146 lines
12 KiB
JavaScript
146 lines
12 KiB
JavaScript
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, readState } 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('large retained history can finish activation and record a rollback above the old 4 MiB receipt cap', async t => {
|
|
const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null;
|
|
f.store.storage.transaction(() => {
|
|
f.store.storage.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(f.session.id, f.project.id);
|
|
f.store.storage.database.exec("INSERT INTO outbox(seq) SELECT seq FROM events WHERE type='owned.large_history'");
|
|
});
|
|
const before = snapshotPersistentData(f.data), activated = await m.activate();
|
|
assert.ok(fs.statSync(activated.receiptFile).size > 4 * 1024 * 1024);
|
|
assert.equal(readState(activated.receiptFile).state, 'activated');
|
|
assert.deepEqual(snapshotPersistentData(f.data), before);
|
|
const pointer = fs.readFileSync(m.recordFile);
|
|
m.candidateRoot = candidate(f, 'owned-large-history-b');
|
|
await assert.rejects(m.activate({ afterPointer: () => { throw Error('owned-large-history-rollback'); } }), /owned-large-history-rollback/);
|
|
assert.equal(readState(m.receiptFile).state, 'failed');
|
|
assert.equal(readState(m.receiptFile).rollback, 'pointer-preserved');
|
|
assert.ok(fs.statSync(m.receiptFile).size > 4 * 1024 * 1024);
|
|
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);
|
|
});
|