import test from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import path from 'node:path'; import net from 'node:net'; import { createHash } from 'node:crypto'; import { fixture, workspace } from './helpers.mjs'; import { InstallationManager, validateInstalledVersion, snapshotPersistentData } from '../src/core/desktop/install-manager.mjs'; import { inspectHostInstallation } from '../src/core/desktop/app-installation.mjs'; const hash = value => createHash('sha256').update(value).digest('hex'); function candidate(f, name = 'owned-a', bootstrapBytes = 'declared-static-unit-fixture') { const root = path.join(f.root, 'install', 'versions', name); fs.mkdirSync(root, { recursive: true }); for (const directory of ['dist-client', 'dist-server', 'dist-desktop']) fs.cpSync(path.join(workspace, directory), path.join(root, directory), { recursive: true }); for (const file of ['AgentWorkbench.exe', 'runtime/node.exe', 'desktop/AgentWorkbench.exe', 'desktop/resources/app/main.cjs', 'desktop/resources/app/package.json']) { fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true }); fs.writeFileSync(path.join(root, file), 'declared-static-unit-fixture'); } fs.writeFileSync(path.join(root, 'AgentWorkbench.exe'), bootstrapBytes); const walk = (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() ? walk(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: JSON.parse(fs.readFileSync(path.join(workspace, 'package.json'))).version, platform: 'win32-x64', files: walk(root) })); return root; } const manager = (f, root) => new InstallationManager({ installRoot: path.join(f.root, 'install'), dataRoot: f.data, candidateRoot: root, port: 49999 }); test('full candidate validation returns the exact loaded-input host identity and rejects undeclared or altered files', t => { const f = fixture(t), root = candidate(f); assert.deepEqual(validateInstalledVersion(root), inspectHostInstallation(root)); fs.writeFileSync(path.join(root, 'extra.txt'), 'unknown'); assert.throws(() => validateInstalledVersion(root)); fs.unlinkSync(path.join(root, 'extra.txt')); fs.appendFileSync(path.join(root, 'dist-server/server.mjs'), '\nchanged'); assert.throws(() => validateInstalledVersion(root)); }); test('installation requires separate absolute program/data directories and a candidate in its own versions namespace', t => { const f = fixture(t), root = candidate(f); assert.throws(() => new InstallationManager({ installRoot: f.root, dataRoot: f.data })); assert.throws(() => new InstallationManager({ installRoot: 'relative', dataRoot: f.data })); const m = manager(f, root); m.candidateRoot = f.projectRoot; assert.throws(() => m.candidate()); }); test('staging retains the original data and pointer without querying or restarting a host', async t => { const f = fixture(t), root = candidate(f), m = manager(f, root), before = snapshotPersistentData(f.data); m.host = () => { throw Error('Staging must not contact the host'); }; const result = await m.activate({ stageOnly: true }); assert.equal(result.activated, false); assert.equal(m.current(), null); assert.deepEqual(snapshotPersistentData(f.data), before); }); test('a post-pointer failure restores every original pointer byte and persistent row; a first-install failure removes only its published pointer', async t => { const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; await assert.rejects(m.activate({ afterPointer: () => { throw Error('owned-first-failure'); } }), /owned-first-failure/); assert.equal(m.current(), null); await m.activate(); const pointer = fs.readFileSync(m.recordFile), before = snapshotPersistentData(f.data); m.candidateRoot = candidate(f, 'owned-b'); await assert.rejects(m.activate({ afterPointer: () => { throw Error('owned-post-pointer-failure'); } }), /owned-post-pointer-failure/); assert.deepEqual(fs.readFileSync(m.recordFile), pointer); assert.deepEqual(snapshotPersistentData(f.data), before); }); test('changed active manifest and concurrent pointer changes are rejected without overwriting the unknown record', async t => { const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; await m.activate(); fs.appendFileSync(path.join(root, 'MANIFEST.json'), ' '); assert.throws(() => m.current()); }); test('an unregistered non-HTTP listener blocks preflight even when service-info is absent', async t => { const f = fixture(t), root = candidate(f), server = net.createServer(socket => socket.on('error', () => {})); await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); f.onCleanup(() => new Promise(resolve => server.close(resolve))); const m = new InstallationManager({ installRoot: path.join(f.root, 'install'), dataRoot: f.data, candidateRoot: root, port: server.address().port }); await assert.rejects(m.preflight(), /端口/); assert.equal(m.current(), null); }); test('uninstall archives its original pointer and preserves every data row/artifact instead of recursively deleting data', async t => { const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; await m.activate(); const before = snapshotPersistentData(f.data), pointer = fs.readFileSync(m.recordFile); const result = await m.prepareUninstall(); assert.equal(result.dataPolicy, 'preserve-original-data'); assert.equal(m.current(), null); assert.deepEqual(snapshotPersistentData(f.data), before); const archive = fs.readdirSync(m.stateRoot).find(name => name.startsWith('uninstalled-')); assert.deepEqual(fs.readFileSync(path.join(m.stateRoot, archive)), pointer); }); test('preflight rejects an unrelated program root or changed native bootstrap while preserving its original bytes', async t => { const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; const unknown = path.join(m.installRoot, 'unrelated.exe'); fs.writeFileSync(unknown, 'owned-unknown-original'); await assert.rejects(m.preflight(), /未登记/); assert.equal(fs.readFileSync(unknown, 'utf8'), 'owned-unknown-original'); fs.unlinkSync(unknown); const launcher = path.join(m.installRoot, 'AgentWorkbench.exe'); fs.writeFileSync(launcher, 'owned-altered-bootstrap'); await assert.rejects(m.preflight(), /启动器/); assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-altered-bootstrap'); }); test('a changed owned bootstrap follows its candidate and a post-pointer fault restores both original bytes', async t => { const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; await m.activate(); const launcher = path.join(m.installRoot, 'AgentWorkbench.exe'), original = fs.readFileSync(launcher), pointer = fs.readFileSync(m.recordFile); m.candidateRoot = candidate(f, 'owned-bootstrap-b', 'owned-new-native-bootstrap'); await assert.rejects(m.activate({ afterPointer: () => { assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-new-native-bootstrap'); throw Error('owned-bootstrap-published-fault'); } }), /owned-bootstrap-published-fault/); assert.deepEqual(fs.readFileSync(launcher), original); assert.deepEqual(fs.readFileSync(m.recordFile), pointer); await m.preflight(); await m.activate(); assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-new-native-bootstrap'); await m.preflight(); }); test('an external bootstrap change after preflight is preserved and never overwritten as an update or rollback', async t => { const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; await m.activate(); const launcher = path.join(m.installRoot, 'AgentWorkbench.exe'), pointer = fs.readFileSync(m.recordFile); m.candidateRoot = candidate(f, 'owned-bootstrap-b', 'owned-new-native-bootstrap'); await assert.rejects(m.activate({ beforePointer: () => fs.writeFileSync(launcher, 'owned-external-bootstrap') }), /回退尚待核对/); assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-external-bootstrap'); assert.deepEqual(fs.readFileSync(m.recordFile), pointer); });