757 lines
52 KiB
TypeScript
757 lines
52 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import {createCipheriv, createHash} from 'node:crypto';
|
|
import {test} from 'node:test';
|
|
import {RELAY_METHODS, WORKFLOW_ACTIONS, WORKFLOW_METHODS} from '../types.ts';
|
|
import type {BotEvent, JsonValue, RelayClaims, RelayLimits, WorkflowRunSnapshot, WorkflowRuntimeState} from '../types.ts';
|
|
import {decode_token, encode_token, verify_token} from '../utils/token_utils.ts';
|
|
import {DEFAULT_LIMITS} from '../utils/relay_config.ts';
|
|
import {
|
|
RelayError, check_permissions, check_size, error_ack, fail, is_record, is_uuid,
|
|
success, validate_event, validate_grant, validate_info_update, validate_node_ack, validate_open, validate_request, validate_scope,
|
|
} from '../utils/relay_validation.ts';
|
|
|
|
const secret = 'relay-test-key-not-a-production-secret';
|
|
const uuid = 'a89acd9a-0ab3-44ac-812e-e221a5b915e0';
|
|
const other_uuid = '45264c09-7529-478f-b3ef-6a84bec8c1a7';
|
|
const now = 1_800_000_000_000;
|
|
const limits: RelayLimits = {
|
|
auth_timeout_ms: 10_000, close_timeout_ms: 5_000, rpc_timeout_ms: 5_000, unused_timeout_ms: 60_000,
|
|
idle_timeout_ms: 30_000, max_token_age_ms: 300_000, join_window_ms: 60_000,
|
|
clock_skew_ms: 1_000, max_lease_ms: 300_000, max_token_bytes: 4096,
|
|
max_payload_bytes: 256 * 1024, max_chat_length: 256, max_connections: 100,
|
|
max_sessions: 100, max_grants_per_session: 100, max_pending_per_web: 8,
|
|
max_pending_total: 100, requests_per_second: 20, events_per_second: 100,
|
|
max_dedupe_entries: 100, dedupe_ttl_ms: 30_000, max_buffered_packets: 100,
|
|
};
|
|
|
|
function claims(overrides: Record<string, unknown> = {}): RelayClaims {
|
|
return {
|
|
v: 1, role: 'web', forward_id: 0, forward_session_id: uuid,
|
|
node_session_id: 'mZAb09_-SocketIOmainID', node_id: 1, bot_id: 2,
|
|
user_id: 3, grant_id: other_uuid, permissions: ['bot.snapshot', 'bot.logs'],
|
|
issued_at: now, join_before: now + 60_000, expires_at: now + 300_000,
|
|
jti: other_uuid, ...overrides,
|
|
} as RelayClaims;
|
|
}
|
|
|
|
function rejected(action: () => unknown, code = 'INVALID_REQUEST'): void {
|
|
assert.throws(action, (error: unknown) => error instanceof RelayError && error.code === code);
|
|
}
|
|
|
|
function verify(value: unknown, at = now, settings = limits): RelayClaims {
|
|
return verify_token(secret, encode_token(secret, value), 0, settings, at);
|
|
}
|
|
|
|
function request(method: string, payload: unknown): unknown {
|
|
return {request_id: uuid, method, payload};
|
|
}
|
|
|
|
function record(): Record<string, unknown> {
|
|
return {id: uuid, timestamp: now, context_generation: null, seq: 1,
|
|
segments: [{message: 'hello', font_color: '#ffffff', font_style: ['normal', 'bold']}]};
|
|
}
|
|
|
|
function event(name: string, payload: unknown): unknown {
|
|
return {forward_session_id: uuid, bot_id: 2, context_generation: null,
|
|
stream_id: other_uuid, seq: 1, emitted_at: now, name, payload};
|
|
}
|
|
|
|
test('AES-256-GCM wire format remains IV[12] + tag[16] + ciphertext', () => {
|
|
const value = claims();
|
|
const iv = Buffer.from('000102030405060708090a0b', 'hex');
|
|
const cipher = createCipheriv('aes-256-gcm', createHash('sha256').update(secret).digest(), iv);
|
|
const ciphertext = Buffer.concat([cipher.update(JSON.stringify(value)), cipher.final()]);
|
|
const token = Buffer.concat([iv, cipher.getAuthTag(), ciphertext]).toString('base64url');
|
|
assert.equal(token, 'AAECAwQFBgcICQoLKReCzFKlEY6g42nAQLV9_x0ByGStIbnU7jVnJBA372eKB2zodLxLE9mBUS1agWpMmTc7swZYqNfSWy53I7FUGk6-ik0it6dgU_Sr5B4xex5F89Dl89k2hg2wkenWZpeIksBqjx2kPX2vj1o05iSueFxOXLopUmDFt7SWUFLzsQUdE5Q1nyTH7cWi71k5S5Fmc-Fo9qetCUp3QDyMPaD5Bn4sTrmUoSztp1AHREowEAMFMNAhjQ5Y5-aVDg08biMmw9X2KbBMukqomk5t-cHk0-l6r2XudPdPxH6B4YFhfE8iqIPnekUXz-GyCwuOODvdPajUKQs48s13OCVyhW5WzvxsoimN1KrM0ac0S1ybB9aRvkXSbkDHuEfy9Q-NCcddJacIKjIpFqeIrRV0EJAdCaMirNPIer_5F4YvmJB9H5UKNGSg4mZ-DYkvmXsvYAleGpSJzIpwjWG_pXb8dbjltryrQQ5HbXSIvs_8GBVGZdROTmwXCOrI_ZS8azkFA29zrHRBHiz-H3Rs0bv0GUgfZPoz_eJWxyA');
|
|
assert.deepEqual(decode_token(secret, token), value);
|
|
assert.deepEqual(verify_token(secret, token, 0, limits, now), value);
|
|
assert.deepEqual(decode_token(secret, encode_token(secret, value)), value);
|
|
assert.notEqual(encode_token(secret, value), encode_token(secret, value));
|
|
});
|
|
|
|
test('tokens enforce canonical base64url, byte limit, authentication and audience', () => {
|
|
const token = encode_token(secret, claims());
|
|
for (const input of ['', token + '=', token + '\n', ' ' + token, token + '+', 'A', '_'.repeat(40)]) {
|
|
rejected(() => verify_token(secret, input, 0, limits, now), 'UNAUTHORIZED');
|
|
}
|
|
const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
|
|
// GCM token ends in unused base64 bits: accepting an alias would allow multiple wire IDs.
|
|
let short_token = encode_token(secret, {a: 1});
|
|
if (short_token.length % 4 === 0) short_token = encode_token(secret, {a: 12});
|
|
const last_index = alphabet.indexOf(short_token.at(-1)!);
|
|
const alias = short_token.slice(0, -1) + alphabet[last_index + 1];
|
|
assert.deepEqual(Buffer.from(alias, 'base64url'), Buffer.from(short_token, 'base64url'));
|
|
assert.throws(() => decode_token(secret, alias));
|
|
const raw = Buffer.from(token, 'base64url');
|
|
for (const offset of [0, 12, 28, raw.length - 1]) {
|
|
const modified = Buffer.from(raw);
|
|
modified[offset] ^= 1;
|
|
rejected(() => verify_token(secret, modified.toString('base64url'), 0, limits, now), 'UNAUTHORIZED');
|
|
}
|
|
rejected(() => verify_token('wrong-secret', token, 0, limits, now), 'UNAUTHORIZED');
|
|
rejected(() => verify_token(secret, token, 1, limits, now), 'UNAUTHORIZED');
|
|
rejected(() => verify_token(secret, token, 0, {...limits, max_token_bytes: token.length - 1}, now), 'UNAUTHORIZED');
|
|
assert.deepEqual(verify_token(secret, token, 0, {...limits, max_token_bytes: token.length}, now), claims());
|
|
});
|
|
|
|
test('authenticated plaintext must be valid UTF-8 JSON of exactly typed claims', () => {
|
|
for (const value of [null, [], 'claims', 1, {}, {...claims(), v: '1'}, {...claims(), password: 'sensitive'},
|
|
{...claims(), role: 'admin'}, {...claims(), permissions: ['*']},
|
|
{...claims(), permissions: ['bot.chat', 'bot.chat']}, {...claims(), permissions: null}]) {
|
|
rejected(() => verify(value), 'UNAUTHORIZED');
|
|
}
|
|
for (const key of Object.keys(claims())) {
|
|
const missing = {...claims()} as Record<string, unknown>;
|
|
delete missing[key];
|
|
rejected(() => verify(missing), 'UNAUTHORIZED');
|
|
}
|
|
const cipher = createCipheriv('aes-256-gcm', createHash('sha256').update(secret).digest(), Buffer.alloc(12));
|
|
const ciphertext = Buffer.concat([cipher.update(Buffer.from([0x22, 0xff, 0x22])), cipher.final()]);
|
|
const token = Buffer.concat([Buffer.alloc(12), cipher.getAuthTag(), ciphertext]).toString('base64url');
|
|
rejected(() => verify_token(secret, token, 0, limits, now), 'UNAUTHORIZED');
|
|
});
|
|
|
|
test('IDs are safe integers, protocol IDs are UUIDs, and Main socket session IDs are bounded strings', () => {
|
|
for (const field of ['forward_id', 'node_id', 'bot_id', 'user_id']) {
|
|
for (const value of ['1', -1, 1.5, Number.MAX_SAFE_INTEGER + 1, null]) {
|
|
rejected(() => verify(claims({[field]: value})), 'UNAUTHORIZED');
|
|
}
|
|
}
|
|
for (const field of ['forward_session_id', 'grant_id', 'jti']) {
|
|
rejected(() => verify(claims({[field]: 'not-a-uuid'})), 'UNAUTHORIZED');
|
|
}
|
|
for (const value of ['', ' ', 'x'.repeat(257), '\u754c'.repeat(86), null, 123]) {
|
|
rejected(() => verify(claims({node_session_id: value})), 'UNAUTHORIZED');
|
|
}
|
|
assert.equal(verify(claims({node_session_id: 'x'.repeat(256)})).node_session_id.length, 256);
|
|
assert.equal(verify(claims({node_id: Number.MAX_SAFE_INTEGER})).node_id, Number.MAX_SAFE_INTEGER);
|
|
});
|
|
|
|
test('node tokens exclude web identity; web tokens require both grant and positive user ID', () => {
|
|
const node = {...claims(), role: 'node'} as Record<string, unknown>;
|
|
delete node.user_id;
|
|
delete node.grant_id;
|
|
assert.equal(verify(node).role, 'node');
|
|
for (const extras of [{user_id: 3}, {grant_id: uuid}, {user_id: null}, {grant_id: null}]) {
|
|
rejected(() => verify({...node, ...extras}), 'UNAUTHORIZED');
|
|
}
|
|
for (const extras of [{user_id: 0}, {user_id: null}, {grant_id: null}, {grant_id: ''}]) {
|
|
rejected(() => verify(claims(extras)), 'UNAUTHORIZED');
|
|
}
|
|
assert.deepEqual(verify(claims({permissions: []})).permissions, []);
|
|
});
|
|
|
|
test('time ordering, TTL, join window and finite clock skew are enforced at boundaries', () => {
|
|
for (const times of [
|
|
{issued_at: '1800000000000'}, {issued_at: -1}, {issued_at: now + 0.5},
|
|
{join_before: now}, {join_before: now - 1}, {join_before: now + 60_001},
|
|
{expires_at: now + 300_001}, {expires_at: now + 10},
|
|
{issued_at: now + 1001, join_before: now + 2000, expires_at: now + 3000},
|
|
]) rejected(() => verify(claims(times)), 'UNAUTHORIZED');
|
|
assert.equal(verify(claims(), now + 60_999).role, 'web');
|
|
rejected(() => verify(claims(), now + 61_000), 'TOKEN_EXPIRED');
|
|
const short = claims({join_before: now + 1000, expires_at: now + 1000});
|
|
assert.equal(verify(short, now + 1999).role, 'web');
|
|
rejected(() => verify(short, now + 2000), 'TOKEN_EXPIRED');
|
|
rejected(() => verify(claims(), now + 60_000, {...limits, clock_skew_ms: 0}), 'TOKEN_EXPIRED');
|
|
assert.equal(verify(claims(), now - 1000).role, 'web');
|
|
rejected(() => verify(claims(), now - 1001), 'UNAUTHORIZED');
|
|
for (const clock of [NaN, Infinity, -1, 1.5]) {
|
|
rejected(() => verify(claims(), clock), 'UNAUTHORIZED');
|
|
rejected(() => verify(claims(), now, {...limits, clock_skew_ms: clock}), 'UNAUTHORIZED');
|
|
}
|
|
for (const option of ['max_token_bytes', 'max_token_age_ms', 'join_window_ms'] as const) {
|
|
rejected(() => verify(claims(), now, {...limits, [option]: 0}), 'UNAUTHORIZED');
|
|
}
|
|
});
|
|
|
|
test('errors are standard ACKs and unknown errors do not expose internal secrets', () => {
|
|
assert.throws(() => fail('TIMEOUT', 'RPC timed out', true), RelayError);
|
|
assert.deepEqual(error_ack(new RelayError('TIMEOUT', 'RPC timed out', true)), {
|
|
status: 'error', data: {code: 'TIMEOUT', message: 'RPC timed out', retryable: true},
|
|
});
|
|
for (const error of [new Error('password=secret'), {code: 'TIMEOUT', message: 'secret'}, null]) {
|
|
assert.deepEqual(error_ack(error), {
|
|
status: 'error', data: {code: 'INTERNAL_ERROR', message: 'Internal relay error', retryable: false},
|
|
});
|
|
}
|
|
assert.deepEqual(success({accepted: true}), {status: 'success', data: {accepted: true}});
|
|
assert.equal(is_record([]), false);
|
|
assert.equal(is_record(new Date()), false);
|
|
assert.equal(is_record(Object.create(null)), true);
|
|
assert.equal(is_uuid(uuid), true);
|
|
assert.equal(is_uuid('not-a-uuid'), false);
|
|
});
|
|
|
|
test('payload size uses UTF-8 JSON bytes and limits traversal without invoking accessors', () => {
|
|
const value = {text: '\u754c\n'};
|
|
const size = Buffer.byteLength(JSON.stringify(value));
|
|
check_size(value, size);
|
|
rejected(() => check_size(value, size - 1));
|
|
const cyclic: Record<string, unknown> = {};
|
|
cyclic.self = cyclic;
|
|
let nested: unknown = 'leaf';
|
|
for (let i = 0; i < 17; i++) nested = {nested};
|
|
for (const invalid of [cyclic, nested, Array(4097).fill(0), {value: undefined}, {value: NaN},
|
|
{value: Infinity}, {value: 1n}, {value: () => 1}, Array(2), new Date()]) {
|
|
rejected(() => check_size(invalid, limits.max_payload_bytes));
|
|
}
|
|
let calls = 0;
|
|
rejected(() => check_size({get secret() { calls++; return 'secret'; }}, 4096));
|
|
assert.equal(calls, 0);
|
|
for (const bad_limit of [0, -1, Infinity, NaN]) rejected(() => check_size({}, bad_limit));
|
|
});
|
|
|
|
test('large segmented history fits default limits while bytes and complexity remain bounded', () => {
|
|
const records = Array.from({length: 20}, (_, index) => ({...record(),
|
|
id: `a89acd9a-0ab3-44ac-812e-${index.toString(16).padStart(12, '0')}`, seq: index + 1,
|
|
segments: Array.from({length: 32}, () => ({message: '\u754c'.repeat(1024),
|
|
font_color: '#ffffff', font_style: ['normal']}))}));
|
|
const result = success({stream_id: uuid, seq: 20, records, truncated: false});
|
|
const size = Buffer.byteLength(JSON.stringify(result));
|
|
assert.ok(size > 1024 * 1024);
|
|
assert.ok(size < DEFAULT_LIMITS.max_payload_bytes);
|
|
validate_node_ack('get_log_history', result, 2, DEFAULT_LIMITS);
|
|
validate_node_ack('bot.logs', result, 2, DEFAULT_LIMITS);
|
|
rejected(() => validate_node_ack('get_log_history', result, 2,
|
|
{...DEFAULT_LIMITS, max_payload_bytes: 262_144}));
|
|
check_size('x'.repeat(DEFAULT_LIMITS.max_payload_bytes - 2), DEFAULT_LIMITS.max_payload_bytes);
|
|
rejected(() => check_size('x'.repeat(DEFAULT_LIMITS.max_payload_bytes - 1), DEFAULT_LIMITS.max_payload_bytes));
|
|
const many_nodes = Array.from({length: 1024}, () => Array(64).fill(0));
|
|
rejected(() => check_size(many_nodes, DEFAULT_LIMITS.max_payload_bytes));
|
|
});
|
|
|
|
test('requests whitelist every method and reject identity or sensitive payload fields', () => {
|
|
for (const [method, payload] of [
|
|
['bot.snapshot', {}], ['bot.logs', {limit: 1}],
|
|
['bot.logs', {limit: 200, stream_id: uuid, after_seq: Number.MAX_SAFE_INTEGER}],
|
|
['bot.subscribe', {events: ['status_update', 'message']}], ['bot.unsubscribe', {events: []}],
|
|
['bot.chat', {message: 'hello'}],
|
|
] as const) validate_request(request(method, payload), limits);
|
|
for (const [method, payload] of [
|
|
['bot.delete', {}], ['bot.snapshot', null], ['bot.snapshot', {token: 'secret'}],
|
|
['bot.logs', {limit: 0}], ['bot.logs', {limit: 201}], ['bot.logs', {limit: '1'}],
|
|
['bot.logs', {limit: 1, after_seq: 0}], ['bot.logs', {limit: 1, stream_id: 'stream'}],
|
|
['bot.logs', {limit: 1, stream_id: uuid, after_seq: Number.MAX_SAFE_INTEGER + 1}],
|
|
['bot.subscribe', {events: ['log', 'log']}], ['bot.subscribe', {events: ['error']}],
|
|
['bot.chat', {message: ' '}], ['bot.chat', {message: 'x'.repeat(257)}],
|
|
['bot.chat', {message: 'hello', password: 'secret'}],
|
|
] as Array<[string, unknown]>) rejected(() => validate_request(request(method, payload), limits));
|
|
rejected(() => validate_request({...request('bot.snapshot', {}) as object, bot_id: 99}, limits));
|
|
rejected(() => validate_request({request_id: 'id', method: 'bot.snapshot', payload: {}}, limits));
|
|
rejected(() => validate_request(request('bot.chat', {message: '\u754c'.repeat(20)}), {...limits, max_payload_bytes: 100}));
|
|
check_permissions(['bot.chat']);
|
|
rejected(() => check_permissions(['bot.chat', 'bot.chat']));
|
|
rejected(() => check_permissions(['unknown']));
|
|
rejected(() => check_permissions(Array(1)));
|
|
});
|
|
|
|
test('all six bot statuses and typed event DTOs are accepted, unexpected fields are rejected', () => {
|
|
for (const status of ['offline', 'ready', 'connecting', 'online', 'disconnecting', 'reconnecting']) {
|
|
validate_event({...event('status_update', {status, context_exists: true}) as BotEvent,
|
|
context_generation: uuid}, limits);
|
|
}
|
|
validate_event(event('status_update', {status: 'offline', context_exists: false}), limits);
|
|
rejected(() => validate_event(event('status_update', {status: 'online', context_exists: false}), limits));
|
|
rejected(() => validate_event(event('status_update', {status: 'offline', context_exists: true}), limits));
|
|
for (const [name, payload] of [
|
|
['log', {records: [record()]}], ['message', {text: 'hello', position: 'chat', json: {extra: [{text: 'hello'}]}}],
|
|
['bot_error', {code: 'OFFLINE', message: 'not online'}], ['bot_error', {message: 'error'}],
|
|
] as Array<[string, unknown]>) validate_event(event(name, payload), limits);
|
|
for (const [name, payload] of [
|
|
['error', {message: 'error'}], ['status_update', {status: 'unknown', context_exists: true}],
|
|
['status_update', {status: 'online', context_exists: 'true'}],
|
|
['message', {text: 'hello', position: 'chat', token: 'secret'}],
|
|
['bot_error', {message: 'error', stack: 'sensitive stack'}],
|
|
['log', {records: [{...record(), password: 'secret'}]}],
|
|
['log', {records: [{...record(), segments: [{message: 'hi', font_color: '#fff', font_style: ['script']}]}]}],
|
|
] as Array<[string, unknown]>) rejected(() => validate_event(event(name, payload), limits));
|
|
for (const seq of [-1, 0.5, Number.MAX_SAFE_INTEGER + 1]) {
|
|
rejected(() => validate_event({...event('log', {records: []}) as BotEvent, seq}, limits));
|
|
}
|
|
rejected(() => validate_event({...event('log', {records: []}) as BotEvent, key: 'secret'}, limits));
|
|
});
|
|
|
|
test('execute_function validates exact payloads, bounded JSON args, boolean ACKs and permissions', () => {
|
|
const payload = {function: 'movement/navigation', name: 'go_to', args: [1, 'target', true, null, {position: [1, 2, 3]}]};
|
|
validate_request(request('execute_function', payload), limits);
|
|
validate_request(request('execute_function', {function: '', name: '', args: []}), limits);
|
|
for (const invalid of [null, [], {}, {...payload, category: 'movement'}, {...payload, function: []},
|
|
{...payload, name: 1}, {...payload, args: {}}, {name: 'go_to', args: []},
|
|
{function: 'movement', args: []}, {function: 'movement', name: 'go_to'}]) {
|
|
rejected(() => validate_request(request('execute_function', invalid), limits));
|
|
}
|
|
const cyclic: unknown[] = []; cyclic.push(cyclic);
|
|
let deep: unknown = 0;
|
|
for (let i = 0; i < 17; i++) deep = [deep];
|
|
for (const args of [[undefined], [NaN], [Infinity], [1n], [() => true], [new Date()],
|
|
Array(1), cyclic, [deep], Array(4097).fill(0)]) {
|
|
rejected(() => validate_request(request('execute_function', {...payload, args}), limits));
|
|
}
|
|
const value = request('execute_function', payload);
|
|
const bytes = Buffer.byteLength(JSON.stringify(value));
|
|
validate_request(value, {...limits, max_payload_bytes: bytes});
|
|
rejected(() => validate_request(value, {...limits, max_payload_bytes: bytes - 1}));
|
|
for (const data of [true, false]) validate_node_ack('execute_function', success(data), 2, limits);
|
|
for (const data of [null, 0, 1, 'true', [], {}, {accepted: true}]) {
|
|
rejected(() => validate_node_ack('execute_function', success(data), 2, limits));
|
|
}
|
|
validate_node_ack('execute_function', error_ack(new RelayError('NO_CONTEXT', 'No context')), 2, limits);
|
|
rejected(() => validate_node_ack('execute_function', {status: 'success', data: true, extra: true}, 2, limits));
|
|
check_permissions(['execute_function']);
|
|
rejected(() => check_permissions(['execute_function', 'execute_function']));
|
|
assert.deepEqual(verify(claims({permissions: ['execute_function']})).permissions, ['execute_function']);
|
|
});
|
|
|
|
test('tab_complete validates exact bounded completion DTOs without adding token permissions', () => {
|
|
for (const text of ['', ' ', '/help ', 'x'.repeat(256), '\u754c'.repeat(256)]) {
|
|
validate_request(request('tab_complete', {text}), limits);
|
|
}
|
|
for (const payload of [null, {}, {text: 1}, {text: 'x'.repeat(257)}, {text: 'a\rb'},
|
|
{text: 'a\nb'}, {text: 'a\0b'}, {text: '', extra: true}, {message: '/help'}]) {
|
|
rejected(() => validate_request(request('tab_complete', payload), limits));
|
|
}
|
|
for (const matches of [[], [' '], ['x'.repeat(256), '\u754c'.repeat(256)],
|
|
Array.from({length: 100}, (_, index) => String(index))]) {
|
|
validate_node_ack('tab_complete', success({matches, start: 0, length: 0}), 2, limits);
|
|
}
|
|
for (const data of [null, {}, {matches: 'help'}, {matches: [1]}, {matches: ['']},
|
|
{matches: ['help', 'help']}, {matches: ['x'.repeat(257)]},
|
|
{matches: Array.from({length: 101}, (_, index) => String(index))}, {matches: [], extra: true}]) {
|
|
rejected(() => validate_node_ack('tab_complete', success(data === null ? null : {start: 0, length: 0, ...data}), 2, limits));
|
|
}
|
|
for (const range of [{start: 0, length: 256}, {start: 256, length: 0}, {start: 128, length: 128}]) {
|
|
validate_node_ack('tab_complete', success({matches: [], ...range}), 2, limits);
|
|
}
|
|
for (const data of [{matches: []}, {matches: [], start: 0}, {matches: [], length: 0}] as unknown[]) {
|
|
rejected(() => validate_node_ack('tab_complete', success(data), 2, limits));
|
|
}
|
|
for (const value of [-1, 0.5, 257, Number.MAX_SAFE_INTEGER + 1, NaN, Infinity, '0', null]) {
|
|
for (const field of ['start', 'length']) {
|
|
rejected(() => validate_node_ack('tab_complete', success({matches: [], start: 0, length: 0, [field]: value}), 2, limits));
|
|
}
|
|
}
|
|
rejected(() => validate_node_ack('tab_complete', success({matches: [], start: 256, length: 1}), 2, limits));
|
|
validate_node_ack('tab_complete', error_ack(new RelayError('BOT_NOT_ONLINE', 'Offline')), 2, limits);
|
|
check_permissions(['bot.chat']);
|
|
rejected(() => check_permissions(['tab_complete']));
|
|
rejected(() => verify(claims({permissions: ['tab_complete']})), 'UNAUTHORIZED');
|
|
});
|
|
|
|
test('log metadata is accepted for events and history with exact bounded payloads', () => {
|
|
const base = record();
|
|
const segment = {message: 'hello', font_color: '#ffffff', font_style: ['normal'], hoverEvent: {action: 'show_text', value: 'tooltip', segments: [{message: 'tooltip', font_color: '#55ffff', font_style: ['bold']}]},
|
|
clickEvent: {action: 'suggest_command', value: '/help'}, insertion: 'Alex'};
|
|
const records = [{...base, segments: [segment]}];
|
|
validate_event(event('log', {records}), limits);
|
|
validate_node_ack('bot.logs', success({stream_id: uuid, seq: 1, records, truncated: false}), 2, limits);
|
|
for (const metadata of [
|
|
{hoverEvent: {action: 'unknown', value: 'text'}},
|
|
{clickEvent: {action: 'run_command', value: '/help', secret: 'extra'}},
|
|
{clickEvent: {action: 'run_command', value: 42}},
|
|
{insertion: 'x'.repeat(4097)},
|
|
]) rejected(() => validate_event(event('log', {records: [{...base, segments: [{...segment, ...metadata}]}]}), limits));
|
|
});
|
|
|
|
test('get_context_info validates empty requests and exact bounded info arrays without new permissions', () => {
|
|
validate_request(request('get_context_info', {}), limits);
|
|
for (const payload of [null, [], {name: 'health'}, {token: 'secret'}] as unknown[]) {
|
|
rejected(() => validate_request(request('get_context_info', payload), limits));
|
|
}
|
|
const info = {name: 'health_0-HP', i18n: {lang: 'en', name: 'Health', description: ''}, value: {hp: 20}};
|
|
for (const data of [[], [info], Array(256).fill(info), [{...info, name: 'a'.repeat(128),
|
|
i18n: {lang: 'a'.repeat(128), name: 'a'.repeat(256), description: 'a'.repeat(4096)}}]]) {
|
|
validate_node_ack('get_context_info', success(data), 2, limits);
|
|
}
|
|
for (const data of [null, {}, Array(257).fill(info), [{...info, extra: true}],
|
|
[{...info, i18n: {...info.i18n, extra: true}}], [{name: 'health', value: 1}],
|
|
[{...info, i18n: {...info.i18n, fields: {x: {lang: 'en', name: 'X'}}}}],
|
|
[{...info, i18n: {...info.i18n, values: []}}],
|
|
[{...info, i18n: {lang: 'en', name: 'Health'}}]]) {
|
|
rejected(() => validate_node_ack('get_context_info', success(data), 2, limits));
|
|
}
|
|
for (const name of ['', 'a.b', 'a b', '\u754c', 'a'.repeat(129), null, 1]) {
|
|
rejected(() => validate_node_ack('get_context_info', success([{...info, name}]), 2, limits));
|
|
}
|
|
for (const [field, length] of [['lang', 128], ['name', 256], ['description', 4096]] as const) {
|
|
for (const value of ['a'.repeat(length + 1), '\u754c'.repeat(Math.floor(length / 3) + 1), null, 1]) {
|
|
rejected(() => validate_node_ack('get_context_info', success([{...info, i18n: {...info.i18n, [field]: value}}]), 2, limits));
|
|
}
|
|
}
|
|
validate_node_ack('get_context_info', error_ack(new RelayError('BOT_NOT_ONLINE', 'Offline')), 2, limits);
|
|
rejected(() => check_permissions(['get_context_info']));
|
|
rejected(() => verify(claims({permissions: ['get_context_info']})), 'UNAUTHORIZED');
|
|
});
|
|
|
|
test('info_update uses an exact envelope with non-null context and JSON-safe bounded values', () => {
|
|
const update = {forward_session_id: uuid, bot_id: 2, context_generation: uuid, stream_id: other_uuid,
|
|
seq: 1, emitted_at: now, data: {name: 'health', value: null as unknown}};
|
|
const info = {name: 'health', i18n: {lang: '', name: '', description: ''}, value: null as unknown};
|
|
for (const value of [null, true, 0, -1.5, '', [1, {nested: ['ok']}], {health: 20}, Object.create(null)]) {
|
|
validate_info_update({...update, data: {...update.data, value}}, limits);
|
|
validate_node_ack('get_context_info', success([{...info, value}]), 2, limits);
|
|
}
|
|
for (const invalid of [{...update, context_generation: null}, {...update, context_generation: ''},
|
|
{...update, name: 'info_update'}, {...update, payload: update.data}, {...update, seq: -1},
|
|
{...update, bot_id: 0}, {...update, emitted_at: 0.5}, {...update, stream_id: 'stream'},
|
|
{...update, forward_session_id: 'session'}, {...update, data: {name: 'health'}},
|
|
{...update, data: {...update.data, i18n: {}}}, {...update, data: {name: 'bad.name', value: 1}},
|
|
{...update, data: {name: 'a'.repeat(129), value: 1}}]) {
|
|
rejected(() => validate_info_update(invalid, limits));
|
|
}
|
|
const cyclic: Record<string, unknown> = {}; cyclic.self = cyclic;
|
|
let nested: unknown = 0;
|
|
for (let index = 0; index < 69; index++) nested = {nested};
|
|
let accessor_calls = 0;
|
|
for (const value of [undefined, NaN, Infinity, 1n, () => 1, new Date(), Array(1), cyclic, nested,
|
|
{get secret() {accessor_calls++; return 1;}}, Array(65_537).fill(0)]) {
|
|
rejected(() => validate_info_update({...update, data: {...update.data, value}}, limits));
|
|
rejected(() => validate_node_ack('get_context_info', success([{...info, value}]), 2, limits));
|
|
}
|
|
assert.equal(accessor_calls, 0);
|
|
const size = Buffer.byteLength(JSON.stringify(update));
|
|
validate_info_update(update, {...limits, max_payload_bytes: size});
|
|
rejected(() => validate_info_update(update, {...limits, max_payload_bytes: size - 1}));
|
|
const result = success([info]);
|
|
const ack_size = Buffer.byteLength(JSON.stringify(result));
|
|
validate_node_ack('get_context_info', result, 2, {...limits, max_payload_bytes: ack_size});
|
|
rejected(() => validate_node_ack('get_context_info', result, 2, {...limits, max_payload_bytes: ack_size - 1}));
|
|
});
|
|
|
|
test('inventory info alone accepts deep NBT and large JSON within dedicated complexity limits', () => {
|
|
const info = {name: 'inventory', i18n: {lang: 'en', name: 'Inventory', description: ''}, value: null as unknown};
|
|
const update = {forward_session_id: uuid, bot_id: 2, context_generation: uuid, stream_id: other_uuid,
|
|
seq: 1, emitted_at: now, data: {name: 'inventory', value: null as unknown}};
|
|
const validate = (value: unknown) => {
|
|
validate_info_update({...update, data: {...update.data, value}}, DEFAULT_LIMITS);
|
|
validate_node_ack('get_context_info', success([{...info, value}]), 2, DEFAULT_LIMITS);
|
|
};
|
|
let nbt: unknown = {text: 'deep'};
|
|
for (let index = 0; index < 40; index++) nbt = {type: 'compound', value: nbt};
|
|
const inventory = {slots: Array.from({length: 46}, (_, slot) => ({slot, nbt, components: '\u754c'.repeat(2048)}))};
|
|
assert.ok(Buffer.byteLength(JSON.stringify(inventory)) > 192 * 1024);
|
|
validate(inventory);
|
|
for (const value of [Array(65_536).fill(0), Object.fromEntries(Array.from({length: 65_536}, (_, index) => [String(index), 0])),
|
|
Array.from({length: 4}, () => Array(60_000).fill(0))]) validate(value);
|
|
for (const value of [Array.from({length: 4}, () => Array(65_000).fill(0)),
|
|
Object.fromEntries(Array.from({length: 65_537}, (_, index) => [String(index), 0]))]) {
|
|
rejected(() => validate(value));
|
|
}
|
|
let nested: unknown = 0;
|
|
for (let index = 0; index < 65; index++) nested = {nested};
|
|
validate(nested); // ACK value starts at depth 3, reaching the depth-68 boundary.
|
|
rejected(() => validate_node_ack('get_context_info', success([{...info, value: {nested}}]), 2, DEFAULT_LIMITS));
|
|
validate_info_update({...update, data: {...update.data, value: {nested}}}, DEFAULT_LIMITS);
|
|
rejected(() => validate_info_update({...update, data: {...update.data, value: {nested: {nested}}}}, DEFAULT_LIMITS));
|
|
rejected(() => check_size(inventory, DEFAULT_LIMITS.max_payload_bytes));
|
|
rejected(() => validate_event(event('message', {text: '', position: 'chat', json: nbt}), DEFAULT_LIMITS));
|
|
rejected(() => validate_node_ack('bot.chat', success({accepted: true, nested: nbt}), 2, DEFAULT_LIMITS));
|
|
rejected(() => validate_request(request('get_context_info', {nested: nbt}), DEFAULT_LIMITS));
|
|
});
|
|
|
|
test('Node success ACKs enforce method-specific exact DTOs and expected bot', () => {
|
|
const snapshot = {bot_id: 2, bot_status: 'offline', context_exists: false, context_generation: null as string | null,
|
|
stream_id: uuid, seq: 0, captured_at: now};
|
|
validate_node_ack('bot.snapshot', success(snapshot), 2, limits);
|
|
validate_node_ack('bot.logs', success({stream_id: uuid, seq: 1, records: [record()], truncated: false}), 2, limits);
|
|
validate_node_ack('bot.chat', success({accepted: true}), 2, limits);
|
|
validate_node_ack('bot.subscribe', success({events: ['log']}), 2, limits);
|
|
validate_node_ack('bot.chat', error_ack(new RelayError('NO_CONTEXT', 'No context')), 2, limits);
|
|
rejected(() => validate_node_ack('bot.snapshot', success(snapshot), 3, limits));
|
|
for (const data of [true, {}, {accepted: false}, {accepted: true, token: 'secret'}, snapshot]) {
|
|
rejected(() => validate_node_ack('bot.chat', success(data), 2, limits));
|
|
}
|
|
rejected(() => validate_node_ack('bot.snapshot', success({...snapshot, config: {password: 'secret'}}), 2, limits));
|
|
rejected(() => validate_node_ack('bot.snapshot', success({...snapshot, seq: Number.MAX_SAFE_INTEGER + 1}), 2, limits));
|
|
rejected(() => validate_node_ack('bot.snapshot', success({...snapshot, bot_status: 'online'}), 2, limits));
|
|
rejected(() => validate_node_ack('bot.snapshot', success({...snapshot, context_generation: uuid}), 2, limits));
|
|
rejected(() => validate_node_ack('bot.chat', {status: 'error', data: {code: 'NO_CONTEXT', message: 'error', retryable: false, stack: 'secret'}}, 2, limits));
|
|
rejected(() => validate_node_ack('bot.chat', {status: 'error', data: {code: 'UNKNOWN', message: 'error', retryable: false}}, 2, limits));
|
|
});
|
|
|
|
test('logs result record count cannot exceed 200 even inside the byte budget', () => {
|
|
const records = Array.from({length: 200}, (_, index) => ({...record(),
|
|
id: `a89acd9a-0ab3-44ac-812e-${index.toString(16).padStart(12, '0')}`, seq: index + 1}));
|
|
const result = {stream_id: uuid, seq: 200, records, truncated: false};
|
|
validate_node_ack('bot.logs', success(result), 2, limits);
|
|
rejected(() => validate_node_ack('bot.logs', success({...result, records: [...records, record()]}), 2, limits));
|
|
rejected(() => validate_event(event('log', {records: [...records, record()]}), limits));
|
|
rejected(() => validate_node_ack('bot.logs', success({...result, seq: 199}), 2, limits));
|
|
rejected(() => validate_node_ack('bot.logs', success({...result, records: [records[1], records[0]]}), 2, limits));
|
|
rejected(() => validate_node_ack('bot.logs', success({...result, records: [records[0], records[0]]}), 2, limits));
|
|
});
|
|
|
|
test('control DTOs validate scope, permissions, audience and bounded leases', () => {
|
|
const {forward_id, forward_session_id, node_session_id, node_id, bot_id} = claims();
|
|
const scope = {forward_id, forward_session_id, node_session_id, node_id, bot_id};
|
|
validate_scope(scope);
|
|
const open = {...scope, lease_expires_at: Date.now() + 60_000};
|
|
validate_open(open, 0, limits);
|
|
rejected(() => validate_open(open, 1, limits));
|
|
rejected(() => validate_open({...open, key: 'secret'}, 0, limits));
|
|
rejected(() => validate_open({...open, lease_expires_at: Date.now() + limits.max_lease_ms + 5000}, 0, limits));
|
|
rejected(() => validate_open({...open, lease_expires_at: Date.now() - 5000}, 0, limits));
|
|
const grant = {forward_session_id, grant_id: uuid, user_id: 3, permissions: ['bot.snapshot'], expires_at: Date.now() + 60_000};
|
|
validate_grant(grant, limits);
|
|
rejected(() => validate_grant({...grant, user_id: 1.5}, limits));
|
|
rejected(() => validate_grant({...grant, permissions: ['bot.snapshot', 'bot.snapshot']}, limits));
|
|
rejected(() => validate_grant({...grant, key: 'secret'}, limits));
|
|
});
|
|
|
|
test('file requests have exact payloads and a dedicated bot.files permission', () => {
|
|
check_permissions(['bot.files']);
|
|
assert.deepEqual(verify(claims({permissions: ['bot.files']})).permissions, ['bot.files']);
|
|
validate_request(request('get_data_file_list', {}), limits);
|
|
for (const payload of [{id: uuid}, {id: uuid, offset: 0, length: 1},
|
|
{id: uuid, offset: Number.MAX_SAFE_INTEGER, length: 262_144}]) {
|
|
validate_request(request('get_file_data', payload), limits);
|
|
}
|
|
for (const payload of [null, [], {id: uuid}] as unknown[]) rejected(() => validate_request(request('get_data_file_list', payload), limits));
|
|
for (const payload of [{}, {id: 'file'}, {id: uuid, path: 'secret'}, {id: uuid, offset: undefined},
|
|
...[-1, 0.5, Number.MAX_SAFE_INTEGER + 1, '0', null].map(offset => ({id: uuid, offset})),
|
|
...[0, -1, 0.5, 262_145, '1', null].map(length => ({id: uuid, length}))]) {
|
|
rejected(() => validate_request(request('get_file_data', payload), limits));
|
|
}
|
|
rejected(() => validate_request(request('bot.files', {}), limits));
|
|
rejected(() => check_permissions(['get_file_data']));
|
|
rejected(() => check_permissions(['get_data_file_list']));
|
|
});
|
|
|
|
test('file listings bound exact recursive trees, JSON bytes, depth and total nodes', () => {
|
|
const file = {type: 'file', name: 'data.bin', id: uuid, size: Number.MAX_SAFE_INTEGER, modified_at: 0};
|
|
const listing = {listing_id: uuid, expires_at: 1, partial: false, children: [file] as unknown[]};
|
|
const validate = (data: unknown) => validate_node_ack('get_data_file_list', success(data), 2, DEFAULT_LIMITS);
|
|
validate(listing);
|
|
validate({...listing, children: []});
|
|
validate({...listing, children: Array(2000).fill(file)});
|
|
let deep: unknown = file;
|
|
for (let index = 0; index < 31; index++) deep = {type: 'directory', name: 'dir', children: [deep]};
|
|
validate({...listing, children: [deep]});
|
|
rejected(() => check_size(success({...listing, children: [deep]}), DEFAULT_LIMITS.max_payload_bytes));
|
|
rejected(() => validate({...listing, children: [{type: 'directory', name: 'dir', children: [deep]}]}));
|
|
for (const data of [{...listing, children: Array(2001).fill(file)}, {...listing, listing_id: 'id'},
|
|
{...listing, expires_at: 0}, {...listing, partial: 1}, {...listing, extra: true},
|
|
{...listing, children: {}}, {...listing, children: [{...file, size: -1}]},
|
|
{...listing, children: [{...file, modified_at: Number.MAX_SAFE_INTEGER + 1}]},
|
|
{...listing, children: [{...file, path: 'secret'}]},
|
|
{...listing, children: [{type: 'directory', name: 'dir'}]},
|
|
{...listing, children: [{type: 'directory', name: 1, children: []}]}]) rejected(() => validate(data));
|
|
const small_tree = [{...file, name: ''}];
|
|
const overhead = Buffer.byteLength(JSON.stringify(small_tree));
|
|
const children = [{...file, name: 'x'.repeat(512 * 1024 - overhead)}];
|
|
validate({...listing, children});
|
|
rejected(() => validate({...listing, children: [{...children[0], name: children[0].name + 'x'}]}));
|
|
const cyclic: unknown[] = [];
|
|
cyclic.push({type: 'directory', name: 'dir', children: cyclic});
|
|
let calls = 0;
|
|
for (const children of [cyclic, Array(1), [{...file, get name() {calls++; return 'secret';}}]]) {
|
|
rejected(() => validate({...listing, children}));
|
|
}
|
|
assert.equal(calls, 0);
|
|
const bytes = Buffer.byteLength(JSON.stringify(success(listing)));
|
|
validate_node_ack('get_data_file_list', success(listing), 2, {...limits, max_payload_bytes: bytes});
|
|
rejected(() => validate_node_ack('get_data_file_list', success(listing), 2, {...limits, max_payload_bytes: bytes - 1}));
|
|
});
|
|
|
|
test('file ACKs enforce canonical base64, safe offsets, byte counts and EOF equivalence', () => {
|
|
const chunk = {id: uuid, name: 'data.bin', encoding: 'base64', offset: 0, next_offset: 1,
|
|
total_bytes: 2, eof: false, data: 'YQ=='};
|
|
const validate = (data: unknown) => validate_node_ack('get_file_data', success(data), 2, DEFAULT_LIMITS);
|
|
validate(chunk);
|
|
validate({...chunk, total_bytes: 1, eof: true});
|
|
validate({...chunk, offset: 2, next_offset: 2, total_bytes: 2, eof: true, data: ''});
|
|
validate({...chunk, next_offset: 0, total_bytes: 0, eof: true, data: ''});
|
|
const data = Buffer.alloc(262_144).toString('base64');
|
|
validate({...chunk, data, next_offset: 262_144, total_bytes: 262_144, eof: true});
|
|
for (const invalid of [{...chunk, id: 'id'}, {...chunk, name: 1}, {...chunk, encoding: 'utf8'},
|
|
{...chunk, offset: -1}, {...chunk, next_offset: 0}, {...chunk, total_bytes: 0},
|
|
{...chunk, total_bytes: Number.MAX_SAFE_INTEGER + 1}, {...chunk, next_offset: 0.5},
|
|
{...chunk, eof: true}, {...chunk, total_bytes: 1}, {...chunk, extra: true},
|
|
...['YQ', 'YR==', 'YQ==\n', 'YQ===', ' YQ==', '_w==', '!!!!'].map(data => ({...chunk, data})),
|
|
{...chunk, data: Buffer.alloc(262_145).toString('base64'), next_offset: 262_145, total_bytes: 262_145, eof: true}]) {
|
|
rejected(() => validate(invalid));
|
|
}
|
|
});
|
|
|
|
test('workflow permissions are capabilities distinct from RPC names for tokens and grants', () => {
|
|
check_permissions([...RELAY_METHODS]);
|
|
assert.deepEqual(verify(claims({permissions: ['workflow.control', 'bot.snapshot']})).permissions, ['workflow.control', 'bot.snapshot']);
|
|
const grant = {forward_session_id: uuid, grant_id: other_uuid, user_id: 3,
|
|
permissions: ['workflow.control'], expires_at: Date.now() + 60_000};
|
|
validate_grant(grant, limits);
|
|
rejected(() => check_permissions(['workflow.control', 'workflow.control']));
|
|
for (const method of WORKFLOW_METHODS.filter(method => method !== 'workflow.control')) {
|
|
rejected(() => check_permissions([method]));
|
|
rejected(() => verify(claims({permissions: [method]})), 'UNAUTHORIZED');
|
|
rejected(() => validate_grant({...grant, permissions: [method]}, limits));
|
|
}
|
|
});
|
|
|
|
test('workflow requests enforce exact targets, UUID context, positive generation and safe 64 KiB inputs', () => {
|
|
const control = {command_id: uuid, context_generation: other_uuid, workflow_id: 'workflow-1', action: 'run_once'};
|
|
for (const action of WORKFLOW_ACTIONS) {
|
|
const payload = action === 'stop_run' ? {command_id: uuid, context_generation: other_uuid, action, run_id: uuid}
|
|
: {...control, action};
|
|
validate_request(request('workflow.control', payload), limits);
|
|
if (action !== 'stop_run') validate_request(request('workflow.control', {...payload, expected_generation: 1}), limits);
|
|
if (action === 'run_once') {
|
|
validate_request(request('workflow.control', {...payload, input: {value: [1, null, true]}}), limits);
|
|
validate_request(request('workflow.control', {...payload, expected_generation: 1, input: {value: [1, null, true]}}), limits);
|
|
}
|
|
for (const [field, value] of Object.entries({workflow_id: 'workflow-1', run_id: uuid, expected_generation: 1, input: {value: true}})) {
|
|
const allowed = field === 'workflow_id' || field === 'expected_generation' ? action !== 'stop_run'
|
|
: field === 'run_id' ? action === 'stop_run' : action === 'run_once';
|
|
if (!allowed) rejected(() => validate_request(request('workflow.control', {...payload, [field]: value}), limits));
|
|
}
|
|
}
|
|
for (const [method, payload] of [['workflow.start', {workflow_id: 'a'}], ['workflow.start', {workflow_id: 'a', trigger: {}}],
|
|
['workflow.stop', {run_id: uuid}], ['workflow.snapshot', {}], ['workflow.snapshot', {run_id: uuid}],
|
|
['workflow.snapshot', {run_id: uuid, include_branches: false}], ['workflow.snapshot', {run_id: uuid, include_branches: true}],
|
|
['workflow.catalog', {}], ['workflow.runtime', {}], ['workflow.command', {command_id: uuid, context_generation: other_uuid}]]) {
|
|
validate_request(request(method as string, payload), limits);
|
|
rejected(() => validate_request(request(method as string, {...payload as object, extra: true}), limits));
|
|
}
|
|
for (const payload of [{...control, command_id: 'bad'}, {...control, context_generation: null},
|
|
{command_id: uuid, workflow_id: 'a', action: 'run_once'}, {...control, action: 'unknown'},
|
|
{...control, workflow_id: undefined}, {...control, action: 'stop_run'}, {...control, run_id: 'bad'},
|
|
...[0, -1, 1.5, Number.MAX_SAFE_INTEGER + 1, null, '1'].map(expected_generation => ({...control, expected_generation})),
|
|
...['', 'a/b', 'a'.repeat(101), '__proto__', 'constructor', 'prototype'].map(workflow_id => ({...control, workflow_id}))]) {
|
|
rejected(() => validate_request(request('workflow.control', payload), limits));
|
|
}
|
|
for (const method of ['workflow.stop', 'workflow.snapshot']) {
|
|
rejected(() => validate_request(request(method, {run_id: 'bad'}), limits));
|
|
}
|
|
for (const include_branches of [false, true]) {
|
|
rejected(() => validate_request(request('workflow.snapshot', {include_branches}), limits));
|
|
rejected(() => validate_request(request('workflow.snapshot', {run_id: 'bad', include_branches}), limits));
|
|
rejected(() => validate_request(request('workflow.stop', {run_id: uuid, include_branches}), limits));
|
|
}
|
|
for (const include_branches of [null, undefined, 0, 1, 'false', 'true', [], {}]) {
|
|
rejected(() => validate_request(request('workflow.snapshot', {run_id: uuid, include_branches}), limits));
|
|
}
|
|
rejected(() => validate_request(request('workflow.stop', {}), limits));
|
|
rejected(() => validate_request(request('workflow.command', {command_id: uuid}), limits));
|
|
const input = {value: 'x'.repeat(64 * 1024 - Buffer.byteLength(JSON.stringify({value: ''})))};
|
|
validate_request(request('workflow.control', {...control, input}), limits);
|
|
validate_request(request('workflow.start', {workflow_id: 'a', trigger: input}), limits);
|
|
rejected(() => validate_request(request('workflow.control', {...control, input: {value: input.value + 'x'}}), limits));
|
|
const cyclic: Record<string, unknown> = {}; cyclic.self = cyclic;
|
|
let calls = 0;
|
|
for (const input of [null, [], {value: 'x'.repeat(64 * 1024)}, {value: undefined}, {value: NaN},
|
|
cyclic, {get value() {calls++; return 1;}}, JSON.parse('{"nested":{"__proto__":1}}'),
|
|
JSON.parse('{"constructor":1}'), {value: new Date()}, {value: Array(1)}]) {
|
|
rejected(() => validate_request(request('workflow.control', {...control, input}), limits));
|
|
rejected(() => validate_request(request('workflow.start', {workflow_id: 'a', trigger: input}), limits));
|
|
}
|
|
assert.equal(calls, 0);
|
|
for (const field of ['method', 'payload']) {
|
|
const value = Object.defineProperty(request('workflow.control', control), field, {enumerable: true, get() {calls++; return control;}});
|
|
rejected(() => validate_request(value, limits));
|
|
}
|
|
assert.equal(calls, 0);
|
|
const value = request('workflow.control', control);
|
|
const bytes = Buffer.byteLength(JSON.stringify(value));
|
|
validate_request(value, {...limits, max_payload_bytes: bytes});
|
|
rejected(() => validate_request(value, {...limits, max_payload_bytes: bytes - 1}));
|
|
});
|
|
|
|
test('workflow ACKs validate start/stop, opaque bounded catalog, run output and runtime commands', () => {
|
|
const command = {command_id: uuid, action: 'run_once', workflow_id: 'a', state: 'completed'};
|
|
const state: WorkflowRuntimeState = {workflow_id: 'a', generation: 1, enabled: true, start_type: 'timer', trigger_state: 'scheduled',
|
|
accepted_count: 0, max_runs: null, next_fire_at: null, active_run_ids: [uuid], queued_count: 0, last_error: null};
|
|
const runtime = {source_config_revision: 0, workflows: [state], commands: [command]};
|
|
const run: WorkflowRunSnapshot = {run_id: uuid, workflow_id: 'a', status: 'running', steps: 0, active_nodes: ['n'], started_at: 0,
|
|
ended_at: null, stop_reason: null, error: null};
|
|
const full = {...run, branches: [{trigger: {}, vars: {}, inputs: {}, retry_counts: {}, last_result: null as JsonValue,
|
|
outputs: {n: {execution: 1, status: 'success', output: {value: [1, 'output']}}}}]};
|
|
const catalog = {catalog_version: 1, nodes: [{name: 'code', config: [] as JsonValue[], output: {type: 'json'}}], start_nodes: [] as JsonValue[],
|
|
events: [] as JsonValue[], queries: [] as JsonValue[], common: {node_fields: [] as JsonValue[], policy_fields: [] as JsonValue[],
|
|
result: {}, edge_input: {}, references: [] as JsonValue[]}};
|
|
for (const data of [{status: 'started', run_id: uuid}, {status: 'queued', request_id: uuid}, {status: 'skipped'}]) {
|
|
validate_node_ack('workflow.start', success(data), 2, limits);
|
|
validate_node_ack('workflow.control', success({...command, result: data}), 2, limits);
|
|
}
|
|
validate_node_ack('workflow.stop', success({stopped: true}), 2, limits);
|
|
validate_node_ack('workflow.catalog', success(catalog), 2, limits);
|
|
for (const data of [null, [], [run, full], run, full]) validate_node_ack('workflow.snapshot', success(data), 2, limits);
|
|
const trigger: Record<string, JsonValue> = {disabled: false, count: 0, empty: null, nested: {values: [false, 0, null, 'text']}};
|
|
const summary: WorkflowRunSnapshot = {...run, trigger_available: true};
|
|
const detail: WorkflowRunSnapshot = {...run, trigger, trigger_available: true, branches: []};
|
|
for (const data of [summary, [summary], detail, {...run, trigger}, {...full, trigger}, {...run, trigger: {}},
|
|
{...run, trigger: Object.create(null)}, {...run, trigger_available: false}]) {
|
|
validate_node_ack('workflow.snapshot', success(data), 2, limits);
|
|
}
|
|
assert.equal(Object.hasOwn(summary, 'trigger'), false);
|
|
assert.equal(Object.hasOwn(summary, 'branches'), false);
|
|
assert.deepEqual(detail.trigger, trigger);
|
|
const overhead = Buffer.byteLength(JSON.stringify({value: ''}));
|
|
const bounded_trigger = {value: '\u754c'.repeat(Math.floor((65_536 - overhead) / 3))
|
|
+ 'x'.repeat((65_536 - overhead) % 3)};
|
|
assert.equal(Buffer.byteLength(JSON.stringify(bounded_trigger), 'utf8'), 65_536);
|
|
validate_node_ack('workflow.snapshot', success({...detail, trigger: bounded_trigger}), 2, limits);
|
|
rejected(() => validate_node_ack('workflow.snapshot', success({...detail,
|
|
trigger: {value: bounded_trigger.value + 'x'}}), 2, limits));
|
|
const cyclic: Record<string, unknown> = {}; cyclic.self = cyclic;
|
|
let calls = 0;
|
|
for (const trigger of [null, [], 'trigger', false, 0, undefined, {value: NaN}, {value: Infinity}, {value: undefined},
|
|
{value: 1n}, {value: () => 1}, new Date(), Object.create({inherited: true}), cyclic,
|
|
{nested: new Date()}, {nested: Object.create({inherited: true})}, {nested: Array(1)},
|
|
{nested: Object.setPrototypeOf([], null)}, JSON.parse('{"nested":{"__proto__":1}}'),
|
|
JSON.parse('{"constructor":1}'), JSON.parse('{"nested":{"prototype":1}}'),
|
|
{get value() {calls++; return 1;}}, Object.defineProperty({}, 'hidden', {value: true}), {[Symbol('key')]: true}]) {
|
|
for (const data of [{...run, trigger}, [{...run, trigger}]]) {
|
|
rejected(() => validate_node_ack('workflow.snapshot', success(data), 2, limits));
|
|
}
|
|
}
|
|
for (const trigger_available of [null, undefined, 0, 1, 'true', {}, []]) {
|
|
rejected(() => validate_node_ack('workflow.snapshot', success({...run, trigger_available}), 2, limits));
|
|
}
|
|
rejected(() => validate_node_ack('workflow.snapshot', success({...detail, trigger_available: false}), 2, limits));
|
|
for (const field of ['trigger', 'trigger_available']) {
|
|
const data = Object.defineProperty({...run}, field, {enumerable: true, get() {calls++; return true;}});
|
|
rejected(() => validate_node_ack('workflow.snapshot', success(data), 2, limits));
|
|
}
|
|
assert.equal(calls, 0);
|
|
for (const data of [command, {...command, state: 'accepted'}, {...command, result: {stopped: true}},
|
|
{...command, result: {generation: 1}}, {...command, state: 'failed', error: {code: 'WORKFLOW_NOT_FOUND', message: 'Missing'}}]) {
|
|
validate_node_ack('workflow.control', success(data), 2, limits);
|
|
validate_node_ack('workflow.command', success(data), 2, limits);
|
|
}
|
|
validate_node_ack('workflow.command', success(null), 2, limits);
|
|
validate_node_ack('workflow.runtime', success(runtime), 2, limits);
|
|
const bytes = Buffer.byteLength(JSON.stringify(success(runtime)));
|
|
validate_node_ack('workflow.runtime', success(runtime), 2, {...limits, max_payload_bytes: bytes});
|
|
rejected(() => validate_node_ack('workflow.runtime', success(runtime), 2, {...limits, max_payload_bytes: bytes - 1}));
|
|
const catalog_bytes = Buffer.byteLength(JSON.stringify(catalog));
|
|
const bounded_catalog = {...catalog, nodes: [{...catalog.nodes[0], description: 'x'.repeat(100 * 1024 - catalog_bytes - 17)}]};
|
|
assert.equal(Buffer.byteLength(JSON.stringify(bounded_catalog)), 100 * 1024);
|
|
validate_node_ack('workflow.catalog', success(bounded_catalog), 2, limits);
|
|
rejected(() => validate_node_ack('workflow.catalog', success({...bounded_catalog,
|
|
nodes: [{...bounded_catalog.nodes[0], description: bounded_catalog.nodes[0].description + 'x'}]}), 2, limits));
|
|
const full_bytes = Buffer.byteLength(JSON.stringify(success(full)));
|
|
validate_node_ack('workflow.snapshot', success(full), 2, {...limits, max_payload_bytes: full_bytes});
|
|
rejected(() => validate_node_ack('workflow.snapshot', success(full), 2, {...limits, max_payload_bytes: full_bytes - 1}));
|
|
for (const [method, data] of [
|
|
['workflow.start', {status: 'started'}], ['workflow.start', {status: 'queued', request_id: 'bad'}],
|
|
['workflow.start', {status: 'other'}], ['workflow.stop', {stopped: false}], ['workflow.stop', {stopped: true, extra: true}],
|
|
['workflow.catalog', {...catalog, catalog_version: 2}], ['workflow.catalog', {...catalog, nodes: {}}],
|
|
['workflow.catalog', {...catalog, common: {}}], ['workflow.catalog', {...catalog, nodes: [{description: 'x'.repeat(100 * 1024)}]}],
|
|
['workflow.catalog', {...catalog, nodes: [JSON.parse('{"constructor":1}')]}],
|
|
['workflow.snapshot', {...run, run_id: 'bad'}], ['workflow.snapshot', {...run, status: 'unknown'}],
|
|
['workflow.snapshot', {...full, branches: [{}]}], ['workflow.snapshot', {...full, branches: [{...full.branches[0], vars: {bad: Infinity}}]}],
|
|
['workflow.snapshot', {...full, branches: [{...full.branches[0], outputs: {n: {status: 'invalid', output: null as JsonValue, execution: 1}}}]}],
|
|
['workflow.snapshot', {...full, branches: [{...full.branches[0], retry_counts: {n: -1}}]}],
|
|
['workflow.snapshot', {...full, branches: [{...full.branches[0], last_result: {status: 'success', output: true, node_id: 'n', extra: true}}]}],
|
|
['workflow.control', null], ['workflow.control', {...command, command_id: 'bad'}],
|
|
['workflow.control', {...command, action: 'invalid'}], ['workflow.control', {...command, result: {generation: 0}}],
|
|
['workflow.control', {...command, error: {code: 'bad', message: 'x'.repeat(1025)}}],
|
|
['workflow.runtime', {...runtime, source_config_revision: -1}], ['workflow.runtime', {...runtime, commands: Array(257).fill(command)}],
|
|
['workflow.runtime', {...runtime, workflows: [{...state, generation: 0}]}],
|
|
['workflow.runtime', {...runtime, workflows: [{...state, active_run_ids: ['bad']}]}],
|
|
] as const) rejected(() => validate_node_ack(method, success(data), 2, limits));
|
|
for (const method of WORKFLOW_METHODS) {
|
|
validate_node_ack(method, error_ack(new RelayError('INVALID_REQUEST', 'Invalid workflow')), 2, limits);
|
|
rejected(() => validate_node_ack(method, {status: 'error', data: {code: 'WORKFLOW_NOT_FOUND', message: 'bad', retryable: false}}, 2, limits));
|
|
}
|
|
});
|