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); });