93 lines
8.9 KiB
JavaScript
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);
|
|
});
|