208 lines
18 KiB
JavaScript
208 lines
18 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { createHash, randomUUID } from 'node:crypto';
|
|
import { ResearchManager } from '../src/core/research-manager.mjs';
|
|
import { REA_OPERATIONS } from '../src/core/tools/rea-adapter.mjs';
|
|
import { researchFileIdentity, sealResearchDocument, readResearchDocument, researchPointer } from '../src/shared/contracts/research.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { Runtime, validateToolArgs } from '../src/server/runtime.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { fixture, until, compatibleFixture, completion, call, assertToolPairs } from './helpers.mjs';
|
|
|
|
const digest = text => createHash('sha256').update(text).digest('hex');
|
|
function researchFixture(t, behavior = null, { deepStore = false, modernDefaults = false } = {}) {
|
|
let f = fixture(t, { modernDefaults });
|
|
if (deepStore) {
|
|
const parts = [];
|
|
while (path.join(f.root, ...parts, 'data').length < 165) parts.push('用户资料-' + parts.length + '-'.repeat(12));
|
|
const data = path.join(f.root, ...parts, 'data');
|
|
assert.ok(path.join(data, 'workbench.sqlite').length < 230, 'The REA export fixture must stay inside SQLite\'s separate Windows path limit.');
|
|
const store = new Store(data), project = store.addProject(f.projectRoot), session = store.createSession(project.id);
|
|
f.onCleanup(() => store.close()); f = { ...f, data, store, project, session };
|
|
}
|
|
const file = path.join(f.root, '用户登记工件.asar'); fs.writeFileSync(file, 'Owned research fixture bytes.');
|
|
const calls = { connect: 0, analyze: 0, close: 0 }, installation = { status: 'available', version: '6.8.0', protocolVersion: '2025-03-26', fixture: true };
|
|
const makeEvidence = (target, operation) => ({ evidence_id: 'ev_' + digest(target.sha256 + operation), operation: REA_OPERATIONS[operation].name,
|
|
subject: { digest: { sha256: target.sha256 } }, authority: 'static-observation', confidence: 1, limitations: ['Fixture static candidates; execution is not observed.'],
|
|
normalized_result: { root_artifact_sha256: target.sha256, summary: { functions: 2 }, statistics: { relevant_files: 2 },
|
|
graph: { nodes: [{ id: 'input', name: 'owned entry', kind: 'file' }], edges: [] }, text: '中文🙂 "raw"\n'.repeat(1400) } });
|
|
const manager = new ResearchManager(f.store, { installation, adapterFactory: (profile, options) => {
|
|
const client = { id: randomUUID(), startedAt: new Date().toISOString(), trace: [], stderr: '' }; options.onClient(client);
|
|
return {
|
|
connect: async signal => { signal.throwIfAborted(); calls.connect++; return { fixture: true, initialize: { protocolVersion: profile.protocolVersion }, enabled: Object.keys(REA_OPERATIONS) }; },
|
|
analyze: async (target, operation, { signal }) => {
|
|
calls.analyze++; if (behavior) await behavior({ target, operation, signal, calls }); signal.throwIfAborted();
|
|
const evidence = makeEvidence(target, operation), bundleText = JSON.stringify({ records: [evidence], unknowns: [] });
|
|
return { request: { name: REA_OPERATIONS[operation].name, arguments: { path: target.path } }, result: { structuredContent: evidence },
|
|
exportResult: { fixture: true }, evidence, bundleText, operation: REA_OPERATIONS[operation].name };
|
|
},
|
|
close: async () => { calls.close++; return { rootExited: true, scope: 'fixture-owned-connection', pid: null }; },
|
|
};
|
|
} });
|
|
return { ...f, file, manager, calls, installation };
|
|
}
|
|
|
|
test('deep Windows data directories keep REA output within the external path allowance and retain owned evidence', async t => {
|
|
const f = researchFixture(t, null, { deepStore: true }), before = fs.readFileSync(path.join(f.projectRoot, 'README.md'));
|
|
const target = await f.manager.register(f.session, { path: f.file });
|
|
const { job, promise } = f.manager.start(f.session, target.id, 'javascript'); await promise;
|
|
assert.equal(job.status, 'completed', job.summary); assert.equal(f.calls.analyze, 1);
|
|
if (process.platform === 'win32') {
|
|
assert.ok(Buffer.byteLength(path.join(job.outputDirectory, 'evidence-' + 'a'.repeat(36) + '.json'), 'utf8') <= 240,
|
|
'Existing deep data directories must not become an overlong REA export path.');
|
|
assert.equal(job.outputScope.location, 'host-temporary');
|
|
const output = fs.realpathSync.native(job.outputDirectory), root = fs.realpathSync.native(job.outputScope.root);
|
|
assert.equal(path.dirname(output), root); assert.equal(path.basename(output), job.id);
|
|
f.onCleanup(() => { assert.equal(path.dirname(fs.realpathSync.native(output)), root); assert.equal(path.basename(output), job.id); fs.rmSync(output, { recursive: true, force: true }); });
|
|
}
|
|
assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, 'README.md')), before);
|
|
const evidence = f.manager.verifiedEvidence(f.session, job); assert.equal(evidence.subject.digest.sha256, target.sha256);
|
|
assert.equal(f.store.core.task.get(f.session.taskId).usage.requests, 0);
|
|
});
|
|
|
|
test('user research registration creates an owned Task without model requests and seals the exact artifact identity', async t => {
|
|
const f = researchFixture(t), owner = fs.readFileSync(path.join(f.projectRoot, 'README.md'));
|
|
await assert.rejects(f.manager.register(f.session, { path: 'relative.asar' }), /绝对路径/);
|
|
const target = await f.manager.register(f.session, { path: f.file, label: '代理工件', goal: '研究工具执行机制。' });
|
|
assert.equal(target.source, 'user-registration'); assert.equal(target.taskId, f.session.taskId); assert.equal(target.runId, f.session.runId);
|
|
assert.equal(target.sha256, digest(fs.readFileSync(f.file))); assert.equal(f.session.status, 'paused');
|
|
assert.equal(f.store.core.run.get(target.runId).engine, 'rea-stdio'); assert.equal(f.store.core.task.get(target.taskId).usage.requests, 0);
|
|
assert.deepEqual(f.manager.calls, undefined); assert.equal(f.calls.connect, 0);
|
|
assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, 'README.md')), owner);
|
|
const other = f.store.createSession(f.project.id); assert.throws(() => f.manager.targetFor(other, target.id), /不属于当前会话/);
|
|
f.store.core.research_target.get(target.id).path = path.join(f.projectRoot, 'README.md');
|
|
assert.throws(() => f.manager.start(f.session, target.id, 'javascript'), /封存身份/); assert.equal(f.calls.analyze, 0);
|
|
});
|
|
|
|
test('complete research binds original Evidence and Bundle, pages exact fields and reuses verified results after reload', async t => {
|
|
const f = researchFixture(t), target = await f.manager.register(f.session, { path: f.file });
|
|
const { job, promise } = f.manager.start(f.session, target.id, 'javascript'); await promise;
|
|
assert.equal(job.status, 'completed', job.summary); assert.equal(job.evidenceBinding.verified, true); assert.equal(f.calls.analyze, 1); assert.equal(f.calls.close, 1);
|
|
const original = f.manager.verifiedEvidence(f.session, job), expected = JSON.stringify(original.normalized_result.text, null, 2);
|
|
let text = '', offset = 0, pages = 0;
|
|
do {
|
|
const page = f.manager.readEvidence(f.session, job.id, { pointer: '/normalized_result/text', offset, limit: 16000, maximumMessageBytes: 5000, callId: 'read-fixture' });
|
|
assert.equal(page.content, expected.slice(offset, page.next_offset));
|
|
assert.ok(Buffer.byteLength(JSON.stringify({ role: 'tool', tool_call_id: 'read-fixture', content: JSON.stringify(page) })) <= 5000);
|
|
assert.equal(page.evidence_id, original.evidence_id); assert.equal(page.target_sha256, target.sha256);
|
|
text += page.content; offset = page.next_offset; pages++; if (!page.truncated) break;
|
|
} while (pages < 100);
|
|
assert.equal(text, expected); assert.ok(pages > 1);
|
|
assert.throws(() => f.manager.readEvidence(f.session, job.id, { pointer: '/__proto__/polluted' }), /没有这个字段/);
|
|
assert.throws(() => f.manager.readEvidence(f.session, job.id, { pointer: '/normalized_result/absent' }), /没有这个字段/);
|
|
const originalTaskId = f.session.taskId; f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
|
|
const session = reopened.session(f.session.id), manager = new ResearchManager(reopened, { installation: f.installation,
|
|
adapterFactory: () => { throw new Error('The original completed analysis must not be repeated.'); } });
|
|
const reused = manager.start(session, target.id, 'javascript'); await reused.promise;
|
|
assert.equal(reused.job.status, 'completed', reused.job.summary); assert.equal(reused.job.reusedFromJobId, job.id);
|
|
assert.equal(session.taskId, originalTaskId); assert.equal(reused.job.evidenceId, job.evidenceId);
|
|
assert.deepEqual(manager.verifiedEvidence(session, reused.job), original);
|
|
const visible = reopened.publicSession(session).execution;
|
|
assert.equal(visible.researchTargets.length, 1); assert.equal(visible.researchJobs.length, 2);
|
|
});
|
|
|
|
test('artifact changes before analysis refuse dispatch and changes during analysis preserve unverified original responses', async t => {
|
|
const f = researchFixture(t), target = await f.manager.register(f.session, { path: f.file });
|
|
fs.appendFileSync(f.file, ' owner edit');
|
|
const refused = f.manager.start(f.session, target.id, 'javascript'); await refused.promise;
|
|
assert.equal(refused.job.status, 'stale'); assert.equal(f.calls.connect, 0); assert.equal(f.calls.analyze, 0);
|
|
const second = researchFixture(t, async ({ target }) => fs.appendFileSync(target.path, ' owner changed during analysis'));
|
|
const registered = await second.manager.register(second.session, { path: second.file });
|
|
const started = second.manager.start(second.session, registered.id, 'javascript'); await started.promise;
|
|
assert.equal(started.job.status, 'stale'); assert.ok(started.job.raw); assert.ok(started.job.bundle); assert.equal(started.job.evidenceBinding, null);
|
|
assert.throws(() => second.manager.verifiedEvidence(second.session, started.job), /尚没有已核验/);
|
|
assert.match(fs.readFileSync(second.file, 'utf8'), /owner changed during analysis/); assert.equal(second.calls.close, 1);
|
|
});
|
|
|
|
test('owned cancellation closes the connection, concurrent and automatic retries are refused, explicit new analysis preserves history', async t => {
|
|
const f = researchFixture(t, async ({ signal, calls }) => {
|
|
if (calls.analyze > 1) return;
|
|
await new Promise((resolve, reject) => { signal.addEventListener('abort', () => reject(Object.assign(new Error('Stopped owned fixture'), { code: 'MCP_CANCELLED' })), { once: true }); });
|
|
});
|
|
const target = await f.manager.register(f.session, { path: f.file }), started = f.manager.start(f.session, target.id, 'javascript');
|
|
await until(() => f.calls.analyze === 1);
|
|
assert.throws(() => f.manager.start(f.session, target.id, 'javascript'), /此前分析/);
|
|
await f.manager.stop(f.session.id); await started.promise;
|
|
assert.equal(started.job.status, 'cancelled'); assert.equal(started.job.cleanup.rootExited, true); assert.equal(f.manager.isActive(f.session.id), false);
|
|
assert.throws(() => f.manager.start(f.session, target.id, 'javascript', { source: 'agent' }), /此前分析/);
|
|
assert.throws(() => f.manager.start(f.session, target.id, 'javascript', { source: 'agent', refresh: true }), /用户/);
|
|
const fresh = f.manager.start(f.session, target.id, 'javascript', { source: 'user', refresh: true }); await fresh.promise;
|
|
assert.equal(fresh.job.status, 'completed'); assert.equal(started.job.status, 'cancelled'); assert.equal(f.calls.analyze, 2); assert.equal(f.calls.close, 2);
|
|
});
|
|
|
|
test('a dispatched transport timeout stays unknown and reload never launches or kills a saved PID', async t => {
|
|
const f = researchFixture(t, async () => { throw Object.assign(new Error('Owned request timed out.'), { code: 'MCP_TIMEOUT', dispatched: true }); });
|
|
const target = await f.manager.register(f.session, { path: f.file }), started = f.manager.start(f.session, target.id, 'javascript'); await started.promise;
|
|
assert.equal(started.job.status, 'unknown'); assert.equal(started.job.requiresVerification, true); assert.equal(started.job.evidenceBinding, null);
|
|
assert.equal(f.manager.result(started.job).research_status, 'unknown'); assert.equal(f.manager.result(started.job).evidence_verified, false);
|
|
started.job.status = 'analyzing'; f.store.save(f.session); f.store.close();
|
|
const reopened = new Store(f.data); f.onCleanup(() => reopened.close()); const saved = reopened.core.research_job.get(started.job.id);
|
|
assert.equal(saved.status, 'unknown'); assert.match(saved.summary, /历史PID/); assert.equal(f.calls.analyze, 1); assert.equal(f.calls.close, 1);
|
|
assert.equal(reopened.publicSession(reopened.session(f.session.id)).execution.researchJobs[0].requiresVerification, true);
|
|
});
|
|
|
|
test('corrupt Evidence parts and changed binding records are refused instead of silently re-analysed', async t => {
|
|
const f = researchFixture(t), target = await f.manager.register(f.session, { path: f.file }), started = f.manager.start(f.session, target.id, 'javascript'); await started.promise;
|
|
const manifest = JSON.parse(f.store.artifactStore.read(f.store.core.artifact.get(started.job.evidence.id))), part = f.store.core.artifact.get(manifest.parts[0].id);
|
|
fs.appendFileSync(path.join(f.store.artifactStore.root, part.relative), 'corrupt');
|
|
assert.throws(() => f.manager.verifiedEvidence(f.session, started.job), /工件校验失败/);
|
|
const reused = f.manager.start(f.session, target.id, 'javascript'); await reused.promise;
|
|
assert.notEqual(reused.job.status, 'completed'); assert.equal(f.calls.analyze, 1);
|
|
started.job.targetSha256 = 'f'.repeat(64); assert.throws(() => f.manager.verifiedEvidence(f.session, started.job), /封存绑定/);
|
|
});
|
|
|
|
test('research documents over the single-artifact limit preserve exact Unicode bytes with owned verifiable parts', t => {
|
|
const f = fixture(t), text = JSON.stringify({ evidence: '中文🙂"\n'.repeat(1000000) });
|
|
assert.ok(Buffer.byteLength(text) > 8 * 1024 * 1024);
|
|
const reference = sealResearchDocument(f.store, f.session, null, text, 'research-evidence'); f.store.save(f.session);
|
|
assert.equal(readResearchDocument(f.store, f.session, reference), text); assert.equal(reference.documentSha256, digest(text));
|
|
assert.equal(reference.bytes, Buffer.byteLength(text));
|
|
assert.throws(() => researchPointer({ field: 1 }, '/constructor'), /没有这个字段/);
|
|
});
|
|
|
|
test('research tools are only sent for registered Task artifacts and actual HTTP uses the sealed tool contract without replay', async t => {
|
|
// This tests research and diagnostic ownership under the product defaults;
|
|
// finite context and read-budget behavior have separate regression cases.
|
|
const f = researchFixture(t, null, { modernDefaults: true }), runtime = new Runtime(f.store, new Provider()); runtime.research = f.manager;
|
|
const target = await f.manager.register(f.session, { path: f.file });
|
|
let requests = 0, jobId = null;
|
|
const model = await compatibleFixture(t, (route, body) => {
|
|
if (!route.endsWith('/chat/completions')) return { body: {} }; requests++;
|
|
if (requests <= 3) assert.ok(body.tools.some(tool => tool.function.name === 'analyze_research_target'));
|
|
else {
|
|
assert.ok(body.tools.some(tool => tool.function.name === 'read_research_evidence'));
|
|
assert.ok(body.tools.some(tool => tool.function.name === 'list_research_targets'));
|
|
assert.equal(body.tools.some(tool => tool.function.name === 'analyze_research_target'), false);
|
|
}
|
|
const tools = body.messages.filter(value => value.role === 'tool').map(value => JSON.parse(value.content));
|
|
if (requests === 1) return { body: completion([call('rea-fixture-analysis', 'analyze_research_target', { target_id: target.id, operation: 'javascript' })]) };
|
|
if (requests === 2) { jobId = tools.at(-1).research_job_id; assert.equal(tools.at(-1).evidence_verified, true);
|
|
return { body: completion([call('rea-fixture-field', 'read_research_evidence', { research_job_id: jobId, pointer: '/normalized_result/graph' })]) }; }
|
|
if (requests === 4) {
|
|
return { body: completion([call('rea-diagnostic-original-field', 'read_research_evidence', { research_job_id: jobId, pointer: '/normalized_result/graph' })]) };
|
|
}
|
|
assert.equal(JSON.parse(tools.at(-1).content).nodes[0].name, 'owned entry');
|
|
return { body: completion([], '依据原静态Evidence完成机制核对,运行行为尚未观测。') };
|
|
});
|
|
f.store.saveConfig({ mode: 'compatible', baseUrl: model.baseUrl, model: 'research-contract-fixture', maxSteps: 5 });
|
|
runtime.start(f.session.id, '用登记工件分析机制并核对原图字段。'); await until(() => !runtime.isActive(f.session.id), 20000);
|
|
assert.equal(f.session.status, 'completed', JSON.stringify({ failure: f.session.failure, requests, messages: f.session.providerMessages, events: f.session.events })); assert.equal(requests, 3); assert.equal(f.calls.analyze, 1);
|
|
assert.equal(f.store.core.research_job.get(jobId).status, 'completed'); assertToolPairs(f.session.providerMessages);
|
|
const originalTaskId = f.session.taskId, evidence = structuredClone(f.store.core.research_job.get(jobId).evidence);
|
|
runtime.start(f.session.id, '刚才的分析为什么报错?'); await until(() => !runtime.isActive(f.session.id), 20000);
|
|
assert.equal(requests, 5); assert.equal(f.calls.analyze, 1); assert.equal(f.session.taskId, originalTaskId);
|
|
const diagnostic = f.store.core.run.get(f.session.runId);
|
|
assert.equal(diagnostic.purpose, 'diagnostic'); assert.equal(diagnostic.status, 'completed'); assert.equal(diagnostic.stopReason, 'diagnostic_answered');
|
|
assert.deepEqual(f.store.core.research_job.get(jobId).evidence, evidence); assertToolPairs(f.session.providerMessages);
|
|
assert.throws(() => validateToolArgs('analyze_research_target', { target_id: target.id, operation: 'javascript', path: 'other.exe' }), /已登记/);
|
|
assert.throws(() => validateToolArgs('analyze_research_target', { target_id: target.id, operation: 'execute' }), /静态分析方式/);
|
|
const noTarget = f.store.createSession(f.project.id); assert.equal(f.manager.targets(noTarget).length, 0);
|
|
});
|
|
|
|
test('file identity rejects directory and invalid formats without running a target', async t => {
|
|
const f = fixture(t); await assert.rejects(researchFileIdentity(f.projectRoot), /常规ASAR/);
|
|
await assert.rejects(researchFileIdentity(path.join(f.projectRoot, 'README.md')), /支持ASAR/);
|
|
});
|