Files
Agent-Workbench/scripts/verify-desktop-host.mjs
T
2026-10-31 09:03:01 +08:00

73 lines
8.5 KiB
JavaScript

import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import http from 'node:http';
import net from 'node:net';
import { randomUUID, randomBytes, createHash } from 'node:crypto';
import { DatabaseSync } from 'node:sqlite';
import { HostController } from '../src/core/desktop/host-controller.mjs';
import { ownedChild, readState, writeState } from '../src/core/desktop/file-state.mjs';
import { observeWindowsProcess } from '../src/core/desktop/process-identity.mjs';
import { HOST_REGISTRATION_FILE } from '../src/shared/contracts/desktop-host.mjs';
if (process.argv.includes('--help')) { console.log('node scripts/verify-desktop-host.mjs - real Windows isolated host identity, concurrent start, request stop and restart acceptance.'); process.exit(0); }
if (process.argv.length > 2) throw new Error('Use --help.');
const root = path.resolve('.qa', 'desktop-host-' + randomUUID()), appRoot = path.join(root, 'app'), dataRoot = path.join(root, 'data');
fs.mkdirSync(appRoot, { recursive: true });
for (const directory of ['dist-server', 'dist-client']) fs.cpSync(path.resolve(directory), path.join(appRoot, directory), { recursive: true });
fs.copyFileSync('package.json', path.join(appRoot, 'package.json'));
const freePort = async () => { const server = net.createServer(); await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); const port = server.address().port; await new Promise(resolve => server.close(resolve)); return port; };
const port = await freePort(), options = { appRoot, dataRoot, port, nodePath: process.execPath, timeoutMs: 60000 };
const controller = new HostController(options), results = []; let stage = 'concurrent start', started = false, fixture;
const record = (name, detail = {}) => { results.push({ name, passed: true, ...detail }); console.log(name + ': passed'); };
const until = async action => { const end = Date.now() + 20000; while (!await action()) { if (Date.now() > end) throw new Error('Timed out: ' + stage); await new Promise(resolve => setTimeout(resolve, 100)); } };
const save = result => { fs.writeFileSync(path.join(root, 'result.json'), JSON.stringify(result, null, 2)); fs.writeFileSync('.qa/desktop-host-latest.json', JSON.stringify(result, null, 2)); };
const completedTools = id => {
const db = new DatabaseSync(path.join(dataRoot, 'workbench.sqlite'), { readOnly: true });
try { return db.prepare("SELECT payload FROM records WHERE kind='tool' AND session_id=? ORDER BY id").all(id).map(row => JSON.parse(row.payload)).filter(value => value.state === 'completed'); }
finally { db.close(); }
};
try {
const starts = await Promise.all([controller.start(), new HostController(options).start()]); started = true;
assert.equal(starts[0].identity.pid, starts[1].identity.pid); assert.equal(starts[0].identity.instanceId, starts[1].identity.instanceId);
assert.equal(starts.filter(value => !value.reused).length, 1); record(stage, { pid: starts[0].identity.pid, instanceId: starts[0].identity.instanceId });
const original = starts[0].identity;
stage = 'independent creation and user observation'; const observed = observeWindowsProcess(original.pid); assert.equal(observed.createdAt, original.createdAt); assert.equal(observed.userSid, original.userSid); record(stage);
const status = await controller.status(); assert.equal(status.state, 'ready'); assert.equal(status.windowClose, 'keep-host-running');
stage = 'wrong data root and installation rejected'; await assert.rejects(new HostController({ ...options, dataRoot: path.join(root, 'wrong-data') }).start());
const other = path.join(root, 'other-app'); fs.cpSync(appRoot, other, { recursive: true }); await assert.rejects(new HostController({ ...options, appRoot: other }).start()); record(stage);
stage = 'stale registration and creation rejected'; const registrationFile = ownedChild(dataRoot, '.secrets/' + HOST_REGISTRATION_FILE), registration = readState(registrationFile);
for (const changed of [{ createdAt: '2000-01-01T00:00:00.000Z' }, { instanceId: randomUUID() }, { userSid: 'S-1-5-21-1-2-3-1000' }, { secret: randomBytes(32).toString('base64') }]) {
writeState(registrationFile, { ...registration, ...changed }); await assert.rejects(new HostController(options).connect()); writeState(registrationFile, registration);
} record(stage);
stage = 'damaged service index rejected'; const infoFile = ownedChild(dataRoot, 'service-info.json'), info = readState(infoFile); writeState(infoFile, { ...info, runtimeRoot: other }); await assert.rejects(new HostController(options).connect()); writeState(infoFile, info); record(stage);
stage = 'running input binding does not silently change'; const serverFile = ownedChild(appRoot, 'dist-server/server.mjs'), bytes = fs.readFileSync(serverFile); fs.appendFileSync(serverFile, '\n// owned changed-on-disk fixture\n');
assert.equal((await controller.connect()).identity.runtimeIdentity, original.runtimeIdentity); await assert.rejects(new HostController(options).connect()); fs.writeFileSync(serverFile, bytes); record(stage);
stage = 'foreign health service rejected'; const foreignPort = await freePort(), foreign = http.createServer((_req, res) => { res.setHeader('Content-Type', 'application/json'); res.end(JSON.stringify({ app: 'agent-workbench', ready: true, pid: process.pid })); });
await new Promise(resolve => foreign.listen(foreignPort, '127.0.0.1', resolve));
try { await assert.rejects(new HostController({ ...options, port: foreignPort, dataRoot: path.join(root, 'foreign-data') }).start()); } finally { await new Promise(resolve => foreign.close(resolve)); } record(stage);
stage = 'completed tools and approvals retained on stop and restart'; const projectRoot = path.join(root, 'project'); fs.mkdirSync(projectRoot); fs.writeFileSync(path.join(projectRoot, 'README.md'), '# Owned desktop lifecycle fixture\n');
const project = await controller.api('/projects', { method: 'POST', input: { root: projectRoot } });
const session = await controller.api('/sessions', { method: 'POST', input: { projectId: project.id } });
await controller.api('/sessions/' + session.id + '/messages', { method: 'POST', input: { content: 'Run the offline demonstration in this owned project.' } });
await until(async () => (await controller.api('/sessions/' + session.id)).approvals.some(value => value.status === 'pending'));
const before = await controller.api('/sessions/' + session.id + '/export'), completed = completedTools(session.id); assert.ok(completed.length >= 3);
const completedHash = createHash('sha256').update(JSON.stringify(completed)).digest('hex');
const firstStop = await controller.stop(); started = false; assert.equal(firstStop.processExited, true); assert.equal(observeWindowsProcess(original.pid), null);
const second = await controller.start(); started = true; assert.notEqual(second.identity.instanceId, original.instanceId);
const restored = await controller.api('/sessions/' + session.id + '/export');
assert.equal(createHash('sha256').update(JSON.stringify(completedTools(session.id))).digest('hex'), completedHash);
assert.equal(restored.session.events.filter(value => value.kind === 'tool').length, before.session.events.filter(value => value.kind === 'tool').length);
assert.equal(restored.session.status, 'paused'); record(stage, { completedTools: completed.length, originalEventSeq: before.session.eventSeq, restoredEventSeq: restored.session.eventSeq });
stage = 'actual model HTTP request abort and verified process exit'; let requests = 0, disconnected = false;
fixture = http.createServer((req, res) => { requests++; res.on('close', () => { disconnected = true; }); req.resume(); }); await new Promise(resolve => fixture.listen(0, '127.0.0.1', resolve));
const pending = controller.api('/config/models', { method: 'POST', input: { baseUrl: 'http://127.0.0.1:' + fixture.address().port + '/v1', apiKey: 'owned-desktop-http-key' }, timeoutMs: 60000 }).catch(error => error);
await until(() => requests === 1); const stopped = await controller.stop(); started = false; await pending;
assert.equal(stopped.processExited, true); await until(() => disconnected); assert.equal(requests, 1); record(stage, { requests, disconnected, pid: stopped.identity.pid });
save({ success: true, root, appRoot, dataRoot, port, results, inference: 'Owned local HTTP fixtures only; no existing model credential is read or persisted.' });
} catch (cause) { save({ success: false, root, stage, results, message: cause.message, stack: cause.stack }); throw cause; }
finally {
if (fixture) { fixture.closeAllConnections(); await new Promise(resolve => fixture.close(resolve)); }
if (started) await controller.stop();
}