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