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'; import { treeFile } from '../src/core/desktop/file-state.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('fast per-file scan still rejects a junctioned subdirectory, a hard-linked file and a stream path with the original bytes intact', t => { const f = fixture(t), root = candidate(f), identity = validateInstalledVersion(root); const server = path.join(root, 'dist-server'), moved = path.join(f.root, 'outside-server'); fs.renameSync(server, moved); fs.symlinkSync(moved, server, 'junction'); assert.throws(() => validateInstalledVersion(root), /链接|重解析/); assert.throws(() => inspectHostInstallation(root), /链接|重解析/); fs.rmdirSync(server); assert.ok(fs.existsSync(path.join(moved, 'server.mjs'))); fs.renameSync(moved, server); assert.deepEqual(validateInstalledVersion(root), identity); const original = path.join(root, 'dist-server/server.mjs'), alias = path.join(f.root, 'server-alias.mjs'); fs.linkSync(original, alias); assert.throws(() => validateInstalledVersion(root), /多个路径/); fs.unlinkSync(alias); assert.throws(() => treeFile(root, 'dist-server/server.mjs:stream'), /路径无效/); assert.throws(() => treeFile(root, '../outside.txt'), /超出所属目录/); assert.deepEqual(validateInstalledVersion(root), identity); }); 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('inventory rejects a new hardlink on an optional file after its full-manifest scan and accepts the untouched candidate after removal', t => { const f = fixture(t), root = candidate(f), relative = 'zz-optional-data.txt', original = Buffer.from('owned optional release data'); const file = path.join(root, relative), alias = path.join(f.root, 'outside-optional-alias.txt'); fs.writeFileSync(file, original); const manifestFile = path.join(root, 'MANIFEST.json'), manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8')); manifest.files.push({ path: relative, bytes: original.length, sha256: hash(original) }); fs.writeFileSync(manifestFile, JSON.stringify(manifest)); const before = validateInstalledVersion(root); let linked = false, fullScanFinished = false; assert.throws(() => validateInstalledVersion(root, { onProgress(progress) { if (progress.scope === 'full-manifest' && progress.completedFiles === progress.totalFiles) fullScanFinished = true; if (progress.scope === 'directory-inventory' && !linked) { assert.equal(fullScanFinished, true); fs.linkSync(file, alias); linked = true; } } }), /多个路径/); assert.equal(linked, true); assert.equal(fs.lstatSync(file).nlink, 2); assert.deepEqual(fs.readFileSync(file), original); assert.deepEqual(fs.readFileSync(alias), original); fs.unlinkSync(alias); assert.deepEqual(validateInstalledVersion(root), before); }); 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); });