Files
Agent-Workbench/scripts/verify-previous-patch-install.mjs
T

142 lines
12 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import net from 'node:net';
import http from 'node:http';
import assert from 'node:assert/strict';
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
import { randomUUID, createHash } from 'node:crypto';
import { DatabaseSync } from 'node:sqlite';
import { buildWindowsInstaller } from './build-installer.mjs';
import { publicSnapshot, compareOriginalState } from './retained-host-state.mjs';
import { HostController } from '../src/core/desktop/host-controller.mjs';
import { snapshotPersistentData } from '../src/core/desktop/install-manager.mjs';
import { projectEnvironment } from '../src/core/process-environment.mjs';
if (process.argv.includes('--help')) {
console.log('node scripts/verify-previous-patch-install.mjs --previous-root ABSOLUTE_PORTABLE_ROOT — actual isolated previous-patch installation and retained-PID update to releases/latest.json. Synthetic credential only; no formal host or real model requests.');
process.exit(0);
}
assert.equal(process.argv.length, 4); assert.equal(process.argv[2], '--previous-root');
assert.ok(path.isAbsolute(process.argv[3]));
const workspace = process.cwd(), previousRoot = fs.realpathSync.native(process.argv[3]);
const read = file => JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
const latest = read('releases/latest.json'), candidateRoot = fs.realpathSync.native(latest.portableRoot);
const previous = read(path.join(previousRoot, 'MANIFEST.json')), candidate = read(path.join(candidateRoot, 'MANIFEST.json'));
const [major, minor, patch] = candidate.version.split('.').map(Number);
assert.ok(patch > 0); assert.equal(previous.version, `${major}.${minor}.${patch - 1}`);
assert.equal(previous.kind, 'portable'); assert.equal(candidate.kind, 'portable');
fs.mkdirSync(path.resolve('.qa'), { recursive: true });
const root = fs.mkdtempSync(path.resolve('.qa', 'pv-'));
const installRoot = path.join(root, 'program'), dataRoot = path.join(root, 'user-data'), appId = randomUUID();
const save = (name, value) => fs.writeFileSync(path.join(root, name), JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
const hash = value => createHash('sha256').update(value).digest('hex');
const maximumInstalledPath = Math.max(...previous.files.map(row => path.join(installRoot, 'versions', path.basename(previousRoot), row.path).length),
...candidate.files.map(row => path.join(installRoot, 'versions', path.basename(candidateRoot), row.path).length));
assert.ok(maximumInstalledPath < 250, 'Use a shorter workspace path for this Windows installer test.');
save('path-preflight.json', { maximumInstalledPath, installRoot });
const run = promisify(execFile), env = projectEnvironment();
const reserve = net.createServer(); await new Promise(resolve => reserve.listen(0, '127.0.0.1', resolve));
const port = reserve.address().port; await new Promise(resolve => reserve.close(resolve));
const key = 'owned-previous-patch-' + randomUUID(); let authenticated = 0;
const model = http.createServer((request, response) => {
assert.equal(request.headers.authorization, 'Bearer ' + key);
assert.equal(request.url, '/v1/models'); authenticated++;
response.writeHead(200, { 'Content-Type': 'application/json', Connection: 'close' });
response.end(JSON.stringify({ data: [{ id: 'owned-previous-patch-model' }] }));
});
await new Promise(resolve => model.listen(0, '127.0.0.1', resolve));
let controller, stage = 'build actual isolated installers', result;
const results = [], startedAt = new Date().toISOString();
function passed(name, detail = {}) { results.push({ name, passed: true, ...detail }); console.log('PASS ' + name); }
async function setup(installer, label) {
const log = path.join(root, label + '-setup.log'), began = Date.now(); let code = 0, output;
try { output = await run(installer.path, ['/VERYSILENT', '/SUPPRESSMSGBOXES', '/NORESTART', '/LOG=' + log,
'/DIR=' + installRoot, '/DATA_ROOT=' + dataRoot, '/PORT=' + port], { env, windowsHide: true, timeout: 600000, maxBuffer: 4 * 1024 * 1024 }); }
catch (error) { code = typeof error.code === 'number' ? error.code : -1; output = error; }
const receipt = { code, elapsedMs: Date.now() - began, log, sha256: hash(fs.readFileSync(log)) };
save(label + '-exit.json', receipt);
fs.writeFileSync(path.join(root, label + '-process.log'), String(output.stdout ?? '') + String(output.stderr ?? ''), { flag: 'wx' });
assert.equal(code, 0, 'Inspect original installer log: ' + log); return receipt;
}
try {
const oldSetup = buildWindowsInstaller({ root: workspace, portableRoot: previousRoot, outputRoot: root, name: 'previous-patch', qaFixture: { appId } });
const newSetup = buildWindowsInstaller({ root: workspace, portableRoot: candidateRoot, outputRoot: root, name: 'current-patch', qaFixture: { appId } });
save('installers.json', { previous: oldSetup, candidate: newSetup });
stage = 'actual previous-patch clean installation'; const oldReceipt = await setup(oldSetup, 'previous');
const oldInstalled = path.join(installRoot, 'versions', path.basename(previousRoot));
controller = new HostController({ appRoot: oldInstalled, dataRoot, port, timeoutMs: 60000 });
const original = (await controller.start()).identity;
const oldBootstrap = await controller.api('/bootstrap'); assert.equal(oldBootstrap.version, previous.version);
passed(stage, { ...oldReceipt, version: previous.version, pid: original.pid });
const projectRoot = path.join(root, 'owned-project'); fs.mkdirSync(projectRoot);
const initial = Buffer.from('\uFEFF# Owned previous-patch source\r\n'); fs.writeFileSync(path.join(projectRoot, 'README.md'), initial);
const project = await controller.api('/projects', { method: 'POST', input: { root: projectRoot } });
assert.equal(project.root, projectRoot);
const session = await controller.api('/sessions', { method: 'POST', input: { projectId: project.id } });
const database = new DatabaseSync(path.join(dataRoot, 'workbench.sqlite'));
try {
database.exec('BEGIN IMMEDIATE');
database.prepare(`WITH RECURSIVE n(v) AS (VALUES(1) UNION ALL SELECT v+1 FROM n WHERE v<35000)
INSERT INTO events(id,session_id,project_id,type,revision,created_at,payload)
SELECT 'owned-large-history-'||v,?,?,'owned.large_history',0,'2026-11-05T00:00:00.000Z','{}' FROM n`).run(session.id, project.id);
database.exec("INSERT INTO outbox(seq) SELECT seq FROM events WHERE type='owned.large_history'; COMMIT");
} finally { database.close(); }
save('large-history-fixture.json', { events: 35000, outbox: 35000, synthetic: true });
await controller.api('/config', { method: 'POST', input: { mode: 'compatible', model: 'owned-previous-patch-model',
baseUrl: 'http://127.0.0.1:' + model.address().port + '/v1', apiKey: key } });
await controller.api('/config/models', { method: 'POST', input: {} }); assert.equal(authenticated, 1);
const before = await publicSnapshot(controller.url, dataRoot); save('state-before.json', before);
const pointerBefore = read(path.join(installRoot, 'current.json')); save('pointer-before.json', pointerBefore);
assert.equal(before.version, previous.version); assert.equal(before.hasKey, true);
stage = 'actual previous-patch to current-patch update retains original PID and all data';
const receipt = await setup(newSetup, 'update');
const installedRoot = path.join(installRoot, 'versions', path.basename(candidateRoot));
controller = new HostController({ appRoot: installedRoot, dataRoot, port, timeoutMs: 60000 });
const connected = await controller.connect(); assert.equal(connected.identity.pid, original.pid);
assert.equal(connected.identity.instanceId, original.instanceId);
const after = await publicSnapshot(controller.url, dataRoot), retention = compareOriginalState(before, after,
{ credentialDefaultsSchemaChange: previous.version === '1.25.13' && candidate.version === '1.25.14' });
assert.equal(after.version, candidate.version); assert.equal(fs.realpathSync.native(after.runtimeRoot), fs.realpathSync.native(installedRoot));
const pointer = read(path.join(installRoot, 'current.json'));
assert.equal(pointer.revision, pointerBefore.revision + 1); assert.equal(pointer.previous.version, previous.version);
assert.equal(pointer.active.version, candidate.version); assert.deepEqual(fs.readFileSync(path.join(projectRoot, 'README.md')), initial);
await controller.api('/config/models', { method: 'POST', input: {} }); assert.equal(authenticated, 2);
const operationFile = fs.readdirSync(path.join(installRoot, '.installation')).filter(name => /^operation-.*\.json$/.test(name))
.map(name => path.join(installRoot, '.installation', name)).find(file => read(file).candidate.version === candidate.version);
assert.ok(operationFile); assert.equal(read(operationFile).state, 'activated');
const receiptBytes = fs.statSync(operationFile).size; assert.ok(receiptBytes > 4 * 1024 * 1024);
save('state-updated.json', after); save('pointer-updated.json', pointer);
passed(stage, { ...receipt, from: previous.version, to: after.version, pid: after.pid, instanceId: original.instanceId, retention, authenticated, receiptBytes });
if (candidate.version === '1.25.14') {
stage = 'save the retained old-process key internally and restore it in a new packaged process';
const current = (await controller.api('/model-center')).connections.find(connection => connection.id === 'legacy-default');
assert.equal(current.hasKey, true); assert.notEqual(current.savedCredential?.status, 'saved');
const saved = await controller.api('/model-center/credentials', { method: 'POST', input: { id: current.id, revision: current.revision, action: 'save-current' } });
assert.equal(saved.credential.status, 'saved');
const retained = saved.center.connections.find(connection => connection.id === current.id);
assert.equal(retained.revision, current.revision); assert.equal(retained.credentialRevision, current.credentialRevision);
const savedState = await publicSnapshot(controller.url, dataRoot); save('state-saved.json', savedState);
await controller.stop(); const fresh = await controller.start();
assert.notEqual(fresh.identity.pid, original.pid); assert.notEqual(fresh.identity.instanceId, original.instanceId);
const restored = await publicSnapshot(controller.url, dataRoot);
const restartRetention = compareOriginalState(savedState, { ...restored, pid: savedState.pid });
await controller.api('/config/models', { method: 'POST', input: {} }); assert.equal(authenticated, 3);
save('state-restarted.json', restored);
passed(stage, { pid: fresh.identity.pid, oldPid: original.pid, credentialRevision: retained.credentialRevision,
restartRetention, authenticated, savedCiphertextUnchanged: true });
}
stage = 'owned program uninstall preserves data';
await controller.stop(); controller = null;
const baseline = snapshotPersistentData(dataRoot), uninstallLog = path.join(root, 'uninstall.log');
await run(path.join(installRoot, 'unins000.exe'), ['/VERYSILENT', '/SUPPRESSMSGBOXES', '/NORESTART', '/LOG=' + uninstallLog], { env, windowsHide: true, timeout: 60000 });
assert.deepEqual(snapshotPersistentData(dataRoot), baseline);
passed(stage, { originalData: 'exact', log: uninstallLog });
result = { success: true };
} catch (error) { result = { success: false, stage, error: error.stack }; process.exitCode = 1; }
finally { if (controller) await controller.stop().catch(() => {}); model.closeAllConnections(); await new Promise(resolve => model.close(resolve)); }
result = { ...result, root, version: candidate.version, previousVersion: previous.version, sourceCommit: latest.documentation.sourceCommit,
previousRoot, candidateRoot, installRoot, dataRoot, port, appId, results, authenticated, startedAt, finishedAt: new Date().toISOString(),
realModelRequests: 0, realCredentialsAccessed: false };
save('result.json', result); console.log(JSON.stringify(result));