Files
Agent-Workbench/scripts/upgrade-running.mjs
Agent Workbench Dev e306f40cae
Official contracts and Windows source CI / windows-source (push) Has been cancelled
feat(memory): release Mnemo project bridge and schema2 recovery
2026-11-11 03:03:43 +08:00

193 lines
15 KiB
JavaScript

import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { setTimeout as delay } from 'node:timers/promises';
import packageManifest from '../package.json' with { type: 'json' };
// The current release is also a valid source for a retained-process update or
// rollback. JSON is bundled for compiled hosts and remains available beside
// this standalone script in the portable release, without requiring src/.
// Earlier patches of the same release line stay valid when the package version
// advances. Including only the current patch silently dropped 1.25.4 in 1.25.5.
const currentRelease = /^(\d+)\.(\d+)\.(\d+)$/.exec(packageManifest.version);
const releasePatches = currentRelease ? Array.from({ length: Number(currentRelease[3]) + 1 },
(_, patch) => currentRelease[1] + '.' + currentRelease[2] + '.' + patch) : [];
export const SUPPORTED_UPGRADE_VERSIONS = Object.freeze([...new Set([
'0.1.0', '1.0.0', '1.1.0', '1.2.0', '1.3.0', '1.4.0', '1.5.0', '1.5.1',
'1.6.0', '1.6.1', '1.6.2', '1.7.0', '1.8.0', '1.9.0', '1.10.0', '1.10.1',
'1.11.0', '1.12.0', '1.12.1', '1.13.0', '1.14.0', '1.15.0', '1.16.0', '1.17.0',
'1.18.0', '1.19.0', '1.20.0', '1.20.1', '1.20.2', '1.20.3', '1.21.0', '1.22.0',
'1.22.1', '1.23.0', '1.24.0', '1.24.1', '1.24.2', '1.24.3', '1.24.4', '1.24.5',
'1.24.6', '1.24.7', '1.24.8', '1.24.9', '1.25.0', '1.25.1', '1.25.2', '1.25.3',
...releasePatches, packageManifest.version,
])]);
function localUrl(value) {
const url = new URL(value);
if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || url.username || url.password || url.search || url.hash) throw new Error('Upgrade only accepts the local Workbench address.');
return url.origin;
}
async function within(promise, milliseconds, label) {
let timer;
try { return await Promise.race([promise, new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(label + ' timed out.')), milliseconds); })]); }
finally { clearTimeout(timer); }
}
async function readUpgradeJson(address, milliseconds, stage) {
try {
// Inspector pauses can outlast a server's keep-alive timeout. Use a fresh
// connection for each control request rather than reuse a stale pooled one.
const response = await fetch(address, { headers: { Connection: 'close' }, signal: AbortSignal.timeout(milliseconds) });
if (!response.ok) throw new Error('HTTP ' + response.status);
return await response.json();
} catch (error) {
throw new Error(stage + ': ' + error.message + (error.cause?.code ? ' (' + error.cause.code + ')' : ''), { cause: error });
}
}
class Protocol {
constructor(socket) {
this.socket = socket; this.nextId = 1; this.pending = new Map(); this.listeners = new Map();
socket.addEventListener('message', event => {
const message = JSON.parse(String(event.data));
if (message.id) {
const pending = this.pending.get(message.id); if (!pending) return;
this.pending.delete(message.id);
if (message.error) pending.reject(new Error(message.error.message)); else pending.resolve(message.result);
} else for (const listener of this.listeners.get(message.method) ?? []) listener(message.params);
});
socket.addEventListener('close', () => { for (const pending of this.pending.values()) pending.reject(new Error('Inspector connection closed.')); this.pending.clear(); });
}
on(method, listener) { this.listeners.set(method, [...(this.listeners.get(method) ?? []), listener]); }
send(method, params = {}) {
return within(new Promise((resolve, reject) => {
const id = this.nextId++; this.pending.set(id, { resolve, reject }); this.socket.send(JSON.stringify({ id, method, params }));
}), 10000, method);
}
}
function sameFile(url, file) {
try { return path.resolve(fileURLToPath(url)).toLowerCase() === path.resolve(file).toLowerCase(); } catch { return false; }
}
function sameTarget(target, file) {
if (sameFile(target.url, file)) return true;
const displayName = path.resolve(file).replaceAll('\\', '_').replaceAll('/', '_');
return target.title === displayName && target.url === 'file://' + displayName;
}
export async function upgradeRunning({ url, pid, currentRoot, newRoot, handlerRoot, rollbackInitialization = false }) {
if (typeof rollbackInitialization !== 'boolean' || rollbackInitialization && !handlerRoot) throw new Error('Initialization rollback requires the source-bound current handler root.');
const origin = localUrl(url), original = fs.realpathSync.native(currentRoot), next = fs.realpathSync.native(newRoot);
const originalScript = path.join(original, 'dist-server', 'server.mjs');
const upgradeScript = path.join(next, 'dist-server', 'hot-upgrade.mjs');
if (!fs.existsSync(originalScript) || !fs.existsSync(upgradeScript) || !fs.existsSync(path.join(next, 'dist-client', 'index.html'))) throw new Error('Upgrade bundles are incomplete.');
if (!Number.isInteger(pid) || pid < 1 || pid === process.pid) throw new Error('Invalid target process.');
const before = await readUpgradeJson(origin + '/api/bootstrap', 5000, 'Read original Workbench');
if (!before.token || !SUPPORTED_UPGRADE_VERSIONS.includes(before.version)) throw new Error('This migration accepts a supported existing Workbench.');
if (before.sessions.some(session => ['running', 'awaiting_approval', 'stopping'].includes(session.status))) throw new Error('Wait for existing tasks and approvals before upgrading.');
let protocol, socket, enabledHere = false, paused = false;
const breakpoints = [];
try {
let targets;
try { targets = await readUpgradeJson('http://127.0.0.1:9229/json/list', 500, 'Discover inspector'); } catch {}
if (targets && !targets.some(target => sameTarget(target, originalScript))) throw new Error('The local inspector port belongs to another process.');
if (!targets) {
process._debugProcess(pid); enabledHere = true;
for (let attempt = 0; attempt < 40 && !targets; attempt++) {
await delay(100);
try { targets = await readUpgradeJson('http://127.0.0.1:9229/json/list', 500, 'Discover opened inspector'); } catch {}
}
}
const target = targets?.find(item => sameTarget(item, originalScript));
if (!target || !target.webSocketDebuggerUrl?.startsWith('ws://127.0.0.1:9229/')) throw new Error('The expected Workbench inspector was not found.');
socket = new WebSocket(target.webSocketDebuggerUrl);
await within(new Promise((resolve, reject) => { socket.addEventListener('open', resolve, { once: true }); socket.addEventListener('error', reject, { once: true }); }), 10000, 'Inspector connection');
protocol = new Protocol(socket);
const scripts = [];
protocol.on('Debugger.scriptParsed', script => scripts.push(script));
let pausedResolve;
const pausedEvent = new Promise(resolve => { pausedResolve = resolve; });
protocol.on('Debugger.paused', event => { paused = true; pausedResolve(event); });
await protocol.send('Runtime.enable');
const identity = await protocol.send('Runtime.evaluate', { expression: 'process.pid', returnByValue: true });
if (identity.result.value !== pid) throw new Error('The inspector belongs to a different process.');
await protocol.send('Debugger.enable');
const previousRoot = handlerRoot || before.runtimeRoot;
const expectedScripts = [originalScript, ...(previousRoot ? [path.join(fs.realpathSync.native(previousRoot), 'dist-server', 'hot-upgrade.mjs')] : [])];
const candidates = scripts.filter(item => expectedScripts.some(file => sameFile(item.url, file)));
if (!candidates.length) throw new Error('The existing server module is missing from inspector metadata.');
for (const script of candidates) {
const { scriptSource } = await protocol.send('Debugger.getScriptSource', { scriptId: script.scriptId });
// Bundled transport libraries can parse request.url too. Select the
// actual loopback handler with its local base and observed port binding.
const locations = scriptSource.split('\n').flatMap((line, index) => /const url = new URL\(request\.url,\s*["']http:\/\/127\.0\.0\.1:["']\s*\+\s*actualPort\d*\)/.test(line) ? [index] : []);
if (locations.length !== 1) throw new Error('The existing request handler could not be identified uniquely.');
breakpoints.push((await protocol.send('Debugger.setBreakpoint', { location: { scriptId: script.scriptId, lineNumber: locations[0] } })).breakpointId);
}
const probe = readUpgradeJson(origin + '/api/health', 15000, 'Observe owned request handler');
probe.catch(() => {});
const event = await within(pausedEvent, 10000, 'Workbench request observation');
const captureExpression = "(() => {"
+ " const currentServer = typeof server !== 'undefined' ? server : typeof server2 !== 'undefined' ? server2 : undefined;"
+ " const currentStore = typeof store !== 'undefined' ? store : typeof store2 !== 'undefined' ? store2 : undefined;"
+ " const currentProvider = typeof provider !== 'undefined' ? provider : typeof provider2 !== 'undefined' ? provider2 : undefined;"
+ " const currentRuntime = typeof runtime !== 'undefined' ? runtime : typeof runtime2 !== 'undefined' ? runtime2 : undefined;"
+ " const currentToken = typeof token !== 'undefined' ? token : typeof token2 !== 'undefined' ? token2 : undefined;"
+ " const currentClients = typeof clients !== 'undefined' ? clients : typeof clients2 !== 'undefined' ? clients2 : undefined;"
+ " const currentStarted = typeof started !== 'undefined' ? started : typeof started2 !== 'undefined' ? started2 : undefined;"
+ " const currentExampleProject = typeof exampleProject !== 'undefined' ? exampleProject : typeof exampleProject2 !== 'undefined' ? exampleProject2 : undefined;"
+ " const currentShutdown = typeof shutdown !== 'undefined' ? shutdown : typeof shutdown2 !== 'undefined' ? shutdown2 : undefined;"
+ " const servers = currentServer ? [currentServer] : process._getActiveHandles().filter(handle => handle?.listening && handle.address?.()?.address === '127.0.0.1' && handle.address?.()?.port === " + new URL(origin).port + ");"
+ " if (servers.length !== 1 || !currentStore || !currentProvider || !currentRuntime || !currentToken || !currentClients || !currentShutdown) throw new Error('The existing Workbench context is incomplete.');"
+ " globalThis.__awUpgradeContext = { server: servers[0], store: currentStore, provider: currentProvider, runtime: currentRuntime, token: currentToken, clients: currentClients, started: currentStarted, exampleProject: currentExampleProject, shutdown: currentShutdown }; return 'context-ready'; })()";
const captured = await protocol.send('Debugger.evaluateOnCallFrame', { callFrameId: event.callFrames[0].callFrameId,
expression: captureExpression, returnByValue: true });
if (captured.exceptionDetails || captured.result.value !== 'context-ready') throw new Error('Could not retain the existing runtime objects.');
for (const breakpointId of breakpoints.splice(0)) await protocol.send('Debugger.removeBreakpoint', { breakpointId });
await protocol.send('Debugger.resume'); paused = false; await probe;
const restoreScript = rollbackInitialization ? path.join(fs.realpathSync.native(handlerRoot), 'dist-server/hot-upgrade.mjs') : null;
const restore = restoreScript ? ' const restoreModule = process.getBuiltinModule("module").createRequire(' + JSON.stringify(restoreScript) + ')(' + JSON.stringify(restoreScript) + ');'
+ ' restoreModule.rollbackUnchangedUpgrade(globalThis.__awUpgradeContext, { appDirectory: ' + JSON.stringify(fs.realpathSync.native(handlerRoot)) + ' });' : '';
const expression = '(() => { try { const module = process.getBuiltinModule("module").createRequire(' + JSON.stringify(upgradeScript) + ')(' + JSON.stringify(upgradeScript) + ');' + restore
+ ' return module.installUpgrade(globalThis.__awUpgradeContext, { appDirectory: ' + JSON.stringify(next) + ' }); } finally { delete globalThis.__awUpgradeContext; } })()';
const upgraded = await protocol.send('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true });
if (upgraded.exceptionDetails) throw new Error('Runtime upgrade failed: ' + (upgraded.exceptionDetails.exception?.description ?? upgraded.exceptionDetails.text));
const result = upgraded.result.value;
const after = await readUpgradeJson(origin + '/api/bootstrap', 5000, 'Read upgraded Workbench');
const health = await readUpgradeJson(origin + '/api/health', 5000, 'Verify upgraded PID');
if (health.pid !== pid || result.pid !== pid || after.version !== result.version || after.config.hasKey !== before.config.hasKey
|| after.config.model !== before.config.model || after.config.baseUrl !== before.config.baseUrl
|| JSON.stringify(after.projects) !== JSON.stringify(before.projects)
|| JSON.stringify(after.sessions) !== JSON.stringify(before.sessions)) throw new Error('The upgraded runtime did not preserve the existing state.');
return { ...result, verified: true, connectionPreserved: true, url: origin };
} finally {
if (protocol) {
for (const breakpointId of breakpoints) { try { await protocol.send('Debugger.removeBreakpoint', { breakpointId }); } catch {} }
try { if (paused) await protocol.send('Debugger.resume'); } catch {}
try { await protocol.send('Runtime.evaluate', { expression: 'delete globalThis.__awUpgradeContext; true', returnByValue: true }); } catch {}
if (enabledHere) {
try { await protocol.send('Runtime.evaluate', { expression: "setTimeout(() => process.getBuiltinModule('inspector').close(), 25); true", returnByValue: true }); } catch {}
}
}
socket?.close();
if (enabledHere) await delay(150);
}
}
// This file is also bundled as an installation library; its CLI must not run
// merely because esbuild gives it the install-manager entry's import.meta.url.
if (path.basename(fileURLToPath(import.meta.url)) === 'upgrade-running.mjs' && process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
const raw = process.argv.slice(2), args = {}, options = new Set(['url', 'pid', 'current-root', 'new-root', 'handler-root']);
if (raw.length === 1 && raw[0] === '--help') { console.log('node scripts/upgrade-running.mjs --pid PID --current-root DIR --new-root DIR [--url http://127.0.0.1:4318] [--handler-root DIR]'); process.exit(0); }
for (let index = 0; index < raw.length; index += 2) {
const key = raw[index].startsWith('--') ? raw[index].slice(2) : '';
if (!options.has(key) || Object.hasOwn(args, key) || !raw[index + 1] || raw[index + 1].startsWith('--')) throw new Error('Unknown or incomplete argument; use --help.');
args[key] = raw[index + 1];
}
if (!/^\d+$/.test(args.pid ?? '') || !path.isAbsolute(args['current-root'] ?? '') || !path.isAbsolute(args['new-root'] ?? '')
|| args['handler-root'] !== undefined && !path.isAbsolute(args['handler-root'])) throw new Error('PID and absolute current/new roots are required arguments; use --help.');
const result = await upgradeRunning({ url: args.url || 'http://127.0.0.1:4318', pid: Number(args.pid), currentRoot: args['current-root'], newRoot: args['new-root'], handlerRoot: args['handler-root'] });
console.log(JSON.stringify(result, null, 2));
}