import assert from 'node:assert/strict' import { randomUUID } from 'node:crypto' import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client' import { StdioClientTransport } from '@modelcontextprotocol/client/stdio' const limit = 1024 * 1024 const budgetMeta = 'io.mikrotikmanager/result-budget' const comment = 'Ж'.repeat(11000) const payloadBytes = value => Buffer.byteLength(JSON.stringify(value), 'utf8') const tools = ['mm_servers_list', 'mm_logs_settings_update_plan', 'mm_change_apply', 'mm_operation_get'] export async function verifyResultEnvelope(endpoint, pool, jwt, bridgeFile) { assert.equal(new URL(endpoint).hostname, '127.0.0.1') const { rows: [{ count: existingServers }] } = await pool.query('SELECT count(*)::int AS count FROM servers') await pool.query(` INSERT INTO servers(name,host,enabled,comment) SELECT 'owned-envelope-'||n, '192.0.2.'||(10+n), false, $1 FROM generate_series(1,24) AS n `, [comment]) const { rows: servers } = await pool.query('SELECT id FROM servers ORDER BY id') // Independently observe actual writes, including an accidental repeat with unchanged settings. await pool.query(` CREATE TABLE owned_log_settings_writes (interval_sec integer NOT NULL); CREATE FUNCTION owned_count_log_settings_write() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN INSERT INTO owned_log_settings_writes VALUES (NEW.interval_sec); RETURN NEW; END $$; CREATE TRIGGER owned_count_log_settings_write AFTER UPDATE ON router_log_settings FOR EACH ROW EXECUTE FUNCTION owned_count_log_settings_write()`) const headers = { authorization: 'Bearer ' + jwt, 'content-type': 'application/json' } const json = async (path, body) => { const response = await fetch(new URL(path, endpoint), { headers, signal: AbortSignal.timeout(10000), ...(body ? { method: 'POST', body: JSON.stringify(body) } : {}), }) assert.equal(response.status, 200, path) return response.json() } const cases = [] for (const mode of ['http', 'stdio']) { const { connection, token } = await json('/api/mcp/connections', { name: 'Owned result envelope ' + mode, mode: 'approval', expiresAt: new Date(Date.now() + 600000).toISOString(), permissions: ['mm:servers:read', 'mm:settings:admin'], limits: { serversPerPlan: servers.length, mutationsPerHour: servers.length }, scope: { serverIds: servers.map(row => Number(row.id)), allowGlobal: true, operationIds: ['servers.list', 'logs.settings.update', 'changes.apply', 'operations.read'] }, }) const client = new Client({ name: 'owned-result-envelope-' + mode, version: '1.0.0' }) const transport = mode === 'http' ? new StreamableHTTPClientTransport(new URL(endpoint), { requestInit: { headers: { authorization: 'Bearer ' + token } } }) : new StdioClientTransport({ command: process.execPath, args: ['--import', import.meta.resolve('tsx'), bridgeFile], cwd: process.cwd(), env: { MCP_URL: endpoint, MCP_TOKEN: token }, maxBufferSize: limit + 65536, stderr: 'pipe' }) transport.stderr?.on('data', () => {}) try { await client.connect(transport, { timeout: 10000 }) const observedTools = (await client.listTools({}, { timeout: 5000 })).tools.map(tool => tool.name) assert.deepEqual(observedTools.sort(), [...tools].sort()) const call = async (name, args) => { const result = await client.callTool({ name, arguments: args }, undefined, { timeout: 10000 }) assert(payloadBytes(result) <= limit, mode + ' ' + name) return result } const output = result => { if (result.isError) assert.fail(JSON.parse(result.content[0].text).code) const text = JSON.parse(result.content[0].text) assert.deepEqual(result.structuredContent.result, text) return text } const accepted = await call('mm_servers_list', { limit: 23, offset: existingServers }) const page = output(accepted) assert.equal(page.items.length, 23) assert(page.items.every(item => item.comment === comment)) assert(payloadBytes(accepted) >= 1000000) // Even without field names and framing this page's duplicated UTF-8 text exceeds 1 MiB. assert(24 * Buffer.byteLength(comment, 'utf8') * 2 > limit) const refused = await call('mm_servers_list', { limit: 24, offset: existingServers }) assert.equal(refused.isError, true) assert.equal(refused.structuredContent, undefined) assert.equal(JSON.parse(refused.content[0].text).code, 'RESULT_TOO_LARGE') assert.deepEqual(refused._meta[budgetMeta], { version: 1, detailsOmitted: true, reason: 'byte-budget', automaticReplay: false, }) const before = await json('/api/logs/settings') const intervalSec = before.intervalSec === 60 ? 61 : 60 const plan = output(await call('mm_logs_settings_update_plan', { settings: { intervalSec } })) assert.equal(plan.state, 'awaiting-approval') await json('/api/mcp/plans/' + plan.planId + '/decision', { approve: true }) const applyArgs = { planId: plan.planId, idempotencyKey: randomUUID() } const operation = output(await call('mm_change_apply', applyArgs)) let terminal for (const end = Date.now() + 10000; Date.now() < end;) { terminal = output(await call('mm_operation_get', { operationId: operation.id })) if (!['pending', 'running'].includes(terminal.state)) break await new Promise(resolve => setTimeout(resolve, 100)) } assert.equal(terminal.state, 'applied') assert.equal(terminal.verification, 'passed') const writes = async () => (await pool.query('SELECT count(*)::int AS n FROM owned_log_settings_writes')).rows[0].n const checkEffect = async () => { assert.equal(await writes(), cases.length + 1) assert.deepEqual(await json('/api/logs/settings'), { ...before, intervalSec }) } await checkEffect() // Supply namespaced synthetic optional details to the actual, already applied operation. // The ordinary runtime read and duplicate-apply paths must keep its original outcome. const oversizedDetails = JSON.stringify(Array(24).fill(comment)) const staged = await pool.query(` UPDATE mcp_operations SET result=jsonb_set(COALESCE(result, '{}'::jsonb), '{ownedEnvelopeDetails}', $2::jsonb) WHERE id=$1 AND state='applied' RETURNING id`, [operation.id, oversizedDetails]) assert.equal(staged.rowCount, 1) const compactRead = await call('mm_operation_get', { operationId: operation.id }) const compactApply = await call('mm_change_apply', applyArgs) for (const compact of [compactRead, compactApply]) { assert(payloadBytes(compact) < 2048) assert.deepEqual(compact._meta[budgetMeta], refused._meta[budgetMeta]) assert.deepEqual(output(compact), { id: operation.id, plan_id: plan.planId, state: 'applied', verification: 'passed', error_code: null, }) } await checkEffect() const { rows: [counts] } = await pool.query(` SELECT (SELECT count(*)::int FROM mcp_operations WHERE connection_id=$1) AS operations, (SELECT count(*)::int FROM mcp_operation_steps WHERE operation_id=$2 AND state='verified') AS verified_steps, (SELECT count(*)::int FROM mcp_requests WHERE connection_id=$1 AND tool='mm_change_apply') AS apply_requests `, [connection.id, operation.id]) assert.deepEqual(counts, { operations: 1, verified_steps: 1, apply_requests: 2 }) cases.push({ mode, nearLimitBytes: payloadBytes(accepted), refusalBytes: payloadBytes(refused), compactReadBytes: payloadBytes(compactRead), compactApplyBytes: payloadBytes(compactApply), ...counts, settingsWrites: 1 }) } finally { await client.close() } } return { scope: 'complete CallToolResult from HTTP SDK and production stdio bridge on owned PostgreSQL', limitBytes: limit, wholeGenericResultEnvelopeLimitAccepted: true, cases } }