123 lines
11 KiB
JavaScript
123 lines
11 KiB
JavaScript
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { createHash } from 'node:crypto';
|
|
import { DatabaseSync } from 'node:sqlite';
|
|
import { isDeepStrictEqual } from 'node:util';
|
|
import { canonicalHost, hostError } from '../../shared/contracts/desktop-host.mjs';
|
|
import { assertLocalTree, ownedChild, readState } from './file-state.mjs';
|
|
import { REQUEST_LEDGER_MIGRATION, REQUEST_LEDGER_OBJECTS, databaseSchemaObjects, legacyLedgerRow } from '../storage/request-ledger-schema.mjs';
|
|
|
|
const digest = value => createHash('sha256').update(value).digest('hex');
|
|
const rowHash = row => digest(JSON.stringify(canonicalHost(row)));
|
|
const fail = message => hostError(message, 'INSTALLATION_REJECTED', 409);
|
|
const same = (a, b, message) => { if (!isDeepStrictEqual(a, b)) throw fail(message); };
|
|
const shaPattern = /^[a-f0-9]{64}$/;
|
|
const contractFile = 'dist-server/data-compatibility.json';
|
|
|
|
// The declaration is generated after compilation and binds both executable
|
|
// bundles. An earlier, undeclared program is never inferred to support schema2.
|
|
export function readDataCompatibility(appRoot) {
|
|
if (!fs.existsSync(path.join(appRoot, contractFile))) return { source: 'legacy-undeclared', readWriteSchemas: [1], ledgerMigration: null };
|
|
const declared = readState(ownedChild(appRoot, contractFile));
|
|
same(Object.keys(declared).sort(), ['application', 'bundles', 'ledgerMigration', 'readWriteSchemas', 'schemaVersion', 'sourceInputs'].sort(), '候选数据库能力声明含未知字段。');
|
|
if (declared.schemaVersion !== 1 || declared.application !== 'agent-workbench-database') throw fail('候选数据库能力声明版本无效。');
|
|
same(declared.readWriteSchemas, [1, 2], '候选数据库读写范围未经核验。');
|
|
same(declared.ledgerMigration, REQUEST_LEDGER_MIGRATION, '候选请求账本迁移身份与已核验定义不同。');
|
|
const expectedBundles = ['dist-server/server.mjs', 'dist-server/hot-upgrade.mjs'];
|
|
if (!Array.isArray(declared.bundles) || !Array.isArray(declared.sourceInputs)) throw fail('候选数据库声明输入必须为完整清单。');
|
|
same(declared.bundles?.map(row => row.path).sort(), expectedBundles.slice().sort(), '候选数据库声明未绑定完整处理器。');
|
|
for (const row of declared.bundles) {
|
|
same(Object.keys(row).sort(), ['bytes', 'path', 'sha256'], '候选数据库处理器绑定字段无效。');
|
|
const bytes = fs.readFileSync(ownedChild(appRoot, row.path));
|
|
if (row.bytes !== bytes.length || !shaPattern.test(row.sha256) || digest(bytes) !== row.sha256) throw fail('候选数据库声明与实际处理器原字节不同。');
|
|
}
|
|
const sourceNames = ['src/core/models/request-ledger.mjs', 'src/core/storage/state-database.mjs', 'src/core/storage/request-ledger-schema.mjs'];
|
|
same(declared.sourceInputs?.map(row => row.path).sort(), sourceNames.slice().sort(), '候选数据库声明来源不完整。');
|
|
if (declared.sourceInputs.some(row => Object.keys(row).sort().join(',') !== 'bytes,path,sha256' || !shaPattern.test(row.sha256) || !Number.isSafeInteger(row.bytes) || row.bytes < 1)) throw fail('候选数据库声明来源摘要无效。');
|
|
return { source: contractFile, readWriteSchemas: declared.readWriteSchemas, ledgerMigration: declared.ledgerMigration,
|
|
declarationSha256: digest(fs.readFileSync(ownedChild(appRoot, contractFile))), bundles: declared.bundles, sourceInputs: declared.sourceInputs };
|
|
}
|
|
|
|
export function assertDataCompatibility(snapshot, compatibility) {
|
|
const version = snapshot.database?.userVersion;
|
|
if (version !== undefined && !compatibility?.readWriteSchemas?.includes(version)) throw fail(`候选程序未声明支持数据库 schema${version},请选用已核验的兼容恢复载荷;原账本保持。`);
|
|
}
|
|
|
|
export function snapshotPersistentData(dataRoot) {
|
|
assertLocalTree(dataRoot);
|
|
const databaseFile = path.join(dataRoot, 'workbench.sqlite'), tables = {};
|
|
let databaseState = null;
|
|
if (fs.existsSync(databaseFile)) {
|
|
ownedChild(dataRoot, 'workbench.sqlite');
|
|
const database = new DatabaseSync(databaseFile, { readOnly: true });
|
|
try {
|
|
database.exec('PRAGMA busy_timeout=5000; BEGIN;');
|
|
const objects = databaseSchemaObjects(database);
|
|
for (const object of objects.filter(row => row.type === 'table')) {
|
|
if (!/^[a-z_]+$/.test(object.name)) throw fail('原数据库包含无法核对的表名。');
|
|
const rows = database.prepare('SELECT * FROM "' + object.name + '"').all().filter(row => !(object.name === 'metadata' && row.key === 'runtimeOwner'));
|
|
const hashes = rows.map(rowHash).sort(); tables[object.name] = { count: hashes.length, hashes };
|
|
}
|
|
const raw = tables.metadata ? database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get()?.value : undefined;
|
|
const markerRow = tables.metadata ? database.prepare("SELECT key,value FROM metadata WHERE key='modelAttemptLedger'").get() : undefined;
|
|
let entries;
|
|
try { entries = raw === undefined ? [] : JSON.parse(raw); } catch { throw fail('原请求账本 metadata 无法核对,原字节保持。'); }
|
|
if (!Array.isArray(entries) || entries.some(entry => !entry || typeof entry !== 'object' || Array.isArray(entry) || typeof entry.id !== 'string' || !entry.id)) throw fail('原请求账本 metadata 无法完整核对,原字节保持。');
|
|
const expectedRows = entries.map((entry, index) => {
|
|
const row = legacyLedgerRow(entry, index);
|
|
return { legacyPosition: index, sequence: row.seq, rowSha256: rowHash(row), payloadSha256: row.payload_sha256, initialSha256: row.initial_sha256 };
|
|
});
|
|
databaseState = { userVersion: database.prepare('PRAGMA user_version').get().user_version, objects,
|
|
sequences: database.prepare("SELECT name FROM sqlite_schema WHERE name='sqlite_sequence'").get()
|
|
? database.prepare('SELECT name,seq FROM sqlite_sequence ORDER BY name').all().map(row => ({ name: row.name, seq: row.seq })) : [],
|
|
legacyMetadata: raw === undefined ? null : { bytes: Buffer.byteLength(raw), sha256: digest(raw) }, expectedLegacyRows: expectedRows,
|
|
ledgerMarker: markerRow ? { value: JSON.parse(markerRow.value), rowSha256: rowHash(markerRow) } : null };
|
|
database.exec('ROLLBACK');
|
|
} finally { database.close(); }
|
|
}
|
|
const artifacts = [], artifactRoot = path.join(dataRoot, 'artifacts');
|
|
if (fs.existsSync(artifactRoot)) {
|
|
const walk = relative => { for (const entry of fs.readdirSync(path.join(artifactRoot, relative), { withFileTypes: true })) {
|
|
const next = path.posix.join(relative, entry.name), file = ownedChild(dataRoot, 'artifacts/' + next);
|
|
if (entry.isDirectory()) walk(next);
|
|
else if (entry.isFile()) { const bytes = fs.readFileSync(file); artifacts.push({ path: next, bytes: bytes.length, sha256: digest(bytes) }); }
|
|
else throw fail('原工件目录包含非常规文件。');
|
|
} }; walk('');
|
|
}
|
|
const files = ['config.json', 'projects.json'].filter(relative => fs.existsSync(path.join(dataRoot, relative)))
|
|
.map(relative => ({ path: relative, sha256: digest(fs.readFileSync(ownedChild(dataRoot, relative))) }));
|
|
assertLocalTree(dataRoot);
|
|
return { tables, database: databaseState, artifacts: artifacts.sort((a, b) => a.path.localeCompare(b.path)), files,
|
|
scope: 'Every persistent row except runtimeOwner, schema objects/user_version/sequences, every original artifact byte and public config/project files; no credential is decrypted or returned.' };
|
|
}
|
|
|
|
export function verifyPersistentDataTransition(before, after, compatibility) {
|
|
assertDataCompatibility(after, compatibility);
|
|
if (isDeepStrictEqual(before, after)) return { kind: 'unchanged', databaseSchema: after.database?.userVersion ?? null };
|
|
same(before.artifacts, after.artifacts, '安装更新改变了原工件字节。');
|
|
same(before.files, after.files, '安装更新改变了原公开配置或项目字节。');
|
|
const old = before.database, next = after.database;
|
|
if (!old || !next || old.userVersion !== 1 || next.userVersion !== 2 || old.ledgerMarker
|
|
|| Object.hasOwn(before.tables, 'model_attempts') || !isDeepStrictEqual(compatibility?.ledgerMigration, REQUEST_LEDGER_MIGRATION)) throw fail('安装更新不是已核验的精确请求账本迁移,原数据仍需核对。');
|
|
same(old.legacyMetadata, next.legacyMetadata, '迁移改变了原请求 metadata 字符串。');
|
|
same(old.expectedLegacyRows, next.expectedLegacyRows, '迁移原请求条目或顺序变化。');
|
|
const marker = next.ledgerMarker?.value;
|
|
if (!marker || Object.keys(marker).sort().join(',') !== 'id,legacyEntries,legacyMetadataSha256,migratedAt,originalMetadataPreserved,schemaVersion'
|
|
|| marker.schemaVersion !== 1 || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(marker.id)
|
|
|| marker.legacyEntries !== old.expectedLegacyRows.length || marker.legacyMetadataSha256 !== (old.legacyMetadata?.sha256 ?? null)
|
|
|| marker.originalMetadataPreserved !== true || typeof marker.migratedAt !== 'string'
|
|
|| !Number.isFinite(Date.parse(marker.migratedAt)) || new Date(marker.migratedAt).toISOString() !== marker.migratedAt) throw fail('请求账本迁移标记与原来源不同或含未知字段。');
|
|
const expectedObjects = [...old.objects, ...REQUEST_LEDGER_OBJECTS].sort((a, b) => a.name.localeCompare(b.name));
|
|
same(expectedObjects, next.objects.slice().sort((a, b) => a.name.localeCompare(b.name)), '迁移产生了未知表、索引、视图、触发器或改变了原 schema。');
|
|
const expectedSequences = old.sequences.concat(old.expectedLegacyRows.length ? [{ name: 'model_attempts', seq: old.expectedLegacyRows.length }] : []).sort((a, b) => a.name.localeCompare(b.name));
|
|
same(expectedSequences, next.sequences.slice().sort((a, b) => a.name.localeCompare(b.name)), '迁移改变了原数据库序号或账本序号。');
|
|
const expectedTables = structuredClone(before.tables);
|
|
if (!expectedTables.metadata) throw fail('原数据库缺少可核验 metadata 表。');
|
|
expectedTables.metadata = { count: before.tables.metadata.count + 1, hashes: before.tables.metadata.hashes.concat(next.ledgerMarker.rowSha256).sort() };
|
|
expectedTables.model_attempts = { count: old.expectedLegacyRows.length, hashes: old.expectedLegacyRows.map(row => row.rowSha256).sort() };
|
|
same(expectedTables, after.tables, '请求账本迁移少行、重复归属、记录/初始来源/搜索字段变化,或原持久行改变。');
|
|
return { kind: REQUEST_LEDGER_MIGRATION.id, migration: REQUEST_LEDGER_MIGRATION, legacyEntries: old.expectedLegacyRows.length,
|
|
originalMetadata: old.legacyMetadata, legacyRows: old.expectedLegacyRows, markerSha256: next.ledgerMarker.rowSha256,
|
|
originalRowsPreserved: true, originalArtifactsPreserved: true, originalConfigPreserved: true };
|
|
}
|