<dataRoot>/triage/route.json holds Triage's model route and daily cap as names only: a catalogue model key, a harness name and a daily-quota cap leaf, with no env value and no key. The directory is 0700 and the file 0600, owned by the running user; a link, a hard link, a non-file, a wrong mode or owner, an unknown field or an unknown time zone refuses. A write is compare-and-set on revision under an exclusive lock, atomic (temp file, fsync, rename, directory fsync), and appends one receipt line. The reset is 00:00 in a zone the owner gives, with no default. The file location, field names and reset rule each live in one place. mosaic triage route show|set are human verbs and refuse an agent run before any read. Nothing is wired into the Triage host: the Console keeps route: null. Held for Jason's ruling on the design's four questions (#1873, lane triage-route-store).
150 lines
7.4 KiB
JavaScript
150 lines
7.4 KiB
JavaScript
// #1873 triage-route-store: `mosaic triage route show|set`, the owner's terminal verbs for the
|
|
// Triage route file (packages/webui/src/triage-route-store.mjs). Human verbs: an agent run is
|
|
// refused before anything is read (exit 3), as the other human verbs refuse it. `show` with no
|
|
// file says the route is not set and exits 0.
|
|
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { spawnSync } from "node:child_process";
|
|
import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { run } from "../src/cli.mjs";
|
|
import { AGENT_MARKERS } from "../src/transport.mjs";
|
|
import { routePaths } from "../../webui/src/triage-route-store.mjs";
|
|
import { humanEnv, io } from "./helpers.mjs";
|
|
|
|
const REPO = new URL("../../../", import.meta.url).pathname;
|
|
const MOSAIC = join(REPO, "scripts/mosaic");
|
|
const NOW = new Date("2026-11-18T12:00:00.000Z");
|
|
const SET = ["triage", "route", "set", "--model", "glm-5", "--harness", "claude-code", "--cap", "200000", "--time-zone", "America/Chicago"];
|
|
|
|
function dataRoot(t) {
|
|
const d = mkdtempSync(join(tmpdir(), "tr-"));
|
|
t.after(() => rmSync(d, { recursive: true, force: true }));
|
|
return d;
|
|
}
|
|
async function cli(argv, d, env = humanEnv()) {
|
|
const s = io(env);
|
|
const code = await run(argv, s, { system: { dataRoot: d }, now: () => NOW });
|
|
return { code, stdout: s.out.text, stderr: s.err.text };
|
|
}
|
|
|
|
test("show with no route says it is not set and exits 0", async (t) => {
|
|
const d = dataRoot(t);
|
|
assert.deepEqual(await cli(["triage", "route", "show"], d), { code: 0, stdout: "triage route: not set\n", stderr: "" });
|
|
assert.equal(existsSync(routePaths(d).dir), false);
|
|
});
|
|
|
|
test("set writes the route; show reads it back", async (t) => {
|
|
const d = dataRoot(t);
|
|
const set = await cli(SET, d);
|
|
assert.equal(set.code, 0, set.stderr);
|
|
assert.equal(set.stdout, "triage route set: revision 1\n");
|
|
const shown = await cli(["triage", "route", "show"], d);
|
|
assert.equal(shown.code, 0);
|
|
assert.equal(shown.stdout, [
|
|
"triage route: revision 1",
|
|
"model: glm-5",
|
|
"harness: claude-code",
|
|
"cap: 200000 tokens a day, resets 00:00 America/Chicago, counted since 2026-11-18T12:00:00.000Z",
|
|
"updated: 2026-11-18T12:00:00.000Z by owner",
|
|
"",
|
|
].join("\n"));
|
|
const doc = JSON.parse(readFileSync(routePaths(d).file, "utf8"));
|
|
assert.equal(doc.updatedBy, "owner");
|
|
// --revision makes the write conditional on what show printed.
|
|
const five = ["triage", "route", "set", "--model", "glm-5", "--harness", "claude-code", "--cap", "5", "--time-zone", "America/Chicago", "--revision", "1"];
|
|
assert.equal((await cli(five, d)).code, 0);
|
|
assert.equal(JSON.parse(readFileSync(routePaths(d).file, "utf8")).cap.limit, 5);
|
|
const stale = await cli([...SET, "--revision", "1"], d);
|
|
assert.equal(stale.code, 3);
|
|
assert.match(stale.stderr, /^mosaic: triage-route-stale: /);
|
|
});
|
|
|
|
test("refused input exits 2 or 4 and writes nothing", async (t) => {
|
|
const d = dataRoot(t);
|
|
const without = (flag) => { const a = [...SET]; const i = a.indexOf(flag); a.splice(i, 2); return a; };
|
|
const swap = (flag, value) => { const a = [...SET]; a[a.indexOf(flag) + 1] = value; return a; };
|
|
const cases = [
|
|
[without("--model"), 4], [without("--harness"), 4], [without("--cap"), 4], [without("--time-zone"), 4],
|
|
[swap("--cap", "-1"), 2], [swap("--cap", "1e3"), 2], [swap("--cap", "01"), 2], [swap("--cap", "9007199254740993"), 2],
|
|
[swap("--time-zone", "Atlantis/Lost"), 2], [swap("--model", "Has Space"), 2],
|
|
[swap("--harness", "nonesuch"), 2], [swap("--harness", "../pi"), 2],
|
|
[[...SET, "--revision", "x"], 2], [[...SET, "--revision", "-1"], 2],
|
|
[[...SET, "--cap", "5"], 4], [[...SET, "--unknown", "1"], 4], [[...SET, "extra"], 4],
|
|
[["triage", "route", "show", "--model", "x"], 4], [["triage", "route", "show", "extra"], 4],
|
|
[["triage", "route"], 4], [["triage", "route", "remove"], 4], [["triage"], 4], [["triage", "key"], 4],
|
|
];
|
|
for (const [argv, want] of cases) {
|
|
const r = await cli(argv, d);
|
|
assert.equal(r.code, want, `${argv.join(" ")}: ${r.stderr}`);
|
|
assert.equal(r.stdout, "");
|
|
}
|
|
// An unknown option is named as one, and its value never reaches the message.
|
|
const unknown = await cli([...SET, "--unknown", "secret-value"], d);
|
|
assert.equal(unknown.code, 4);
|
|
assert.match(unknown.stderr, /^mosaic: unknown option\n/);
|
|
assert.doesNotMatch(unknown.stderr, /secret-value/);
|
|
assert.equal(existsSync(routePaths(d).file), false);
|
|
});
|
|
|
|
test("an unreadable store exits 3 on show and on set", async (t) => {
|
|
const d = dataRoot(t);
|
|
assert.equal((await cli(SET, d)).code, 0);
|
|
chmodSync(routePaths(d).file, 0o644);
|
|
for (const argv of [["triage", "route", "show"], [...SET, "--revision", "1"]]) {
|
|
const r = await cli(argv, d);
|
|
assert.equal(r.code, 3);
|
|
assert.match(r.stderr, /^mosaic: triage-route-unreadable: the Triage route store is unreadable: route\.json mode is not 0600\n$/);
|
|
}
|
|
});
|
|
|
|
test("an agent caller is refused before anything is read, for show and set", async (t) => {
|
|
const d = dataRoot(t);
|
|
for (const marker of AGENT_MARKERS) {
|
|
for (const argv of [["triage", "route", "show"], SET]) {
|
|
const r = await cli(argv, d, { ...humanEnv(), [marker]: "1" });
|
|
assert.equal(r.code, 3, marker);
|
|
assert.equal(r.stderr, `mosaic: refused: this runs only from a human shell, outside any agent run (found ${marker} in the environment)\n`);
|
|
}
|
|
}
|
|
assert.equal(existsSync(routePaths(d).dir), false);
|
|
});
|
|
|
|
test("scripts/mosaic routes triage to the verb; a marker in the process env refuses", (t) => {
|
|
const home = mkdtempSync(join(tmpdir(), "trm-"));
|
|
t.after(() => rmSync(home, { recursive: true, force: true }));
|
|
const env = humanEnv({ HOME: home, MOSAIC_CONFIG: join(home, ".config/mosaic-trtest/config.json") });
|
|
const setup = spawnSync(join(REPO, "scripts/bootstrap.sh"), ["--instance", "trtest"], { env, encoding: "utf8" });
|
|
assert.equal(setup.status, 0, setup.stderr);
|
|
const mosaic = (args, extra = {}) => spawnSync(MOSAIC, args, { env: { ...env, ...extra }, encoding: "utf8", timeout: 60000 });
|
|
const shown = mosaic(["triage", "route", "show"]);
|
|
assert.equal(shown.status, 0, shown.stderr);
|
|
assert.equal(shown.stdout, "triage route: not set\n");
|
|
const set = mosaic(SET.slice(0));
|
|
assert.equal(set.status, 0, set.stderr);
|
|
assert.equal(set.stdout, "triage route set: revision 1\n");
|
|
const dataDir = join(home, ".mosaic-trtest");
|
|
assert.equal(JSON.parse(readFileSync(routePaths(dataDir).file, "utf8")).model, "glm-5");
|
|
const refused = mosaic(["triage", "route", "show"], { CLAUDECODE: "1" });
|
|
assert.equal(refused.status, 3);
|
|
assert.match(refused.stderr, /found CLAUDECODE in the environment/);
|
|
assert.equal(refused.stdout, "");
|
|
});
|
|
|
|
test("a marker in this process's own environment refuses even when the command's env is clean", async (t) => {
|
|
const d = dataRoot(t);
|
|
for (const marker of AGENT_MARKERS) {
|
|
const saved = process.env[marker];
|
|
process.env[marker] = "1";
|
|
try {
|
|
for (const argv of [["triage", "route", "show"], SET]) {
|
|
const r = await cli(argv, d, humanEnv());
|
|
assert.equal(r.code, 3, marker);
|
|
assert.match(r.stderr, new RegExp(`found ${marker} in the environment`));
|
|
}
|
|
} finally { if (saved === undefined) delete process.env[marker]; else process.env[marker] = saved; }
|
|
}
|
|
assert.equal(existsSync(routePaths(d).dir), false);
|
|
});
|