import test from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import path from 'node:path'; import http from 'node:http'; import { randomUUID } from 'node:crypto'; import { spawnSync } from 'node:child_process'; import { fixture, workspace } from './helpers.mjs'; import { Provider } from '../src/server/provider.mjs'; import { Runtime } from '../src/server/runtime.mjs'; import { installUpgrade } from '../src/server/hot-upgrade.mjs'; function databaseRows(store) { const database = store.storage.database; return Object.fromEntries(database.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all() .map(({ name }) => [name, database.prepare('SELECT * FROM "' + name.replaceAll('"', '""') + '" ORDER BY rowid').all()])); } async function context(t) { const f = fixture(t), provider = new Provider(), runtime = new Runtime(f.store, provider, { appDirectory: workspace }); provider.setKey('owned-controlled-upgrade-fixture'); f.store.claimRuntime(); const server = http.createServer((_request, response) => response.end('original-owned-handler')); await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); f.onCleanup(() => new Promise(resolve => { server.closeAllConnections(); server.close(resolve); })); return { ...f, provider, runtime, server, context: { server, store: f.store, provider, runtime, clients: new Set(), token: 'owned-controlled-upgrade-token', started: Date.now(), exampleProject: f.project, shutdown: () => {} } }; } function retainedEngineRecord(f, session) { // A declared persisted record for migration/read ownership; no native execution is claimed. return { id: randomUUID(), schemaVersion: 1, sessionId: session.id, projectId: session.projectId, taskId: session.taskId ?? null, runId: session.runId ?? null, status: 'unknown', requiresVerification: true, native: null, requests: [], calls: [], startedAt: '2026-01-01T00:00:00.000Z' }; } test('claiming the same runtime owner twice preserves its original metadata and every database row', t => { const f = fixture(t); f.store.claimRuntime(); const original = f.store.storage.meta('runtimeOwner'); original.startedAt = '2026-01-01T00:00:00.000Z'; f.store.storage.transaction(() => f.store.storage.setMeta('runtimeOwner', original)); const before = databaseRows(f.store); f.store.claimRuntime(); f.store.claimRuntime(); assert.deepEqual(f.store.storage.meta('runtimeOwner'), original); assert.deepEqual(databaseRows(f.store), before); }); test('sessions without controlled-engine history retain their prior export shape and never expose another session record', t => { const f = fixture(t), other = f.store.createSession(f.project.id), record = retainedEngineRecord(f, other); assert.equal(Object.hasOwn(f.store.executionSnapshot(f.session), 'engineRuns'), false); f.store.putRecord('engine_run', other, record, 'fixture.persisted-engine'); assert.equal(Object.hasOwn(f.store.executionSnapshot(f.session), 'engineRuns'), false); assert.deepEqual(f.store.executionSnapshot(other).engineRuns.map(value => value.id), [record.id]); }); test('live workers, controlled drivers, or MCP operations refuse an upgrade before changing handlers, managers or database rows', async t => { const f = await context(t), handlers = f.server.listeners('request'), before = databaseRows(f.store); for (const [name, manager] of [['workers', { active: new Map([[f.session.id, {}]]) }], ['controlledEngines', { drivers: new Map([[f.session.runId, { session: f.session }]]) }], ['mcp', { active: new Map([[randomUUID(), {}]]) }]]) { f.runtime[name] = manager; assert.throws(() => installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false }), /active|finish|upgrading/); assert.equal(f.runtime[name], manager); assert.deepEqual(f.server.listeners('request'), handlers); assert.deepEqual(databaseRows(f.store), before); delete f.runtime[name]; } }); test('an idle upgrade loads the newly introduced engine record map, resets obsolete managers and preserves original rows, sessions and provider objects', async t => { const f = await context(t), other = f.store.createSession(f.project.id), record = retainedEngineRecord(f, other); f.store.putRecord('engine_run', other, record, 'fixture.persisted-engine'); const before = databaseRows(f.store), exported = f.store.publicSession(f.session), tasks = f.store.core.task, provider = f.provider, credentials = provider.credentials; delete f.store.core.engine_run; f.runtime.workers = { active: new Map() }; f.runtime.controlledEngines = { drivers: new Map() }; installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false }); assert.equal(f.runtime.workers, null); assert.equal(f.runtime.controlledEngines, null); assert.equal(f.store.core.task, tasks); assert.equal(f.store.core.engine_run.size, 1); assert.deepEqual(f.store.core.engine_run.get(record.id), record); assert.equal(f.context.provider, provider); assert.equal(f.provider.credentials, credentials); assert.equal(f.provider.hasKey(), true); assert.deepEqual(f.store.publicSession(f.session), exported); assert.deepEqual(databaseRows(f.store), before); }); test('an installation failure restores old managers, original record maps, handlers and all existing database rows', async t => { const f = await context(t), workers = { active: new Map() }, engines = { drivers: new Map() }; f.runtime.workers = workers; f.runtime.controlledEngines = engines; delete f.store.core.engine_run; const core = f.store.core, handlers = f.server.listeners('request'), before = databaseRows(f.store), provider = f.provider; fs.mkdirSync(path.join(f.data, 'service-info.json')); assert.throws(() => installUpgrade(f.context, { appDirectory: workspace })); assert.equal(f.runtime.workers, workers); assert.equal(f.runtime.controlledEngines, engines); assert.equal(f.store.core, core); assert.equal(Object.hasOwn(core, 'engine_run'), false); assert.equal(f.context.provider, provider); assert.equal(provider.hasKey(), true); assert.deepEqual(f.server.listeners('request'), handlers); assert.deepEqual(databaseRows(f.store), before); }); test('the owned controlled driver remains an active session and project even after outer task activity has ended', t => { const f = fixture(t), provider = new Provider(), runtime = new Runtime(f.store, provider), runner = runtime.engineRunner(); assert.equal(runtime.hasActivity(), false); runner.drivers.set(f.session.runId, { session: f.session }); assert.equal(runtime.active.size, 0); assert.equal(runtime.hasActivity(), true); assert.equal(runtime.isActive(f.session.id), true); assert.equal(runtime.projectHasActivity(f.project.id), true); const parentRoot = path.join(f.root, 'parent-project'); fs.mkdirSync(parentRoot); const parentProject = f.store.addProject(parentRoot), parent = f.store.createSession(parentProject.id), manager = runtime.workerManager(); const id = randomUUID(); f.store.core.collaboration.set(id, { id, sessionId: parent.id, projectId: parentProject.id, status: 'paused', children: [{ sessionId: f.session.id }] }); assert.equal(manager.childActive(f.session.id), true); assert.equal(runtime.isActive(parent.id), true); assert.equal(runtime.projectHasActivity(parentProject.id), true); runner.drivers.clear(); assert.equal(runtime.hasActivity(), false); assert.equal(runtime.isActive(f.session.id), false); assert.equal(runtime.isActive(parent.id), false); assert.equal(runtime.projectHasActivity(parentProject.id), false); }); test('release and upgrade help or invalid arguments have no file or network setup side effects in an independent directory', t => { const f = fixture(t), before = fs.readdirSync(f.root).sort(); for (const script of ['package.mjs', 'upgrade-running.mjs']) { const help = spawnSync(process.execPath, [path.join(workspace, 'scripts', script), '--help'], { cwd: f.root, encoding: 'utf8', windowsHide: true, timeout: 10000 }); assert.equal(help.status, 0, help.stderr); assert.match(help.stdout, /node scripts/); const invalid = spawnSync(process.execPath, [path.join(workspace, 'scripts', script), '--unknown-owned-argument'], { cwd: f.root, encoding: 'utf8', windowsHide: true, timeout: 10000 }); assert.notEqual(invalid.status, 0); assert.match(invalid.stderr, /argument|option|Unsupported|Unknown/); assert.deepEqual(fs.readdirSync(f.root).sort(), before); } });