Files
Agent-Workbench/docs/controlled-engine-retained-deployment-verifier.mjs
T
2026-10-31 08:16:56 +08:00

126 lines
12 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import assert from 'node:assert/strict';
import { createHash } from 'node:crypto';
import { DatabaseSync } from 'node:sqlite';
// Verification of an already completed upgrade. This script has no installer,
// inspector, model, project command, or task/tool execution entry point.
const version = '1.14.0', previousVersion = '1.13.0';
const read = file => JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
const hash = bytes => createHash('sha256').update(bytes).digest('hex');
const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object'
? Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])])) : value;
const digest = value => hash(JSON.stringify(canonical(value)));
const directory = path.resolve('.qa/controlled-engine-deployment-c17f1733-ec1c-4df5-8e9c-d733db09cf94');
const before = read(path.join(directory, 'before.json')), upgraded = read(path.join(directory, 'upgrade.json'));
const preflight = read('docs/controlled-engine-service-preflight.json');
const release = read('releases/latest.json'), source = read('.qa/source-package-validation.json');
const archives = read('.qa/archives-validation.json'), portable = read('.qa/release-validation.json');
const baseline = read('docs/controlled-engine-final-release-baseline.json'), compared = read('.qa/controlled-engine-final-inputs-comparison.json');
const qaChange = read('docs/controlled-engine-portable-qa-change.json');
const node = read('.qa/controlled-engine-retained-node-observation.json');
assert.equal(before.version, previousVersion); assert.equal(preflight.version, previousVersion);
assert.equal(before.pid, preflight.pid); assert.equal(preflight.pid, preflight.registeredPid);
assert.equal(upgraded.version, version); assert.equal(upgraded.verified, true); assert.equal(upgraded.connectionPreserved, true);
assert.equal(qaChange.success, true); assert.equal(qaChange.change.path, 'scripts/verify-release.mjs');
assert.deepEqual(source.inputs, baseline.sourceValidatedInputs);
for (const [name, report] of Object.entries({ source, archives, portable, compared })) {
assert.equal(report.success, true, name); assert.equal(report.version, version, name);
}
assert.deepEqual(source.tests, { tests: 445, pass: 445, fail: 0, cancelled: 0, skipped: 0, todo: 0 });
assert.equal(source.buildMatchedFiles, 6); assert.equal(source.actualControlled.success, true);
assert.equal(source.actualControlled.cases, 4); assert.equal(source.actualControlled.realModelRequests, 0); assert.equal(source.actualControlled.rootExited, true);
assert.equal(portable.actualControlled.success, true); assert.equal(portable.actualControlled.cases.length, 4);
assert.equal(portable.actualControlled.realModelRequests, 0); assert.equal(portable.actualControlled.contained, true);
assert.equal(fs.realpathSync.native(portable.appRoot), fs.realpathSync.native(release.portableRoot));
for (const kind of ['source', 'portable']) {
const archive = archives.archives.find(value => value.kind === kind);
assert.equal(archive.sha256, release[kind].sha256); assert.equal(hash(fs.readFileSync(release[kind].path)), archive.sha256);
}
for (const row of baseline.inputs) for (const root of [process.cwd(), release.sourceRoot]) {
const bytes = fs.readFileSync(path.join(root, row.path)); assert.equal(bytes.length, row.bytes); assert.equal(hash(bytes), row.sha256, row.path);
}
assert.equal(compared.finalPortableRoot, release.portableRoot); assert.equal(compared.finalSourceRoot, release.sourceRoot);
assert.equal(compared.buildMatchedFiles, 6); assert.equal(compared.comparedFiles, 8836);
assert.equal(compared.sourceInputsExactToFinal, 252); assert.deepEqual(compared.validationOnlyDifferences.map(value => value.path), ['scripts/verify-release.mjs']);
const ui = read('docs/controlled-engine-all-ui-validation.json'), projects = read('docs/controlled-engine-final-projects-validation.json');
assert.equal(ui.success, true); assert.equal(ui.version, version); assert.equal(ui.groups, 178); assert.equal(ui.results.length, 23);
assert.equal(projects.success, true); assert.equal(projects.testedVersion, version); assert.equal(projects.targetVersion, version);
assert.equal(projects.results.length, 3); assert.equal(projects.realModelRequests, 0); assert.ok(projects.results.every(value => value.success));
const base = 'http://127.0.0.1:4318'; let token;
async function api(route) {
const response = await fetch(base + '/api' + route, { headers: { Connection: 'close', ...(token ? { 'X-Workbench-Token': token } : {}) }, signal: AbortSignal.timeout(20000) });
assert.ok(response.ok, route + ': HTTP ' + response.status); return response.json();
}
const after = await api('/bootstrap'); token = after.token;
const health = await api('/health'), info = read(path.join(process.env.LOCALAPPDATA, 'AgentWorkbench/service-info.json'));
assert.equal(after.version, version); assert.equal(health.version, version); assert.equal(health.pid, before.pid); assert.equal(info.pid, before.pid);
assert.equal(fs.realpathSync.native(info.appRoot), fs.realpathSync.native(preflight.appRoot));
assert.equal(fs.realpathSync.native(info.runtimeRoot), fs.realpathSync.native(release.portableRoot));
assert.equal(fs.realpathSync.native(after.runtimeRoot), fs.realpathSync.native(release.portableRoot));
assert.equal(fs.realpathSync.native(info.dataRoot), fs.realpathSync.native(preflight.dataRoot));
assert.equal(digest(after.config), before.configSha256); assert.equal(digest(after.projects), before.projectsSha256); assert.equal(digest(after.sessions), before.sessionsSha256);
const modelCenter = await api('/model-center'); assert.equal(digest(modelCenter), before.modelCenterSha256);
assert.equal(modelCenter.waiting, 0); assert.ok(modelCenter.connections.every(value => value.activeRequests === 0));
function snapshotDb() {
const db = new DatabaseSync(path.join(info.dataRoot, 'workbench.sqlite'), { readOnly: true }); db.exec('BEGIN');
try {
const tables = {};
for (const { name: table } of db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all()) {
const rows = db.prepare('SELECT * FROM "' + table.replaceAll('"', '""') + '" ORDER BY rowid').all();
tables[table] = { count: rows.length, sha256: digest(rows), rows: rows.map((row, index) => ({ id: row.id ?? row.key ?? row.seq ?? index, ...(row.kind ? { kind: row.kind } : {}), sha256: digest(row) })) };
}
return { tables, sessions: db.prepare("SELECT id,json_extract(payload,'$.archived') AS archived FROM sessions ORDER BY id").all(),
recordKinds: db.prepare('SELECT kind,COUNT(*) AS count FROM records GROUP BY kind ORDER BY kind').all() };
} finally { db.exec('ROLLBACK'); db.close(); }
}
assert.deepEqual(canonical(snapshotDb()), canonical(before.database), 'All original rows, schemas, counts and hashes must match exactly.');
for (const saved of before.exports) {
const value = await api('/sessions/' + saved.id + '/export');
for (const kind of ['project', 'session', 'execution']) assert.equal(digest(value[kind]), saved[kind], saved.id + ':' + kind);
}
await assert.rejects(fetch('http://127.0.0.1:9229/json/list', { signal: AbortSignal.timeout(1000) }));
const headers = Object.fromEntries((await fetch(base)).headers);
assert.equal(headers['x-frame-options'], 'DENY'); assert.match(headers['content-security-policy'], /frame-ancestors 'none'/);
const rea = await api('/research/availability'); assert.equal(rea.status, 'available'); assert.equal(rea.version, '6.8.0');
assert.equal(fs.realpathSync.native(rea.packageRoot), fs.realpathSync.native(path.join(release.portableRoot, 'runtime/node_modules/rea-agents')));
assert.equal((await api('/engines/deepseek/availability')).status, 'available');
const controlled = await api('/engines/deepseek/controlled-availability'); assert.equal(controlled.controlledStatus, 'available');
assert.equal(node.pid, health.pid); assert.ok(Date.parse(node.createdAt) < Date.parse(preflight.observedAt));
assert.equal(fs.realpathSync.native(controlled.node.path), fs.realpathSync.native(node.executablePath));
assert.equal(fs.realpathSync.native(node.executablePath), fs.realpathSync.native(path.join(info.appRoot, 'runtime/node.exe')));
assert.equal(fs.realpathSync.native(node.finalBundledNodePath), fs.realpathSync.native(path.join(release.portableRoot, 'runtime/node.exe')));
assert.equal(hash(fs.readFileSync(node.executablePath)), node.executableSha256);
assert.equal(hash(fs.readFileSync(node.finalBundledNodePath)), node.finalBundledNodeSha256);
assert.equal(node.executableSha256, node.finalBundledNodeSha256); assert.equal(controlled.node.sha256, node.executableSha256);
assert.equal(controlled.node.version, '24.22.1');
const purge = await api('/engines/purge/source'); assert.equal(purge.status, 'available'); assert.equal(purge.defaultEnabled, false);
assert.equal((await api('/sessions/' + after.sessions[0].id + '/browser')).availability.status, 'available');
assert.deepEqual(canonical(snapshotDb()), canonical(before.database), 'Read-only re-verification must not change the original database.');
const result = { success: true, version, previousVersion, testedAt: new Date().toISOString(), ...upgraded, directory,
appRoot: release.portableRoot, dataRoot: info.dataRoot, originalAppRoot: info.appRoot, pid: health.pid,
model: after.config.model, hasKey: after.config.hasKey, allSessionCount: before.database.sessions.length, visibleSessionCount: after.sessions.length,
archivedSessionCount: before.database.sessions.filter(value => value.archived).length,
database: Object.fromEntries(Object.entries(before.database.tables).map(([name, value]) => [name, { count: value.count, sha256: value.sha256 }])),
recordKinds: before.database.recordKinds, preservedSessionSnapshots: before.exports, allRowsAndExportsPreserved: true, inspectorClosed: true,
comparedFiles: compared.comparedFiles, repackedMetadata: compared.repackedMetadata, frozenInputs: source.inputFiles, independentSourceRoot: source.sourceRoot,
independentSourceTests: source.tests, uiGroups: ui.groups, projectSamples: projects.results.length, realModelRequests: 0, headers,
comparison: 'Exact original canonical hashes of all database rows and all session/project/execution exports, no omitted fields.',
preflight, historicalReleasePid: preflight.historicalReleasePid, preservesCurrentObservedProcess: true,
modelCenterPreserved: true, modelCenter: { sha256: digest(modelCenter), connections: modelCenter.connections.length, pools: modelCenter.pools.length,
imports: modelCenter.imports.length, attempts: modelCenter.attempts.length }, retainedHostNode: node,
verificationResumed: { beforePath: path.join(directory, 'before.json'), upgradePath: path.join(directory, 'upgrade.json'),
originalFailureLog: '.qa/controlled-engine-deployment-log.txt', upgradeReplayed: false,
correctedExpectation: 'Retained PID uses its actual original process.execPath. Both actual and new bundled Node binaries match exact SHA256/version.' },
credentialsHandling: 'Only public configuration flags and data hashes. Original Provider stays in the process; no model credentials read/copied/printed/saved and no model requests.' };
fs.writeFileSync(path.join(directory, 'verification-after-upgrade.json'), JSON.stringify(result, null, 2) + '\n');
fs.writeFileSync('docs/controlled-engine-upgrade-live-validation.json', JSON.stringify(result, null, 2) + '\n');
fs.writeFileSync('docs/deployment.json', JSON.stringify({ ready: true, url: base, version, mode: after.config.mode, model: after.config.model, hasKey: after.config.hasKey,
pid: health.pid, appRoot: release.portableRoot, originalAppRoot: info.appRoot, dataRoot: info.dataRoot, installedAt: new Date().toISOString(), verification: 'controlled-engine-upgrade-live-validation.json' }, null, 2) + '\n');
console.log(JSON.stringify({ success: true, version, pid: health.pid, hasKey: after.config.hasKey, allSessions: result.allSessionCount,
counts: Object.fromEntries(Object.entries(result.database).map(([name, value]) => [name, value.count])), allRowsAndExportsPreserved: true,
retainedNodeExact: true, inspectorClosed: true, upgradeReplayed: false, realModelRequests: 0 }));