Files
Agent-Workbench/tests/mnemo-bridge.test.mjs
Agent Workbench Dev e306f40cae
Official contracts and Windows source CI / windows-source (push) Has been cancelled
feat(memory): release Mnemo project bridge and schema2 recovery
2026-11-11 03:03:43 +08:00

93 lines
8.9 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { randomUUID } from 'node:crypto';
import { fixture } from './helpers.mjs';
import { Store } from '../src/server/store.mjs';
import { ProjectMemoryManager } from '../src/core/memory/project-memory.mjs';
import { MnemoBridge, memoryConfirmationDigest } from '../src/core/memory/mnemo-bridge.mjs';
import { MNEMO_PROTOCOL, digest, sourceDigest, eventDigest } from '../src/core/memory/mnemo-protocol.mjs';
function transport() {
const bindings = new Map(), receipts = new Map(), calls = []; let drop = false, gate = null;
const fetch = async (url, options) => {
const route = new URL(url).pathname.split('/').at(-1), body = options.body ? JSON.parse(options.body) : null;
calls.push({ route, body }); if (gate) await gate;
if (route === 'capabilities') {
const bindingId = new URL(url).searchParams.get('bindingId'), binding = bindings.get(bindingId);
return Response.json({ protocol: MNEMO_PROTOCOL, bindingId, producerId: binding.producerId, projectId: binding.projectId, grantId: binding.grantId,
available: true, manifestLifetimeMs: 30000, executionAuthorized: false, privateOnly: true });
}
if (route === 'sync') {
const receipt = { protocol: MNEMO_PROTOCOL, bindingId: body.bindingId, requestKey: body.requestKey, receiptId: randomUUID(), sourceId: body.source.id, sequence: body.source.sequence,
sourceDigest: sourceDigest(body.source, body.memory), eventDigest: eventDigest(body), state: body.source.state,
memoryId: body.memory && body.source.state === 'current' ? randomUUID() : null, revision: body.memory && body.source.state === 'current' ? 1 : null,
committedAt: new Date().toISOString(), replayed: false, currentState: body.source.state, requiresFreshManifest: true };
receipts.set(body.requestKey, receipt); if (drop) { drop = false; throw new TypeError('Synthetic response lost after commit'); }
return Response.json(receipt);
}
if (route === 'lookup') return Response.json({ found: receipts.has(body.requestKey), receipt: receipts.get(body.requestKey) ?? null });
throw new Error('Unexpected fixture route ' + route);
};
return { fetch, bindings, calls, setDrop: () => { drop = true; }, setGate: value => { gate = value; } };
}
async function setup(t) {
const f = fixture(t, { modernDefaults: true }), remote = transport(), bridge = new MnemoBridge(f.store, { fetch: remote.fetch });
const m = await new ProjectMemoryManager(f.store).create(f.session, { title: '完整来源', content: '保留中文\n原始正文。' });
const view = await bridge.view(f.project.id), bindingId = randomUUID(); remote.bindings.set(bindingId, { producerId: view.producerId, projectId: f.project.id, grantId: randomUUID() });
const config = { enabled: true, baseUrl: 'http://127.0.0.1:12345', bindingId, token: 'synthetic-bridge-token', expectedRevision: 0 };
return { ...f, remote, bridge, m, config, producerId: view.producerId,
change: action => bridge.changeSource(f.project.id, m.id, { action, confirmed: true, expectedDigest: memoryConfirmationDigest(f.store.core.memory.get(m.id)) }) };
}
test('an unopened default-off bridge makes no request and does not persist a producer or alter configuration', async t => {
const f = fixture(t, { modernDefaults: true }); let calls = 0; const bridge = new MnemoBridge(f.store, { fetch: () => { calls++; } }), config = structuredClone(f.store.config);
assert.equal(await bridge.context(f.session, 'topic'), null); assert.equal(f.store.storage.meta('mnemoProjectMemoryBridge'), null); assert.equal(calls, 0); assert.deepEqual(f.store.config, config);
});
test('explicit confirmation is bound to exact full revision; candidate and confirmation sequences survive restart without credentials', async t => {
const f = await setup(t); await f.bridge.configure(f.project.id, f.config);
const before = structuredClone(f.store.core.memory.get(f.m.id)); await f.change('candidate'); assert.equal((await f.bridge.view(f.project.id)).sources[0].confirmation, null);
const staleDigest = memoryConfirmationDigest(before), m = f.store.core.memory.get(f.m.id); m.content += '\n新修订'; f.store.putRecord('memory', f.session, m, 'memory.test_revision');
const currentReview = (await f.bridge.view(f.project.id)).sources[0];
assert.equal(currentReview.review.content, m.content); assert.notEqual(currentReview.review.content, before.content);
assert.equal(digest(currentReview.review), currentReview.confirmationDigest);
await assert.rejects(f.bridge.changeSource(f.project.id, m.id, { action: 'confirm', confirmed: true, expectedDigest: staleDigest }), { code: 'PROJECT_CONFIRMATION_CHANGED' });
await f.change('confirm'); const view = await f.bridge.view(f.project.id); assert.equal(view.sources[0].sequence, 2); assert.equal(view.sources[0].confirmation.by, 'user');
assert.equal(JSON.stringify(f.store.storage.meta('mnemoProjectMemoryBridge')).includes(f.config.token), false);
f.store.close(); const reopened = new Store(f.data); f.onCleanup(() => reopened.close());
const restored = new MnemoBridge(reopened, { fetch: f.remote.fetch }), after = await restored.view(f.project.id);
assert.equal(after.producerId, f.producerId); assert.equal(after.sources[0].sequence, 2); assert.equal(after.connection.hasToken, false);
await assert.rejects(restored.configure(f.project.id, { enabled: true, expectedRevision: after.connection.revision }), { code: 'PROJECT_TOKEN_REQUIRED' });
});
test('unknown sync persists original package before submission and only looks up the same durable key', async t => {
const f = await setup(t); await f.bridge.configure(f.project.id, f.config); f.remote.setDrop(); await f.change('confirm');
const unknown = f.store.storage.meta('mnemoProjectMemoryBridge').projects[f.project.id].sources[f.m.id].event;
assert.equal(unknown.status, 'unknown'); assert.equal(unknown.input.memory.content, f.m.content);
await f.bridge.lookupSource(f.project.id, f.m.id);
const after = f.store.storage.meta('mnemoProjectMemoryBridge').projects[f.project.id].sources[f.m.id].event;
assert.equal(after.status, 'committed'); assert.equal(after.requestKey, unknown.requestKey); assert.deepEqual(after.input, unknown.input);
assert.equal(f.remote.calls.filter(c => c.route === 'sync').length, 1); assert.equal(f.remote.calls.filter(c => c.route === 'lookup').length, 1);
});
test('cross-project configuration and confirmation serialize across manager instances sharing one metadata document', async t => {
const f = await setup(t), root2 = f.projectRoot + '-2'; fs.mkdirSync(root2); fs.writeFileSync(root2 + '/README.md', '# Second synthetic project\n');
const p2 = f.store.addProject(root2), b2 = new MnemoBridge(f.store, { fetch: f.remote.fetch }), id2 = randomUUID();
f.remote.bindings.set(id2, { producerId: f.producerId, projectId: p2.id, grantId: randomUUID() });
let release; f.remote.setGate(new Promise(resolve => { release = resolve; }));
const a = f.bridge.configure(f.project.id, f.config); const b = b2.configure(p2.id, { ...f.config, bindingId: id2 });
await new Promise(resolve => setImmediate(resolve)); assert.equal(f.remote.calls.length, 1); f.remote.setGate(null); release(); await Promise.all([a, b]);
const state = f.store.storage.meta('mnemoProjectMemoryBridge'); assert.equal(state.projects[f.project.id].revision, 1); assert.equal(state.projects[p2.id].revision, 1);
});
test('deletion erases recoverable bridge packages and old restored metadata cannot revive their body or authorization', async t => {
const f = await setup(t); await f.bridge.configure(f.project.id, f.config); await f.change('confirm'); const old = structuredClone(f.store.storage.meta('mnemoProjectMemoryBridge'));
await f.change('delete'); let p = f.store.storage.meta('mnemoProjectMemoryBridge').projects[f.project.id];
assert.ok(p.events.every(e => e.input.memory === null && e.attempts.every(a => !a.request?.memory)));
assert.equal(f.store.core.memory.get(f.m.id).content, f.m.content, 'Original local source is independent of erasing the optional bridge copy');
f.store.storage.transaction(() => f.store.storage.setMeta('mnemoProjectMemoryBridge', old));
const fresh = new MnemoBridge(f.store, { fetch: f.remote.fetch }), view = await fresh.view(f.project.id); assert.equal(view.connection.hasToken, false); assert.equal(view.sources[0].state, 'deleted');
p = f.store.storage.meta('mnemoProjectMemoryBridge').projects[f.project.id]; assert.ok(p.events.every(e => e.input.memory === null));
assert.equal(JSON.stringify(p).includes(f.m.content), false);
});
test('corrupt optional bridge state is recorded as unavailable without preventing the original model task', async t => {
const f = fixture(t); f.store.storage.setMeta('mnemoProjectMemoryBridge', { schemaVersion: 99 });
const view = await new MnemoBridge(f.store).context(f.session, 'topic'); assert.equal(view.issue.code, 'PROJECT_STATE_INVALID'); assert.equal(view.entries.length, 0);
});