Compare commits

...
Author SHA1 Message Date
jason.woltje bbbefb3f28 fix(webui): triage fences re-check, only HOME may hold the stack's code: the code root names its holder, which must be a protected path, and no other protected path sets a source aside; a code root in or around the run dir or a fixed path is refused in either path's real spelling too; the mount, install root and protected lists are copied once so a changing list cannot pass one check and feed another; the refuse list adds PERLLIB, LESSOPEN, LESSCLOSE, HOSTALIASES and names ending _ASKPASS, _CA_BUNDLE or _BASE_URL (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje 2f91ff5bea fix(webui): triage fences review, HOME is not counted against the stack's own code: a caller's protected path that holds the code root sets aside a source whose named and real paths both lie in it, never the run dir or a fixed path, so pi starts from a copy or worktree under HOME; a refusal at the binds answers triage-route-invalid and removes what the start wrote; each mount field is read once and no dest lies in or around another; values refuse every C0 and C1 control and U+2028/U+2029; the token shape drops the m flag; the refuse list adds MALLOC_, NPM_CONFIG_, XDG_, names ending _DIR, _CONF or _CONFIG, and the libc, shell, OpenSSL and Java hooks (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje 1ca3a38f86 feat(webui): triage fences, the host checks a copy of the route's answer before anything is written or spawned: harnessEnv names must be declared by the harness module and are refused outright when MOSAIC_, NODE_, LD_, DYLD_, PYTHON, BASH_, GIT_, PATH, HOME, TMPDIR, ENV, a founder or a provider name; values are short clean strings; route env holds only the proxy's two names with a loopback base URL, and the host's port and token shape when given; the adapter and at most 8 mounts resolve inside the module's install roots and never in or around the data root, the config dir, HOME, /srv/mosaic or a secrets path, with dests clear of /tmp, the run dir and the system binds, checked again in hostedBinds; a refused answer answers triage-route-invalid and leaves a host line (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje cb80b2b8a8 fix(webui): triage drawer re-check notes, a scrolled-up reader keeps the right one of two identical lines in view, the unsafe-directory answer no longer says Triage did not start since it can come while a session runs, and the text cleaner removes every default-ignorable character (#1873, lane triage-drawer) 2026-11-16 15:04:49 -06:00
jason.woltje fd300b4fe3 fix(webui): triage drawer review, a scrolled-up reader keeps the line in view when the oldest lines drop at the 200-line cap, a failed start says the message is in the conversation and was not delivered, a read that turns sending off hides the box and keeps the draft, and the text cleaner removes every control, format, separator and invisible character (#1873, lane triage-drawer)
The test helper opens the drawer after the page's first render has focused its heading, as a person
would. A drawer opened before that loses focus to the heading (bus.js); that is left as a follow-up.
2026-11-16 14:51:27 -06:00
jason.woltje a88302d6eb feat(webui): triage drawer, the instance owner opens Triage from the top bar and reads its state, health and transcript, and sends a message when the route allows it; nobody else gets the entry, the markup or a request (#1873, lane triage-drawer)
The drawer reads GET /api/triage only while open. A poll keeps the draft and the reader's scroll place.
Every field is set as text. Cards show the command with no Run button, and the dropped count.
The send box shows only when config triageSend and the read's send are both true. It names each
answer in plain words, never resends, and keeps the draft after a refusal.
Workflows: Save with only the state changed in an add form says the step is not added yet and keeps
the form. The step picker no longer offers the system-only triage template.
2026-11-16 14:36:07 -06:00
12 changed files with 1512 additions and 56 deletions

No files matched your search

+18
View File
@@ -258,6 +258,24 @@ export returns:
`gateTimeout`, `bundle`, `env`, `turnEnd`, `outputPolicy` and `transcript` give its
sandbox binds, web, tool names, S0 lines, bundle files, adapter variables,
how a turn ends and where its transcripts land.
- `envNames` and `installRoots({env})` (#1873 triage-fences) are optional and
outside `kinds.mjs`. A session the Console hosts with no organization
(Triage) reads them; organization launches do not. `envNames` lists the
names `env()` returns, less the provider's. The host takes a route's
`harnessEnv` name only when it is listed here and is not one the host
always refuses: `MOSAIC_*`, `NODE_*`, `LD_*`, `DYLD_*`, `PYTHON*`, `BASH_*`,
`GIT_*`, `MALLOC_*`, `NPM_CONFIG_*`, `XDG_*`, any name ending in `_DIR`,
`_CONF` or `_CONFIG`, PATH, HOME, TMPDIR, ENV, the founder's and the
provider's names, and named shell, proxy, libc, OpenSSL and Java hooks. `installRoots` lists the directories
where the adapter and the mounts live. A hosted adapter or mount source
must resolve inside one of them, and never in or around the data root,
the config directory, HOME, `/srv/mosaic` or a path with a `secret`
segment. HOME does not count against a source inside the stack's own
code, so a copy or a worktree under HOME still passes. Every claude-code
name is `MOSAIC_*`, so a hosted session cannot run Claude Code yet. pi's
`MOSAIC_TOOLS`, `MOSAIC_EXTENSIONS` and `MOSAIC_THINKING` are refused the
same way, so a hosted pi gets no tools and no extension until the host
sets those names itself.
- `compactions({store, cursors, budget, streams, first})` reads a thread
session's native store for row 270's compaction count (row 307). Core keeps
the ledger (`packages/seat/src/compactions.mjs`) and passes `store` as
+11 -1
View File
@@ -6,7 +6,7 @@
// session.json. packages/plugins/README.md lists the interface.
import { spawnSync } from "node:child_process";
import { accessSync, constants, realpathSync, statSync } from "node:fs";
import { delimiter, isAbsolute, join } from "node:path";
import { delimiter, dirname, isAbsolute, join } from "node:path";
import { fileURLToPath } from "node:url";
import { claudeBuiltins, MCP_PREFIX } from "../../../harness/src/gate.mjs";
import { hasSessionCredential, SESSION_CREDENTIALS } from "../../../seat/src/session.mjs";
@@ -145,6 +145,16 @@ export function env({ files, policy, session, proxy = null }) {
};
}
// #1873 triage-fences: the names env() returns, less the proxy's, and the directories its adapter
// and mounts live in: the pinned binary's when MOSAIC_CLAUDE_BIN is set. A hosted session's host
// (Triage) takes harnessEnv names and mount sources only from these; launches don't read them.
export const envNames = Object.freeze(["MOSAIC_TOOLS", "MOSAIC_CLAUDE_SETTINGS", "MOSAIC_CLAUDE_MCP_CONFIG", "MOSAIC_THINKING", "MOSAIC_MODEL_ACTIVITY_SOURCE"]);
export function installRoots({ env = {} } = {}) {
const roots = [join(REPO, "adapters", "claude"), join(REPO, "tools", "unslop-hook")];
if (env.MOSAIC_CLAUDE_BIN) roots.push(dirname(realpathSync(env.MOSAIC_CLAUDE_BIN)));
return roots;
}
// A turn ends when claude exits; there is no marker.
export const turnEnd = () => "exit";
export const transcript = ({ runDir, store = null }) => (store ? store.projects : join(runDir, "home", ".claude", "projects"));
+8
View File
@@ -118,6 +118,14 @@ export function env({ policy, tools, session, proxy = null }) {
};
}
// #1873 triage-fences: the names env() returns, less the provider key, and the directories its
// adapter and mounts live in. A hosted session's host (Triage) takes harnessEnv names and mount
// sources only from these; launches don't read them. The host refuses every MOSAIC_* name from a
// route, so MOSAIC_TOOLS, MOSAIC_EXTENSIONS and MOSAIC_THINKING are listed only to say what env()
// hands a session: a hosted pi needs the host to set them itself (a later slice).
export const envNames = Object.freeze(["PI_OFFLINE", "MOSAIC_TOOLS", "MOSAIC_EXTENSIONS", "PI_PROVIDER", "PI_MODEL", "MOSAIC_THINKING"]);
export const installRoots = () => [join(REPO, "adapters", "pi"), join(REPO, "packages", "plugins", "harness", "pi"), realpathSync(join(REPO, "node_modules")), join(REPO, "tools", "unslop-hook")];
// The extension writes the turn marker at agent_end; an exit without it is a failed turn.
export const turnEnd = () => "marker";
export const transcript = ({ runDir, store = null }) => (store ? store.session : join(runDir, "session"));
+111 -4
View File
@@ -34,7 +34,7 @@
// the launch (sandbox-unavailable).
import { spawnSync } from "node:child_process";
import { existsSync, lstatSync, mkdirSync, readlinkSync, realpathSync } from "node:fs";
import { existsSync, lstatSync, mkdirSync, readlinkSync, realpathSync, statSync } from "node:fs";
import { dirname, isAbsolute, join, relative, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { ID_PATTERN } from "../../organization/src/vocabulary.mjs";
@@ -193,6 +193,110 @@ 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-fences: what a model route may hand a hosted session, checked before the host
// writes anything and again in hostedBinds. The adapter and each mount's source must be a clean
// absolute path whose real path lies under one of the harness module's install roots, named under
// that same root, and outside every protected path: the data root, the config directory and HOME
// the caller passes, the run directory, ALWAYS_PROTECTED, and any path with a segment that
// contains "secret" in any case. A protected path counts in its own spelling and its real path, and
// a source may neither lie inside one nor contain one. The bind's source is the real path, so a
// link swapped after the check cannot steer it. A mount's dest (its source when it names none) is
// never /tmp, the run directory or a system bind's dest, nor inside or around one, never a parent
// of or equal to a runner file, the adapter or node, and never in or around another mount's dest.
// At most HOSTED_MOUNTS_MAX mounts. A refusal is a HostedRouteError naming its fence, never a path.
// `codeRoot` is the stack's own code and `codeHolder` the one protected path that may hold it:
// HOME, when the stack runs from a copy or a worktree under it. That path does not refuse a source
// whose named and real paths both lie in the code root. Every other check still applies to it, and
// no other protected path, the run directory or ALWAYS_PROTECTED is ever set aside. A code root in
// or around the run directory or ALWAYS_PROTECTED, in either path's spelling or real path, is refused.
export const HOSTED_MOUNTS_MAX = 8;
const ROOTS_MAX = 16;
const PATH_MAX = 4096;
const ALWAYS_PROTECTED = Object.freeze(["/srv/mosaic", "/proc", "/sys", "/dev", "/run", "/root", "/boot"]);
const MOUNT_KEYS = Object.freeze(["src", "dest", "why"]);
export class HostedRouteError extends Error {
constructor(fence, message) {
super(`hosted binds: ${message}`);
this.code = "hosted-binds-refused";
this.fence = fence;
}
}
const refuseRoute = (fence, message) => { throw new HostedRouteError(fence, message); };
// Absolute, already normal (no "..", ".", "//" or trailing slash), not "/", no NUL.
const cleanPath = (p) => typeof p === "string" && p.length > 1 && p.length <= PATH_MAX && !p.includes("\0") && isAbsolute(p) && resolve(p) === p;
const within = (child, parent) => child === parent || child.startsWith(parent + "/");
const overlaps = (a, b) => within(a, b) || within(b, a);
const secretPath = (p) => p.split("/").some((seg) => /secret/i.test(seg));
const realOr = (p) => { try { return realpathSync(p); } catch { return p; } };
const plainObject = (o) => o !== null && typeof o === "object" && !Array.isArray(o) && [Object.prototype, null].includes(Object.getPrototypeOf(o));
export function checkHostedRoute({ adapter, harnessMounts, installRoots, protectedPaths, codeRoot = null, codeHolder = null, runDir, node = process.execPath }) {
if (!cleanPath(runDir)) refuseRoute("protected", "the run directory is not a clean absolute path");
if (!Array.isArray(protectedPaths)) refuseRoute("protected", "no protected paths were given");
// Lists are copied once, so a Proxy cannot answer one length to a check and another to the map.
protectedPaths = Array.from(protectedPaths);
let code = null;
if (codeRoot !== null) {
if (!cleanPath(codeRoot)) refuseRoute("protected", "the code root is not a clean absolute path");
if (!protectedPaths.includes(codeHolder)) refuseRoute("protected", "the code root's holder is not a protected path");
code = [codeRoot, realOr(codeRoot)];
const fixed = [runDir, ...ALWAYS_PROTECTED].flatMap((g) => [g, realOr(g)]);
if (code.some((c) => fixed.some((g) => overlaps(c, g)))) refuseRoute("protected", "the code root is in or around a path that is never set aside");
}
// Each guarded entry: its spellings, and whether a source in the code root is clear of it.
const guarded = [];
for (const [p, mayHoldCode] of [...ALWAYS_PROTECTED.map((g) => [g, false]), ...protectedPaths.map((g) => [g, g === codeHolder]), [runDir, false]]) {
if (!cleanPath(p)) refuseRoute("protected", "a protected path is not a clean absolute path");
const spellings = [p, realOr(p)];
const holdsCode = mayHoldCode && code !== null && spellings.some((g) => code.some((c) => c !== g && within(c, g)));
guarded.push({ spellings, holdsCode });
}
if (!Array.isArray(installRoots)) refuseRoute("roots", "the harness module declares no usable install roots");
installRoots = Array.from(installRoots);
if (installRoots.length === 0 || installRoots.length > ROOTS_MAX) refuseRoute("roots", "the harness module declares no usable install roots");
const roots = installRoots.map((r) => {
if (!cleanPath(r)) refuseRoute("roots", "an install root is not a clean absolute path");
let real;
try { real = realpathSync(r); } catch { refuseRoute("roots", "an install root is missing"); }
if (real === "/" || !statSync(real).isDirectory()) refuseRoute("roots", "an install root is not a directory");
return { named: r, real };
});
const source = (src, fence, what) => {
if (!cleanPath(src)) refuseRoute(fence, `${what} is not a clean absolute path`);
let real;
try { real = realpathSync(src); } catch { refuseRoute(fence, `${what} is missing`); }
if (!roots.some((r) => (within(src, r.named) || within(src, r.real)) && within(real, r.real))) refuseRoute(fence, `${what} is not under an install root`);
const inCode = code !== null && code.some((c) => within(src, c)) && within(real, code[1]);
if (guarded.some((g) => !(g.holdsCode && inCode) && [src, real].some((p) => g.spellings.some((s) => overlaps(p, s))))) refuseRoute(fence, `${what} is in or around a protected path`);
if ([src, real].some(secretPath)) refuseRoute(fence, `${what} is in a secrets path`);
return real;
};
const adapterReal = source(adapter, "adapter", "the adapter");
if (!statSync(adapterReal).isFile()) refuseRoute("adapter", "the adapter is not a file");
if (!Array.isArray(harnessMounts)) refuseRoute("mounts", `a hosted session takes at most ${HOSTED_MOUNTS_MAX} harness mounts`);
harnessMounts = Array.from(harnessMounts);
if (harnessMounts.length > HOSTED_MOUNTS_MAX) refuseRoute("mounts", `a hosted session takes at most ${HOSTED_MOUNTS_MAX} harness mounts`);
const apart = ["/tmp", runDir, ...systemBinds(node).map((b) => b.dest ?? b.src)];
const kept = [...RUNNER_FILES, adapter, node];
const dests = [];
const mounts = harnessMounts.map((m, i) => {
const what = `harness mount ${i + 1}`;
if (!plainObject(m) || Object.keys(m).some((k) => !MOUNT_KEYS.includes(k))) refuseRoute("mounts", `${what} is not { src, dest, why }`);
// Each field is read once, so a getter cannot answer one value to a check and another to the bind.
const { src, dest: named, why } = m;
if (typeof why !== "string" || !why || why.length > 256) refuseRoute("mounts", `${what} is not { src, dest, why }`);
if (named !== undefined && !cleanPath(named)) refuseRoute("mount-dest", `${what}'s dest is not a clean absolute path`);
const real = source(src, "mount-src", what);
const dest = named ?? src;
if (apart.some((p) => overlaps(dest, p)) || kept.some((p) => within(p, dest)) || dests.some((d) => overlaps(dest, d))) refuseRoute("mount-dest", `${what}'s dest would cover a path the session needs`);
dests.push(dest);
return { src: real, dest, why };
});
return { adapter: { src: adapterReal, dest: adapter }, mounts };
}
// #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
@@ -200,7 +304,9 @@ export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWR
// 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 = [] }) {
// The adapter and the mounts pass checkHostedRoute against `installRoots`, `protectedPaths` and
// `codeRoot` with its `codeHolder` here too; without install roots nothing binds.
export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], installRoots, protectedPaths, codeRoot = null, codeHolder = null, 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]) {
@@ -213,10 +319,11 @@ export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], re
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 route = checkHostedRoute({ adapter, harnessMounts, installRoots, protectedPaths, codeRoot, codeHolder, runDir, node });
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 });
out.push({ kind: "ro", src: route.adapter.src, ...(route.adapter.src !== adapter ? { dest: adapter } : {}), why: "the harness adapter the runner starts each turn" });
for (const m of route.mounts) out.push({ kind: "ro", src: m.src, ...(m.dest !== m.src ? { 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/" },
+141 -7
View File
@@ -5,8 +5,8 @@ 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";
import { dirname, join } from "node:path";
import { HOSTED_MOUNTS_MAX, RUNNER_FILES, checkHostedRoute, hostedArgv, hostedBinds } from "../src/sandbox.mjs";
function layout(t) {
const root = mkdtempSync(join(process.env.TMPDIR, "hb-"));
@@ -15,19 +15,21 @@ function layout(t) {
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");
const install = join(root, "install");
mkdirSync(install);
const adapter = join(install, "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") });
resolve({ root, dataRoot, runDir, healthDir, adapter, install, relaySocket: join(runDir, "relay.sock"), installRoots: [install], protectedPaths: [dataRoot] });
});
});
}
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 list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths });
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],
@@ -46,7 +48,7 @@ test("hosted binds hold the run directory and the health directory of the data r
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 };
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
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"]) {
@@ -72,7 +74,7 @@ test("hosted binds refuse a relay socket elsewhere, and any source in the run di
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" });
const argv = hostedArgv(hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }), 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]);
@@ -81,3 +83,135 @@ test("the hosted command line sets no git identity and runs the command under th
assert.equal(argv[home + 1], join(p.runDir, "home"));
assert.ok(argv.includes("--remount-ro"));
});
// #1873 triage-fences: hostedBinds checks the adapter and the mounts again, so a caller that skips
// the host's own check still binds nothing outside the install roots.
test("hosted binds refuse without install roots or protected paths, and refuse an adapter or a mount source outside the roots or in a protected path", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label);
refused({ installRoots: undefined }, "roots", "no roots");
refused({ installRoots: [] }, "roots", "empty roots");
refused({ installRoots: ["/"] }, "roots", "root /");
refused({ installRoots: [join(p.root, "absent")] }, "roots", "missing root");
refused({ installRoots: [p.adapter] }, "roots", "a file as root");
refused({ protectedPaths: undefined }, "protected", "no protected paths");
refused({ protectedPaths: ["relative"] }, "protected", "relative protected path");
writeFileSync(join(p.root, "out.sh"), "x");
refused({ adapter: join(p.root, "out.sh") }, "adapter", "adapter outside");
symlinkSync(join(p.root, "out.sh"), join(p.install, "link.sh"));
refused({ adapter: join(p.install, "link.sh") }, "adapter", "adapter link out");
refused({ adapter: p.install }, "adapter", "adapter is a directory");
refused({ harnessMounts: [{ src: join(p.install, "link.sh"), why: "w" }] }, "mount-src", "mount link out");
refused({ harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }], installRoots: [p.root] }, "mount-src", "mount in the data root");
refused({ harnessMounts: [{ src: p.root, why: "w" }], installRoots: [p.root] }, "mount-src", "mount around the data root");
mkdirSync(join(p.install, "secrets"));
writeFileSync(join(p.install, "secrets", "k"), "x");
refused({ harnessMounts: [{ src: join(p.install, "secrets", "k"), why: "w" }] }, "mount-src", "mount in secrets");
writeFileSync(join(p.install, "m"), "x");
refused({ harnessMounts: Array.from({ length: HOSTED_MOUNTS_MAX + 1 }, (_, i) => ({ src: join(p.install, "m"), dest: `/opt/m${i}`, why: "w" })) }, "mounts", "too many");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/tmp/m", why: "w" }] }, "mount-dest", "dest under /tmp");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: p.runDir, why: "w" }] }, "mount-dest", "dest is the run dir");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: join(p.runDir, "session.json"), why: "w" }] }, "mount-dest", "dest is session.json");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/usr", why: "w" }] }, "mount-dest", "dest is a system bind");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: dirname(RUNNER_FILES[0]), why: "w" }] }, "mount-dest", "dest holds a runner file");
refused({ harnessMounts: [{ src: join(p.install, "m"), why: "w", kind: "rw" }] }, "mounts", "a kind of its own");
});
test("hosted binds bind the real file of a link that stays inside the install root, at the path the route named", async (t) => {
const p = await layout(t);
writeFileSync(join(p.install, "real.mjs"), "x");
symlinkSync(join(p.install, "real.mjs"), join(p.install, "named.mjs"));
symlinkSync(p.adapter, join(p.install, "adapter-link.sh"));
const list = hostedBinds({
runDir: p.runDir, healthDir: p.healthDir, adapter: join(p.install, "adapter-link.sh"), relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths,
harnessMounts: [{ src: join(p.install, "named.mjs"), why: "w" }, { src: join(p.install, "real.mjs"), dest: "/opt/real.mjs", why: "w2" }],
});
assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter && b.dest === join(p.install, "adapter-link.sh")));
assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === join(p.install, "named.mjs") && b.why === "w"));
assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === "/opt/real.mjs" && b.why === "w2"));
assert.ok(!list.some((b) => b.src === join(p.install, "named.mjs")));
});
test("a protected path that holds the code root (HOME over a copy or a worktree) does not refuse a source inside the code root; everything else still holds", async (t) => {
const p = await layout(t);
// home/ holds the code root code/, which holds the install root.
const home = join(p.root, "home");
const code = join(home, "code");
const inst = join(code, "inst");
mkdirSync(join(inst, "secrets"), { recursive: true });
for (const f of ["adapter.sh", "m", join("secrets", "k")]) writeFileSync(join(inst, f), "x");
writeFileSync(join(home, "outside"), "x");
mkdirSync(join(code, "data"));
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: join(inst, "adapter.sh"), relaySocket: p.relaySocket, installRoots: [inst], protectedPaths: [p.dataRoot, home], codeRoot: code, codeHolder: home };
const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label);
const list = hostedBinds({ ...base, harnessMounts: [{ src: join(inst, "m"), dest: "/opt/m", why: "w" }] });
assert.ok(list.some((b) => b.src === join(inst, "adapter.sh")) && list.some((b) => b.src === join(inst, "m") && b.dest === "/opt/m"));
// Without the code root, HOME refuses the same adapter.
refused({ codeRoot: null }, "adapter", "no code root");
// A code root that is HOME itself sets nothing aside.
refused({ codeRoot: home }, "adapter", "code root is HOME");
// A source under HOME outside the code root, even inside an install root.
refused({ installRoots: [home], adapter: join(home, "outside") }, "adapter", "outside the code root");
// A link inside the code root to a file outside it.
symlinkSync(join(home, "outside"), join(inst, "out"));
refused({ installRoots: [inst, home], harnessMounts: [{ src: join(inst, "out"), why: "w" }] }, "mount-src", "link out of the code root");
// A protected path inside the code root still refuses.
writeFileSync(join(code, "data", "f"), "x");
refused({ installRoots: [code], protectedPaths: [p.dataRoot, home, join(code, "data")], harnessMounts: [{ src: join(code, "data", "f"), why: "w" }] }, "mount-src", "protected path in the code root");
// The secrets check still holds inside the code root.
refused({ harnessMounts: [{ src: join(inst, "secrets", "k"), why: "w" }] }, "mount-src", "secrets in the code root");
// The run directory and the fixed list are never set aside, and a code root around them is refused.
refused({ codeRoot: p.root, installRoots: [p.root], harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }] }, "protected", "code root holds the run dir");
refused({ codeRoot: "/srv/mosaic/x" }, "protected", "code root in a fixed path");
refused({ codeRoot: "relative" }, "protected", "relative code root");
// Only the named holder sets the code aside: another protected path that holds the code still refuses.
refused({ protectedPaths: [p.dataRoot, home, p.root] }, "adapter", "a second protected path holds the code");
refused({ codeHolder: null }, "protected", "no holder");
refused({ codeHolder: join(p.root, "elsewhere") }, "protected", "a holder that is not a protected path");
// A run directory named through a link: a code root in its real path is refused before any check.
const realRun = join(home, "run");
mkdirSync(join(realRun, "code", "inst"), { recursive: true });
writeFileSync(join(realRun, "code", "inst", "a.sh"), "x");
symlinkSync(realRun, join(p.root, "runlink"));
assert.throws(() => checkHostedRoute({ adapter: join(realRun, "code", "inst", "a.sh"), harnessMounts: [], installRoots: [join(realRun, "code", "inst")], protectedPaths: [p.dataRoot, home], codeRoot: join(realRun, "code"), codeHolder: home, runDir: join(p.root, "runlink") }), (e) => e.fence === "protected", "code root in the run dir's real path");
});
test("a list that answers one length to the check and another later is read once", async (t) => {
const p = await layout(t);
const items = [];
for (let i = 0; i <= HOSTED_MOUNTS_MAX; i++) { writeFileSync(join(p.install, `m${i}`), "x"); items.push({ src: join(p.install, `m${i}`), dest: `/opt/m${i}`, why: "w" }); }
let reads = 0;
const mounts = new Proxy(items, { get: (o, k) => (k === "length" ? (reads++ === 0 ? 1 : o.length) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: mounts, installRoots: p.installRoots, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "mounts");
// Install roots: two short answers pass the count, then a long one would add roots the count never saw.
const roots = [];
for (let i = 0; i <= 16; i++) { roots.push(join(p.root, `r${i}`)); mkdirSync(roots[i]); }
writeFileSync(join(roots[16], "a.sh"), "x");
let rootReads = 0;
const rootList = new Proxy(roots, { get: (o, k) => (k === "length" ? (rootReads++ < 2 ? 1 : o.length) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: join(roots[16], "a.sh"), harnessMounts: [], installRoots: rootList, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "adapter");
// Protected paths: the holder check sees HOME, then a shorter answer would leave HOME unguarded.
const home = join(p.root, "home");
mkdirSync(join(home, "code"), { recursive: true });
writeFileSync(join(home, "f"), "x");
let guardReads = 0;
const guards = new Proxy([p.dataRoot, home], { get: (o, k) => (k === "length" ? (guardReads++ === 0 ? 2 : 1) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: [{ src: join(home, "f"), dest: "/opt/f", why: "w" }], installRoots: [p.install, home], protectedPaths: guards, codeRoot: join(home, "code"), codeHolder: home, runDir: p.runDir }), (e) => e.fence === "protected" || e.fence === "mount-src");
});
test("each mount field is read once, and no mount's dest lies in or around another's", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
writeFileSync(join(p.install, "m"), "x");
writeFileSync(join(p.install, "n"), "x");
let reads = 0;
const list = hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), why: "w", get dest() { return reads++ === 0 ? undefined : "/opt/../tmp"; } }] });
assert.equal(reads, 1);
assert.ok(list.some((b) => b.src === join(p.install, "m") && b.dest === undefined));
assert.ok(!list.some((b) => b.dest === "/opt/../tmp"));
for (const [a, b] of [["/opt/x", "/opt/x/f"], ["/opt/x/f", "/opt/x"], ["/opt/x", "/opt/x"]]) {
assert.throws(() => hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: a, why: "w" }, { src: join(p.install, "n"), dest: b, why: "w" }] }), (e) => e.fence === "mount-dest", `${a} then ${b}`);
}
assert.equal(hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: "/opt/x", why: "w" }, { src: join(p.install, "n"), dest: "/opt/xy", why: "w" }] }).filter((b) => b.dest?.startsWith("/opt/")).length, 2);
});
+293
View File
@@ -1,4 +1,297 @@
window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(value).toLocaleString() : 'unknown';
// #1873 triage-drawer: the instance owner's Triage drawer, one system-level entry in the top bar.
// It reads /api/config and /api/triage through the fetch this file starts with, before the
// organization wrapper below replaces it, so both reads stay unscoped: Triage is in no organization.
// The entry, the drawer and every Triage request exist only when that config says triage: true.
// Every value from the read goes in as text, never as markup. The drawer reads only while open.
(() => {
const systemFetch = window.fetch.bind(window);
const POLL_MS = 4000;
// Control, format (direction, zero-width, soft hyphen, word joiner, tag), separator and default-ignorable
// characters (fillers, variation selectors) never reach the page; newline and tab stay.
const HIDDEN = /(?![\n\t])[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}]/gu;
const clean = (value, max = 8000) => (typeof value === 'string' ? value : value === null || value === undefined ? '' : String(value)).replace(/\r\n?/g, '\n').replace(HIDDEN, '').slice(0, max);
const when = value => window.MosaicLocalTime(clean(value, 64));
const el = (tag, cls, text) => { const n = document.createElement(tag); if (cls) n.className = cls; if (text !== undefined) n.textContent = clean(text); return n; };
const NO_ROUTE = 'No model route is set for Triage, so Triage will not start. The instance owner sets the route first.';
let config = null, entry = null, drawer = null, parts = null, timer = null, gen = 0, sending = false, lastTranscript = '', lastHealth = '', shown = [];
const read = () => systemFetch('/api/config', { cache: 'no-store', redirect: 'manual' }).then(r => (r.ok ? r.json() : null)).catch(() => null);
read().then(c => { if (c && c.triage === true) { config = c; addEntry(); } });
function addEntry() {
const bar = document.querySelector('.cmd-right');
if (!bar || document.getElementById('triage-open')) return;
entry = el('button', 'header-action');
entry.id = 'triage-open'; entry.type = 'button'; entry.title = 'Triage';
entry.setAttribute('aria-label', 'Triage'); entry.setAttribute('aria-expanded', 'false'); entry.setAttribute('aria-controls', 'triage-drawer');
const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg'), path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
svg.setAttribute('class', 'i'); svg.setAttribute('viewBox', '0 0 24 24'); svg.setAttribute('aria-hidden', 'true');
path.setAttribute('d', 'M3 12h4l3-8 4 16 3-8h4');
svg.append(path); entry.append(svg, el('span', '', 'Triage'));
entry.addEventListener('click', () => (drawer && !drawer.hidden ? close() : open()));
bar.insertBefore(entry, document.getElementById('refresh') ?? bar.firstChild);
}
function build() {
drawer = el('aside', 'ws-drawer triage-drawer');
drawer.id = 'triage-drawer';
drawer.setAttribute('aria-labelledby', 'triage-title');
const hd = el('div', 'hd'), title = el('h2', '', 'Triage'), x = el('button', 'x', '×');
title.id = 'triage-title'; title.tabIndex = -1;
x.type = 'button'; x.setAttribute('aria-label', 'Close Triage');
x.addEventListener('click', close);
hd.append(title, x);
const state = el('p', 'triage-state'); state.id = 'triage-state'; state.setAttribute('role', 'status');
const healthSec = el('details', 'triage-health-sec'); healthSec.open = true;
const healthSum = el('summary', '', 'Health');
const health = el('ul', 'triage-health'); health.id = 'triage-health';
healthSec.append(healthSum, health);
const convo = el('h3', 'triage-convo-title', 'Conversation');
const transcript = el('ol', 'triage-transcript'); transcript.id = 'triage-transcript'; transcript.tabIndex = 0;
transcript.setAttribute('aria-label', 'Triage conversation');
const compose = el('div', 'triage-compose');
drawer.append(hd, state, healthSec, convo, transcript, compose);
drawer.addEventListener('keydown', e => { if (e.key === 'Escape') { e.preventDefault(); close(); } });
document.body.append(drawer);
parts = { title, state, health, transcript, compose, box: null, send: null, status: null, off: null };
}
// The message box is built once and never rewritten or removed by a read, so a draft survives every
// poll. A read that turns sending off hides the box; one that turns it on again shows it.
function composer(view) {
const c = parts.compose;
const canSend = config.triageSend === true && view.send === true;
const READ_ONLY = 'This Console is read-only, so messages cannot be sent from here.';
if (!canSend && !parts.box) {
if (!parts.off || !parts.off.isConnected) { parts.off = el('p', 'note triage-send-off'); parts.off.id = 'triage-send-off'; c.append(parts.off); }
parts.off.textContent = READ_ONLY;
return;
}
if (!parts.box) {
c.replaceChildren();
const label = el('label', 'triage-label', 'Message to Triage');
label.htmlFor = 'triage-text';
const box = el('textarea', 'triage-text'); box.id = 'triage-text'; box.rows = 3; box.maxLength = 8000;
box.setAttribute('aria-describedby', 'triage-send-off triage-send-status');
box.addEventListener('keydown', e => { if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) { e.preventDefault(); submit(); } });
const row = el('div', 'triage-send-row');
const send = el('button', 'ws-btn primary triage-send', 'Send'); send.id = 'triage-send'; send.type = 'button';
send.addEventListener('click', submit);
const hint = el('span', 'triage-hint', 'Ctrl+Enter sends');
row.append(send, hint);
const off = el('p', 'note triage-send-off'); off.id = 'triage-send-off';
const status = el('p', 'triage-send-status'); status.id = 'triage-send-status'; status.setAttribute('role', 'status');
c.append(label, box, off, row, status);
Object.assign(parts, { label, box, send, status, off, row });
}
for (const n of [parts.label, parts.box, parts.row]) n.hidden = !canSend;
if (!canSend) { parts.off.textContent = READ_ONLY; parts.box.disabled = parts.send.disabled = true; return; }
// A route that is not set, or a session over its cap, turns the box off and says why.
const until = typeof view.overCapUntil === 'string' && view.overCapUntil ? view.overCapUntil : null;
const reason = view.route !== 'set' ? 'Sending is off: no model route is set for Triage.'
: until ? `Sending is off: Triage is over its daily token cap until ${when(until)}.` : '';
parts.off.textContent = reason;
parts.box.disabled = !!reason;
parts.send.disabled = !!reason || sending;
}
const stateLine = view => {
if (view.route !== 'set') return clean(view.routeMessage) || NO_ROUTE;
if (view.overCapUntil) return clean(view.capMessage) ? `${clean(view.capMessage)} Local time: ${when(view.overCapUntil)}.` : `Triage is over its daily token cap. It takes messages again at ${when(view.overCapUntil)}.`;
if (view.running === true) return 'Running.';
const x = view.lastExit;
if (x && typeof x === 'object') {
const how = [x.code !== null && x.code !== undefined ? `code ${clean(x.code)}` : '', x.signal ? `signal ${clean(x.signal)}` : ''].filter(Boolean).join(', ') || 'no code';
return `Not running. Last exit: ${how} at ${when(x.at)}.`;
}
return 'Not running. No run has ended yet.';
};
const notRead = v => v === 'not read' || v === null || v === undefined || typeof v !== 'object';
const configWords = c => (notRead(c) ? 'not read' : c.valid === true ? 'valid' : `not valid${c.code ? ` (${clean(c.code)})` : ''}`);
function healthLines(s) {
if (notRead(s)) return ['Health: not read'];
const lines = [];
lines.push(notRead(s.console) ? 'Console: not read' : `Console: ${clean(s.console.state) || 'not read'}, ${when(s.console.at)}`);
if (notRead(s.proxy)) lines.push('Proxy: not read');
else {
const p = s.proxy;
const words = [p.healthy === true ? 'healthy' : p.healthy === false ? 'not healthy' : 'health not read'];
if (p.initialized === false) words.push('not set up');
if (p.installed === false) words.push('not installed');
if (typeof p.active === 'string' && p.active) words.push(`unit ${clean(p.active)}`);
if (p.fence === true) words.push('fence set');
lines.push(`Proxy: ${words.join(', ')}`);
}
lines.push(`System config: ${configWords(s.systemConfig)}`);
const orgs = s.organizations;
if (notRead(orgs) || !Array.isArray(orgs.list)) lines.push('Organizations: not read');
else if (!orgs.list.length) lines.push('Organizations: none');
else for (const o of orgs.list) {
if (!o || typeof o !== 'object') continue;
const bus = notRead(o.bus) ? 'bus not read' : `bus ${clean(o.bus.state) || 'not read'}${o.bus.lastStart && o.bus.lastStart.ok === false ? `, last start failed ${when(o.bus.lastStart.at)}` : ''}`;
const proc = notRead(o.processing) ? 'processing not read' : o.processing.invalid === true ? 'processing state not valid' : o.processing.halted === true ? 'processing stopped' : 'processing on';
lines.push(`${clean(o.id) || 'unnamed'}: ${bus}, ${proc}, config ${configWords(o.config)}`);
}
return lines;
}
const WHO = { owner: 'You', triage: 'Triage', host: 'Console' };
function entryNode(m, owners) {
const from = Object.hasOwn(WHO, m.from) ? m.from : 'other';
const li = el('li', `triage-msg from-${from}`);
li.dataset.from = from;
const head = el('div', 'triage-msg-head');
head.append(el('strong', '', WHO[from] ?? 'Unknown sender'), el('span', 'triage-when', when(m.at)));
li.append(head);
if (m.in_reply_to && (from === 'triage' || from === 'host')) {
const asked = owners.get(m.in_reply_to);
li.append(el('p', 'triage-reply', asked !== undefined ? `Reply to: ${asked.length > 120 ? `${asked.slice(0, 119)}…` : asked}` : 'Reply to an earlier message'));
}
li.append(el('p', 'triage-text-body', m.text));
if (from === 'triage') {
const cards = Array.isArray(m.cards) ? m.cards.filter(c => c && typeof c === 'object') : [];
if (cards.length) {
const list = el('ul', 'triage-cards');
list.setAttribute('aria-label', 'Suggested commands');
for (const c of cards) {
const card = el('li', 'triage-card');
card.append(el('span', 'triage-card-meta', `Step: ${clean(c.step)} · Organization: ${clean(c.org)}`), el('code', 'triage-card-cmd', c.command));
list.append(card);
}
li.append(list);
}
const dropped = Number.isSafeInteger(m.dropped) && m.dropped > 0 ? m.dropped : 0;
if (dropped) li.append(el('p', 'triage-dropped', `${dropped} ${dropped === 1 ? 'card' : 'cards'} dropped: not a known step or organization.`));
}
return li;
}
function render(view) {
// Where the reader is, measured before anything above the conversation changes its height.
const t = parts.transcript, atBottom = t.scrollHeight - t.scrollTop - t.clientHeight < 24, top = t.scrollTop;
parts.state.textContent = stateLine(view);
parts.state.dataset.kind = view.route !== 'set' ? 'off' : view.overCapUntil ? 'cap' : view.running === true ? 'running' : 'stopped';
const lines = healthLines(view.snapshot);
const healthKey = JSON.stringify(lines);
if (healthKey !== lastHealth) { lastHealth = healthKey; parts.health.replaceChildren(...lines.map(l => el('li', l.endsWith('not read') ? 'not-read' : '', l))); }
// The box first: it sets the conversation's height, which the scroll position below depends on.
composer(view);
const list = Array.isArray(view.transcript) ? view.transcript.filter(m => m && typeof m === 'object') : [];
const key = JSON.stringify(list);
if (key !== lastTranscript) {
const first = lastTranscript === '';
// The host keeps the newest 200 lines, so a new line can drop old ones from the top. A reader who
// has scrolled up keeps the line they are reading at the same place, not the same scroll number.
const edge = () => t.getBoundingClientRect().top;
let anchor = null;
if (!first && !atBottom) {
const i = [...t.children].findIndex(n => n.getBoundingClientRect().bottom > edge() + 1);
if (i >= 0 && shown[i] !== undefined) anchor = { i, key: shown[i], off: t.children[i].getBoundingClientRect().top - edge() };
}
lastTranscript = key;
const owners = new Map(list.filter(m => m.from === 'owner' && typeof m.id === 'string').map(m => [m.id, clean(m.text)]));
if (list.length) t.replaceChildren(...list.map(m => entryNode(m, owners)));
else t.replaceChildren(el('li', 'triage-empty', 'No messages yet.'));
const next = list.map(m => JSON.stringify(m));
// Lines only drop from the top and add at the bottom, so the anchor moves up by the number dropped.
// That finds the right one of two identical lines; anything else falls back to the first match.
const fits = d => shown.length - d <= next.length && shown.slice(d).every((k, n) => next[n] === k);
let j = -1;
if (anchor) { let d = 0; while (d <= anchor.i && !fits(d)) d += 1; j = d <= anchor.i ? anchor.i - d : next.indexOf(anchor.key); }
shown = next;
if (first || atBottom) t.scrollTop = t.scrollHeight;
else {
t.scrollTop = top;
if (j >= 0) t.scrollTop += t.children[j].getBoundingClientRect().top - edge() - anchor.off;
else if (anchor) t.scrollTop = 0;
}
}
}
// Only the newest read renders and schedules the next one, so a send's read and the timer's never
// run two chains at once, and an answer that lands after close is dropped.
async function poll() {
const mine = ++gen;
clearTimeout(timer);
let view = null, failed = null;
try {
const r = await systemFetch('/api/triage', { cache: 'no-store', redirect: 'manual' });
if (r.ok) view = await r.json(); else failed = r.status;
} catch { failed = 'no answer'; }
if (mine !== gen || !drawer || drawer.hidden) return;
if (view && typeof view === 'object') render(view);
else { parts.state.textContent = `Triage could not be read (${failed}). The drawer tries again shortly.`; parts.state.dataset.kind = 'error'; }
timer = setTimeout(poll, POLL_MS);
}
function open() {
if (!drawer) build();
drawer.hidden = false;
entry.setAttribute('aria-expanded', 'true');
if (!parts.state.dataset.kind) { parts.state.textContent = 'Reading Triage.'; parts.state.dataset.kind = 'reading'; }
poll().then(() => { if (!drawer.hidden && !drawer.contains(document.activeElement)) (parts.box && !parts.box.disabled ? parts.box : parts.title).focus(); });
}
function close() {
if (!drawer || drawer.hidden) return;
gen += 1;
clearTimeout(timer); timer = null;
drawer.hidden = true;
entry.setAttribute('aria-expanded', 'false');
entry.focus();
}
// Plain words for each answer. A refused send keeps the draft; an unknown outcome is never resent.
function answer(status, body) {
const code = body && typeof body.error === 'string' ? body.error : '';
if (status === 202) return { sent: true, text: 'Sent. Triage answers in the conversation above.' };
// These come after the host wrote the message, with its "did not start" line under it.
if (code === 'triage-route-invalid' || code === 'triage-start-failed') return { text: `Not delivered: ${code === 'triage-start-failed' ? 'the Triage session did not start' : 'Triage did not start because the model route\'s answer is not usable'}. The message is in the conversation with the Console's note; it was not sent again.` };
// This one can come before or after the message is written.
if (code === 'triage-dir-unsafe') return { text: 'Not delivered: a Triage directory is not safe to use. It was not sent again: check the conversation before you send it again.' };
if (status === 409) return { text: code === 'triage-no-route' ? 'Not sent: no model route is set for Triage. The instance owner sets the route first.' : code === 'triage-route-refused' ? 'Not sent: the model route refused to start Triage.' : 'Not sent: the model route\'s answer is not usable.' };
if (status === 429) {
if (code === 'triage-over-cap') {
const until = typeof body.until === 'string' ? clean(body.until) : '';
return { text: until ? `Not sent: Triage is over its daily token cap. It takes messages again at ${when(until)} (${until}).` : 'Not sent: Triage is over its daily token cap.' };
}
return { text: 'Not sent: Triage has too many messages waiting. Try again in a moment.' };
}
if (status === 400) return { text: code === 'triage-message-empty' ? 'Not sent: the message is empty.' : code === 'triage-message-too-long' ? 'Not sent: the message is too long.' : 'Not sent: the Console did not accept this as a Triage message.' };
if (status === 403) return { text: code === 'read-only' ? 'Not sent: this Console is read-only.' : 'Not sent: the Console refused a request that did not come from this page.' };
if (status === 503 && code === 'outcome-unknown') return { unknown: true, text: 'Triage did not answer. The message may or may not have arrived. It was not sent again: check the conversation before you send it again.' };
if (status === 503) return { text: `Not sent: ${clean(body && body.message) || 'Triage could not take the message'}.` };
if (status === 401 || status === 404) return { text: 'Not sent: this page can no longer reach Triage. Reload the page.' };
return { text: `Not sent: the Console answered ${status}.` };
}
async function submit() {
if (sending || !parts.box || parts.box.disabled) return;
const text = parts.box.value;
if (!text.trim()) { parts.status.textContent = 'Not sent: the message is empty.'; return; }
sending = true; parts.send.disabled = true; parts.status.textContent = 'Sending…';
let result;
try {
const r = await systemFetch('/api/triage/message', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ text }), cache: 'no-store', redirect: 'manual' });
result = answer(r.status, await r.json().catch(() => null));
} catch {
result = { unknown: true, text: 'The Console did not answer. The message may or may not have arrived. It was not sent again: check the conversation before you send it again.' };
}
sending = false;
if (!parts.box) return;
// The status line can grow the composer; a reader at the bottom of the transcript stays there.
const t = parts.transcript, atBottom = t.scrollHeight - t.scrollTop - t.clientHeight < 24;
parts.status.textContent = result.text;
parts.status.dataset.kind = result.sent ? 'ok' : result.unknown ? 'unknown' : 'refused';
// Only a 202 clears the box, and only when the reader has not typed more since.
if (result.sent && parts.box.value === text) parts.box.value = '';
parts.send.disabled = parts.box.disabled;
if (atBottom) t.scrollTop = t.scrollHeight;
if (drawer && !drawer.hidden) poll();
}
})();
// #1873 SP1: one shell for the whole system. `#/dashboard` is the system landing route and
// `#/orgs/<id>/...` is a route inside the same page, not a mode: opening another organization
// changes the scope of later /api reads and fires `mosaic-org-switch`. Nothing reloads.
+51
View File
@@ -810,3 +810,54 @@ html[data-organizations] .ws-drawer-acts .note{flex-basis:100%}
html[data-organizations] .ws-av.mob{display:inline-grid;margin-right:6px;vertical-align:-3px}
html[data-organizations] .ws-tbl .t2.mono.hide-m{display:none}
}
/* #1873 triage-drawer: the owner's Triage drawer, in the agent drawer family. It sits above an open
agent drawer, keeps its own header and message box in view, and scrolls the conversation alone. */
#triage-drawer{position:fixed;top:var(--bar-h,52px);right:0;bottom:0;width:min(440px,100vw);z-index:41;display:flex;flex-direction:column;overflow:hidden;background:var(--surface);color:var(--text);border-left:1px solid var(--line);box-shadow:-8px 0 24px color-mix(in srgb,#000 14%,transparent)}
#triage-drawer[hidden]{display:none}
#triage-drawer .hd{display:flex;align-items:center;gap:8px;padding:12px 14px 12px 17px;border-bottom:1px solid var(--line);flex:none;box-shadow:inset 4px 0 0 var(--action)}
#triage-drawer h2{margin:0;font-size:18px;font-weight:800;color:var(--strong)}
#triage-drawer h2:focus{outline:none}
#triage-drawer .x{margin-left:auto;flex:none;width:32px;height:32px;border:1px solid var(--line);border-radius:6px;background:var(--canvas);color:var(--strong);font-size:20px;line-height:1;cursor:pointer}
#triage-drawer .triage-state{margin:0;padding:10px 14px;flex:none;font-size:14px;font-weight:600;color:var(--strong);border-bottom:1px solid var(--line);overflow-wrap:anywhere}
#triage-drawer .triage-state[data-kind=off],#triage-drawer .triage-state[data-kind=cap]{color:var(--warning);background:color-mix(in srgb,var(--warning) 9%,var(--surface))}
#triage-drawer .triage-state[data-kind=running]::before{content:"";display:inline-block;width:8px;height:8px;margin-right:7px;border-radius:50%;background:var(--success);vertical-align:1px}
#triage-drawer .triage-health-sec{flex:none;padding:8px 14px;border-bottom:1px solid var(--line)}
#triage-drawer .triage-health-sec summary{cursor:pointer;font:700 11px/1.6 var(--font);letter-spacing:.06em;text-transform:uppercase;color:var(--muted)}
#triage-drawer .triage-health{list-style:none;margin:6px 0 0;padding:0;display:grid;gap:3px;max-height:24vh;overflow:auto;font-size:12.5px;color:var(--strong)}
#triage-drawer .triage-health li{overflow-wrap:anywhere;padding-left:12px;position:relative}
#triage-drawer .triage-health li::before{content:"";position:absolute;left:0;top:.5em;width:6px;height:6px;border-radius:50%;background:var(--line)}
#triage-drawer .triage-health li.not-read{color:var(--muted)}
#triage-drawer .triage-convo-title{margin:0;padding:10px 14px 4px;flex:none;font:700 11px/1.3 var(--font);letter-spacing:.06em;text-transform:uppercase;color:var(--muted)}
#triage-drawer .triage-transcript{list-style:none;margin:0;padding:4px 14px 12px;flex:1 1 auto;min-height:120px;overflow:auto;overscroll-behavior:contain;display:flex;flex-direction:column;gap:8px}
#triage-drawer .triage-transcript:focus-visible{outline:2px solid var(--action);outline-offset:-2px}
#triage-drawer .triage-msg{border:1px solid var(--line);border-radius:8px;padding:8px 10px;background:var(--canvas);font-size:13.5px;overflow-wrap:anywhere}
#triage-drawer .triage-msg.from-owner{background:color-mix(in srgb,var(--action) 8%,var(--surface));border-color:color-mix(in srgb,var(--action) 30%,var(--line))}
#triage-drawer .triage-msg.from-host,#triage-drawer .triage-msg.from-other{background:transparent;border-style:dashed;color:var(--muted)}
#triage-drawer .triage-msg-head{display:flex;gap:8px;align-items:baseline;margin-bottom:3px}
#triage-drawer .triage-msg-head strong{color:var(--strong);font-size:13px}
#triage-drawer .triage-when{font-size:11.5px;color:var(--muted)}
#triage-drawer .triage-reply{margin:0 0 4px;padding-left:8px;border-left:3px solid var(--line);font-size:12.5px;color:var(--muted)}
#triage-drawer .triage-text-body{margin:0;white-space:pre-wrap;color:var(--strong)}
#triage-drawer .from-host .triage-text-body,#triage-drawer .from-other .triage-text-body{color:inherit}
#triage-drawer .triage-cards{list-style:none;margin:8px 0 0;padding:0;display:grid;gap:6px}
#triage-drawer .triage-card{display:grid;gap:4px;border:1px solid var(--line);border-radius:6px;padding:6px 8px;background:var(--surface)}
#triage-drawer .triage-card-meta{font-size:12px;color:var(--muted)}
#triage-drawer .triage-card-cmd{display:block;font:12px/1.5 var(--mono);color:var(--strong);white-space:pre-wrap;overflow-wrap:anywhere;user-select:all}
#triage-drawer .triage-dropped{margin:6px 0 0;font-size:12px;color:var(--warning)}
#triage-drawer .triage-empty{color:var(--muted);font-size:13px}
#triage-drawer .triage-compose{flex:none;display:grid;gap:6px;padding:10px 14px 14px;border-top:1px solid var(--line);background:var(--surface)}
#triage-drawer .triage-label{font-size:12px;font-weight:700;color:var(--muted)}
#triage-drawer .triage-text{width:100%;box-sizing:border-box;min-height:64px;max-height:30vh;resize:vertical;padding:8px 10px;border:1px solid var(--line);border-radius:6px;background:var(--canvas);color:var(--strong);font:14px/1.45 var(--font)}
#triage-drawer .triage-text:disabled{opacity:.6;cursor:not-allowed}
#triage-drawer .triage-send-row{display:flex;align-items:center;gap:10px}
#triage-drawer .triage-send{display:inline-flex;align-items:center;min-height:36px;padding:4px 16px;border:1px solid var(--action);border-radius:var(--r,6px);background:var(--action);color:var(--canvas);font:700 13px/1.4 var(--font);cursor:pointer}
#triage-drawer .triage-send:disabled{background:var(--raised);border-color:var(--line);color:var(--muted);cursor:not-allowed}
#triage-drawer .triage-hint{font-size:12px;color:var(--muted)}
#triage-drawer .note{margin:0;font-size:12.5px;color:var(--warning)}
#triage-drawer .note:empty,#triage-drawer .triage-send-status:empty{display:none}
#triage-drawer .triage-send-status{margin:0;font-size:13px;color:var(--strong)}
#triage-drawer .triage-send-status[data-kind=refused]{color:var(--danger)}
#triage-drawer .triage-send-status[data-kind=unknown]{color:var(--warning)}
#triage-drawer .triage-send-status[data-kind=ok]{color:var(--success)}
@media (min-width:1200px){body:has(#triage-drawer:not([hidden])) .content{padding-right:calc(440px + 22px)}}
@media (max-width:700px){#triage-drawer{top:0;left:0;width:auto;border-left:0;box-shadow:none;z-index:60}html:has(#triage-drawer:not([hidden])),body:has(#triage-drawer:not([hidden])){overflow:hidden}#triage-drawer .triage-health{max-height:18vh}}
+9 -4
View File
@@ -40,11 +40,15 @@
return value;
}
const plain = v => v !== null && typeof v === 'object' && !Array.isArray(v);
// #1873: the templates no organization may hold (organization vocabulary SYSTEM_ONLY). The read may still
// list them; a step role never resolves to one and the picker never offers one.
const SYSTEM_ONLY = ['triage'];
const offered = list => (list || []).filter(r => !SYSTEM_ONLY.includes(r));
async function read(org, s) {
const value = await call(`${base(org)}/workflows`, 'GET');
if (!plain(value) || !plain(value.workflows) || !plain(value.projects) || !plain(value.roles) || typeof value.revision !== 'string') throw Error('The workflow read returned an unexpected answer.');
s.data = value;
s.known = new Set([...(value.roles.definitions || []), ...(value.roles.templates || []), 'human']);
s.known = new Set([...(value.roles.definitions || []), ...offered(value.roles.templates), 'human']);
}
// SP17: a write in flight holds the poll. Each organization counts its writes (epoch moves when one starts
// and when it ends); a read that began before a write ended, or answers while one is in flight, is dropped
@@ -310,7 +314,7 @@
// The role picker: human, the organization's roles, the role templates, and first any role the step names
// that resolves to none of those (checked and marked, so leaving it in is a choice the save check names).
function rolePick(s, chosen, prefix, off = false) {
const defs = [...(s.data.roles.definitions || [])].sort(), tpl = [...(s.data.roles.templates || [])].filter(r => !defs.includes(r)).sort();
const defs = [...(s.data.roles.definitions || [])].sort(), tpl = offered(s.data.roles.templates).filter(r => !defs.includes(r)).sort();
const odd = chosen.filter(r => !s.known.has(r));
const box = (r, mark = '') => `<label class="wfg-pick"><input type="checkbox" name="role" value="${esc(r)}"${chosen.includes(r) ? ' checked' : ''} data-focus-key="${esc(`${prefix}:role:${r}`)}"> <code>${esc(r)}</code>${mark}</label>`;
const group = (title, list, mark) => (list.length ? `<p class="wfg-pick-h">${title}</p>${list.map(r => box(r, mark)).join('')}` : '');
@@ -620,9 +624,10 @@
const d = drafts.get(key);
if (!d || d.busy) return;
// SP17 review: a new step typed in the add form is not saved over or dropped: Save says so and keeps the
// form. An add form with nothing typed in it is closed and the rest is saved.
// form. So is one in which only the state was changed. An add form left as it opened is closed and the
// rest is saved.
if (d.edit?.mode === 'add') {
if (d.edit.title.trim() || d.edit.roles.length) {
if (d.edit.title.trim() || d.edit.roles.length || editDirty(d.edit)) {
d.atBar = false; d.status = `Not saved: new step ${d.edit.i + 1} is not added yet. Press Add step, or Cancel to drop it.`;
say(d.status); paint(); return toAddTitle();
}
+108 -14
View File
@@ -22,13 +22,27 @@
// 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.
//
// #1873 triage-fences: the host checks a copy of the route's answer before it writes anything, and
// uses only that copy. harnessEnv names must be in the harness module's envNames and pass
// refusedHarnessName; values are clean strings. env holds only ROUTE_ENV_ALLOW names, with
// ANTHROPIC_BASE_URL loopback http on a port (the host's proxyPort when it names one) and the
// token matching the host's tokenPattern when it names one. The adapter and the mounts pass
// checkHostedRoute (sandbox.mjs) against the module's installRoots and the data root, the config
// directory and HOME (HOME not counted against the stack's own code), here and again in
// hostedBinds. A refused answer reaches no spawn, answers triage-route-invalid, and writes
// ROUTE_REFUSED to the transcript; a refusal at the binds also removes what the start wrote.
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 { homedir } from "node:os";
import { dirname, join } from "node:path";
import { BWRAP, REPO, RUNNER_FILES, hostedArgv, hostedBinds } from "../../seat/src/sandbox.mjs";
import { pathToFileURL } from "node:url";
import { BWRAP, REPO, RUNNER_FILES, checkHostedRoute, hostedArgv, hostedBinds } from "../../seat/src/sandbox.mjs";
import { isProviderVariable } from "../../seat/src/session.mjs";
import { configDir as systemConfigDir } from "../../organization/src/organization-config.mjs";
import { typedTools } from "../../harness/src/tools.mjs";
import { builtinTools } from "../../harness/src/bundle.mjs";
import { FOUNDER_ENV } from "../../harness/src/runner.mjs";
@@ -43,6 +57,7 @@ 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.";
export const ROUTE_REFUSED = "Triage did not start: the model route's answer did not pass the host's checks, 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$/;
@@ -56,7 +71,35 @@ const CAP = /^[0-9a-f]{64}$/;
export const SPAWN_ENV_ALLOW = Object.freeze(["PATH", "LANG", "LC_ALL", "TZ", "TERM"]);
export const ROUTE_ENV_ALLOW = Object.freeze(["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN"]);
const ENV_NAME = /^[A-Z][A-Z0-9_]{0,63}$/;
const deniedHarnessName = (k) => !ENV_NAME.test(k) || k === "MOSAIC_CONFIG" || k.startsWith("MOSAIC_BUS_") || FOUNDER_ENV.includes(k) || k === "SSH_AUTH_SOCK";
const ENV_VALUE_MAX = 4096;
const HARNESS_ENV_MAX = 64;
// Refused in harnessEnv even when the harness module declares them: the runner's own MOSAIC_*
// values, loader, libc and interpreter hooks, the shell's start files, a tool's config directory
// and the founder's, an askpass program, a CA bundle or a base URL. A provider name (every ANTHROPIC_* among them) goes through route env or nowhere.
const REFUSED_PREFIX = /^(MOSAIC_|NODE_|LD_|DYLD_|PYTHON|BASH_|GIT_|MALLOC_|NPM_CONFIG_|XDG_)/;
const REFUSED_SUFFIX = /_(DIR|CONF|CONFIG|ASKPASS|CA_BUNDLE|BASE_URL)$/;
const REFUSED_NAMES = new Set([
"PATH", "HOME", "TMPDIR", "BASH_ENV", "ENV", "SSH_AUTH_SOCK", "SHELL", "SHELLOPTS", "BASHOPTS", "PS4", "IFS", "CDPATH",
"GLOBIGNORE", "PROMPT_COMMAND", "ZDOTDIR", "PERL5OPT", "PERL5LIB", "RUBYOPT", "RUBYLIB", "PERLLIB", "LESSOPEN", "LESSCLOSE", "HOSTALIASES", "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY",
"GCONV_PATH", "GLIBC_TUNABLES", "LOCPATH", "OPENSSL_CONF", "OPENSSL_ENGINES", "OPENSSL_MODULES", "SSL_CERT_FILE", "SSL_CERT_DIR",
"JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "JDK_JAVA_OPTIONS",
...FOUNDER_ENV,
]);
export const refusedHarnessName = (k) => typeof k !== "string" || !ENV_NAME.test(k) || REFUSED_PREFIX.test(k) || REFUSED_SUFFIX.test(k) || REFUSED_NAMES.has(k) || isProviderVariable(k);
// No control character of any kind (C0, DEL, C1) and no line or paragraph separator.
const cleanValue = (v) => typeof v === "string" && v.length <= ENV_VALUE_MAX && !/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(v);
const plainObject = (o) => o !== null && typeof o === "object" && !Array.isArray(o) && [Object.prototype, null].includes(Object.getPrototypeOf(o));
// The proxy is on this machine: http, 127.0.0.1, a port, nothing after it.
const LOOPBACK_URL = /^http:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/;
const HARNESS_NAME = /^[a-z][a-z0-9-]{0,31}$/;
// The harness module a route names, from the repository's own tree; null when there is none.
async function repoHarnessModule(name) {
if (!HARNESS_NAME.test(name)) return null;
const file = join(REPO, "packages", "plugins", "harness", name, "index.mjs");
try { if (!lstatSync(file).isFile()) return null; } catch { return null; }
return import(pathToFileURL(file).href);
}
export function triageEnv(source, routeEnv = {}, { node = process.execPath } = {}) {
const env = { PATH: `${dirname(node)}:/usr/bin:/bin` };
@@ -185,8 +228,21 @@ export function createRelay({ socket, cap, take, read, onSend, log = () => {} })
// provider, env } | { ok: false, code, until? } } or null for no route
// readSnapshot async () -> the snapshot (triage-snapshot.mjs composeSnapshot), written to health/
// pollInterval the runner's receive interval in ms, for tests; the runner's default otherwise
export function createTriageHost({ dataRoot, route = null, readSnapshot = async () => null, env = process.env, node = process.execPath, bwrap = BWRAP, now = () => new Date(), devOwner = false, log = () => {}, roleDir = join(REPO, "roles"), readOnly = [], pollInterval = null }) {
// proxyPort the port ANTHROPIC_BASE_URL must name, or null for any port
// tokenPattern a RegExp the whole ANTHROPIC_AUTH_TOKEN must match, or null for no shape check
// harnessModule async (name) -> the harness module (envNames, installRoots) or null; the
// repository's packages/plugins/harness/<name> by default
// home HOME, which no mount may reach outside the stack's own code; the Console user's by default
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, proxyPort = null, tokenPattern = null, harnessModule = repoHarnessModule, home = homedir() }) {
if (typeof dataRoot !== "string" || !dataRoot.startsWith("/")) throw new TriageError("triage-no-data-root", "no data root");
if (proxyPort !== null && !(Number.isInteger(proxyPort) && proxyPort > 0 && proxyPort <= 65535)) throw new TypeError("proxyPort must be a port number or null");
if (tokenPattern !== null && !(tokenPattern instanceof RegExp)) throw new TypeError("tokenPattern must be a RegExp or null");
if (typeof harnessModule !== "function") throw new TypeError("harnessModule must be a function");
const tokenShape = tokenPattern && new RegExp(`^(?:${tokenPattern.source})$`, tokenPattern.flags.replace(/[gmy]/g, ""));
// What no mount source may lie in or around, besides the run directory and the fixed list. HOME
// does not refuse the stack's own code when the stack runs from under it (a copy or a worktree).
const protectedPaths = [dataRoot, systemConfigDir(env), home];
const codeRoot = REPO;
const paths = triagePaths(dataRoot);
const role = JSON.parse(readFileSync(join(roleDir, "triage.json"), "utf8"));
const contract = readFileSync(join(roleDir, role.contract), "utf8");
@@ -272,17 +328,44 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
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");
// The route's answer, checked. It returns a copy taken once, so a getter or a later change to
// the route's object cannot hand the bundle or the binds anything the checks did not see, and
// the module's install roots, for hostedBinds. The log names the fence, never a value.
const checkAdmitted = async (answer) => {
const refuse = (fence) => {
log(`triage host: route refused: ${fence}`);
throw new TriageError("triage-route-invalid", "the model route's answer is not usable");
};
let a;
try { a = structuredClone(answer); } catch { refuse("shape"); }
if (!plainObject(a) || typeof a.adapter !== "string" || !["marker", "exit"].includes(a.turnEnd)
|| typeof a.model !== "string" || !a.model || typeof a.harness !== "string" || !HARNESS_NAME.test(a.harness)
|| (a.provider !== undefined && typeof a.provider !== "string")) refuse("shape");
let mod = null;
try { mod = await harnessModule(a.harness); } catch { mod = null; }
const declared = mod?.envNames;
if (!Array.isArray(declared) || typeof mod.installRoots !== "function") refuse("module");
const he = a.harnessEnv;
if (!plainObject(he) || Object.keys(he).length > HARNESS_ENV_MAX) refuse("harness-env");
for (const [k, v] of Object.entries(he)) if (refusedHarnessName(k) || !declared.includes(k) || !cleanValue(v)) refuse("harness-env");
const re = a.env ?? {};
if (!plainObject(re) || Object.entries(re).some(([k, v]) => !ROUTE_ENV_ALLOW.includes(k) || !cleanValue(v))) refuse("route-env");
const url = LOOPBACK_URL.exec(re.ANTHROPIC_BASE_URL ?? "");
if (!url || Number(url[1]) > 65535 || (proxyPort !== null && Number(url[1]) !== proxyPort)) refuse("route-env");
if (tokenShape && !(typeof re.ANTHROPIC_AUTH_TOKEN === "string" && tokenShape.test(re.ANTHROPIC_AUTH_TOKEN))) refuse("route-env");
let installRoots;
try { installRoots = structuredClone(mod.installRoots({ env })); } catch { refuse("module"); }
try {
checkHostedRoute({ adapter: a.adapter, harnessMounts: a.harnessMounts ?? [], installRoots, protectedPaths, codeRoot, codeHolder: home, runDir: paths.agent, node });
} catch (e) {
if (e?.code === "hosted-binds-refused") refuse(e.fence);
throw e;
}
return { admitted: a, installRoots };
};
const start = async (admitted) => {
checkAdmitted(admitted);
const start = async (answer) => {
const { admitted, installRoots } = await checkAdmitted(answer);
ensureDirs();
writeBundle(admitted);
cap = randomBytes(32).toString("hex");
@@ -307,7 +390,18 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
},
log,
});
const list = hostedBinds({ runDir: paths.agent, healthDir: paths.health, adapter: admitted.adapter, harnessMounts: admitted.harnessMounts ?? [], relaySocket: join(paths.agent, "relay.sock"), node, readOnly });
let list;
try {
list = hostedBinds({ runDir: paths.agent, healthDir: paths.health, adapter: admitted.adapter, harnessMounts: admitted.harnessMounts ?? [], installRoots, protectedPaths, codeRoot, codeHolder: home, relaySocket: join(paths.agent, "relay.sock"), node, readOnly });
} catch (e) {
if (e?.code !== "hosted-binds-refused") throw e;
log(`triage host: route refused at the binds: ${e.fence}`);
// Nothing of the refused start stays: the relay, its socket, the bundle and session.json go.
relay?.close();
relay = null;
for (const f of ["relay.sock", "session.json", "bundle"]) rmSync(join(paths.agent, f), { recursive: true, force: true });
throw new TriageError("triage-route-invalid", "the model route's answer is not usable");
}
const argv = hostedArgv(list, paths.agent, [node, RUNNER, paths.agent], { bwrap });
const out = openSync(paths.log, "a", 0o600);
try {
@@ -406,7 +500,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
catch (e) {
const i = queue.findIndex((m) => m.id === id);
if (i >= 0) queue.splice(i, 1);
try { append({ at: now().toISOString(), from: "host", in_reply_to: id, text: NOT_STARTED }); } catch {}
try { append({ at: now().toISOString(), from: "host", in_reply_to: id, text: e?.code === "triage-route-invalid" ? ROUTE_REFUSED : NOT_STARTED }); } catch {}
relay?.close();
relay = null;
log(`triage host: start failed: ${e.code ?? "error"}`);
@@ -0,0 +1,411 @@
// #1873 triage-drawer: the Console's Triage drawer over GET /api/triage and POST /api/triage/message.
// Only the instance owner sees it: the entry, the drawer and every Triage request exist only when the
// unscoped /api/config says triage: true. The real server serves the routes from a fake Triage host,
// so every answer here crossed the real HTTP boundary. One page stub forces the 403 answer, which the
// browser's own same-origin request cannot produce.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { fileURLToPath } from 'node:url';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { TriageError, NOT_STARTED } from '../src/triage-host.mjs';
import { capMessage, NO_ROUTE_MESSAGE } from '../src/triage-http.mjs';
import { browser } from './browser.mjs';
import { close } from './fixture.mjs';
const waitFor = b => (expression, tries = 200) => b.evaluate(`(async()=>{for(let i=0;i<${tries};i++){if(${expression})return;await new Promise(r=>setTimeout(r,30))}throw Error(${JSON.stringify(expression)})})()`);
const sleep = ms => new Promise(r => setTimeout(r, ms));
const at = minutesAgo => new Date(Date.now() - minutesAgo * 60000).toISOString();
const POLL_MS = 4000;
async function orgFixture() {
const { checkRootAgents } = await import('../../organization/src/index.mjs');
const rolesDir = fileURLToPath(new URL('../../../roles', import.meta.url));
const root = { state: 'ok', ...checkRootAgents({ agentsVersion: 1, agents: {} }, { rolesDir }) };
const LIST = [{ id: 'acme', label: 'Acme Studio', theme: 'cobalt', busHealthy: true }];
const empty = (name) => Promise.resolve(['usage', 'limits'].includes(name) ? {} : []);
const opts = () => ({
bus: { inbox: () => empty('inbox'), agents: () => empty('agents'), 'thread.claims': () => empty('claims'), tasks: () => empty('tasks'), usage: () => empty('usage'), limits: () => empty('limits'), decisions: () => empty('decisions') },
chat: { threads: () => empty('threads'), projects: () => empty('projects') },
});
const member = org => ({ id: org.id, doc: { appearance: { theme: org.theme }, roles: { chief: { definition: 'chief-of-staff' } }, projects: {} }, status: async () => ({ healthy: true, pid: 4242, boot: null }), options: opts });
const organizations = {
list: async () => LIST,
members: async () => LIST.map(member),
resolve: async id => {
const org = LIST.find(o => o.id === id); if (!org) return null;
return {
busHealthy: true,
reads: { business: async () => ({ business: { id, human: 'jason', projects: [], appearance: { theme: org.theme } } }), settings: async () => ({ business: id, release: 'fixture', notifier: {}, launch: { business: id, revision: 'a'.repeat(64), models: {}, limits: { total: 4 }, instances: {}, usage: { total: 0, providers: {}, models: {} } } }), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
bus: { messages: async () => ({ messages: [], unread: 0 }), agents: async () => [], 'thread.claims': async () => [], inbox: async () => [], tasks: async () => [], instances: async () => ({ business: id, revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }) },
chat: { projects: async () => [], threads: async () => [] },
};
},
};
return { organizations, agentLevels: { loadRoot: () => root, rolesDir, ctx: { configDir: '/cfg', dataRoot: '/data', instance: 'test' } } };
}
const SNAPSHOT = () => ({
snapshotVersion: 1, at: at(1), console: { state: 'answering', at: at(1) }, proxy: 'not read',
systemConfig: { valid: true, exit: 0, code: null },
organizations: { count: 2, list: [
{ id: 'acme', bus: { state: 'running', lastStart: { ok: true, at: at(60) } }, processing: { halted: false, invalid: false }, config: { valid: true, exit: 0, code: null } },
{ id: 'gamma', bus: 'not read', processing: 'not read', config: { valid: false, exit: 2, code: 'org-config-invalid' } },
] },
});
// The fake host. `h` is the state the next read returns; `h.next` is an error the next message throws.
// An error marked `recorded` throws after the owner line and the host's "did not start" line are written,
// as the real host does when the session fails to start.
function fakeHost(over = {}) {
const h = { route: 'set', running: false, lastExit: null, overCapUntil: null, snapshot: SNAPSHOT(), transcript: [], reads: 0, sent: [], next: null, ...over };
let n = 0;
const triage = {
snapshotAt: () => Date.now(),
refresh: async () => null,
state: async () => { h.reads += 1; return { route: h.route, running: h.running, lastExit: h.lastExit, overCapUntil: h.overCapUntil, snapshot: h.snapshot, transcript: h.transcript }; },
message: async text => {
h.sent.push(text);
const e = h.next; h.next = null;
if (e && !e.recorded) throw e;
const m = { id: `owner-${String(++n).padStart(12, '0')}`, at: new Date().toISOString() };
h.transcript = [...h.transcript, { at: m.at, from: 'owner', id: m.id, text }];
if (e) { h.transcript = [...h.transcript, { at: new Date().toISOString(), from: 'host', in_reply_to: m.id, text: NOT_STARTED }]; throw e; }
return m;
},
};
return { h, triage };
}
async function setup(t, { host = fakeHost(), triage = host.triage, send = true, sso = createDevOwner(), viewport = [1440, 900], path = '/#/dashboard', init = null } = {}) {
const { organizations, agentLevels } = await orgFixture();
const server = await startServer({ port: 0, sso, organizations, agentLevels, triage, send: send ? async () => ({}) : null, log: () => {} });
t.after(() => close(server));
const b = await browser({ machine: false }); t.after(() => b.close());
await b.viewport(...viewport);
const requests = [];
await b.call('Network.enable');
b.on('Network.requestWillBeSent', p => { const u = new URL(p.request.url); requests.push(`${p.request.method} ${u.pathname}`); });
if (init) await b.call('Page.addScriptToEvaluateOnNewDocument', { source: init });
const base = `http://127.0.0.1:${server.address().port}`;
await b.navigate(`${base}${path}`);
const wait = waitFor(b);
const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.innerText ?? null`);
const click = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)}).click()`);
const triageReads = () => requests.filter(r => r === 'GET /api/triage').length;
return { b, base, wait, text, click, requests, triageReads, h: host.h };
}
// The page focuses its heading when its first render ends (bus.js). Open after that, as a person would, or
// that late focus can land after the drawer's own.
const open = async f => { await f.wait('document.querySelector("#triage-open")'); await f.wait('document.activeElement?.tagName === "H1"', 100).catch(() => {}); await f.click('#triage-open'); await f.wait('["off", "cap", "running", "stopped"].includes(document.querySelector("#triage-drawer #triage-state")?.dataset.kind)'); };
const type = async (f, words) => { await f.b.evaluate('document.querySelector("#triage-text").focus()'); await f.b.call('Input.insertText', { text: words }); };
const sendAndWait = async (f, before) => { await f.click('#triage-send'); await f.wait(`document.querySelector("#triage-send-status").textContent.trim() && document.querySelector("#triage-send-status").textContent !== ${JSON.stringify(before)} && !document.querySelector("#triage-send").disabled`); return f.text('#triage-send-status'); };
test('item 1: a session that is not the instance owner gets no entry, no drawer markup and no Triage request', async t => {
// No Triage host wired: the config never says triage.
{
const f = await setup(t, { triage: null });
await f.wait('document.querySelector("#dashboard-kpis")');
await sleep(1500);
assert.equal(await f.b.evaluate('document.querySelector("#triage-open, #triage-drawer, [id^=triage]")'), null);
assert.deepEqual(f.requests.filter(r => /triage/i.test(r)), []);
}
// A Triage host, but a signed-in session that is not the root owner.
{
const owner = createDevOwner(), plain = { ...owner.session(), rootOwner: false };
const f = await setup(t, { sso: { ...owner, session: () => plain } });
await f.wait('document.querySelector("#dashboard-kpis")');
await sleep(1500);
assert.equal(await f.b.evaluate('document.querySelector("[id^=triage]")'), null);
assert.equal(await f.b.evaluate('document.body.innerHTML.includes("Triage")'), false, 'no Triage words in the page');
assert.deepEqual(f.requests.filter(r => /triage/i.test(r)), []);
}
});
test('item 1: the owner gets one Triage entry in the top bar on the dashboard and inside an organization; nothing is read until it opens', async t => {
const f = await setup(t, { path: '/#/orgs/acme/organization' });
await f.wait('document.querySelector(".cmd-right #triage-open")');
assert.equal(await f.b.evaluate('document.querySelectorAll("#triage-open").length'), 1);
assert.equal(await f.b.evaluate('document.querySelector("#triage-drawer")'), null, 'no drawer markup before it opens');
await sleep(800);
assert.equal(f.triageReads(), 0, 'no read before it opens');
assert.equal(await f.b.evaluate('document.querySelector("#triage-open").getAttribute("aria-expanded")'), 'false');
await open(f);
assert.equal(await f.b.evaluate('document.querySelector("#triage-open").getAttribute("aria-expanded")'), 'true');
// From inside an organization the read is still the system route, never the organization's.
assert.ok(f.triageReads() >= 1);
assert.deepEqual(f.requests.filter(r => /triage/.test(r) && r !== 'GET /api/triage'), []);
assert.ok(f.requests.includes('GET /api/config'), 'the unscoped config read');
// The same entry on the system dashboard.
await f.b.evaluate('location.hash = "#/dashboard"');
await f.wait('location.hash === "#/dashboard" && document.querySelector("#triage-open")');
});
test('item 1: at 390 wide the entry stays visible and one click opens the drawer', async t => {
const f = await setup(t, { viewport: [390, 844] });
await f.wait('document.querySelector("#triage-open")');
const box = await f.b.evaluate('(() => { const r = document.querySelector("#triage-open").getBoundingClientRect(); return { w: r.width, h: r.height, right: r.right, top: r.top }; })()');
assert.ok(box.w > 0 && box.h > 0 && box.right <= 390 && box.top >= 0, JSON.stringify(box));
await open(f);
const d = await f.b.evaluate('(() => { const r = document.querySelector("#triage-drawer").getBoundingClientRect(); return { l: r.left, w: r.width, page: document.documentElement.clientWidth }; })()');
assert.ok(d.l <= 1 && d.w >= d.page - 1, `the drawer takes the whole width: ${JSON.stringify(d)}`);
assert.equal(await f.b.evaluate('document.documentElement.scrollWidth <= 390'), true, 'no sideways scroll');
});
test('item 2 and 3: route not set says so, and the message box is off with the reason', async t => {
const f = await setup(t, { host: fakeHost({ route: 'not set' }) });
await open(f);
assert.match(await f.text('#triage-state'), new RegExp(NO_ROUTE_MESSAGE.slice(0, 40)));
assert.equal(await f.b.evaluate('document.querySelector("#triage-text")?.disabled'), true);
assert.equal(await f.b.evaluate('document.querySelector("#triage-send")?.disabled'), true);
assert.match(await f.text('#triage-send-off'), /no model route is set/i);
});
test('item 2: over cap shows the cap message and the time it takes messages again', async t => {
const until = new Date(Date.now() + 3 * 3600000).toISOString();
const f = await setup(t, { host: fakeHost({ overCapUntil: until }) });
await open(f);
const state = await f.text('#triage-state');
assert.ok(state.includes(capMessage(until)), state);
const local = await f.b.evaluate(`window.MosaicLocalTime(${JSON.stringify(until)})`);
assert.ok(state.includes(`Local time: ${local}.`), state);
assert.match(await f.text('#triage-send-off'), /daily token cap/i);
});
test('item 2: running, last exit, and the health snapshot with "not read" shown as that', async t => {
const host = fakeHost({ running: true });
const f = await setup(t, { host });
await open(f);
assert.match(await f.text('#triage-state'), /^Running/);
const health = await f.text('#triage-health');
assert.match(health, /Console: answering/);
assert.match(health, /Proxy: not read/);
assert.match(health, /System config: valid/);
assert.match(health, /acme: bus running, processing on, config valid/);
assert.match(health, /gamma: bus not read, processing not read, config not valid \(org-config-invalid\)/);
assert.doesNotMatch(health.split('\n').find(l => l.startsWith('gamma')), /healthy|running/);
// The next poll picks up a stopped session and its last exit, and a snapshot that read nothing.
host.h.running = false; host.h.lastExit = { code: 1, signal: null, at: at(2) };
host.h.snapshot = { snapshotVersion: 1, at: at(0), console: { state: 'answering', at: at(0) }, proxy: { initialized: true, installed: true, active: 'active', healthy: true, fence: false }, systemConfig: 'not read', organizations: 'not read' };
await f.wait('/Last exit/.test(document.querySelector("#triage-state").textContent)', 300);
assert.match(await f.text('#triage-state'), /Not running\. Last exit: code 1/);
const after = await f.text('#triage-health');
assert.match(after, /Proxy: healthy/);
assert.match(after, /System config: not read/);
assert.match(after, /Organizations: not read/);
// No snapshot at all.
host.h.snapshot = null;
await f.wait('/Health: not read/.test(document.querySelector("#triage-health").textContent)', 300);
});
test('item 2: the transcript shows owner, Triage and host lines, a reply under its message, and cards as text with no Run button', async t => {
const transcript = [
{ at: at(5), from: 'owner', id: 'owner-000000000001', text: 'Why is gamma down?' },
{ at: at(4), from: 'triage', in_reply_to: 'owner-000000000001', text: 'gamma config is not valid. Restart acme after fixing it.', cards: [{ step: 'org-config-validate', org: 'gamma', command: 'mosaic org config validate gamma' }, { step: 'bus-restart', org: 'acme', command: 'mosaic bus restart acme' }], dropped: 2 },
{ at: at(3), from: 'owner', id: 'owner-000000000002', text: 'And beta?' },
{ at: at(2), from: 'host', in_reply_to: 'owner-000000000002', text: 'Triage stopped before it answered this message. Send it again.' },
];
const f = await setup(t, { host: fakeHost({ running: true, transcript }) });
await open(f);
const items = await f.b.evaluate('[...document.querySelectorAll("#triage-transcript > li")].map(li => ({ from: li.dataset.from, text: li.innerText }))');
assert.deepEqual(items.map(i => i.from), ['owner', 'triage', 'owner', 'host']);
assert.match(items[0].text, /You/); assert.match(items[0].text, /Why is gamma down\?/);
assert.match(items[1].text, /Triage/); assert.match(items[1].text, /Reply to: Why is gamma down\?/);
assert.match(items[1].text, /Step: org-config-validate/); assert.match(items[1].text, /Organization: gamma/);
assert.match(items[1].text, /mosaic org config validate gamma/); assert.match(items[1].text, /mosaic bus restart acme/);
assert.match(items[1].text, /2 cards dropped/);
assert.match(items[3].text, /Console/); assert.match(items[3].text, /Reply to: And beta\?/);
assert.equal(await f.b.evaluate('document.querySelectorAll("#triage-transcript button, #triage-transcript a, #triage-transcript input").length'), 0, 'no Run button or link in a card');
assert.equal(await f.b.evaluate('[...document.querySelectorAll("#triage-drawer button")].some(x => /run/i.test(x.textContent))'), false);
});
test('item 3: each send answer has plain words, a refused send keeps the draft, and an unknown outcome is never resent', async t => {
const host = fakeHost({ running: true });
const until = new Date(Date.now() + 2 * 3600000).toISOString();
// The browser's own request is same-origin, so the 403 comes from a page stub over the native fetch.
const init = `(() => { const f = window.fetch.bind(window); window.fetch = (input, init) => (window.__force403 && input === '/api/triage/message') ? Promise.resolve(new Response('{"error":"read-only"}', { status: 403, headers: { 'content-type': 'application/json' } })) : f(input, init); })();`;
const f = await setup(t, { host, init });
await open(f);
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-text', 'the box has focus when the drawer opens');
let status = '';
const draft = () => f.b.evaluate('document.querySelector("#triage-text").value');
const refused = async (setupNext, pattern, label) => {
await setupNext();
status = await sendAndWait(f, status);
assert.match(status, pattern, label);
assert.equal(await draft(), 'is acme healthy?', `${label}: the draft stays`);
};
await type(f, 'is acme healthy?');
await refused(() => { host.h.next = new TriageError('triage-no-route', 'x'); }, /Not sent.*no model route is set/i, '409');
await refused(() => { const e = new TriageError('triage-over-cap', 'x'); e.until = until; host.h.next = e; }, new RegExp(`Not sent.*daily token cap.*${until.slice(0, 16)}`), '429');
await refused(() => { host.h.next = new TriageError('triage-message-too-long', 'x'); }, /Not sent.*too long/i, '400');
await refused(() => f.b.evaluate('window.__force403 = true'), /Not sent.*read-only/i, '403');
await f.b.evaluate('window.__force403 = false');
const before = host.h.sent.length;
await refused(() => { host.h.next = new Error('lost'); }, /may or may not have arrived/i, '503');
assert.equal(host.h.sent.length, before + 1);
await sleep(POLL_MS + 1500);
assert.equal(host.h.sent.length, before + 1, 'an unknown outcome is not sent again');
status = await sendAndWait(f, status);
assert.match(status, /^Sent/);
assert.equal(await draft(), '', 'a sent message clears the box');
await f.wait('[...document.querySelectorAll("#triage-transcript > li")].some(li => li.dataset.from === "owner" && li.textContent.includes("is acme healthy?"))');
// Ctrl+Enter sends too.
await type(f, 'second');
await f.b.key('Enter', 'Enter', 2);
await f.wait('document.querySelector("#triage-text").value === "" && /^Sent/.test(document.querySelector("#triage-send-status").textContent)');
assert.equal(host.h.sent.at(-1), 'second');
});
test('item 3: a read-only Console shows no message box and says why', async t => {
const f = await setup(t, { send: false });
await open(f);
assert.equal(await f.b.evaluate('document.querySelector("#triage-text")'), null);
assert.match(await f.text('#triage-send-off'), /read-only/i);
});
test('item 3: a send that reached the conversation but did not start Triage says so, not "Not sent", and keeps the draft', async t => {
const host = fakeHost();
const f = await setup(t, { host });
await open(f);
let status = '';
for (const [code, words] of [['triage-start-failed', /session did not start/i], ['triage-route-invalid', /route's answer is not usable/i]]) {
await f.b.evaluate('document.querySelector("#triage-text").value = ""');
await type(f, `try ${code}`);
const e = new TriageError(code, 'x'); e.recorded = true; host.h.next = e;
status = await sendAndWait(f, status);
assert.doesNotMatch(status, /^Not sent/, code);
assert.match(status, /Not delivered/, code);
assert.match(status, words, code);
assert.match(status, /in the conversation/i, code);
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), `try ${code}`, `${code}: the draft stays`);
await f.wait(`document.querySelector("#triage-transcript").textContent.includes(${JSON.stringify(NOT_STARTED)})`, 300);
}
// A directory refusal can come before or after the message is written, so the words cover both.
host.h.next = new TriageError('triage-dir-unsafe', 'x');
status = await sendAndWait(f, status);
assert.match(status, /Not delivered.*not safe to use.*check the conversation/i);
assert.doesNotMatch(status, /did not start/i, 'this one can come while a session runs');
});
test('item 3: a read that turns sending off hides the box and keeps the draft; one that turns it on again shows it', async t => {
const init = `(() => { const f = window.fetch.bind(window); window.fetch = (input, init) => (window.__sendOff && input === '/api/triage') ? f(input, init).then(r => r.json()).then(j => new Response(JSON.stringify({ ...j, send: false }), { status: 200, headers: { 'content-type': 'application/json' } })) : f(input, init); })();`;
const f = await setup(t, { host: fakeHost({ running: true }), init });
await open(f);
await type(f, 'keep me');
await f.b.evaluate('window.__sendOff = true');
await f.wait('/read-only/i.test(document.querySelector("#triage-send-off")?.textContent || "")', 300);
const off = await f.b.evaluate('(() => { const x = document.querySelector("#triage-text"); return x && { value: x.value, hidden: x.hidden, disabled: x.disabled, send: document.querySelector("#triage-send").disabled, shown: x.getClientRects().length > 0 }; })()');
assert.deepEqual(off, { value: 'keep me', hidden: true, disabled: true, send: true, shown: false });
await f.b.evaluate('window.__sendOff = false');
await f.wait('document.querySelector("#triage-text").getClientRects().length > 0', 300);
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), 'keep me');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").disabled'), false);
assert.equal(await f.text('#triage-send-off'), '');
});
test('item 4: polling runs only while the drawer is open and stops on close', async t => {
const f = await setup(t, { host: fakeHost({ running: true }) });
await f.wait('document.querySelector("#triage-open")');
await sleep(1000);
assert.equal(f.triageReads(), 0);
await open(f);
await sleep(POLL_MS * 2 + 1000);
const open2 = f.triageReads();
assert.ok(open2 >= 2, `reads while open: ${open2}`);
await f.click('#triage-drawer .x');
await f.wait('!document.querySelector("#triage-drawer") || document.querySelector("#triage-drawer").hidden');
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-open', 'focus goes back to the entry');
const closed = f.triageReads();
await sleep(POLL_MS * 2 + 1000);
assert.equal(f.triageReads(), closed, 'no read after close');
// Escape closes it as well, and reopening reads again.
await open(f);
await f.b.evaluate('document.querySelector("#triage-text").focus()');
await f.b.key('Escape');
await f.wait('!document.querySelector("#triage-drawer") || document.querySelector("#triage-drawer").hidden');
});
test('item 4: a poll keeps the draft and the cursor, and keeps the scroll position when the reader has scrolled up', async t => {
const transcript = Array.from({ length: 40 }, (_, i) => ({ at: at(60 - i), from: i % 2 ? 'triage' : 'owner', ...(i % 2 ? { text: `answer ${i}`, cards: [], dropped: 0 } : { id: `owner-${String(i).padStart(12, '0')}`, text: `question ${i}` }) }));
const host = fakeHost({ running: true, transcript });
const f = await setup(t, { host, viewport: [1440, 700] });
await open(f);
const scroller = 'document.querySelector("#triage-transcript")';
// Opening lands on the newest line.
assert.equal(await f.b.evaluate(`(() => { const s = ${scroller}; return s.scrollHeight - s.scrollTop - s.clientHeight < 4; })()`), true);
await type(f, 'half a thought');
await f.b.evaluate('document.querySelector("#triage-text").setSelectionRange(4, 4)');
await f.b.evaluate(`${scroller}.scrollTop = 120`);
host.h.transcript = [...transcript, { at: at(0), from: 'host', text: 'a new line', in_reply_to: null }];
await f.wait('document.querySelector("#triage-transcript").textContent.includes("a new line")', 300);
assert.equal(await f.b.evaluate(`${scroller}.scrollTop`), 120, 'scrolled up: the position stays');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), 'half a thought');
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-text');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").selectionStart'), 4);
// At the bottom, a new line scrolls into view.
await f.b.evaluate(`(() => { const s = ${scroller}; s.scrollTop = s.scrollHeight; })()`);
host.h.transcript = [...host.h.transcript, { at: at(0), from: 'host', text: 'one more line' }];
await f.wait('document.querySelector("#triage-transcript").textContent.includes("one more line")', 300);
assert.equal(await f.b.evaluate(`(() => { const s = ${scroller}; return s.scrollHeight - s.scrollTop - s.clientHeight < 4; })()`), true);
});
test('item 4: at the 200-line cap the oldest lines drop, and a scrolled-up reader keeps the same lines in view, even with an identical line above', async t => {
const line = i => ({ at: new Date(Date.now() - (300 - i) * 60000).toISOString(), from: 'host', text: `line ${i}` });
const transcript = Array.from({ length: 200 }, (_, i) => line(i));
transcript[4] = transcript[8]; // an identical twin of the line that is first in view
const host = fakeHost({ running: true, transcript });
const f = await setup(t, { host, viewport: [1440, 700] });
await open(f);
const firstInView = `(() => { const s = document.querySelector("#triage-transcript"), top = s.getBoundingClientRect().top; const li = [...s.children].find(n => n.getBoundingClientRect().bottom > top + 1); return { text: li.textContent, second: li.nextElementSibling.textContent, off: Math.round(li.getBoundingClientRect().top - top) }; })()`;
await f.b.evaluate('document.querySelector("#triage-transcript").scrollTop = 600');
const before = await f.b.evaluate(firstInView);
assert.match(before.text, /line 8$/, 'the twin line is the one in view');
host.h.transcript = [...transcript.slice(3), line(200), line(201), line(202)];
await f.wait('document.querySelector("#triage-transcript").textContent.includes("line 202")', 300);
const after = await f.b.evaluate(firstInView);
assert.equal(after.text, before.text, 'the same line is first in view');
assert.equal(after.second, before.second, 'and the same line follows it');
assert.ok(Math.abs(after.off - before.off) <= 1, `at the same place: ${before.off} then ${after.off}`);
});
test('item 5: markup and control characters in every field stay text: no element, no link, no script', async t => {
const BAD = '<img src=x onerror="window.__pwned=1"><a href="https://example.test/x">link</a><b>bold</b><script>window.__pwned=2</script>';
const CTRL = '\u0007\u001b[31m\u202eevil\u200b\u2028\ufeff\u00ad\u2060\u034f\ufe0f\u{E0041}\u{E0100}\u{E0002}\u17b4\ufff0';
const v = s => `${BAD}${CTRL}${s}`;
const snapshot = {
snapshotVersion: 1, at: v('at'), console: { state: v('state'), at: v('cat') },
proxy: { initialized: true, installed: true, active: v('active'), healthy: null, fence: false },
systemConfig: { valid: false, exit: 2, code: v('code') },
organizations: { count: 1, list: [{ id: v('org'), bus: { state: v('bus'), lastStart: { ok: false, at: v('ls') } }, processing: { halted: true, invalid: true }, config: { valid: false, exit: 2, code: v('oc') } }] },
};
const transcript = [
{ at: v('t1'), from: 'owner', id: v('id'), text: v('owner text') },
{ at: v('t2'), from: 'triage', in_reply_to: v('id'), text: v('triage text'), cards: [{ step: v('step'), org: v('corg'), command: v('cmd') }], dropped: v('dropped') },
{ at: v('t3'), from: 'host', in_reply_to: v('nope'), text: v('host text') },
{ at: v('t4'), from: v('from'), text: v('unknown sender') },
];
const host = fakeHost({ running: true, transcript, snapshot, lastExit: { code: v('code'), signal: v('sig'), at: v('lat') }, overCapUntil: v('until') });
const f = await setup(t, { host });
await open(f);
await f.wait('document.querySelector("#triage-transcript > li")');
const out = await f.b.evaluate(`(() => {
const d = document.querySelector('#triage-drawer');
return {
pwned: window.__pwned ?? null,
tags: [...d.querySelectorAll('img, a, b, script, iframe, svg image, [onerror], [href]')].map(e => e.outerHTML),
text: d.textContent,
body: document.body.querySelectorAll('img[src="x"], a[href^="https://example.test"]').length,
};
})()`);
assert.equal(out.pwned, null);
assert.deepEqual(out.tags, []);
assert.equal(out.body, 0);
for (const word of ['owner text', 'triage text', 'host text', 'cmd', 'corg', 'step', 'org', 'oc', 'code', 'active']) assert.ok(out.text.includes(word), `${word} shown as text`);
assert.ok(out.text.includes('<img src=x onerror='), 'the markup reads as its own characters');
// eslint-disable-next-line no-control-regex
assert.doesNotMatch(out.text, /[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u061c\u180e\u2028\u2029\ufeff\u200b-\u200f\u202a-\u202e\u2066-\u2069\u00ad\u2060-\u2064\u034f\ufe00-\ufe0f\u{E0000}-\u{E007F}\u{E0100}-\u{E01EF}\p{Default_Ignorable_Code_Point}]/u, 'no control, direction, invisible or tag characters reach the page');
await sleep(500);
assert.equal(await f.b.evaluate('window.__pwned ?? null'), null);
});
+310 -25
View File
@@ -5,12 +5,14 @@
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 { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { Client } from "../../bus/src/client.mjs";
import { sandboxProblem } from "../../seat/src/sandbox.mjs";
import { REPO, RUNNER_FILES, checkHostedRoute, sandboxProblem } from "../../seat/src/sandbox.mjs";
import { isProviderVariable } from "../../seat/src/session.mjs";
import {
NOT_STARTED, NOT_TAKEN, RELAY_REFUSED, ROUTE_ENV_ALLOW, SPAWN_ENV_ALLOW, UNANSWERED, createRelay, createTriageHost, hostPrompt, triageEnv,
NOT_STARTED, NOT_TAKEN, RELAY_REFUSED, ROUTE_ENV_ALLOW, ROUTE_REFUSED, SPAWN_ENV_ALLOW, UNANSWERED, createRelay, createTriageHost, hostPrompt,
refusedHarnessName, triageEnv,
} from "../src/triage-host.mjs";
const FIXTURE = new URL("./fixtures/triage-adapter.mjs", import.meta.url).pathname;
@@ -95,13 +97,67 @@ test("the prompt names the snapshot inside the session and the card form, after
assert.match(text, /```cards\n\[\{"step": "bus-start", "org": "alpha"\}\]\n```/);
});
// Names the route may try in harnessEnv that the host refuses even when the module declares them.
const REFUSED_TRIED = [
"MOSAIC_POLICY_FILE", "MOSAIC_TOOLS_FILE", "MOSAIC_CONFIG", "MOSAIC_BUS_CONSOLE_SOCKET", "NODE_OPTIONS", "NODE_PATH", "LD_PRELOAD",
"LD_LIBRARY_PATH", "DYLD_INSERT_LIBRARIES", "PYTHONPATH", "PYTHONSTARTUP", "PATH", "HOME", "TMPDIR", "BASH_ENV", "ENV", "SSH_AUTH_SOCK",
"GITEA_TOKEN", "GH_TOKEN", "GIT_ASKPASS", "GIT_CONFIG_PARAMETERS", "VIKUNJA_TOKEN", "ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN",
"ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN", "OPENAI_API_KEY", "GLIBC_TUNABLES", "PI_CODING_AGENT_DIR", "XDG_CONFIG_HOME",
];
// The fake harness module: it declares the probe names and every refused one, so only the host's
// own refusal stops those. Its one install root is <root>/install.
const DECLARED = Object.freeze(["TRIAGE_PROBE", "FAKE_OK", "FAKE_TWO", ...REFUSED_TRIED]);
const fakeModule = (roots, names = DECLARED) => async (name) => name === "fake" ? { envNames: names, installRoots: () => roots } : null;
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 });
mkdirSync(join(root, "install"), { recursive: true });
if (!existsSync(join(root, "install", "adapter.sh"))) writeFileSync(join(root, "install", "adapter.sh"), "exit 0\n");
const h = createTriageHost({ dataRoot, readSnapshot: async () => SNAPSHOT, env: CONSOLE_ENV, readOnly: [FIXTURE], pollInterval: 100, harnessModule: fakeModule([join(root, "install")]), ...opts });
t.after(() => h.stop());
return { h, dataRoot };
}
// A launcher that only leaves a mark: a spawn is proved by the mark, no spawn by its absence.
function spy(root) {
const f = join(root, "spy");
writeFileSync(f, `#!/bin/sh\n: > '${join(root, "spawned")}'\nexit 0\n`, { mode: 0o755 });
return f;
}
const answer = (root, over = {}) => ({
ok: true, adapter: join(root, "install", "adapter.sh"), harness: "fake", harnessEnv: {}, harnessMounts: [], turnEnd: "exit",
model: "m", provider: "p", env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9" }, ...over,
});
// One route answer through a fresh host: refused before anything is written or spawned, with the
// one code, the owner-readable line, and a log line that names the fence.
async function refusedRoute(t, label, make, opts = {}) {
const root = scratch();
mkdirSync(join(root, "install"), { recursive: true });
const logs = [];
const over = await make(root);
const route = { admit: async () => (typeof over === "function" ? over() : answer(root, over)) };
const { h, dataRoot } = host(t, root, { route, bwrap: spy(root), log: (l) => logs.push(l), ...(typeof opts === "function" ? opts(root) : opts) });
await assert.rejects(h.message("hello"), (e) => e.code === "triage-route-invalid" && e.message === "the model route's answer is not usable", label);
assert.equal(existsSync(join(root, "spawned")), false, `${label}: nothing spawned`);
assert.equal(h.running, false, label);
assert.equal(existsSync(join(dataRoot, "triage", "agent", "session.json")), false, `${label}: no bundle`);
const [owner, note, ...rest] = (await h.state()).transcript;
assert.deepEqual([owner.from, note.from, note.in_reply_to, note.text, rest.length], ["owner", "host", owner.id, ROUTE_REFUSED, 0], label);
assert.ok(logs.some((l) => /^triage host: route refused: [a-z-]+$/.test(l)), `${label}: ${logs.join(" | ")}`);
return logs;
}
// One route answer through a fresh host that must reach the launcher; the session.json it wrote.
async function admittedRoute(t, label, make, opts = {}) {
const root = scratch();
mkdirSync(join(root, "install"), { recursive: true });
const over = await make(root);
const route = { admit: async () => (typeof over === "function" ? over() : answer(root, over)) };
const { h, dataRoot } = host(t, root, { route, bwrap: spy(root), ...(typeof opts === "function" ? opts(root) : opts) });
await h.message("hello");
await waitFor(() => existsSync(join(root, "spawned")));
return JSON.parse(readFileSync(join(dataRoot, "triage", "agent", "session.json"), "utf8"));
}
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");
@@ -147,20 +203,249 @@ test("over the cap: the message is refused until the next day and nothing launch
await assert.rejects(other.message("hello"), (e) => e.code === "triage-route-refused" && e.until === undefined);
});
test("a route whose answer carries a config, bus or founder variable is refused before anything starts", async (t) => {
for (const name of ["MOSAIC_CONFIG", "MOSAIC_BUS_CONSOLE_SOCKET", "GITEA_TOKEN", "SSH_AUTH_SOCK", "lower"]) {
const root = scratch();
const adapter = join(root, "adapter.sh");
writeFileSync(adapter, "exit 0\n");
const route = { admit: async () => ({ ok: true, adapter, harness: "fake", harnessEnv: { [name]: "x" }, harnessMounts: [], turnEnd: "exit", model: "m", provider: "p", env: {} }) };
const { h, dataRoot } = host(t, root, { route });
await assert.rejects(h.message("hello"), (e) => e.code === "triage-route-invalid", name);
assert.equal(h.running, false);
assert.equal(existsSync(join(dataRoot, "triage", "agent", "session.json")), false);
// The owner's line is written before the start; the transcript then says it was not delivered.
const [owner, note, ...rest] = (await h.state()).transcript;
assert.deepEqual([owner.from, owner.text, note.from, note.in_reply_to, note.text, rest.length], ["owner", "hello", "host", owner.id, NOT_STARTED, 0], name);
// #1873 triage-fences, design section 4. Every refused answer reaches no spawn (the spy launcher
// leaves no mark), writes no bundle, answers triage-route-invalid and leaves ROUTE_REFUSED under
// the owner's line.
test("fence 1: a harnessEnv name the host refuses is refused even when the harness module declares it", async (t) => {
for (const name of REFUSED_TRIED) {
assert.ok(DECLARED.includes(name));
await refusedRoute(t, name, () => ({ harnessEnv: { [name]: "x" } }));
assert.equal(refusedHarnessName(name), true, name);
}
// Names that are not one plain upper-case name: lower or mixed case, an equals sign, a NUL.
for (const name of ["lower", "Mosaic_policy_file", "mosaic_policy_file", "FAKE_OK=x", "A=B", "FAKE_OK\0", " FAKE_OK", "fake_ok"]) {
await refusedRoute(t, JSON.stringify(name), () => ({ harnessEnv: { [name]: "x" } }), (root) => ({ harnessModule: fakeModule([join(root, "install")], [...DECLARED, name]) }));
}
for (const name of [
"GIT_DIR", "BASH_FUNC_x%%", "LD_AUDIT", "SHELLOPTS", "PS4", "IFS", "HTTPS_PROXY", "NODE_EXTRA_CA_CERTS", "PYTHONHOME", "MOSAIC_X", "GCONV_PATH",
"LOCPATH", "MALLOC_CHECK_", "OPENSSL_CONF", "SSL_CERT_FILE", "ZDOTDIR", "PROMPT_COMMAND", "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "NPM_CONFIG_PREFIX",
"CLAUDE_CONFIG_DIR", "XDG_DATA_HOME", "ANY_CONF", "ANY_CONFIG", "PERLLIB", "LESSOPEN", "LESSCLOSE", "HOSTALIASES",
"SSH_ASKPASS", "SUDO_ASKPASS", "CURL_CA_BUNDLE", "REQUESTS_CA_BUNDLE", "OPENAI_BASE_URL", "ANY_BASE_URL",
]) assert.equal(refusedHarnessName(name), true, name);
for (const name of ["FAKE_OK", "PI_MODEL", "TRIAGE_PROBE"]) assert.equal(refusedHarnessName(name), false, name);
});
test("fence 1: values are strings of at most 4096 characters with no control character or line separator, and at most 64 names", async (t) => {
for (const [label, v] of [
["newline", "x\ny"], ["nul", "x\0"], ["cr", "x\ry"], ["tab", "x\ty"], ["escape", "x\u001by"], ["del", "x\u007f"], ["c1 next line", "x\u0085y"],
["line separator", "x\u2028y"], ["paragraph separator", "x\u2029y"], ["4097", "a".repeat(4097)], ["number", 5], ["null", null], ["object", {}], ["array", ["x"]],
]) {
await refusedRoute(t, label, () => ({ harnessEnv: { FAKE_OK: v } }));
}
const many = Object.fromEntries(Array.from({ length: 65 }, (_, i) => [`FAKE_N${i}`, "x"]));
await refusedRoute(t, "65 names", () => ({ harnessEnv: many }), (root) => ({ harnessModule: fakeModule([join(root, "install")], Object.keys(many)) }));
await admittedRoute(t, "64 names", () => ({ harnessEnv: Object.fromEntries(Object.entries(many).slice(0, 64)) }), (root) => ({ harnessModule: fakeModule([join(root, "install")], Object.keys(many)) }));
await refusedRoute(t, "array harnessEnv", () => ({ harnessEnv: ["FAKE_OK"] }));
await refusedRoute(t, "no harnessEnv", () => ({ harnessEnv: undefined }));
const s = await admittedRoute(t, "4096", () => ({ harnessEnv: { FAKE_OK: "a".repeat(4096), FAKE_TWO: "" } }));
assert.deepEqual(Object.keys(s.harnessEnv), ["FAKE_OK", "FAKE_TWO"]);
});
test("fence 1: a name the harness module does not declare is refused; a declared one reaches the session's bundle", async (t) => {
await refusedRoute(t, "undeclared", () => ({ harnessEnv: { FAKE_UNDECLARED: "x" } }));
await refusedRoute(t, "no such module", () => ({ harness: "nope" }));
await refusedRoute(t, "module without envNames", () => ({}), (root) => ({ harnessModule: async () => ({ installRoots: () => [join(root, "install")] }) }));
await refusedRoute(t, "module without installRoots", () => ({}), { harnessModule: async () => ({ envNames: DECLARED }) });
await refusedRoute(t, "module that throws", () => ({}), { harnessModule: async () => { throw new Error("x"); } });
await refusedRoute(t, "installRoots that throws", () => ({}), { harnessModule: async () => ({ envNames: DECLARED, installRoots: () => { throw new Error("x"); } }) });
const s = await admittedRoute(t, "declared", () => ({ harnessEnv: { FAKE_OK: "yes" } }));
assert.deepEqual(s.harnessEnv, { FAKE_OK: "yes" });
});
test("fence 1: the bundle holds the copy the host checked; no MOSAIC_ name reaches session.json, even from a getter", async (t) => {
let reads = 0;
const s = await admittedRoute(t, "getter", (root) => () => {
const a = answer(root);
delete a.harnessEnv;
Object.defineProperty(a, "harnessEnv", { enumerable: true, get: () => (reads++ === 0 ? { FAKE_OK: "checked" } : { MOSAIC_POLICY_FILE: "/evil", FAKE_OK: "swapped" }) });
return a;
});
assert.equal(reads, 1, "the answer is read once");
assert.deepEqual(s.harnessEnv, { FAKE_OK: "checked" });
assert.ok(!Object.keys(s.harnessEnv).some((k) => k.startsWith("MOSAIC_")));
// An answer that cannot be copied (a function in it) is refused.
await refusedRoute(t, "function", (root) => ({ harnessEnv: { FAKE_OK: "x" }, extra: () => 1 }));
});
test("fence 2: route env holds only the proxy's two names, the base URL is http on 127.0.0.1 with a port, and the host's port and token shape hold when given", async (t) => {
const bad = [
undefined, "", "http://localhost:9", "http://[::1]:9", "https://127.0.0.1:9", "http://127.0.0.1", "http://127.0.0.1:", "http://127.0.0.1:9/",
"http://127.0.0.1:9/v1", "http://127.0.0.1:09", "http://127.0.0.1:0", "http://127.0.0.1:65536", "http://127.0.0.1:99999", "http://127.0.0.2:9",
"http://[email protected]:9", "HTTP://127.0.0.1:9", "http://127.0.0.1:9\n", "http://127.0.0.1:9 ", "http://127.1:9", "http://2130706433:9",
"http://127.0.0.1:9#x", "http://127.0.0.1:9?x", "http://10.0.0.1:9", 9,
];
for (const url of bad) await refusedRoute(t, `url ${JSON.stringify(url)}`, () => ({ env: url === undefined ? {} : { ANTHROPIC_BASE_URL: url } }));
for (const extra of ["OTHER", "MOSAIC_CONFIG", "ANTHROPIC_API_KEY", "PATH", "anthropic_base_url"]) {
await refusedRoute(t, `env ${extra}`, () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9", [extra]: "x" } }));
}
for (const token of ["a\nb", "a\u2028b", "a\u0000b", "a\u007fb"]) await refusedRoute(t, `token ${JSON.stringify(token)}`, () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9", ANTHROPIC_AUTH_TOKEN: token } }));
await refusedRoute(t, "env array", () => ({ env: ["ANTHROPIC_BASE_URL"] }));
await admittedRoute(t, "port 65535", () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:65535" } }));
// The host's port.
await refusedRoute(t, "other port", () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9" } }), { proxyPort: 9001 });
await admittedRoute(t, "its port", () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9001" } }), { proxyPort: 9001 });
// The host's token shape: the whole token, never a part of it.
const tokenPattern = /mst-[0-9a-f]{8}/g;
for (const token of [undefined, "xmst-deadbeef", "mst-deadbeefx", "mst-DEADBEEF", "", "mst-deadbee"]) {
await refusedRoute(t, `token ${token}`, () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9", ...(token === undefined ? {} : { ANTHROPIC_AUTH_TOKEN: token }) } }), { tokenPattern });
}
await admittedRoute(t, "token", () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9", ANTHROPIC_AUTH_TOKEN: "mst-deadbeef" } }), { tokenPattern });
await admittedRoute(t, "token twice", () => ({ env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9", ANTHROPIC_AUTH_TOKEN: "mst-deadbeef" } }), { tokenPattern });
for (const p of [0, 65536, "9", 1.5]) assert.throws(() => createTriageHost({ dataRoot: "/x", proxyPort: p }), /proxyPort/);
assert.throws(() => createTriageHost({ dataRoot: "/x", tokenPattern: "mst-" }), /tokenPattern/);
});
test("fence 3: a mount source outside the install roots, through a link out of them, or in the data root, the config directory, HOME or a secrets path is refused", async (t) => {
const file = (p) => { mkdirSync(dirname(p), { recursive: true }); writeFileSync(p, "x"); return p; };
const mount = (src, extra = {}) => ({ harnessMounts: [{ src, why: "w", ...extra }] });
await refusedRoute(t, "outside", (root) => mount(file(join(root, "elsewhere", "f"))));
await refusedRoute(t, "link out", (root) => { file(join(root, "elsewhere", "f")); symlinkSync(join(root, "elsewhere", "f"), join(root, "install", "out")); return mount(join(root, "install", "out")); });
await refusedRoute(t, "dir link out", (root) => { file(join(root, "elsewhere", "f")); symlinkSync(join(root, "elsewhere"), join(root, "install", "d")); return mount(join(root, "install", "d", "f")); });
await refusedRoute(t, "dotdot", (root) => { file(join(root, "elsewhere", "f")); return mount(`${root}/install/../elsewhere/f`); });
await refusedRoute(t, "dotdot in root", (root) => { file(join(root, "install", "f")); return mount(`${root}/install/x/../f`); });
await refusedRoute(t, "trailing slash", (root) => { mkdirSync(join(root, "install", "d")); return mount(join(root, "install", "d") + "/"); });
await refusedRoute(t, "double slash", (root) => { file(join(root, "install", "f")); return mount(root + "//install/f"); });
await refusedRoute(t, "relative", () => mount("install/adapter.sh"));
await refusedRoute(t, "missing", (root) => mount(join(root, "install", "absent")));
await refusedRoute(t, "case", (root) => { file(join(root, "install", "f")); return mount(join(root, "INSTALL", "f")); });
// With the whole scratch root as the install root, only the protected-path fence stands.
const wide = (root) => ({ harnessModule: fakeModule([root]) });
await refusedRoute(t, "data root", (root) => mount(file(join(root, "data", "f"))), wide);
await refusedRoute(t, "parent of data root", (root) => { mkdirSync(join(root, "data"), { recursive: true }); return mount(join(root)); }, wide);
await refusedRoute(t, "alias of data root", (root) => { file(join(root, "data", "f")); symlinkSync(join(root, "data"), join(root, "alias")); return mount(join(root, "alias", "f")); }, wide);
await refusedRoute(t, "config dir", (root) => mount(file(join(root, "cfg", "f"))), (root) => ({ ...wide(root), env: { ...CONSOLE_ENV, MOSAIC_CONFIG: join(root, "cfg", "config.json") } }));
await refusedRoute(t, "home", (root) => mount(file(join(root, "h", "f"))), (root) => ({ ...wide(root), home: join(root, "h") }));
await refusedRoute(t, "parent of home", (root) => { file(join(root, "p", "h", "f")); return mount(join(root, "p")); }, (root) => ({ ...wide(root), home: join(root, "p", "h") }));
for (const seg of ["secrets", "Secrets", "SECRET", "my-secret-store"]) {
await refusedRoute(t, seg, (root) => mount(file(join(root, "install", seg, "token"))));
}
await refusedRoute(t, "link into secrets", (root) => { file(join(root, "install", "secrets", "token")); symlinkSync(join(root, "install", "secrets", "token"), join(root, "install", "t")); return mount(join(root, "install", "t")); });
await refusedRoute(t, "9 mounts", (root) => ({ harnessMounts: Array.from({ length: 9 }, (_, i) => ({ src: file(join(root, "install", `m${i}`)), dest: `/opt/m${i}`, why: "w" })) }));
await refusedRoute(t, "mounts not a list", (root) => ({ harnessMounts: { src: file(join(root, "install", "f")) } }));
await refusedRoute(t, "extra key", (root) => mount(file(join(root, "install", "f")), { mode: "rw" }));
await refusedRoute(t, "no why", (root) => ({ harnessMounts: [{ src: file(join(root, "install", "f")) }] }));
await refusedRoute(t, "string mount", (root) => ({ harnessMounts: [file(join(root, "install", "f"))] }));
await refusedRoute(t, "install root is /", () => ({}), { harnessModule: fakeModule(["/"]) });
await refusedRoute(t, "install root not a list", (root) => ({}), (root) => ({ harnessModule: fakeModule(join(root, "install")) }));
await refusedRoute(t, "no install roots", () => ({}), { harnessModule: fakeModule([]) });
await admittedRoute(t, "8 mounts", (root) => ({ harnessMounts: Array.from({ length: 8 }, (_, i) => ({ src: file(join(root, "install", `m${i}`)), dest: `/opt/m${i}`, why: "w" })) }));
});
test("fence 3: a mount dest that is or holds /tmp, the run directory, the relay socket, the bundle, session.json, the health dest, a system bind or a runner file is refused", async (t) => {
const withDest = (dest) => (root) => {
writeFileSync(join(root, "install", "f"), "x");
return { harnessMounts: [{ src: join(root, "install", "f"), dest: typeof dest === "function" ? dest(root) : dest, why: "w" }] };
};
const run = (root, ...p) => join(root, "data", "triage", "agent", ...p);
const dests = [
["/tmp", "/tmp"], ["under /tmp", "/tmp/x"], ["/tmp/", "/tmp/"], ["root", "/"], ["/usr/bin/sh", "/usr/bin/sh"], ["/usr", "/usr"], ["/etc", "/etc"],
["/etc/hosts", "/etc/hosts"], ["relative", "opt/x"], ["dotdot", "/opt/../tmp"], ["empty", ""], ["number", 5],
["run dir", (r) => run(r)], ["in run dir", (r) => run(r, "x")], ["relay", (r) => run(r, "relay.sock")], ["bundle", (r) => run(r, "bundle")],
["session.json", (r) => run(r, "session.json")], ["health dest", (r) => run(r, "work", "health")], ["parent of run dir", (r) => dirname(run(r))],
["parent of data root", (r) => r], ["runner file", RUNNER_FILES[0]], ["holds runner files", join(REPO, "packages")], ["repo", REPO],
["node", process.execPath], ["holds node", dirname(process.execPath)], ["adapter", (r) => join(r, "install", "adapter.sh")],
["holds adapter", (r) => join(r, "install")],
];
for (const [label, dest] of dests) await refusedRoute(t, `dest ${label}`, withDest(dest));
await refusedRoute(t, "same dest twice", (root) => {
writeFileSync(join(root, "install", "f"), "x");
writeFileSync(join(root, "install", "g"), "x");
return { harnessMounts: [{ src: join(root, "install", "f"), dest: "/opt/x", why: "w" }, { src: join(root, "install", "g"), dest: "/opt/x", why: "w" }] };
});
for (const [label, a, b] of [["nested dest", "/opt/x", "/opt/x/f"], ["parent dest", "/opt/x/f", "/opt/x"]]) {
await refusedRoute(t, label, (root) => {
writeFileSync(join(root, "install", "f"), "x");
writeFileSync(join(root, "install", "g"), "x");
return { harnessMounts: [{ src: join(root, "install", "f"), dest: a, why: "w" }, { src: join(root, "install", "g"), dest: b, why: "w" }] };
});
}
await admittedRoute(t, "dest /opt/x", withDest("/opt/x"));
});
test("fence 3: the adapter takes the same checks: inside an install root, a file, not through a link out, not in a protected path", async (t) => {
await refusedRoute(t, "outside", (root) => { writeFileSync(join(root, "a.sh"), "exit 0\n"); return { adapter: join(root, "a.sh") }; });
await refusedRoute(t, "link out", (root) => { writeFileSync(join(root, "a.sh"), "exit 0\n"); symlinkSync(join(root, "a.sh"), join(root, "install", "a.sh")); return { adapter: join(root, "install", "a.sh") }; });
await refusedRoute(t, "directory", (root) => { mkdirSync(join(root, "install", "d")); return { adapter: join(root, "install", "d") }; });
await refusedRoute(t, "relative", () => ({ adapter: "install/adapter.sh" }));
await refusedRoute(t, "dotdot", (root) => ({ adapter: `${root}/install/../install/adapter.sh` }));
await refusedRoute(t, "missing", (root) => ({ adapter: join(root, "install", "absent.sh") }));
await refusedRoute(t, "secrets", (root) => { mkdirSync(join(root, "install", "secrets")); writeFileSync(join(root, "install", "secrets", "a.sh"), "x"); return { adapter: join(root, "install", "secrets", "a.sh") }; });
await refusedRoute(t, "data root", (root) => { mkdirSync(join(root, "data"), { recursive: true }); writeFileSync(join(root, "data", "a.sh"), "x"); return { adapter: join(root, "data", "a.sh") }; }, (root) => ({ harnessModule: fakeModule([root]) }));
await refusedRoute(t, "not a string", () => ({ adapter: 5 }));
// A link that stays inside the root is followed: the bind's source is the file itself.
await admittedRoute(t, "link inside", (root) => { writeFileSync(join(root, "install", "real.sh"), "exit 0\n"); symlinkSync(join(root, "install", "real.sh"), join(root, "install", "a.sh")); return { adapter: join(root, "install", "a.sh") }; });
});
test("the shipped harness modules declare what their own env() and mounts() hand a session, and their adapter and mounts pass the host's checks", async () => {
const dir = scratch();
for (const name of ["pi", "claude-code"]) {
const mod = await import(new URL(`../../plugins/harness/${name}/index.mjs`, import.meta.url).href);
assert.ok(Array.isArray(mod.envNames) && Object.isFrozen(mod.envNames), name);
const keys = Object.keys(mod.env({
files: { settings: "/s", mcp: "/m" }, policy: { tools: ["read"] }, tools: [], session: { model: "m", thinking: "off", provider: "p" },
}));
assert.deepEqual(keys.filter((k) => !isProviderVariable(k)).sort(), [...mod.envNames].sort(), name);
const roots = mod.installRoots({ env: {} });
const route = { adapter: mod.adapter(), harnessMounts: mod.mounts({ env: {} }), installRoots: roots, runDir: join(dir, "data", "triage", "agent") };
const got = checkHostedRoute({ ...route, protectedPaths: [join(dir, "data"), join(dir, "cfg"), join(dir, "home")] });
assert.equal(got.adapter.dest, mod.adapter(), name);
// A stack that runs from under HOME (a copy or a worktree): HOME holds the repository, and the
// code root keeps HOME from refusing the stack's own files. Without it, HOME refuses them.
const underHome = { ...route, protectedPaths: [join(dir, "data"), join(dir, "cfg"), dirname(REPO)] };
assert.equal(checkHostedRoute({ ...underHome, codeRoot: REPO, codeHolder: dirname(REPO) }).adapter.dest, mod.adapter(), name);
assert.throws(() => checkHostedRoute(underHome), (e) => e.fence === "adapter", name);
}
});
test("a host whose HOME holds the repository starts the shipped pi harness's own route; a source under HOME outside the repository is still refused", async (t) => {
const pi = await import(new URL("../../plugins/harness/pi/index.mjs", import.meta.url).href);
const home = dirname(REPO);
const opts = { home, harnessModule: async (name) => (name === "pi" ? pi : null) };
const piRoute = (root) => answer(root, { harness: "pi", adapter: pi.adapter(), harnessMounts: pi.mounts({ env: {} }), harnessEnv: { PI_MODEL: "m", PI_OFFLINE: "1" } });
const s = await admittedRoute(t, "pi under HOME", (root) => () => piRoute(root), opts);
assert.equal(s.adapter, pi.adapter());
assert.deepEqual(s.harnessEnv, { PI_MODEL: "m", PI_OFFLINE: "1" });
// The same host and module, with HOME's own directory (which holds the repository) as an extra
// install root and mount: it is under HOME and not in the code, so it is refused.
const wide = { ...pi, installRoots: (o) => [...pi.installRoots(o), home] };
const logs = await refusedRoute(t, "under HOME, outside the repository", (root) => () => ({ ...piRoute(root), harnessMounts: [...pi.mounts({ env: {} }), { src: home, dest: "/opt/home", why: "w" }] }), { home, harnessModule: async (name) => (name === "pi" ? wide : null) });
assert.ok(logs.includes("triage host: route refused: mount-src"), logs.join(" | "));
});
test("a route that changes after the first check is refused at the binds: nothing spawns, what the start wrote is removed, and the next message starts", async (t) => {
const root = scratch();
mkdirSync(join(root, "install"), { recursive: true });
writeFileSync(join(root, "outside.sh"), "exit 0\n");
const logs = [];
let checked = false;
let swapped = false;
const harnessModule = async (name) => (name === "fake" ? { envNames: DECLARED, installRoots: () => { checked = true; return [join(root, "install")]; } } : null);
// The run id in session.json reads the clock after the first check: the adapter becomes a link
// out of the install root then, so only hostedBinds' own check can see it.
const now = () => {
if (checked && !swapped) {
swapped = true;
rmSync(join(root, "install", "adapter.sh"));
symlinkSync(join(root, "outside.sh"), join(root, "install", "adapter.sh"));
}
return new Date("2026-11-16T12:00:00.000Z");
};
const route = { admit: async () => answer(root) };
const { h, dataRoot } = host(t, root, { route, bwrap: spy(root), log: (l) => logs.push(l), harnessModule, now });
const agent = join(dataRoot, "triage", "agent");
await assert.rejects(h.message("hello"), (e) => e.code === "triage-route-invalid" && e.message === "the model route's answer is not usable");
assert.ok(swapped, "the swap happened between the checks");
assert.ok(logs.includes("triage host: route refused at the binds: adapter"), logs.join(" | "));
assert.equal(existsSync(join(root, "spawned")), false);
assert.equal(h.running, false);
for (const f of ["session.json", "relay.sock", "bundle"]) assert.equal(existsSync(join(agent, f)), false, f);
const [owner, note, ...rest] = (await h.state()).transcript;
assert.deepEqual([owner.from, note.from, note.in_reply_to, note.text, rest.length], ["owner", "host", owner.id, ROUTE_REFUSED, 0]);
rmSync(join(root, "install", "adapter.sh"));
writeFileSync(join(root, "install", "adapter.sh"), "exit 0\n");
await h.message("again");
await waitFor(() => existsSync(join(root, "spawned")));
});
test("a read and a message that arrive together share one snapshot read", async (t) => {
@@ -211,7 +496,8 @@ test("end to end under the sandbox: the first message starts the session, which
// 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");
mkdirSync(join(root, "install"));
const adapter = join(root, "install", "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"),
@@ -219,7 +505,7 @@ test("end to end under the sandbox: the first message starts the session, which
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 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" } }; } };
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);
@@ -280,9 +566,10 @@ test("end to end under the sandbox: the first message starts the session, which
// A route answer that runs the stub adapter under the sandbox.
function stubRoute(root) {
const adapter = join(root, "adapter.sh");
mkdirSync(join(root, "install"), { recursive: true });
const adapter = join(root, "install", "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: {} }) };
return { admit: async () => ({ ok: true, adapter, harness: "fake", harnessEnv: {}, harnessMounts: [], turnEnd: "exit", model: "stub", provider: "stub", env: { ANTHROPIC_BASE_URL: "http://127.0.0.1:9" } }) };
}
const repliesOf = (h, n, from = "triage") => waitFor(async () => {
const list = (await h.state()).transcript.filter((e) => e.from === from);
@@ -326,9 +613,7 @@ test("a session that ends mid-turn: the message it took is answered by the host,
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 route = { admit: async () => answer(root) };
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);
@@ -87,7 +87,7 @@ function organizations(reads, st) {
const workflowsRead = async () => {
reads.push(id);
if (st.failRead) throw Object.assign(new Error('org-unavailable'), { code: 'org-unavailable' });
const answer = { revision: st.revs[id], document: structuredClone(st.docs[id] ?? {}), templates: ['writer'] };
const answer = { revision: st.revs[id], document: structuredClone(st.docs[id] ?? {}), templates: ['writer', 'triage'] };
const h = st.held.read; if (h) { st.held.read = null; await h; }
return answer;
};
@@ -976,6 +976,46 @@ test('SP17: while a Save is in flight the form takes no typing, and takes it aga
assert.equal(await b.evaluate(`document.querySelector('${form} input[name="title"]').value`), 'Ship again');
});
// #1873 triage-drawer item 6: the Triage template is system-only. The picker never offers it, and a step
// that names it is marked and named by the save check, as any role the organization cannot hold.
test('the step picker does not offer the triage template, and a step naming it is marked and refused before the bus', { timeout: 60000 }, async t => {
const { b, wait, st } = await setup(t, { path: '#/orgs/acme/workflows/change?step=1' });
await wait(`!!document.querySelector('${form}')`, 'step 1 form');
assert.equal(await b.evaluate(`document.querySelector('${form} input[name="role"][value="triage"]')`), null, 'not in the edit form');
await b.evaluate(press('[data-wfg-add]'));
await wait(`!!document.querySelector('[data-wfg-add-form]')`, 'add form');
assert.equal(await b.evaluate(`document.querySelector('[data-wfg-add-form] input[name="role"][value="triage"]')`), null, 'not in the add form');
assert.doesNotMatch(await b.evaluate(text('[data-wfg-add-form] [data-wfg-roles-pick]')), /triage/);
await b.evaluate(press('[data-wfg-add-form] [data-wfg-cancel]'));
st.change('acme', doc => { doc.workflows.sorted = { steps: [{ title: 'Sort', state: 'todo', roles: ['triage'] }] }; });
await b.evaluate(`location.hash = '#/orgs/acme/workflows/sorted?step=1'`);
await wait(`!!document.querySelector('${form}') && document.querySelectorAll('[data-wfg-graph] [data-wfg-missing]').length === 1`, 'triage marked in the graph');
assert.match(await b.evaluate(text(`${form} [data-wfg-roles-pick]`)), /triage names no current role/);
await b.evaluate(fill(`${form} input[name="title"]`, 'Sort it'));
await b.evaluate(press('[data-wfg-save]'));
await wait(`/Step 1: triage names no current role/.test(${text('[data-wfg-status]')})`, 'refused on the page');
assert.equal(st.writes.length, 0, 'nothing sent');
});
// #1873 triage-drawer item 6: an add form in which only the state was changed is not closed without a word.
test('Save with only the state changed in the add form says so and keeps the form', { timeout: 60000 }, async t => {
const { b, wait, st } = await setup(t, { path: '#/orgs/acme/workflows/change?project=site&step=1' });
await retitle(b, wait, 1, 'Build it');
await b.evaluate(press('[data-wfg-add]'));
await wait(`!!document.querySelector('[data-wfg-add-form]')`, 'add form');
await b.evaluate(`(()=>{const e=document.querySelector('[data-wfg-add-form] select[name="state"]');e.value='in-review';e.dispatchEvent(new Event('input',{bubbles:true}));return true})()`);
await b.evaluate(press('[data-wfg-bar] [data-wfg-save]'));
await wait(`/new step 2 is not added yet/.test(${text('[data-wfg-bar] [data-wfg-status]')})`, 'said in words');
assert.equal(st.writes.length, 0, 'nothing written');
assert.equal(await b.evaluate(`document.querySelector('[data-wfg-add-form] select[name="state"]')?.value`), 'in-review', 'the form is kept as set');
// Cancel drops it; Save then saves the rest.
await b.evaluate(press('[data-wfg-add-form] [data-wfg-cancel]'));
await wait(`!document.querySelector('[data-wfg-add-form]')`, 'add form closed');
await b.evaluate(press('[data-wfg-save]'));
await wait(`/Saved change\\./.test(${text('[data-wfg-status]')})`, 'saved');
assert.deepEqual(st.writes.at(-1).args.workflow.steps.map(s => s.title), ['Build it', 'Ship']);
});
// SP17 review 2 P2-1: a new step typed in the add form is not dropped by the bar's Save: Save says it is not
// added yet and keeps the form; once added, Save sends it.
test('SP17: the bar Save with a new step typed in the add form says so and keeps it, and saves it once added', { timeout: 60000 }, async t => {