feat: integrate Orven workspace and engineering repairs for 1.25.9

This commit is contained in:
Agent Workbench Dev
2026-11-06 15:06:07 +08:00
parent 02043f6f8b
commit b3cb5d3420
21 changed files with 662 additions and 14 deletions
+117
View File
@@ -0,0 +1,117 @@
import fs from 'node:fs';
import path from 'node:path';
import net from 'node:net';
import assert from 'node:assert/strict';
import { execFileSync, spawn } from 'node:child_process';
import { fixture, launchWorkbench } from '../tests/helpers.mjs';
import { InstallationManager, snapshotPersistentData } from '../src/core/desktop/install-manager.mjs';
import { publicSnapshot, compareOriginalState, hash } from './retained-host-state.mjs';
// Explicit, write-once release operations. No model requests, credential access,
// task continuation, process restart or automatic installer retry.
const mode = process.argv[2], version = '1.25.9';
assert.ok(['register', 'install', 'before', 'upgrade', 'final'].includes(mode));
const root = path.resolve('.qa/orven-integration-1.25.9'), url = 'http://127.0.0.1:4318';
const read = file => JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
const save = (name, value) => {
const file = path.join(root, name); fs.mkdirSync(path.dirname(file), { recursive: true });
fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n', { flag: 'wx' });
};
fs.mkdirSync(root, { recursive: true });
save(mode + '-started.json', { mode, startedAt: new Date().toISOString() });
const disposers = [], t = { after: dispose => disposers.push(dispose) };
async function api(route) {
const boot = await (await fetch(url + '/api/bootstrap', { signal: AbortSignal.timeout(20000) })).json();
const response = await fetch(url + '/api' + route, { headers: { 'X-Workbench-Token': boot.token, Connection: 'close' }, signal: AbortSignal.timeout(20000) });
assert.equal(response.status, 200, route); return response.json();
}
async function inspectorClosed() {
await new Promise((resolve, reject) => {
const socket = net.createConnection({ host: '127.0.0.1', port: 9229 }); socket.setTimeout(1500);
socket.once('connect', () => { socket.destroy(); reject(Error('Inspector already open.')); });
socket.once('error', error => { socket.destroy(); error.code === 'ECONNREFUSED' ? resolve() : reject(error); });
socket.once('timeout', () => { socket.destroy(); reject(Error('Inspector state unknown.')); });
});
}
let result;
try {
if (mode === 'register') {
assert.equal(execFileSync('git', ['status', '--porcelain'], { encoding: 'utf8', windowsHide: true }).trim(), '');
const release = read('releases/latest.json'), manifest = read(path.join(release.portableRoot, 'MANIFEST.json'));
const source = read(process.env.AGENT_WORKBENCH_SOURCE_RELEASE);
const commit = execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8', windowsHide: true }).trim();
assert.equal(manifest.version, version); assert.equal(source.version, version);
assert.equal(source.sourceCommit, commit); assert.equal(release.documentation.sourceCommit, commit);
assert.equal(hash(fs.readFileSync(source.path)), source.sha256);
assert.equal(hash(fs.readFileSync(release.installer.path)), release.installer.sha256);
save('candidate.json', release); save('source.json', source);
result = { success: true, version, sourceCommit: commit, candidate: release.portableRoot };
} else {
const release = read(path.join(root, 'candidate.json')), registration = read(path.join(root, 'register.json'));
assert.equal(registration.success, true);
assert.equal(hash(fs.readFileSync(release.installer.path)), release.installer.sha256);
assert.equal(read(path.join(release.portableRoot, 'MANIFEST.json')).version, version);
if (mode === 'install') {
const f = fixture(t, { modernDefaults: true }); f.store.close();
const installRoot = path.join(root, 'installed', 'program'), target = path.join(installRoot, 'versions', path.basename(release.portableRoot));
assert.equal(fs.existsSync(target), false); fs.mkdirSync(path.dirname(target), { recursive: true });
fs.cpSync(release.portableRoot, target, { recursive: true, errorOnExist: true, force: false });
const before = snapshotPersistentData(f.data);
const manager = new InstallationManager({ installRoot, candidateRoot: target, dataRoot: f.data, port: 49997 });
const preflight = await manager.preflight({ stageOnly: true }), staged = await manager.activate({ stageOnly: true });
const activation = await manager.activate(); assert.equal(activation.phase, 'activated');
assert.deepEqual(snapshotPersistentData(f.data), before);
const host = await launchWorkbench(t, f.data, {}, { appRoot: target, nodePath: path.join(target, 'runtime/node.exe') });
const health = await (await fetch(host.url + '/api/health')).json();
assert.equal(health.version, version); assert.notEqual(new URL(host.url).port, '4318');
await host.close();
result = { success: true, version, target, preflight: preflight.phase, staged: staged.phase, activation: activation.phase,
originalData: 'exact', sourceCommit: registration.sourceCommit, scope: 'Actual isolated stage/activate/start. UI verification uses this installed program with separate owned data.' };
} else {
await inspectorClosed();
const host = await api('/host/status'); assert.equal(host.activity.active, false); assert.equal(host.desktopWindows.count, 0);
const current = await publicSnapshot(url, host.identity.dataRoot); assert.deepEqual(current.active, []);
const installRoot = path.dirname(path.dirname(host.identity.runtimeRoot)); assert.equal(path.basename(path.dirname(host.identity.runtimeRoot)), 'versions');
if (mode === 'before') {
assert.equal(current.version, '1.25.8'); save('formal/state-before.json', current); save('formal/host-before.json', host);
save('formal/pointer-before.json', read(path.join(installRoot, 'current.json')));
result = { success: true, version: current.version, pid: current.pid, projects: current.projects, sessions: current.database.sessionIds.length };
} else {
assert.equal(read(path.join(root, 'install.json')).success, true);
const before = read(path.join(root, 'formal/state-before.json')), originalHost = read(path.join(root, 'formal/host-before.json'));
compareOriginalState(before, current); assert.equal(host.identity.instanceId, originalHost.identity.instanceId);
if (mode === 'upgrade') {
for (const file of ['archive-verification.json', 'rebuild-result.json', 'installed-web/result.json', 'installed-electron/desktop-result.json']) {
const receipt = read(path.join(root, file));
const fixtureUI = receipt.fixtureOnly === true && receipt.userDataAccessed === false && receipt.checks?.length === 10 && receipt.errors?.length === 0 && receipt.realModelCalls === 0;
const nativeUI = receipt.isolatedHost === true && receipt.productionTouched === false && receipt.errors?.length === 0 && receipt.realModelCalls === 0;
assert.ok(receipt.success === true || fixtureUI || nativeUI, file);
}
assert.equal(current.version, '1.25.8');
assert.deepEqual(read(path.join(installRoot, 'current.json')), read(path.join(root, 'formal/pointer-before.json')));
const log = fs.openSync(path.join(root, 'formal/installer-process.log'), 'wx'), started = Date.now(); let code;
try {
code = await new Promise((resolve, reject) => {
const child = spawn(release.installer.path, ['/VERYSILENT', '/SUPPRESSMSGBOXES', '/NORESTART', '/LOG=' + path.join(root, 'formal/installer.log'), '/DIR=' + installRoot, '/DATA_ROOT=' + host.identity.dataRoot, '/PORT=4318'],
{ windowsHide: true, stdio: ['ignore', log, log] });
child.once('error', reject); child.once('close', resolve);
});
} finally { fs.closeSync(log); }
save('formal/installer-exit.json', { code, elapsedMs: Date.now() - started }); assert.equal(code, 0, 'Preserve this failed/unknown installation; do not replay.');
} else assert.equal(read(path.join(root, 'upgrade.json')).success, true);
const after = await publicSnapshot(url, host.identity.dataRoot), finalHost = await api('/host/status');
const retention = compareOriginalState(before, after); assert.equal(after.version, version);
assert.equal(finalHost.identity.instanceId, originalHost.identity.instanceId); assert.equal(finalHost.identity.pid, originalHost.identity.pid);
const target = path.join(installRoot, 'versions', path.basename(release.portableRoot));
assert.equal(fs.realpathSync.native(after.runtimeRoot), fs.realpathSync.native(target));
assert.equal(read(path.join(installRoot, 'current.json')).active.directory, path.basename(target));
await inspectorClosed(); save('formal/' + mode + '-state-after.json', after);
result = { success: true, version, pid: after.pid, instanceId: finalHost.identity.instanceId, runtimeRoot: after.runtimeRoot,
retention, projects: after.projects, sessions: after.database.sessionIds.length, sourceCommit: registration.sourceCommit, inspectorClosed: true };
}
}
}
} catch (error) { result = { success: false, error: error.stack }; process.exitCode = 1; }
finally { for (const dispose of disposers.reverse()) await dispose(); }
result = { ...result, mode, finishedAt: new Date().toISOString(), realModelRequests: 0, keyReadOrResaved: false };
save(mode + '.json', result); console.log(JSON.stringify(result));
+1 -1
View File
@@ -9,7 +9,7 @@ const disposers = [], t = { after: dispose => disposers.push(dispose) };
const f = fixture(t, { modernDefaults: true }); f.store.close();
const host = await launchWorkbench(t, f.data);
assert.notEqual(new URL(host.url).port, '4318');
const output = path.resolve('output/playwright/orven-appearance'); fs.mkdirSync(output, { recursive: true });
const output = path.resolve(process.env.ORVEN_QA_OUTPUT ?? 'output/playwright/orven-appearance'); fs.mkdirSync(output, { recursive: true });
const browser = await chromium.launch({ channel: 'msedge', headless: true });
const context = await browser.newContext({ viewport: { width: 1440, height: 960 } });
const page = await context.newPage(), checks = [], errors = [], mutations = [], contrast = [];
+4 -3
View File
@@ -10,11 +10,12 @@ const disposers = [], t = { after: dispose => disposers.push(dispose) };
const f = fixture(t, { modernDefaults: true }); f.store.close();
const host = await launchWorkbench(t, f.data);
assert.notEqual(new URL(host.url).port, '4318');
const output = path.resolve('output/playwright/orven'); fs.mkdirSync(output, { recursive: true });
const appRoot = path.resolve(process.env.AGENT_WORKBENCH_TEST_APP_ROOT ?? '.');
const output = path.resolve(process.env.ORVEN_QA_OUTPUT ?? 'output/playwright/orven'); fs.mkdirSync(output, { recursive: true });
let app;
try {
app = await _electron.launch({ executablePath: path.resolve('node_modules/electron/dist/electron.exe'),
args: [path.resolve('dist-desktop/main.cjs'), '--app-root', process.cwd(), '--data-root', f.data, '--node', process.execPath, '--port', new URL(host.url).port, '--hidden-window'],
app = await _electron.launch({ executablePath: process.env.ORVEN_QA_ELECTRON ?? path.resolve('node_modules/electron/dist/electron.exe'),
args: [path.join(appRoot, 'dist-desktop/main.cjs'), '--app-root', appRoot, '--data-root', f.data, '--node', process.execPath, '--port', new URL(host.url).port, '--hidden-window'],
env: projectEnvironment(), cwd: process.cwd(), timeout: 60000 });
const page = await app.firstWindow(), errors = [];
page.on('pageerror', error => errors.push(error.message));
+1 -1
View File
@@ -7,7 +7,7 @@ import { fixture, compatibleFixture, completion, call, launchWorkbench } from '.
// Real browser + real isolated host + local protocol fixture. No real model or user project.
const palette = process.env.ORVEN_QA_PALETTE ?? 'green';
assert.ok(['green', 'blue', 'purple'].includes(palette));
const output = path.resolve('output/playwright/' + (palette === 'green' ? 'orven' : 'orven-' + palette));
const output = path.resolve(process.env.ORVEN_QA_OUTPUT ?? ('output/playwright/' + (palette === 'green' ? 'orven' : 'orven-' + palette)));
fs.mkdirSync(output, { recursive: true });
const disposers = [], t = { after: dispose => disposers.push(dispose) };
const f = fixture(t, { modernDefaults: true });
+50
View File
@@ -0,0 +1,50 @@
"""Verify separate source/program releases without accessing installed user data."""
import hashlib
import json
import os
from pathlib import Path, PurePosixPath
import sys
import zipfile
source_receipt, output = sys.argv[1:]
release = json.loads(Path('releases/latest.json').read_text(encoding='utf-8'))
source = json.loads(Path(source_receipt).read_text(encoding='utf-8'))
program_root = Path(release['portableRoot'])
program = json.loads((program_root / 'MANIFEST.json').read_text(encoding='utf-8'))
assert source['sourceCommit'] == release['documentation']['sourceCommit']
assert source['version'] == program['version']
result = {'success': True, 'version': source['version'], 'sourceCommit': source['sourceCommit'], 'archives': []}
for kind, receipt, manifest, top in [
('program', release['portable'], program, program_root.name),
('source', source, source, 'Agent-Workbench-' + source['version'] + '-source'),
]:
archive_path = Path(receipt['path'])
assert archive_path.stat().st_size == receipt['bytes']
assert hashlib.sha256(archive_path.read_bytes()).hexdigest() == receipt['sha256']
expected = {entry['path']: entry for entry in manifest['files']}
assert len(expected) == len(manifest['files'])
if kind == 'program':
contents = (program_root / 'MANIFEST.json').read_bytes()
expected['MANIFEST.json'] = {'bytes': len(contents), 'sha256': hashlib.sha256(contents).hexdigest()}
seen = set()
with zipfile.ZipFile(archive_path) as bundle:
assert bundle.testzip() is None
for entry in bundle.infolist():
name = PurePosixPath(entry.filename.replace('\\', '/'))
assert not name.is_absolute() and '..' not in name.parts and name.parts[0] == top
if entry.is_dir():
continue
relative = '/'.join(name.parts[1:])
assert relative in expected and relative not in seen, relative
contents = bundle.read(entry)
assert len(contents) == expected[relative]['bytes'], relative
assert hashlib.sha256(contents).hexdigest() == expected[relative]['sha256'], relative
if kind == 'program':
assert (program_root / relative).read_bytes() == contents, relative
seen.add(relative)
assert seen == set(expected)
result['archives'].append({'kind': kind, 'files': len(seen), 'crc': 'passed', 'everyByteAndSha256': 'passed', 'path': str(archive_path)})
Path(output).parent.mkdir(parents=True, exist_ok=True)
with Path(output).open('x', encoding='utf-8') as stream:
json.dump(result, stream, ensure_ascii=False, indent=2)
print(json.dumps(result, ensure_ascii=False))