feat: relay world snapshot and voxel payloads
Allow world.* methods through the relay, validate their payloads, and track per-session world revisions in the session store.
This commit is contained in:
+182
-1
@@ -4,7 +4,7 @@ import {randomUUID} from 'node:crypto';
|
||||
import test from 'node:test';
|
||||
import type {Socket} from 'socket.io';
|
||||
import {RELAY_METHODS, WORKFLOW_ACTIONS} from '../types.ts';
|
||||
import type {ForwardAck, JsonValue, NodeRelayRequest, RelayClaims, RelayLimits, RelayMethod, RelayRequest, WorkflowRunSnapshot} from '../types.ts';
|
||||
import type {ForwardAck, JsonValue, NodeRelayRequest, RelayClaims, RelayLimits, RelayMethod, RelayRequest, WorkflowRunSnapshot, WorldSnapshot} from '../types.ts';
|
||||
import {create_session_store} from '../runtime/session_store.ts';
|
||||
import {DEFAULT_LIMITS} from '../utils/relay_config.ts';
|
||||
import {encode_token} from '../utils/token_utils.ts';
|
||||
@@ -70,6 +70,187 @@ function code(value: ForwardAck<unknown>, expected: string) {
|
||||
const control = () => ({command_id: randomUUID(), context_generation: randomUUID(), action: 'run_once', workflow_id: 'a'});
|
||||
const command = (input: ReturnType<typeof control>) => ({command_id: input.command_id, action: input.action, workflow_id: input.workflow_id, state: 'accepted'});
|
||||
|
||||
const world = (): WorldSnapshot => ({world_generation: randomUUID(), context_generation: randomUUID(), stream_id: randomUUID(), watch_id: randomUUID(),
|
||||
version: '1.21.1', dimension: 'minecraft:overworld', min_y: -64, height: 384, center: {x: 0, z: 0},
|
||||
position: {x: 0, y: 64, z: 0, yaw: 0}, chunks: [], loaded: [] as Array<{x: number; z: number; revision: string}>, partial: true});
|
||||
|
||||
test('mock lifecycle status pushes require snapshot permission and do not require log subscriptions', async t => {
|
||||
for (const [web_permissions, node_permissions] of [
|
||||
[['bot.snapshot'], ['bot.snapshot']], [['bot.logs', 'bot.subscribe'], ['bot.snapshot']],
|
||||
[['bot.snapshot'], ['bot.logs']],
|
||||
] as RelayMethod[][][]) {
|
||||
const f = await fixture(t, {}, web_permissions, node_permissions);
|
||||
const received: unknown[] = [];
|
||||
f.web.on('bot_event', value => received.push(value));
|
||||
const base = {forward_session_id: f.scope.forward_session_id, bot_id: f.scope.bot_id,
|
||||
context_generation: randomUUID(), stream_id: randomUUID(), emitted_at: Date.now(), name: 'status_update'};
|
||||
const events = ['online', 'disconnecting', 'offline'].map((status, index) => ({...base, seq: index + 1,
|
||||
payload: {status, context_exists: true}}));
|
||||
events.push({...base, context_generation: null, seq: 4, payload: {status: 'offline', context_exists: false}});
|
||||
for (const event of events) {
|
||||
if (node_permissions.includes('bot.snapshot')) assert.deepEqual(f.store.event(f.node.socket, event), {accepted: true});
|
||||
else assert.throws(() => f.store.event(f.node.socket, event), {code: 'FORBIDDEN'});
|
||||
}
|
||||
assert.deepEqual(received, web_permissions.includes('bot.snapshot') && node_permissions.includes('bot.snapshot') ? events : []);
|
||||
assert.throws(() => f.store.event(f.web.socket, events[0]), {code: 'FORBIDDEN'});
|
||||
}
|
||||
});
|
||||
|
||||
test('mock lifecycle pushes reject invalid names, payloads, scopes and shared sequence replays', async t => {
|
||||
const f = await fixture(t, {}, ['bot.snapshot']);
|
||||
const event = {forward_session_id: f.scope.forward_session_id, bot_id: f.scope.bot_id,
|
||||
context_generation: randomUUID(), stream_id: randomUUID(), seq: 1, emitted_at: Date.now(),
|
||||
name: 'status_update', payload: {status: 'online', context_exists: true}};
|
||||
for (const invalid of [
|
||||
{...event, name: 'message', payload: {text: 'hi', position: 'chat'}},
|
||||
{...event, name: 'bot_error', payload: {message: 'error'}},
|
||||
{...event, name: 'log', payload: {records: [] as never[]}}, {...event, name: 'arbitrary'},
|
||||
{...event, payload: {status: 'invalid', context_exists: true}},
|
||||
{...event, payload: {status: 'offline', context_exists: 'true'}},
|
||||
{...event, payload: {status: 'online', context_exists: true, token: 'secret'}},
|
||||
{...event, context_generation: null}, {...event, seq: -1}, {...event, stream_id: 'invalid'},
|
||||
{...event, payload: {status: 'offline', context_exists: false}},
|
||||
]) assert.throws(() => f.store.event(f.node.socket, invalid), {code: 'INVALID_REQUEST'});
|
||||
for (const invalid of [{...event, bot_id: f.scope.bot_id + 1}, {...event, forward_session_id: randomUUID()}]) {
|
||||
assert.throws(() => f.store.event(f.node.socket, invalid), {code: 'FORBIDDEN'});
|
||||
}
|
||||
f.store.event(f.node.socket, event);
|
||||
f.store.log(f.node.socket, {...event, seq: 2, name: 'log', payload: {records: []}});
|
||||
for (const seq of [1, 2]) assert.throws(() => f.store.event(f.node.socket, {...event, seq}), {code: 'INVALID_REQUEST'});
|
||||
f.store.info(f.node.socket, {forward_session_id: event.forward_session_id, bot_id: event.bot_id,
|
||||
context_generation: event.context_generation, stream_id: event.stream_id, seq: 3,
|
||||
emitted_at: event.emitted_at, data: {name: 'health', value: 20}});
|
||||
assert.throws(() => f.store.event(f.node.socket, {...event, seq: 3}), {code: 'INVALID_REQUEST'});
|
||||
f.store.event(f.node.socket, {...event, seq: 4});
|
||||
assert.throws(() => f.store.log(f.node.socket, {...event, seq: 4, name: 'log', payload: {records: []}}), {code: 'INVALID_REQUEST'});
|
||||
f.store.event(f.node.socket, {...event, stream_id: randomUUID(), seq: 0});
|
||||
assert.throws(() => f.store.event(f.node.socket, {...event, seq: 5}), {code: 'RESYNC_REQUIRED'});
|
||||
});
|
||||
|
||||
test('mock lifecycle fanout checks current Web claims, grants, readiness and expiry', async t => {
|
||||
const f = await fixture(t, {}, ['bot.snapshot', 'bot.logs']);
|
||||
const received: unknown[] = [];
|
||||
const event = {forward_session_id: f.scope.forward_session_id, bot_id: f.scope.bot_id,
|
||||
context_generation: null as string | null, stream_id: randomUUID(), seq: 1, emitted_at: Date.now(),
|
||||
name: 'status_update', payload: {status: 'offline', context_exists: false}};
|
||||
const limited = new MockSocket();
|
||||
await f.join(limited, 'web', ['bot.logs']);
|
||||
limited.on('bot_event', value => received.push(value));
|
||||
f.store.event(f.node.socket, event);
|
||||
assert.deepEqual(received, []);
|
||||
const allowed = new MockSocket();
|
||||
await f.join(allowed, 'web', ['bot.snapshot']);
|
||||
allowed.on('bot_event', value => received.push(value));
|
||||
f.store.event(f.node.socket, {...event, seq: 2});
|
||||
assert.equal(received.length, 1);
|
||||
f.store.revoke_grant({forward_session_id: f.scope.forward_session_id, grant_id: f.grant_id, reason: 'revoked'});
|
||||
f.store.event(f.node.socket, {...event, seq: 3});
|
||||
assert.equal(received.length, 1);
|
||||
const replacement = new MockSocket();
|
||||
await f.join(replacement, 'node', ['bot.snapshot']);
|
||||
assert.throws(() => f.store.event(f.node.socket, {...event, seq: 4}), {code: 'UNAUTHORIZED'});
|
||||
assert.throws(() => f.store.event(replacement.socket, event), {code: 'NODE_OFFLINE'});
|
||||
f.store.node_ready(replacement.socket, {forward_session_id: f.scope.forward_session_id});
|
||||
t.mock.timers.enable({apis: ['setTimeout', 'Date'], now: Date.now()});
|
||||
t.mock.timers.tick(50_001);
|
||||
assert.throws(() => f.store.event(replacement.socket, event), {code: 'UNAUTHORIZED'});
|
||||
t.mock.timers.reset();
|
||||
});
|
||||
|
||||
test('mock world RPCs use snapshot permission on web grants and Node tokens', async t => {
|
||||
for (const [web, node] of [
|
||||
[['bot.snapshot'], ['bot.snapshot']], [['bot.logs'], ['bot.snapshot']], [['bot.snapshot'], ['bot.logs']],
|
||||
] as RelayMethod[][][]) {
|
||||
const f = await fixture(t, {}, web, node);
|
||||
f.store.set_control_available(false);
|
||||
for (const [method, payload] of [['world.snapshot', {radius: 1, known: []}], ['world.unwatch', {watch_id: randomUUID()}]] as const) {
|
||||
const data = method === 'world.snapshot' ? world() : {released: true};
|
||||
f.node.respond = () => success(data);
|
||||
const result = await f.request(method, payload);
|
||||
if (web.includes('bot.snapshot') && node.includes('bot.snapshot')) {
|
||||
assert.deepEqual(result, success(data));
|
||||
const forwarded = f.node.requests.at(-1)!;
|
||||
assert.equal(forwarded.method, method);
|
||||
assert.deepEqual(forwarded.payload, payload);
|
||||
assert.equal(forwarded.forward_session_id, f.scope.forward_session_id);
|
||||
assert.notEqual(forwarded.correlation_id, forwarded.request_id);
|
||||
assert.ok(forwarded.deadline_at > Date.now());
|
||||
} else {
|
||||
code(result, 'FORBIDDEN');
|
||||
assert.equal(f.node.requests.length, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('mock world reads refresh watch results and validate ACKs against request radius', async t => {
|
||||
const f = await fixture(t);
|
||||
const reads = [['world.snapshot', {radius: 1, known: []}], ['world.unwatch', {watch_id: randomUUID()}]] as const;
|
||||
for (const [method, payload] of reads) {
|
||||
const before = f.node.requests.length;
|
||||
const id = randomUUID();
|
||||
let count = 0;
|
||||
f.node.respond = () => {count++; return success(method === 'world.snapshot' ? world() : {released: true});};
|
||||
const first = await f.request(method, payload, id);
|
||||
const second = await f.request(method, payload, id);
|
||||
assert.equal(first.status, 'success');
|
||||
assert.equal(second.status, 'success');
|
||||
assert.equal(count, 2);
|
||||
if (method === 'world.snapshot') assert.notDeepEqual(first, second);
|
||||
f.node.respond = () => error_ack({});
|
||||
code(await f.request(method, payload, id), 'INTERNAL_ERROR');
|
||||
assert.equal(f.node.requests.length - before, 3);
|
||||
const mismatched = method === 'world.snapshot' ? {...payload, radius: 2} : {watch_id: randomUUID()};
|
||||
code(await f.request(method, mismatched, id), 'INVALID_REQUEST');
|
||||
}
|
||||
f.node.respond = () => success({...world(), loaded: [{x: 2, z: 0, revision: randomUUID()}]});
|
||||
code(await f.request('world.snapshot', {radius: 1, known: []}), 'INVALID_REQUEST');
|
||||
assert.equal((await f.request('world.snapshot', {radius: 2, known: []})).status, 'success');
|
||||
const replacement = new MockSocket();
|
||||
const id = randomUUID(); const payload = {radius: 1, known: [] as unknown[]};
|
||||
f.node.respond = () => success(world());
|
||||
assert.equal((await f.request('world.snapshot', payload, id)).status, 'success');
|
||||
await f.join(replacement, 'node', ['bot.logs']);
|
||||
f.store.node_ready(replacement.socket, {forward_session_id: f.scope.forward_session_id});
|
||||
code(await f.request('world.snapshot', payload, id), 'FORBIDDEN');
|
||||
assert.equal(replacement.requests.length, 0);
|
||||
});
|
||||
|
||||
test('mock world pending duplicates do not dispatch twice and completed reads retry after errors', async t => {
|
||||
const f = await fixture(t);
|
||||
for (const [method, payload] of [['world.snapshot', {radius: 1, known: []}], ['world.unwatch', {watch_id: randomUUID()}]] as const) {
|
||||
const id = randomUUID();
|
||||
let release!: (value: unknown) => void;
|
||||
f.node.respond = () => new Promise(resolve => {release = resolve;});
|
||||
const pending = f.request(method, payload, id);
|
||||
await Promise.resolve();
|
||||
const before = f.node.requests.length;
|
||||
code(await f.request(method, payload, id), 'RATE_LIMITED');
|
||||
assert.equal(f.node.requests.length, before);
|
||||
release(success(method === 'world.snapshot' ? world() : {released: true}));
|
||||
assert.equal((await pending).status, 'success');
|
||||
f.node.respond = () => error_ack(new Error('private'));
|
||||
code(await f.request(method, payload, id), 'INTERNAL_ERROR');
|
||||
f.node.respond = () => success(method === 'world.snapshot' ? world() : {released: true});
|
||||
assert.equal((await f.request(method, payload, id)).status, 'success');
|
||||
assert.equal(f.node.requests.length - before, 2);
|
||||
}
|
||||
});
|
||||
|
||||
test('mock world_preview hints fan out on the existing scoped info channel', async t => {
|
||||
for (const permissions of [['bot.snapshot'], ['bot.logs']] as RelayMethod[][]) {
|
||||
const f = await fixture(t, {}, permissions);
|
||||
const received: unknown[] = [];
|
||||
f.web.on('info_update', value => received.push(value));
|
||||
const update = {forward_session_id: f.scope.forward_session_id, bot_id: f.scope.bot_id,
|
||||
context_generation: randomUUID(), stream_id: randomUUID(), seq: 1, emitted_at: Date.now(),
|
||||
data: {name: 'world_preview', value: {world_generation: randomUUID()}}};
|
||||
assert.deepEqual(f.store.info(f.node.socket, update), {accepted: true});
|
||||
assert.deepEqual(received, permissions.includes('bot.snapshot') ? [update] : []);
|
||||
assert.throws(() => f.store.info(f.node.socket, {...update, bot_id: f.scope.bot_id + 1}));
|
||||
}
|
||||
});
|
||||
|
||||
test('mock relay forwards all workflow RPCs with private correlated deadlines and safe ACKs', async t => {
|
||||
const f = await fixture(t);
|
||||
const input = control(); const run_id = randomUUID();
|
||||
|
||||
Reference in New Issue
Block a user