feat(memory): release Mnemo project bridge and schema2 recovery
Official contracts and Windows source CI / windows-source (push) Has been cancelled
Official contracts and Windows source CI / windows-source (push) Has been cancelled
This commit is contained in:
@@ -0,0 +1,174 @@
|
||||
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 { DatabaseSync } from 'node:sqlite';
|
||||
import { fixture, workspace } from './helpers.mjs';
|
||||
import { ModelRequestLedger } from '../src/core/models/request-ledger.mjs';
|
||||
import { StateDatabase } from '../src/core/storage/state-database.mjs';
|
||||
import { REQUEST_LEDGER_MIGRATION } from '../src/core/storage/request-ledger-schema.mjs';
|
||||
import { readDataCompatibility, assertDataCompatibility, snapshotPersistentData, verifyPersistentDataTransition } from '../src/core/desktop/data-retention.mjs';
|
||||
import { InstallationManager } from '../src/core/desktop/install-manager.mjs';
|
||||
import { writeDataCompatibility } from '../scripts/build-data-compatibility.mjs';
|
||||
|
||||
const hash = value => createHash('sha256').update(value).digest('hex');
|
||||
const compatible = { readWriteSchemas: [1, 2], ledgerMigration: REQUEST_LEDGER_MIGRATION };
|
||||
const seed = (f, count = 7) => {
|
||||
const values = Array.from({ length: count }, (_, index) => ({ id: index < 2 ? 'duplicate-legacy-id' : 'legacy-' + index,
|
||||
connectionId: 'synthetic-connection', sessionId: f.session.id, projectId: f.project.id, taskId: 'synthetic-task', runId: 'synthetic-run',
|
||||
model: 'synthetic-model', protocol: 'chat-completions', status: ['succeeded', 'failed', 'unknown'][index % 3],
|
||||
opaqueSource: { index, text: '原文 / 😀' } }));
|
||||
const raw = JSON.stringify(values, null, 2) + '\n';
|
||||
f.store.storage.database.prepare('INSERT INTO metadata(key,value) VALUES(?,?)').run('modelAttempts', raw);
|
||||
return { values, raw };
|
||||
};
|
||||
const candidate = (f, name, { legacy = false } = {}) => {
|
||||
const root = path.join(f.root, 'install/versions', name); fs.mkdirSync(root, { recursive: true });
|
||||
for (const name of ['dist-client', 'dist-server', 'dist-desktop']) fs.cpSync(path.join(workspace, name), path.join(root, name), { recursive: true });
|
||||
if (legacy) fs.unlinkSync(path.join(root, 'dist-server/data-compatibility.json'));
|
||||
for (const name of ['AgentWorkbench.exe', 'runtime/node.exe', 'desktop/AgentWorkbench.exe', 'desktop/resources/app/main.cjs', 'desktop/resources/app/package.json']) {
|
||||
const file = path.join(root, name); fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, 'declared-static-unit-fixture');
|
||||
}
|
||||
const inventory = (directory, prefix = '') => fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
|
||||
const relative = path.posix.join(prefix, entry.name), file = path.join(directory, entry.name);
|
||||
return entry.isDirectory() ? inventory(file, relative) : [{ path: relative, bytes: fs.statSync(file).size, sha256: hash(fs.readFileSync(file)) }];
|
||||
});
|
||||
fs.writeFileSync(path.join(root, 'MANIFEST.json'), JSON.stringify({ app: 'agent-workbench', kind: 'portable', version: '1.25.12', platform: 'win32-x64', files: inventory(root) }));
|
||||
return root;
|
||||
};
|
||||
const manager = (f, candidateRoot) => {
|
||||
const instance = new InstallationManager({ installRoot: path.join(f.root, 'install'), dataRoot: f.data, candidateRoot, port: 49996 });
|
||||
instance.host = async () => null; return instance;
|
||||
};
|
||||
|
||||
for (const count of [0, 7, 107]) test(`exact schema1 migration preserves ${count} ordered legacy entries, original metadata and each artifact/config byte`, t => {
|
||||
const f = fixture(t, { modernDefaults: true }), { raw } = seed(f, count), before = snapshotPersistentData(f.data);
|
||||
const ledger = new ModelRequestLedger(f.store.storage), after = snapshotPersistentData(f.data);
|
||||
const result = verifyPersistentDataTransition(before, after, compatible);
|
||||
assert.equal(result.kind, 'model-attempt-ledger-v1'); assert.equal(result.legacyEntries, count);
|
||||
assert.equal(result.originalMetadata.sha256, hash(raw));
|
||||
assert.equal(f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get().value, raw);
|
||||
assert.equal(ledger.page().total, count); assert.equal(after.database.userVersion, 2);
|
||||
assert.deepEqual(after.database.expectedLegacyRows.map(row => row.legacyPosition), Array.from({ length: count }, (_, i) => i));
|
||||
});
|
||||
|
||||
test('fresh empty legacy metadata is not fabricated and absent row migrates without adding a modelAttempts row', t => {
|
||||
const f = fixture(t, { modernDefaults: true }), before = snapshotPersistentData(f.data);
|
||||
new ModelRequestLedger(f.store.storage);
|
||||
const after = snapshotPersistentData(f.data), result = verifyPersistentDataTransition(before, after, compatible);
|
||||
assert.equal(result.legacyEntries, 0); assert.equal(result.originalMetadata, null);
|
||||
assert.equal(f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get(), undefined);
|
||||
});
|
||||
|
||||
const corruptions = {
|
||||
'missing legacy row': db => db.exec('DELETE FROM model_attempts WHERE seq=2'),
|
||||
'reassigned legacy position': db => db.exec('UPDATE model_attempts SET legacy_position=50 WHERE seq=2'),
|
||||
'same-length payload edit': db => db.exec("UPDATE model_attempts SET payload=replace(payload,'原文','改文') WHERE seq=2"),
|
||||
'edited initial bytes with recomputed hash': db => { const raw = db.prepare('SELECT initial_payload FROM model_attempts WHERE seq=2').get().initial_payload.replace('原文', '改文'); db.prepare('UPDATE model_attempts SET initial_payload=?,initial_sha256=? WHERE seq=2').run(raw, hash(raw)); },
|
||||
'search ownership altered': db => db.exec("UPDATE model_attempts SET task_id='other-owner' WHERE seq=2"),
|
||||
'new request after migration': db => db.exec("INSERT INTO model_attempts(id,payload,payload_sha256,initial_payload,initial_sha256) VALUES('new','{}','x','{}','x')"),
|
||||
'unknown marker field': db => db.exec("UPDATE metadata SET value=json_set(value,'$.unknown',true) WHERE key='modelAttemptLedger'"),
|
||||
'wrong marker original digest': db => db.exec("UPDATE metadata SET value=json_set(value,'$.legacyMetadataSha256','bad') WHERE key='modelAttemptLedger'"),
|
||||
'extra table': db => db.exec('CREATE TABLE foreign_rows(id TEXT)'),
|
||||
'extra trigger': db => db.exec('CREATE TRIGGER foreign_trigger AFTER INSERT ON model_attempts BEGIN SELECT 1; END'),
|
||||
'extra view': db => db.exec('CREATE VIEW foreign_view AS SELECT id FROM model_attempts'),
|
||||
'changed index definition': db => db.exec('DROP INDEX model_attempts_status; CREATE INDEX model_attempts_status ON model_attempts(model,seq)'),
|
||||
'wrong schema version': db => db.exec('PRAGMA user_version=3'),
|
||||
'same-length original metadata edit': db => db.exec("UPDATE metadata SET value=replace(value,'原文','改文') WHERE key='modelAttempts'"),
|
||||
'old project payload altered': db => db.exec("UPDATE projects SET payload=json_set(payload,'$.name','other-project')"),
|
||||
'original sequence altered': db => db.exec("UPDATE sqlite_sequence SET seq=seq+1 WHERE name='events'"),
|
||||
};
|
||||
for (const [name, corrupt] of Object.entries(corruptions)) test(`exact migration rejects ${name} and never rewrites the conflicting source`, t => {
|
||||
const f = fixture(t, { modernDefaults: true }); seed(f); const before = snapshotPersistentData(f.data);
|
||||
new ModelRequestLedger(f.store.storage); corrupt(f.store.storage.database);
|
||||
const after = snapshotPersistentData(f.data);
|
||||
assert.throws(() => verifyPersistentDataTransition(before, after, compatible), /迁移|原|schema/);
|
||||
assert.deepEqual(snapshotPersistentData(f.data), after);
|
||||
});
|
||||
|
||||
test('ledger initializer rollback remains source-bound and a new current outcome cannot be removed', t => {
|
||||
const f = fixture(t, { modernDefaults: true }); seed(f); const before = snapshotPersistentData(f.data);
|
||||
const first = new ModelRequestLedger(f.store.storage); assert.equal(first.rollbackInitialization(), true);
|
||||
assert.deepEqual(snapshotPersistentData(f.data), before);
|
||||
const ledger = new ModelRequestLedger(f.store.storage), old = ledger.all()[2]; old.status = 'succeeded'; ledger.save(old);
|
||||
const after = snapshotPersistentData(f.data);
|
||||
assert.throws(() => ledger.rollbackInitialization(), /已有新记录/); assert.deepEqual(snapshotPersistentData(f.data), after);
|
||||
});
|
||||
|
||||
test('consistent read transaction prevents a second SQLite writer from mixing original rows with later schema/metadata state', t => {
|
||||
const f = fixture(t, { modernDefaults: true }); seed(f); const before = snapshotPersistentData(f.data);
|
||||
const writer = new DatabaseSync(path.join(f.data, 'workbench.sqlite'));
|
||||
const original = DatabaseSync.prototype.prepare; let changed = false;
|
||||
DatabaseSync.prototype.prepare = function(sql) {
|
||||
const statement = original.call(this, sql);
|
||||
if (this !== writer && sql === 'SELECT * FROM "metadata"') {
|
||||
const read = statement.all.bind(statement);
|
||||
statement.all = (...args) => {
|
||||
const rows = read(...args);
|
||||
writer.exec("UPDATE projects SET payload=json_set(payload,'$.name','concurrent-write')"); changed = true;
|
||||
return rows;
|
||||
};
|
||||
}
|
||||
return statement;
|
||||
};
|
||||
try {
|
||||
const snapshot = snapshotPersistentData(f.data); assert.equal(changed, true); assert.deepEqual(snapshot, before);
|
||||
} finally { DatabaseSync.prototype.prepare = original; writer.close(); }
|
||||
assert.notDeepEqual(snapshotPersistentData(f.data), before);
|
||||
});
|
||||
|
||||
test('candidate compatibility binds actual server/hot-upgrade bytes and unknown/changed declarations are rejected', t => {
|
||||
const f = fixture(t, { modernDefaults: true }), root = path.join(f.root, 'declaration'); fs.mkdirSync(path.join(root, 'dist-server'), { recursive: true });
|
||||
assert.deepEqual(readDataCompatibility(root).readWriteSchemas, [1]);
|
||||
for (const name of ['src/core/models/request-ledger.mjs', 'src/core/storage/state-database.mjs', 'src/core/storage/request-ledger-schema.mjs', 'dist-server/server.mjs', 'dist-server/hot-upgrade.mjs']) {
|
||||
fs.mkdirSync(path.dirname(path.join(root, name)), { recursive: true }); fs.copyFileSync(path.join(workspace, name), path.join(root, name));
|
||||
}
|
||||
const declaration = writeDataCompatibility(root), file = path.join(root, 'dist-server/data-compatibility.json');
|
||||
assert.deepEqual(readDataCompatibility(root).readWriteSchemas, [1, 2]);
|
||||
const changed = structuredClone(declaration); changed.ledgerMigration.id = 'unreviewed'; fs.writeFileSync(file, JSON.stringify(changed));
|
||||
assert.throws(() => readDataCompatibility(root), /迁移身份/);
|
||||
fs.writeFileSync(file, JSON.stringify(declaration)); fs.appendFileSync(path.join(root, 'dist-server/hot-upgrade.mjs'), '\nchanged');
|
||||
assert.throws(() => readDataCompatibility(root), /实际处理器/);
|
||||
const before = snapshotPersistentData(f.data); new ModelRequestLedger(f.store.storage);
|
||||
assert.doesNotThrow(() => assertDataCompatibility(before, { readWriteSchemas: [1] }));
|
||||
assert.throws(() => assertDataCompatibility(snapshotPersistentData(f.data), { readWriteSchemas: [1] }), /schema2/);
|
||||
});
|
||||
|
||||
test('actual installer path accepts only the declared exact migration and archives per-legacy hashes in its receipt', async t => {
|
||||
const f = fixture(t, { modernDefaults: true }); seed(f); const root = candidate(f, 'declared-migration'), m = manager(f, root);
|
||||
let migrated = false; const phase = m.phase.bind(m);
|
||||
m.phase = (name, detail) => { phase(name, detail); if (name === 'verify-data' && !migrated) { new ModelRequestLedger(f.store.storage); migrated = true; } };
|
||||
const result = await m.activate(), receipt = JSON.parse(fs.readFileSync(result.receiptFile));
|
||||
assert.equal(result.dataVerification.kind, 'model-attempt-ledger-v1'); assert.equal(receipt.dataVerification.legacyRows.length, 7);
|
||||
assert.equal(receipt.compatibility.declarationSha256, readDataCompatibility(root).declarationSha256);
|
||||
assert.equal(receipt.state, 'activated');
|
||||
});
|
||||
|
||||
test('installer catches data drift between verification and pointer publication, keeps the original pointer and does not erase the conflicting change', async t => {
|
||||
const f = fixture(t, { modernDefaults: true }), m = manager(f, candidate(f, 'first'));
|
||||
await m.activate(); const pointer = fs.readFileSync(m.recordFile); m.candidateRoot = candidate(f, 'second');
|
||||
await assert.rejects(m.activate({ beforePointer: () => f.store.storage.setMeta('concurrent-change', { id: randomUUID() }) }), /回退尚待核对/);
|
||||
assert.ok(fs.readFileSync(m.recordFile).equals(pointer)); assert.ok(f.store.storage.meta('concurrent-change'));
|
||||
assert.equal(JSON.parse(fs.readFileSync(m.receiptFile)).state, 'rollback-unverified');
|
||||
});
|
||||
|
||||
test('schema2 rollback rejects an undeclared schema1 previous payload before pointer changes and a declared recovery payload keeps all new outcomes through fresh open', async t => {
|
||||
const f = fixture(t, { modernDefaults: true }); seed(f);
|
||||
const old = candidate(f, 'old-schema1', { legacy: true }), active = candidate(f, 'new-schema2'), recovery = candidate(f, 'schema2-recovery'), m = manager(f, old);
|
||||
await m.activate(); m.candidateRoot = active;
|
||||
let migrated = false; const phase = m.phase.bind(m);
|
||||
m.phase = (name, detail) => { phase(name, detail); if (name === 'verify-data' && !migrated) { new ModelRequestLedger(f.store.storage); migrated = true; } };
|
||||
await m.activate();
|
||||
const ledger = new ModelRequestLedger(f.store.storage);
|
||||
for (const status of ['succeeded', 'failed', 'unknown']) ledger.save({ id: 'post-migration-' + status, model: 'synthetic-model', status, opaque: { status } });
|
||||
const before = snapshotPersistentData(f.data), pointer = fs.readFileSync(m.recordFile);
|
||||
await assert.rejects(m.rollback(), /schema2/); assert.ok(fs.readFileSync(m.recordFile).equals(pointer));
|
||||
assert.deepEqual(snapshotPersistentData(f.data), before);
|
||||
const result = await m.rollback({ recoveryRoot: recovery }); assert.equal(result.operation, 'rollback');
|
||||
assert.equal(result.dataVerification.kind, 'unchanged'); assert.deepEqual(snapshotPersistentData(f.data), before);
|
||||
f.store.storage.close(); f.store.storage = new StateDatabase(f.data);
|
||||
const reopened = new ModelRequestLedger(f.store.storage); assert.equal(reopened.page().total, 10);
|
||||
reopened.save({ id: 'post-restart-request', model: 'synthetic-model', status: 'succeeded' });
|
||||
assert.equal(reopened.page().total, 11); assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 2);
|
||||
});
|
||||
@@ -0,0 +1,38 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { createHash } from 'node:crypto';
|
||||
import { fixture } from './helpers.mjs';
|
||||
import { desktopLaunchCommand } from '../scripts/desktop-launch.mjs';
|
||||
import { desktopLaunchOptions } from '../src/core/desktop/launch-options.mjs';
|
||||
|
||||
for (const relative of ['node_modules/electron/dist/electron.exe', 'runtime/electron/electron.exe', 'desktop/AgentWorkbench.exe']) {
|
||||
test('desktop acceptance launch parses correctly with ' + relative, t => {
|
||||
const f = fixture(t), root = path.join(f.root, '验收 程序');
|
||||
const write = file => { const absolute = path.join(root, file); fs.mkdirSync(path.dirname(absolute), { recursive: true }); fs.writeFileSync(absolute, 'static executable fixture'); };
|
||||
write(relative); write('dist-desktop/main.cjs');
|
||||
const packaged = relative === 'desktop/AgentWorkbench.exe';
|
||||
if (packaged) { write('runtime/electron/electron.exe'); write('node_modules/electron/dist/electron.exe'); }
|
||||
const flags = ['--app-root', root, '--data-root', f.data, '--node', process.execPath, '--port', '4319', '--hidden-window'];
|
||||
const original = flags.slice(), command = desktopLaunchCommand(root, flags), mainFile = path.join(root, 'dist-desktop/main.cjs');
|
||||
assert.equal(command.executablePath, fs.realpathSync.native(path.join(root, relative)));
|
||||
assert.deepEqual(flags, original);
|
||||
const debugArgs = ['--inspect=0', '--remote-debugging-port=0'];
|
||||
assert.deepEqual(desktopLaunchOptions([command.executablePath, ...debugArgs, ...command.args], { defaultApp: !packaged, mainFile }),
|
||||
{ '--app-root': root, '--data-root': f.data, '--node': process.execPath, '--port': '4319', hidden: true });
|
||||
if (packaged) assert.throws(() => desktopLaunchOptions([command.executablePath, ...debugArgs, mainFile, ...flags], { defaultApp: false, mainFile }), /Unsupported desktop option/);
|
||||
else assert.throws(() => desktopLaunchOptions([command.executablePath, ...debugArgs, ...command.args], { defaultApp: true, mainFile: path.join(root, 'other.cjs') }), /Desktop entry does not match/);
|
||||
assert.throws(() => desktopLaunchOptions([command.executablePath, ...debugArgs, ...command.args, '--port', '4320'], { defaultApp: !packaged, mainFile }), /Unsupported desktop option/);
|
||||
});
|
||||
}
|
||||
|
||||
test('desktop acceptance launch still verifies the executable against its original manifest', t => {
|
||||
const f = fixture(t), root = path.join(f.root, 'portable'), relative = 'desktop/AgentWorkbench.exe', executable = path.join(root, relative);
|
||||
fs.mkdirSync(path.dirname(executable), { recursive: true }); fs.writeFileSync(executable, 'original executable fixture');
|
||||
const bytes = fs.readFileSync(executable);
|
||||
fs.writeFileSync(path.join(root, 'MANIFEST.json'), JSON.stringify({ files: [{ path: relative, bytes: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex') }] }));
|
||||
assert.equal(desktopLaunchCommand(root, ['--hidden-window']).executablePath, executable);
|
||||
fs.appendFileSync(executable, 'changed');
|
||||
assert.throws(() => desktopLaunchCommand(root, ['--hidden-window']), /桌面程序与原发行清单不一致/);
|
||||
});
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"protocol": "workbench.mnemo-bridge-fixture-source.v1",
|
||||
"description": "Independently frozen Mnemo V1 digest vectors, synthetic data only; not a real provider or Workbench joint acceptance.",
|
||||
"source": "D:/Ai-project/Mnemo/docs/integration/project-memory-bridge/digest-vectors.json",
|
||||
"sha256": "2ed45ff142981131b9442c76ebddc41625ee0270b4fc95a15fea5acb90bad7e0",
|
||||
"protocolDocumentSha256": "7689cf34ab14d4c5608aa87ee95ea4fd4b33bb65eac46fe44be6d916d3d34379"
|
||||
}
|
||||
+171
@@ -0,0 +1,171 @@
|
||||
{
|
||||
"protocol": "mnemo.project-memory.digest-vectors.v1",
|
||||
"syntheticOnly": true,
|
||||
"credentialsIncluded": false,
|
||||
"scope": "Offline byte-format vectors; timestamps are fixed examples, not fresh live manifests or joint Workbench acceptance",
|
||||
"algorithm": "SHA256 of UTF-8 JSON.stringify of explicitly ordered objects; no BOM or Unicode/newline normalization",
|
||||
"confirmed": {
|
||||
"input": {
|
||||
"protocol": "mnemo.project-memory.v1",
|
||||
"bindingId": "22222222-2222-4222-8222-222222222222",
|
||||
"requestKey": "33333333-3333-4333-8333-333333333333",
|
||||
"source": {
|
||||
"id": "wb-memory-1",
|
||||
"sequence": 1,
|
||||
"version": "rev-1",
|
||||
"state": "current",
|
||||
"fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"expiresAt": null,
|
||||
"confirmation": {
|
||||
"by": "user",
|
||||
"at": "2026-11-07T00:00:00.000Z"
|
||||
}
|
||||
},
|
||||
"memory": {
|
||||
"title": "项目构建约定",
|
||||
"content": "使用 Python 3.12。\n检查命令:pytest。",
|
||||
"kind": "decision"
|
||||
}
|
||||
},
|
||||
"sourcePayloadJson": "{\"source\":{\"id\":\"wb-memory-1\",\"sequence\":1,\"version\":\"rev-1\",\"state\":\"current\",\"fingerprint\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"expiresAt\":null,\"confirmation\":{\"by\":\"user\",\"at\":\"2026-11-07T00:00:00.000Z\"}},\"memory\":{\"title\":\"项目构建约定\",\"content\":\"使用 Python 3.12。\\n检查命令:pytest。\",\"kind\":\"decision\"}}",
|
||||
"sourceDigest": "9147a52197306426f53f980ffc259b1132e9b6f33bc78b401c97745f2bc31178",
|
||||
"eventDigest": "fa83bf18ad757215e1eee7827804e103fb943bcdfd174550bff6aace6a0678ac"
|
||||
},
|
||||
"archived": {
|
||||
"input": {
|
||||
"protocol": "mnemo.project-memory.v1",
|
||||
"bindingId": "22222222-2222-4222-8222-222222222222",
|
||||
"requestKey": "44444444-4444-4444-8444-444444444444",
|
||||
"source": {
|
||||
"id": "wb-memory-1",
|
||||
"sequence": 2,
|
||||
"version": "rev-2",
|
||||
"state": "archived",
|
||||
"fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"expiresAt": null,
|
||||
"confirmation": null
|
||||
},
|
||||
"memory": null
|
||||
},
|
||||
"sourcePayloadJson": "{\"source\":{\"id\":\"wb-memory-1\",\"sequence\":2,\"version\":\"rev-2\",\"state\":\"archived\",\"fingerprint\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"expiresAt\":null,\"confirmation\":null},\"memory\":null}",
|
||||
"sourceDigest": "90105b552b97f165f73100a7824d51af36ecb50964a55dcbed6b2a90bd1329df",
|
||||
"eventDigest": "ff29e762bb4cb4cebc4f4791db8ec872903bc93e0d5d3f5e4ef1d2cb9d3a7999"
|
||||
},
|
||||
"secondConfirmed": {
|
||||
"input": {
|
||||
"protocol": "mnemo.project-memory.v1",
|
||||
"bindingId": "22222222-2222-4222-8222-222222222222",
|
||||
"requestKey": "55555555-5555-4555-8555-555555555555",
|
||||
"source": {
|
||||
"id": "wb-memory-0",
|
||||
"sequence": 9,
|
||||
"version": "rev-9",
|
||||
"state": "current",
|
||||
"fingerprint": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
|
||||
"expiresAt": null,
|
||||
"confirmation": {
|
||||
"by": "user",
|
||||
"at": "2026-11-07T00:00:00.000Z"
|
||||
}
|
||||
},
|
||||
"memory": {
|
||||
"title": "权限约定",
|
||||
"content": "发布前核对当前项目授权。",
|
||||
"kind": "preference"
|
||||
}
|
||||
},
|
||||
"sourcePayloadJson": "{\"source\":{\"id\":\"wb-memory-0\",\"sequence\":9,\"version\":\"rev-9\",\"state\":\"current\",\"fingerprint\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\",\"expiresAt\":null,\"confirmation\":{\"by\":\"user\",\"at\":\"2026-11-07T00:00:00.000Z\"}},\"memory\":{\"title\":\"权限约定\",\"content\":\"发布前核对当前项目授权。\",\"kind\":\"preference\"}}",
|
||||
"sourceDigest": "bd1f22a1c5c31fde0293269cc045a77219373f4e8990cd17fb44cad2b81b6e57",
|
||||
"eventDigest": "c9779f0beb0c81bfd6bf6ce6dd2c7ecb7cca86a24706e11a3daef65e1e6ccb46"
|
||||
},
|
||||
"manifest": {
|
||||
"input": {
|
||||
"projectId": "example-project",
|
||||
"projectFingerprint": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
|
||||
"checkedAt": "2026-11-07T00:00:01.000Z",
|
||||
"complete": true,
|
||||
"sources": [
|
||||
{
|
||||
"id": "wb-memory-1",
|
||||
"sequence": 1,
|
||||
"digest": "9147a52197306426f53f980ffc259b1132e9b6f33bc78b401c97745f2bc31178"
|
||||
},
|
||||
{
|
||||
"id": "wb-memory-0",
|
||||
"sequence": 9,
|
||||
"digest": "bd1f22a1c5c31fde0293269cc045a77219373f4e8990cd17fb44cad2b81b6e57"
|
||||
}
|
||||
]
|
||||
},
|
||||
"digest": "262c6937b26ff1b1fc7bb2e7e3620ddb1d2dc38c3b5317ae454a344f8d34dd32",
|
||||
"reorderedSourceIds": ["wb-memory-0", "wb-memory-1"],
|
||||
"sameContentNewTime": {
|
||||
"projectId": "example-project",
|
||||
"projectFingerprint": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
|
||||
"checkedAt": "2026-11-07T00:00:03.000Z",
|
||||
"complete": true,
|
||||
"sources": [
|
||||
{
|
||||
"id": "wb-memory-1",
|
||||
"sequence": 1,
|
||||
"digest": "9147a52197306426f53f980ffc259b1132e9b6f33bc78b401c97745f2bc31178"
|
||||
},
|
||||
{
|
||||
"id": "wb-memory-0",
|
||||
"sequence": 9,
|
||||
"digest": "bd1f22a1c5c31fde0293269cc045a77219373f4e8990cd17fb44cad2b81b6e57"
|
||||
}
|
||||
]
|
||||
},
|
||||
"sameContentNewTimeDigest": "262c6937b26ff1b1fc7bb2e7e3620ddb1d2dc38c3b5317ae454a344f8d34dd32",
|
||||
"checkedAtExcluded": true
|
||||
},
|
||||
"recall": {
|
||||
"protocol": "mnemo.project-memory.v1",
|
||||
"entries": [
|
||||
{
|
||||
"title": "项目构建约定",
|
||||
"content": "使用 Python 3.12。\n检查命令:pytest。",
|
||||
"kind": "decision",
|
||||
"origin": "authorized_project_mirror",
|
||||
"bindingId": "22222222-2222-4222-8222-222222222222",
|
||||
"projectId": "example-project",
|
||||
"memoryId": "66666666-6666-4666-8666-666666666666",
|
||||
"revision": 1,
|
||||
"source": {
|
||||
"id": "wb-memory-1",
|
||||
"sequence": 1,
|
||||
"version": "rev-1",
|
||||
"state": "current",
|
||||
"fingerprint": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
|
||||
"expiresAt": null,
|
||||
"confirmation": {
|
||||
"by": "user",
|
||||
"at": "2026-11-07T00:00:00.000Z"
|
||||
}
|
||||
},
|
||||
"sourceDigest": "9147a52197306426f53f980ffc259b1132e9b6f33bc78b401c97745f2bc31178",
|
||||
"visibility": "private"
|
||||
}
|
||||
],
|
||||
"snapshot": {
|
||||
"id": "77777777-7777-4777-8777-777777777777",
|
||||
"bindingId": "22222222-2222-4222-8222-222222222222",
|
||||
"grantId": "88888888-8888-4888-8888-888888888888",
|
||||
"manifestDigest": "262c6937b26ff1b1fc7bb2e7e3620ddb1d2dc38c3b5317ae454a344f8d34dd32",
|
||||
"contextDigest": "b9fedde1d1b2eccaa9b5d15aa428fb9e0f32ace55788f5bbb42253cca20283e1",
|
||||
"issuedAt": "2026-11-07T00:00:02.000Z",
|
||||
"expiresAt": "2026-11-07T00:00:31.000Z",
|
||||
"refs": [
|
||||
{
|
||||
"sourceId": "wb-memory-1",
|
||||
"sequence": 1,
|
||||
"sourceDigest": "9147a52197306426f53f980ffc259b1132e9b6f33bc78b401c97745f2bc31178",
|
||||
"memoryId": "66666666-6666-4666-8666-666666666666",
|
||||
"revision": 1
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"contextDigest": "b9fedde1d1b2eccaa9b5d15aa428fb9e0f32ace55788f5bbb42253cca20283e1"
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
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);
|
||||
});
|
||||
@@ -0,0 +1,53 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import fs from 'node:fs';
|
||||
import { MnemoClient, MNEMO_PROTOCOL, sourceDigest, eventDigest, manifestDigest, contextDigest, bridgeOrigin, checkRecall } from '../src/core/memory/mnemo-protocol.mjs';
|
||||
|
||||
const vectors = JSON.parse(fs.readFileSync(new URL('./fixtures/mnemo-bridge/digest-vectors.json', import.meta.url)));
|
||||
test('Mnemo V1 uses the independently frozen ordered Unicode/newline digest vectors', () => {
|
||||
for (const name of ['confirmed', 'archived', 'secondConfirmed']) {
|
||||
const v = vectors[name]; assert.equal(sourceDigest(v.input.source, v.input.memory), v.sourceDigest); assert.equal(eventDigest(v.input), v.eventDigest);
|
||||
}
|
||||
assert.equal(manifestDigest(vectors.manifest.input), vectors.manifest.digest);
|
||||
assert.equal(contextDigest(vectors.recall.entries), vectors.contextDigest);
|
||||
});
|
||||
test('bridge endpoints reject credentials, redirects-to-path configuration and nonlocal plaintext', () => {
|
||||
for (const value of ['http://example.com', 'https://a/x', 'https://a/?q=1', 'https://user:pass@a/', 'https://a/#x']) assert.throws(() => bridgeOrigin(value));
|
||||
assert.equal(bridgeOrigin('http://127.0.0.1:12345'), 'http://127.0.0.1:12345');
|
||||
});
|
||||
const input = () => ({ ...structuredClone(vectors.confirmed.input), requestKey: randomUUID() });
|
||||
const options = transport => ({ enabled: true, baseUrl: 'http://127.0.0.1:12345', bindingId: vectors.confirmed.input.bindingId, producerId: randomUUID(), projectId: 'fixture', token: 'only-synthetic', fetch: transport });
|
||||
test('transport failures and incomplete/mismatched sync receipts are UNKNOWN, not local 409 rejections', async () => {
|
||||
for (const fetch of [async () => { throw new TypeError('connection reset'); }, async () => new Response('{'), async () => Response.json({ protocol: MNEMO_PROTOCOL })]) {
|
||||
const client = new MnemoClient(options(fetch)); await assert.rejects(client.sync(input()), { code: 'PROJECT_SYNC_UNKNOWN' });
|
||||
}
|
||||
const client = new MnemoClient(options(async () => Response.json({ code: 'PROJECT_SEQUENCE_CONFLICT' }, { status: 409 })));
|
||||
await assert.rejects(client.sync(input()), { code: 'PROJECT_SEQUENCE_CONFLICT', status: 409 });
|
||||
});
|
||||
test('default-off sends zero bridge requests and an invalid body never changes original strings', async () => {
|
||||
let calls = 0; const client = new MnemoClient({ ...options(async () => { calls++; }), enabled: false });
|
||||
await assert.rejects(client.capabilities(), { code: 'PROJECT_BRIDGE_DISABLED' }); assert.equal(calls, 0);
|
||||
const original = input(); original.memory.content = '中\n'.repeat(6001); const bytes = JSON.stringify(original);
|
||||
await assert.rejects(client.sync(original)); assert.equal(JSON.stringify(original), bytes); assert.equal(calls, 0);
|
||||
});
|
||||
|
||||
test('received HTTP rejection retains upstream codes outside the local namespace and original diagnostic', async () => {
|
||||
const trace = [], raw = { code: 'AUTH_GRANT_REVOKED', message: 'Project grant revoked' };
|
||||
const client = new MnemoClient({ ...options(async () => Response.json(raw, { status: 401 })), observe: value => trace.push(value) });
|
||||
await assert.rejects(client.capabilities(), { code: raw.code, status: 401, message: '项目记忆服务拒绝本次操作(HTTP 401)。' });
|
||||
assert.equal(trace[0].httpStatus, 401); assert.deepEqual(trace[0].response, raw);
|
||||
await assert.rejects(client.sync(input()), { code: raw.code, status: 401 });
|
||||
assert.equal(trace.length, 2);
|
||||
});
|
||||
test('200 recall cannot authorize corrupted content, mismatched context or foreign projects', () => {
|
||||
const v = vectors.confirmed.input, now = new Date().toISOString();
|
||||
const manifest = { projectId: 'fixture', projectFingerprint: 'b'.repeat(64), checkedAt: now, complete: true, sources: [{ id: v.source.id, sequence: v.source.sequence, digest: vectors.confirmed.sourceDigest }] };
|
||||
const entry = { origin: 'authorized_project_mirror', bindingId: v.bindingId, projectId: 'fixture', memoryId: randomUUID(), revision: 1, source: v.source, sourceDigest: vectors.confirmed.sourceDigest, ...v.memory, visibility: 'private' };
|
||||
const snapshot = { id: randomUUID(), bindingId: v.bindingId, grantId: randomUUID(), manifestDigest: manifestDigest(manifest), contextDigest: contextDigest([entry]), issuedAt: now,
|
||||
expiresAt: new Date(Date.now() + 20000).toISOString(), refs: [{ sourceId: entry.source.id, sequence: entry.source.sequence, sourceDigest: entry.sourceDigest, memoryId: entry.memoryId, revision: entry.revision }] };
|
||||
const result = { protocol: MNEMO_PROTOCOL, entries: [entry], snapshot }; assert.equal(checkRecall(result, v.bindingId, manifest), result);
|
||||
for (const change of [r => { r.entries[0].content += 'corrupt'; }, r => { r.snapshot.contextDigest = 'a'.repeat(64); }, r => { r.entries[0].projectId = 'another'; }, r => { r.snapshot.expiresAt = new Date(Date.now() + 60000).toISOString(); }]) {
|
||||
const bad = structuredClone(result); change(bad); assert.throws(() => checkRecall(bad, v.bindingId, manifest));
|
||||
}
|
||||
});
|
||||
@@ -1,6 +1,8 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import http from 'node:http';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { EventEmitter } from 'node:events';
|
||||
import { fixture, until, workspace } from './helpers.mjs';
|
||||
import { Provider } from '../src/server/provider.mjs';
|
||||
@@ -12,7 +14,8 @@ import { usageSamples, usageModelId, cacheUsageFixture } from './fixtures/cache-
|
||||
import { historicalAttempts, inspectExport, hash } from './fixtures/request-ledger-data.mjs';
|
||||
import { StateDatabase as LegacyStateDatabase } from './fixtures/legacy-request-ledger/state-database.mjs';
|
||||
import { ModelHub } from '../src/core/models/model-hub.mjs';
|
||||
import { installUpgrade } from '../src/server/hot-upgrade.mjs';
|
||||
import { installUpgrade, rollbackUnchangedUpgrade } from '../src/server/hot-upgrade.mjs';
|
||||
import { HostAuthority } from '../src/core/desktop/host-authority.mjs';
|
||||
const originalMeta = store => store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get()?.value;
|
||||
const provider = () => Object.assign(Object.create(Provider.prototype), { apiKey: '' });
|
||||
const owned = (id, status = 'completed') => ({ id, connectionId: 'owned-alpha', model: 'owned-new', runId: id, status, usageStatus: 'unknown', usage: null, startedAt: '2026-11-07T00:00:00Z' });
|
||||
@@ -142,6 +145,68 @@ test('failed retained handler adoption restores the original storage prototype,
|
||||
assert.equal(storage.database.prepare("SELECT COUNT(*) AS n FROM sqlite_schema WHERE name='model_attempts'").get().n, 0);
|
||||
});
|
||||
|
||||
test('source-bound untouched hot adoption restores the exact legacy shape while new outcomes refuse schema downgrade or handler rollback', async t => {
|
||||
const f = await retainedLegacy(t), storage = f.store.storage, prototype = Object.getPrototypeOf(storage), attempts = f.hub.attempts, original = originalMeta(f.store);
|
||||
const credentials = f.actual.credentials;
|
||||
installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false });
|
||||
assert.throws(() => rollbackUnchangedUpgrade(f.context, { appDirectory: f.root }), /source-bound/);
|
||||
assert.equal(rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }).restored, true);
|
||||
assert.equal(Object.getPrototypeOf(storage), prototype); assert.equal(f.hub.attempts, attempts); assert.equal(Object.hasOwn(f.hub, 'attempts'), true);
|
||||
assert.equal(f.hub.ledger, undefined); assert.equal(originalMeta(f.store), original); assert.equal(f.actual.credentials, credentials);
|
||||
assert.equal(storage.database.prepare('PRAGMA user_version').get().user_version, 1); assert.equal(f.server.listeners('request')[0], f.originalHandler);
|
||||
installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false });
|
||||
f.hub.ledger.save(owned('new-post-adoption-result'));
|
||||
const handler = f.server.listeners('request')[0];
|
||||
assert.throws(() => rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }), /已有新记录/);
|
||||
assert.equal(f.server.listeners('request')[0], handler); assert.equal(f.hub.ledger.page().total, 108);
|
||||
assert.equal(storage.database.prepare('PRAGMA user_version').get().user_version, 2); assert.equal(originalMeta(f.store), original);
|
||||
});
|
||||
|
||||
async function retainedRegisteredLegacy(t) {
|
||||
const f = await retainedLegacy(t), oldRoot = path.join(f.root, 'previous-program'); fs.mkdirSync(oldRoot);
|
||||
for (const directory of ['dist-client', 'dist-server']) fs.cpSync(path.join(workspace, directory), path.join(oldRoot, directory), { recursive: true });
|
||||
fs.copyFileSync(path.join(workspace, 'package.json'), path.join(oldRoot, 'package.json'));
|
||||
f.context.runtime.appDirectory = oldRoot;
|
||||
const authority = new HostAuthority({ ...f.context, appDirectory: oldRoot });
|
||||
f.server.workbenchHostAuthority = authority;
|
||||
const identity = authority.identity(), infoFile = path.join(f.data, 'service-info.json');
|
||||
// Legal original formatting must also survive; reserializing is insufficient.
|
||||
fs.appendFileSync(infoFile, '\n ');
|
||||
return { ...f, authority, identity, infoFile, info: fs.readFileSync(infoFile),
|
||||
registration: fs.readFileSync(path.join(f.data, '.secrets/host-authority-v1.json')) };
|
||||
}
|
||||
|
||||
test('untouched adoption restores actual registered authority and exact public index together, retaining original registration and results', async t => {
|
||||
const f = await retainedRegisteredLegacy(t), results = { original: 'retained runtime results' }; f.context.runtime.results = results;
|
||||
installUpgrade(f.context, { appDirectory: workspace });
|
||||
const published = JSON.parse(fs.readFileSync(f.infoFile));
|
||||
assert.equal(published.runtimeRoot, fs.realpathSync.native(workspace));
|
||||
assert.notEqual(published.runtimeRoot, f.identity.runtimeRoot);
|
||||
assert.equal(f.authority.identity().runtimeRoot, published.runtimeRoot);
|
||||
assert.equal(rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }).restored, true);
|
||||
assert.equal(f.server.workbenchHostAuthority, f.authority);
|
||||
assert.deepEqual(f.authority.identity(), f.identity);
|
||||
assert.ok(fs.readFileSync(f.infoFile).equals(f.info));
|
||||
assert.ok(fs.readFileSync(path.join(f.data, '.secrets/host-authority-v1.json')).equals(f.registration));
|
||||
assert.equal(f.context.runtime.results, results);
|
||||
assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 1);
|
||||
assert.equal(f.server.listeners('request')[0], f.originalHandler);
|
||||
});
|
||||
|
||||
test('external public index drift refuses untouched rollback before removing the ledger or replacing the current handler', async t => {
|
||||
const f = await retainedRegisteredLegacy(t);
|
||||
installUpgrade(f.context, { appDirectory: workspace });
|
||||
const handler = f.server.listeners('request')[0], published = fs.readFileSync(f.infoFile);
|
||||
const external = Buffer.from(published.toString('utf8') + '\n '); fs.writeFileSync(f.infoFile, external);
|
||||
assert.throws(() => rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }), /host index changed outside this adoption/);
|
||||
assert.ok(fs.readFileSync(f.infoFile).equals(external));
|
||||
assert.equal(f.server.listeners('request')[0], handler);
|
||||
assert.equal(f.context.runtime.appDirectory, fs.realpathSync.native(workspace));
|
||||
assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 2);
|
||||
assert.equal(f.hub.ledger.page().total, f.rows.length);
|
||||
assert.ok(fs.readFileSync(path.join(f.data, '.secrets/host-authority-v1.json')).equals(f.registration));
|
||||
});
|
||||
|
||||
test('full export holds a read snapshot while live rows change, keeps all raw fields and ends with complete count and byte checksum', async t => {
|
||||
const f = fixture(t, { modernDefaults: true }), rows = historicalAttempts(); f.store.storage.setMeta('modelAttempts', rows); const ledger = new ModelRequestLedger(f.store.storage);
|
||||
const snapshot = ledger.exportSnapshot(), response = new Response(line => { if (JSON.parse(line).type === 'header') { ledger.save({ ...rows[500], reason: 'export-time change' }); ledger.save(owned('owned-during-export')); } });
|
||||
|
||||
Reference in New Issue
Block a user