231 lines
22 KiB
JavaScript
231 lines
22 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { execFile } from 'node:child_process';
|
|
import { promisify } from 'node:util';
|
|
import { fixture, compatibleFixture, completion, call, until, assertToolPairs, launchWorkbench } from './helpers.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { validateMcpArguments, checkMcpSchema } from '../src/core/tools/mcp-contract.mjs';
|
|
import { verifyPlanEvidence } from '../src/core/context/request-plan.mjs';
|
|
import { proposeFile, applyChange } from '../src/server/files.mjs';
|
|
import { gitEnvironment } from '../src/core/git-process.mjs';
|
|
|
|
function entryFor(f) { const entry = path.join(f.root, 'owned-mcp.mjs'); fs.copyFileSync(path.resolve('tests/fixtures/registered-mcp-server.mjs'), entry); return entry; }
|
|
async function setup(t, respond = () => completion([], 'Owned MCP local fixture response.')) {
|
|
const f = fixture(t), provider = new Provider(); provider.setKey('owned-mcp-key-canary');
|
|
const runtime = new Runtime(f.store, provider); f.onCleanup(() => runtime.stopAll());
|
|
const manager = runtime.mcpRegistry(), entry = entryFor(f);
|
|
const saved = manager.register(f.project.id, { name: 'Owned stdio MCP', executable: process.execPath, entry, timeoutMs: 800 });
|
|
return { ...f, provider, runtime, manager, entry, saved, respond,
|
|
async probe() { const result = await manager.start(f.session, { id: saved.id, configurationRevision: manager.find(f.project.id, saved.id).configurationRevision, confirm: true }).promise;
|
|
assert.equal(result.status, 'completed', result.error?.message); return result; },
|
|
async model() { const server = await compatibleFixture(t, respond); f.store.saveConfig({ mode: 'compatible', model: 'owned-mcp', baseUrl: server.baseUrl, contextLimit: 24000 }); return server; },
|
|
};
|
|
}
|
|
function enable(f, tools = ['echo']) { const value = f.manager.find(f.project.id, f.saved.id); return f.manager.configure(f.project.id, { id: value.id, configurationRevision: value.configurationRevision, enabled: true, allowedTools: tools }); }
|
|
function toolInput(f, tool = 'echo', args = { text: 'Owned echo', count: 2 }) { const value = f.manager.find(f.project.id, f.saved.id); return { registration_id: value.id, configuration_revision: value.configurationRevision, contract_sha256: value.contract.sha256, tool, arguments: args }; }
|
|
|
|
test('MCP registration stays disabled until an explicit real stdio probe and schema-based tool selection, with actual process cleanup', async t => {
|
|
const f = await setup(t); assert.equal(f.saved.enabled, false); assert.equal(f.saved.contract, null);
|
|
assert.throws(() => f.manager.start(f.session, { id: f.saved.id, configurationRevision: 1, confirm: false }), /确认/);
|
|
const job = await f.probe(), report = f.manager.report(f.session, job.id);
|
|
assert.equal(report.initialize.serverInfo.version, '1.0'); assert.equal(report.tools.length, 3); assert.equal(job.cleanup.rootExited, true);
|
|
assert.ok(report.tools.find(value => value.name === 'unsupported').unsupported);
|
|
assert.deepEqual(report.trace.map(value => value.method), ['initialize', 'tools/list']); assert.equal(report.result, null);
|
|
assert.throws(() => enable(f, ['unsupported']), /inputSchema.*MCP/); const enabled = enable(f); assert.equal(enabled.enabled, true);
|
|
assert.equal(f.manager.catalog(f.project.id).entries.length, 1);
|
|
assert.throws(() => f.manager.configure(f.project.id, { id: enabled.id, configurationRevision: 2, enabled: false, allowedTools: [] }), /配置已变化/);
|
|
f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
const next = new Runtime(reopened, new Provider()); assert.equal(next.mcpRegistry().view(f.project.id).registrations[0].status, 'verified');
|
|
});
|
|
|
|
test('MCP probe holds the project operation lock until its owned process and report are settled', async t => {
|
|
const f = await setup(t), entry = path.join(f.root, 'second-mcp.mjs');
|
|
fs.copyFileSync(path.resolve('tests/fixtures/registered-mcp-server.mjs'), entry);
|
|
const probe = f.manager.start(f.session, { id: f.saved.id, configurationRevision: 1, confirm: true });
|
|
assert.throws(() => f.manager.register(f.project.id, { name: 'Concurrent MCP', executable: process.execPath, entry }), /项目正在执行/);
|
|
const result = await probe.promise;
|
|
assert.equal(result.status, 'completed'); assert.equal(result.cleanup.rootExited, true);
|
|
const saved = f.manager.register(f.project.id, { name: 'After MCP', executable: process.execPath, entry });
|
|
assert.equal(saved.enabled, false);
|
|
});
|
|
|
|
test('MCP keeps object envelopes and forwards schema semantics to the declaring server without coercion', () => {
|
|
const schema = { type: 'object', properties: { count: { type: 'integer', minimum: 1, maximum: 3 }, name: { type: 'string', enum: ['alpha', 'beta'] } }, required: ['count'], additionalProperties: false };
|
|
assert.equal(validateMcpArguments(schema, { count: 2, name: 'alpha' }), true);
|
|
for (const value of [{}, { count: 4 }, { count: '2' }, { count: 2, other: true }, { count: 2, name: 'other' }]) {
|
|
const original = structuredClone(value); assert.equal(validateMcpArguments(schema, value), true); assert.deepEqual(value, original);
|
|
}
|
|
for (const value of [null, [], 'input']) assert.throws(() => validateMcpArguments(schema, value), /arguments.*JSON/);
|
|
assert.equal(checkMcpSchema({ type: 'object', $ref: '#/other' }), true);
|
|
assert.equal(checkMcpSchema({ type: 'object', properties: { x: { type: 'string', pattern: '.*' } } }), true);
|
|
assert.throws(() => checkMcpSchema({ type: 'array' }), /inputSchema.*MCP/);
|
|
});
|
|
|
|
test('actual model MCP call approves long schema-valid arguments, validates the sent catalog and stores one original result without leaking environment secrets', async t => {
|
|
let input;
|
|
const f = await setup(t, (_url, body, requests) => requests.length === 1 ? completion([call('owned-external-call', 'call_registered_mcp', input)]) : completion([], 'One owned MCP call finished.'));
|
|
await f.probe(); enable(f); input = toolInput(f, 'echo', { text: 'Owned echo '.repeat(1200), count: 2 });
|
|
const server = await f.model(); f.runtime.start(f.session.id, 'Use the registered echo tool for the current project.');
|
|
await until(() => f.session.status === 'awaiting_approval'); assert.equal(f.manager.jobs(f.session).length, 1);
|
|
const approval = f.session.approvals.find(value => value.status === 'pending'); assert.match(approval.command, /工具 echo/);
|
|
assert.ok(approval.command.length > 6000); assert.ok(approval.command.includes(JSON.stringify(input.arguments)));
|
|
assert.equal(approval.mcpRegistrationId, f.saved.id); assert.equal(approval.taskId, f.session.taskId);
|
|
f.runtime.decide(f.session.id, approval.id, true); await f.runtime.active.get(f.session.id).promise;
|
|
assert.equal(f.session.status, 'completed', f.session.lastFailure?.message); assert.equal(server.requests.length, 2); assertToolPairs(f.session.providerMessages);
|
|
const job = f.manager.jobs(f.session).find(value => value.operation === 'call'); assert.equal(job.status, 'completed'); assert.equal(job.dispatched, true);
|
|
const report = f.manager.report(f.session, job.id); assert.equal(report.result.content[0].text, input.arguments.text.repeat(2));
|
|
assert.deepEqual(report.result.structuredContent.environmentNames, []); assert.equal(report.cleanup.rootExited, true);
|
|
assert.equal(JSON.stringify(report).includes('owned-mcp-key-canary'), false);
|
|
for (const plan of f.store.core.context_plan.values()) assert.doesNotThrow(() => verifyPlanEvidence(f.store, f.session, plan));
|
|
});
|
|
|
|
test('denying an MCP call never starts another process or executes the external tool', async t => {
|
|
let input; const f = await setup(t, (_url, _body, requests) => requests.length === 1 ? completion([call('denied-external', 'call_registered_mcp', input)]) : completion([], 'Denied.'));
|
|
await f.probe(); enable(f); input = toolInput(f); await f.model();
|
|
f.runtime.start(f.session.id, 'Request the registered tool.'); await until(() => f.session.status === 'awaiting_approval');
|
|
f.runtime.decide(f.session.id, f.session.approvals.find(value => value.status === 'pending').id, false); await f.runtime.active.get(f.session.id).promise;
|
|
assert.equal(f.manager.jobs(f.session).length, 1); assert.equal([...f.store.core.tool.values()][0].state, 'denied');
|
|
});
|
|
|
|
test('actual handshake drift rejects tools/call even if program entry hash is unchanged', async t => {
|
|
let input; const f = await setup(t, (_url, _body, requests) => requests.length === 1 ? completion([call('drift-external', 'call_registered_mcp', input)]) : completion([], 'Version drift rejected.'));
|
|
await f.probe(); enable(f); input = toolInput(f);
|
|
// Simulate a dynamic dependency by changing the stored original contract's actual server version.
|
|
const state = f.manager.state(), registration = state.registrations[0], original = f.manager.contract(registration);
|
|
original.serverInfo.version = 'unmatched-version';
|
|
const contract = f.store.artifactStore.write(f.session, f.store.core.run.get(f.session.runId), original, { kind: 'mcp-contract' });
|
|
f.store.core.artifact.set(contract.id, contract); f.store.save(f.session); registration.contract = { ...registration.contract, artifactId: contract.id, sha256: contract.sha256 }; f.manager.save(state);
|
|
input = toolInput(f); await f.model(); f.runtime.start(f.session.id, 'Call with fixed actual schema.'); await until(() => f.session.status === 'awaiting_approval');
|
|
f.runtime.decide(f.session.id, f.session.approvals.find(value => value.status === 'pending').id, true); await f.runtime.active.get(f.session.id).promise;
|
|
const job = f.manager.jobs(f.session).find(value => value.operation === 'call'), report = f.manager.report(f.session, job.id);
|
|
assert.equal(job.status, 'failed'); assert.equal(job.dispatched, false); assert.match(job.error.message, /实际版本/);
|
|
assert.equal(report.trace.some(value => value.method === 'tools/call'), false);
|
|
});
|
|
|
|
test('cancelled dispatched external side effect stays unknown, closes its owned process and cannot replay on reopen', async t => {
|
|
let input; const f = await setup(t, (_url, _body, requests) => requests.length === 1 ? completion([call('held-external', 'call_registered_mcp', input)]) : completion([], 'Stopped.'));
|
|
await f.probe(); enable(f, ['hold']); input = toolInput(f, 'hold', { text: 'unknown-effect' }); await f.model();
|
|
f.runtime.start(f.session.id, 'Use the external held operation.'); await until(() => f.session.status === 'awaiting_approval');
|
|
f.runtime.decide(f.session.id, f.session.approvals.find(value => value.status === 'pending').id, true);
|
|
await until(() => f.manager.jobs(f.session).some(value => value.status === 'calling'));
|
|
const job = f.manager.jobs(f.session).find(value => value.operation === 'call');
|
|
await until(() => fs.existsSync(path.join(job.directory, 'owned-call-dispatched.txt'))); await f.runtime.stop(f.session.id);
|
|
assert.equal(job.status, 'unknown'); assert.equal(job.requiresVerification, true); assert.equal(job.cleanup.rootExited, true);
|
|
const before = f.manager.jobs(f.session).length; f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
assert.equal(reopened.core.mcp_job.get(job.id).status, 'unknown'); assert.equal([...reopened.core.mcp_job.values()].length, before);
|
|
assert.equal(fs.readFileSync(path.join(job.directory, 'owned-call-dispatched.txt'), 'utf8').includes('unknown-effect'), true);
|
|
});
|
|
|
|
test('changed executable input, foreign project IDs and corrupted original contracts block enable and dispatch', async t => {
|
|
const f = await setup(t); await f.probe(); const value = f.manager.find(f.project.id, f.saved.id);
|
|
const otherRoot = path.join(f.root, 'other'); fs.mkdirSync(otherRoot); const other = f.store.addProject(otherRoot);
|
|
assert.throws(() => f.manager.find(other.id, value.id), /不属于当前项目/);
|
|
fs.appendFileSync(f.entry, '\n// Changed executable input.\n'); assert.throws(() => enable(f), /程序文件已变化/);
|
|
assert.equal(f.manager.view(f.project.id).registrations[0].status, 'changed');
|
|
fs.copyFileSync(path.resolve('tests/fixtures/registered-mcp-server.mjs'), f.entry);
|
|
const artifact = f.store.core.artifact.get(value.contract.artifactId); fs.appendFileSync(path.join(f.store.artifactStore.root, artifact.relative), '\nChanged.');
|
|
assert.throws(() => enable(f), /工件校验失败/);
|
|
});
|
|
|
|
test('registered MCP HTTP API uses fixed execution contracts and project-owned probe records with no model requests', async t => {
|
|
const f = fixture(t), entry = entryFor(f); f.store.close(); const host = await launchWorkbench(t, f.data); f.onCleanup(host.close);
|
|
const saved = await host.api('/projects/' + f.project.id + '/mcp', { name: 'HTTP MCP', executable: process.execPath, entry, timeoutMs: 2000 });
|
|
assert.equal(saved.enabled, false);
|
|
const started = await host.api('/sessions/' + f.session.id + '/mcp/probe', { id: saved.id, configurationRevision: 1, confirm: true });
|
|
await until(async () => (await host.api('/sessions/' + f.session.id + '/mcp/jobs')).some(value => value.id === started.job.id && value.status === 'completed'));
|
|
const report = await host.api('/sessions/' + f.session.id + '/mcp/jobs/' + started.job.id + '/report'); assert.equal(report.cleanup.rootExited, true);
|
|
const input = await host.api('/sessions/' + f.session.id + '/mcp/jobs/' + started.job.id + '/input');
|
|
const sealed = (await host.api('/sessions/' + f.session.id + '/mcp/jobs')).find(value => value.id === started.job.id);
|
|
assert.equal(input.taskId, started.job.taskId); assert.equal(input.runId, started.job.runId); assert.equal(input.sha256, sealed.inputSha256);
|
|
const view = await host.api('/projects/' + f.project.id + '/mcp'); assert.equal(view.registrations[0].tools.length, 3);
|
|
await assert.rejects(host.api('/projects/' + f.project.id + '/mcp', { name: 'Arbitrary command', executable: process.execPath, args: ['-e', 'do not execute'] }), /不支持|未支持/);
|
|
await host.close();
|
|
});
|
|
|
|
test('unknown MCP pauses later tool calls and all project writers; fingerprinted acknowledgement clears only the review gates and explicit resume does not replay', async t => {
|
|
let input;
|
|
const f = await setup(t, (_url, _body, requests) => requests.length === 1 ? completion([
|
|
call('unknown-before-writer', 'call_registered_mcp', input),
|
|
call('must-not-execute-later', 'run_command', { command: 'Set-Content must-not-exist.txt unexpected', reason: 'Owned later call must never execute.' }),
|
|
]) : completion([], 'Explicit resumed task.'));
|
|
await f.probe(); enable(f, ['hold']); input = toolInput(f, 'hold', { text: 'timeout-original-effect' }); const server = await f.model();
|
|
f.runtime.start(f.session.id, 'Call the external tool before doing any further work.');
|
|
await until(() => f.session.status === 'awaiting_approval');
|
|
f.runtime.decide(f.session.id, f.session.approvals.find(value => value.status === 'pending').id, true);
|
|
await f.runtime.active.get(f.session.id).promise;
|
|
const job = f.manager.jobs(f.session).find(value => value.operation === 'call'), tool = f.store.owned('tool', job.invocationId, f.session.id);
|
|
assert.equal(job.status, 'unknown'); assert.equal(tool.requiresVerification, true); assert.equal(f.session.status, 'paused');
|
|
assert.equal(f.store.core.run.get(job.runId).stopReason, 'mcp_review'); assert.equal(server.requests.length, 1);
|
|
const later = [...f.store.core.tool.values()].find(value => value.callId === 'must-not-execute-later');
|
|
assert.equal(later.state, 'interrupted'); assert.equal(later.result.reason, 'mcp_review'); assertToolPairs(f.session.providerMessages);
|
|
assert.equal(fs.existsSync(path.join(f.projectRoot, 'must-not-exist.txt')), false);
|
|
const original = f.store.artifactStore.readBytes(f.store.owned('artifact', tool.resultArtifactId, f.session.id));
|
|
const transcript = JSON.stringify(f.session.providerMessages), other = f.store.createSession(f.project.id);
|
|
assert.throws(() => f.runtime.start(other.id, 'Cannot evade project-wide unknown results.'), /MCP.*待核对/);
|
|
assert.throws(() => proposeFile(f.store, other, { path: 'new.txt', content: 'blocked' }), /MCP.*待核对/);
|
|
assert.throws(() => applyChange(f.store, f.session, 'no-change'), /MCP.*待核对/);
|
|
await assert.rejects(f.runtime.checkRunner().start(f.session, 'no-plan'), /MCP.*待核对/);
|
|
assert.throws(() => f.runtime.gitDelivery().assertTask(f.session), /MCP.*待核对/);
|
|
assert.throws(() => f.runtime.changeSetManager().requireIdle(f.session), /MCP.*待核对/);
|
|
assert.throws(() => f.runtime.workspaceManager().assertIdle(f.session), /MCP.*待核对/);
|
|
assert.throws(() => f.runtime.browserManager().assertReady(f.session), /MCP.*待核对/);
|
|
const evidence = f.manager.evidence(f.session, job.id);
|
|
assert.throws(() => f.manager.acknowledge(f.session, job.id, '0'.repeat(64)), /指纹/);
|
|
const acknowledged = f.manager.acknowledge(f.session, job.id, evidence.evidenceSha256);
|
|
assert.equal(acknowledged.status, 'unknown'); assert.equal(acknowledged.requiresVerification, false);
|
|
const reviewed = f.store.core.tool.get(tool.id); assert.equal(reviewed.state, 'unknown'); assert.equal(reviewed.requiresVerification, false);
|
|
assert.equal(f.store.core.run.get(job.runId).checkpoint.requiresVerification.includes(tool.id), false);
|
|
assert.deepEqual(f.store.artifactStore.readBytes(f.store.owned('artifact', tool.resultArtifactId, f.session.id)), original);
|
|
assert.equal(JSON.stringify(f.session.providerMessages), transcript); assert.equal(server.requests.length, 1);
|
|
f.runtime.resume(f.session.id); await f.runtime.active.get(f.session.id).promise;
|
|
assert.equal(server.requests.length, 2); assert.equal(f.manager.jobs(f.session).filter(value => value.operation === 'call').length, 1);
|
|
assert.equal(f.session.status, 'completed');
|
|
});
|
|
|
|
test('MCP acknowledgement persistence failure restores both job and tool review gates; corrupt evidence cannot be acknowledged', async t => {
|
|
let input; const f = await setup(t, () => completion([call('rollback-review', 'call_registered_mcp', input)]));
|
|
await f.probe(); enable(f, ['hold']); input = toolInput(f, 'hold', { text: 'review-rollback' }); await f.model();
|
|
f.runtime.start(f.session.id, 'Preserve unresolved state if acknowledgement cannot persist.'); await until(() => f.session.status === 'awaiting_approval');
|
|
f.runtime.decide(f.session.id, f.session.approvals.find(value => value.status === 'pending').id, true); await f.runtime.active.get(f.session.id).promise;
|
|
const job = f.manager.jobs(f.session).find(value => value.operation === 'call'), evidence = f.manager.evidence(f.session, job.id), save = f.store.save;
|
|
f.store.save = function(session, event) { if (event?.type === 'mcp.acknowledged') throw new Error('Owned acknowledgement persistence failure'); return save.call(this, session, event); };
|
|
try { assert.throws(() => f.manager.acknowledge(f.session, job.id, evidence.evidenceSha256), /persistence failure/); }
|
|
finally { f.store.save = save; }
|
|
assert.equal(f.store.core.mcp_job.get(job.id).requiresVerification, true); assert.equal(f.store.core.tool.get(job.invocationId).requiresVerification, true);
|
|
assert.equal(f.store.core.run.get(job.runId).checkpoint.requiresVerification.includes(job.invocationId), true);
|
|
const tool = f.store.core.tool.get(job.invocationId), originalHash = tool.argsSha256; tool.argsSha256 = '0'.repeat(64);
|
|
assert.throws(() => f.manager.evidence(f.session, job.id), /原调用输入/); tool.argsSha256 = originalHash;
|
|
const artifact = f.store.core.artifact.get(job.inputArtifactId); fs.appendFileSync(path.join(f.store.artifactStore.root, artifact.relative), '\ncorrupted');
|
|
assert.throws(() => f.manager.acknowledge(f.session, job.id, evidence.evidenceSha256), /工件校验失败/);
|
|
assert.equal(f.store.core.mcp_job.get(job.id).requiresVerification, true);
|
|
});
|
|
|
|
test('actual host exit after an external effect restores unknown jobs without a fabricated report, allows source-bound review and never replays the call', async t => {
|
|
let input; const f = await setup(t, () => completion([call('crashed-mcp-host', 'call_registered_mcp', input)]));
|
|
await f.probe(); enable(f, ['hold']); input = toolInput(f, 'hold', { text: 'crash-original-effect' }); const server = await f.model(); f.store.close();
|
|
const executed = await promisify(execFile)(process.execPath, [path.resolve('tests/fixtures/mcp-host-crash.mjs'), f.data, f.session.id], { env: gitEnvironment(), windowsHide: true, timeout: 18000 })
|
|
.then(() => assert.fail('Owned crash worker must exit after the dispatched effect.'), error => { assert.equal(error.code, 85, error.stderr); return JSON.parse(error.stdout.trim().split('\n').at(-1)); });
|
|
assert.equal(executed.crashAfterDispatched, true);
|
|
const store = new Store(f.data); f.onCleanup(() => store.close()); const runtime = new Runtime(store, new Provider()); f.onCleanup(() => runtime.stopAll());
|
|
const session = store.session(f.session.id), manager = runtime.mcpRegistry(), job = store.core.mcp_job.get(executed.jobId);
|
|
assert.equal(job.status, 'unknown'); assert.equal(job.requiresVerification, true); assert.equal(job.reportArtifactId, undefined);
|
|
assert.equal(store.core.tool.get(job.invocationId).state, 'unknown'); assert.equal(server.requests.length, 1);
|
|
const evidence = manager.evidence(session, job.id); assert.equal(evidence.report, null); assert.match(evidence.note, /没有完整原报告/);
|
|
assert.equal(evidence.input.input.call.arguments.text, 'crash-original-effect');
|
|
assert.throws(() => runtime.resume(session.id), /MCP.*待核对/);
|
|
const reviewed = manager.acknowledge(session, job.id, evidence.evidenceSha256);
|
|
assert.equal(reviewed.status, 'unknown'); assert.equal(reviewed.reportArtifactId, undefined); assert.equal(store.core.tool.get(job.invocationId).requiresVerification, false);
|
|
assert.equal(manager.jobs(session).filter(value => value.operation === 'call').length, 1); assert.equal(server.requests.length, 1);
|
|
});
|
|
|
|
test('changed enabled MCP programs can be explicitly disabled without launching or trusting their changed source', async t => {
|
|
const f = await setup(t); await f.probe(); const enabled = enable(f);
|
|
fs.appendFileSync(f.entry, '\n// Changed dependency entry.\n'); assert.equal(f.manager.view(f.project.id).registrations[0].status, 'changed');
|
|
const disabled = f.manager.configure(f.project.id, { id: enabled.id, configurationRevision: enabled.configurationRevision, enabled: false, allowedTools: [] });
|
|
assert.equal(disabled.enabled, false); assert.deepEqual(f.manager.catalog(f.project.id).entries, []); assert.equal(f.manager.jobs(f.session).length, 1);
|
|
});
|