Compare commits
31
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
6ad11e6993 | ||
|
|
e52a6b714f | ||
|
|
2d065b936e | ||
|
|
098b3771c0 | ||
|
|
eac42663ba | ||
|
|
b41bc00b26 | ||
|
|
749d6d98f5 | ||
|
|
fa5ce3ae65 | ||
|
|
d009ccaec4 | ||
|
|
2613fb1c4c | ||
|
|
df26085303 | ||
|
|
7c1b87d154 | ||
|
|
8908df113e | ||
|
|
b8354e4304 | ||
|
|
f62b1b9518 | ||
|
|
7355b233a8 | ||
|
|
88d08c8437 | ||
|
|
4377941bd4 | ||
|
|
de39750ebb | ||
|
|
3b17326b74 | ||
|
|
d03ae494e8 | ||
|
|
e1b56d9ea7 | ||
|
|
e6f6f5445b | ||
|
|
55f9652f6a | ||
|
|
9e434c0e9c | ||
|
|
e732ae7450 | ||
|
|
66255c9bf2 | ||
|
|
cecc901854 | ||
|
|
81ca8399a2 | ||
|
|
37c3854849 | ||
|
|
db2dc96aa2 |
No files matched your search
+12
-4
@@ -1,6 +1,6 @@
|
||||
#!/bin/sh
|
||||
# Pi adapter: implements the Mosaic adapter contract for the pinned
|
||||
# @earendil-works/pi-coding-agent CLI.
|
||||
# Pi adapter: implements the Mosaic adapter contract for the
|
||||
# @earendil-works/pi-coding-agent CLI. Its behaviour notes are read from 0.85.1.
|
||||
#
|
||||
# Contract: see /opt/mosaic/adapters/README.md.
|
||||
# Headless (default): stdout = response only; stderr = diagnostics; exit 0.
|
||||
@@ -92,6 +92,11 @@ fi
|
||||
THINKING_FLAG=""
|
||||
[ -n "${MOSAIC_THINKING:-}" ] && THINKING_FLAG="--thinking $MOSAIC_THINKING"
|
||||
|
||||
# MCP (#1873 S3): the harness module sets MOSAIC_PI_NO_MCP=1 when the binary's --help lists
|
||||
# --no-mcp, so MCP stays off by its own flag and not only as a side effect of --no-extensions.
|
||||
NO_MCP_FLAG=""
|
||||
[ "${MOSAIC_PI_NO_MCP:-}" = "1" ] && NO_MCP_FLAG="--no-mcp"
|
||||
|
||||
# Mode (M13): interactive TUI or one-shot print.
|
||||
PRINT_MODE="-p"
|
||||
REQUEST_ARG=""
|
||||
@@ -107,6 +112,7 @@ fi
|
||||
# --system-prompt replace the default prompt with the generated one, given
|
||||
# as the file's absolute path (checked above), never its text
|
||||
# --no-* no ambient context/skills/extensions/templates/themes
|
||||
# NO_MCP_FLAG --no-mcp when the binary lists it, else nothing
|
||||
# EXT_FLAGS the explicitly provided extensions only (-e)
|
||||
# SESSION_FLAGS ephemeral | persistent | forked (per env)
|
||||
# TOOLS_FLAG per capabilities
|
||||
@@ -118,6 +124,7 @@ set -- \
|
||||
--offline \
|
||||
--no-approve \
|
||||
--no-extensions \
|
||||
$NO_MCP_FLAG \
|
||||
$EXT_FLAGS \
|
||||
$SKILLS_FLAG \
|
||||
--no-prompt-templates \
|
||||
@@ -134,6 +141,7 @@ set -- \
|
||||
[ "$INTERACTIVE" = "1" ] || set -- "$@" -p "$MOSAIC_REQUEST"
|
||||
if [ -n "${MOSAIC_MODEL_EVENT_MONITOR:-}" ] && [ "$INTERACTIVE" != "1" ]; then
|
||||
STREAM="$(dirname "$0")/../../packages/plugins/harness/pi/model-stream.mjs"
|
||||
exec node "$STREAM" pi "$MOSAIC_FIRST_OUTPUT_DIR" pi "$@" --mode json
|
||||
exec node "$STREAM" pi "$MOSAIC_FIRST_OUTPUT_DIR" "${MOSAIC_PI_BIN:-pi}" "$@" --mode json
|
||||
fi
|
||||
exec pi "$@"
|
||||
# #1873 S2: the binary the harness module found (MOSAIC_PI_BIN, its path inside the sandbox).
|
||||
exec "${MOSAIC_PI_BIN:-pi}" "$@"
|
||||
@@ -6,6 +6,7 @@ import { join } from 'node:path';
|
||||
import { sandboxProblem } from '../../seat/src/sandbox.mjs';
|
||||
import { startTimeOf } from '../../seat/src/proc.mjs';
|
||||
import { ownershipFixture, waitFor } from './model-hire-ownership-fixture.mjs';
|
||||
import * as pi from '../../plugins/harness/pi/index.mjs';
|
||||
const unavailable=sandboxProblem()??false; // Any skip means UNVERIFIED, not green acceptance.
|
||||
const done=async box=>{await box.promise;return box;};
|
||||
const refused=async(box,code)=>{await done(box);assert.equal(box.ok,false,'real operation refuses');assert.equal(box.code,code,'real operation preserves exact refusal');};
|
||||
@@ -17,7 +18,12 @@ test('655 listed duplicate with no record refuses before any model or management
|
||||
assert.deepEqual(f.snapshot(),before,'duplicate hire makes no credential or management effects');f.assertHistoryGuard();f.valueFree();
|
||||
});
|
||||
|
||||
test('655 actual launch own preflight generation and bound consumer survive concurrent duplicate hire',{skip:unavailable,timeout:30000},async t=>{
|
||||
test('655 actual launch own preflight generation and bound consumer survive concurrent duplicate hire',{skip:unavailable,timeout:120000},async t=>{
|
||||
// #1873 pi-unpin re-check 9 and 10: the launch's preflight shares pi's fit check, which is cold in
|
||||
// a fresh process. Wait for it before the fixture starts its launcher, so the launcher's warm-up
|
||||
// and the launch's preflight hit the cache, the gate's 5 s times the launch, and the launch starts
|
||||
// at the same point in the launcher's 2 s tick as it did before the fit check existed.
|
||||
await pi.ready({env:{PATH:process.env.PATH,HOME:process.env.HOME,TMPDIR:process.env.TMPDIR}});
|
||||
const f=await ownershipFixture(t),pGet=f.hold('GET'),p=f.launchAide();await pGet.entered();
|
||||
// P's own acquisition GET is held. Its PUT confirmation GET is ordinal+1;
|
||||
// only an OLD H reuse GET can be ordinal+2. The correct early refusal removes it.
|
||||
|
||||
@@ -215,12 +215,19 @@ const relayed = (failed) => failed && (typeof failed.message === "string" ? { ..
|
||||
// and names the module rather than escaping the host. What it threw is named by its system code
|
||||
// or its class, never its message, which the host didn't write (#1873).
|
||||
function call(name, what, fn) {
|
||||
try {
|
||||
return fn();
|
||||
} catch (e) {
|
||||
const failed = (e) => {
|
||||
const thrown = quietMessage(e, "a host file") ?? `threw ${/^[A-Za-z][A-Za-z0-9]{0,39}$/.test(String(e?.name)) ? e.name : "a value"} without a system code`;
|
||||
throw new Refusal("harness-failed", `harness ${name} ${what}: ${thrown}`);
|
||||
};
|
||||
let out;
|
||||
try {
|
||||
out = fn();
|
||||
} catch (e) {
|
||||
failed(e);
|
||||
}
|
||||
// #1873 pi-unpin re-check 7: a module may answer with a promise (pi's preflight runs its fit
|
||||
// check as child processes). The caller awaits it; a rejection is refused as a throw is.
|
||||
return typeof out?.then === "function" ? Promise.resolve(out).then(undefined, failed) : out;
|
||||
}
|
||||
|
||||
// host: startHost()'s handle. tracker: true when the broker has task verbs for
|
||||
@@ -454,14 +461,11 @@ export function createLauncher({
|
||||
for (const m of [primary, fallback].filter(Boolean)) {
|
||||
if (!on.includes(m.harness)) throw new Refusal("harness-off", `harness ${m.harness} isn't switched on in plugins.harness`);
|
||||
}
|
||||
// One harness through a fresh loader, so a refusal never leaves an earlier load's module in use.
|
||||
const harnessOf = async (m) => {
|
||||
const loader = makeLoader({ dataRoot:system.instanceRoot ?? dataRoot, log: (entry) => record({ ...entry, instance }) });
|
||||
const { refused } = await loader.load({ harness: [m.harness] });
|
||||
const { refused, module } = await freshHarness(m, (entry) => record({ ...entry, instance }));
|
||||
// #1873: a loader message can quote the module's path or its load error; only a
|
||||
// missing-export one, which names the export, is relayed. Any other refusal names its code.
|
||||
if (refused.length) throw new Refusal("harness-refused", `harness ${m.harness}: ${refused.map((r) => r.code === "missing-export" ? `${r.code}: ${relay(r.message)}` : String(r.code)).join("; ")}`);
|
||||
const module = loader.modules("harness")[0];
|
||||
const levels = call(m.harness, "levels", () => module.levels());
|
||||
if (!levels.includes(m.thinking)) throw new Refusal("thinking-unsupported", `harness ${m.harness} takes thinking ${levels.join(", ")}, not ${m.thinking}`);
|
||||
return module;
|
||||
@@ -556,7 +560,7 @@ export function createLauncher({
|
||||
const pickRoute = async (proxyOf) => {
|
||||
let sessionProxy = await proxyOf(primary);
|
||||
// #1873: a preflight's message is the module's own text, relayed with host paths replaced.
|
||||
const failed = relayed(call(primary.harness, "preflight", () => harness.preflight({ env: sessionProxy ? sessionEnv(env, "preflight", sessionProxy) : env, proxy: sessionProxy })));
|
||||
const failed = relayed(await call(primary.harness, "preflight", () => harness.preflight({ env: sessionProxy ? sessionEnv(env, "preflight", sessionProxy) : env, proxy: sessionProxy })));
|
||||
if (failed) {
|
||||
if (!fallback) throw new Refusal(failed.code, failed.message);
|
||||
// The fallback only on a failed primary preflight, and only at launch (row 65). Any refusal of
|
||||
@@ -566,7 +570,7 @@ export function createLauncher({
|
||||
throw e;
|
||||
});
|
||||
sessionProxy = await proxyOf(fallback);
|
||||
const also = relayed(call(fallback.harness, "preflight", () => second.preflight({ env: sessionProxy ? sessionEnv(env, "preflight", sessionProxy) : env, proxy: sessionProxy })));
|
||||
const also = relayed(await call(fallback.harness, "preflight", () => second.preflight({ env: sessionProxy ? sessionEnv(env, "preflight", sessionProxy) : env, proxy: sessionProxy })));
|
||||
if (also) throw new Refusal(also.code, `fallback ${fallback.harness}: ${also.message} (primary ${primary.harness}: ${failed.message})`);
|
||||
[model, harness, route, routeReason] = [fallback, second, "fallback", failed.code];
|
||||
}
|
||||
@@ -740,7 +744,7 @@ export function createLauncher({
|
||||
if (store) compactions(store, model.harness, harness, { instance, thread, session, run });
|
||||
const toolSocket = join(runDir, "tools.sock");
|
||||
const turnMarker = join(runDir, "turn.done");
|
||||
const version = harnessVersion !== undefined ? harnessVersion : call(model.harness, "version", () => harness.version({ env }));
|
||||
const version = harnessVersion !== undefined ? harnessVersion : await call(model.harness, "version", () => harness.version({ env }));
|
||||
// Row 137 (#1631): a role and thread holding an approved, unspent merge decision get land_work.
|
||||
// The broker checks the decision again on every land; this only decides what the bundle shows.
|
||||
// Row 156 (#1651): a non-thread instance's land and landing come from one landHolders read, so a
|
||||
@@ -1670,6 +1674,38 @@ export function createLauncher({
|
||||
clearTimeout(timer);
|
||||
}
|
||||
|
||||
// One harness ({ harness: name }) through a fresh loader, so a refusal never leaves an earlier
|
||||
// load's module in use: { refused, module }, module null when refused. A launch (harnessOf) and
|
||||
// the start's fit warm-up below (#1873 re-check 8) both load through here.
|
||||
async function freshHarness(m, log) {
|
||||
const loader = makeLoader({ dataRoot:system.instanceRoot ?? dataRoot, log });
|
||||
const { refused } = await loader.load({ harness: [m.harness] });
|
||||
return { refused, module: refused.length ? null : loader.modules("harness")[0] };
|
||||
}
|
||||
|
||||
// #1873 pi-unpin re-check 8: each switched-on harness module with ready() (pi's fit check) starts
|
||||
// it here, in the background, so the first launch joins the check in flight instead of starting
|
||||
// it. Nothing waits on it: a launch still awaits its own preflight, which shares this check or
|
||||
// reads its pass. A warm-up that fails or throws is dropped; it caches nothing, and the launch's
|
||||
// preflight runs the check again. Re-check 9: a harness plugin the warm-up can't load leaves one
|
||||
// launch log entry, by its code only (a launch that loads it records the message).
|
||||
function warmHarnesses() {
|
||||
const on = Array.isArray(b.plugins?.harness) ? b.plugins.harness : [];
|
||||
for (const name of on) {
|
||||
(async () => {
|
||||
let logged = false;
|
||||
const refusal = (entry) => {
|
||||
if (logged || entry?.event !== "plugin-refused") return;
|
||||
logged = true;
|
||||
record({ event: "plugin-refused", kind: entry.kind, name: entry.name, code: entry.code, during: "warm-up" });
|
||||
};
|
||||
const { module } = await freshHarness({ harness: name }, refusal);
|
||||
if (typeof module?.ready === "function") await module.ready({ env });
|
||||
})().catch(() => {});
|
||||
}
|
||||
}
|
||||
if (launches) warmHarnesses();
|
||||
|
||||
host.beforeClose(close);
|
||||
return { business: b, registry, listen, launchPm, fromSession, tick, close };
|
||||
}
|
||||
+2
-1
@@ -16,7 +16,7 @@ import { pushWorking, fetchReview } from '../../../harness/src/git-tools.mjs';
|
||||
import { callTool } from '../../../harness/src/tools.mjs';
|
||||
import { toolServer } from '../../../harness/src/runner.mjs';
|
||||
import { buildBundle } from '../../../harness/src/bundle.mjs';
|
||||
import { HARNESS } from '../../../harness/tests/helpers.mjs';
|
||||
import { HARNESS, harnessReady } from '../../../harness/tests/helpers.mjs';
|
||||
import { ensureCheckouts } from '../../../seat/src/checkout.mjs';
|
||||
import { newRun, Registry, readSessions, writeSessionFile, workspaceDir } from '../../../seat/src/session.mjs';
|
||||
import { startTimeOf } from '../../src/host.mjs';
|
||||
@@ -127,6 +127,7 @@ async function runtime() {
|
||||
const cap = bus.bindLaunch(launch_record).cap;
|
||||
roles[role] = { cap, run: id, workspace, runDir };
|
||||
call(role, 'role.claim');
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
const bundle = buildBundle({ dir: join(runDir, 'bundle'), resolved, contract: readFileSync(resolved.contract, 'utf8'),
|
||||
arbiter: role === 'cto', tracker: Boolean(resolved.tracker), credentials: [], skillsDir: join(dataRoot, 'skills-enabled'), harness: HARNESS.pi,
|
||||
harnessVersion: '0.85.1', session: { run: id, workspace, checkouts, toolSocket: join(runDir, 'tools.sock'), turnMarker: join(runDir, 'turn.done') } });
|
||||
|
||||
@@ -12,7 +12,8 @@ import { createHash } from "node:crypto";
|
||||
import { once } from "node:events";
|
||||
import { createInterface } from "node:readline";
|
||||
import { connect } from "node:net";
|
||||
import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
|
||||
import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, watch, writeFileSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { Client } from "../../bus/src/client.mjs";
|
||||
@@ -24,6 +25,8 @@ import { bootConfig, loadSystem } from "../src/config.mjs";
|
||||
import { cmdlineOf, startHost, startTimeOf } from "../src/host.mjs";
|
||||
import { createLauncher } from "../src/launcher.mjs";
|
||||
import { mockAnthropic, REPO } from "../../harness/tests/helpers.mjs";
|
||||
import { piStandIn } from "../../harness/tests/pi-stand-in.mjs";
|
||||
import * as pi from "../../plugins/harness/pi/index.mjs";
|
||||
import { fakeHarnesses, fixture, HOST_CREDENTIALS, tmp, withoutHostCredentials } from "./helpers.mjs";
|
||||
|
||||
const FAKE = fileURLToPath(new URL("../../harness/tests/fixtures/fake-adapter.mjs", import.meta.url));
|
||||
@@ -266,6 +269,142 @@ test("bus start --pm: the launcher instance (the chief of staff) runs under its
|
||||
assert.equal(end.exitCode, 0);
|
||||
});
|
||||
|
||||
// #1873 pi-unpin S1/S2: the version label comes from the pi the module finds. A pi whose --version
|
||||
// fails gives a null label, and the launch still goes ahead.
|
||||
test("pi-unpin: a pi named by MOSAIC_PI_BIN that exits 1 on --version records a null harnessVersion and still launches", { skip, timeout: 30000 }, async (t) => {
|
||||
const prepared = prepare(t);
|
||||
const pkg = join(prepared.root, "pi-prefix", "lib", "node_modules", "@earendil-works", "pi-coding-agent");
|
||||
mkdirSync(join(pkg, "dist", "bundle"), { recursive: true });
|
||||
writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: "@earendil-works/pi-coding-agent", version: "3.0.0", bin: { pi: "dist/bundle/cli.js" } }));
|
||||
// #1873 S3: the stand-in passes the fit check; only its --version fails.
|
||||
writeFileSync(join(pkg, "dist", "bundle", "cli.js"), piStandIn({ versionExit: 1 }), { mode: 0o755 });
|
||||
mkdirSync(join(prepared.root, "pi-prefix", "bin"));
|
||||
const bin = join(prepared.root, "pi-prefix", "bin", "pi");
|
||||
symlinkSync("../lib/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js", bin);
|
||||
prepared.f.env.MOSAIC_PI_BIN = bin;
|
||||
// env() reads the bus's own environment, as the launcher's is process.env outside tests.
|
||||
const before = process.env.MOSAIC_PI_BIN;
|
||||
process.env.MOSAIC_PI_BIN = bin;
|
||||
t.after(() => { if (before === undefined) delete process.env.MOSAIC_PI_BIN; else process.env.MOSAIC_PI_BIN = before; });
|
||||
const { f, launcher, close } = await setup(t, (doc) => doc, prepared, { harnessVersion: undefined });
|
||||
const chief = await launcher.launchPm();
|
||||
assert.equal(chief.harness, "pi");
|
||||
const [s] = readSessions(f.dataRoot);
|
||||
const manifest = JSON.parse(readFileSync(join(s.runDir, "bundle", "manifest.json"), "utf8"));
|
||||
assert.equal(manifest.harnessVersion, null);
|
||||
assert.equal(await close(), 0);
|
||||
});
|
||||
|
||||
// #1873 re-check 8: a pi stand-in under root/pi-prefix, as an npm prefix holds it. Returns its bin.
|
||||
function piPrefix(root, knobs) {
|
||||
const pkg = join(root, "pi-prefix", "lib", "node_modules", "@earendil-works", "pi-coding-agent");
|
||||
mkdirSync(join(pkg, "dist", "bundle"), { recursive: true });
|
||||
writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: "@earendil-works/pi-coding-agent", version: "3.0.0", bin: { pi: "dist/bundle/cli.js" } }));
|
||||
writeFileSync(join(pkg, "dist", "bundle", "cli.js"), piStandIn(knobs), { mode: 0o755 });
|
||||
mkdirSync(join(root, "pi-prefix", "bin"));
|
||||
const bin = join(root, "pi-prefix", "bin", "pi");
|
||||
symlinkSync("../lib/node_modules/@earendil-works/pi-coding-agent/dist/bundle/cli.js", bin);
|
||||
return bin;
|
||||
}
|
||||
// Each fit run makes one scratch directory under tmpdir(), so a watch there counts the runs.
|
||||
// quiet() waits until no run has started for a while, so a check an earlier test left going
|
||||
// (the real pi's, warmed by its launcher) is not counted.
|
||||
function fitRuns(t) {
|
||||
const made = new Set();
|
||||
const watcher = watch(tmpdir(), (event, name) => { if (name && name.startsWith("mosaic-pi-fit-")) made.add(name); });
|
||||
t.after(() => watcher.close());
|
||||
const quiet = async () => {
|
||||
let n;
|
||||
do { n = made.size; await new Promise((r) => setTimeout(r, 700)); } while (made.size !== n);
|
||||
};
|
||||
return { made, quiet };
|
||||
}
|
||||
function busPiBin(t, prepared, bin) {
|
||||
prepared.f.env.MOSAIC_PI_BIN = bin;
|
||||
const before = process.env.MOSAIC_PI_BIN;
|
||||
process.env.MOSAIC_PI_BIN = bin;
|
||||
t.after(() => { if (before === undefined) delete process.env.MOSAIC_PI_BIN; else process.env.MOSAIC_PI_BIN = before; });
|
||||
}
|
||||
|
||||
// #1873 pi-unpin re-check 8: the launcher starts pi's fit check when it starts, before any launch,
|
||||
// and does not wait for it. The first launch joins that check: the two together make one check's
|
||||
// runs, not two.
|
||||
test("pi-unpin re-check 8: the launcher starts pi's fit check when it starts, and the first launch joins it", { skip, timeout: 60000 }, async (t) => {
|
||||
const { made, quiet } = fitRuns(t);
|
||||
// One check on its own, for another stand-in: how many runs it makes.
|
||||
const alone = piPrefix(tmp(t, "mosaic-launch-pi-"), {});
|
||||
await quiet();
|
||||
made.clear();
|
||||
assert.equal(await pi.preflight({ env: { ANTHROPIC_API_KEY: "stand-in", MOSAIC_PI_BIN: alone } }), null);
|
||||
await quiet();
|
||||
const runs = made.size;
|
||||
assert.ok(runs > 10, `one check made ${runs} runs`);
|
||||
const prepared = prepare(t);
|
||||
busPiBin(t, prepared, piPrefix(prepared.root, {}));
|
||||
made.clear();
|
||||
const { launcher, close } = await setup(t, (doc) => doc, prepared, { harnessVersion: undefined });
|
||||
// No launch yet, and the check is under way.
|
||||
await until(() => made.size > 0, 10000).catch(() => assert.fail("no fit run started before the first launch"));
|
||||
const chief = await launcher.launchPm();
|
||||
assert.equal(chief.harness, "pi");
|
||||
await quiet();
|
||||
assert.equal(made.size, runs, "the launch joined the check the launcher started");
|
||||
assert.equal(await close(), 0);
|
||||
});
|
||||
|
||||
// A warm-up that fails leaves no unhandled rejection and keeps no verdict: the next preflight runs
|
||||
// the check again and refuses on its own.
|
||||
test("pi-unpin re-check 8: a fit check the launcher starts that fails is dropped: no unhandled rejection, nothing kept", { skip, timeout: 60000 }, async (t) => {
|
||||
const { made, quiet } = fitRuns(t);
|
||||
const unhandled = [];
|
||||
const seen = (e) => unhandled.push(e);
|
||||
process.on("unhandledRejection", seen);
|
||||
t.after(() => process.off("unhandledRejection", seen));
|
||||
const prepared = prepare(t);
|
||||
const bin = piPrefix(prepared.root, { dropFlags: ["--no-themes"] });
|
||||
busPiBin(t, prepared, bin);
|
||||
await quiet();
|
||||
made.clear();
|
||||
const { close } = await setup(t, (doc) => doc, prepared, { harnessVersion: undefined });
|
||||
await until(() => made.size > 0, 10000).catch(() => assert.fail("no fit run started before the first launch"));
|
||||
// This preflight joins the failing check; then it is gone.
|
||||
const env = { ANTHROPIC_API_KEY: "stand-in", MOSAIC_PI_BIN: bin };
|
||||
const refusal = { code: "harness-feature-missing", message: "pi 9.9.9 (MOSAIC_PI_BIN) lacks --no-themes" };
|
||||
assert.deepEqual(await pi.preflight({ env }), refusal);
|
||||
await quiet();
|
||||
await new Promise((r) => setImmediate(r));
|
||||
assert.deepEqual(unhandled, []);
|
||||
made.clear();
|
||||
assert.deepEqual(await pi.preflight({ env }), refusal);
|
||||
await quiet();
|
||||
assert.ok(made.size > 0, "the failed check was kept");
|
||||
assert.equal(await close(), 0);
|
||||
});
|
||||
|
||||
// Re-check 9: a harness plugin the warm-up can't load leaves one launch log entry, by its code
|
||||
// only, so the message (which may name a host path) stays out of it.
|
||||
test("pi-unpin re-check 9: a harness plugin the launcher's warm-up can't load leaves one launch log entry, by code only", { skip, timeout: 30000 }, async (t) => {
|
||||
const given = prepare(t, (doc) => {
|
||||
doc.plugins = { ...doc.plugins, harness: [...doc.plugins.harness, "broken"] };
|
||||
return doc;
|
||||
});
|
||||
const makeLoader = await fakeHarnesses(t, { pi: given.adapter, "claude-code": given.adapter }, (write) => {
|
||||
write("harness", "broken", `throw new Error("broken at /srv/fit-secret-path");\n`);
|
||||
});
|
||||
const { f, close } = await setup(t, undefined, given, { makeLoader });
|
||||
const refused = () => existsSync(launchLogFile(f.dataRoot, "acme")) ? log(f).filter((e) => e.event === "plugin-refused") : [];
|
||||
await until(() => refused().length > 0, 10000).catch(() => assert.fail("the warm-up left no record of the refused plugin"));
|
||||
await new Promise((r) => setTimeout(r, 500));
|
||||
const entries = refused();
|
||||
assert.equal(entries.length, 1, JSON.stringify(entries));
|
||||
const [entry] = entries;
|
||||
assert.deepEqual(Object.keys(entry).sort(), ["at", "code", "during", "event", "kind", "name"]);
|
||||
assert.deepEqual([entry.kind, entry.name, entry.during], ["harness", "broken", "warm-up"]);
|
||||
assert.match(entry.code, /^[a-z][a-z-]+$/);
|
||||
assert.doesNotMatch(readFileSync(launchLogFile(f.dataRoot, "acme"), "utf8"), /fit-secret-path/);
|
||||
assert.equal(await close(), 0);
|
||||
});
|
||||
|
||||
test("the chief of staff launches a coder through its launch tool; the coder answers; refusals name their code", { skip, timeout: 30000 }, async (t) => {
|
||||
const { f, launcher, client, cto } = await setup(t);
|
||||
const sock = launchSocketPath(f.dataRoot);
|
||||
|
||||
@@ -90,6 +90,8 @@ async function routed(t, harness) {
|
||||
const makeLoader = await fakeHarnesses(t, { pi: null, 'claude-code': null }, write => {
|
||||
// fsthrows: its preflight reads a missing file, so the error's message quotes the path.
|
||||
write('harness', 'fsthrows', `export * from ${PI};\nimport { readFileSync } from "node:fs";\nexport function preflight() { readFileSync(${JSON.stringify(absent)}); }\n`);
|
||||
// fsrejects (#1873 re-check 8): an async preflight, as pi's is, whose promise rejects with that error.
|
||||
write('harness', 'fsrejects', `export * from ${PI};\nimport { readFileSync } from "node:fs";\nexport async function preflight() { readFileSync(${JSON.stringify(absent)}); }\n`);
|
||||
// plainthrows: a plain Error whose message quotes a host path, as a module's own text.
|
||||
write('harness', 'plainthrows', `export * from ${PI};\nexport function preflight() { throw new Error(${JSON.stringify(`cannot read ${absent}`)}); }\n`);
|
||||
// pathfails: a preflight that returns a failure whose message quotes a host path.
|
||||
@@ -146,6 +148,15 @@ test('a harness whose preflight throws a system error refuses harness-failed nam
|
||||
clean(JSON.stringify(s.last()), s.root);
|
||||
});
|
||||
|
||||
// #1873 re-check 8 P3-1: a preflight promise that rejects is refused as a throw is, by the call and
|
||||
// the system code, never the raw error or its path.
|
||||
test('a harness whose async preflight rejects with a system error refuses harness-failed naming the call and code, never the path', async t => {
|
||||
const s = await routed(t, 'fsrejects');
|
||||
assert.deepEqual(await s.launch(), { ok: false, error: 'harness-failed' });
|
||||
assert.equal(s.last().why, 'harness fsrejects preflight: cannot open a host file (ENOENT)');
|
||||
clean(JSON.stringify(s.last()), s.root);
|
||||
});
|
||||
|
||||
test('a harness the loader refuses names its code only, never the loader message or a path', async t => {
|
||||
const s = await routed(t, 'absent');
|
||||
assert.deepEqual(await s.launch(), { ok: false, error: 'harness-refused' });
|
||||
|
||||
@@ -18,13 +18,103 @@ Every harness layer below is a row S0 line
|
||||
(`docs/plans/2026-10-04_slice-1.md`, "What S6 can rely on"), and each
|
||||
bundle's `manifest.json` names the lines it relies on (`reliesOn`):
|
||||
|
||||
| | Pi | Claude Code |
|
||||
|---|---|---|
|
||||
| 1. block a tool | `tool_call` handler returns a block | PreToolUse command hook exits 2; `--bare` is never passed |
|
||||
| 2. gate crash | a throw in the handler blocks | the hook runs as `<gate> \|\| exit 2` |
|
||||
| 3. gate missing | a missing `-e` file refuses to start | the wrapper blocks |
|
||||
| 4. gate hang | the runner's wall clock plus the `agent_end` marker | `timeout -k 2 10 <gate> \|\| exit 2`, hook timeout 20 |
|
||||
| 5. bash | limited only by the tool limit | limited only by the tool limit |
|
||||
| | Pi | Claude Code | How pi's line is checked |
|
||||
|---|---|---|---|
|
||||
| 1. block a tool | `tool_call` handler returns a block | PreToolUse command hook exits 2; `--bare` is never passed | suites, on the repository's pi (`pi-session.test.mjs`) |
|
||||
| 2. gate crash | a throw in the handler blocks | the hook runs as `<gate> \|\| exit 2` | suites, on the repository's pi |
|
||||
| 3. gate missing | a missing `-e` file refuses to start | the wrapper blocks | at every start, by the fit check, on the pi that runs; and suites |
|
||||
| 4. gate hang | the runner's wall clock plus the `agent_end` marker | `timeout -k 2 10 <gate> \|\| exit 2`, hook timeout 20 | suites, on the repository's pi |
|
||||
| 5. bash | limited only by the tool limit | limited only by the tool limit | suites, on the repository's pi |
|
||||
|
||||
Pi is not pinned (#1873 pi-unpin). Before a session starts, `preflight`
|
||||
awaits the fit check in `src/pi-fit.mjs` on the binary the module found
|
||||
(the Triage host and route await the module's `ready` instead), and
|
||||
`env` reads its pass. It runs that binary in a sandbox with the network
|
||||
unshared and calls no model. Each run is a child process the check
|
||||
awaits, up to four at a time, so the bus's event loop keeps running
|
||||
while it does; callers that ask while a check runs share it. Each run
|
||||
gets the environment a bus session's pi gets, built by the same code
|
||||
(the launcher's `ENV_ALLOW` and `sessionEnv`, the sandbox's
|
||||
`sessionSetenv`, the runner's `adapterEnv` and the pi module's
|
||||
`harnessEnv`) from the bus process's own environment, less the provider
|
||||
keys, and starts the binary through `/bin/sh` as the adapter does. So
|
||||
`HOME` is a scratch home, `TMPDIR` is `/tmp` bound to scratch, a run has
|
||||
`TERM`, `TZ` or `LC_ALL` only when the bus has it (a bus started by its
|
||||
unit has none), and no run sets `PI_CODING_AGENT_DIR`, which no session
|
||||
has: pi's agent directory is `$HOME/.pi/agent`, where the user sources
|
||||
are planted. A test fails when the fit runs' names, or the values the
|
||||
code sets, differ from a bus session's, apart from the provider
|
||||
variables, for a login shell's host and a unit's. It needs
|
||||
`--help` to list, in its option column, every flag the adapter passes
|
||||
(with rpc mode and each thinking level), and a missing `-e` file to stop
|
||||
the start in rpc and in `-p`. The planted ambient sources must stay
|
||||
unloaded with the seal flags on (skills and prompt templates are read
|
||||
from `get_commands` in rpc and from the `-e` extension's command list in
|
||||
`-p`): extensions, MCP
|
||||
servers, skills and prompt templates (found in their directories, listed
|
||||
in a `settings.json`, or in a local package a `settings.json` lists),
|
||||
context files (`AGENTS.md`, `CLAUDE.md`, `SYSTEM.md`) and a trusted
|
||||
project's `.pi/SYSTEM.md` and `.pi/APPEND_SYSTEM.md`. The project has a
|
||||
saved trust, so only `--no-approve` keeps those two out. An `-e`
|
||||
extension writes the system prompt, command names and session id it sees
|
||||
at `session_start`; the sealed runs must show the `--system-prompt` file
|
||||
and none of the planted sources. A control run passes the seal flags less every loader flag
|
||||
(`--no-approve`, `--no-extensions`, `--no-skills`,
|
||||
`--no-prompt-templates`, `--no-context-files`, and `--no-mcp` when
|
||||
listed), so it keeps `--offline`, `--no-themes`, `--no-tools` and
|
||||
`--no-session`, and the same `-e` and `--system-prompt`. It must show
|
||||
each kind of source (an MCP server only when `--help` lists `--no-mcp`)
|
||||
and answer `get_state` and `get_commands`, and its `-e` extension must
|
||||
list the planted skill and prompt template, or the check can't tell and
|
||||
refuses. For every kind but the trusted project files, only a source
|
||||
outside the project counts there, since a project source can wait on
|
||||
trust and `--no-approve` would then hide a seal flag the binary ignores.
|
||||
Then one sealed rpc run per loader flag leaves out only that flag: its
|
||||
kind must show, and no other kind (an MCP server may show beside an
|
||||
extension when `--help` lists no `--no-mcp`, since pi then ties MCP to
|
||||
`--no-extensions`). So each loader flag is shown to keep its own kind
|
||||
out, and no other seal flag, nor their order, can stand in for it. Five
|
||||
sealed `-p` runs have a bus session's shape: the arguments the adapter
|
||||
passes for a session, in its order, from `sessionShape` in
|
||||
`src/pi-fit.mjs`, with two `-e` and `--session-dir`. The adapter's four
|
||||
session branches (a tool list or `--no-tools`, `-c` over a stored
|
||||
session or none, `--thinking` or none, `--mode json` or none) are spread
|
||||
over the five runs so every pair of them is passed together. A `-c` run
|
||||
gets a stored session and must resume it. Each must load both `-e`
|
||||
files and show no planted source. A test drives the adapter, in a bus
|
||||
session's environment, through every branch set with no tools, one or
|
||||
two, `-c` over a pi-named session file or an unrelated file, each
|
||||
thinking level and each provider a session can name. It runs over a
|
||||
login shell's host and a unit's, and fails on an argv `sessionShape`
|
||||
doesn't build, a pair no run passes, or a variable the adapter reads
|
||||
that no session sets. So a branch on `TZ` or `LC_ALL` being unset, or on
|
||||
`TERM` missing from the environment, turns it red. (Bash run as
|
||||
`/bin/sh` sets an unset `TERM` to `dumb` for the shell without exporting
|
||||
it, so `${TERM:-}` in the adapter is never empty, in a session or here.)
|
||||
It can't see a branch keyed on a
|
||||
value it doesn't try (a model, a path, another tool or provider). A last sealed `-p` run uses `--no-session`, as
|
||||
worker runs do. Each run gets a fresh scratch directory, so no run sees
|
||||
what another left. Not run: `--fork`, `--skill` and the interactive TUI
|
||||
(worker containers and `scripts/agent.sh` only), the branches three or
|
||||
four at a time beyond the five runs, `-c` over a session directory that
|
||||
holds nothing for the project (one more run costs about 340 ms cold),
|
||||
and a session's own values (tools beyond `read` and `bash`, thinking
|
||||
levels beyond `low`, provider, model, key, `-e` files, request). The
|
||||
runs are offline with no key, so nothing past the start is tried. A pi
|
||||
built to act one way in the fit runs and another way with those is
|
||||
outside what a start-time check can catch. A run killed for taking
|
||||
over 20 s or printing over 4 MB can't be checked and says which. A
|
||||
`--version` that fails or hangs past 3 s only leaves no label. Pi
|
||||
0.85.1 appends the agent directory's `APPEND_SYSTEM.md` whatever the
|
||||
flags, so the check doesn't plant one. Any failure refuses the launch with
|
||||
`harness-feature-missing` and one line that names the binary by its label,
|
||||
for example `pi 2.0.0 (MOSAIC_PI_BIN) lacks --no-context-files`. When
|
||||
`--help` lists `--no-mcp`, the adapter passes it too. A pass is cached in
|
||||
memory by a digest of the package's files (and npm's lock files, for
|
||||
the repository's copy) and the names in the runs' environment, so a bus
|
||||
restarted under other names checks again. Lines 1, 2, 4 and 5 are not
|
||||
checked at start; a pi other than the repository's copy relies on them
|
||||
unproved until a scripted-model fit run exists (design section 5, S6).
|
||||
|
||||
Claude Code also runs with `--restricted`: no user, project or local
|
||||
settings, file tools confined to the working directory, and no `CLAUDE.md`
|
||||
|
||||
@@ -0,0 +1,778 @@
|
||||
// #1873 pi-unpin S3: the start-time fit check for a pi binary the harness module found. Nothing
|
||||
// here compares a version. The check runs the binary only inside a sandbox with the network
|
||||
// unshared, the found package mounted as a session mounts it, and a bus session's environment
|
||||
// (fitEnv below), so its agent directory is $HOME/.pi/agent under a scratch HOME, as a session's
|
||||
// is. No model is called and no provider key is passed. It asks:
|
||||
//
|
||||
// --version a label for the refusal line and the record; not a gate
|
||||
// --help lists, in its option column, every flag Mosaic passes, with rpc mode and each
|
||||
// thinking level
|
||||
// control rpc, planted ambient sources, a saved trust for the project, the seal flags less
|
||||
// every loader flag (the ones that each keep one kind of source out: --no-approve,
|
||||
// --no-extensions, --no-skills, --no-prompt-templates, --no-context-files, and
|
||||
// --no-mcp when --help lists it), the --system-prompt file the sealed runs pass, and
|
||||
// one -e extension that writes what it sees at session_start: the system prompt, the
|
||||
// command names and the session id. The binary answers get_state and get_commands,
|
||||
// its -e extension lists the planted skill and prompt template (the -p runs see
|
||||
// those kinds only that way), and it shows each kind of planted source:
|
||||
// an extension, a skill, a prompt template, a context file, a trusted project file
|
||||
// (the project's .pi/APPEND_SYSTEM.md, which only the trust --no-approve must undo
|
||||
// lets in), and an MCP server when --help lists --no-mcp. Only a source outside the
|
||||
// project counts for the other kinds, since a project source can wait on trust. A
|
||||
// kind it doesn't show could not be told apart from a sealed one.
|
||||
// sealed rpc the adapter's seal flags (and --no-mcp when --help lists it), the -e extension and
|
||||
// --system-prompt. The binary answers both, loads that extension (a session's gate
|
||||
// comes in that way), uses the --system-prompt file, and shows no planted source.
|
||||
// one out one more sealed rpc run per loader flag, with every seal flag but that one. The
|
||||
// kind it keeps out must show, and no other kind (pi without --no-mcp ties MCP to
|
||||
// --no-extensions, so an MCP server may show beside an extension). So each loader flag
|
||||
// is shown to keep its own kind out, and no other seal flag, nor the order they come
|
||||
// in, can stand in for it.
|
||||
// session five -p runs in a bus session's shape, with the arguments adapters/pi/adapter.sh
|
||||
// passes for a session, in its order (sessionShape below): two -e, --session-dir in
|
||||
// place of --no-session, a fixed --provider and --model, -p and a message. The
|
||||
// adapter's four session branches (a tool list or --no-tools, -c over a stored
|
||||
// session or none, --thinking or none, --mode json or none) are spread over the five
|
||||
// runs so each pair of them is passed together (SESSION_RUNS). A -c run gets a
|
||||
// stored session for the project and must resume it. Each run loads both -e
|
||||
// extensions, uses the --system-prompt file, and shows no
|
||||
// planted source. A test drives the adapter through every branch set, tool list
|
||||
// length and thinking level, and fails on an argv sessionShape doesn't build or a
|
||||
// pair no run passes.
|
||||
// sealed -p the seal flags in -p with --no-session, as a worker run passes them. Its -e
|
||||
// extension must reach session_start, and no planted source may show.
|
||||
// missing -e a missing -e file, in rpc and in -p, stops the start: exit non-zero, no answer,
|
||||
// and no session_start for the -e extension given after it
|
||||
//
|
||||
// Every run gets a fresh scratch directory with the sources planted again, so no run sees what
|
||||
// another one left. The directory's name carries the pid, start time and pid namespace of the
|
||||
// process that made it, and each check first stops the processes and removes the directories a
|
||||
// process no longer running left (sweepScratch below). Every run dies with the process that runs
|
||||
// the check (checkArgv in packages/seat/src/sandbox.mjs), at once when unshare runs here and at
|
||||
// the next check's sweep when it doesn't.
|
||||
// The runs share no state: up to FIT_CONCURRENCY of them run at once,
|
||||
// each a child process the check awaits, so the process that runs the check (the bus) keeps
|
||||
// answering while it runs. --version and --help go first; the rest start in the order above and
|
||||
// are judged in that order, so the first failure is the one a refusal names, and the runs still
|
||||
// going are killed. Each run passes the same -e and --system-prompt; the other runs differ only by
|
||||
// their seal flags, their mode, the -p message and the missing -e file. Each run starts the binary
|
||||
// through /bin/sh, as the adapter does, with fitEnv's variables: the environment a bus session's pi
|
||||
// gets, built by the code that builds it (the launcher's ENV_ALLOW and sessionEnv, the sandbox's
|
||||
// sessionSetenv, the runner's adapterEnv and the pi module's harnessEnv) from the calling process's
|
||||
// own environment, less the provider variables. So a fit run has a name only when a session in that
|
||||
// process has it (TERM, TZ and LC_ALL only when the bus has them), no run sets a variable a session
|
||||
// lacks, such as PI_CODING_AGENT_DIR, and a test holds the two together.
|
||||
//
|
||||
// A check that cannot tell refuses: a sandbox that fails, a run that times out or prints more
|
||||
// than 4 MB, an answer that is missing or doesn't parse, a kind of source the control doesn't
|
||||
// show, or the kind a one-out run should show. A one-out run that shows another kind, or a
|
||||
// session-shaped run that shows any, is a leak. A --version that fails or hangs past 3 s only
|
||||
// leaves no label. A pass is cached in memory by a digest of the files that run (the package's
|
||||
// package.json, every file under dist/bundle/, every file in the directory tree that holds the
|
||||
// binary's real file, and, for a copy mounted with the node_modules it sits in, npm's lock files
|
||||
// there), the mount layout and the names in the fit runs' environment, so a process with other
|
||||
// names checks again. Callers that ask while a check for the same key is running share it.
|
||||
// A refusal line names the found binary by its label (MOSAIC_PI_BIN, the pi on PATH, the
|
||||
// repository's pi), never a host path.
|
||||
//
|
||||
// Known limit: pi 0.85.1 appends the agent directory's APPEND_SYSTEM.md whatever the flags. The
|
||||
// check doesn't plant one; a session's agent directory is the run's own. Not run: --fork,
|
||||
// --skill with --no-skills dropped, and the interactive TUI, which only worker containers and
|
||||
// scripts/agent.sh pass; the session branches three or four at a time beyond the session-shaped
|
||||
// runs; -c over a session directory that holds nothing for the project (the adapter passes -c
|
||||
// whenever the directory isn't empty), since one more run costs about 340 ms cold; and a
|
||||
// session's own values: its tool names beyond read and bash, thinking levels beyond low,
|
||||
// provider, model, key, -e files and request. The runs are offline with no key, so nothing
|
||||
// past the start is tried. A pi built to act differently with those is outside what a start-time
|
||||
// check can catch.
|
||||
import { spawn } from "node:child_process";
|
||||
import { createHash } from "node:crypto";
|
||||
import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, writeFileSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { dirname, join, relative } from "node:path";
|
||||
import { BWRAP, SETPRIV, UNSHARE, checkArgv, outerArgv, sessionSetenv } from "../../seat/src/sandbox.mjs";
|
||||
import { isProviderVariable, sessionEnv } from "../../seat/src/session.mjs";
|
||||
import { adapterEnv } from "./runner.mjs";
|
||||
import { FIT_ROUTE, harnessEnv } from "../../plugins/harness/pi/session-env.mjs";
|
||||
|
||||
// The flags adapters/pi/adapter.sh and the conversation engine pass.
|
||||
export const FIT_FLAGS = Object.freeze(["--mode", "--session", "--no-session", "--session-dir", "--fork", "-c", "--no-extensions", "-e", "--no-skills", "--skill", "--no-prompt-templates", "--no-themes", "--no-context-files", "--no-approve", "--offline", "--tools", "--no-tools", "--provider", "--model", "--thinking", "--system-prompt", "-p"]);
|
||||
// The adapter's seal flags, as it passes them in an ephemeral session with no tools.
|
||||
const SEAL = ["--offline", "--no-approve", "--no-extensions", "--no-skills", "--no-prompt-templates", "--no-themes", "--no-context-files", "--no-tools", "--no-session"];
|
||||
// The loader flags: each keeps one kind of planted source out. --no-mcp counts when --help lists it.
|
||||
const LOADERS = [["--no-approve", "trusted project file"], ["--no-extensions", "extension"], ["--no-skills", "skill"], ["--no-prompt-templates", "prompt template"], ["--no-context-files", "context file"]];
|
||||
// The session-shaped runs' fixed values: a two-tool list, a thinking level, a provider and model.
|
||||
// Offline with no key, pi stops before any model call. The provider and model are the pi module's
|
||||
// (session-env.mjs FIT_ROUTE), so no core source names them.
|
||||
export const SESSION_SHAPE = Object.freeze({ tools: "read,bash", thinking: "low", provider: FIT_ROUTE.provider, model: FIT_ROUTE.model });
|
||||
// The branches adapters/pi/adapter.sh takes for a bus session, each run once or not: a tool list or
|
||||
// --no-tools, -c over a stored session or a fresh one, --thinking or none, --mode json (the model
|
||||
// event monitor) or none. The five runs pass every pair of those together; pi-fit.test.mjs drives
|
||||
// the adapter through all sixteen and fails on a pair no run passes.
|
||||
const T = SESSION_SHAPE.tools;
|
||||
const L = SESSION_SHAPE.thinking;
|
||||
export const SESSION_RUNS = Object.freeze([
|
||||
{ tools: "", cont: false, thinking: "", json: false },
|
||||
{ tools: "", cont: true, thinking: L, json: true },
|
||||
{ tools: T, cont: false, thinking: L, json: true },
|
||||
{ tools: T, cont: true, thinking: "", json: true },
|
||||
{ tools: T, cont: true, thinking: L, json: false },
|
||||
].map((r) => Object.freeze(r)));
|
||||
// The arguments adapters/pi/adapter.sh builds for a bus session: the given -e files, a tool list
|
||||
// or none, a persistent session directory with -c when it holds a session, a thinking level or
|
||||
// none, the --system-prompt file, -p and the request, and --mode json when the model event monitor
|
||||
// runs pi. No --skill and no --fork: a bus session never passes them. Keep its order:
|
||||
// pi-fit.test.mjs runs the adapter through every branch and fails when the two differ.
|
||||
export function sessionShape({ noMcp, extensions, prompt, sessionDir, tools, cont, thinking, json, message }) {
|
||||
return [
|
||||
"--offline", "--no-approve", "--no-extensions", ...(noMcp ? ["--no-mcp"] : []), ...extensions.flatMap((e) => ["-e", e]),
|
||||
"--no-skills", "--no-prompt-templates", "--no-themes", "--no-context-files",
|
||||
...(tools ? ["--tools", tools] : ["--no-tools"]), "--session-dir", sessionDir, ...(cont ? ["-c"] : []),
|
||||
"--provider", SESSION_SHAPE.provider, "--model", SESSION_SHAPE.model, ...(thinking ? ["--thinking", thinking] : []),
|
||||
"--system-prompt", prompt, "-p", message, ...(json ? ["--mode", "json"] : []),
|
||||
];
|
||||
}
|
||||
// What a session-shaped run is named by in a refusal line.
|
||||
const shapeName = ({ tools, cont, thinking, json }) => `in a session's shape with ${[tools ? "--tools" : "--no-tools", ...(cont ? ["-c"] : []), ...(thinking ? ["--thinking"] : []), ...(json ? ["--mode json"] : [])].join(", ")}`;
|
||||
const RUN_TIMEOUT = 20000;
|
||||
// --version gives only a label, so a hang costs this much and leaves no label.
|
||||
const VERSION_TIMEOUT = 3000;
|
||||
const OUTPUT_MAX = 4 * 1024 * 1024;
|
||||
// How long a run's pipes may stay open after it exits or is killed (spawned).
|
||||
const PIPE_GRACE = 1000;
|
||||
const DIGEST_FILES_MAX = 20000;
|
||||
|
||||
// At most this many fit runs at once. Each run is one sandboxed pi start in its own scratch
|
||||
// directory.
|
||||
export const FIT_CONCURRENCY = 4;
|
||||
|
||||
const passed = new Map();
|
||||
const running = new Map();
|
||||
|
||||
// #1873 re-check 9: each run's scratch directory is named for the process that makes it, by its
|
||||
// pid and its start time (field 22 of /proc/<pid>/stat), so a pid used again later is not taken
|
||||
// for it. A process killed mid-check can't remove its own directories. So a check removes, before
|
||||
// it starts, every directory here that a process no longer running made: its pid is gone, or now
|
||||
// belongs to a process that started at another time. A directory whose process can't be read, or
|
||||
// one this uid doesn't own, or a symlink, is left alone.
|
||||
//
|
||||
// #1873 re-check 10: the name also carries the maker's pid namespace (the inode of
|
||||
// /proc/<pid>/ns/pid), and a sweep leaves alone every directory made in another one, since it
|
||||
// can't read that process. And before it removes a directory, the sweep stops the processes that
|
||||
// name it on their command line: a run's every layer does (the setpriv, shell, unshare and bwrap
|
||||
// argv, bwrap's child before its exec, pi's own -e and --system-prompt), and so do the sandbox
|
||||
// probes. Without unshare's outer layer a bwrap child killed in its setup waits for good (see
|
||||
// checkArgv in sandbox.mjs), and this is what stops it. A process is stopped only when an argument
|
||||
// is that directory or a path in it, its real and effective uid are this process's, and its start
|
||||
// time is the same before and after its command line is read. Never by name, never another uid's,
|
||||
// never one whose directory's maker still runs.
|
||||
const SCRATCH = /^mosaic-pi-fit-(\d+)-(\d+)-(\d+)-/;
|
||||
const startTime = (pid) => readFileSync(`/proc/${pid}/stat`, "utf8").split(") ").pop().split(" ")[19];
|
||||
const pidNamespace = (pid) => /^pid:\[(\d+)\]$/.exec(readlinkSync(`/proc/${pid}/ns/pid`))[1];
|
||||
let ownName = null;
|
||||
const scratchPrefix = () => `mosaic-pi-fit-${ownName ??= `${process.pid}-${startTime(process.pid)}-${pidNamespace("self")}`}-`;
|
||||
function sweepScratch(dir = tmpdir()) {
|
||||
let names;
|
||||
try {
|
||||
names = readdirSync(dir);
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
const uid = process.getuid();
|
||||
const ns = pidNamespace("self");
|
||||
const stale = [];
|
||||
for (const name of names) {
|
||||
const m = SCRATCH.exec(name);
|
||||
if (!m || m[3] !== ns) continue;
|
||||
try {
|
||||
let alive;
|
||||
try {
|
||||
alive = startTime(m[1]) === m[2];
|
||||
} catch (e) {
|
||||
if (e.code !== "ENOENT") continue;
|
||||
alive = false;
|
||||
}
|
||||
if (alive) continue;
|
||||
const at = join(dir, name);
|
||||
const st = lstatSync(at);
|
||||
if (st.isDirectory() && st.uid === uid) stale.push(at);
|
||||
} catch {}
|
||||
}
|
||||
if (!stale.length) return;
|
||||
stopNaming(stale, uid);
|
||||
for (const at of stale) {
|
||||
try {
|
||||
rmSync(at, { recursive: true, force: true });
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
// SIGKILL to every process of uid (real and effective) with an argument that is one of dirs or a
|
||||
// path in one, other than this one.
|
||||
function stopNaming(dirs, uid) {
|
||||
let pids;
|
||||
try {
|
||||
pids = readdirSync("/proc").filter((p) => /^\d+$/.test(p) && Number(p) !== process.pid);
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
const names = (arg) => dirs.some((d) => arg === d || arg.startsWith(`${d}/`));
|
||||
for (const pid of pids) {
|
||||
try {
|
||||
const start = startTime(pid);
|
||||
const ids = /^Uid:\s+(\d+)\s+(\d+)\s/m.exec(readFileSync(`/proc/${pid}/status`, "utf8"));
|
||||
if (!ids || Number(ids[1]) !== uid || Number(ids[2]) !== uid) continue;
|
||||
if (!readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").some(names)) continue;
|
||||
if (startTime(pid) !== start) continue;
|
||||
process.kill(Number(pid), "SIGKILL");
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
|
||||
// The provider variables never reach a fit run: no key is passed, since no model is called.
|
||||
const withoutProviders = (host) => Object.fromEntries(Object.entries(host ?? {}).filter(([k, v]) => typeof v === "string" && !isProviderVariable(k)));
|
||||
// The names a fit run's host part holds: sessionEnv's answer for the process's environment.
|
||||
export const fitNames = (host = process.env) => Object.keys(sessionEnv(withoutProviders(host), "fit")).sort();
|
||||
const fitKey = (found, { levels, bwrap, unshare, node, host }) => JSON.stringify([filesDigest(found), found.root, found.dest ?? null, found.view, bwrap, unshare, node, levels, fitNames(host)]);
|
||||
|
||||
// found: binary.mjs's answer ({ bin, label, root, dest, view, pkg }). levels: the thinking levels
|
||||
// the module applies. host: the environment of the process sessions launch from (the bus's own),
|
||||
// which a fit run's environment is built from as a session's is. bwrap and unshare: where those
|
||||
// tools are (tests pass stand-ins). Returns a promise of { ok: true, version, noMcp, digest, outer }
|
||||
// or { ok: false, message }. outer: { used: true } when the runs had unshare's outer layer, else
|
||||
// { used: false, why } with why naming unshare and how it failed (sandboxLayers below). A call
|
||||
// while a check with the same key runs gets that check's promise. A check that throws (a scratch directory it can't
|
||||
// make, say) can't tell, so it gives { ok: false, message } too and keeps nothing.
|
||||
export function piFit(found, { levels = [], bwrap = BWRAP, unshare = UNSHARE, node = process.execPath, host = process.env } = {}) {
|
||||
const who = (version) => `pi${version ? ` ${version}` : ""} (${found.label})`;
|
||||
let key;
|
||||
try {
|
||||
key = fitKey(found, { levels, bwrap, unshare, node, host });
|
||||
} catch {
|
||||
return Promise.resolve({ ok: false, message: `${who(null)} can't be checked: its files can't be read` });
|
||||
}
|
||||
if (passed.has(key)) return Promise.resolve(passed.get(key));
|
||||
if (running.has(key)) return running.get(key);
|
||||
const job = (async () => {
|
||||
try {
|
||||
sweepScratch();
|
||||
// The sandbox's own error text can name a host path, so the line keeps only what failed.
|
||||
const layers = await sandboxLayers({ bwrap, unshare, node });
|
||||
if (layers.problem) return { ok: false, message: `${who(null)} can't be checked: ${layers.problem}` };
|
||||
const result = await check(found, { levels, bwrap, unshare: layers.outer, node, who, digest: JSON.parse(key)[0], host });
|
||||
if (!result.ok) return result;
|
||||
const passing = { ...result, outer: layers.outer ? { used: true } : { used: false, why: layers.why } };
|
||||
passed.set(key, passing);
|
||||
return passing;
|
||||
} catch {
|
||||
// #1873 re-check 8: refused as a fit that failed. The error's text can name a host path, so
|
||||
// the line keeps none of it.
|
||||
return { ok: false, message: `${who(null)} can't be checked: the check could not run` };
|
||||
}
|
||||
})().finally(() => { if (running.get(key) === job) running.delete(key); });
|
||||
running.set(key, job);
|
||||
return job;
|
||||
}
|
||||
|
||||
// The passed check for found as piFit would key it now, or null: none passed, or its files can't
|
||||
// be read. Nothing is run.
|
||||
export function fitVerdict(found, { levels = [], bwrap = BWRAP, unshare = UNSHARE, node = process.execPath, host = process.env } = {}) {
|
||||
try {
|
||||
return passed.get(fitKey(found, { levels, bwrap, unshare, node, host })) ?? null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
async function check(found, { levels, bwrap, unshare, node, who, digest, host }) {
|
||||
// At most FIT_CONCURRENCY runs at once, started in the order they are asked for. stop kills the
|
||||
// runs still going and keeps queued ones from starting; the check waits for every run it began,
|
||||
// so no scratch directory or child outlives it.
|
||||
const stop = new AbortController();
|
||||
const begun = [];
|
||||
let active = 0;
|
||||
const waiting = [];
|
||||
const slot = () => active < FIT_CONCURRENCY ? (active++, Promise.resolve()) : new Promise((resolve) => waiting.push(resolve));
|
||||
const free = () => { const next = waiting.shift(); if (next) next(); else active--; };
|
||||
// args: the arguments, or a function of the run's scratch directory that returns them (it may
|
||||
// plant more first). The answer is read before the scratch directory goes: the rpc answers,
|
||||
// whether each -e extension loaded, what the first one saw at session_start (the system prompt,
|
||||
// the command names, the session id), and the planted sources that showed, through the rpc
|
||||
// get_commands answer or through the -e extension's command list (listed: through that alone).
|
||||
// shape: a session-shaped run's branches, which set its tools, thinking level and monitor
|
||||
// variables as a session's would. A run that stop kept from starting gives null.
|
||||
const once = async (args, input, { timeout, noMcp, shape }) => {
|
||||
await slot();
|
||||
try {
|
||||
if (stop.signal.aborted) return null;
|
||||
const scratch = mkdtempSync(join(tmpdir(), scratchPrefix()));
|
||||
let ran = null;
|
||||
try {
|
||||
plant(scratch);
|
||||
const env = fitEnv(scratch, { view: found.view, noMcp, shape, host });
|
||||
const r = ran = await runIn(found, { bwrap, unshare, node, scratch, env, args: typeof args === "function" ? args(scratch) : args, input, timeout, signal: stop.signal });
|
||||
const answer = answered(r.stdout);
|
||||
const start = started(scratch);
|
||||
const listed = start?.commands ?? [];
|
||||
return { ...r, answer, explicit: marked(scratch, EXPLICIT), second: marked(scratch, SECOND), prompt: start?.prompt ?? null, session: start?.session ?? null, listed: named(listed), seen: seen(scratch, [...(answer.commands ?? []), ...listed], start) };
|
||||
} finally {
|
||||
// #1873 re-check 10: a run this check killed (a timeout, or stop) may have had bwrap in its
|
||||
// setup, and without unshare's outer layer bwrap's child then waits for good. The run is
|
||||
// over, so whatever still names its directory is left from it.
|
||||
if (ran?.stopped) stopNaming([scratch], process.getuid());
|
||||
rmSync(scratch, { recursive: true, force: true });
|
||||
}
|
||||
} finally {
|
||||
free();
|
||||
}
|
||||
};
|
||||
const run = (args, input = "", { timeout = RUN_TIMEOUT, noMcp = false, shape = null } = {}) => {
|
||||
const p = once(args, input, { timeout, noMcp, shape });
|
||||
// Judged in order, a later run can fail before an earlier one is awaited: this keeps that
|
||||
// failure from counting as unhandled. Awaiting p still throws it.
|
||||
p.catch(() => {});
|
||||
begun.push(p);
|
||||
return p;
|
||||
};
|
||||
try {
|
||||
return await judge(found, { levels, who, digest, run });
|
||||
} finally {
|
||||
stop.abort();
|
||||
await Promise.allSettled(begun);
|
||||
}
|
||||
}
|
||||
|
||||
async function judge(found, { levels, who, digest, run }) {
|
||||
const helped = run(["--help"]);
|
||||
const versioned = run(["--version"], "", { timeout: VERSION_TIMEOUT });
|
||||
const help = await helped;
|
||||
const v = await versioned;
|
||||
const version = v.status === 0 ? versionLabel(v.stdout) : null;
|
||||
const refuse = (why) => ({ ok: false, message: `${who(version)} ${why}` });
|
||||
if (help.status !== 0) return refuse("can't be checked: --help failed");
|
||||
const lines = help.stdout.split("\n");
|
||||
const has = (flag) => lines.some((l) => optionsIn(l).includes(flag));
|
||||
const line = (flag) => lines.find((l) => optionsIn(l).includes(flag)) ?? "";
|
||||
const missing = FIT_FLAGS.filter((f) => !has(f));
|
||||
if (has("--mode") && !word(line("--mode"), "rpc")) missing.push("--mode rpc");
|
||||
if (has("--thinking")) for (const l of levels) if (!word(line("--thinking"), l)) missing.push(`--thinking ${l}`);
|
||||
if (missing.length) return refuse(`lacks ${missing.join(", ")}`);
|
||||
const noMcp = has("--no-mcp");
|
||||
|
||||
const ask = '{"id":"fit-state","type":"get_state"}\n{"id":"fit-commands","type":"get_commands"}\n';
|
||||
// Every run passes the same -e and --system-prompt, so the runs differ only by the seal flags.
|
||||
const given = (scratch) => ["-e", join(scratch, "explicit", "fit.ts"), "--system-prompt", join(scratch, "prompt.md")];
|
||||
const seal = [...SEAL, ...(noMcp ? ["--no-mcp"] : [])];
|
||||
const loaders = [...LOADERS, ...(noMcp ? [["--no-mcp", "MCP server"]] : [])];
|
||||
const without = (...flags) => seal.filter((f) => !flags.includes(f));
|
||||
const rpcRun = (flags) => run((s) => ["--mode", "rpc", ...flags, ...given(s)], ask, { noMcp });
|
||||
|
||||
// Every run is asked for now, in the order they are judged below; none depends on another.
|
||||
// The control keeps the seal flags no planted source tells apart (--offline, --no-themes,
|
||||
// --no-tools, --no-session), so one of those can't stand in for a loader flag either.
|
||||
const controlRun = rpcRun(without(...loaders.map(([f]) => f)));
|
||||
const rpcSealed = rpcRun(seal);
|
||||
const oneOut = loaders.map(([flag, kind]) => [flag, kind, rpcRun(without(flag))]);
|
||||
// A bus session's shapes, in -p as its turns run: --session-dir in place of --no-session, two -e
|
||||
// as a session passes, and each pair of the adapter's session branches in one run. A -c run gets
|
||||
// a stored session for the project first and must resume it, since -c with none starts afresh.
|
||||
const shaped = SESSION_RUNS.map((shape) => [shape, run((s) => {
|
||||
if (shape.cont) plantSession(s);
|
||||
return sessionShape({ noMcp, extensions: [join(s, "explicit", "fit.ts"), join(s, "explicit", "second.ts")], prompt: join(s, "prompt.md"), sessionDir: join(s, "sessions"), message: "fit check", ...shape });
|
||||
}, "", { noMcp, shape })]);
|
||||
// -p takes a message; offline with no key, pi stops before any model call.
|
||||
const pRun = run((s) => ["-p", ...seal, ...given(s), "fit check"], "", { noMcp });
|
||||
// A missing -e file stops the start. pi 0.85.1 loads the -e files in order and still loads the
|
||||
// one after the missing one, then exits 1 before session_start, so only session_start tells.
|
||||
const missingRuns = [["rpc", ["--mode", "rpc"], ask], ["-p", ["-p"], ""]].map(([mode, args, input]) =>
|
||||
[mode, run((s) => [...args, ...seal, "-e", join(s, "missing", "extension.ts"), ...given(s), ...(mode === "-p" ? ["fit check"] : [])], input, { noMcp })]);
|
||||
|
||||
const control = await controlRun;
|
||||
if (control.stopped) return refuse(`can't be checked: the start without the seal flags ${control.stopped}`);
|
||||
if (!control.answer.state) return refuse("can't be checked: it didn't answer get_state");
|
||||
if (!control.answer.commands) return refuse("can't be checked: it didn't answer get_commands");
|
||||
if (!control.explicit || control.prompt === null) return refuse("can't be checked: its -e extension didn't see the system prompt without the seal flags");
|
||||
// A kind counts only through a source outside the project, except the trusted project files
|
||||
// themselves: a project source can wait on project trust, and then --no-approve alone would keep
|
||||
// it out of the sealed runs and hide a seal flag of its kind that the binary ignores.
|
||||
const shown = new Set(control.seen.filter((s) => s.kind === "trusted project file" || !s.source.startsWith("project ")).map((s) => s.kind));
|
||||
const unshown = KINDS.filter((k) => (k !== "MCP server" || noMcp) && !shown.has(k));
|
||||
if (unshown.length) return refuse(`can't be checked: it didn't load a planted ${unshown.join(", ")} without the seal flags`);
|
||||
// -p answers no get_commands, so the -p runs see skills and prompt templates only through the -e
|
||||
// extension's command list, which must show them here.
|
||||
const listed = new Set(control.listed.filter((s) => !s.source.startsWith("project ")).map((s) => s.kind));
|
||||
const unlisted = ["skill", "prompt template"].filter((k) => !listed.has(k));
|
||||
if (unlisted.length) return refuse(`can't be checked: its -e extension didn't list a planted ${unlisted.join(", ")} without the seal flags`);
|
||||
|
||||
const rpc = await rpcSealed;
|
||||
if (rpc.stopped) return refuse(`can't be checked: the start with the seal flags ${rpc.stopped}`);
|
||||
if (!rpc.answer.state) return refuse("can't be checked: it didn't answer get_state with the seal flags on");
|
||||
if (!rpc.answer.commands) return refuse("can't be checked: it didn't answer get_commands with the seal flags on");
|
||||
if (!rpc.explicit) return refuse("didn't load an -e extension with the seal flags on");
|
||||
if (rpc.prompt === null) return refuse("can't be checked: its -e extension didn't see the system prompt with the seal flags on");
|
||||
if (!rpc.prompt.includes(GIVEN)) return refuse("didn't use the --system-prompt file with the seal flags on");
|
||||
if (rpc.seen.length) return refuse(`loaded a planted ${rpc.seen.map((s) => s.source).join(", ")} with the seal flags on`);
|
||||
|
||||
// Each loader flag on its own: with every other seal flag on, its kind must show.
|
||||
for (const [flag, kind, pending] of oneOut) {
|
||||
const r = await pending;
|
||||
const but = `with every seal flag but ${flag}`;
|
||||
if (r.stopped) return refuse(`can't be checked: the start ${but} ${r.stopped}`);
|
||||
if (!r.answer.state || !r.answer.commands) return refuse(`can't be checked: it didn't answer get_state and get_commands ${but}`);
|
||||
if (r.prompt === null) return refuse(`can't be checked: its -e extension didn't see the system prompt ${but}`);
|
||||
if (!r.seen.some((s) => s.kind === kind)) return refuse(`can't be checked: it didn't load a planted ${kind} ${but}`);
|
||||
const others = r.seen.filter((s) => s.kind !== kind && !(flag === "--no-extensions" && !noMcp && s.kind === "MCP server"));
|
||||
if (others.length) return refuse(`loaded a planted ${others.map((s) => s.source).join(", ")} ${but}`);
|
||||
}
|
||||
|
||||
for (const [shape, pending] of shaped) {
|
||||
const r = await pending;
|
||||
const name = shapeName(shape);
|
||||
if (r.stopped) return refuse(`can't be checked: the start ${name} ${r.stopped}`);
|
||||
if (r.prompt === null) return refuse(`can't be checked: its -e extension didn't see the system prompt ${name}`);
|
||||
if (!r.explicit || !r.second) return refuse(`didn't load every -e extension ${name}`);
|
||||
if (!r.prompt.includes(GIVEN)) return refuse(`didn't use the --system-prompt file ${name}`);
|
||||
if (shape.cont && r.session !== PLANTED_SESSION) return refuse(`can't be checked: it didn't resume the planted session with -c ${name}`);
|
||||
if (r.seen.length) return refuse(`loaded a planted ${r.seen.map((x) => x.source).join(", ")} with the seal flags ${name}`);
|
||||
}
|
||||
|
||||
const p = await pRun;
|
||||
if (p.stopped) return refuse(`can't be checked: a -p start with the seal flags ${p.stopped}`);
|
||||
if (p.prompt === null) return refuse("can't be checked: a -p start with the seal flags didn't run its -e extension");
|
||||
if (p.seen.length) return refuse(`loaded a planted ${p.seen.map((x) => x.source).join(", ")} with the seal flags on in -p`);
|
||||
|
||||
for (const [mode, pending] of missingRuns) {
|
||||
const r = await pending;
|
||||
if (r.stopped) return refuse(`can't be checked: a ${mode} start with a missing -e extension ${r.stopped}`);
|
||||
if (r.status === 0 || r.answer.state || r.prompt !== null) return refuse("starts with a missing -e extension");
|
||||
}
|
||||
return { ok: true, version, noMcp, digest };
|
||||
}
|
||||
|
||||
// Whether bwrap runs here, as sandbox.mjs's sandboxProblem asks, but as child processes the caller
|
||||
// awaits: the system part, the network unshared, an empty environment, then /usr/bin/true. And,
|
||||
// once per check, whether unshare's outer layer runs (checkArgv in sandbox.mjs): first on its own,
|
||||
// then with bwrap inside it. Returns { problem } when the check can't run, naming the tool that
|
||||
// failed without its own text, else { outer, why }: outer is the unshare to pass checkArgv, or null
|
||||
// when the layer can't run here, and why then names unshare and how it failed. A missing,
|
||||
// too old or refused unshare drops only that layer and is no refusal: bwrap's sandbox is the same
|
||||
// either way. The probes run in a scratch directory of their own and name it on their command
|
||||
// line, so a probe process a killed owner leaves is one the next sweep finds.
|
||||
async function sandboxLayers({ bwrap, unshare, node }) {
|
||||
if (!existsSync(bwrap)) return { problem: "the sandbox (bwrap) is missing" };
|
||||
if (!existsSync(SETPRIV)) return { problem: "the sandbox's parent-death tool (setpriv) is missing" };
|
||||
const scratch = mkdtempSync(join(tmpdir(), scratchPrefix()));
|
||||
let stopped = false;
|
||||
try {
|
||||
const probe = async (argv) => {
|
||||
const r = await spawned(argv, { input: "", timeout: 10000, signal: new AbortController().signal });
|
||||
stopped ||= Boolean(r.stopped);
|
||||
return r.status === 0;
|
||||
};
|
||||
const sandboxed = (outer) => checkArgv([{ kind: "ro", src: scratch }], ["/usr/bin/true"], { chdir: scratch, node, bwrap, unshare: outer });
|
||||
let why = "unshare is missing";
|
||||
if (existsSync(unshare)) {
|
||||
if (!await probe(outerArgv(["/usr/bin/true", scratch], { unshare }))) why = "unshare failed";
|
||||
else if (await probe(sandboxed(unshare))) return { outer: unshare, why: null };
|
||||
else why = "unshare failed with bwrap inside it";
|
||||
}
|
||||
if (!await probe(sandboxed(null))) return { problem: "the sandbox (bwrap) failed" };
|
||||
return { outer: null, why };
|
||||
} finally {
|
||||
// As for a run (once, in piFit): a probe killed at its timeout may leave what names its directory.
|
||||
if (stopped) stopNaming([scratch], process.getuid());
|
||||
rmSync(scratch, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
// The binary, inside the sandbox: the system part, the found package where a session sees it, the
|
||||
// scratch directory read-write, and its tmp/ as /tmp, as a session has it. The environment is
|
||||
// fitEnv's. The binary starts through /bin/sh, as the adapter starts it, so it also gets the
|
||||
// variables the shell sets. The run is a child process the caller awaits; nothing here blocks.
|
||||
// stopped: why the run was killed ("timed out", "printed more than 4 MB", "was stopped"), or null.
|
||||
function runIn(found, { bwrap, unshare, node, scratch, env, args, input, timeout, signal }) {
|
||||
const list = [
|
||||
{ kind: "ro", src: found.root, ...(found.dest ? { dest: found.dest } : {}) },
|
||||
{ kind: "rw", src: scratch },
|
||||
{ kind: "rw", src: join(scratch, "tmp"), dest: "/tmp" },
|
||||
];
|
||||
return spawned(checkArgv(list, ["/bin/sh", "-c", 'exec "$0" "$@"', found.view, ...args], { env, chdir: join(scratch, "project"), node, bwrap, unshare }), { input, timeout, signal });
|
||||
}
|
||||
|
||||
// One child process with an empty environment, awaited: its exit status, its stdout, and why it was
|
||||
// killed, or null. It settles PIPE_GRACE after the child exits or is killed even if its pipes stay
|
||||
// open: a process left behind can hold them (a kill of bwrap's outer process while its child still
|
||||
// sets up leaves that child waiting until the pid namespace checkArgv makes is killed, or, without
|
||||
// that layer, until the next check's sweep), and no wait here is unbounded.
|
||||
function spawned(argv, { input, timeout, signal }) {
|
||||
return new Promise((resolve) => {
|
||||
const out = [];
|
||||
const size = { stdout: 0, stderr: 0 };
|
||||
let stopped = null;
|
||||
let done = false;
|
||||
let child;
|
||||
let timer = null;
|
||||
let grace = null;
|
||||
let exited = null;
|
||||
const finish = (status, sig) => {
|
||||
if (done) return;
|
||||
done = true;
|
||||
clearTimeout(timer);
|
||||
clearTimeout(grace);
|
||||
child?.stdout?.destroy();
|
||||
child?.stderr?.destroy();
|
||||
signal.removeEventListener("abort", onAbort);
|
||||
if (!stopped && sig === "SIGKILL") stopped = "timed out";
|
||||
resolve({ status, stdout: Buffer.concat(out).toString("utf8"), stopped });
|
||||
};
|
||||
const settleSoon = () => { if (!grace) grace = setTimeout(() => finish(exited?.status ?? null, exited?.sig ?? "SIGKILL"), PIPE_GRACE); };
|
||||
const kill = (why) => {
|
||||
if (!stopped) stopped = why;
|
||||
try { child?.kill("SIGKILL"); } catch {}
|
||||
settleSoon();
|
||||
};
|
||||
const onAbort = () => kill("was stopped");
|
||||
try {
|
||||
child = spawn(argv[0], argv.slice(1), { env: {}, stdio: ["pipe", "pipe", "pipe"] });
|
||||
} catch {
|
||||
finish(null, null);
|
||||
return;
|
||||
}
|
||||
timer = setTimeout(() => kill("timed out"), timeout);
|
||||
if (signal.aborted) onAbort();
|
||||
else signal.addEventListener("abort", onAbort, { once: true });
|
||||
const count = (stream) => (chunk) => {
|
||||
size[stream] += chunk.length;
|
||||
if (size[stream] > OUTPUT_MAX) kill(`printed more than ${OUTPUT_MAX / 1024 / 1024} MB`);
|
||||
else if (stream === "stdout") out.push(chunk);
|
||||
};
|
||||
child.stdout.on("data", count("stdout"));
|
||||
child.stderr.on("data", count("stderr"));
|
||||
child.stdin.on("error", () => {});
|
||||
child.on("error", () => finish(null, null));
|
||||
child.on("exit", (status, sig) => { exited = { status, sig }; settleSoon(); });
|
||||
child.on("close", (status, sig) => finish(status, sig));
|
||||
child.stdin.end(input);
|
||||
});
|
||||
}
|
||||
|
||||
// A fit run's environment: what a bus session's pi gets, built the same way from host, the
|
||||
// environment of the process sessions launch from (the bus's own). The launcher passes host's
|
||||
// ENV_ALLOW names that are set through sessionEnv (less the provider variables here, since no key
|
||||
// is passed: no model is called), with host's PATH behind the repository's .bin; the sandbox sets
|
||||
// sessionSetenv's (HOME is the scratch home, so pi's agent directory is $HOME/.pi/agent); the
|
||||
// runner adds adapterEnv's with the pi module's harnessEnv, and MOSAIC_REQUEST for each turn. No
|
||||
// name is added that a session in that process would lack: a bus started by its unit has no TERM,
|
||||
// TZ or LC_ALL, and then no fit run has them either. shape: a session-shaped run's branches (its
|
||||
// tool list, thinking level and --mode json, which a proxy session's first turn takes with the
|
||||
// model event monitor's variables), else none: no tools, no thinking, one -e. noMcp: --help lists
|
||||
// --no-mcp. pi-fit.test.mjs fails when these names, or the values the code sets, differ from a bus
|
||||
// session's, for a login shell's host and a unit's.
|
||||
export function fitEnv(scratch, { view, noMcp = false, shape = null, host = process.env }) {
|
||||
const runner = { ...sessionEnv(withoutProviders(host), "fit"), ...sessionSetenv(scratch, { business: "fit", role: "fit" }) };
|
||||
const { tools = "", thinking = "", json = false } = shape ?? {};
|
||||
const session = { provider: SESSION_SHAPE.provider, model: SESSION_SHAPE.model, thinking };
|
||||
const extensions = [join(scratch, "explicit", "fit.ts"), ...(shape ? [join(scratch, "explicit", "second.ts")] : [])];
|
||||
const env = adapterEnv({
|
||||
...session,
|
||||
bundle: { prompt: join(scratch, "prompt.md"), policy: join(scratch, "policy.json"), tools: join(scratch, "tools.json") },
|
||||
workspace: join(scratch, "project"), sessionDir: join(scratch, "sessions"), toolSocket: join(scratch, "tools.sock"), turnMarker: join(scratch, "turn"),
|
||||
harnessEnv: harnessEnv({ bin: view, noMcp, tools: tools ? tools.split(",") : [], extensions, session }),
|
||||
runDir: scratch, proxyFirstTurn: json,
|
||||
}, runner);
|
||||
return { ...env, MOSAIC_REQUEST: "fit check" };
|
||||
}
|
||||
|
||||
// The options one help line lists in its option column: a line that starts with "-" (after its
|
||||
// indent), up to the first run of two spaces or a tab, split at commas; the first word of each
|
||||
// part. " --extension, -e <path> Load an extension" lists --extension and -e. A flag named in a
|
||||
// sentence is not listed.
|
||||
function optionsIn(line) {
|
||||
const t = line.trim();
|
||||
if (!t.startsWith("-")) return [];
|
||||
return t.split(/ {2,}|\t/)[0].split(",").map((part) => part.trim().split(/[ =<[]/)[0]).filter((o) => /^--?[A-Za-z0-9]/.test(o));
|
||||
}
|
||||
const word = (line, w) => line.split(/[^A-Za-z0-9-]+/).includes(w);
|
||||
|
||||
// The version a refusal line may carry: a version-shaped first line, else none. Anything else the
|
||||
// binary prints stays out of the line.
|
||||
function versionLabel(stdout) {
|
||||
const first = String(stdout).split("\n")[0].trim();
|
||||
return /^v?[0-9]+(\.[0-9]+){0,3}([-+][0-9A-Za-z.-]{1,32})?$/.test(first) ? first : null;
|
||||
}
|
||||
|
||||
// The rpc answers in the output: whether get_state succeeded, and the command names get_commands
|
||||
// listed, or null when it didn't answer with a { commands: [...] } list.
|
||||
function answered(stdout) {
|
||||
let state = false;
|
||||
let commands = null;
|
||||
for (const l of String(stdout).split("\n")) {
|
||||
let m;
|
||||
try { m = JSON.parse(l); } catch { continue; }
|
||||
if (!m || m.type !== "response" || m.success !== true) continue;
|
||||
if (m.id === "fit-state" && m.command === "get_state" && m.data && typeof m.data === "object") state = true;
|
||||
if (m.id === "fit-commands" && m.command === "get_commands" && Array.isArray(m.data?.commands)) {
|
||||
commands = m.data.commands.filter((c) => typeof c?.name === "string").map((c) => c.name);
|
||||
}
|
||||
}
|
||||
return { state, commands };
|
||||
}
|
||||
|
||||
// The planted sources, each with the kind the control must show. Each extension and each MCP
|
||||
// server touches its own marker; each skill and prompt template has a name get_commands lists;
|
||||
// each context and system prompt file holds a word the -e extension's view of the system prompt
|
||||
// shows. "user" sources sit in the agent directory, $HOME/.pi/agent: no fit run sets
|
||||
// PI_CODING_AGENT_DIR, as no bus session does. "settings" sources are listed by a settings.json;
|
||||
// "package" sources come from a local package a settings.json lists. "parent" is a directory above
|
||||
// the project.
|
||||
const KINDS = ["extension", "MCP server", "skill", "prompt template", "context file", "trusted project file"];
|
||||
const MARKED = {
|
||||
"user extension": "extension", "user settings extension": "extension", "user package extension": "extension",
|
||||
"project extension": "extension", "project settings extension": "extension", "project package extension": "extension",
|
||||
"user mcp.json": "MCP server", "project mcp.json": "MCP server", "project .mcp.json": "MCP server",
|
||||
};
|
||||
const NAMED = {
|
||||
"fit-user-skill": ["user skill", "skill"], "fit-user-set-skill": ["user settings skill", "skill"], "fit-user-pkg-skill": ["user package skill", "skill"],
|
||||
"fit-project-skill": ["project skill", "skill"], "fit-project-set-skill": ["project settings skill", "skill"],
|
||||
"fit-project-pkg-skill": ["project package skill", "skill"], "fit-agents-skill": ["project .agents skill", "skill"], "fit-home-skill": ["home .agents skill", "skill"],
|
||||
"fit-user-prompt": ["user prompt template", "prompt template"], "fit-user-set-prompt": ["user settings prompt template", "prompt template"],
|
||||
"fit-user-pkg-prompt": ["user package prompt template", "prompt template"],
|
||||
"fit-project-prompt": ["project prompt template", "prompt template"], "fit-project-set-prompt": ["project settings prompt template", "prompt template"],
|
||||
"fit-project-pkg-prompt": ["project package prompt template", "prompt template"],
|
||||
};
|
||||
// Planted file (under the scratch directory), the word it holds, the source, the kind. A project
|
||||
// SYSTEM.md or APPEND_SYSTEM.md loads only in a trusted project: the saved trust makes it trusted,
|
||||
// and only --no-approve undoes that with the seal flags on.
|
||||
const TEXTS = [
|
||||
["home/.pi/agent/SYSTEM.md", "FITUSERSYSTEM", "user SYSTEM.md", "context file"],
|
||||
["home/.pi/agent/AGENTS.md", "FITUSERAGENTS", "user AGENTS.md", "context file"],
|
||||
["project/.pi/SYSTEM.md", "FITPROJECTSYSTEM", "project SYSTEM.md", "trusted project file"],
|
||||
["project/.pi/APPEND_SYSTEM.md", "FITPROJECTAPPEND", "project APPEND_SYSTEM.md", "trusted project file"],
|
||||
["project/AGENTS.md", "FITPROJECTAGENTS", "project AGENTS.md", "context file"],
|
||||
["project/CLAUDE.md", "FITPROJECTCLAUDE", "project CLAUDE.md", "context file"],
|
||||
["CLAUDE.md", "FITPARENTCLAUDE", "parent CLAUDE.md", "context file"],
|
||||
];
|
||||
// The --system-prompt file's word, which the sealed runs must show.
|
||||
const GIVEN = "FITGIVENPROMPT";
|
||||
// The -e extension every run passes, which must load, and the second one the session-shaped runs
|
||||
// pass after it.
|
||||
const EXPLICIT = "explicit extension";
|
||||
const SECOND = "second explicit extension";
|
||||
// The id of the session a -c run must resume.
|
||||
const PLANTED_SESSION = "fit-planted-session";
|
||||
const markerName = (source) => source.replace(/[^a-z]/g, "-");
|
||||
const marked = (scratch, source) => { try { return readdirSync(join(scratch, "marks")).includes(markerName(source)); } catch { return false; } };
|
||||
// What the -e extension saw at session_start ({ prompt, commands, session }), or null when it wrote
|
||||
// nothing that parses into that shape.
|
||||
function started(scratch) {
|
||||
let m;
|
||||
try { m = JSON.parse(readFileSync(join(scratch, "marks", "start.json"), "utf8")); } catch { return null; }
|
||||
if (!m || typeof m.prompt !== "string" || !Array.isArray(m.commands)) return null;
|
||||
return { prompt: m.prompt, commands: m.commands.filter((c) => typeof c === "string"), session: typeof m.session === "string" ? m.session : null };
|
||||
}
|
||||
// The planted skills and prompt templates among command names, as { source, kind }.
|
||||
const named = (names) => Object.entries(NAMED).filter(([name]) => names.some((c) => c === name || c.endsWith(`:${name}`))).map(([, [source, kind]]) => ({ source, kind }));
|
||||
|
||||
function plant(scratch) {
|
||||
const marks = join(scratch, "marks");
|
||||
const put = (path, text) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, text); };
|
||||
const ext = (source) => `import { writeFileSync } from "node:fs";\nexport default function (): void { writeFileSync(${JSON.stringify(join(marks, markerName(source)))}, ""); }\n`;
|
||||
const mcp = (source) => JSON.stringify({ mcpServers: { fit: { command: "/bin/sh", args: ["-c", `: > ${join(marks, markerName(source))}`] } } });
|
||||
const skill = (name) => `---\nname: ${name}\ndescription: a planted skill\n---\nA planted skill.\n`;
|
||||
const prompt = "A planted prompt template.\n";
|
||||
const agent = join(scratch, "home", ".pi", "agent");
|
||||
const project = join(scratch, "project");
|
||||
mkdirSync(marks, { recursive: true });
|
||||
mkdirSync(join(scratch, "tmp"), { recursive: true });
|
||||
mkdirSync(project, { recursive: true });
|
||||
// The session-shaped runs' --session-dir, made as the adapter makes it.
|
||||
mkdirSync(join(scratch, "sessions"), { recursive: true });
|
||||
// Each settings.json lists an extension, a skill directory, a prompt template and a local
|
||||
// package holding one of each.
|
||||
const listed = (who) => {
|
||||
const dir = join(scratch, "listed", who);
|
||||
put(join(dir, "fit.ts"), ext(`${who} settings extension`));
|
||||
put(join(dir, `fit-${who}-set-skill`, "SKILL.md"), skill(`fit-${who}-set-skill`));
|
||||
put(join(dir, `fit-${who}-set-prompt.md`), prompt);
|
||||
const pkg = join(dir, "package");
|
||||
put(join(pkg, "package.json"), JSON.stringify({ name: `fit-${who}-package`, version: "1.0.0" }));
|
||||
put(join(pkg, "extensions", "fit.ts"), ext(`${who} package extension`));
|
||||
put(join(pkg, "skills", `fit-${who}-pkg-skill`, "SKILL.md"), skill(`fit-${who}-pkg-skill`));
|
||||
put(join(pkg, "prompts", `fit-${who}-pkg-prompt.md`), prompt);
|
||||
return { extensions: [join(dir, "fit.ts")], skills: [join(dir, `fit-${who}-set-skill`)], prompts: [join(dir, `fit-${who}-set-prompt.md`)], packages: [pkg] };
|
||||
};
|
||||
// A saved trust for the project, so the control loads its trust-gated files without --approve.
|
||||
put(join(agent, "settings.json"), JSON.stringify({ ...listed("user"), defaultProjectTrust: "always" }));
|
||||
put(join(agent, "trust.json"), JSON.stringify({ [realpathSync(project)]: true }));
|
||||
put(join(agent, "extensions", "fit.ts"), ext("user extension"));
|
||||
put(join(agent, "mcp.json"), mcp("user mcp.json"));
|
||||
put(join(agent, "skills", "fit-user-skill", "SKILL.md"), skill("fit-user-skill"));
|
||||
put(join(agent, "prompts", "fit-user-prompt.md"), prompt);
|
||||
put(join(project, ".pi", "settings.json"), JSON.stringify(listed("project")));
|
||||
put(join(project, ".pi", "extensions", "fit.ts"), ext("project extension"));
|
||||
put(join(project, ".pi", "mcp.json"), mcp("project mcp.json"));
|
||||
put(join(project, ".mcp.json"), mcp("project .mcp.json"));
|
||||
put(join(project, ".pi", "skills", "fit-project-skill", "SKILL.md"), skill("fit-project-skill"));
|
||||
put(join(project, ".agents", "skills", "fit-agents-skill", "SKILL.md"), skill("fit-agents-skill"));
|
||||
put(join(project, ".pi", "prompts", "fit-project-prompt.md"), prompt);
|
||||
put(join(scratch, "home", ".agents", "skills", "fit-home-skill", "SKILL.md"), skill("fit-home-skill"));
|
||||
for (const [file, text] of TEXTS) put(join(scratch, file), `${text}\n`);
|
||||
put(join(scratch, "explicit", "fit.ts"), `import { writeFileSync } from "node:fs";\nexport default function (pi: any): void {\n writeFileSync(${JSON.stringify(join(marks, markerName(EXPLICIT)))}, "");\n pi.on("session_start", (_event: any, ctx: any) => { writeFileSync(${JSON.stringify(join(marks, "start.json"))}, JSON.stringify({ prompt: ctx.getSystemPrompt(), commands: pi.getCommands().map((c: any) => c.name), session: ctx.sessionManager.getSessionId() })); });\n}\n`);
|
||||
put(join(scratch, "explicit", "second.ts"), ext(SECOND));
|
||||
put(join(scratch, "prompt.md"), `${GIVEN}\n`);
|
||||
}
|
||||
|
||||
// A stored session for the project, as pi 0.85.1 writes one: a header whose cwd is the project's
|
||||
// real path (pi's -c takes only a session for its own cwd) and one user message.
|
||||
function plantSession(scratch) {
|
||||
const at = new Date().toISOString();
|
||||
writeFileSync(join(scratch, "sessions", `${PLANTED_SESSION}.jsonl`), [
|
||||
{ type: "session", version: 3, id: PLANTED_SESSION, timestamp: at, cwd: realpathSync(join(scratch, "project")) },
|
||||
{ type: "message", id: "f17e0001", parentId: null, timestamp: at, message: { role: "user", content: [{ type: "text", text: "an earlier turn" }], timestamp: Date.now() } },
|
||||
].map((e) => `${JSON.stringify(e)}\n`).join(""));
|
||||
}
|
||||
|
||||
// The planted sources a run loaded, as { source, kind }: markers present, planted names among the
|
||||
// command names, and planted words in the system prompt the -e extension saw.
|
||||
function seen(scratch, commands, start) {
|
||||
let marks = [];
|
||||
try { marks = readdirSync(join(scratch, "marks")); } catch { marks = []; }
|
||||
const out = Object.entries(MARKED).filter(([s]) => marks.includes(markerName(s))).map(([source, kind]) => ({ source, kind }));
|
||||
out.push(...named(commands));
|
||||
const text = start?.prompt ?? "";
|
||||
for (const [, word, source, kind] of TEXTS) if (text.includes(word)) out.push({ source, kind });
|
||||
return out;
|
||||
}
|
||||
|
||||
// sha256 over the sorted (path, sha256) list of the package's package.json, every regular file
|
||||
// under dist/bundle/ (design section 4), every regular file in the directory tree that holds the
|
||||
// binary's real file, so a bin outside dist/bundle/ can't import a file the digest skips, and npm's
|
||||
// lock files for a copy mounted with its node_modules. A symlink there is read through.
|
||||
function filesDigest(found) {
|
||||
const pkg = found.pkg;
|
||||
const bin = realpathSync(found.bin);
|
||||
const files = new Set([join(pkg, "package.json"), bin]);
|
||||
const walk = (dir) => {
|
||||
let entries;
|
||||
try { entries = readdirSync(dir, { withFileTypes: true }); } catch (e) { if (e.code === "ENOENT") return; throw e; }
|
||||
for (const e of entries) {
|
||||
const p = join(dir, e.name);
|
||||
if (e.isDirectory()) walk(p);
|
||||
else if (e.isFile() || (e.isSymbolicLink() && lstatSync(realpathSync(p)).isFile())) files.add(p);
|
||||
if (files.size > DIGEST_FILES_MAX) throw new Error("too many files");
|
||||
}
|
||||
};
|
||||
walk(join(pkg, "dist", "bundle"));
|
||||
const binDir = dirname(bin);
|
||||
if (binDir !== pkg && binDir.startsWith(`${pkg}/`)) walk(binDir);
|
||||
// A copy mounted with the node_modules it sits in imports packages beside it: npm's lock files
|
||||
// there stand for them.
|
||||
if (found.root !== pkg) for (const f of [join(found.root, ".package-lock.json"), join(dirname(found.root), "package-lock.json")]) {
|
||||
try { lstatSync(f); } catch (e) { if (e.code === "ENOENT") continue; throw e; }
|
||||
files.add(f);
|
||||
}
|
||||
const h = createHash("sha256");
|
||||
for (const f of [...files].sort()) {
|
||||
h.update(relative(pkg, f)).update("\0").update(createHash("sha256").update(readFileSync(f)).digest("hex")).update("\n");
|
||||
}
|
||||
return h.digest("hex");
|
||||
}
|
||||
@@ -4,7 +4,8 @@ import { createHash } from "node:crypto";
|
||||
import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
import { BundleError, buildBundle, sessionModel, SOURCES } from "../src/bundle.mjs";
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch } from "./helpers.mjs";
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch, harnessReady } from "./helpers.mjs";
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
import { decide } from "../src/gate.mjs";
|
||||
import { resolveInstance, validateBusinessDocument } from "../../organization/src/index.mjs";
|
||||
import { businessDoc, REPO_ROLES, systemFor } from "../../organization/tests/helpers.mjs";
|
||||
|
||||
@@ -12,7 +12,8 @@ import { join, relative } from "node:path";
|
||||
import { buildBundle, PERSONA_CHARS } from "../src/bundle.mjs";
|
||||
import { decide } from "../src/gate.mjs";
|
||||
import { adapterEnv } from "../src/runner.mjs";
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch } from "./helpers.mjs";
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch, harnessReady } from "./helpers.mjs";
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
|
||||
const sha = (data) => createHash("sha256").update(data).digest("hex");
|
||||
const CREATIVE = ["companion", "ideas", "research", "proofreader", "fact-checker", "continuity"];
|
||||
@@ -177,7 +178,8 @@ function runAdapter(t, harness, b, { prompt = b.files.prompt, cwd } = {}) {
|
||||
writeFileSync(cli, '#!/bin/sh\nprintf "%s\\0" "$@" > "$ARGV_OUT"\necho \'{"type":"result","subtype":"success","result":"ok"}\'\n');
|
||||
chmodSync(cli, 0o755);
|
||||
const s = { harness, provider: harness === "pi" ? "probe" : null, model: "claude-sonnet-5-5", workspace: b.workspace, sessionDir: join(b.dir, "session"), toolSocket: join(b.dir, "tools.sock"), turnMarker: join(b.dir, "turn.done"), bundle: { ...b.files, prompt }, harnessEnv: b.env };
|
||||
const env = { ...adapterEnv(s, { PATH: `${bin}:/usr/bin:/bin`, HOME: join(b.dir, "home") }), ARGV_OUT: join(b.dir, "argv"), MOSAIC_REQUEST: "x" };
|
||||
// #1873 S2: the pi adapter runs MOSAIC_PI_BIN, which the bundle sets to the pi it found.
|
||||
const env = { ...adapterEnv(s, { PATH: `${bin}:/usr/bin:/bin`, HOME: join(b.dir, "home") }), ARGV_OUT: join(b.dir, "argv"), MOSAIC_REQUEST: "x", ...(harness === "pi" ? { MOSAIC_PI_BIN: cli } : {}) };
|
||||
const r = spawnSync("/bin/sh", [join(REPO, "adapters", harness === "pi" ? "pi" : "claude", "adapter.sh")], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], env });
|
||||
const argv = existsSync(env.ARGV_OUT) ? readFileSync(env.ARGV_OUT, "utf8").split("\0") : null;
|
||||
return { ...r, argv };
|
||||
|
||||
@@ -31,6 +31,12 @@ async function harnessModule(name) {
|
||||
return loader.modules("harness")[0];
|
||||
}
|
||||
export const HARNESS = Object.freeze({ pi: await harnessModule("pi"), "claude-code": await harnessModule("claude-code") });
|
||||
// #1873 re-check 7: a module whose fit check runs async has ready(), which the launcher's preflight
|
||||
// stands for. A test that calls buildBundle directly awaits this first. It is not run on import:
|
||||
// request-agent.mjs imports this file in every tool-call process, which builds no bundle.
|
||||
export async function harnessReady() {
|
||||
for (const mod of Object.values(HARNESS)) if (typeof mod.ready === "function") await mod.ready();
|
||||
}
|
||||
|
||||
// A session's route is its own three vars (row 65); a role the test doesn't route runs pi on the
|
||||
// test system's old execution.model at thinking high, so the bundle tests keep their models.
|
||||
|
||||
@@ -6,7 +6,8 @@ import { join } from 'node:path';
|
||||
import { typedTools } from '../src/tools.mjs';
|
||||
import { buildBundle } from '../src/bundle.mjs';
|
||||
import { TYPES } from '../../library/src/mapping.mjs';
|
||||
import { HARNESS, REPO_SKILLS, resolvedFor, scratch } from './helpers.mjs';
|
||||
import { HARNESS, REPO_SKILLS, resolvedFor, scratch, harnessReady } from './helpers.mjs';
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
|
||||
const LOOKUPS = ['library_find', 'library_get', 'library_search', 'library_manuscript', 'library_universe'];
|
||||
const CREATIVE = ['companion', 'research', 'ideas', 'proofreader', 'fact-checker', 'continuity'];
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -10,7 +10,8 @@ import { join } from "node:path";
|
||||
import { buildBundle } from "../src/bundle.mjs";
|
||||
import { adapterEnv, unslopCounts, unslopLog, unslopNotes } from "../src/runner.mjs";
|
||||
import { REPLY_CAP } from "../src/tools.mjs";
|
||||
import { fakeToolSocket, HARNESS, mockAnthropic, REPO, REPO_SKILLS, resolvedFor, scratch } from "./helpers.mjs";
|
||||
import { fakeToolSocket, HARNESS, mockAnthropic, REPO, REPO_SKILLS, resolvedFor, scratch, harnessReady } from "./helpers.mjs";
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
|
||||
const ADAPTER = join(REPO, "adapters", "pi", "adapter.sh");
|
||||
|
||||
|
||||
@@ -0,0 +1,241 @@
|
||||
// #1873 pi-unpin S3: a stand-in pi that the fit check (src/pi-fit.mjs) can run. It is one sh
|
||||
// script with its knobs written into it, because the fit check runs it with an empty
|
||||
// environment. Put it at dist/bundle/cli.js in a package named @earendil-works/pi-coding-agent.
|
||||
//
|
||||
// What it does, in order:
|
||||
// --version prints `version` (default 9.9.9), or exits `versionExit` when that is set, or
|
||||
// hangs for a minute with `versionHang`
|
||||
// $ARGV_OUT set: a session. Writes its argv there, prints `sessionOut`, exits 0. This part is
|
||||
// sh, so it runs in a sandbox that holds no node.
|
||||
// otherwise runs node (the absolute path, since the fit check gives it no PATH) on the rest:
|
||||
// --help lists every flag the fit check wants, less `dropFlags`, plus `extraFlags`, then
|
||||
// the `helpProse` lines as they are
|
||||
// -e <file> a file that doesn't exist stops it with exit 1, unless `missingExtOk` is true or
|
||||
// names the mode ("rpc" or "print") it starts in anyway
|
||||
// --mode rpc loads the planted sources the way pi 0.85.1 finds them, honouring the seal flags,
|
||||
// or -p runs each -e extension's session_start (one that writes JSON.stringify(...) gets
|
||||
// the prompt this stand-in builds, the command names and the session id), then
|
||||
// answers get_state and get_commands
|
||||
// (rpc), or prints `sessionOut` and exits 0 (-p).
|
||||
// An -e file that exists loads even with --no-extensions, unless `dropExplicit`
|
||||
// (then it loads only without --no-extensions). `printNoStart`: -p runs no
|
||||
// session_start. MCP servers stay out with --no-mcp when `extraFlags` lists it, else
|
||||
// with --no-extensions.
|
||||
// `ignoreAll` loads no planted source. `sealLeak` lists kinds (extensions, mcp,
|
||||
// skills, prompts, context, approve) loaded even when their seal flag is on.
|
||||
// `ignoreSystemPrompt` drops the --system-prompt file. `ignoreAppend` drops every
|
||||
// APPEND_SYSTEM.md. `sysReplacesAll`: a --system-prompt file also drops every
|
||||
// APPEND_SYSTEM.md and context file. `trustExtOnly`: the only extensions are the
|
||||
// project's .pi/extensions, loaded in a trusted project whatever --no-extensions
|
||||
// says. `trustCtxOnly`: the only context file is the project's AGENTS.md, loaded the
|
||||
// same way whatever --no-context-files says. `flood`: prints 8 MB first.
|
||||
// `hideWhen`: a cue, a flag or "order" (--offline before --no-session). With the cue
|
||||
// it loads no planted source; without it, every kind even with its seal flag on.
|
||||
// `standIn`: [flag, other]: it ignores flag, and other keeps flag's kind out instead.
|
||||
// `remember`: the first run in a scratch directory (it leaves a marker beside the
|
||||
// -e file's directory) loads every kind whatever the seal flags; a later run loads
|
||||
// none. `needs`: a flag the loader flags work only with; without it they do
|
||||
// nothing. `leakWithout`: flags; when any of them is absent, every kind loads.
|
||||
// `leakWith`: flags; when all of them are given, every kind loads (with
|
||||
// `leakWithout` too, both must hold). `mcpAlso`: a flag that keeps MCP servers out
|
||||
// as well as their own flag does. `leakNoAgentDir`: every kind loads when
|
||||
// PI_CODING_AGENT_DIR is unset, as in a bus session. `leakNoVar`: names; every
|
||||
// kind loads when any of them is unset (TERM, TZ, LC_ALL in a unit-started bus).
|
||||
// `leakNoMatch`: with -c, every
|
||||
// kind loads when no .jsonl in --session-dir names the working directory.
|
||||
// `leakEnv`: { json, other }, the variable names a run with --mode json and any
|
||||
// other run should get; every kind loads when the environment holds a name not in
|
||||
// the list or lacks one, apart from the names /bin/sh sets (PWD, OLDPWD, SHLVL, _).
|
||||
// An -e extension that writes JSON.stringify({...}) at session_start gets the
|
||||
// prompt, the command names, the session id (with -c, the id in the header of a
|
||||
// .jsonl in --session-dir whose cwd is the working directory, else a new one) and
|
||||
// the --thinking level (else "medium"). `noResume`: -c always starts a new
|
||||
// session. `oneExt`: only the first -e loads. `extNoCommands`: the extension sees
|
||||
// no commands.
|
||||
// `commands` "fail" answers get_commands with success false; "list" answers
|
||||
// with a bare list.
|
||||
// otherwise a session with no $ARGV_OUT: prints `sessionOut` and exits 0.
|
||||
//
|
||||
// Trust, as pi 0.85.1 has it: the project is trusted with --approve, or with a saved trust and
|
||||
// no --no-approve. Only the project SYSTEM.md and APPEND_SYSTEM.md wait on it here. The user
|
||||
// APPEND_SYSTEM.md is appended whatever the flags, as 0.85.1 does when the project has none.
|
||||
import { FIT_FLAGS } from "../src/pi-fit.mjs";
|
||||
|
||||
const BODY = String.raw`
|
||||
const fs = require("node:fs");
|
||||
const path = require("node:path");
|
||||
const cp = require("node:child_process");
|
||||
const argv = process.argv.slice(1);
|
||||
const has = (f) => argv.includes(f);
|
||||
const val = (f) => { const i = argv.indexOf(f); return i === -1 ? undefined : argv[i + 1]; };
|
||||
if (argv[0] === "--help") {
|
||||
const drop = new Set(K.dropFlags || []);
|
||||
const lines = ["Usage: pi [options] [messages...]", "", "Options:"];
|
||||
for (const f of FLAGS) {
|
||||
if (drop.has(f)) continue;
|
||||
if (f === "--mode") lines.push(" --mode <mode> Output mode: " + (K.modes || ["text", "json", "rpc"]).join(", "));
|
||||
else if (f === "--thinking") lines.push(" --thinking <level> Thinking level: " + (K.levels || ["off", "minimal", "low", "medium", "high", "xhigh", "max"]).join(", "));
|
||||
else lines.push(" " + f);
|
||||
}
|
||||
for (const f of K.extraFlags || []) lines.push(" " + f);
|
||||
for (const l of K.helpProse || []) lines.push(l);
|
||||
process.stdout.write(lines.join("\n") + "\n");
|
||||
process.exit(0);
|
||||
}
|
||||
const rpc = val("--mode") === "rpc";
|
||||
const print = !rpc && has("-p");
|
||||
const startsAnyway = K.missingExtOk === true || (rpc && K.missingExtOk === "rpc") || (print && K.missingExtOk === "print");
|
||||
for (let i = 0; i < argv.length; i++) {
|
||||
if (argv[i] === "-e" && !fs.existsSync(argv[i + 1]) && !startsAnyway) {
|
||||
process.stderr.write("Failed to load extension: it does not exist\n");
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
if (rpc || print) {
|
||||
if (K.flood) {
|
||||
const chunk = Buffer.alloc(1024 * 1024, "x");
|
||||
for (let n = 0; n < 8; n++) for (let off = 0; off < chunk.length;) {
|
||||
try { off += fs.writeSync(1, chunk, off); } catch (e) { if (e.code !== "EAGAIN") throw e; }
|
||||
}
|
||||
}
|
||||
const ALL = ["extensions", "mcp", "skills", "prompts", "context", "approve"];
|
||||
// The id in the header of the last .jsonl in dir whose cwd is the working directory, or null.
|
||||
const storedFor = (dir) => {
|
||||
let id = null;
|
||||
if (dir) for (const n of (() => { try { return fs.readdirSync(dir); } catch { return []; } })()) {
|
||||
if (!n.endsWith(".jsonl")) continue;
|
||||
let h = null;
|
||||
try { h = JSON.parse(fs.readFileSync(path.join(dir, n), "utf8").split("\n")[0]); } catch { h = null; }
|
||||
if (h && h.type === "session" && h.cwd === process.cwd()) id = h.id;
|
||||
}
|
||||
return id;
|
||||
};
|
||||
let ignoreAll = K.ignoreAll;
|
||||
let leak = new Set(K.sealLeak || []);
|
||||
if (K.hideWhen) {
|
||||
const cued = K.hideWhen === "order" ? argv.indexOf("--offline") !== -1 && argv.indexOf("--offline") < argv.indexOf("--no-session") : has(K.hideWhen);
|
||||
if (cued) ignoreAll = true;
|
||||
else leak = new Set(ALL);
|
||||
}
|
||||
if (K.remember) {
|
||||
const marker = path.join(path.dirname(path.dirname(val("-e"))), "seen-before");
|
||||
if (fs.existsSync(marker)) ignoreAll = true;
|
||||
else { fs.writeFileSync(marker, ""); leak = new Set(ALL); }
|
||||
}
|
||||
if ((K.leakWith || K.leakWithout) && (K.leakWith || []).every(has) && (!K.leakWithout || K.leakWithout.some((f) => !has(f)))) leak = new Set(ALL);
|
||||
if (K.leakNoAgentDir && !process.env.PI_CODING_AGENT_DIR) leak = new Set(ALL);
|
||||
if (K.leakNoVar && K.leakNoVar.some((n) => process.env[n] === undefined)) leak = new Set(ALL);
|
||||
if (K.leakNoMatch && has("-c") && !storedFor(val("--session-dir"))) leak = new Set(ALL);
|
||||
if (K.leakEnv) {
|
||||
const want = new Set(K.leakEnv[val("--mode") === "json" ? "json" : "other"]);
|
||||
const got = Object.keys(process.env).filter((n) => !["PWD", "OLDPWD", "SHLVL", "_"].includes(n));
|
||||
if (got.length !== want.size || got.some((n) => !want.has(n))) leak = new Set(ALL);
|
||||
}
|
||||
// Whether a seal flag is on: with standIn, its flag reads as the other flag; with needs, only
|
||||
// when that flag is given too.
|
||||
const sealed = (flag) => has(K.standIn && K.standIn[0] === flag ? K.standIn[1] : flag) && (!K.needs || has(K.needs));
|
||||
const on = (kind, flag) => !ignoreAll && (!sealed(flag) || leak.has(kind));
|
||||
const agent = process.env.PI_CODING_AGENT_DIR || path.join(process.env.HOME || "/", ".pi", "agent");
|
||||
const cwd = process.cwd();
|
||||
const list = (dir, test) => { try { return fs.readdirSync(dir).filter(test).map((n) => path.join(dir, n)); } catch { return []; } };
|
||||
const json = (file) => { try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return null; } };
|
||||
const read = (file) => { try { return fs.readFileSync(file, "utf8"); } catch { return null; } };
|
||||
const settings = [json(path.join(agent, "settings.json")), json(path.join(cwd, ".pi", "settings.json"))].filter(Boolean);
|
||||
const trust = json(path.join(agent, "trust.json")) || {};
|
||||
const saved = settings.some((s) => s.defaultProjectTrust === "always") || trust[cwd] === true;
|
||||
const trusted = !ignoreAll && (has("--approve") || (saved && (!sealed("--no-approve") || leak.has("approve"))));
|
||||
const commands = [];
|
||||
// A planted extension writes one marker on load; an -e extension may also write what it saw at
|
||||
// session_start. Do what each would do.
|
||||
const starts = [];
|
||||
const load = (f) => {
|
||||
const text = read(f);
|
||||
if (text === null) return;
|
||||
for (const m of text.matchAll(/writeFileSync\(("(?:[^"\\]|\\.)*")(, JSON\.stringify\()?/g)) {
|
||||
if (m[2]) starts.push(JSON.parse(m[1]));
|
||||
else fs.writeFileSync(JSON.parse(m[1]), "");
|
||||
}
|
||||
};
|
||||
const given = argv.flatMap((a, i) => a === "-e" ? [argv[i + 1]] : []);
|
||||
if (!(K.dropExplicit && has("--no-extensions"))) for (const f of K.oneExt ? given.slice(0, 1) : given) load(f);
|
||||
const packages = settings.flatMap((s) => (s.packages || []).map((p) => typeof p === "string" ? p : p.source));
|
||||
if (K.trustExtOnly) {
|
||||
if (trusted) for (const f of list(path.join(cwd, ".pi", "extensions"), (n) => n.endsWith(".ts"))) load(f);
|
||||
} else if (on("extensions", "--no-extensions")) {
|
||||
const files = [...list(path.join(agent, "extensions"), (n) => n.endsWith(".ts")), ...list(path.join(cwd, ".pi", "extensions"), (n) => n.endsWith(".ts"))];
|
||||
for (const s of settings) files.push(...(s.extensions || []));
|
||||
for (const p of packages) files.push(...list(path.join(p, "extensions"), (n) => n.endsWith(".ts")));
|
||||
for (const f of files) load(f);
|
||||
}
|
||||
const mcpFlag = (K.extraFlags || []).includes("--no-mcp") ? "--no-mcp" : "--no-extensions";
|
||||
if (!ignoreAll && (!(sealed(mcpFlag) || (K.mcpAlso && has(K.mcpAlso))) || leak.has("mcp"))) {
|
||||
for (const f of [path.join(agent, "mcp.json"), path.join(cwd, ".pi", "mcp.json"), path.join(cwd, ".mcp.json")]) {
|
||||
for (const s of Object.values(json(f)?.mcpServers || {})) cp.spawnSync(s.command, s.args || [], { stdio: "ignore" });
|
||||
}
|
||||
}
|
||||
if (on("skills", "--no-skills")) {
|
||||
const home = process.env.HOME || "/";
|
||||
const dirs = [path.join(agent, "skills"), path.join(cwd, ".pi", "skills"), path.join(cwd, ".agents", "skills"), path.join(home, ".agents", "skills"), ...packages.map((p) => path.join(p, "skills"))];
|
||||
for (const d of dirs) for (const p of list(d, () => true)) commands.push({ name: "skill:" + path.basename(p), source: "skill" });
|
||||
for (const s of settings) for (const p of s.skills || []) commands.push({ name: "skill:" + path.basename(p), source: "skill" });
|
||||
}
|
||||
if (on("prompts", "--no-prompt-templates")) {
|
||||
const dirs = [path.join(agent, "prompts"), path.join(cwd, ".pi", "prompts"), ...packages.map((p) => path.join(p, "prompts"))];
|
||||
for (const d of dirs) for (const p of list(d, (n) => n.endsWith(".md"))) commands.push({ name: path.basename(p, ".md"), source: "prompt" });
|
||||
for (const s of settings) for (const p of s.prompts || []) commands.push({ name: path.basename(p, ".md"), source: "prompt" });
|
||||
}
|
||||
// The system prompt: the --system-prompt file, else SYSTEM.md; then APPEND_SYSTEM.md; then the
|
||||
// context files, from the agent directory and from / down to the working directory.
|
||||
const sys = K.ignoreSystemPrompt ? null : val("--system-prompt");
|
||||
const own = (name) => (trusted && read(path.join(cwd, ".pi", name))) || (!ignoreAll && read(path.join(agent, name))) || "";
|
||||
const hide = K.sysReplacesAll && sys;
|
||||
const parts = [sys ? (read(sys) || "") : own("SYSTEM.md"), K.ignoreAppend || hide ? "" : own("APPEND_SYSTEM.md")];
|
||||
if (K.trustCtxOnly) {
|
||||
if (trusted) parts.push(read(path.join(cwd, "AGENTS.md")) || "");
|
||||
} else if (!hide && on("context", "--no-context-files")) {
|
||||
const dirs = [];
|
||||
for (let d = cwd; ; d = path.dirname(d)) { dirs.unshift(d); if (path.dirname(d) === d) break; }
|
||||
parts.push(read(path.join(agent, "AGENTS.md")) || "");
|
||||
for (const d of dirs) parts.push(read(path.join(d, "AGENTS.md")) || read(path.join(d, "CLAUDE.md")) || "");
|
||||
}
|
||||
// The session -c resumes: the newest .jsonl in --session-dir whose header names this cwd.
|
||||
let session = "stand-in-" + process.pid;
|
||||
const dir = val("--session-dir");
|
||||
if (has("-c") && dir && !K.noResume) session = storedFor(dir) || session;
|
||||
const start = { prompt: parts.join("\n"), commands: K.extNoCommands ? [] : commands.map((c) => c.name), session };
|
||||
if (!(print && K.printNoStart)) for (const f of starts) fs.writeFileSync(f, JSON.stringify(start));
|
||||
if (print) {
|
||||
if (K.sessionOut) process.stdout.write(K.sessionOut);
|
||||
process.exit(0);
|
||||
}
|
||||
let input = "";
|
||||
try { input = fs.readFileSync(0, "utf8"); } catch { input = ""; }
|
||||
for (const line of input.split("\n")) {
|
||||
let m;
|
||||
try { m = JSON.parse(line); } catch { continue; }
|
||||
if (m.type === "get_state") process.stdout.write(JSON.stringify({ id: m.id, type: "response", command: "get_state", success: true, data: { isStreaming: false } }) + "\n");
|
||||
if (m.type === "get_commands") {
|
||||
const answer = K.commands === "fail" ? { success: false, error: "no" } : { success: true, data: K.commands === "list" ? commands : { commands } };
|
||||
process.stdout.write(JSON.stringify({ id: m.id, type: "response", command: "get_commands", ...answer }) + "\n");
|
||||
}
|
||||
}
|
||||
process.exit(0);
|
||||
}
|
||||
if (K.sessionOut) process.stdout.write(K.sessionOut);
|
||||
process.exit(0);
|
||||
`;
|
||||
|
||||
const quote = (text) => `'${String(text).replace(/'/g, "'\\''")}'`;
|
||||
|
||||
// The script text. node: the interpreter the fit part runs on (absolute, so it runs with no PATH).
|
||||
export function piStandIn(knobs = {}, { node = process.execPath } = {}) {
|
||||
const version = knobs.versionHang ? "sleep 60; exit 0" : knobs.versionExit != null ? `exit ${Number(knobs.versionExit)}` : `printf '%s\\n' ${quote(knobs.version ?? "9.9.9")}; exit 0`;
|
||||
const program = `"use strict";\nconst K = ${JSON.stringify(knobs)};\nconst FLAGS = ${JSON.stringify(FIT_FLAGS)};\n${BODY}`;
|
||||
return [
|
||||
"#!/bin/sh",
|
||||
`[ "$1" = --version ] && { ${version}; }`,
|
||||
`if [ -n "\${ARGV_OUT:-}" ]; then printf '%s\\n' "$@" > "$ARGV_OUT"; printf '%s' ${quote(knobs.sessionOut ?? "")}; exit 0; fi`,
|
||||
`exec ${quote(node)} -e ${quote(program)} -- "$@"`,
|
||||
"",
|
||||
].join("\n");
|
||||
}
|
||||
@@ -4,7 +4,8 @@ import assert from 'node:assert/strict';
|
||||
import { mkdirSync, readFileSync, statSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { buildBundle } from '../src/bundle.mjs';
|
||||
import { HARNESS, REPO_SKILLS, resolvedFor, scratch } from './helpers.mjs';
|
||||
import { HARNESS, REPO_SKILLS, resolvedFor, scratch, harnessReady } from './helpers.mjs';
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
|
||||
const models = {
|
||||
a: { provider: 'proxy', model: 'claude-fixture', route: 'anthropic' },
|
||||
|
||||
@@ -4,7 +4,8 @@ import { readFileSync, mkdirSync } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { buildBundle } from '../src/bundle.mjs';
|
||||
import { typedTools } from '../src/tools.mjs';
|
||||
import { resolvedFor, scratch, HARNESS, REPO_SKILLS } from './helpers.mjs';
|
||||
import { resolvedFor, scratch, HARNESS, REPO_SKILLS, harnessReady } from './helpers.mjs';
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
import { ownRails, railsText, decisionAutonomy } from '../../organization/src/rails.mjs';
|
||||
|
||||
const SECRET = 'sk-test-NOT-A-SECRET-1234';
|
||||
|
||||
@@ -9,7 +9,8 @@ import { createServer } from 'node:net';
|
||||
import { buildBundle, SOURCES } from '../src/bundle.mjs';
|
||||
import { callTool, typedTools } from '../src/tools.mjs';
|
||||
import * as runner from '../src/runner.mjs';
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch } from './helpers.mjs';
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch, harnessReady } from './helpers.mjs';
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
import { Broker } from '../../bus/src/broker.mjs';
|
||||
import { Store } from '../../bus/src/store.mjs';
|
||||
import { createRequestStore } from '../../bus/src/request-store.mjs';
|
||||
|
||||
@@ -10,7 +10,8 @@ import { chmodSync, cpSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeF
|
||||
import { join } from "node:path";
|
||||
import { BundleError, buildBundle, readSkills, SKILL_BYTES } from "../src/bundle.mjs";
|
||||
import { adapterEnv } from "../src/runner.mjs";
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch } from "./helpers.mjs";
|
||||
import { HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch, harnessReady } from "./helpers.mjs";
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
|
||||
const sha = (text) => createHash("sha256").update(text).digest("hex");
|
||||
const MARKED = /<skill-file skill="([^"]+)" path="([^"]+)">\n([\s\S]*?)\n<\/skill-file>/g;
|
||||
@@ -183,7 +184,8 @@ test("each adapter passes the skills only in the prompt file, with skill discove
|
||||
const b = buildBundle({ dir: join(dir, "bundle"), resolved, contract: "# Contract\n", harness: HARNESS[harness], models, skillsDir: REPO_SKILLS, session: { ...s, run: "run-1", launchedBy: "pm" } });
|
||||
s.bundle = b.files;
|
||||
s.harnessEnv = b.env;
|
||||
const env = { ...adapterEnv(s, { PATH: `${join(dir, "bin")}:/usr/bin:/bin`, HOME: join(dir, "home") }), ARGV_OUT: join(dir, "argv"), MOSAIC_REQUEST: "x" };
|
||||
// #1873 S2: the pi adapter runs MOSAIC_PI_BIN, which the bundle sets to the pi it found.
|
||||
const env = { ...adapterEnv(s, { PATH: `${join(dir, "bin")}:/usr/bin:/bin`, HOME: join(dir, "home") }), ARGV_OUT: join(dir, "argv"), MOSAIC_REQUEST: "x", ...(harness === "pi" ? { MOSAIC_PI_BIN: cli } : {}) };
|
||||
const r = spawnSync("/bin/sh", [join(REPO, "adapters", harness === "pi" ? "pi" : "claude", "adapter.sh")], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], env });
|
||||
assert.equal(r.status, 0, `${harness}: ${r.stderr}`);
|
||||
const argv = readFileSync(join(dir, "argv"), "utf8").split("\0");
|
||||
|
||||
@@ -9,7 +9,8 @@ import { join } from "node:path";
|
||||
// A namespace import, so the red-before test runs (and fails on its assertion) on a base without
|
||||
// the section's exports.
|
||||
import * as bundleModule from "../src/bundle.mjs";
|
||||
import { HARNESS, REPO_SKILLS, resolvedFor, scratch } from "./helpers.mjs";
|
||||
import { HARNESS, REPO_SKILLS, resolvedFor, scratch, harnessReady } from "./helpers.mjs";
|
||||
await harnessReady(); // #1873 re-check 7: buildBundle reads a passed fit check
|
||||
import { REPO_ROLES } from "../../organization/tests/helpers.mjs";
|
||||
|
||||
const { buildBundle, sessionModel } = bundleModule;
|
||||
|
||||
@@ -7,11 +7,66 @@ import { homedir } from 'node:os';
|
||||
import { fetchPinned } from './fetch.mjs';
|
||||
import { PIN } from './common.mjs';
|
||||
import { localRide, riddenOrgs } from './ride.mjs';
|
||||
import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, receiptsText, createUnitControl, FILE_LABELS } from './admin.mjs';
|
||||
import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, receiptsText, createUnitControl, FILE_LABELS, LOG_LINES, receiptHistory, serviceKeyState } from './admin.mjs';
|
||||
import { secretValues } from './redact.mjs';
|
||||
import { discoverModules, hasModule } from '../../plugins/src/loader.mjs';
|
||||
import { readPluginLock } from '../../plugins/src/pinned.mjs';
|
||||
|
||||
export const proxyCode = (error, fallback) => (/^proxy-[a-z-]+$/.test(error?.code ?? '') ? error.code : fallback);
|
||||
const failure = code => Object.assign(new Error(code), { code });
|
||||
|
||||
// #1873 settings-backend A2: the harness programs installed on this instance, from the plugin tree
|
||||
// through the plugins loader and from the instance's plugin lock, the way the bus lists them
|
||||
// (runtime.mjs harnessLevels). No name list here. A tree that cannot be read answers null; a lock
|
||||
// that cannot be read adds nothing, so a pinned program is then not offered.
|
||||
export function installedHarnesses(dataRoot = null) {
|
||||
let names;
|
||||
try { names = discoverModules('harness').names.filter(name => hasModule('harness', name)); } catch { return null; }
|
||||
if (dataRoot !== null) {
|
||||
try { names = [...new Set([...names, ...Object.keys(readPluginLock(dataRoot).plugins).filter(name => hasModule('harness', name, dataRoot))])]; } catch { /* the tree's list */ }
|
||||
}
|
||||
return names.sort();
|
||||
}
|
||||
|
||||
// #1873 settings-backend A2: every harness an organization document names for an agent: each
|
||||
// `harness` or `fallback.harness` string anywhere in it (role vars, project agent vars, or any
|
||||
// later place), outside its plugins list. Broader than the routes view on purpose: a program is
|
||||
// never turned off where anything in the file still names it.
|
||||
export function harnessesNamed(document) {
|
||||
const named = new Set();
|
||||
const walk = (value, depth) => {
|
||||
if (depth > 32 || value === null || typeof value !== 'object') return;
|
||||
if (Array.isArray(value)) { for (const item of value) walk(item, depth + 1); return; }
|
||||
for (const [key, item] of Object.entries(value)) {
|
||||
if ((key === 'harness' || key === 'fallback.harness') && typeof item === 'string') named.add(item);
|
||||
else walk(item, depth + 1);
|
||||
}
|
||||
};
|
||||
if (document === null || typeof document !== 'object' || Array.isArray(document)) return null;
|
||||
for (const [key, value] of Object.entries(document)) if (key !== 'plugins') walk(value, 1);
|
||||
return named;
|
||||
}
|
||||
|
||||
// #1873 settings-backend A2 (review P1-1): the harnesses the root agents an organization takes name.
|
||||
// `root` is what loadRootAgents answered ({state, agents, assistant, definitions?}). An organization
|
||||
// takes every root agent except the root assistant and the ones that exclude it, the way
|
||||
// materializeCopies copies them at bus boot. Anything not in that shape answers null (unreadable).
|
||||
export function rootHarnessesNamed(root, orgId) {
|
||||
if (root === null || typeof root !== 'object' || root.agents === null || typeof root.agents !== 'object' || Array.isArray(root.agents)) return null;
|
||||
const taken = {};
|
||||
for (const [name, entry] of Object.entries(root.agents)) {
|
||||
if (entry === null || typeof entry !== 'object' || !Array.isArray(entry.excludeOrgs)) return null;
|
||||
if (entry.definition === 'assistant' || entry.excludeOrgs.includes(orgId)) continue;
|
||||
taken[name] = entry.vars ?? {};
|
||||
}
|
||||
return harnessesNamed({ agents: taken, definitions: root.definitions ?? {} });
|
||||
}
|
||||
// A key id is the first 12 hex of the key's sha256. A label is a short plain name; anything that
|
||||
// looks like a Mosaic key prefix is dropped, so an answer can never carry key text.
|
||||
const KEY_ID = /^[a-f0-9]{12}$/;
|
||||
const plainLabel = value => (typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(value) && !/ms[kotp][-_]/i.test(value) ? value : null);
|
||||
const isoTime = value => (typeof value === 'string' && /^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9:.]{1,18}Z$/.test(value) ? value : null);
|
||||
|
||||
// `buses()` proves the init-lock condition "bus stopped" ({stopped, running:[label]}).
|
||||
// `orgs()` lists the organizations this proxy serves: [{id, catalogue}]. `unit` and `fetch` are
|
||||
// (and `pin`) seams for tests; the defaults run the real proxy-service.sh, systemctl and pinned fetch.
|
||||
@@ -20,7 +75,11 @@ const failure = code => Object.assign(new Error(code), { code });
|
||||
// change log, `call(verb, args)` reaches its bus as the owner and `status()` is its bus status. `ownerModels()` answers
|
||||
// {proxy, riding, models} from the riding buses' catalogues. `move(id, models, principal)` moves a
|
||||
// stopped fixture organization to the owner's models through the organization service.
|
||||
export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir = null, unit = null, fetch = fetchPinned, buses, orgs = async () => [], riders = async () => [], ownerModels = async () => ({ proxy: false, riding: false, models: [] }), move = null, now = () => new Date(), env = process.env, pin = PIN }) {
|
||||
// #1873 settings-backend A2: a rider may also have `file()`, its organization file as the writer
|
||||
// reads it ({document, revision}), read only. `harnesses()` lists the installed harness programs.
|
||||
// `rootAgents()` reads the root agent file (loadRootAgents); with none given, or one that throws,
|
||||
// no organization that has the program on is written (unreadable).
|
||||
export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir = null, unit = null, fetch = fetchPinned, buses, orgs = async () => [], riders = async () => [], harnesses = () => installedHarnesses(dataRoot), rootAgents = null, ownerModels = async () => ({ proxy: false, riding: false, models: [] }), move = null, now = () => new Date(), env = process.env, pin = PIN }) {
|
||||
const port = () => { try { return initState(configDir, dataRoot).settings?.port ?? null; } catch { return null; } };
|
||||
const control = unit ?? createUnitControl({ instance, unitDir, port, env });
|
||||
let job = { state: 'idle', step: null, receipt: null, error: null };
|
||||
@@ -97,6 +156,83 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
|
||||
return (await riders()).map(r => { const state = decide(r, wasRidden); return state === 'fixture' && typeof r.status !== 'function' ? { id: r.id, state, running: null } : { id: r.id, state }; });
|
||||
} catch { return null; }
|
||||
}
|
||||
// #1873 settings-backend A2, item 5: which harness programs each organization has on, from its
|
||||
// bus's plugins read as the owner. null when the read fails, its answer has no harness list, or
|
||||
// any entry is not a plugin name (review P3-3: no bus text reaches the page).
|
||||
const harnessList = value => (Array.isArray(value?.plugins?.harness) && value.plugins.harness.every(n => typeof n === 'string' && /^[a-z][a-z0-9-]{0,63}$/.test(n)) ? [...value.plugins.harness] : null);
|
||||
async function programsSummary() {
|
||||
let installed = null;
|
||||
try { installed = harnesses(); if (!Array.isArray(installed)) installed = null; } catch { installed = null; }
|
||||
let list;
|
||||
try { list = await riders(); } catch { return { installed, organizations: null }; }
|
||||
const organizations = await Promise.all(list.map(async rider => {
|
||||
try { return { id: rider.id, on: harnessList(await rider.call('plugins')) }; } catch { return { id: rider.id, on: null }; }
|
||||
}));
|
||||
return { installed, organizations };
|
||||
}
|
||||
// Item 5, one organization: turn `name` off unless something still uses it or it is the only one.
|
||||
// Three reads (the plugins read, the routes view and the organization file) must show one revision;
|
||||
// the write carries it, so a change after them is refused by the writer (revision-conflict) and
|
||||
// reported, never retried. Every skip writes nothing. `root` is the root agent file read once per
|
||||
// call (undefined when it could not be read): the root agents this organization takes count too.
|
||||
async function offOne(rider, name, root) {
|
||||
const id = rider.id;
|
||||
let current;
|
||||
try { current = await rider.call('plugins'); } catch { return { id, outcome: 'bus-down' }; }
|
||||
const on = harnessList(current);
|
||||
if (on === null || typeof current?.revision !== 'string' || !/^[a-f0-9]{64}$/.test(current.revision)) return { id, outcome: 'unreadable' };
|
||||
if (!on.includes(name)) return { id, outcome: 'already-off' };
|
||||
let routes = null;
|
||||
try { routes = await rider.call('routes'); } catch (error) { if (error?.code !== 'launch-not-configured') return { id, outcome: 'unreadable' }; }
|
||||
let file;
|
||||
try { file = typeof rider.file === 'function' ? await rider.file() : null; } catch { file = null; }
|
||||
const named = harnessesNamed(file?.document);
|
||||
const fromRoot = root === undefined ? null : rootHarnessesNamed(root, id);
|
||||
if (named === null || fromRoot === null || typeof file?.revision !== 'string') return { id, outcome: 'unreadable' };
|
||||
for (const harness of fromRoot) named.add(harness);
|
||||
if (file.revision !== current.revision || (routes !== null && routes?.revision !== current.revision)) return { id, outcome: 'failed:revision-conflict' };
|
||||
// The routes view must be readable when there is one; each instance's route and fallback count.
|
||||
if (routes !== null) {
|
||||
if (!routes || typeof routes.instances !== 'object' || routes.instances === null) return { id, outcome: 'unreadable' };
|
||||
for (const route of Object.values(routes.instances)) {
|
||||
if (typeof route?.harness === 'string') named.add(route.harness);
|
||||
if (typeof route?.fallback?.harness === 'string') named.add(route.fallback.harness);
|
||||
}
|
||||
}
|
||||
// The harness rule: any route on this program, whatever account its model uses, keeps it on.
|
||||
if (named.has(name)) return { id, outcome: 'in-use' };
|
||||
if (on.length === 1) return { id, outcome: 'last-program' };
|
||||
try { await rider.call('plugins.set', { revision: current.revision, plugins: { harness: on.filter(n => n !== name) } }); }
|
||||
catch (error) { return { id, outcome: `failed:${failCode(error)}` }; }
|
||||
return { id, outcome: 'off' };
|
||||
}
|
||||
// Item 8, one organization: its proxy client keys by key id, from proxy.keys as the owner. Never
|
||||
// the usage queue. A key value never reaches here: proxy.keys answers ids, and every other field
|
||||
// is checked against a plain pattern before it is passed on.
|
||||
async function accessOne(rider) {
|
||||
const id = rider.id;
|
||||
if (typeof rider.fixture !== 'boolean' || typeof rider.cliproxy !== 'boolean') return { id, health: 'unreadable', reason: 'unreadable', keys: [] };
|
||||
if (rider.fixture || !rider.cliproxy) return { id, health: 'not-riding', keys: [] };
|
||||
let answer;
|
||||
try { answer = await rider.call('proxy.keys'); }
|
||||
catch (error) {
|
||||
const code = error?.code;
|
||||
if (code === 'proxy-uncertain') return { id, health: 'attention', reason: 'proxy-uncertain', keys: [] };
|
||||
const reason = code === 'not-configured' ? 'no-proxy-client' : code === 'outcome-unknown' || code === 'no-bus-host' ? 'bus-down' : 'unreadable';
|
||||
return { id, health: 'unreadable', reason, keys: [] };
|
||||
}
|
||||
if (!Array.isArray(answer?.keys)) return { id, health: 'unreadable', reason: 'unreadable', keys: [] };
|
||||
const keys = [];
|
||||
let other = 0, sentinel = 0;
|
||||
for (const key of answer.keys) {
|
||||
if (!key || typeof key !== 'object' || !KEY_ID.test(key.keyId ?? '')) return { id, health: 'unreadable', reason: 'unreadable', keys: [] };
|
||||
if (key.management === 'sentinel') sentinel++;
|
||||
else if (key.management === 'stack-managed') keys.push({ keyId: key.keyId, agent: plainLabel(key.agent), state: plainLabel(key.state), issuedAt: isoTime(key.issuedAt) });
|
||||
else other++;
|
||||
}
|
||||
const health = keys.length === 0 ? 'missing' : keys.every(k => k.state === 'active') ? 'ok' : 'attention';
|
||||
return { id, health, keys, other, sentinel };
|
||||
}
|
||||
function nextSteps({ release, init, unitState, fence, lock }) {
|
||||
if (!release.fetched || release.problem) return ['fetch'];
|
||||
if (lock.present) return lock.clearable ? ['init-lock-clear'] : ['init-lock-wait'];
|
||||
@@ -122,6 +258,7 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
|
||||
let organizations = null;
|
||||
try { organizations = await orgs(); } catch { organizations = null; }
|
||||
const ride = await rideSummary();
|
||||
const programs = await programsSummary();
|
||||
const next = nextSteps({ release, init, unitState, fence, lock });
|
||||
// Ride all comes after the proxy runs with no fence, while an organization can still ride.
|
||||
if (next[0] === 'accounts' && ride?.some(r => r.state === 'ready' || r.state === 'fixture')) next.push('ride-all');
|
||||
@@ -143,6 +280,7 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
|
||||
// needs a config format that does not exist yet.
|
||||
ownProxy: { available: false, state: 'not built', reason: 'This instance has one shared proxy. A separate proxy per organization is not built yet.' },
|
||||
ride,
|
||||
programs,
|
||||
next,
|
||||
};
|
||||
},
|
||||
@@ -254,6 +392,65 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
|
||||
if (typeof org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(org)) throw failure('proxy-org-invalid');
|
||||
return receipt({ op: 'ride-removed', org });
|
||||
},
|
||||
// #1873 settings-backend A1: three reads for the instance owner's setup page.
|
||||
// The proxy unit's last journal lines, redacted. A unit that is not installed is not-configured;
|
||||
// a unit state that cannot be read is outcome-unknown, as is a journal that cannot be read.
|
||||
async log({ lines = LOG_LINES.default } = {}) {
|
||||
if (typeof control.log !== 'function') throw failure('not-configured');
|
||||
const state = await unitStatus();
|
||||
if (state.error) throw failure('outcome-unknown');
|
||||
if (!state.installed) throw failure('not-configured');
|
||||
return control.log(lines, { secrets: secretValues(env) });
|
||||
},
|
||||
// When the service key was made, from proxy.json's mtime; never the key or any part of it.
|
||||
serviceKey() { return serviceKeyState(configDir); },
|
||||
// The setup history, a page at a time (receiptHistory).
|
||||
history({ limit, before = null } = {}) { return receiptHistory(dataRoot, { limit, before, secrets: secretValues(env) }); },
|
||||
// An account change made through /api/proxy/* or an organization's /api/orgs/<id>/proxy/*,
|
||||
// recorded after its bus call answered. Labels only: the provider id, a 12-hex account id, a
|
||||
// priority or a model count, the organization whose route carried it, and the signed-in name.
|
||||
// Never a key, a login state, a callback URL, a model list or a body. Answers null when the verb
|
||||
// is not an account change, true when recorded and false when the append failed.
|
||||
recordAccount({ verb, args = {}, result = null, user = null, org = null } = {}) {
|
||||
const label = value => (typeof value === 'string' && /^[a-z0-9][a-z0-9._-]{0,31}$/.test(value) ? value : null);
|
||||
const account = value => (typeof value === 'string' && /^[a-f0-9]{12}$/.test(value) ? value : null);
|
||||
let record;
|
||||
if (verb === 'proxy.apikey.add') record = { op: 'account.proxy.apikey.add', provider: label(args.provider) };
|
||||
else if (verb === 'proxy.login.status' && result?.status === 'ok') record = { op: 'account.proxy.login.complete' };
|
||||
else if (verb === 'proxy.priority.set') record = { op: 'account.proxy.priority.set', accountId: account(args.accountId), priority: Number.isSafeInteger(args.priority) ? args.priority : null };
|
||||
else if (verb === 'proxy.group.models.set') record = { op: 'account.proxy.group.models.set', accountId: account(args.accountId), models: Array.isArray(args.models) ? args.models.length : null };
|
||||
else return null;
|
||||
if (typeof org === 'string' && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(org)) record.org = org;
|
||||
if (typeof user === 'string' && user) record.user = user.slice(0, 64);
|
||||
try { receipt(record); return true; } catch { return false; }
|
||||
},
|
||||
// #1873 settings-backend A2, item 5: turns one harness program off for every current
|
||||
// organization that can do without it, through each organization's bus as the owner (the way
|
||||
// Ride all writes). Sequential, one organization at a time; one receipt names the outcome ids.
|
||||
async programsOff({ name, user = null } = {}) {
|
||||
return exclusive('programs', async () => {
|
||||
let installed;
|
||||
try { installed = harnesses(); } catch { installed = null; }
|
||||
if (typeof name !== 'string' || !Array.isArray(installed) || !installed.includes(name)) throw failure('invalid-request');
|
||||
const list = await riders();
|
||||
let root;
|
||||
try { root = typeof rootAgents === 'function' ? await rootAgents() : undefined; } catch { root = undefined; }
|
||||
const results = [];
|
||||
for (const rider of list) results.push(await offOne(rider, name, root));
|
||||
const record = { op: 'programs.off', name, results: results.map(r => ({ id: r.id, outcome: r.outcome })) };
|
||||
if (typeof user === 'string' && user) record.user = user.slice(0, 64);
|
||||
// Each write is the organization's own change log entry, so a receipt that cannot be
|
||||
// written still answers what happened, with no receipt.
|
||||
let written = null;
|
||||
try { written = receipt(record); } catch { written = null; }
|
||||
return { name, results, receipt: written };
|
||||
});
|
||||
},
|
||||
// #1873 settings-backend A2, item 8: each organization's proxy client keys and their health.
|
||||
async access() {
|
||||
const list = await riders();
|
||||
return { organizations: await Promise.all(list.map(rider => accessOne(rider).catch(() => ({ id: rider.id, health: 'unreadable', reason: 'unreadable', keys: [] })))) };
|
||||
},
|
||||
async initLockClear() {
|
||||
return exclusive('init-lock-clear', async () => ({ receipt: clearInitLock({ configDir, dataRoot, buses: await buses(), now }) }));
|
||||
},
|
||||
|
||||
@@ -9,6 +9,7 @@ import { execFile } from 'node:child_process';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { PIN, refuse } from './common.mjs';
|
||||
import { installPaths, loadProxy, verifyInstall } from './settings.mjs';
|
||||
import { holdsSecret, redactLine, redactValue } from './redact.mjs';
|
||||
|
||||
const REPO = fileURLToPath(new URL('../../../', import.meta.url)).replace(/\/$/, '');
|
||||
export const INSTANCE_NAME = /^[a-z][a-z0-9]{1,15}$/;
|
||||
@@ -142,6 +143,135 @@ export function recentReceipts(dataRoot, limit = 10) {
|
||||
} finally { fs.closeSync(fd); }
|
||||
}
|
||||
|
||||
// #1873 settings-backend A1 (item 9): the setup history, one page at a time, newest page first and
|
||||
// oldest first within a page. `before` is a byte offset the previous page answered as `next`: the
|
||||
// start of a line. The file is read the way ownedText reads (no symlink, no FIFO, owned by the
|
||||
// Console's user, no group or other bits) and backward from `before` in 64 KB chunks. A partial
|
||||
// last line (a write in progress) waits for a later read; a line that does not parse, or is longer
|
||||
// than 64 KB, is skipped. Each entry is redacted (redact.mjs) before it is answered, so a receipt
|
||||
// that ever held key text shows none. An entry whose redacted values read together, or whose keys
|
||||
// and values read together, still hold an environment secret split across them is answered as
|
||||
// { withheld: true }; pieces kept apart by another whole field are not seen (known limit). A missing
|
||||
// file is an empty history; any other failure to read refuses outcome-unknown. `uid` is a test seam.
|
||||
export const HISTORY_LIMIT = Object.freeze({ min: 1, max: 100, default: 25 });
|
||||
const HISTORY_CHUNK = 65536, HISTORY_LINE_MAX = 65536, HISTORY_SCAN_MAX = 2000;
|
||||
// A redacted entry's values joined in order, with each object key before its value when `keys`.
|
||||
const entryText = (value, keys) => (value !== null && typeof value === 'object'
|
||||
? Object.entries(value).map(([key, item]) => (keys && !Array.isArray(value) ? key : '') + entryText(item, keys)).join('')
|
||||
: String(value));
|
||||
export function receiptHistory(dataRoot, { limit = HISTORY_LIMIT.default, before = null, uid = process.getuid(), secrets = [] } = {}) {
|
||||
if (!Number.isSafeInteger(limit)) refuse('invalid-request');
|
||||
const n = Math.min(HISTORY_LIMIT.max, Math.max(HISTORY_LIMIT.min, limit));
|
||||
if (before !== null && !(Number.isSafeInteger(before) && before >= 0)) refuse('invalid-request');
|
||||
let fd;
|
||||
try { fd = fs.openSync(receiptFile(dataRoot), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK); }
|
||||
catch (error) {
|
||||
if (error.code !== 'ENOENT') refuse('outcome-unknown');
|
||||
if (before !== null && before !== 0) refuse('invalid-request');
|
||||
return { entries: [], next: null };
|
||||
}
|
||||
try {
|
||||
let stat;
|
||||
try { stat = fs.fstatSync(fd); } catch { refuse('outcome-unknown'); }
|
||||
if (!stat.isFile() || stat.uid !== uid || (stat.mode & 0o077)) refuse('outcome-unknown');
|
||||
const size = stat.size;
|
||||
if (before !== null && before > size) refuse('invalid-request');
|
||||
// A window over the file: `buf` holds bytes [start, start + buf.length).
|
||||
let start = 0, buf = Buffer.alloc(0);
|
||||
const readAt = (offset, length) => {
|
||||
const out = Buffer.alloc(length);
|
||||
let got;
|
||||
try { got = fs.readSync(fd, out, 0, length, offset); } catch { refuse('outcome-unknown'); }
|
||||
if (got !== length) refuse('outcome-unknown');
|
||||
return out;
|
||||
};
|
||||
// The offset of the last newline in [0, from), or -1.
|
||||
const lastNewline = from => {
|
||||
let pos = from;
|
||||
while (pos > 0) {
|
||||
if (!(pos > start && pos <= start + buf.length)) { start = Math.max(0, pos - HISTORY_CHUNK); buf = readAt(start, pos - start); }
|
||||
const i = buf.lastIndexOf(0x0a, pos - start - 1);
|
||||
if (i >= 0) return start + i;
|
||||
pos = start;
|
||||
}
|
||||
return -1;
|
||||
};
|
||||
const bytes = (from, to) => (from >= start && to <= start + buf.length ? buf.subarray(from - start, to - start) : readAt(from, to - from));
|
||||
// `cursor` is always 0 or the offset just after a newline: the end of the next line to read.
|
||||
let cursor;
|
||||
if (before === null) cursor = lastNewline(size) + 1;
|
||||
else if (before > 0 && bytes(before - 1, before)[0] !== 0x0a) refuse('invalid-request');
|
||||
else cursor = before;
|
||||
const entries = [];
|
||||
for (let scanned = 0; cursor > 0 && entries.length < n && scanned < HISTORY_SCAN_MAX; scanned++) {
|
||||
const lineStart = lastNewline(cursor - 1) + 1, lineEnd = cursor - 1;
|
||||
if (lineEnd - lineStart <= HISTORY_LINE_MAX) {
|
||||
let value = null;
|
||||
try { value = JSON.parse(bytes(lineStart, lineEnd).toString('utf8')); } catch { /* torn line */ }
|
||||
if (value && typeof value === 'object' && !Array.isArray(value) && typeof value.op === 'string') {
|
||||
const safe = redactValue(value, secrets);
|
||||
const split = holdsSecret(entryText(safe, false), secrets) || holdsSecret(entryText(safe, true), secrets);
|
||||
entries.push(split ? { withheld: true } : safe);
|
||||
}
|
||||
}
|
||||
cursor = lineStart;
|
||||
}
|
||||
entries.reverse();
|
||||
return { entries, next: cursor > 0 ? cursor : null };
|
||||
} finally { fs.closeSync(fd); }
|
||||
}
|
||||
|
||||
// #1873 settings-backend A1 (item 7): when the service key was made. proxy.json is created in the
|
||||
// same init step as the management key, with exclusive create, and is never rewritten, so its
|
||||
// mtime is the key's creation time. Only proxy.json is lstat'ed: the key file is never opened or
|
||||
// stat'ed, and nothing is read. A missing proxy.json is `missing`; a symlink, a non-file, one owned
|
||||
// by another user or one that cannot be examined is `unreadable`, with no date. There is no
|
||||
// renewal yet (proxy-scope: no rotation in the MVP), so renewedAt is null and renewal 'not-built'.
|
||||
export function serviceKeyState(configDir, { uid = process.getuid() } = {}) {
|
||||
const out = { madeAt: null, renewedAt: null, renewal: 'not-built', problem: null };
|
||||
let stat;
|
||||
try { stat = fs.lstatSync(path.join(configDir, 'proxy.json')); }
|
||||
catch (error) { out.problem = error.code === 'ENOENT' ? 'missing' : 'unreadable'; return out; }
|
||||
if (!stat.isFile() || stat.uid !== uid || !Number.isFinite(stat.mtimeMs) || stat.mtimeMs <= 0) { out.problem = 'unreadable'; return out; }
|
||||
out.madeAt = new Date(stat.mtimeMs).toISOString();
|
||||
return out;
|
||||
}
|
||||
|
||||
// #1873 settings-backend A1 (item 3): the proxy unit's last journal lines, made safe to show. The
|
||||
// unit name is unitName()'s, never the caller's; `lines` is clamped to 1..200. journalctl runs
|
||||
// through `run` (defaultRun: its timeout and 1 MB cap). A missing journalctl, a nonzero exit or a
|
||||
// timeout refuses outcome-unknown, with no lines and no other source tried. Each line is redacted
|
||||
// (redact.mjs) and cut to 300 characters; a line that cannot be shown is dropped, never shown raw.
|
||||
// A secret from `secrets` found across the shown lines, though in no one line, drops every line.
|
||||
export const LOG_LINES = Object.freeze({ min: 1, max: 200, default: 50 });
|
||||
export async function unitLog({ run = defaultRun, unit, lines = LOG_LINES.default, env, secrets = [] } = {}) {
|
||||
if (typeof unit !== 'string' || !/^mosaic-proxy(-[a-z][a-z0-9]{1,15})?\.service$/.test(unit)) refuse('proxy-unit-usage');
|
||||
if (!Number.isSafeInteger(lines)) refuse('invalid-request');
|
||||
const n = Math.min(LOG_LINES.max, Math.max(LOG_LINES.min, lines));
|
||||
let result;
|
||||
try { result = await run('journalctl', ['--user', '-u', unit, '-n', String(n), '-o', 'cat', '--no-pager', '-q'], { env, timeout: 15000 }); }
|
||||
catch { refuse('outcome-unknown'); }
|
||||
if (!result || result.code !== 0 || typeof result.stdout !== 'string') refuse('outcome-unknown');
|
||||
const raw = result.stdout.split('\n');
|
||||
if (raw.at(-1) === '') raw.pop();
|
||||
const kept = raw.slice(-n);
|
||||
const out = [];
|
||||
let redacted = 0, dropped = 0;
|
||||
try {
|
||||
for (const line of kept) {
|
||||
const safe = redactLine(line, secrets);
|
||||
if (safe.text === null) { if (line.trim()) dropped++; continue; }
|
||||
if (safe.redacted) redacted++;
|
||||
out.push(safe.text);
|
||||
}
|
||||
// The lines that will be shown, read together: a secret split across them drops them all.
|
||||
// Only environment secrets are checked this way. A key pattern broken across two journal
|
||||
// lines, each part too short for the long-run rules, is a known limit shared with chat-fail.
|
||||
if (holdsSecret(out.join(''), secrets)) { dropped += out.length; out.length = 0; }
|
||||
} catch { refuse('outcome-unknown'); }
|
||||
return { unit, lines: out, redacted, dropped };
|
||||
}
|
||||
|
||||
export function unitName(instance) {
|
||||
if (instance !== null && instance !== undefined && instance !== 'dev' && !INSTANCE_NAME.test(instance)) refuse('proxy-unit-usage');
|
||||
return instance && instance !== 'dev' ? `mosaic-proxy-${instance}.service` : 'mosaic-proxy.service';
|
||||
@@ -215,6 +345,8 @@ export function createUnitControl({ instance = null, port = () => null, unitDir
|
||||
return {
|
||||
unit,
|
||||
status,
|
||||
// settings-backend A1: the unit's last journal lines, redacted (unitLog).
|
||||
log(lines, { secrets = [] } = {}) { return unitLog({ run, unit, lines, env, secrets }); },
|
||||
async render() { return (await service('render')).stdout; },
|
||||
async install() { await service('install'); return status(); },
|
||||
async start() {
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
// #1873 settings-backend A1: redaction for the model service's log lines and the setup history,
|
||||
// read by the instance owner on the setup page.
|
||||
//
|
||||
// It is the redaction chat-fail landed for a failed turn's cause (packages/harness/src/failure-notice.mjs,
|
||||
// its REDACT list), with Mosaic's own key prefixes added to the key-prefix line: mso- (an organization's
|
||||
// model key), mst- (the Triage key) and msp-, beside msk- (the owner's). One line is added after it:
|
||||
// those four Mosaic prefixes with no word boundary, so a key glued to a word (xmso-...) is caught
|
||||
// too. Over-redaction there is the safe side. failure-notice.mjs does not
|
||||
// export its list, and packages/harness/ belongs to another lane now, so the list is copied here.
|
||||
// tests/redact.test.mjs fails when a copied line no longer matches failure-notice.mjs.
|
||||
//
|
||||
// A text is decoded (%XX, HTML references, NFKC) and cleaned (ANSI, controls, whitespace) with
|
||||
// failure-notice's own exported helpers before it is redacted. A text that holds one of the
|
||||
// Console's environment secrets (secretValues), even split by spaces or controls, is withheld
|
||||
// whole. A text that redacts to nothing but [redacted] says nothing and is dropped.
|
||||
import { cleanText, decodeText } from '../../harness/src/failure-notice.mjs';
|
||||
|
||||
export { secretValues } from '../../harness/src/failure-notice.mjs';
|
||||
|
||||
export const LINE_MAX = 300;
|
||||
export const REDACTED = '[redacted]';
|
||||
|
||||
// Copied from failure-notice.mjs. The key-prefix line adds mso, mst and msp, and the line after
|
||||
// it is Mosaic's own; every other line is failure-notice's.
|
||||
const KEY_WORD = "(?:\\w*[_-])?(?:api[_-]?key|key|token|secret|password|passwd|authorization|cookie|session)";
|
||||
const REDACT = [
|
||||
/(?<![a-z0-9+.-])[a-z0-9+.-]+:\/\/\S*/gi, // any link, its userinfo and query included, from the run's start
|
||||
/\bwww\.\S+/gi,
|
||||
/(?<!\S)(?=\S*\S@\S)\S+/g, // email addresses and user@host: the whole run holding the @
|
||||
/(?:^|(?<=[\s("'=:]))(?:~|\.{1,2})?\/\S+/g, // absolute and home paths
|
||||
/\b[A-Za-z]:\\\S*/g, // Windows paths
|
||||
/\\\\\S+/g, // UNC paths
|
||||
/\b(?:bearer|basic)\s+\S+/gi,
|
||||
new RegExp(`\\b${KEY_WORD}["']?\\s*[:=]\\s*(?:"[^"]*"?|'[^']*'?|[^\\s,;}]+)`, "gi"),
|
||||
new RegExp(`\\b${KEY_WORD}["']?\\s+(?:"[^"]*"?|'[^']*'?|(?=[^\\s"',;}]*\\d)[^\\s"',;}]+|[^\\s"',;}]{8,})`, "gi"),
|
||||
/\b(?:sk|msk|mso|mst|msp|rk|pk|ghp|gho|ghs|glpat|xox[a-z])[-_]\S+/gi,
|
||||
/ms[kotp][-_]\S+/gi, // Mosaic's prefixes glued to a word: added here, not in failure-notice.mjs
|
||||
/\beyJ\S+/g, // JWT
|
||||
/[A-Za-z0-9_\-+/=.]{32,}/g,
|
||||
/(?<![A-Za-z0-9_\-+/=.])(?=[A-Za-z0-9_\-+/=.]*\d)(?=[A-Za-z0-9_\-+/=.]*[A-Za-z])[A-Za-z0-9_\-+/=.]{16,}/g,
|
||||
];
|
||||
|
||||
// The text with every space, mark and separator gone, after cleanText, for the secret check.
|
||||
// cleanText has already removed ANSI, format, surrogate and private-use characters and turned
|
||||
// controls into spaces, so this removes the same set failure-notice's compactText does.
|
||||
const compact = clean => clean.replace(/[\p{M}\p{Z}\s]/gu, '');
|
||||
|
||||
function cap(text, n = LINE_MAX) {
|
||||
const chars = Array.from(text);
|
||||
return chars.length <= n ? text : chars.slice(0, n - 3).join('') + '...';
|
||||
}
|
||||
|
||||
// One text made safe to show. Answers { text, redacted } where text is null when nothing can be
|
||||
// shown: an empty text, one holding a secret (withheld: true), or one that redacts to only
|
||||
// [redacted]. Redaction runs over the whole text before the cap, so the cut never parts a key word
|
||||
// from its value. `secrets` is secretValues(env).
|
||||
export function redactLine(line, secrets = []) {
|
||||
const clean = cleanText(decodeText(String(line)));
|
||||
if (!clean) return { text: null, redacted: false };
|
||||
if (secrets.length) {
|
||||
const flat = compact(clean);
|
||||
if (secrets.some(value => flat.includes(value))) return { text: null, redacted: true, withheld: true };
|
||||
}
|
||||
let shown = clean;
|
||||
for (const re of REDACT) shown = shown.replace(re, REDACTED);
|
||||
shown = shown.replace(/(?:\[redacted\]\s*){2,}/g, `${REDACTED} `).trim();
|
||||
if (!shown || shown === REDACTED) return { text: null, redacted: true };
|
||||
return { text: cap(shown), redacted: shown !== clean };
|
||||
}
|
||||
|
||||
// True when the whole text, joined with no spaces, holds a secret: one split across lines is seen.
|
||||
export function holdsSecret(text, secrets = []) {
|
||||
if (!secrets.length) return false;
|
||||
const flat = compact(cleanText(decodeText(String(text))));
|
||||
return secrets.some(value => flat.includes(value));
|
||||
}
|
||||
|
||||
// A stored value made safe to show: strings are redacted, and a string that cannot be shown
|
||||
// becomes [redacted]. Keys that redaction would change are dropped with their value. Depth and
|
||||
// size are bounded; anything past the bound becomes null.
|
||||
export function redactValue(value, secrets = [], depth = 0) {
|
||||
if (value === null || typeof value === 'number' || typeof value === 'boolean') return value;
|
||||
if (typeof value === 'string') return value === '' ? '' : redactLine(value, secrets).text ?? REDACTED;
|
||||
if (depth >= 4 || typeof value !== 'object') return null;
|
||||
if (Array.isArray(value)) return value.slice(0, 64).map(item => redactValue(item, secrets, depth + 1));
|
||||
const out = {};
|
||||
for (const [key, item] of Object.entries(value).slice(0, 64)) {
|
||||
if (!/^[A-Za-z][A-Za-z0-9_]{0,63}$/.test(key) || redactLine(key, secrets).text !== key) continue;
|
||||
out[key] = redactValue(item, secrets, depth + 1);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@@ -7,7 +7,10 @@ import fs from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { createHash } from 'node:crypto';
|
||||
import { createProxyAdmin } from '../src/admin-control.mjs';
|
||||
import { createProxyAdmin, installedHarnesses, harnessesNamed, rootHarnessesNamed } from '../src/admin-control.mjs';
|
||||
import { pluginHash } from '../../plugins/src/pinned.mjs';
|
||||
import { installPlugin } from '../../plugins/src/install.mjs';
|
||||
import { KINDS } from '../../plugins/src/kinds.mjs';
|
||||
import { initFiles, receiptFile } from '../src/admin.mjs';
|
||||
import { PIN } from '../src/common.mjs';
|
||||
|
||||
@@ -15,7 +18,7 @@ const code = name => error => error.code === name;
|
||||
const SENTINEL = 'pa-sentinel-management-key-0123456789';
|
||||
const stopped = async () => ({ stopped: true, running: [] });
|
||||
|
||||
function fixture(t, { unitState = { installed: false, active: 'inactive', healthy: false }, restart = null, fetch = null, pin = PIN, statusHook = null } = {}) {
|
||||
function fixture(t, { unitState = { installed: false, active: 'inactive', healthy: false }, restart = null, fetch = null, pin = PIN, statusHook = null, extra = {} } = {}) {
|
||||
const root = fs.mkdtempSync(join(tmpdir(), 'pc-'));
|
||||
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
||||
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
||||
@@ -30,7 +33,7 @@ function fixture(t, { unitState = { installed: false, active: 'inactive', health
|
||||
stop: async () => { ops.push('stop'); return { ...unitState, active: 'inactive', pid: null }; },
|
||||
restart: async () => { ops.push('restart'); return restart ?? { state: unitState, evidence: { unit: 'mosaic-proxy-zz.service', confirmed: true, before: { pid: 10, since: 1, active: 'active' }, after: { pid: 11, since: 2, active: 'active', listening: true }, observedAt: new Date(0).toISOString() } }; },
|
||||
};
|
||||
const admin = createProxyAdmin({ dataRoot, configDir, unit, buses: stopped, fetch: fetch ?? (async () => ({})), now: () => new Date(0), orgs: async () => [{ id: 'acme', catalogue: 'ready' }], pin });
|
||||
const admin = createProxyAdmin({ dataRoot, configDir, unit, buses: stopped, fetch: fetch ?? (async () => ({})), now: () => new Date(0), orgs: async () => [{ id: 'acme', catalogue: 'ready' }], pin, ...extra });
|
||||
return { root, configDir, dataRoot, admin, ops, files: initFiles(configDir, dataRoot) };
|
||||
}
|
||||
const receipts = dataRoot => { try { return fs.readFileSync(receiptFile(dataRoot), 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse); } catch { return []; } };
|
||||
@@ -227,3 +230,340 @@ test('status carries the last receipts from proxy-admin.jsonl, so the page shows
|
||||
assert.equal(receipts.length, 10);
|
||||
assert.ok(receipts.every(r => r.op === 'unit.stop'));
|
||||
});
|
||||
|
||||
// #1873 settings-backend A1: the controller's three reads and the account-change record.
|
||||
function a1Fixture(t, { unitState = { installed: true, active: 'active', healthy: true }, log = undefined, statusError = false, env = {} } = {}) {
|
||||
const root = fs.mkdtempSync(join(tmpdir(), 'pc-'));
|
||||
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
|
||||
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
||||
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
|
||||
const calls = [];
|
||||
const unit = {
|
||||
unit: 'mosaic-proxy-zz.service',
|
||||
status: async () => { if (statusError) throw Object.assign(new Error('systemctl gone'), { code: 'proxy-unit-failed' }); return { unit: 'mosaic-proxy-zz.service', ...unitState }; },
|
||||
...(log === undefined ? { log: async (lines, options) => { calls.push({ lines, options }); return { unit: 'mosaic-proxy-zz.service', lines: ['ok'], redacted: 0, dropped: 0 }; } } : log === null ? {} : { log }),
|
||||
};
|
||||
const admin = createProxyAdmin({ dataRoot, configDir, unit, buses: stopped, now: () => new Date(0), env });
|
||||
return { admin, calls, configDir, dataRoot };
|
||||
}
|
||||
|
||||
test('log reads the unit journal with the env secrets; a missing unit or log reader is not-configured, an unreadable state outcome-unknown', async t => {
|
||||
const { admin, calls } = a1Fixture(t, { env: { MOSAIC_PROXY_KEY: 'plainwordsonly', PATH: '/usr/bin' } });
|
||||
assert.deepEqual(await admin.log(), { unit: 'mosaic-proxy-zz.service', lines: ['ok'], redacted: 0, dropped: 0 });
|
||||
assert.deepEqual(calls, [{ lines: 50, options: { secrets: ['plainwordsonly'] } }]);
|
||||
await admin.log({ lines: 7 });
|
||||
assert.equal(calls[1].lines, 7);
|
||||
await assert.rejects(a1Fixture(t, { unitState: { installed: false, active: 'inactive', healthy: false } }).admin.log(), code('not-configured'));
|
||||
await assert.rejects(a1Fixture(t, { log: null }).admin.log(), code('not-configured'));
|
||||
await assert.rejects(a1Fixture(t, { statusError: true }).admin.log(), code('outcome-unknown'));
|
||||
const failing = a1Fixture(t, { log: async () => { throw Object.assign(new Error('journal'), { code: 'outcome-unknown' }); } });
|
||||
await assert.rejects(failing.admin.log(), code('outcome-unknown'));
|
||||
});
|
||||
|
||||
test('serviceKey and history read the configured directories', async t => {
|
||||
const { admin, configDir, dataRoot } = a1Fixture(t);
|
||||
assert.equal(admin.serviceKey().problem, 'missing');
|
||||
fs.writeFileSync(join(configDir, 'proxy.json'), '{}', { mode: 0o600 });
|
||||
assert.equal(admin.serviceKey().problem, null);
|
||||
assert.match(admin.serviceKey().madeAt, /^\d{4}-\d\d-\d\dT/);
|
||||
assert.deepEqual(admin.history(), { entries: [], next: null });
|
||||
admin.recordAccount({ verb: 'proxy.login.status', result: { status: 'ok' } });
|
||||
assert.deepEqual(admin.history({ limit: 5 }), { entries: [{ time: new Date(0).toISOString(), op: 'account.proxy.login.complete' }], next: null });
|
||||
assert.equal(receipts(dataRoot).length, 1);
|
||||
});
|
||||
|
||||
test('history withholds an env secret a receipt holds', async t => {
|
||||
const { admin, dataRoot } = a1Fixture(t, { env: { PROXY_TOKEN: 'plainwordsonly' } });
|
||||
fs.mkdirSync(join(dataRoot, 'state'), { recursive: true, mode: 0o700 });
|
||||
fs.writeFileSync(receiptFile(dataRoot), JSON.stringify({ op: 'x', note: 'plain words only' }) + '\n', { mode: 0o600 });
|
||||
assert.deepEqual(admin.history().entries, [{ op: 'x', note: '[redacted]' }]);
|
||||
});
|
||||
|
||||
test('recordAccount records account changes by label only, never a key, login state, callback or model name', async t => {
|
||||
const { admin, dataRoot } = a1Fixture(t);
|
||||
const KEY = 'sk-proj-Ab3dE5fG7hJ9kL1mN3pQ5rS7tU9vW1xY';
|
||||
assert.equal(admin.recordAccount({ verb: 'proxy.apikey.add', args: { provider: 'openai', key: KEY }, result: { added: true }, user: 'jason', org: 'acme' }), true);
|
||||
assert.equal(admin.recordAccount({ verb: 'proxy.apikey.add', args: { provider: KEY, key: KEY } }), true);
|
||||
assert.equal(admin.recordAccount({ verb: 'proxy.login.status', args: { state: 'state-secret-123' }, result: { status: 'ok' } }), true);
|
||||
assert.equal(admin.recordAccount({ verb: 'proxy.login.status', args: { state: 'state-secret-123' }, result: { status: 'wait' } }), null);
|
||||
assert.equal(admin.recordAccount({ verb: 'proxy.priority.set', args: { accountId: '0123456789ab', priority: 2 } }), true);
|
||||
assert.equal(admin.recordAccount({ verb: 'proxy.group.models.set', args: { accountId: 'not-hex', models: ['secret-model-name', 'b'] }, org: '../x' }), true);
|
||||
for (const verb of ['proxy.login.start', 'proxy.login.submit', 'proxy.login.cancel', 'plugins.set', 'proxy.accounts', undefined]) {
|
||||
assert.equal(admin.recordAccount({ verb, args: { redirect_url: 'https://cb.example/?code=abc', provider: 'x' } }), null, String(verb));
|
||||
}
|
||||
const all = receipts(dataRoot);
|
||||
const at = new Date(0).toISOString();
|
||||
assert.deepEqual(all, [
|
||||
{ time: at, op: 'account.proxy.apikey.add', provider: 'openai', org: 'acme', user: 'jason' },
|
||||
{ time: at, op: 'account.proxy.apikey.add', provider: null },
|
||||
{ time: at, op: 'account.proxy.login.complete' },
|
||||
{ time: at, op: 'account.proxy.priority.set', accountId: '0123456789ab', priority: 2 },
|
||||
{ time: at, op: 'account.proxy.group.models.set', accountId: null, models: 2 },
|
||||
]);
|
||||
const text = fs.readFileSync(receiptFile(dataRoot), 'utf8');
|
||||
for (const bit of ['Ab3dE5', 'state-secret', 'secret-model', 'cb.example', 'code=abc']) assert.equal(text.includes(bit), false, bit);
|
||||
});
|
||||
|
||||
test('recordAccount answers false, and throws nothing, when the history cannot be written', async t => {
|
||||
const { admin, dataRoot } = a1Fixture(t);
|
||||
fs.mkdirSync(join(dataRoot, 'state'), { mode: 0o700 });
|
||||
fs.mkdirSync(receiptFile(dataRoot));
|
||||
assert.equal(admin.recordAccount({ verb: 'proxy.apikey.add', args: { provider: 'openai', key: 'k' } }), false);
|
||||
});
|
||||
|
||||
// #1873 settings-backend A2 (items 5 and 8): fake organizations behind the riders. The harness names
|
||||
// are made up; every answer carries a planted key, which no result, receipt or history entry may hold.
|
||||
const REV = 'a'.repeat(64), REV2 = 'b'.repeat(64);
|
||||
const PLANT = `mso-zz-acme-key-${'Q'.repeat(43)}`;
|
||||
const KEY_TEXT = /ms[kotp][-_][A-Za-z0-9_-]{6,}/;
|
||||
const busError = name => Object.assign(new Error(`refused ${PLANT}`), { code: name, reason: PLANT });
|
||||
function fakeOrg(id, { on = ['alpha', 'beta'], revision = REV, fileRevision = null, instances = {}, routesError = null, routesRevision = null, document = null, fileError = false, down = false, setError = null, keys = [], keysError = null, fixture = false, cliproxy = true, plugins = undefined } = {}) {
|
||||
const calls = [];
|
||||
const rider = {
|
||||
id, fixture, cliproxy, changes: '',
|
||||
file: () => { if (fileError) throw new Error(PLANT); return { document: document ?? { roles: {}, plugins: { harness: on }, secretNote: PLANT }, revision: fileRevision ?? revision }; },
|
||||
call: async (verb, args) => {
|
||||
calls.push(args === undefined ? [verb] : [verb, args]);
|
||||
if (down) throw busError('outcome-unknown');
|
||||
if (verb === 'plugins') return { business: id, revision, plugins: plugins !== undefined ? plugins : { harness: on, 'model-provider': ['cliproxy'] }, available: { harness: on }, note: PLANT };
|
||||
if (verb === 'routes') { if (routesError) throw busError(routesError); return { business: id, revision: routesRevision ?? revision, harnesses: on, models: ['m1'], providerModels: {}, levels: {}, instances, note: PLANT }; }
|
||||
if (verb === 'plugins.set') { if (setError) throw busError(setError); return { business: id, revision: REV2, plugins: args.plugins }; }
|
||||
if (verb === 'proxy.keys') { if (keysError) throw busError(keysError); return { keys }; }
|
||||
throw busError('invalid-request');
|
||||
},
|
||||
};
|
||||
return { rider, calls };
|
||||
}
|
||||
const NO_ROOT = { state: 'absent', agents: {}, assistant: null };
|
||||
const programsFixture = (t, orgs, extra = {}) => fixture(t, { extra: { riders: async () => orgs.map(o => o.rider), harnesses: () => ['alpha', 'beta', 'gamma'], rootAgents: () => NO_ROOT, ...extra } });
|
||||
const rootAgent = (vars, { definition = 'coder', excludeOrgs = [] } = {}) => ({ definition, title: 'Coder', vars, excludeOrgs });
|
||||
const route = harness => ({ harness, model: 'm1', thinking: null, fallback: null });
|
||||
|
||||
test('A2 item 5: the installed list comes from the harness plugin tree, and status lists it with no organization', async t => {
|
||||
const tree = new URL('../../plugins/harness/', import.meta.url);
|
||||
const fromTree = fs.readdirSync(tree).filter(name => { try { return fs.lstatSync(new URL(`${name}/index.mjs`, tree)).isFile(); } catch { return false; } }).sort();
|
||||
assert.ok(fromTree.length >= 1);
|
||||
assert.deepEqual(installedHarnesses(), fromTree);
|
||||
const { admin } = fixture(t);
|
||||
assert.deepEqual((await admin.status()).programs, { installed: fromTree, organizations: [] });
|
||||
});
|
||||
|
||||
test('A2 item 5: status names the programs each organization has on; one bus down is null and leaves the others', async t => {
|
||||
const acme = fakeOrg('acme', { on: ['alpha'] }), bolt = fakeOrg('bolt', { down: true }), crux = fakeOrg('crux', { plugins: { harness: 'alpha' } });
|
||||
const { admin } = programsFixture(t, [acme, bolt, crux]);
|
||||
const status = await admin.status();
|
||||
assert.deepEqual(status.programs, { installed: ['alpha', 'beta', 'gamma'], organizations: [{ id: 'acme', on: ['alpha'] }, { id: 'bolt', on: null }, { id: 'crux', on: null }] });
|
||||
assert.doesNotMatch(JSON.stringify(status), KEY_TEXT);
|
||||
});
|
||||
|
||||
test('A2 item 5: off skips a program any route still uses, whatever its model, and writes nothing there', async t => {
|
||||
// A role route, a fallback route, a project agent only the file shows, and a route whose model has
|
||||
// no known account kind: each keeps alpha on (the harness rule).
|
||||
const role = fakeOrg('role', { instances: { chief: route('alpha') } });
|
||||
const fallback = fakeOrg('fallback', { instances: { chief: { ...route('beta'), fallback: { harness: 'alpha', model: 'm1', thinking: null } } } });
|
||||
const project = fakeOrg('project', { routesError: 'launch-not-configured', document: { roles: {}, plugins: { harness: ['alpha', 'beta'] }, projects: { site: { agents: { dev: { definition: 'coder', vars: { harness: 'alpha' } } } } } } });
|
||||
const unknownKind = fakeOrg('unknown-kind', { instances: { chief: { harness: 'alpha', model: 'mystery-account-model', thinking: null, fallback: null } } });
|
||||
const { admin } = programsFixture(t, [role, fallback, project, unknownKind]);
|
||||
const out = await admin.programsOff({ name: 'alpha' });
|
||||
assert.deepEqual(out.results.map(r => [r.id, r.outcome]), [['role', 'in-use'], ['fallback', 'in-use'], ['project', 'in-use'], ['unknown-kind', 'in-use']]);
|
||||
for (const o of [role, fallback, project, unknownKind]) assert.equal(o.calls.some(([verb]) => verb === 'plugins.set'), false);
|
||||
});
|
||||
|
||||
test('A2 item 5: off turns the program off where nothing uses it, skips the last program, already off and unreadable, and reports bus down', async t => {
|
||||
const free = fakeOrg('free', { instances: { chief: route('beta') } });
|
||||
const last = fakeOrg('last', { on: ['alpha'] });
|
||||
const already = fakeOrg('already', { on: ['beta'] });
|
||||
const down = fakeOrg('down', { down: true });
|
||||
const unreadable = fakeOrg('unreadable', { fileError: true });
|
||||
const noFile = fakeOrg('no-file'); delete noFile.rider.file;
|
||||
const badRoutes = fakeOrg('bad-routes', { routesError: 'organization-invalid' });
|
||||
const { admin } = programsFixture(t, [free, last, already, down, unreadable, noFile, badRoutes]);
|
||||
const out = await admin.programsOff({ name: 'alpha', user: 'owner' });
|
||||
assert.equal(out.name, 'alpha');
|
||||
assert.deepEqual(out.results, [
|
||||
{ id: 'free', outcome: 'off' }, { id: 'last', outcome: 'last-program' }, { id: 'already', outcome: 'already-off' },
|
||||
{ id: 'down', outcome: 'bus-down' }, { id: 'unreadable', outcome: 'unreadable' }, { id: 'no-file', outcome: 'unreadable' }, { id: 'bad-routes', outcome: 'unreadable' },
|
||||
]);
|
||||
assert.deepEqual(free.calls.find(([verb]) => verb === 'plugins.set'), ['plugins.set', { revision: REV, plugins: { harness: ['beta'] } }]);
|
||||
for (const o of [last, already, down, unreadable, noFile, badRoutes]) assert.equal(o.calls.some(([verb]) => verb === 'plugins.set'), false);
|
||||
});
|
||||
|
||||
test('A2 item 5: a plugins.set refusal is reported per organization, and a revision change is reported once, never retried', async t => {
|
||||
const refused = fakeOrg('refused', { setError: 'unknown-plugin' });
|
||||
const raced = fakeOrg('raced', { setError: 'revision-conflict' });
|
||||
const moved = fakeOrg('moved', { fileRevision: REV2 });
|
||||
const ok = fakeOrg('ok');
|
||||
const { admin } = programsFixture(t, [refused, raced, moved, ok]);
|
||||
const out = await admin.programsOff({ name: 'alpha' });
|
||||
assert.deepEqual(out.results.map(r => r.outcome), ['failed:unknown-plugin', 'failed:revision-conflict', 'failed:revision-conflict', 'off']);
|
||||
assert.equal(raced.calls.filter(([verb]) => verb === 'plugins.set').length, 1);
|
||||
assert.equal(moved.calls.some(([verb]) => verb === 'plugins.set'), false);
|
||||
});
|
||||
|
||||
test('A2 item 5: off writes one receipt by name and outcome ids, and no answer, receipt or history entry holds a key', async t => {
|
||||
const a = fakeOrg('acme'), b = fakeOrg('bolt', { setError: 'invalid-plugins' });
|
||||
const { admin, dataRoot } = programsFixture(t, [a, b]);
|
||||
const out = await admin.programsOff({ name: 'beta', user: 'owner' });
|
||||
const record = { time: new Date(0).toISOString(), op: 'programs.off', name: 'beta', results: [{ id: 'acme', outcome: 'off' }, { id: 'bolt', outcome: 'failed:invalid-plugins' }], user: 'owner' };
|
||||
assert.deepEqual(out.receipt, record);
|
||||
assert.deepEqual(receipts(dataRoot), [record]);
|
||||
const history = admin.history({});
|
||||
assert.deepEqual(history.entries, [record]);
|
||||
for (const value of [out, receipts(dataRoot), history]) assert.doesNotMatch(JSON.stringify(value), KEY_TEXT);
|
||||
});
|
||||
|
||||
test('A2 item 5: an unknown name is invalid-request and calls no bus; two off calls at once give proxy-admin-busy for one', async t => {
|
||||
let release;
|
||||
const gate = new Promise(r => { release = r; });
|
||||
const slow = fakeOrg('slow');
|
||||
const original = slow.rider.call;
|
||||
// Blocks only from the busy part on, so a name check that lets a bad name through goes red, not hangs.
|
||||
let blocking = false;
|
||||
slow.rider.call = async (verb, args) => { if (verb === 'plugins' && blocking) await gate; return original(verb, args); };
|
||||
const { admin, dataRoot } = programsFixture(t, [slow]);
|
||||
await assert.rejects(admin.programsOff({ name: 'delta' }), code('invalid-request'));
|
||||
await assert.rejects(admin.programsOff({ name: 42 }), code('invalid-request'));
|
||||
assert.deepEqual(slow.calls, []);
|
||||
assert.deepEqual(receipts(dataRoot), []);
|
||||
blocking = true;
|
||||
const first = admin.programsOff({ name: 'alpha' });
|
||||
await new Promise(r => setImmediate(r));
|
||||
// Bounded: without the lock the second call would wait on the same gate, so it answers 'waited'.
|
||||
const second = admin.programsOff({ name: 'beta' }).then(() => 'answered', e => e?.code);
|
||||
assert.equal(await Promise.race([second, new Promise(r => setTimeout(() => r('waited'), 1000))]), 'proxy-admin-busy');
|
||||
release();
|
||||
await second;
|
||||
assert.deepEqual((await first).results, [{ id: 'slow', outcome: 'off' }]);
|
||||
assert.equal(receipts(dataRoot).length, 1);
|
||||
});
|
||||
|
||||
test('A2 item 5: an installed list that cannot be read refuses off as invalid-request', async t => {
|
||||
const a = fakeOrg('acme');
|
||||
const { admin } = programsFixture(t, [a], { harnesses: () => { throw new Error('unreadable tree'); } });
|
||||
await assert.rejects(admin.programsOff({ name: 'alpha' }), code('invalid-request'));
|
||||
assert.deepEqual(a.calls, []);
|
||||
assert.equal((await admin.status()).programs.installed, null);
|
||||
});
|
||||
|
||||
test('A2 item 5 (review P1-1): a root agent the organization takes keeps its program on; an excluded organization and the root assistant do not count', async t => {
|
||||
// Only the root agent file names alpha: nothing in either organization's file or routes does.
|
||||
const root = { state: 'ok', assistant: 'helper', agents: {
|
||||
writer: rootAgent({ harness: 'gamma', 'fallback.harness': 'alpha' }, { excludeOrgs: ['spare'] }),
|
||||
helper: rootAgent({ harness: 'beta' }, { definition: 'assistant' }),
|
||||
} };
|
||||
const takes = fakeOrg('takes', { on: ['alpha', 'beta', 'gamma'] });
|
||||
const spare = fakeOrg('spare', { on: ['alpha', 'beta', 'gamma'] });
|
||||
const { admin } = programsFixture(t, [takes, spare], { rootAgents: () => root });
|
||||
const out = await admin.programsOff({ name: 'alpha' });
|
||||
assert.deepEqual(out.results, [{ id: 'takes', outcome: 'in-use' }, { id: 'spare', outcome: 'off' }]);
|
||||
assert.equal(takes.calls.some(([verb]) => verb === 'plugins.set'), false);
|
||||
// The root assistant is not copied into an organization, so its harness does not keep beta on.
|
||||
const again = await admin.programsOff({ name: 'beta' });
|
||||
assert.deepEqual(again.results.map(r => r.outcome), ['off', 'off']);
|
||||
// The root file is read once per call, not once per organization.
|
||||
let reads = 0;
|
||||
const counted = programsFixture(t, [fakeOrg('a'), fakeOrg('b')], { rootAgents: () => { reads++; return NO_ROOT; } });
|
||||
await counted.admin.programsOff({ name: 'alpha' });
|
||||
assert.equal(reads, 1);
|
||||
});
|
||||
|
||||
test('A2 item 5 (review P1-1): a root agent file that cannot be read, or no reader, writes nothing where the program is on', async t => {
|
||||
const on = fakeOrg('on'), already = fakeOrg('already', { on: ['beta'] });
|
||||
const { admin } = programsFixture(t, [on, already], { rootAgents: () => { throw Object.assign(new Error(`root agent file refused ${PLANT}`), { name: 'BusinessError' }); } });
|
||||
const out = await admin.programsOff({ name: 'alpha' });
|
||||
assert.deepEqual(out.results, [{ id: 'on', outcome: 'unreadable' }, { id: 'already', outcome: 'already-off' }]);
|
||||
assert.doesNotMatch(JSON.stringify(out), KEY_TEXT);
|
||||
const bare = fakeOrg('bare');
|
||||
const none = fixture(t, { extra: { riders: async () => [bare.rider], harnesses: () => ['alpha', 'beta'] } });
|
||||
assert.deepEqual((await none.admin.programsOff({ name: 'alpha' })).results, [{ id: 'bare', outcome: 'unreadable' }]);
|
||||
for (const o of [on, already, bare]) assert.equal(o.calls.some(([verb]) => verb === 'plugins.set'), false);
|
||||
// A root answer of the wrong shape is unreadable too.
|
||||
assert.equal(rootHarnessesNamed({ agents: { w: { vars: { harness: 'alpha' } } } }, 'acme'), null);
|
||||
assert.equal(rootHarnessesNamed(null, 'acme'), null);
|
||||
assert.deepEqual([...rootHarnessesNamed(NO_ROOT, 'acme')], []);
|
||||
});
|
||||
|
||||
test('A2 item 5 (review P3-1): a revision that is not 64 hex, routes from another revision, and routes with no instances write nothing; later organizations still go', async t => {
|
||||
const badRev = fakeOrg('bad-rev', { revision: 'not-a-revision' });
|
||||
const routesMoved = fakeOrg('routes-moved', { routesRevision: REV2 });
|
||||
const noInstances = fakeOrg('no-instances', { instances: null });
|
||||
const after = fakeOrg('after');
|
||||
const { admin, dataRoot } = programsFixture(t, [badRev, routesMoved, noInstances, after]);
|
||||
const out = await admin.programsOff({ name: 'alpha' });
|
||||
assert.deepEqual(out.results, [{ id: 'bad-rev', outcome: 'unreadable' }, { id: 'routes-moved', outcome: 'failed:revision-conflict' }, { id: 'no-instances', outcome: 'unreadable' }, { id: 'after', outcome: 'off' }]);
|
||||
for (const o of [badRev, routesMoved, noInstances]) assert.equal(o.calls.some(([verb]) => verb === 'plugins.set'), false);
|
||||
assert.equal(receipts(dataRoot).length, 1);
|
||||
});
|
||||
|
||||
test('A2 item 5 (review P3-1): a harness program the instance plugin lock pins is listed as installed', t => {
|
||||
const root = fs.mkdtempSync(join(tmpdir(), 'pl-'));
|
||||
// The install leaves read-only directories; open them up before removing the tree.
|
||||
const thaw = p => { const st = fs.lstatSync(p); if (st.isSymbolicLink()) return; if (st.isDirectory()) { fs.chmodSync(p, 0o700); for (const n of fs.readdirSync(p)) thaw(join(p, n)); } };
|
||||
t.after(() => { thaw(root); fs.rmSync(root, { recursive: true, force: true }); });
|
||||
const src = join(root, 'src'), dataRoot = join(root, 'data');
|
||||
fs.mkdirSync(join(src, 'harness'), { recursive: true }); fs.mkdirSync(dataRoot);
|
||||
fs.writeFileSync(join(src, 'harness', 'index.mjs'), KINDS.harness.exports.map(name => `export function ${name}(){return ${name === 'levels' ? "['high']" : name === 'countsAccount' ? 'true' : 'null'};}`).join('\n') + '\nexport const interfaceVersion=1;');
|
||||
const manifest = { name: 'zetaplug', version: '1.0.0', kinds: ['harness'], interfaceVersions: { harness: 1 }, sha256: '0'.repeat(64), source: { path: 'fixture', version: '1.0.0' }, signature: null, tools: [], actions: [], services: [], roleTemplates: [] };
|
||||
fs.writeFileSync(join(src, 'plugin.json'), JSON.stringify(manifest));
|
||||
manifest.sha256 = pluginHash(src);
|
||||
fs.writeFileSync(join(src, 'plugin.json'), JSON.stringify(manifest));
|
||||
assert.equal(installedHarnesses(dataRoot).includes('zetaplug'), false);
|
||||
installPlugin({ dataRoot, source: src, expectedHash: manifest.sha256 });
|
||||
const listed = installedHarnesses(dataRoot);
|
||||
assert.ok(listed.includes('zetaplug'));
|
||||
assert.deepEqual(listed.filter(n => n !== 'zetaplug'), installedHarnesses());
|
||||
});
|
||||
|
||||
test('A2 item 5 (review P3-3): an organization whose harness list holds anything but plugin names reads on: null', async t => {
|
||||
const odd = fakeOrg('odd', { plugins: { harness: ['alpha', `bad ${PLANT}`] } });
|
||||
const fine = fakeOrg('fine', { on: ['alpha'] });
|
||||
const { admin } = programsFixture(t, [odd, fine]);
|
||||
const status = await admin.status();
|
||||
assert.deepEqual(status.programs.organizations, [{ id: 'odd', on: null }, { id: 'fine', on: ['alpha'] }]);
|
||||
assert.doesNotMatch(JSON.stringify(status), KEY_TEXT);
|
||||
});
|
||||
|
||||
test('A2: harnessesNamed reads every harness and fallback.harness string outside the plugins list', () => {
|
||||
assert.deepEqual([...harnessesNamed({ plugins: { harness: ['alpha'] }, roles: { a: { vars: { harness: 'beta', 'fallback.harness': 'gamma' } } }, projects: { p: { agents: { x: { vars: { harness: 'delta' } } } } } })].sort(), ['beta', 'delta', 'gamma']);
|
||||
assert.equal(harnessesNamed(null), null);
|
||||
assert.equal(harnessesNamed([]), null);
|
||||
});
|
||||
|
||||
const key = (keyId, management, state, agent = 'dev') => ({ keyId, management, agent, issuedAt: '2026-11-01T10:00:00.000Z', state });
|
||||
test('A2 item 8: access gives each organization a health and key ids, never a key, and never reads the usage queue', async t => {
|
||||
const ok = fakeOrg('ok', { keys: [key('0123456789ab', 'stack-managed', 'active'), key('ba9876543210', 'not stack-managed', null, null), key('aaaaaaaaaaaa', 'sentinel', null, null)] });
|
||||
const attention = fakeOrg('attention', { keys: [key('0123456789ab', 'stack-managed', 'active'), key('bbbbbbbbbbbb', 'stack-managed', 'revoked')] });
|
||||
const missing = fakeOrg('missing', { keys: [key('cccccccccccc', 'not stack-managed', null, null)] });
|
||||
const fixtureOrg = fakeOrg('fixture', { fixture: true });
|
||||
const ownModels = fakeOrg('own', { cliproxy: false });
|
||||
const down = fakeOrg('down', { down: true });
|
||||
const noClient = fakeOrg('no-client', { keysError: 'not-configured' });
|
||||
const uncertain = fakeOrg('uncertain', { keysError: 'proxy-uncertain' });
|
||||
const proxyDown = fakeOrg('proxy-down', { keysError: 'proxy-down' });
|
||||
const badShape = fakeOrg('bad-shape', { keys: 'none' });
|
||||
const planted = fakeOrg('planted', { keys: [key('dddddddddddd', 'stack-managed', PLANT, PLANT), { ...key('eeeeeeeeeeee', 'stack-managed', 'active'), value: PLANT, issuedAt: PLANT }] });
|
||||
const plantedId = fakeOrg('planted-id', { keys: [key(PLANT, 'stack-managed', 'active')] });
|
||||
const unread = fakeOrg('unread'); unread.rider.fixture = undefined;
|
||||
const all = [ok, attention, missing, fixtureOrg, ownModels, down, noClient, uncertain, proxyDown, badShape, planted, plantedId, unread];
|
||||
const { admin } = programsFixture(t, all);
|
||||
const out = await admin.access();
|
||||
assert.deepEqual(out.organizations, [
|
||||
{ id: 'ok', health: 'ok', keys: [{ keyId: '0123456789ab', agent: 'dev', state: 'active', issuedAt: '2026-11-01T10:00:00.000Z' }], other: 1, sentinel: 1 },
|
||||
{ id: 'attention', health: 'attention', keys: [{ keyId: '0123456789ab', agent: 'dev', state: 'active', issuedAt: '2026-11-01T10:00:00.000Z' }, { keyId: 'bbbbbbbbbbbb', agent: 'dev', state: 'revoked', issuedAt: '2026-11-01T10:00:00.000Z' }], other: 0, sentinel: 0 },
|
||||
{ id: 'missing', health: 'missing', keys: [], other: 1, sentinel: 0 },
|
||||
{ id: 'fixture', health: 'not-riding', keys: [] },
|
||||
{ id: 'own', health: 'not-riding', keys: [] },
|
||||
{ id: 'down', health: 'unreadable', reason: 'bus-down', keys: [] },
|
||||
{ id: 'no-client', health: 'unreadable', reason: 'no-proxy-client', keys: [] },
|
||||
{ id: 'uncertain', health: 'attention', reason: 'proxy-uncertain', keys: [] },
|
||||
{ id: 'proxy-down', health: 'unreadable', reason: 'unreadable', keys: [] },
|
||||
{ id: 'bad-shape', health: 'unreadable', reason: 'unreadable', keys: [] },
|
||||
{ id: 'planted', health: 'attention', keys: [{ keyId: 'dddddddddddd', agent: null, state: null, issuedAt: '2026-11-01T10:00:00.000Z' }, { keyId: 'eeeeeeeeeeee', agent: 'dev', state: 'active', issuedAt: null }], other: 0, sentinel: 0 },
|
||||
{ id: 'planted-id', health: 'unreadable', reason: 'unreadable', keys: [] },
|
||||
{ id: 'unread', health: 'unreadable', reason: 'unreadable', keys: [] },
|
||||
]);
|
||||
assert.doesNotMatch(JSON.stringify(out), KEY_TEXT);
|
||||
assert.notEqual(out.organizations.find(o => o.id === 'uncertain').health, 'ok');
|
||||
// proxy.keys is the only verb access sends; the usage queue is never read.
|
||||
for (const o of all) for (const [verb] of o.calls) assert.equal(verb, 'proxy.keys');
|
||||
});
|
||||
@@ -6,12 +6,15 @@ import fs from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { createHash } from 'node:crypto';
|
||||
import { execFileSync } from 'node:child_process';
|
||||
import { PIN } from '../src/common.mjs';
|
||||
import { installPaths } from '../src/settings.mjs';
|
||||
import {
|
||||
processTree, pidListensOn, processStartMs, verifyRestart, initLockStatus, clearInitLock, initFiles, initState,
|
||||
fenceState, createUnitControl, releaseState, receiptFile, unitName,
|
||||
unitLog, serviceKeyState, receiptHistory, appendReceipt, LOG_LINES, HISTORY_LIMIT,
|
||||
} from '../src/admin.mjs';
|
||||
import { secretValues } from '../src/redact.mjs';
|
||||
|
||||
const code = name => error => error.code === name;
|
||||
const scratch = t => { const dir = fs.mkdtempSync(join(tmpdir(), 'pa-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true })); return dir; };
|
||||
@@ -193,3 +196,198 @@ test('unit actions map proxy-service refusals by code and refuse a missing unit'
|
||||
assert.equal(started.healthy, true); assert.deepEqual(verbs, ['start']);
|
||||
assert.throws(() => createUnitControl({ unitDir: 'relative' }), code('proxy-unit-path'));
|
||||
});
|
||||
|
||||
// #1873 settings-backend A1: the reads behind the setup page's log, service key and history.
|
||||
// Planted keys, one of each Mosaic prefix and short enough that only the prefix rule finds them,
|
||||
// plus long ones of the real shapes.
|
||||
const TAIL = 'Ab3_dE5-fG7hJ9kL1mN3pQ5rS7tU9vW1xY3zA5bC7dE';
|
||||
const PLANTED = ['msk-tag-qwertyu', 'mso-tag-acme-qwerty', 'mst-tag-triage-zxcvb', 'msp-tag-plmokn',
|
||||
`msk-k1a2-${TAIL}`, `mso-k1a2-acme-${TAIL}`, `mst-k1a2-triage-${TAIL}`, `msp-k1a2-${TAIL}`];
|
||||
const ENV_SECRET = 'plainwordsonly';
|
||||
const leaks = text => [...PLANTED, ...PLANTED.map(k => k.slice(4)), TAIL.slice(0, 10), ENV_SECRET].filter(bit => text.includes(bit));
|
||||
|
||||
function journal(stdout, { code: exit = 0, calls = [] } = {}) {
|
||||
return async (command, args, options) => { calls.push({ command, args, options }); if (stdout instanceof Error) throw stdout; return { code: exit, stdout, stderr: 'raw stderr msk-tag-qwertyu' }; };
|
||||
}
|
||||
|
||||
test('unitLog asks journalctl for the named unit only, clamps the line count, and shows no planted key', async () => {
|
||||
const calls = [];
|
||||
const lines = ['proxy listening on 127.0.0.1:18432', ...PLANTED.map(k => `upstream refused ${k} for model x`), `auth with ${ENV_SECRET} ok`, 'msk-tag-qwertyu', '', 'last line'];
|
||||
const result = await unitLog({ run: journal(lines.join('\n') + '\n', { calls }), unit: 'mosaic-proxy-zz.service', lines: 10000, env: { X: '1' }, secrets: secretValues({ PROXY_KEY: ENV_SECRET }) });
|
||||
assert.deepEqual(calls[0].args, ['--user', '-u', 'mosaic-proxy-zz.service', '-n', String(LOG_LINES.max), '-o', 'cat', '--no-pager', '-q']);
|
||||
assert.equal(calls[0].command, 'journalctl');
|
||||
assert.deepEqual(calls[0].options.env, { X: '1' });
|
||||
assert.equal(result.unit, 'mosaic-proxy-zz.service');
|
||||
assert.equal(result.lines[0], 'proxy listening on 127.0.0.1:18432', 'a line with nothing secret shows as it is');
|
||||
assert.equal(result.lines.at(-1), 'last line');
|
||||
assert.equal(result.lines.filter(l => l === 'upstream refused [redacted] for model x').length, PLANTED.length);
|
||||
assert.equal(result.redacted, PLANTED.length, 'shown lines with a redaction; dropped lines count in dropped');
|
||||
assert.equal(result.dropped, 2, 'the env-secret line and the key-only line are dropped, the blank one is not counted');
|
||||
assert.deepEqual(leaks(JSON.stringify(result)), []);
|
||||
// At least one line, and a line count that is not an integer is refused.
|
||||
await unitLog({ run: journal('x\n', { calls }), unit: 'mosaic-proxy.service', lines: 0 });
|
||||
assert.equal(calls.at(-1).args[4], '1');
|
||||
await assert.rejects(unitLog({ run: journal('x\n'), unit: 'mosaic-proxy.service', lines: 2.5 }), code('invalid-request'));
|
||||
await assert.rejects(unitLog({ run: journal('x\n'), unit: 'mosaic-proxy.service', lines: '5' }), code('invalid-request'));
|
||||
});
|
||||
|
||||
test('unitLog keeps only the last lines asked for and never takes a unit name it was not given by unitName', async () => {
|
||||
const many = Array.from({ length: 30 }, (_, i) => `line ${i}`).join('\n');
|
||||
assert.deepEqual((await unitLog({ run: journal(many), unit: 'mosaic-proxy.service', lines: 3 })).lines, ['line 27', 'line 28', 'line 29']);
|
||||
for (const unit of ['sshd.service', 'mosaic-proxy.service; rm', '../mosaic-proxy.service', 'mosaic-proxy-A.service', undefined]) {
|
||||
await assert.rejects(unitLog({ run: journal('x'), unit, lines: 5 }), code('proxy-unit-usage'), String(unit));
|
||||
}
|
||||
});
|
||||
|
||||
test('a journal that cannot be read refuses outcome-unknown with no lines and no other source', async () => {
|
||||
for (const run of [journal(Object.assign(new Error('spawn journalctl ENOENT'), { code: 'ENOENT' })), journal('partial msk-tag-qwertyu', { code: 1 }), async () => ({ code: 0, stdout: null }), async () => null]) {
|
||||
await assert.rejects(unitLog({ run, unit: 'mosaic-proxy.service', lines: 5 }), error => error.code === 'outcome-unknown' && !leaks(String(error.message) + JSON.stringify(error)).length);
|
||||
}
|
||||
});
|
||||
|
||||
test('a secret split across journal lines drops every line', async () => {
|
||||
const result = await unitLog({ run: journal('ok one\nplain\nwordsonly\nok two\n'), unit: 'mosaic-proxy.service', lines: 10, secrets: [ENV_SECRET] });
|
||||
assert.deepEqual(result.lines, []);
|
||||
assert.equal(result.dropped, 4);
|
||||
});
|
||||
|
||||
test('createUnitControl.log runs unitLog for its own unit', async () => {
|
||||
const calls = [];
|
||||
const control = createUnitControl({ instance: 'zz', port: () => 1, run: journal('hello msk-tag-qwertyu\n', { calls }), probe: async () => true, waitMs: 0, pollMs: 0 });
|
||||
assert.deepEqual(await control.log(5), { unit: 'mosaic-proxy-zz.service', lines: ['hello [redacted]'], redacted: 1, dropped: 0 });
|
||||
assert.equal(calls[0].args[2], 'mosaic-proxy-zz.service');
|
||||
});
|
||||
|
||||
test('serviceKeyState answers proxy.json\'s mtime and never opens or stats the key file', t => {
|
||||
const dir = scratch(t);
|
||||
assert.deepEqual(serviceKeyState(dir), { madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'missing' });
|
||||
const files = initFiles(dir, join(dir, 'data'));
|
||||
fs.writeFileSync(files.settings, '{}', { mode: 0o600 });
|
||||
fs.mkdirSync(join(files.key, '..'), { recursive: true, mode: 0o700 });
|
||||
fs.writeFileSync(files.key, 'msk-k1a2-' + TAIL, { mode: 0o600 });
|
||||
fs.utimesSync(join(dir, 'proxy.json'), new Date(Date.UTC(2026, 10, 1, 8)), new Date(Date.UTC(2026, 10, 1, 8)));
|
||||
const spies = ['openSync', 'readFileSync', 'statSync', 'lstatSync', 'accessSync', 'existsSync', 'realpathSync', 'readdirSync'].map(name => t.mock.method(fs, name));
|
||||
const state = serviceKeyState(dir);
|
||||
const seen = spies.flatMap(spy => spy.mock.calls.map(call => String(call.arguments[0])));
|
||||
spies.forEach(spy => spy.mock.restore());
|
||||
assert.deepEqual(state, { madeAt: '2026-11-01T08:00:00.000Z', renewedAt: null, renewal: 'not-built', problem: null });
|
||||
assert.deepEqual(seen, [join(dir, 'proxy.json')]);
|
||||
assert.deepEqual(leaks(JSON.stringify(state)), []);
|
||||
});
|
||||
|
||||
test('serviceKeyState gives no date for a proxy.json that is a symlink, a directory or another user\'s', t => {
|
||||
const dir = scratch(t), other = scratch(t);
|
||||
fs.writeFileSync(join(other, 'real.json'), '{}');
|
||||
fs.symlinkSync(join(other, 'real.json'), join(dir, 'proxy.json'));
|
||||
assert.deepEqual(serviceKeyState(dir), { madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'unreadable' });
|
||||
fs.rmSync(join(dir, 'proxy.json')); fs.mkdirSync(join(dir, 'proxy.json'));
|
||||
assert.equal(serviceKeyState(dir).problem, 'unreadable');
|
||||
fs.rmSync(join(dir, 'proxy.json'), { recursive: true }); fs.writeFileSync(join(dir, 'proxy.json'), '{}');
|
||||
assert.equal(serviceKeyState(dir, { uid: process.getuid() + 1 }).problem, 'unreadable');
|
||||
assert.equal(serviceKeyState(dir).problem, null);
|
||||
});
|
||||
|
||||
// A receipt file with `count` entries; some lines padded so the file crosses several 64 KB chunks.
|
||||
function history(t, count, { pad = 0 } = {}) {
|
||||
const dataRoot = scratch(t);
|
||||
for (let i = 0; i < count; i++) appendReceipt(dataRoot, { time: new Date(i * 1000).toISOString(), op: 'fetch', n: i, ...(pad ? { note: 'word '.repeat(pad) } : {}) });
|
||||
return dataRoot;
|
||||
}
|
||||
const pages = (dataRoot, limit, extra = {}) => {
|
||||
const seen = []; let before = null, guard = 0;
|
||||
do {
|
||||
const page = receiptHistory(dataRoot, { limit, before, ...extra });
|
||||
seen.push(page.entries.map(e => e.n));
|
||||
before = page.next;
|
||||
} while (before !== null && ++guard < 1000);
|
||||
return seen;
|
||||
};
|
||||
|
||||
test('receiptHistory pages newest first, oldest first within a page, each entry exactly once across chunks', t => {
|
||||
const dataRoot = history(t, 300, { pad: 150 });
|
||||
assert.ok(fs.statSync(receiptFile(dataRoot)).size > 3 * 65536, 'the file spans several chunks');
|
||||
const seen = pages(dataRoot, 7);
|
||||
assert.deepEqual(seen[0], [293, 294, 295, 296, 297, 298, 299]);
|
||||
assert.deepEqual(seen.flat().sort((a, b) => a - b), Array.from({ length: 300 }, (_, i) => i));
|
||||
assert.equal(new Set(seen.flat()).size, 300);
|
||||
assert.deepEqual(seen.reverse().flat(), Array.from({ length: 300 }, (_, i) => i), 'pages read back to front are the whole history in order');
|
||||
const first = receiptHistory(dataRoot);
|
||||
assert.equal(first.entries.length, HISTORY_LIMIT.default);
|
||||
assert.equal(receiptHistory(dataRoot, { limit: 1000 }).entries.length, HISTORY_LIMIT.max, 'limit is clamped');
|
||||
assert.equal(receiptHistory(dataRoot, { limit: 0 }).entries.length, 1);
|
||||
assert.deepEqual(Object.keys(first.entries[0]).sort(), ['n', 'note', 'op', 'time']);
|
||||
});
|
||||
|
||||
test('receiptHistory skips a torn line and a partial last line, and a write after a page does not repeat or lose entries', t => {
|
||||
const dataRoot = history(t, 5);
|
||||
const file = receiptFile(dataRoot);
|
||||
const text = fs.readFileSync(file, 'utf8').split('\n');
|
||||
text.splice(2, 0, '{"op":"torn', '[1,2]', '{"no":"op"}', 'x'.repeat(70000));
|
||||
// The last line is a whole object whose newline is not written yet: it waits for the newline.
|
||||
fs.writeFileSync(file, text.join('\n') + '{"op":"partial","n":99}');
|
||||
const first = receiptHistory(dataRoot, { limit: 2 });
|
||||
assert.deepEqual(first.entries.map(e => e.n), [3, 4]);
|
||||
assert.deepEqual(receiptHistory(dataRoot, { limit: 1 }).entries.map(e => e.n), [4], 'not shown before its newline');
|
||||
fs.appendFileSync(file, '\n'); appendReceipt(dataRoot, { op: 'fetch', n: 100 });
|
||||
const rest = receiptHistory(dataRoot, { limit: 10, before: first.next });
|
||||
assert.deepEqual(rest.entries.map(e => e.n), [0, 1, 2]);
|
||||
assert.equal(rest.next, null);
|
||||
assert.deepEqual(receiptHistory(dataRoot, { limit: 3 }).entries.map(e => e.n), [4, 99, 100], 'the finished line shows on the next newest read');
|
||||
});
|
||||
|
||||
test('receiptHistory refuses a cursor that is not a line start, past the end, negative or not an integer', t => {
|
||||
const dataRoot = history(t, 3);
|
||||
const size = fs.statSync(receiptFile(dataRoot)).size;
|
||||
for (const before of [1, size + 1, -1, 1.5, '10', Number.MAX_SAFE_INTEGER + 2]) {
|
||||
assert.throws(() => receiptHistory(dataRoot, { before }), code('invalid-request'), String(before));
|
||||
}
|
||||
assert.throws(() => receiptHistory(dataRoot, { limit: 'all' }), code('invalid-request'));
|
||||
assert.deepEqual(receiptHistory(dataRoot, { before: 0 }), { entries: [], next: null });
|
||||
assert.equal(receiptHistory(dataRoot, { before: size }).entries.length, 3);
|
||||
});
|
||||
|
||||
test('receiptHistory withholds an entry whose fields hold an environment secret split across them', t => {
|
||||
const dataRoot = scratch(t);
|
||||
appendReceipt(dataRoot, { op: 'fetch', n: 1 });
|
||||
appendReceipt(dataRoot, { op: 'x', a: 'plainword', b: 'sonly' });
|
||||
appendReceipt(dataRoot, { op: 'x', plainw: 'ordsonly' });
|
||||
appendReceipt(dataRoot, { op: 'x', list: ['plainwo', 'rdsonly'] });
|
||||
appendReceipt(dataRoot, { op: 'fetch', n: 2 });
|
||||
const all = receiptHistory(dataRoot, { limit: 10, secrets: secretValues({ PROXY_TOKEN: ENV_SECRET }) });
|
||||
assert.deepEqual(all.entries, [{ op: 'fetch', n: 1 }, { withheld: true }, { withheld: true }, { withheld: true }, { op: 'fetch', n: 2 }]);
|
||||
assert.equal(receiptHistory(dataRoot, { limit: 10 }).entries[1].a, 'plainword', 'with no secrets nothing is withheld');
|
||||
});
|
||||
|
||||
test('receiptHistory: a missing file is an empty history; a symlink, FIFO, directory, group-readable or foreign file refuses', t => {
|
||||
const dataRoot = scratch(t);
|
||||
assert.deepEqual(receiptHistory(dataRoot), { entries: [], next: null });
|
||||
assert.throws(() => receiptHistory(dataRoot, { before: 5 }), code('invalid-request'));
|
||||
appendReceipt(dataRoot, { op: 'fetch' });
|
||||
const file = receiptFile(dataRoot);
|
||||
fs.chmodSync(file, 0o640);
|
||||
assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown'));
|
||||
fs.chmodSync(file, 0o600);
|
||||
assert.throws(() => receiptHistory(dataRoot, { uid: process.getuid() + 1 }), code('outcome-unknown'));
|
||||
assert.equal(receiptHistory(dataRoot).entries.length, 1);
|
||||
const elsewhere = join(scratch(t), 'x.jsonl'); fs.writeFileSync(elsewhere, '{"op":"planted"}\n', { mode: 0o600 });
|
||||
fs.rmSync(file); fs.symlinkSync(elsewhere, file);
|
||||
assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown'));
|
||||
fs.rmSync(file); fs.mkdirSync(file);
|
||||
assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown'));
|
||||
fs.rmSync(file, { recursive: true });
|
||||
execFileSync('mkfifo', ['-m', '600', file]);
|
||||
assert.throws(() => receiptHistory(dataRoot), code('outcome-unknown'), 'a FIFO is refused without blocking');
|
||||
});
|
||||
|
||||
test('receiptHistory shows no planted key from any receipt field, nested value or key name', t => {
|
||||
const dataRoot = scratch(t);
|
||||
for (const key of PLANTED) appendReceipt(dataRoot, { time: new Date(0).toISOString(), op: 'init', note: `made ${key}`, nested: { list: [key, { deeper: key }] }, [key.replace(/-/g, '_')]: 1 });
|
||||
appendReceipt(dataRoot, { op: 'init', env: ENV_SECRET, [`x${ENV_SECRET}`]: 1 });
|
||||
appendReceipt(dataRoot, { op: PLANTED[1] });
|
||||
const all = receiptHistory(dataRoot, { limit: 100, secrets: secretValues({ PROXY_TOKEN: ENV_SECRET }) });
|
||||
assert.equal(all.entries.length, PLANTED.length + 2);
|
||||
assert.deepEqual(leaks(JSON.stringify(all)), []);
|
||||
assert.deepEqual(all.entries[0], { time: new Date(0).toISOString(), op: 'init', note: 'made [redacted]', nested: { list: ['[redacted]', { deeper: '[redacted]' }] } });
|
||||
assert.deepEqual(all.entries.at(-2), { op: 'init', env: '[redacted]' });
|
||||
assert.deepEqual(all.entries.at(-1), { op: '[redacted]' });
|
||||
});
|
||||
@@ -0,0 +1,122 @@
|
||||
// #1873 settings-backend A1: the redaction the setup page's log and history reads use. It is
|
||||
// chat-fail's list (packages/harness/src/failure-notice.mjs) with Mosaic's key prefixes added.
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { redactLine, redactValue, holdsSecret, secretValues, REDACTED, LINE_MAX } from '../src/redact.mjs';
|
||||
|
||||
// Short keys of each Mosaic prefix, letters only, so no long-run or mixed-run rule catches them:
|
||||
// only the key-prefix line does.
|
||||
const SHORT = { msk: 'msk-tag-qwertyu', mso: 'mso-tag-acme-qwerty', mst: 'mst-tag-triage-zxcvb', msp: 'msp-tag-plmokn' };
|
||||
|
||||
for (const [prefix, key] of Object.entries(SHORT)) {
|
||||
test(`a short ${prefix}- key is redacted from a line, and the rest of the line stays`, () => {
|
||||
const safe = redactLine(`proxy said ${key} was refused`);
|
||||
assert.equal(safe.text, `proxy said ${REDACTED} was refused`);
|
||||
assert.equal(safe.redacted, true);
|
||||
assert.equal(safe.text.includes(key), false);
|
||||
// Upper case, and joined by _ instead of -, too.
|
||||
assert.equal(redactLine(`proxy said ${key.toUpperCase()} x`).text, `proxy said ${REDACTED} x`);
|
||||
assert.equal(redactLine(`proxy said ${key.replace('-', '_')} x`).text, `proxy said ${REDACTED} x`);
|
||||
});
|
||||
}
|
||||
|
||||
test('a short Mosaic key glued to a word or an underscore is redacted', () => {
|
||||
for (const key of Object.values(SHORT)) {
|
||||
for (const glued of [`x${key}`, `_${key}`, `id=x${key}`, `9${key.toUpperCase()}`]) {
|
||||
const safe = redactLine(`proxy said ${glued} was refused`);
|
||||
assert.equal(safe.redacted, true, glued);
|
||||
assert.equal(safe.text.toLowerCase().includes(key.slice(4)), false, glued);
|
||||
assert.match(safe.text, / was refused$/);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('the real key shapes of each prefix are redacted', () => {
|
||||
const tail = 'Ab3_dE5-fG7hJ9kL1mN3pQ5rS7tU9vW1xY3zA5bC7dE';
|
||||
for (const key of [`msk-k1a2-${tail}`, `mso-k1a2-acme-${tail}`, `mst-k1a2-triage-${tail}`, `msp-k1a2-${tail}`, `sk-ant-${tail}`]) {
|
||||
const safe = redactLine(`key ${key} rejected by upstream`);
|
||||
assert.equal(safe.text.includes(key.slice(0, 12)), false, key.slice(0, 4));
|
||||
assert.equal(safe.text.includes(tail.slice(0, 8)), false, key.slice(0, 4));
|
||||
}
|
||||
});
|
||||
|
||||
test('bearer and basic tokens, key=value pairs, links, emails and paths never show', () => {
|
||||
const line = 'POST https://u:[email protected]/v1?key=abc Authorization: Bearer abcdefgh api_key=hunter2 token "quoted value" '
|
||||
+ 'by [email protected] from /home/jane/.config/mosaic-dev/proxy.json and ~/.mosaic/x C:\\Users\\j \\\\host\\share Basic dXNlcjpwYXNz eyJhbGciOi.x.y';
|
||||
const safe = redactLine(line);
|
||||
for (const bit of ['u:p@', 'api.example', 'abcdefgh', 'hunter2', 'quoted value', 'jane@', '/home/jane', '.config', '.mosaic', 'Users', 'share', 'dXNlcjpwYXNz', 'eyJhbGci']) {
|
||||
assert.equal(safe.text.includes(bit), false, bit);
|
||||
}
|
||||
assert.match(safe.text, /^POST /);
|
||||
});
|
||||
|
||||
test('a line holding an environment secret is withheld whole, even split by spaces, controls or encoding', () => {
|
||||
const secrets = secretValues({ MOSAIC_PROXY_KEY: 'plainwordsonly', HOME: '/home/x', SHORT_TOKEN: 'abc' });
|
||||
assert.deepEqual(secrets, ['plainwordsonly'], 'only secret-named values of 8 or more characters');
|
||||
for (const line of ['started with plainwordsonly', 'started with plain words only', 'started p\u0000lainwords\u200bonly', 'started %70lainwordsonly', 'started plainwordsonly']) {
|
||||
assert.deepEqual(redactLine(line, secrets), { text: null, redacted: true, withheld: true }, JSON.stringify(line));
|
||||
}
|
||||
assert.equal(holdsSecret('plain\nwords\nonly', secrets), true, 'split across lines');
|
||||
assert.equal(holdsSecret('nothing here', secrets), false);
|
||||
assert.equal(holdsSecret('plainwordsonly', []), false);
|
||||
});
|
||||
|
||||
test('a line that is empty, blank or only redactions is dropped; a long one is cut to the line cap', () => {
|
||||
assert.deepEqual(redactLine(''), { text: null, redacted: false });
|
||||
assert.deepEqual(redactLine(' \u0000\t '), { text: null, redacted: false });
|
||||
assert.deepEqual(redactLine(`${SHORT.mso} ${SHORT.mst}`), { text: null, redacted: true });
|
||||
assert.equal(redactLine(`a ${SHORT.mso} ${SHORT.mst} b`).text, `a ${REDACTED} b`, 'repeated redactions collapse');
|
||||
const long = redactLine('word '.repeat(200));
|
||||
assert.equal(Array.from(long.text).length, LINE_MAX);
|
||||
assert.match(long.text, /\.\.\.$/);
|
||||
assert.equal(redactLine('\u001b[31mred\u001b[0m text').text, 'red text', 'ANSI goes');
|
||||
});
|
||||
|
||||
test('a stored value is redacted all through: strings, nested strings, and keys that read as secrets', () => {
|
||||
const value = { op: 'account.proxy.apikey.add', time: '2026-11-19T12:34:56.789Z', provider: 'openai', note: `got ${SHORT.mso}`, deep: { list: [SHORT.msk, 3, true, null] }, [SHORT.mst.replace(/-/g, '_')]: 'x', 'bad key': 1 };
|
||||
const out = redactValue(value);
|
||||
assert.deepEqual(out, { op: 'account.proxy.apikey.add', time: '2026-11-19T12:34:56.789Z', provider: 'openai', note: `got ${REDACTED}`, deep: { list: [REDACTED, 3, true, null] } });
|
||||
assert.equal(JSON.stringify(out).includes('qwerty'), false);
|
||||
// Depth and size are bounded.
|
||||
assert.deepEqual(redactValue({ a: { b: { c: { d: { e: 1 } } } } }), { a: { b: { c: { d: null } } } });
|
||||
assert.equal(redactValue(Array.from({ length: 100 }, (_, i) => i)).length, 64);
|
||||
assert.equal(redactValue('plainwordsonly', ['plainwordsonly']), REDACTED);
|
||||
assert.equal(redactValue(undefined), null);
|
||||
});
|
||||
|
||||
// chat-fail's shape: redaction runs over a whole line before the cut, so a long run with no spaces
|
||||
// must stay linear.
|
||||
test('a 128000-character run with no spaces is redacted in well under a second', () => {
|
||||
const N = 128000;
|
||||
const secrets = secretValues({ API_KEY: 'plainwordsonly' });
|
||||
for (const run of ['a'.repeat(N), 'a.'.repeat(N / 2), 'a-'.repeat(N / 2), 'a/'.repeat(N / 2), 'a:'.repeat(N / 2), 'a"'.repeat(N / 2), 'mso-'.repeat(N / 4), 'a@'.repeat(N / 2)]) {
|
||||
const started = performance.now();
|
||||
const safe = redactLine(`${run} then the unit stopped`, secrets);
|
||||
const took = performance.now() - started;
|
||||
assert.ok(took < 1000, `${run.slice(0, 4)}... took ${Math.round(took)} ms`);
|
||||
assert.ok(safe.text === null || Array.from(safe.text).length <= LINE_MAX);
|
||||
}
|
||||
// A run that reads as a key is redacted whole, so the words after it show.
|
||||
assert.equal(redactLine(`${'a'.repeat(N)} then the unit stopped`).text, `${REDACTED} then the unit stopped`);
|
||||
});
|
||||
|
||||
// The list is a copy of failure-notice.mjs's. Every line must still match it, except the key-prefix
|
||||
// line, which is the original with mso, mst and msp added after msk, and Mosaic's glued-prefix line
|
||||
// right after it.
|
||||
test('the redaction list matches failure-notice.mjs line for line, with only the prefixes and one line added', () => {
|
||||
const source = file => fs.readFileSync(fileURLToPath(new URL(file, import.meta.url)), 'utf8');
|
||||
const block = text => {
|
||||
const body = /const REDACT = \[\n([\s\S]*?)\n\];/.exec(text)[1];
|
||||
return body.split('\n').map(line => line.trim()).filter(line => line && !line.startsWith('//')).map(line => line.replace(/,\s*\/\/ .*$/, ',').replace(/,$/, ''));
|
||||
};
|
||||
const keyWord = text => /const KEY_WORD = (.*);/.exec(text)[1];
|
||||
const theirs = source('../../harness/src/failure-notice.mjs'), ours = source('../src/redact.mjs');
|
||||
assert.equal(keyWord(ours), keyWord(theirs));
|
||||
const expected = block(theirs).map(line => line.replace('(?:sk|msk|rk|', '(?:sk|msk|mso|mst|msp|rk|'));
|
||||
assert.equal(expected.filter((line, i) => line !== block(theirs)[i]).length, 1, 'the original has one key-prefix line');
|
||||
const at = expected.findIndex(line => line.includes('(?:sk|msk|mso|mst|msp|rk|'));
|
||||
expected.splice(at + 1, 0, '/ms[kotp][-_]\\S+/gi');
|
||||
assert.deepEqual(block(ours), expected);
|
||||
});
|
||||
@@ -246,10 +246,42 @@ export returns:
|
||||
`minimal`, `low`, `medium`, `high`, `xhigh` and `max` as `--thinking`,
|
||||
Claude Code takes `low`, `medium`, `high`, `xhigh` and `max` as
|
||||
`--effort`.
|
||||
- `preflight({env})` returns `null` or `{code, message}`: pi checks its
|
||||
binary in `node_modules` (`harness-binary-missing`), Claude Code its
|
||||
- `preflight({env})` returns `null` or `{code, message}`, or a promise of
|
||||
one, which the launcher awaits before it launches: pi checks that
|
||||
it finds a pi binary (`harness-binary-missing`), Claude Code its
|
||||
session credential (`no-session-credential`) and `MOSAIC_CLAUDE_BIN`.
|
||||
- `version({env})` is what the manifest records as `harnessVersion`.
|
||||
Pi (#1873 pi-unpin, `harness/pi/binary.mjs`) takes `MOSAIC_PI_BIN`,
|
||||
which must be an absolute path to an executable file; else the first
|
||||
`pi` on PATH, skipping the repository's own `node_modules/.bin`; else
|
||||
the repository's copy. The binary must belong to the
|
||||
`@earendil-works/pi-coding-agent` package: it is the bin that package's
|
||||
`package.json` names. With none, the message is
|
||||
"no pi found: set MOSAIC_PI_BIN, put pi on PATH, or run npm ci". No
|
||||
version is pinned. Pi's `mounts` and `installRoots` hold the found
|
||||
package's directory (the repository's whole `node_modules` for the
|
||||
repository's copy, whose packages are hoisted beside pi), and its `env`
|
||||
sets `MOSAIC_PI_BIN` to the binary's path inside the session, which the
|
||||
adapter runs. A refusal names the variable or "the pi on PATH" or "the
|
||||
repository's pi", never a host path. Pi's `preflight` then awaits
|
||||
the fit check (#1873 S3, `packages/harness/src/pi-fit.mjs`), which
|
||||
runs its sandboxed pi starts as child processes, four at a time, so the
|
||||
bus keeps answering, and which every caller that asks while it runs
|
||||
shares. It refuses `harness-feature-missing` when the binary lacks a flag the
|
||||
adapter passes, starts with a missing `-e` file, loads a planted ambient
|
||||
source or context file with the seal flags on, or can't be checked. When its `--help`
|
||||
lists `--no-mcp`, `env` sets `MOSAIC_PI_NO_MCP=1` and the adapter
|
||||
passes `--no-mcp`; otherwise it sets `MOSAIC_PI_NO_MCP=0`. `env`'s
|
||||
variables are built in `harness/pi/session-env.mjs`, which the fit
|
||||
check also uses so its runs get a session's names, from the bus's own
|
||||
environment as a session's are. `env` runs nothing: it reads the passed
|
||||
check for the binary's files and the bus's names, and throws when there
|
||||
is none. A host that calls `env` without `preflight` awaits the
|
||||
optional `ready({env})` first (the Triage host and route do), which runs
|
||||
the check, or shares the one running, and throws its refusal line.
|
||||
- `version({env})` is what the manifest records as `harnessVersion`, or a
|
||||
promise of it, which the launcher awaits. Pi's is the first line its
|
||||
binary prints for `--version`, or null; the binary runs as a child
|
||||
process.
|
||||
- `countsAccount()` says whether its launches spend `launch.account` and get
|
||||
the row 126 account checks. The same answer decides whether an account
|
||||
quota covers authority hires (#1873); the bus reads it once at start, so
|
||||
|
||||
@@ -0,0 +1,153 @@
|
||||
// #1873 pi-unpin: the pi binary a session runs, and the package it comes from. Nothing here is
|
||||
// pinned. The version label is read from the binary (or its package.json), never compared to a
|
||||
// fixed one. The launcher, the bundle and the usage reader call these on the host.
|
||||
import { accessSync, constants, readFileSync, realpathSync, statSync } from "node:fs";
|
||||
import { dirname, isAbsolute, join, relative } from "node:path";
|
||||
import { homedir } from "node:os";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { spawn } from "node:child_process";
|
||||
|
||||
const REPO = fileURLToPath(new URL("../../../../", import.meta.url));
|
||||
export const PACKAGE = "@earendil-works/pi-coding-agent";
|
||||
export const REPO_BIN = join(REPO, "node_modules", ".bin", "pi");
|
||||
const VERSION_MAX = 128;
|
||||
|
||||
export const executable = (path) => {
|
||||
try {
|
||||
accessSync(path, constants.X_OK);
|
||||
return statSync(path).isFile();
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
const REPO_NODE_MODULES = join(REPO, "node_modules");
|
||||
const realOrNull = (path) => { try { return realpathSync(path); } catch { return null; } };
|
||||
const inside = (path, root) => root === "/" || path === root || path.startsWith(root + "/");
|
||||
|
||||
// #1873 S2: the binary a session runs, with the name a refusal line uses for it (never a path):
|
||||
// MOSAIC_PI_BIN, which must be an absolute path to an executable file; else the first executable
|
||||
// pi on PATH, skipping the repository's own node_modules/.bin (a session PATH starts with it, so
|
||||
// the bus's own PATH and a session's give the same answer); else the repository's copy. The binary
|
||||
// must belong to the pi package: its package directory (or, for the repository's copy, the
|
||||
// repository's node_modules) is what the sandbox mounts. The answer: { bin, label, root, view,
|
||||
// dest, pkg } or { bin: null, problem }. root is the real directory mounted, dest where it is
|
||||
// mounted (null: at root itself), view the binary's path inside the session, pkg the package's
|
||||
// real directory.
|
||||
export function locate(env = {}) {
|
||||
if (env.MOSAIC_PI_BIN !== undefined && env.MOSAIC_PI_BIN !== "") {
|
||||
const bin = env.MOSAIC_PI_BIN;
|
||||
if (typeof bin !== "string" || !isAbsolute(bin) || !executable(bin)) return { bin: null, problem: "MOSAIC_PI_BIN isn't an executable file at an absolute path" };
|
||||
return placed(bin, "MOSAIC_PI_BIN", env);
|
||||
}
|
||||
const repoBin = realOrNull(join(REPO_NODE_MODULES, ".bin"));
|
||||
for (const dir of String(env.PATH ?? "").split(":")) {
|
||||
if (!isAbsolute(dir)) continue;
|
||||
const real = realOrNull(dir);
|
||||
if (real === null || (repoBin !== null && real === repoBin)) continue;
|
||||
if (executable(join(dir, "pi"))) return placed(join(dir, "pi"), "the pi on PATH", env);
|
||||
}
|
||||
if (executable(REPO_BIN)) return placed(REPO_BIN, "the repository's pi", env);
|
||||
return { bin: null, problem: "no pi found: set MOSAIC_PI_BIN, put pi on PATH, or run npm ci" };
|
||||
}
|
||||
|
||||
function placed(bin, label, env) {
|
||||
const pkg = packageDir(bin);
|
||||
const realBin = realOrNull(bin);
|
||||
if (!pkg || !realBin) return { bin: null, problem: `${label} isn't part of the ${PACKAGE} package` };
|
||||
// The package directory is mounted whole, so the binary must be the pi bin its package.json
|
||||
// names (a string bin, or bin.pi), inside that directory. A stray executable under some wider
|
||||
// directory whose package.json carries the name doesn't count.
|
||||
if (namedBin(pkg) !== realBin) return { bin: null, problem: `${label} isn't the pi bin the ${PACKAGE} package names` };
|
||||
// The repository's copy keeps the mount every session has had: all of node_modules, at its own
|
||||
// path, since its packages are hoisted beside pi.
|
||||
const repoReal = realOrNull(REPO_NODE_MODULES);
|
||||
if (repoReal !== null && inside(pkg, repoReal)) {
|
||||
return { bin, label, root: repoReal, dest: REPO_NODE_MODULES, view: join(REPO_NODE_MODULES, relative(repoReal, realBin)), pkg };
|
||||
}
|
||||
// Any other copy: its package directory alone, at its real path. npm nests a global install's
|
||||
// dependencies inside it; a copy that needs packages beside it fails the fit check (S3).
|
||||
// A package directory that holds the home directory or the repository would mount them.
|
||||
const held = [homedir(), env.HOME, REPO].filter((p) => typeof p === "string" && isAbsolute(p)).map((p) => realOrNull(p) ?? p);
|
||||
if (held.some((p) => inside(p, pkg))) return { bin: null, problem: `${label}'s package directory holds the home directory or the repository` };
|
||||
return { bin, label, root: pkg, dest: null, view: realBin, pkg };
|
||||
}
|
||||
|
||||
// The real path of the pi bin the package.json in `pkg` names, inside `pkg`, or null.
|
||||
function namedBin(pkg) {
|
||||
let bin;
|
||||
try { bin = JSON.parse(readFileSync(join(pkg, "package.json"), "utf8")).bin; } catch { return null; }
|
||||
const rel = typeof bin === "string" ? bin : bin && typeof bin === "object" ? bin.pi : null;
|
||||
if (typeof rel !== "string" || !rel) return null;
|
||||
const real = realOrNull(join(pkg, rel));
|
||||
return real !== null && real !== pkg && inside(real, pkg) ? real : null;
|
||||
}
|
||||
|
||||
// The package directory that holds the binary's real file: the nearest directory above it whose
|
||||
// package.json has a name. That name must be PACKAGE, or there is none (null).
|
||||
export function packageDir(bin) {
|
||||
let dir;
|
||||
try { dir = dirname(realpathSync(bin)); } catch { return null; }
|
||||
for (let depth = 0; depth < 32; depth++) {
|
||||
let pkg = null;
|
||||
try { pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")); } catch { pkg = null; }
|
||||
if (pkg && typeof pkg === "object" && pkg.name !== undefined) return pkg.name === PACKAGE ? dir : null;
|
||||
const up = dirname(dir);
|
||||
if (up === dir) return null;
|
||||
dir = up;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// The found package's own version, a file read with no spawn, or null.
|
||||
export function packageVersion(bin) {
|
||||
const dir = bin ? packageDir(bin) : null;
|
||||
if (!dir) return null;
|
||||
try {
|
||||
const v = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).version;
|
||||
return typeof v === "string" && cleanLabel(v) ? v : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// The most a --version may print (spawnSync's default buffer, which the check used before).
|
||||
const VERSION_OUTPUT_MAX = 1024 * 1024;
|
||||
// One printable line, short enough to record.
|
||||
const cleanLabel = (s) => s.length > 0 && s.length <= VERSION_MAX && !/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(s);
|
||||
|
||||
// The first line `<bin> --version` prints, or null when it fails, times out or prints something
|
||||
// that is not one short printable line. The environment holds only a PATH that finds node. A
|
||||
// promise: the binary runs as a child process, so the caller's event loop keeps running.
|
||||
export function printedVersion(bin) {
|
||||
if (!bin) return Promise.resolve(null);
|
||||
return new Promise((resolve) => {
|
||||
const out = [];
|
||||
let size = 0;
|
||||
let done = false;
|
||||
let child;
|
||||
let timer = null;
|
||||
const finish = (line) => {
|
||||
if (done) return;
|
||||
done = true;
|
||||
clearTimeout(timer);
|
||||
resolve(line);
|
||||
};
|
||||
try {
|
||||
child = spawn(bin, ["--version"], { env: { PATH: `${dirname(process.execPath)}:/usr/bin:/bin`, PI_OFFLINE: "1" }, stdio: ["ignore", "pipe", "ignore"] });
|
||||
} catch {
|
||||
finish(null);
|
||||
return;
|
||||
}
|
||||
timer = setTimeout(() => { try { child.kill("SIGKILL"); } catch {} finish(null); }, 5000);
|
||||
child.stdout.on("data", (chunk) => {
|
||||
size += chunk.length;
|
||||
if (size > VERSION_OUTPUT_MAX) { try { child.kill("SIGKILL"); } catch {} finish(null); } else out.push(chunk);
|
||||
});
|
||||
child.on("error", () => finish(null));
|
||||
child.on("close", (status) => {
|
||||
const line = Buffer.concat(out).toString("utf8").split("\n")[0].trim();
|
||||
finish(status === 0 && cleanLabel(line) ? line : null);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -3,7 +3,7 @@
|
||||
// `compactions` through the harness kind (packages/plugins/README.md has the contract). This file
|
||||
// reads only the session's native pi store and the Claude history beside it.
|
||||
//
|
||||
// Pi (pinned 0.85.1): a completed compaction is one `type: "compaction"` entry,
|
||||
// Pi (read from 0.85.1): a completed compaction is one `type: "compaction"` entry,
|
||||
// written by SessionManager.appendCompaction after the summary exists. A start
|
||||
// or an aborted compaction writes none. A `compactionSummary` message, a
|
||||
// message inside a compaction's retainedTail and a branch_summary are not
|
||||
@@ -19,8 +19,10 @@
|
||||
import { createHash } from "node:crypto";
|
||||
import { closeSync, constants as fsc, fstatSync, lstatSync, openSync, readdirSync, readSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
import { locate, packageVersion } from "./binary.mjs";
|
||||
|
||||
export const PI_VERSION = "0.85.1";
|
||||
// #1873 S1: the found package's own version (its package.json, no spawn), or null.
|
||||
const foundVersion = () => packageVersion(locate(process.env).bin);
|
||||
const TAIL = 4096;
|
||||
const CHUNK = 1 << 20;
|
||||
const STREAM = /^[A-Za-z0-9._-]{1,200}\.jsonl$/;
|
||||
@@ -158,9 +160,9 @@ export function compactions({ store, cursors, budget, streams, first }) {
|
||||
if (first && claudeHistory(store)) {
|
||||
// Claude runs before this ledger: their compactions can't be counted
|
||||
// (Vikunja 466), so the count is unknown for good, as after a Claude run.
|
||||
return { found: [], cursors: {}, known: false, reason: "harness-unsupported", version: PI_VERSION };
|
||||
return { found: [], cursors: {}, known: false, reason: "harness-unsupported", version: foundVersion() };
|
||||
}
|
||||
const scan = scanPi(store.session, cursors, budget, streams);
|
||||
const reason = REASONS.find((p) => scan.problems.includes(p)) ?? null;
|
||||
return { found: scan.found, cursors: scan.cursors, known: reason === null, reason, version: PI_VERSION };
|
||||
return { found: scan.found, cursors: scan.cursors, known: reason === null, reason, version: foundVersion() };
|
||||
}
|
||||
@@ -1,18 +1,19 @@
|
||||
// The "pi" harness plug-in (row 65, REQ-PLUG-2, Q156): a managed session on the pinned
|
||||
// @earendil-works/pi-coding-agent CLI, the repository's node_modules/.bin/pi. The tool gate is the
|
||||
// The "pi" harness plug-in (row 65, REQ-PLUG-2, Q156): a managed session on the
|
||||
// @earendil-works/pi-coding-agent CLI that binary.mjs finds (#1873: no version pin). The tool gate is the
|
||||
// Pi extension, which stays in packages/harness (a module can't change that boundary). The
|
||||
// launcher, the bundle and the usage reader call these on the host; the runner gets the answers
|
||||
// as data in session.json. packages/plugins/README.md lists the interface.
|
||||
import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
|
||||
import { lstatSync, mkdirSync, writeFileSync } from "node:fs";
|
||||
import { dirname, join } from "node:path";
|
||||
import { createHash } from "node:crypto";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { locate, printedVersion } from "./binary.mjs";
|
||||
import { fitVerdict, piFit } from "../../../harness/src/pi-fit.mjs";
|
||||
import { envNames, harnessEnv } from "./session-env.mjs";
|
||||
|
||||
export const interfaceVersion = 1;
|
||||
|
||||
const REPO = fileURLToPath(new URL("../../../../", import.meta.url));
|
||||
const PACKAGE = "@earendil-works/pi-coding-agent";
|
||||
const BIN = join(REPO, "node_modules", ".bin", "pi");
|
||||
const EXTENSION = fileURLToPath(new URL("../../../harness/src/pi-extension.mjs", import.meta.url));
|
||||
// Row 66 (#1559): the unslop check, loaded as a second extension. It logs to MOSAIC_UNSLOP_LOG,
|
||||
// which the runner sets, and the runner tells the operator.
|
||||
@@ -31,33 +32,53 @@ export const adapter = () => join(REPO, "adapters", "pi", "adapter.sh");
|
||||
export const levels = () => LEVELS;
|
||||
export const outputPolicy = ({ proxy }) => proxy ? "non-newline-stdout" : "stdout";
|
||||
|
||||
// The session runs pi from the repository's node_modules, which the sandbox mounts.
|
||||
export function preflight({ env = {}, proxy = null } = {}) {
|
||||
// The session runs the pi binary.mjs finds, from the package directory the sandbox mounts. Async:
|
||||
// the fit check runs child processes, and the launcher awaits the answer before it launches.
|
||||
export async function preflight({ env = {}, proxy = null } = {}) {
|
||||
if (!(typeof proxy?.key === "string" && proxy.key)
|
||||
&& !["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "OPENROUTER_API_KEY", "ZAI_API_KEY"].some(name => Boolean(env[name]))) {
|
||||
return { code: "no-session-credential", message: "pi needs its own provider key or a session proxy key" };
|
||||
}
|
||||
if (!existsSync(BIN)) return { code: "harness-binary-missing", message: "pi isn't installed in the repository's node_modules; run npm ci in the repository" };
|
||||
const found = locate(env);
|
||||
if (!found.bin) return { code: "harness-binary-missing", message: found.problem };
|
||||
// #1873 S3: the found binary takes every flag the adapter passes and keeps the known ambient
|
||||
// sources off with them, or the launch is refused. A check that cannot tell refuses too. The
|
||||
// check's environment comes from this process's own (the bus's), as a session's does.
|
||||
const fit = await piFit(found, { levels: LEVELS });
|
||||
if (!fit.ok) return { code: "harness-feature-missing", message: fit.message };
|
||||
return null;
|
||||
}
|
||||
|
||||
// The exact pin from the repository's package.json.
|
||||
export function version() {
|
||||
try {
|
||||
const pkg = JSON.parse(readFileSync(join(REPO, "package.json"), "utf8"));
|
||||
return pkg.dependencies?.[PACKAGE] ?? pkg.devDependencies?.[PACKAGE] ?? null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
// #1873 S1: what the found binary prints for --version (5 s timeout), or null. A label only:
|
||||
// nothing compares it to a fixed version. Async, so the bus keeps answering while it runs.
|
||||
export async function version({ env = {} } = {}) {
|
||||
return printedVersion(locate(env).bin);
|
||||
}
|
||||
|
||||
// #1873 S3: runs the fit check, or shares the one running, and throws its refusal line when the
|
||||
// binary fails it. A host that calls env() without preflight (Triage) awaits this first.
|
||||
export async function ready({ env = process.env } = {}) {
|
||||
const fit = await piFit(found(env), { levels: LEVELS });
|
||||
if (!fit.ok) throw new Error(fit.message);
|
||||
}
|
||||
|
||||
// Pi sessions run on a provider key, never the Claude account limit.
|
||||
export const countsAccount = () => false;
|
||||
export const mounts = () => [
|
||||
{ src: join(REPO, "packages/plugins/harness/pi/model-stream.mjs"), why: "the managed model event stream" },
|
||||
{ src: realpathSync(join(REPO, "node_modules")), dest: join(REPO, "node_modules"), why: "pi and its packages, on the session's PATH" },
|
||||
...Object.values(UNSLOP).map((src) => ({ src, why: "the unslop check the session's second extension runs" })),
|
||||
];
|
||||
// #1873 S2: the found pi's package directory (the repository's copy: all of node_modules, as before).
|
||||
// One under /usr is already in every sandbox.
|
||||
const found = (env) => {
|
||||
const at = locate(env);
|
||||
if (!at.bin) throw new Error(at.problem);
|
||||
return at;
|
||||
};
|
||||
export function mounts({ env = {} } = {}) {
|
||||
const at = found(env);
|
||||
return [
|
||||
{ src: join(REPO, "packages/plugins/harness/pi/model-stream.mjs"), why: "the managed model event stream" },
|
||||
...(at.root.startsWith("/usr/") ? [] : [{ src: at.root, ...(at.dest ? { dest: at.dest } : {}), why: `pi and its packages (${at.label})` }]),
|
||||
...Object.values(UNSLOP).map((src) => ({ src, why: "the unslop check the session's second extension runs" })),
|
||||
];
|
||||
}
|
||||
// Pi has no web tool of its own, so a granted role under harness-builtin is refused.
|
||||
export const builtinWeb = () => false;
|
||||
export const builtins = ({ tools }) => [...tools];
|
||||
@@ -105,26 +126,33 @@ export function bundle({ dir, models, proxy = null, transports = {} } = {}) {
|
||||
return { files: { proxyModels: file }, digests: [["../home/.pi/agent/models.json", createHash("sha256").update(text).digest("hex")]], sources };
|
||||
}
|
||||
|
||||
// The tool limit is the built-ins plus the typed tools, which the extension serves.
|
||||
export function env({ policy, tools, session, proxy = null }) {
|
||||
return {
|
||||
PI_OFFLINE: "1",
|
||||
MOSAIC_TOOLS: [...policy.tools, ...tools.map((t) => t.name)].join(","),
|
||||
MOSAIC_EXTENSIONS: [EXTENSION, UNSLOP.unslopExtension].join(","),
|
||||
PI_PROVIDER: proxy ? session.proxyTransport.piProvider : session.provider ?? "",
|
||||
PI_MODEL: session.model,
|
||||
MOSAIC_THINKING: session.thinking,
|
||||
...(proxy ? { ANTHROPIC_API_KEY: proxy.key } : {}),
|
||||
};
|
||||
// The tool limit is the built-ins plus the typed tools, which the extension serves. #1873 S2:
|
||||
// MOSAIC_PI_BIN is the found binary's path inside the session; the bus's own environment names it
|
||||
// (env defaults to it, since buildBundle and the Triage host call env() without one). preflight,
|
||||
// version and mounts get the launcher's env instead. Both find the same binary: the session env
|
||||
// copies PATH and MOSAIC_PI_BIN from the bus's, and locate() skips the repository's .bin on PATH.
|
||||
// env() runs nothing: it reads the fit check that preflight or ready() awaited for what it found.
|
||||
// With none passed for those files and this environment (they differ, the files changed since, or
|
||||
// nobody awaited one), it throws, so the launch fails closed (as harness-failed, not
|
||||
// harness-feature-missing).
|
||||
export function env({ policy, tools, session, proxy = null, env: hostEnv = process.env }) {
|
||||
const at = found(hostEnv);
|
||||
// #1873 S3: a session runs only a binary that passed the fit check.
|
||||
const fit = fitVerdict(at, { levels: LEVELS });
|
||||
if (!fit) throw new Error(`pi (${at.label}) has no passed fit check for its files; preflight or ready() runs one first`);
|
||||
return harnessEnv({ bin: at.view, noMcp: fit.noMcp, tools: [...policy.tools, ...tools.map((t) => t.name)], extensions: [EXTENSION, UNSLOP.unslopExtension], session, proxy });
|
||||
}
|
||||
|
||||
// #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")];
|
||||
// hands a session: a hosted pi needs the host to set them itself (a later slice). MOSAIC_PI_BIN
|
||||
// (#1873 S2) is the binary's path inside the session, which the host keeps from its own env() call;
|
||||
// MOSAIC_PI_NO_MCP (#1873 S3) is "1" when the binary's --help lists --no-mcp, else "0".
|
||||
// session-env.mjs holds the list beside the builder.
|
||||
export { envNames };
|
||||
export const installRoots = ({ env = {} } = {}) => [join(REPO, "adapters", "pi"), join(REPO, "packages", "plugins", "harness", "pi"), found(env).root, 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";
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
// The variables the pi module hands a session (index.mjs env() returns them as harnessEnv). Built
|
||||
// here, with no fit check, so packages/harness/src/pi-fit.mjs (#1873 S3) gives its runs the same
|
||||
// names as a session gets without importing index.mjs, which imports it.
|
||||
//
|
||||
// bin: the binary's path inside the session. noMcp: the binary's --help lists --no-mcp. tools: the
|
||||
// tool names. extensions: the -e files. session: { provider, model, thinking, proxyTransport }.
|
||||
// proxy: { key } when the session runs on the proxy, else null.
|
||||
export function harnessEnv({ bin, noMcp, tools, extensions, session, proxy = null }) {
|
||||
return {
|
||||
MOSAIC_PI_BIN: bin,
|
||||
// "1" when --help lists --no-mcp: the adapter then passes it, so MCP stays off by its own
|
||||
// flag. "0" otherwise, so every name in envNames is always set.
|
||||
MOSAIC_PI_NO_MCP: noMcp ? "1" : "0",
|
||||
PI_OFFLINE: "1",
|
||||
MOSAIC_TOOLS: tools.join(","),
|
||||
MOSAIC_EXTENSIONS: extensions.join(","),
|
||||
PI_PROVIDER: proxy ? session.proxyTransport.piProvider : session.provider ?? "",
|
||||
PI_MODEL: session.model,
|
||||
MOSAIC_THINKING: session.thinking,
|
||||
...(proxy ? { ANTHROPIC_API_KEY: proxy.key } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
// #1873 triage-fences: the names harnessEnv returns, less the provider key. index.mjs exports
|
||||
// them; its comment says what a hosted session's host does with them.
|
||||
export const envNames = Object.freeze(["MOSAIC_PI_BIN", "MOSAIC_PI_NO_MCP", "PI_OFFLINE", "MOSAIC_TOOLS", "MOSAIC_EXTENSIONS", "PI_PROVIDER", "PI_MODEL", "MOSAIC_THINKING"]);
|
||||
|
||||
// #1873 pi-unpin re-check 8: the provider and model the fit check's session-shaped runs pass
|
||||
// (packages/harness/src/pi-fit.mjs SESSION_SHAPE). The runs are offline with no key, so pi stops
|
||||
// before any model call; the names only need to be ones pi takes. Re-check 9: a Claude model is
|
||||
// offered, routed and tested only on the claude-code harness, so this names no Claude model and
|
||||
// no Anthropic provider (pi-fit.test.mjs holds that); glm-5.3-flash is the model index.mjs has
|
||||
// documented limits for, and pi's own catalogue lists it under zai.
|
||||
export const FIT_ROUTE = Object.freeze({ provider: "zai", model: "glm-5.3-flash" });
|
||||
@@ -54,6 +54,7 @@ export const KINDS = Object.freeze({
|
||||
// each one's contract:
|
||||
// adapter() -> the adapter script's absolute path levels() -> the thinking levels it applies
|
||||
// preflight({ env }) -> null | { code, message } version({ env }) -> string | null
|
||||
// (either may answer with a promise of that; the launcher awaits it before it launches)
|
||||
// countsAccount() -> true when its launches spend launch.account
|
||||
// mounts({ env }) -> read-only binds [{ src, dest, why }]
|
||||
// builtinWeb() -> true when it serves harness-builtin web
|
||||
@@ -62,6 +63,8 @@ export const KINDS = Object.freeze({
|
||||
// gateTimeout() -> the gate hook's timeouts | null
|
||||
// bundle({ dir, files, session, write, quote }) -> { files, digests, sources }, its own bundle files
|
||||
// env({ files, policy, tools, session }) -> its adapter variables, written into session.json
|
||||
// (optional, outside the list) ready({ env }) -> a promise a host that calls env() without
|
||||
// preflight awaits first; it rejects when env() would refuse (pi's fit check)
|
||||
// turnEnd() -> "marker" (a turn ends only with the turn marker) | "exit"
|
||||
// outputPolicy({ proxy }) -> "adapter" | "non-newline-stdout" | "stdout"
|
||||
// transcript({ runDir, store }) -> the directory its transcripts land in, for usage
|
||||
|
||||
@@ -3,13 +3,14 @@
|
||||
// harness outside the exceptions the brief lists.
|
||||
import test from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { chmodSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
|
||||
import { chmodSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join, relative, resolve } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { createLoader } from "../src/loader.mjs";
|
||||
import { KINDS } from "../src/kinds.mjs";
|
||||
import { piStandIn } from "../../harness/tests/pi-stand-in.mjs";
|
||||
|
||||
const REPO = resolve(fileURLToPath(new URL("../../../", import.meta.url)));
|
||||
|
||||
@@ -98,11 +99,11 @@ test("row 65 claude-code version asks MOSAIC_CLAUDE_BIN when set, else claude on
|
||||
assert.equal(claude.version({ env: { PATH: join(dir, "none") } }), null);
|
||||
});
|
||||
|
||||
test("row 65 pi preflight refuses missing credentials, and its version is the package pin", async () => {
|
||||
test("row 65 pi preflight refuses missing credentials, and its version is what the installed pi prints (#1873 S1)", async () => {
|
||||
const pi = await load("pi");
|
||||
assert.equal(pi.preflight({ env: {} }).code, "no-session-credential");
|
||||
const pkg = JSON.parse(readFileSync(join(REPO, "package.json"), "utf8"));
|
||||
assert.equal(pi.version({ env: {} }), pkg.dependencies?.["@earendil-works/pi-coding-agent"] ?? pkg.devDependencies?.["@earendil-works/pi-coding-agent"]);
|
||||
assert.equal((await pi.preflight({ env: {} })).code, "no-session-credential");
|
||||
const installed = JSON.parse(readFileSync(join(REPO, "node_modules", "@earendil-works", "pi-coding-agent", "package.json"), "utf8")).version;
|
||||
assert.equal(await pi.version({ env: {} }), installed);
|
||||
// Row 66: the unslop extension's files, bound read-only at their own paths.
|
||||
assert.deepEqual(pi.mounts({ env: {} }).map(m => m.dest ?? m.src), [join(REPO, "packages/plugins/harness/pi/model-stream.mjs"), join(REPO, "node_modules"), ...["extension.ts", "unslop-check.js", "lists.json"].map(f => join(REPO, "tools", "unslop-hook", f))]);
|
||||
});
|
||||
@@ -110,6 +111,8 @@ test("row 65 pi preflight refuses missing credentials, and its version is the pa
|
||||
test("row 65 env passes the thinking level to both adapters, and claude-code's bundle writes its hook and MCP files", async t => {
|
||||
const pi = await load("pi"), claude = await load("claude-code");
|
||||
const session = { provider: "fixture", model: "m", thinking: "high", toolSocket: "/run/tools.sock" };
|
||||
// #1873 S3: env() reads the fit check ready() awaits for the found pi.
|
||||
await pi.ready();
|
||||
const piEnv = pi.env({ policy: { tools: ["read"] }, tools: [{ name: "list_tasks" }], session });
|
||||
assert.equal(piEnv.PI_OFFLINE, "1", "pi avoids startup network operations");
|
||||
assert.deepEqual([piEnv.MOSAIC_THINKING, piEnv.PI_MODEL, piEnv.MOSAIC_TOOLS], ["high", "m", "read,list_tasks"]);
|
||||
@@ -140,10 +143,16 @@ test("row 65 a route's thinking reaches pi as --thinking and claude as --effort,
|
||||
const pi = await load("pi"), claude = await load("claude-code");
|
||||
const dir = scratch(t);
|
||||
mkdirSync(join(dir, "bin"));
|
||||
for (const name of ["pi", "claude"]) {
|
||||
writeFileSync(join(dir, "bin", name), '#!/bin/sh\nprintf "%s\\n" "$@" > "$ARGV_OUT"\necho \'{"type":"result","subtype":"success","result":"ok"}\'\n');
|
||||
chmodSync(join(dir, "bin", name), 0o755);
|
||||
}
|
||||
// #1873 S2: pi's stand-in sits in a pi package, as the module requires, and is found on PATH.
|
||||
const piPackage = join(dir, "lib", "node_modules", "@earendil-works", "pi-coding-agent");
|
||||
mkdirSync(join(piPackage, "dist", "bundle"), { recursive: true });
|
||||
writeFileSync(join(piPackage, "package.json"), JSON.stringify({ name: "@earendil-works/pi-coding-agent", version: "0.0.1", bin: { pi: "dist/bundle/cli.js" } }));
|
||||
const result = '{"type":"result","subtype":"success","result":"ok"}\n';
|
||||
writeFileSync(join(dir, "bin", "claude"), `#!/bin/sh\nprintf "%s\\n" "$@" > "$ARGV_OUT"\necho '${result.trim()}'\n`);
|
||||
// #1873 S3: pi's stand-in also passes the fit check that ready() runs and env() reads.
|
||||
writeFileSync(join(piPackage, "dist", "bundle", "cli.js"), piStandIn({ sessionOut: result }));
|
||||
for (const file of [join(dir, "bin", "claude"), join(piPackage, "dist", "bundle", "cli.js")]) chmodSync(file, 0o755);
|
||||
symlinkSync(join(piPackage, "dist", "bundle", "cli.js"), join(dir, "bin", "pi"));
|
||||
for (const f of ["prompt.md", "settings.json", "mcp.json"]) writeFileSync(join(dir, f), "{}");
|
||||
const run = (adapter, moduleEnv) => {
|
||||
const out = join(dir, "argv");
|
||||
@@ -163,9 +172,10 @@ test("row 65 a route's thinking reaches pi as --thinking and claude as --effort,
|
||||
assert.equal(argv.filter(a => a === name).length, 1, argv.join(" "));
|
||||
return argv[argv.indexOf(name) + 1];
|
||||
};
|
||||
await pi.ready({ env: { PATH: `${join(dir, "bin")}:/usr/bin:/bin` } });
|
||||
for (const thinking of ["xhigh", "low"]) {
|
||||
const session = { provider: "fixture", model: "m", thinking, toolSocket: "/run/tools.sock" };
|
||||
assert.equal(flag(run("pi", pi.env({ policy: { tools: ["read"] }, tools: [], session })), "--thinking"), thinking);
|
||||
assert.equal(flag(run("pi", pi.env({ policy: { tools: ["read"] }, tools: [], session, env: { PATH: `${join(dir, "bin")}:/usr/bin:/bin` } })), "--thinking"), thinking);
|
||||
const files = { settings: join(dir, "settings.json"), mcp: join(dir, "mcp.json") };
|
||||
assert.equal(flag(run("claude", claude.env({ files, policy: { tools: ["read"], typed: [] }, session })), "--effort"), thinking);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,216 @@
|
||||
// #1873 pi-unpin (design section 5, S1): pi's labels come from the binary the module finds, not
|
||||
// from a pin. The version is what `<bin> --version` prints, or null when that fails; the
|
||||
// compaction count records the found package's own version.
|
||||
import test from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { dirname, join, resolve } from "node:path";
|
||||
import { fileURLToPath, pathToFileURL } from "node:url";
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { sandboxProblem } from "../../seat/src/sandbox.mjs";
|
||||
import { piStandIn } from "../../harness/tests/pi-stand-in.mjs";
|
||||
|
||||
const REPO = resolve(fileURLToPath(new URL("../../../", import.meta.url)));
|
||||
const MODULE = join(REPO, "packages", "plugins", "harness", "pi");
|
||||
const NAME = "@earendil-works/pi-coding-agent";
|
||||
|
||||
function scratch(t) {
|
||||
const root = mkdtempSync(join(tmpdir(), "mosaic-pi-bin-"));
|
||||
t.after(() => rmSync(root, { recursive: true, force: true }));
|
||||
return root;
|
||||
}
|
||||
|
||||
// A pi package under `dir` (a node_modules directory), with `script` as its bin.
|
||||
function standIn(dir, script, version) {
|
||||
const pkg = join(dir, NAME);
|
||||
mkdirSync(join(pkg, "dist", "bundle"), { recursive: true });
|
||||
writeFileSync(join(pkg, "package.json"), JSON.stringify({ name: NAME, version, bin: { pi: "dist/bundle/cli.js" } }));
|
||||
writeFileSync(join(pkg, "dist", "bundle", "cli.js"), script, { mode: 0o755 });
|
||||
return join(pkg, "dist", "bundle", "cli.js");
|
||||
}
|
||||
|
||||
// A copy of the pi module in a scratch repository whose node_modules holds a stand-in, so the
|
||||
// module's repository copy is that stand-in and not the real pi. The rest of packages/ links to
|
||||
// the real tree, for the modules the copy imports.
|
||||
async function copyRepo(t, script, version) {
|
||||
const root = scratch(t);
|
||||
const mod = join(root, "packages", "plugins", "harness", "pi");
|
||||
mkdirSync(mod, { recursive: true });
|
||||
for (const f of readdirSync(MODULE)) if (f.endsWith(".mjs")) copyFileSync(join(MODULE, f), join(mod, f));
|
||||
for (const p of readdirSync(join(REPO, "packages"))) if (p !== "plugins") symlinkSync(join(REPO, "packages", p), join(root, "packages", p));
|
||||
standIn(join(root, "node_modules"), script, version);
|
||||
mkdirSync(join(root, "node_modules", ".bin"));
|
||||
symlinkSync(`../${NAME}/dist/bundle/cli.js`, join(root, "node_modules", ".bin", "pi"));
|
||||
return { root, pi: await import(pathToFileURL(join(mod, "index.mjs")).href) };
|
||||
}
|
||||
|
||||
const emptyStore = (t) => {
|
||||
const root = scratch(t);
|
||||
mkdirSync(join(root, "session"));
|
||||
return { session: join(root, "session"), projects: join(root, "claude-projects") };
|
||||
};
|
||||
|
||||
test("pi-unpin S1: the version is what the found binary prints, and the compaction count records its package's version", async t => {
|
||||
const { pi } = await copyRepo(t, "#!/bin/sh\n[ \"$1\" = --version ] && echo 9.9.9\n", "9.9.4");
|
||||
assert.equal(await pi.version({ env: {} }), "9.9.9");
|
||||
const counted = pi.compactions({ store: emptyStore(t), cursors: {}, budget: 1 << 20, streams: 16, first: false });
|
||||
assert.equal(counted.version, "9.9.4");
|
||||
});
|
||||
|
||||
test("pi-unpin S1: a binary that exits 1 on --version gives a null version, not a guess", async t => {
|
||||
const { pi } = await copyRepo(t, "#!/bin/sh\nexit 1\n", "8.8.8");
|
||||
assert.equal(await pi.version({ env: {} }), null);
|
||||
// The package's own file still names its version for the compaction count.
|
||||
assert.equal(pi.compactions({ store: emptyStore(t), cursors: {}, budget: 1 << 20, streams: 16, first: false }).version, "8.8.8");
|
||||
});
|
||||
|
||||
test("pi-unpin S1: a version line with a control character or over 128 characters is not recorded", async t => {
|
||||
const { pi } = await copyRepo(t, "#!/bin/sh\nprintf '1.0\\033[31m\\n'\n", "1.0.0");
|
||||
assert.equal(await pi.version({ env: {} }), null);
|
||||
const long = await copyRepo(t, `#!/bin/sh\necho ${"9".repeat(129)}\n`, "1.0.0");
|
||||
assert.equal(await long.pi.version({ env: {} }), null);
|
||||
});
|
||||
|
||||
test("pi-unpin S1: the repository's real pi reports its installed package's version", async () => {
|
||||
const pi = await import(pathToFileURL(join(MODULE, "index.mjs")).href);
|
||||
const installed = JSON.parse(readFileSync(join(REPO, "node_modules", NAME, "package.json"), "utf8")).version;
|
||||
assert.equal(await pi.version({ env: {} }), installed);
|
||||
});
|
||||
|
||||
// #1873 pi-unpin (design section 5, S2): the binary comes from MOSAIC_PI_BIN, else the first pi on
|
||||
// PATH, else the repository's copy. Mounts, install roots and the session's MOSAIC_PI_BIN follow
|
||||
// the package that binary belongs to. A refusal names the variable, never a path.
|
||||
const real = await import(pathToFileURL(join(MODULE, "index.mjs")).href);
|
||||
const CREDENTIAL = { ZAI_API_KEY: "fixture-zai" };
|
||||
// #1873 S3: the stand-in passes the fit check, prints 7.7.7 for --version, and as a session
|
||||
// records its argv in $ARGV_OUT.
|
||||
const ARGV_SCRIPT = piStandIn({ version: "7.7.7" });
|
||||
|
||||
// npm's global layout: prefix/lib/node_modules/<package>, with prefix/bin/pi a link to its bin.
|
||||
function prefix(t, script = ARGV_SCRIPT, version = "7.7.0") {
|
||||
const root = join(scratch(t), "prefix");
|
||||
const cli = standIn(join(root, "lib", "node_modules"), script, version);
|
||||
mkdirSync(join(root, "bin"), { recursive: true });
|
||||
symlinkSync(`../lib/node_modules/${NAME}/dist/bundle/cli.js`, join(root, "bin", "pi"));
|
||||
return { root, bin: join(root, "bin", "pi"), cli: realpathSync(cli), pkg: realpathSync(join(root, "lib", "node_modules", NAME)) };
|
||||
}
|
||||
const session = { provider: "fixture", model: "m", thinking: "low", toolSocket: "/run/tools.sock" };
|
||||
// pi.env() reads the fit check that preflight awaited for the same files.
|
||||
const piEnv = (env) => real.env({ policy: { tools: ["read"] }, tools: [], session, env });
|
||||
const noPath = (problem, ...paths) => { for (const p of paths) assert.ok(!problem.message.includes(p), problem.message); };
|
||||
|
||||
test("pi-unpin S2: a stand-in pi in an npm prefix, named by MOSAIC_PI_BIN, is found, mounted alone and run from the mount", async t => {
|
||||
const p = prefix(t);
|
||||
const env = { ...CREDENTIAL, MOSAIC_PI_BIN: p.bin, PATH: "/usr/bin:/bin" };
|
||||
assert.equal(await real.preflight({ env }), null);
|
||||
assert.equal(await real.version({ env }), "7.7.7");
|
||||
const mounts = real.mounts({ env });
|
||||
assert.deepEqual(mounts.filter(m => (m.dest ?? m.src) === p.pkg || m.src === p.pkg).map(m => m.src), [p.pkg]);
|
||||
assert.ok(!mounts.some(m => (m.dest ?? m.src) === join(REPO, "node_modules")), "the repository's node_modules is not mounted");
|
||||
const roots = real.installRoots({ env });
|
||||
assert.ok(roots.includes(p.pkg));
|
||||
assert.ok(!roots.includes(realpathSync(join(REPO, "node_modules"))));
|
||||
const given = piEnv(env);
|
||||
assert.equal(given.MOSAIC_PI_BIN, p.cli, "the session runs the real file inside the mounted package");
|
||||
assert.ok(real.envNames.includes("MOSAIC_PI_BIN"));
|
||||
|
||||
// Run the real adapter in a sandbox that holds the system, the adapter and the module's mounts,
|
||||
// and not the repository's node_modules: the stand-in records the argv it was given.
|
||||
if (sandboxProblem()) return t.skip("no usable bwrap");
|
||||
const out = join(scratch(t), "out");
|
||||
mkdirSync(out);
|
||||
writeFileSync(join(out, "prompt.md"), "p");
|
||||
const argv = ["/usr/bin/bwrap", "--unshare-user", "--unshare-pid", "--unshare-net", "--die-with-parent", "--clearenv", "--ro-bind", "/usr", "/usr"];
|
||||
for (const link of ["/bin", "/sbin", "/lib", "/lib64"]) {
|
||||
if (!existsSync(link)) continue;
|
||||
if (lstatSync(link).isSymbolicLink()) argv.push("--symlink", readlinkSync(link), link);
|
||||
else argv.push("--ro-bind", link, link);
|
||||
}
|
||||
argv.push("--proc", "/proc", "--dev", "/dev", "--ro-bind", join(REPO, "adapters", "pi"), join(REPO, "adapters", "pi"));
|
||||
for (const m of mounts) argv.push("--ro-bind", m.src, m.dest ?? m.src);
|
||||
// The extensions the adapter checks for, which a launch's bundle binds.
|
||||
for (const e of given.MOSAIC_EXTENSIONS.split(",")) argv.push("--ro-bind", e, e);
|
||||
argv.push("--bind", out, out);
|
||||
for (const [k, v] of Object.entries({ ...given, PATH: "/usr/bin:/bin", ARGV_OUT: join(out, "argv"), MOSAIC_SYSTEM_PROMPT_FILE: join(out, "prompt.md"),
|
||||
MOSAIC_REQUEST: "x", MOSAIC_WORKSPACE: join(out, "ws"), MOSAIC_SESSION_DIR: join(out, "session"), MOSAIC_MODEL: "m" })) argv.push("--setenv", k, v);
|
||||
argv.push("/bin/sh", join(REPO, "adapters", "pi", "adapter.sh"));
|
||||
const r = spawnSync(argv[0], argv.slice(1), { encoding: "utf8", timeout: 20000 });
|
||||
assert.equal(r.status, 0, r.stderr);
|
||||
const ran = readFileSync(join(out, "argv"), "utf8").split("\n");
|
||||
assert.ok(ran.includes("--no-context-files") && ran.includes("--thinking"), ran.join(" "));
|
||||
});
|
||||
|
||||
test("pi-unpin S2: a relative or non-executable MOSAIC_PI_BIN is refused with harness-binary-missing, naming the variable only", async t => {
|
||||
const p = prefix(t);
|
||||
const plain = join(scratch(t), "pi");
|
||||
writeFileSync(plain, "#!/bin/sh\n", { mode: 0o644 });
|
||||
for (const bin of ["bin/pi", "pi", plain, join(p.root, "missing")]) {
|
||||
const problem = await real.preflight({ env: { ...CREDENTIAL, MOSAIC_PI_BIN: bin, PATH: `${join(p.root, "bin")}:/usr/bin:/bin` } });
|
||||
assert.deepEqual([problem?.code, problem?.message], ["harness-binary-missing", "MOSAIC_PI_BIN isn't an executable file at an absolute path"], bin);
|
||||
noPath(problem, plain, p.root);
|
||||
assert.equal(await real.version({ env: { MOSAIC_PI_BIN: bin } }), null, "no fallback to another pi");
|
||||
}
|
||||
});
|
||||
|
||||
test("pi-unpin S2: with MOSAIC_PI_BIN unset the first pi on PATH is used, and the repository's own .bin on PATH does not count", async t => {
|
||||
const p = prefix(t);
|
||||
const env = { ...CREDENTIAL, PATH: `${join(REPO, "node_modules", ".bin")}:/nonexistent:relative:${join(p.root, "bin")}:/usr/bin:/bin` };
|
||||
assert.equal(await real.preflight({ env }), null);
|
||||
assert.equal(await real.version({ env }), "7.7.7");
|
||||
assert.equal(piEnv(env).MOSAIC_PI_BIN, p.cli);
|
||||
assert.ok(real.mounts({ env }).some(m => m.src === p.pkg));
|
||||
});
|
||||
|
||||
test("pi-unpin S2: with neither, the repository's copy is used and mounted as before", async () => {
|
||||
for (const PATH of ["/usr/bin:/bin", `${join(REPO, "node_modules", ".bin")}:/usr/bin:/bin`]) {
|
||||
const env = { ...CREDENTIAL, PATH };
|
||||
assert.equal(await real.preflight({ env }), null, PATH);
|
||||
const nm = realpathSync(join(REPO, "node_modules"));
|
||||
assert.deepEqual(real.mounts({ env }).filter(m => m.dest === join(REPO, "node_modules")).map(m => m.src), [nm]);
|
||||
assert.ok(real.installRoots({ env }).includes(nm));
|
||||
const bin = piEnv(env).MOSAIC_PI_BIN;
|
||||
assert.ok(bin.startsWith(join(REPO, "node_modules") + "/"), bin);
|
||||
assert.equal(realpathSync(bin), realpathSync(join(REPO, "node_modules", ".bin", "pi")));
|
||||
}
|
||||
});
|
||||
|
||||
test("pi-unpin S2: a pi that is not in a pi package is refused, and so is a pi that cannot be found at all", async t => {
|
||||
const dir = join(scratch(t), "bin");
|
||||
mkdirSync(dir);
|
||||
writeFileSync(join(dir, "pi"), "#!/bin/sh\necho 1.0.0\n");
|
||||
chmodSync(join(dir, "pi"), 0o755);
|
||||
let problem = await real.preflight({ env: { ...CREDENTIAL, PATH: `${dir}:/usr/bin:/bin` } });
|
||||
assert.deepEqual([problem?.code, problem?.message], ["harness-binary-missing", `the pi on PATH isn't part of the ${NAME} package`]);
|
||||
problem = await real.preflight({ env: { ...CREDENTIAL, MOSAIC_PI_BIN: join(dir, "pi") } });
|
||||
assert.deepEqual([problem?.code, problem?.message], ["harness-binary-missing", `MOSAIC_PI_BIN isn't part of the ${NAME} package`]);
|
||||
noPath(problem, dir);
|
||||
// The scratch copy has no node_modules of its own: no pi anywhere.
|
||||
const { root, pi } = await copyRepo(t, "#!/bin/sh\n", "1.0.0");
|
||||
rmSync(join(root, "node_modules"), { recursive: true });
|
||||
problem = await pi.preflight({ env: { ...CREDENTIAL, PATH: "/usr/bin:/bin" } });
|
||||
assert.deepEqual([problem?.code, problem?.message], ["harness-binary-missing", "no pi found: set MOSAIC_PI_BIN, put pi on PATH, or run npm ci"]);
|
||||
assert.throws(() => pi.env({ policy: { tools: [] }, tools: [], session, env: { PATH: "/usr/bin:/bin" } }), /no pi found/);
|
||||
});
|
||||
|
||||
// Review finding 8: the package directory is mounted whole, so the binary must be the pi bin its
|
||||
// package.json names. A stray executable under a directory whose package.json carries the name
|
||||
// (a wide tree, say) is refused, naming the variable only.
|
||||
test("pi-unpin S2 review: a binary that isn't the bin its package names is refused", async t => {
|
||||
const wide = scratch(t);
|
||||
writeFileSync(join(wide, "package.json"), JSON.stringify({ name: NAME, version: "1.0.0", bin: { pi: "dist/bundle/cli.js" } }));
|
||||
mkdirSync(join(wide, "tools"));
|
||||
writeFileSync(join(wide, "tools", "pi"), "#!/bin/sh\necho 1.0.0\n", { mode: 0o755 });
|
||||
let problem = await real.preflight({ env: { ...CREDENTIAL, MOSAIC_PI_BIN: join(wide, "tools", "pi") } });
|
||||
assert.deepEqual([problem?.code, problem?.message], ["harness-binary-missing", `MOSAIC_PI_BIN isn't the pi bin the ${NAME} package names`]);
|
||||
noPath(problem, wide);
|
||||
// A package.json with no bin names none.
|
||||
writeFileSync(join(wide, "package.json"), JSON.stringify({ name: NAME, version: "1.0.0" }));
|
||||
problem = await real.preflight({ env: { ...CREDENTIAL, MOSAIC_PI_BIN: join(wide, "tools", "pi") } });
|
||||
assert.deepEqual([problem?.code, problem?.message], ["harness-binary-missing", `MOSAIC_PI_BIN isn't the pi bin the ${NAME} package names`]);
|
||||
// A bin given as a plain string names it too.
|
||||
const dir = join(scratch(t), "node_modules");
|
||||
const cli = standIn(dir, piStandIn({ version: "1.2.3" }), "1.2.3");
|
||||
writeFileSync(join(dir, NAME, "package.json"), JSON.stringify({ name: NAME, version: "1.2.3", bin: "dist/bundle/cli.js" }));
|
||||
assert.equal(await real.version({ env: { MOSAIC_PI_BIN: cli } }), "1.2.3");
|
||||
});
|
||||
@@ -48,20 +48,20 @@ test('P3 Claude preflight accepts a proxy key without a host provider credential
|
||||
|
||||
test('P3 pi refuses no-session-credential with no provider key', async () => {
|
||||
const pi = await harness('pi');
|
||||
assert.equal(pi.preflight({ env: {} })?.code, 'no-session-credential');
|
||||
assert.equal((await pi.preflight({ env: {} }))?.code, 'no-session-credential');
|
||||
});
|
||||
|
||||
test('P3 pi refuses no-session-credential with only a Claude OAuth token', async () => {
|
||||
const pi = await harness('pi');
|
||||
assert.equal(pi.preflight({ env: { CLAUDE_CODE_OAUTH_TOKEN: 'fx332-oauth' } })?.code, 'no-session-credential');
|
||||
assert.equal((await pi.preflight({ env: { CLAUDE_CODE_OAUTH_TOKEN: 'fx332-oauth' } }))?.code, 'no-session-credential');
|
||||
});
|
||||
|
||||
test('P3 pi accepts its own provider key or a session proxy key', async () => {
|
||||
const pi = await harness('pi');
|
||||
for (const name of ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'OPENROUTER_API_KEY', 'ZAI_API_KEY']) {
|
||||
assert.equal(pi.preflight({ env: { [name]: 'fx332-own' } }), null, name);
|
||||
assert.equal(await pi.preflight({ env: { [name]: 'fx332-own' } }), null, name);
|
||||
}
|
||||
assert.equal(pi.preflight({ env: {}, proxy: { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' } }), null);
|
||||
assert.equal(await pi.preflight({ env: {}, proxy: { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' } }), null);
|
||||
});
|
||||
|
||||
// Row 332 R2 (#1830): callers that only want pi's bundle sources call bundle() with no argument,
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
//
|
||||
// read-only /usr, /etc and the host's /bin, /lib, /lib64, /sbin links;
|
||||
// the repository files the runner loads; the adapter; for pi
|
||||
// the repository's node_modules, for Claude Code its pinned
|
||||
// the found package's directory (#1873), for Claude Code its
|
||||
// binary; node when it lives outside /usr; the broker socket,
|
||||
// the launch socket for the role that may launch, and the
|
||||
// host's git socket for a role holding git.push.working or
|
||||
@@ -41,7 +41,8 @@ import { ID_PATTERN } from "../../organization/src/vocabulary.mjs";
|
||||
|
||||
export const REPO = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
|
||||
export const BWRAP = "/usr/bin/bwrap";
|
||||
const KILL_WITH_PARENT = ["/usr/bin/setpriv", "--pdeathsig", "KILL", "--"];
|
||||
export const SETPRIV = "/usr/bin/setpriv";
|
||||
const KILL_WITH_PARENT = [SETPRIV, "--pdeathsig", "KILL", "--"];
|
||||
|
||||
// What the runner imports, and the three files the harness starts from the
|
||||
// bundle's settings (claude-gate, mcp-server, pi-extension) with theirs.
|
||||
@@ -185,14 +186,61 @@ export function gitIdentity({ business, role }) {
|
||||
return { GIT_AUTHOR_NAME: role, GIT_AUTHOR_EMAIL: email, GIT_COMMITTER_NAME: role, GIT_COMMITTER_EMAIL: email };
|
||||
}
|
||||
|
||||
// The full command line for `command` inside the sandbox. HOME is the run's
|
||||
// home/, empty at the start; the harness makes what it needs there. The git
|
||||
// identity is the role's, for the business it runs in.
|
||||
export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWRAP }) {
|
||||
const identity = Object.entries(gitIdentity({ business, role })).flatMap(([k, v]) => ["--setenv", k, v]);
|
||||
return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", ...identity, "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command];
|
||||
// The variables the sandbox sets for a session's runner, over the session env
|
||||
// the launcher hands it. HOME is the run's home/, empty at the start; the
|
||||
// harness makes what it needs there. TMPDIR is the private /tmp. The git
|
||||
// identity is the role's, for the business it runs in. #1873 S3: the pi fit
|
||||
// check gives its runs these too, so they get the names a session gets.
|
||||
export function sessionSetenv(runDir, { business, role }) {
|
||||
return { HOME: join(runDir, "home"), TMPDIR: "/tmp", ...gitIdentity({ business, role }) };
|
||||
}
|
||||
|
||||
// The full command line for `command` inside the sandbox, with sessionSetenv's variables.
|
||||
export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWRAP }) {
|
||||
const setenv = Object.entries(sessionSetenv(runDir, { business, role })).flatMap(([k, v]) => ["--setenv", k, v]);
|
||||
return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", ...setenv, "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command];
|
||||
}
|
||||
|
||||
// #1873 pi-unpin S3: the command line for a start-time check of a harness binary. It has the
|
||||
// system part every session gets, then `list`, with the network unshared, an empty environment
|
||||
// but `env`, and `chdir` as the working directory.
|
||||
//
|
||||
// #1873 re-check 9: a check dies with the process that runs it, unlike a session. It must not
|
||||
// outlive a bus that was killed. These steps make sure of that:
|
||||
// - setpriv gives the first process SIGKILL as its parent-death signal. A shell then checks
|
||||
// that its parent is still this process ($PPID is read after the signal is set). So either
|
||||
// the owner dies later and the signal kills the chain, or the owner is already gone and the
|
||||
// shell exits before anything starts.
|
||||
// - bwrap's --die-with-parent ties bwrap to the process before it.
|
||||
// - unshare, when this host lets it (the outer layer below), runs bwrap as pid 1 of a fresh pid
|
||||
// namespace, and --kill-child kills it when unshare dies. When pid 1 of a namespace dies, the
|
||||
// kernel kills every process in it. That includes bwrap's own child, wherever it is in its
|
||||
// setup. bwrap's --die-with-parent can't reach that child: bwrap sets the child's parent-death
|
||||
// signal only just before its exec, after the child waits for bwrap to write its uid map. If
|
||||
// bwrap dies before that write, the child waits for good.
|
||||
// The one step left open with the outer layer is unshare's own: if unshare dies after it forks
|
||||
// and before its child sets the signal, bwrap still runs. bwrap is alive then, so the run sets up
|
||||
// and goes on as normal, and it ends when the binary exits. It does not wait for good.
|
||||
//
|
||||
// #1873 re-check 10: the outer layer is best effort. unshare may be missing, older than
|
||||
// util-linux 2.36 (the first with --map-current-user), or refused: on Ubuntu 24.04 with
|
||||
// kernel.apparmor_restrict_unprivileged_userns=1 only bwrap has a profile that lets it make a
|
||||
// user namespace, so an unconfined unshare can't write its uid map. The fit check probes it once
|
||||
// per check (pi-fit.mjs) and passes unshare: null when it can't run, which drops the outer layer
|
||||
// and nothing else. That is not a weaker sandbox: the outer layer only bounds how long a check's
|
||||
// processes live. The sandbox a fit run gets is bwrap's, and bwrap's command line is the same
|
||||
// either way (pi-fit.test.mjs compares the two). Without the outer layer a stuck bwrap child can
|
||||
// outlive a killed owner; the next check stops it (sweepScratch in pi-fit.mjs).
|
||||
export const UNSHARE = "/usr/bin/unshare";
|
||||
const owned = () => [...KILL_WITH_PARENT, "/bin/sh", "-c", '[ "$PPID" = "$0" ] && exec "$@"', String(process.pid)];
|
||||
const bound = (unshare) => unshare ? [unshare, "--user", "--map-current-user", "--pid", "--fork", "--kill-child", "--"] : [];
|
||||
export function checkArgv(list, command, { env = {}, chdir, node = process.execPath, bwrap = BWRAP, unshare = UNSHARE }) {
|
||||
const setenv = Object.entries(env).flatMap(([k, v]) => ["--setenv", k, v]);
|
||||
return [...owned(), ...bound(unshare), bwrap, "--die-with-parent", ...NAMESPACES, "--unshare-net", ...argsOf([...systemBinds(node), ...list]), "--remount-ro", "/", "--clearenv", ...setenv, "--chdir", chdir, "--", ...KILL_WITH_PARENT, ...command];
|
||||
}
|
||||
// The outer layer alone, for its probe: the steps before bwrap in checkArgv, then command.
|
||||
export const outerArgv = (command, { unshare = UNSHARE } = {}) => [...owned(), ...bound(unshare), ...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
|
||||
|
||||
@@ -254,7 +254,7 @@ export const ENV_ALLOW = Object.freeze([
|
||||
"HOME", "USER", "LOGNAME", "LANG", "LC_ALL", "TZ", "TERM",
|
||||
"ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "CLAUDE_CODE_OAUTH_TOKEN",
|
||||
"OPENAI_API_KEY", "OPENROUTER_API_KEY", "ZAI_API_KEY",
|
||||
"MOSAIC_CLAUDE_BIN",
|
||||
"MOSAIC_CLAUDE_BIN", "MOSAIC_PI_BIN",
|
||||
]);
|
||||
|
||||
// The ways a Claude Code session can log in, each a set of variables that
|
||||
|
||||
@@ -129,7 +129,7 @@ test("row 65 a harness module's mounts bind read-only after the adapter, each wi
|
||||
const list = binds({ ...args, harnessMounts: pi.mounts({ env: {} }) });
|
||||
const at = (src) => list.findIndex((b) => b.src === src);
|
||||
const modules = list[at(realpathSync(join(REPO, "node_modules")))];
|
||||
assert.deepEqual(modules, { kind: "ro", src: realpathSync(join(REPO, "node_modules")), dest: join(REPO, "node_modules"), why: "pi and its packages, on the session's PATH" });
|
||||
assert.deepEqual(modules, { kind: "ro", src: realpathSync(join(REPO, "node_modules")), dest: join(REPO, "node_modules"), why: "pi and its packages (the repository's pi)" });
|
||||
assert.ok(at(join(root, "a.sh")) < at(modules.src) && at(modules.src) < at(join(root, "bus.sock")));
|
||||
const fixture = binds({ ...args, harnessMounts: [{ src: join(root, "tool"), why: "a fixture harness's tool" }] });
|
||||
assert.deepEqual(fixture.find((b) => b.src === join(root, "tool")), { kind: "ro", src: join(root, "tool"), why: "a fixture harness's tool" });
|
||||
|
||||
@@ -58,6 +58,15 @@ test("sessionEnv passes only the allowlist, the repo's bin on PATH, and the run
|
||||
assert.equal(sessionEnv({ MOSAIC_CLAUDE_BIN: "/opt/claude" }, "r0123456789ab").MOSAIC_CLAUDE_BIN, "/opt/claude");
|
||||
});
|
||||
|
||||
// #1873 pi-unpin S2: the host's MOSAIC_PI_BIN reaches the session, as MOSAIC_CLAUDE_BIN does, and
|
||||
// it is the only name the slice adds: every other MOSAIC_* and PI_* name from the host stays out.
|
||||
test("pi-unpin S2: sessionEnv passes MOSAIC_PI_BIN and nothing else new", () => {
|
||||
const env = sessionEnv({ MOSAIC_PI_BIN: "/opt/pi/bin/pi", PI_CODING_AGENT_DIR: "/h/.pi", PI_OFFLINE: "0", MOSAIC_PI_ROOT: "/x", PATH: "/usr/bin" }, "r0123456789ab");
|
||||
assert.deepEqual(Object.keys(env).sort(), ["MOSAIC_PI_BIN", "MOSAIC_RUN_ID", "PATH"]);
|
||||
assert.equal(env.MOSAIC_PI_BIN, "/opt/pi/bin/pi");
|
||||
assert.deepEqual(ENV_ALLOW.filter((k) => k.startsWith("MOSAIC_")), ["MOSAIC_CLAUDE_BIN", "MOSAIC_PI_BIN"]);
|
||||
});
|
||||
|
||||
test("ZAI_API_KEY passes the session allowlist, and ZAI_TOKEN does not", () => {
|
||||
assert.ok(ENV_ALLOW.includes("ZAI_API_KEY"));
|
||||
const env = sessionEnv({ ZAI_API_KEY: "fixture-zai", ZAI_TOKEN: "t" }, "r0123456789ab");
|
||||
|
||||
@@ -230,7 +230,9 @@ try {
|
||||
// own check (no symlink, a regular file this user owns, not group or world writable).
|
||||
const rideRiders = async ({ timeoutMs = 5000, deadline } = {}) => {
|
||||
const writer = organizationWriter({ dir: configDir(), rolesDir: rolesDir() });
|
||||
const local = id => readRider({ id, read: () => writer.read(id).document, readLog: () => ownedText(writer.logFile(id), { mask: 0o022 }), isFixture: orgUsesFixture });
|
||||
// settings-backend A2: `file()` is the organization file as the writer reads it ({document, revision}),
|
||||
// read again on each call, for turning a program off for every organization.
|
||||
const local = id => ({ ...readRider({ id, read: () => writer.read(id).document, readLog: () => ownedText(writer.logFile(id), { mask: 0o022 }), isFixture: orgUsesFixture }), file: () => writer.read(id) });
|
||||
const down = async () => { throw Object.assign(new Error('the bus is not reachable'), { code: 'no-bus-host' }); };
|
||||
// The single-business Console has no bus status here: its organization never reads as stopped.
|
||||
if (!organizations) return ownerCall && options.business ? [{ ...local(options.business), call: ownerCall }] : [];
|
||||
@@ -264,6 +266,8 @@ try {
|
||||
return out;
|
||||
},
|
||||
riders: rideRiders,
|
||||
// The root agents each organization takes count when a program is turned off (review P1-1).
|
||||
rootAgents: () => loadRootAgents(configDir(), { rolesDir: rolesDir() }),
|
||||
ownerModels,
|
||||
// A stopped fixture organization moves through the organization service's whole-file update, the
|
||||
// write `POST /api/orgs/ID/admin` makes, as the signed-in owner. The owner starts its bus after.
|
||||
|
||||
@@ -36,7 +36,28 @@ const ROUTES = Object.freeze({
|
||||
// #1873 ride-default: Ride all, and the confirmed move of one stopped fixture organization.
|
||||
'/api/proxy/admin/ride-all': ['POST', []],
|
||||
'/api/proxy/admin/ride-move': ['POST', ['org']],
|
||||
// #1873 settings-backend A1: reads for Model setup. The list names each read's query keys.
|
||||
'/api/proxy/admin/log': ['GET', ['lines']],
|
||||
'/api/proxy/admin/service-key': ['GET', []],
|
||||
'/api/proxy/admin/history': ['GET', ['limit', 'before']],
|
||||
// #1873 settings-backend A2: one harness program off for every organization, and each
|
||||
// organization's proxy client key health. The program list itself is in status.
|
||||
'/api/proxy/admin/programs/off': ['POST', ['name']],
|
||||
'/api/proxy/admin/access': ['GET', []],
|
||||
});
|
||||
// The A1 reads take a query; every other route ignores one, as before.
|
||||
const QUERY_ROUTES = new Set(['/api/proxy/admin/log', '/api/proxy/admin/service-key', '/api/proxy/admin/history']);
|
||||
// Each query key at most once, only the route's own keys, each a plain decimal number.
|
||||
function readQuery(req, allowed) {
|
||||
let params;
|
||||
try { params = new URL(req.url, 'http://localhost').searchParams; } catch { return null; }
|
||||
const out = {};
|
||||
for (const [key, value] of params) {
|
||||
if (!allowed.includes(key) || Object.hasOwn(out, key) || !/^[0-9]{1,15}$/.test(value)) return null;
|
||||
out[key] = Number(value);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
export const PROXY_ADMIN_PATHS = Object.freeze(Object.keys(ROUTES));
|
||||
const INIT_KEYS = ['generate', 'key', 'confirm', 'port', 'rotateGraceMinutes', 'firstOutputSeconds'];
|
||||
const json = (res, status, value) => {
|
||||
@@ -71,6 +92,8 @@ export async function proxyAdminHTTP(req, res, { path, admin, call, named, teste
|
||||
if (req.headersDistinct.origin?.length !== 1 || req.headers.origin !== origin) return done(403, { error: 'cross-origin request refused' });
|
||||
if (req.headersDistinct['sec-fetch-site']?.length !== 1 || req.headers['sec-fetch-site'] !== 'same-origin') return done(403, { error: 'cross-site request refused' });
|
||||
}
|
||||
let query = {};
|
||||
if (QUERY_ROUTES.has(path)) { query = readQuery(req, route[1]); if (!query) return refuse('invalid-request'); }
|
||||
if (!admin) return refuse('not-configured');
|
||||
let args = {};
|
||||
if (req.method === 'POST') {
|
||||
@@ -118,6 +141,13 @@ export async function proxyAdminHTTP(req, res, { path, admin, call, named, teste
|
||||
case '/api/proxy/admin/ride-move':
|
||||
if (typeof args.org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(args.org)) return refuse('invalid-request');
|
||||
return done(200, await admin.rideMove({ org: args.org, principal }));
|
||||
case '/api/proxy/admin/log': return done(200, await admin.log(Object.hasOwn(query, 'lines') ? { lines: query.lines } : {}));
|
||||
case '/api/proxy/admin/service-key': return done(200, await admin.serviceKey());
|
||||
case '/api/proxy/admin/history': return done(200, await admin.history({ ...(Object.hasOwn(query, 'limit') ? { limit: query.limit } : {}), before: query.before ?? null }));
|
||||
case '/api/proxy/admin/programs/off':
|
||||
if (typeof args.name !== 'string' || !/^[a-z][a-z0-9-]{0,31}$/.test(args.name)) return refuse('invalid-request');
|
||||
return done(200, await admin.programsOff({ name: args.name, user: typeof user === 'string' ? user : null }));
|
||||
case '/api/proxy/admin/access': return done(200, await admin.access());
|
||||
}
|
||||
} catch (error) {
|
||||
const code = ['human-required', 'not-configured', 'invalid-request'].includes(error?.code) ? error.code : proxyCode(error, 'outcome-unknown');
|
||||
|
||||
@@ -18,7 +18,10 @@ const codes = ['not-configured', 'human-required', 'provider-not-allowed', 'logi
|
||||
const json = (res, status, value) => {
|
||||
res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify(value));
|
||||
};
|
||||
export async function proxyHTTP(req, res, { path, call, named, tester, granted, send, origin, user, log }) {
|
||||
// `record` is the proxy setup controller's recordAccount (settings-backend A1), or null where this
|
||||
// Console has no proxy setup: after a write's bus call answers, an account change is added to the
|
||||
// setup history. A record that fails leaves the bus answer as it is and adds recorded: false.
|
||||
export async function proxyHTTP(req, res, { path, call, named, tester, granted, send, origin, user, log, record = null }) {
|
||||
const route = routes[path];
|
||||
const done = (status, value) => {
|
||||
// No request body, query, login state, authorization URL or exception text.
|
||||
@@ -48,11 +51,19 @@ export async function proxyHTTP(req, res, { path, call, named, tester, granted,
|
||||
} catch { return done(400, { error: 'invalid-request' }); }
|
||||
}
|
||||
if (path === '/api/proxy/plugins/set' && (!args.plugins || typeof args.plugins !== 'object' || Array.isArray(args.plugins) || Object.keys(args.plugins).length !== 1 || !['harness', 'model-provider'].includes(Object.keys(args.plugins)[0]) || !Array.isArray(Object.values(args.plugins)[0]) || !Object.values(args.plugins)[0].every(name => typeof name === 'string'))) return done(400, { error: 'invalid-request' });
|
||||
try { return done(200, await call(route[1], args)); }
|
||||
let value;
|
||||
try { value = await call(route[1], args); }
|
||||
catch (error) {
|
||||
const code = codes.includes(error.code) || (path === '/api/proxy/plugins/set' && typeof error.code === 'string' && /^[a-z-]{1,64}$/.test(error.code)) ? error.code : 'outcome-unknown';
|
||||
// proxy-pickup (#1873): a bus with no proxy client names the cause in one plain line.
|
||||
const reason = code === 'not-configured' && typeof error.reason === 'string' ? { reason: error.reason.slice(0, 300) } : {};
|
||||
return done(code === 'human-required' ? 403 : ['not-configured', 'proxy-down', 'outcome-unknown'].includes(code) ? 503 : 400, { error: code, ...reason });
|
||||
}
|
||||
if (req.method === 'POST' && typeof record === 'function') {
|
||||
let recorded;
|
||||
try { recorded = record({ verb: route[1], args, result: value, user: user ?? null }); } catch { recorded = false; }
|
||||
// All four recorded verbs answer a plain object; any other answer is passed on unmarked.
|
||||
if (recorded === false && value && typeof value === 'object' && !Array.isArray(value)) value = { ...value, recorded: false };
|
||||
}
|
||||
return done(200, value);
|
||||
}
|
||||
@@ -703,7 +703,14 @@
|
||||
<h2 id="b-for-you">Open decisions <span class="count">${rows.length}</span></h2>${body}
|
||||
<p class="small muted">Open a decision for its seen, DM and closing history.</p>`;
|
||||
}
|
||||
const messageText = m => m.from_role !== 'human' && typeof m.body === 'string' && m.body.startsWith('The turn failed: ') ? `The assistant couldn't reply. Try again, or check Agents.<span class="source">Details: ${txt(m.body.slice('The turn failed: '.length))}</span>` : txt(m.body);
|
||||
// #1873 settings slice 5: a failed turn whose body carries its own "\nDetails: " part (chat.js
|
||||
// messageBody) shows its cause and that part once.
|
||||
const messageText = m => {
|
||||
if (m.from_role === 'human' || typeof m.body !== 'string' || !m.body.startsWith('The turn failed: ')) return txt(m.body);
|
||||
const rest = m.body.slice('The turn failed: '.length), at = rest.indexOf('\nDetails: ');
|
||||
if (at > 0) return `The assistant couldn't reply: ${txt(rest.slice(0, at))}<span class="source">Details: ${txt(rest.slice(at + '\nDetails: '.length))}</span>`;
|
||||
return `The assistant couldn't reply. Try again, or check Agents.<span class="source">Details: ${txt(rest)}</span>`;
|
||||
};
|
||||
async function messagesView(get, q) {
|
||||
const after = q.get('after');
|
||||
if (after !== null && !SAFE.test(after)) return notFound('The message cursor is not a message id.');
|
||||
@@ -1299,6 +1306,9 @@
|
||||
}
|
||||
const routesApplyMarkup=()=>routesApply?.length?`<ul class="routes-apply" aria-label="How the change reaches each agent">${routesApply.map(a=>`<li><b>${txt(a.name)}</b>: ${txt(a.text)}${a.restart&&canSend&&!isTester?` ${window.MosaicAgents?.restartMarkup(a.name,a.thread)??''}`:''}</li>`).join('')}</ul>`:'';
|
||||
let harnessSettings=null, harnessDraft=null, harnessLoading=false, harnessReceipt='', harnessBusy=false;
|
||||
// #1873 settings slice 5: the organization's one choice, Use your models (the cliproxy module in
|
||||
// its model-provider list, from the plugins read above) or its own model service (Coming later).
|
||||
let modelsReceipt='', modelsReceiptKind='', modelsBusy=false, modelsFocus=false;
|
||||
function readHarnesses(){
|
||||
if(harnessLoading || harnessSettings !== null || !canSend || isTester)return; harnessLoading=true;const epoch=orgEpoch;
|
||||
fetch('/api/proxy/plugins',{cache:'no-store',redirect:'manual'}).then(async r=>{const v=await r.json();if(epoch!==orgEpoch)return;if(!r.ok || !/^[a-f0-9]{64}$/.test(v.revision??'') || !Array.isArray(v.available?.harness) || !v.available.harness.every(n=>typeof n==='string') || !Array.isArray(v.plugins?.harness??[]))throw Error();harnessSettings=v;}).catch(()=>{if(epoch!==orgEpoch)return;harnessSettings=false;harnessReceipt='Harnesses could not be read.';}).finally(()=>{if(epoch!==orgEpoch)return;harnessLoading=false;if(routeOf().split('?')[0]==='/settings/routing')render(false);});
|
||||
@@ -1345,11 +1355,48 @@
|
||||
if(owner&&serviceState==='not-running')return `<p class="small warn" id="routes-catalogue">${lead} The model service is not running. ${setupLink('Open Model setup')}. ${thinking}</p>${words}`;
|
||||
if(owner&&(serviceLoading||(serviceState===null&&triageOwner)))return `<p class="small warn" id="routes-catalogue">${lead} Checking the model service. ${thinking}</p>`;
|
||||
if(owner&&serviceState===false)return `<div class="banner routes-catalogue" id="routes-catalogue" role="status"><p>${lead}${plain} The model service's status could not be read. ${thinking}</p>${words}<p class="actions">${recheck}</p></div>`;
|
||||
return `<p class="small warn" id="routes-catalogue">${lead}${plain} ${thinking}${owner?' A new model needs the model service: ask the instance owner to set it up, or press Stop using the model service when this organization does not need it.':''}</p>${words}`;
|
||||
return `<p class="small warn" id="routes-catalogue">${lead}${plain} ${thinking}${owner?' A new model needs the model service: ask the instance owner to set it up, or press Stop using your models when this organization does not need it.':''}</p>${words}`;
|
||||
}
|
||||
// Check again rereads Routing; the bus looks for the model service at that read. A draft is kept.
|
||||
document.addEventListener('click',e=>{if(e.target.id!=='routes-recheck')return;e.target.disabled=true;serviceState=null;routesView=null;last.delete('routes');render(true);});
|
||||
document.addEventListener('mosaic-org-restarted',e=>{if(e.detail?.id!==window.MosaicOrg?.id)return;serviceState=null;routesView=null;last.delete('routes');const path=routeOf().split('?')[0];if(path==='/settings/routing'||document.querySelector('[data-org-down]'))render(true);});
|
||||
// The choice reads only the plugins read: before it answers the radios wait, and a failed read
|
||||
// says so with Read again. Use your models writes at once; Stop using your models is the way back.
|
||||
// While the organization needs a restart, its banner's Restart is the one primary and the choice waits.
|
||||
// A Console with no organizations says "this business": lowercase inside a sentence, capitalized
|
||||
// at its start (cap).
|
||||
const modelsWho=cap=>window.MosaicOrg?(window.MosaicOrg.label||window.MosaicOrg.id):cap?'This business':'this business';
|
||||
const modelsWhose=cap=>`${modelsWho(cap)}'s`;
|
||||
// settings-s5 review P2-3: a choice that is not in force says when the model service behind it is
|
||||
// not set up or not answering (the owner's status read, as on the catalogue line). The choice
|
||||
// still writes: riding before setup is the design's "Nothing set up" state.
|
||||
function modelsService(){
|
||||
const link=text=>`<a href="#/settings/model-setup">${text}</a>`;
|
||||
return serviceState==='not-set-up'?`<p class="small warn" id="models-service">Your model service isn't set up. ${link('Set it up in Model setup')}.</p>`
|
||||
:serviceState==='not-running'?`<p class="small warn" id="models-service">Your model service isn't answering. ${link('Restart it in Model setup')}.</p>`
|
||||
:serviceState==='fenced'?`<p class="small warn" id="models-service">Your model service is waiting for a restart to finish. ${link('Open Model setup to finish it')}.</p>`:'';
|
||||
}
|
||||
function modelsChoice(restartFirst){
|
||||
const who=txt(modelsWho()), Who=txt(modelsWho(true)), whose=txt(modelsWhose()), Whose=txt(modelsWhose(true));
|
||||
const names=harnessSettings&&Array.isArray(harnessSettings.plugins?.['model-provider'])?harnessSettings.plugins['model-provider']:[];
|
||||
const read=!!harnessSettings, on=read&&names.includes('cliproxy'), wait=!read||modelsBusy||restartFirst||out();
|
||||
if(triageOwner)readService();
|
||||
const now=harnessSettings===false?`Which models ${who} uses could not be read.`:!read?`Reading ${whose} models…`:on?`Now: ${who} uses your models.`:`Now: ${who} does not use your models. Its agents use only the models in its own organization file.`;
|
||||
const change=!read?'':restartFirst?`<p class="small" id="models-wait">You can change ${whose} models after it restarts.</p>`
|
||||
:on?`<p class="small muted" id="models-change">Its agents can use the models your accounts offer. To switch back, press Stop using your models. A route on one of your models then stops working until you change it.</p>`
|
||||
:`<p class="small muted" id="models-change">Choose Use your models to switch. ${Whose} agents can then use the models your accounts offer. While your model service is down, a launch that needs it is refused. A running agent keeps its model until it starts again.</p>${modelsService()}`;
|
||||
// P2-1: while the organization needs a restart every control here waits. Stop is left out, as in
|
||||
// the mockup, since a disabled button here looks no different from an enabled one.
|
||||
const stop=on&&!restartFirst?`<button type="button" id="models-stop"${modelsBusy||out()?' disabled':''}>${modelsBusy?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':'Stop using your models'}</button>`:'';
|
||||
const again=harnessSettings===false?'<button type="button" id="models-read">Read again</button>':'';
|
||||
// P3-1: Use your models has no button of its own, so its write shows Saving in the status line.
|
||||
const status=modelsBusy&&!on?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':txt(modelsReceipt);
|
||||
return `<fieldset class="models-source" id="models-source"><legend>Where ${who} gets its models</legend>`
|
||||
+`<label class="choice"><input type="radio" name="models-source" id="models-yours" value="yours"${on?' checked':''}${wait?' disabled':''}><strong>Use your models</strong><span class="badge badge-ok">Recommended</span><span class="small muted">${Who} uses the model service and accounts in Model setup. Nothing to sign in to.</span></label>`
|
||||
+`<label class="choice off"><input type="radio" name="models-source" id="models-own" value="own" disabled><strong>Use its own model service</strong><span class="badge badge-muted">Coming later</span><span class="small muted">${Who} would run a second model service with its own accounts. Planned, not built yet, so you can't choose it today.</span></label>`
|
||||
+`<p id="models-in-force">${now}</p>${change}<p class="actions">${stop}${again}</p>`
|
||||
+`<p role="status" id="models-receipt" class="${modelsBusy&&!on?'':modelsReceiptKind}" tabindex="-1" data-focus-key="models-receipt">${status}</p></fieldset>`;
|
||||
}
|
||||
function routesSection(view,instanceInfo){
|
||||
const title='<h2 id="routes-title">Routing</h2>';
|
||||
readHarnesses();
|
||||
@@ -1381,7 +1428,7 @@
|
||||
// settings-p3 (re-check 3 P3-5): a ready catalogue the bus picked up late says agents start on these
|
||||
// models after a restart; that notice gets the organization's Restart (not primary: Save routes is).
|
||||
const catalogueInfo=v.catalogue?.status==='ready'?`<p class="small muted">Model catalogue, observed ${txt(window.MosaicLocalTime(v.catalogue.observedAt))}.</p>${(v.catalogue.notices??[]).map(n=>`<p class="small warn">${txt(n)}${n===window.MosaicConsole?.RESTART_TO_LAUNCH&&window.MosaicOrg?.id?` ${window.MosaicConsole.orgRestartButton(window.MosaicOrg.id,{name:window.MosaicOrg.label||window.MosaicOrg.id})}`:''}</p>`).join('')}`:v.catalogue?.status==='unavailable'?catalogueLine(proxyOn,v.catalogue):'<p class="small muted">Model catalogue not enabled.</p>';
|
||||
const providerControl=canSend&&!isTester?`<button type="button" id="provider-switch" data-enabled="${proxyOn}">${proxyOn?'Stop using the model service':'Use your models'}</button><p role="status" id="provider-switch-status"></p>`:'';
|
||||
const providerControl=canSend&&!isTester?modelsChoice(/ data-primary[ >]/.test(catalogueInfo)):'';
|
||||
const harnessControl=canSend&&!isTester?`<fieldset class="harness-control"><legend>Harnesses</legend>${harnessSettings ? [...new Set([...harnessSettings.available.harness,...(harnessSettings.plugins.harness??[])])].map(name=>`<label><input type="checkbox" data-harness="${esc(name)}"${(harnessDraft??harnessSettings.plugins.harness??[]).includes(name)?' checked':''}${harnessBusy?' disabled':''}> ${txt(name)}</label>`).join('')+` <button type="button" id="harness-save"${harnessBusy?' disabled':''}>Save harnesses</button>` : '<p>Harnesses unavailable.</p><button type="button" id="harness-read">Read harnesses again</button>'}<p role="status" id="harness-status">${txt(harnessReceipt)}</p></fieldset>`:'';
|
||||
const off=v.harnesses.length?'':'<p class="small warn">No harness is switched on for this organization, so every launch is refused, and so is a save that changes a harness. Switch one on under Harnesses.</p>';
|
||||
return `<section class="panel routing-panel" aria-labelledby="routes-title"><span class="sr-only">${title}</span>${catalogueInfo}${providerControl}${harnessControl}${off}<form id="routes-form"><div class="table-wrap" tabindex="0" role="region" aria-label="Routes, scroll for all columns"><table id="routes-table"><thead><tr><th scope="col" rowspan="2">Agent</th><th scope="colgroup" colspan="3">Primary</th><th scope="colgroup" colspan="3">Fallback</th></tr><tr>${ROUTE_CELLS.map(([,l])=>`<th scope="col">${l.replace('Fallback ','')}</th>`).join('')}</tr></thead><tbody>${rows}</tbody></table></div><p class="small muted">${canSend || isTester?'Changes are checked and logged with your identity.':'Saving requires signed-in send mode.'}</p><div class="settings-actions route-actions${routesDraft?' has-draft':''}"><button type="submit"${/ data-primary[ >]/.test(catalogueInfo)?' class="route-save-quiet"':''}${disabled}>${routesBusy?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':'Save routes'}</button> <button type="button" id="routes-reload"${routesDraft?'':' hidden'}${routesBusy||!routesDraft?' disabled':''}>Discard draft</button><p role="status" id="routes-receipt" class="${routesReceipt.startsWith('Outcome unknown')?'banner ref':routesReceipt.includes('Draft kept')?'banner err':routesReceipt.includes('saved')?'settings-success':''}">${txt(routesReceipt)}</p></div>${routesApplyMarkup()}</form></section>`;
|
||||
@@ -1409,7 +1456,7 @@
|
||||
const moved=Object.entries(routes).flatMap(([name,r])=>{const was=routesView?.instances?.[name]??{};
|
||||
return [[r.harness,r.model,was.harness,was.model],[r.fallback?.harness,r.fallback?.model,was.fallback?.harness,was.fallback?.model]].filter(([h,m,wh,wm])=>m&&(h!==wh||m!==wm)).map(([,m])=>m);});
|
||||
const module=key=>routesView?.providerModels?.[key]?.module;
|
||||
return moved.length&&moved.every(key=>module(key)&&module(key)!=='cliproxy'&&names.includes(module(key)))?' This change does not need the model service: press Stop using the model service, then save again.':'';
|
||||
return moved.length&&moved.every(key=>module(key)&&module(key)!=='cliproxy'&&names.includes(module(key)))?' This change does not need your models: press Stop using your models, then save again.':'';
|
||||
}
|
||||
const routesAnswer=r=>/^[a-f0-9]{64}$/.test(r?.revision??'')&&Array.isArray(r.harnesses)&&Array.isArray(r.models)&&[r.levels,r.instances].every(o=>o&&typeof o==='object'&&!Array.isArray(o));
|
||||
for(const kind of ['input','change'])document.addEventListener(kind,e=>{const form=e.target?.closest?.('#routes-form');if(!form||!routesView)return;routesDraft=routesFields(form);routesEditVersion++;markSettingsDraft('routing',true);form.querySelector('.settings-actions')?.classList.add('has-draft');const discard=$('routes-reload');if(discard){discard.hidden=false;discard.disabled=false;}
|
||||
@@ -1429,17 +1476,32 @@
|
||||
catch{if(epoch!==orgEpoch)return;harnessReceipt='Outcome unknown. Read the harnesses again before trying.';harnessSettings=false;}
|
||||
finally{if(epoch===orgEpoch){harnessBusy=false;if(!out())render(false);}}
|
||||
});
|
||||
document.addEventListener('click',async e=>{if(e.target.id!=='provider-switch'||!canSend||isTester)return;
|
||||
const button=e.target,status=$('provider-switch-status');if(routesDraft){status.textContent='Save or discard the route draft first.';return;}button.disabled=true;const epoch=orgEpoch;
|
||||
try {const read=await fetch('/api/proxy/plugins',{cache:'no-store'});const settings=await read.json();if(epoch!==orgEpoch)return;if(!read.ok||!/^[a-f0-9]{64}$/.test(settings.revision??''))throw Error('Could not read provider settings.');
|
||||
const names=Array.isArray(settings.plugins?.['model-provider'])?settings.plugins['model-provider']:[];
|
||||
// The fresh read decides: a stale label never turns the proxy module on when it meant off.
|
||||
const on=names.includes('cliproxy');if(String(on)!==button.dataset.enabled){button.dataset.enabled=String(on);button.textContent=on?'Stop using the model service':'Use your models';button.disabled=false;status.textContent='The switch now shows the current setting. Press it again to change it.';return;}
|
||||
const next=on?names.filter(n=>n!=='cliproxy'):[...names,'cliproxy'];
|
||||
const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:settings.revision,plugins:{'model-provider':next}}),cache:'no-store',redirect:'manual'});
|
||||
if(epoch!==orgEpoch)return;if(!response.ok)throw Error('Provider setting was refused.');harnessSettings=null;routesView=null;last.delete('routes');render(true);
|
||||
}catch(error){if(epoch!==orgEpoch)return;status.textContent=error.message;button.disabled=false;}
|
||||
});
|
||||
// The fresh read decides: a page that shows a stale choice is redrawn from it and nothing is written.
|
||||
async function setModels(want){
|
||||
if(!canSend||isTester||modelsBusy||!harnessSettings)return;
|
||||
const who=modelsWho(true), shown=(harnessSettings.plugins?.['model-provider']??[]).includes('cliproxy');
|
||||
let sent=false;
|
||||
if(routesDraft){modelsReceipt='Save or discard the route draft first.';modelsReceiptKind='banner err';modelsFocus=true;render(false);return;}
|
||||
modelsBusy=true;modelsReceipt='';modelsReceiptKind='';render(false);const epoch=orgEpoch;
|
||||
try{const read=await fetch('/api/proxy/plugins',{cache:'no-store',redirect:'manual'});const settings=await read.json();if(epoch!==orgEpoch)return;
|
||||
if(!read.ok||!/^[a-f0-9]{64}$/.test(settings.revision??'')||!Array.isArray(settings.available?.harness))throw Error('read');
|
||||
const names=Array.isArray(settings.plugins?.['model-provider'])?settings.plugins['model-provider']:[], on=names.includes('cliproxy');
|
||||
if(on!==shown){harnessSettings=settings;modelsReceipt=`${modelsWhose(true)} models changed since this page read it. The page now shows the current choice; choose again to change it.`;modelsReceiptKind='banner ref';return;}
|
||||
if(on===want)return;
|
||||
const next=want?[...names,'cliproxy']:names.filter(n=>n!=='cliproxy');
|
||||
sent=true;const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:settings.revision,plugins:{'model-provider':next}}),cache:'no-store',redirect:'manual'});
|
||||
const result=await response.json().catch(()=>({}));if(epoch!==orgEpoch)return;
|
||||
if(!response.ok){modelsReceipt=`Not changed. ${result.message||result.error||'The change was refused.'}`;modelsReceiptKind='banner err';return;}
|
||||
modelsReceipt=want?`Saved. ${who} uses your models. An agent picks them up the next time it starts.`:`Saved. ${who} no longer uses your models. An agent on one of them keeps it until it starts again.`;modelsReceiptKind='settings-success';
|
||||
harnessSettings=null;routesView=null;last.delete('routes');window.MosaicModelDots?.read?.();
|
||||
// P3-2: a failed read before the write changed nothing and says so, with Read again.
|
||||
}catch{if(epoch!==orgEpoch)return;if(sent){modelsReceipt='Outcome unknown. Read the page again before trying.';modelsReceiptKind='banner ref';harnessSettings=null;}else{modelsReceipt='Not changed. Nothing was written.';modelsReceiptKind='banner err';harnessSettings=false;}}
|
||||
// P2-4: the render that shows the outcome moves focus to it (render() below).
|
||||
// Recheck N2: only while the page is still shown; a switch left mid-write does not take focus later.
|
||||
finally{if(epoch===orgEpoch){modelsBusy=false;modelsFocus=!!modelsReceipt&&routeOf().split('?')[0]==='/settings/routing';if(!out())render(harnessSettings===null);}}
|
||||
}
|
||||
document.addEventListener('change',e=>{if(e.target.id==='models-yours'&&e.target.checked)setModels(true);});
|
||||
document.addEventListener('click',e=>{if(e.target.closest?.('#models-stop'))setModels(false);else if(e.target.id==='models-read'){harnessSettings=null;harnessReceipt='';modelsReceipt='';modelsReceiptKind='';render(false);}});
|
||||
document.addEventListener('click',e=>{if(e.target.matches?.('.fallback-toggle'))e.target.closest('tr')?.classList.add('fallback-open');});
|
||||
document.addEventListener('click',e=>{if(e.target.id!=='routes-reload')return;routesDraft=null;routesView=null;routesReceipt='';routesApply=null;last.delete('routes');render(true);});
|
||||
document.addEventListener('submit',async e=>{
|
||||
@@ -1525,6 +1587,9 @@
|
||||
const notify = typeof n.binding==='string' ? `<code>${txt(n.binding)}</code>` : n.refused ? `Could not be read: <code>${txt(n.refused)}</code>` : '<span class="muted">None set</span>';
|
||||
const contents={limits:()=>launchForm(s.launch),routing:()=>routesSection(routes,instances),agents:()=>agentsSection(instances)+agentLevels,assistant:()=>assistantSection(s.launch,names),tokens:()=>tokenLimits(limitRows,limitsRefused)+tokenUsage(usage),names:()=>testerNames(names,instances),about:()=>`<section class="panel"><dl class="kv"><dt>Address</dt><dd><code>${txt(s.address)||'unknown'}</code></dd><dt>Release</dt><dd>${txt(s.release)||'unknown'}</dd><dt>Business</dt><dd>${txt(s.business)||none}</dd><dt>Board</dt><dd><code>${txt(s.board)||'unknown'}</code></dd><dt>Notifier binding</dt><dd>${notify}</dd></dl></section>`};
|
||||
const helpers={limits:'Leave a limit blank for no limit. Zero stops new launches. Running sessions keep running when limits or models change.',routing:"Each agent’s harness, model and thinking, and the fallback a launch takes when the primary harness fails its preflight. A fallback sets all three or none. Running sessions keep their route. The next launch reads the change. A harness is the program that runs the model. Preflight is the check a launch makes before it starts.",agents:'Each agent with its definition, launch membership and runs. A launch refuses until the agent has a route in Routing.',assistant:'The definition stays an assistant one. Holder and credentials stay hand edits.',tokens:'Token limits the bus checks, and token use read from session transcripts.'};
|
||||
// settings-s5 review P2-2: the header says where the models come from only from the plugins read.
|
||||
const riding=harnessSettings?(harnessSettings.plugins?.['model-provider']??[]).includes('cliproxy'):null;
|
||||
if(window.MosaicOrg&&!isTester)helpers.routing=`The models ${modelsWhose()} agents use.${riding===true?' They come from your accounts in Model setup.':riding===false?' They come from its own organization file.':''} ${helpers.routing}`;
|
||||
return settingsShell(page,contents[page](),`${get.oldest()?`Read ${when(get.oldest())}.`: 'Reading…'} ${helpers[page]||''}`);
|
||||
}
|
||||
let settingsFocusDisclosure=false;
|
||||
@@ -1911,6 +1976,11 @@
|
||||
if ((navigated || path !== '/settings/organizations') && orgCleanup) {orgCleanup();orgCleanup=null;}
|
||||
// Leaving a decision discards its confirmation immediately, including a preview in flight.
|
||||
if (answer && (navigated || path !== (answer.org ? '/inbox' : `/inbox/${answer.id}`))) answer = null;
|
||||
// Recheck N1: arriving at Models reads the model service again; a status read on an earlier visit may be out of date.
|
||||
if (navigated && path === '/settings/routing' && (typeof shown === 'string' ? shown.split('?')[0] : shown) !== path && !serviceLoading) serviceState = null;
|
||||
// settings-s5b: a focus request for the Models outcome line belongs to that page. Going anywhere else drops it,
|
||||
// including Assistant, Projects and the board, which return before the focus chain at the end of render.
|
||||
if (navigated && path !== '/settings/routing') modelsFocus = false;
|
||||
const g = ++gen, routeVersion = routesEditVersion;
|
||||
const current = () => g === gen && route === routeOf() && !out();
|
||||
// In organization mode #/ is the cross-organization dashboard; the processing controls stay on the board.
|
||||
@@ -1923,6 +1993,8 @@
|
||||
window.MosaicChat?.leave(chatPath);
|
||||
if (path === '/business') { location.replace('#/settings/business'); return; }
|
||||
if (path === '/settings/display') { location.replace('#/settings/appearance'); return; }
|
||||
// #1873 settings slice 5: Members is gone from the nav; its old addresses land on the organization's Agents page.
|
||||
if (path === '/settings/members') { location.replace(`#/settings/agents${window.MosaicOrg ? `?org=${enc(window.MosaicOrg.id)}` : ''}`); return; }
|
||||
// #1873 settings slice 4: the owner's page is Model setup; its old address lands there, query kept.
|
||||
if (path === '/settings/model-proxy') { location.replace(`#/settings/model-setup${query ? `?${query}` : ''}`); return; }
|
||||
// #1873 SP6: the Assistant page draws its own thread panes (assistant.js); every other page
|
||||
@@ -2046,7 +2118,11 @@
|
||||
sections(path);
|
||||
const h1 = $('bus-view').querySelector('h1');
|
||||
document.title = path === '/settings/business' && $('settings-page-title') ? `Settings · ${window.MosaicOrg ? 'Organization' : 'Business'} · Mosaic Console` : `${h1 ? h1.textContent : 'Console'} · Mosaic Console`;
|
||||
if (k) restore(k);
|
||||
// settings-s5 review P2-4: after a switch on Organization > Models, focus goes to its outcome line.
|
||||
// Recheck N2: a render that paints no outcome line drops the request instead of keeping it.
|
||||
const focusModels = modelsFocus && $('models-receipt'); modelsFocus = false;
|
||||
if (focusModels) { if (k) restore(k); focusModels.focus({ preventScroll: true }); }
|
||||
else if (k) restore(k);
|
||||
// Message on the Board (row 95) lands in the form it opened, addressed to the role.
|
||||
else if (focusSend && $('send-body')) { $('send-body').focus(); announce(`Message to ${draft.to}`); }
|
||||
// SP17: a step link on an organization's Workflows card lands in that step's title field.
|
||||
@@ -2261,6 +2337,7 @@
|
||||
instanceView = null; instanceDrafts = { add: null, change: null }; instanceReceipt = ''; instanceReceiptOp = null; instanceReceipts = Object.create(null);
|
||||
routesView = null; routesDraft = null; routesReceipt = ''; routesEditVersion++;
|
||||
harnessSettings = null; harnessDraft = null; harnessReceipt = '';
|
||||
modelsReceipt = ''; modelsReceiptKind = ''; modelsBusy = false; modelsFocus = false;
|
||||
serviceState = null; serviceLoading = false;
|
||||
// A file draft is keyed by project and path only; the page reload that used to drop it is gone.
|
||||
docKey = null; docStates.clear(); pkAll = []; pkShown = []; pkAt = 0;
|
||||
|
||||
@@ -593,7 +593,8 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
const service = '<div id="proxy-setup-next" class="proxy-setup-next" role="status" aria-live="polite"></div>'
|
||||
+ '<ol id="proxy-setup-progress" class="progress" aria-label="Setup progress" hidden></ol>'
|
||||
+ '<p id="proxy-setup-message" role="status" aria-live="polite"></p>'
|
||||
+ '<details id="proxy-setup-lines" hidden><summary>The service\'s last lines</summary><div class="inside"><p class="small muted">This page can\'t read the service\'s lines yet. What the service said last, when the host reported it:</p><pre id="proxy-setup-log" class="setup-log">Nothing reported.</pre></div></details>'
|
||||
// settings-s5b: the lines come from GET /api/proxy/admin/log, read when the box opens (readLog in the controller).
|
||||
+ '<details id="proxy-setup-lines" class="proxy-setup-lines" hidden><summary>The service\'s last lines</summary><div class="inside" data-log></div></details>'
|
||||
+ '<div id="proxy-setup-fixtures" class="banner mk-note" hidden></div>';
|
||||
const accounts = '<p id="proxy-message" role="status" aria-live="polite">Reading accounts…</p>'
|
||||
+ '<p id="proxy-readonly" class="muted" hidden>This Console is read-only. Sign-in and account changes are unavailable.</p>'
|
||||
@@ -637,12 +638,19 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
+ '<dl id="proxy-setup-settings" class="proxy-setup-state" hidden></dl><p id="proxy-setup-settings-note" class="small muted" hidden>Changing these after setup is not built yet.</p></div></details>';
|
||||
const tech = '<details id="proxy-setup-tech" class="proxy-setup-tech"><summary>Technical details: release, service, history</summary><div class="inside">'
|
||||
+ '<div data-admin hidden><dl id="proxy-setup-state" class="proxy-setup-state"></dl>'
|
||||
// settings-s5b: the setup history and the service's lines, read when they open (owner only). The service key is the last
|
||||
// row of the list above (paintState), and the history follows it, as models-advanced shows them.
|
||||
+ '<div class="proxy-setup-history"><h4 id="proxy-setup-history-title">History</h4><p id="proxy-setup-history-message" class="small muted" role="status">Not read yet.</p>'
|
||||
+ '<ol id="proxy-setup-history" aria-labelledby="proxy-setup-history-title"></ol>'
|
||||
+ '<p class="proxy-setup-history-foot"><button type="button" id="proxy-setup-history-all" aria-expanded="false" aria-controls="proxy-setup-history" hidden>Show all</button>'
|
||||
+ '<button type="button" id="proxy-setup-history-older" hidden>Show older</button><button type="button" id="proxy-setup-history-retry" hidden>Read again</button></p></div>'
|
||||
+ '<details id="proxy-setup-tech-lines" class="proxy-setup-lines"><summary>The service\'s last lines</summary><div class="inside" data-log></div></details>'
|
||||
+ '<div class="proxy-setup-unit"><h4>Service controls</h4><p class="small muted">Install renders the unit the same way as <code>mosaic proxy unit install</code>.</p>'
|
||||
+ '<div class="proxy-setup-buttons"><button type="button" data-unit="install" data-setup-write disabled>Install</button><button type="button" data-unit="start" data-setup-write disabled>Start</button><button type="button" data-unit="restart" data-setup-write disabled>Restart</button><button type="button" data-unit="stop" data-setup-write disabled>Stop</button><button type="button" id="proxy-setup-render">Show unit file</button></div>'
|
||||
+ '<pre id="proxy-setup-unit-file" hidden></pre></div>'
|
||||
+ '<div class="proxy-setup-orgs"><h4>Organizations</h4><div class="table-wrap" tabindex="0" role="region" aria-label="Organizations using the model service"><table><thead><tr><th>Organization</th><th>Proxy</th><th>Catalogue</th><th>Models</th></tr></thead><tbody id="proxy-setup-orgs"></tbody></table></div>'
|
||||
+ '<p id="proxy-setup-own" class="muted"></p></div>'
|
||||
+ '<div class="proxy-setup-receipts"><h4>History</h4><ol id="proxy-setup-receipts"><li class="muted">No setup actions on this page yet.</li></ol></div></div>'
|
||||
+ '</div>'
|
||||
+ '</div></details>';
|
||||
const markup = '<div id="proxy-setup" class="model-setup">'
|
||||
+ card('service', 1, 'Model service', service, true)
|
||||
@@ -957,29 +965,174 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
}
|
||||
const say = (text, kind) => receipt('proxy-setup-message', text, kind);
|
||||
const human = value => value === null || value === undefined ? '—' : typeof value === 'object' ? JSON.stringify(value) : String(value);
|
||||
function addReceipt(record) {
|
||||
if (!record || typeof record !== 'object') return;
|
||||
const list = $('proxy-setup-receipts'); list.querySelector('li.muted')?.remove();
|
||||
const li = document.createElement('li'), op = document.createElement('strong'); op.textContent = record.op ?? 'action';
|
||||
const details = Object.entries(record).filter(([k]) => k !== 'op' && k !== 'time').map(([k, v]) => `${k}: ${human(v)}`).join(', ');
|
||||
li.append(op, ` ${window.MosaicLocalTime(record.time)}${details ? ' — ' + details : ''}`);
|
||||
list.prepend(li);
|
||||
// settings-s5b: History, the service key and the service's lines come from their own reads
|
||||
// (GET /api/proxy/admin/history, service-key and log). Nothing reads them until their box opens,
|
||||
// and only the instance owner's page starts this controller. A write's receipt reads them again
|
||||
// when Technical details is open, so the page never shows a raw receipt.
|
||||
const techOpen = () => $('proxy-setup-tech')?.open === true;
|
||||
function addReceipt() { if (enabled && techOpen()) { readKey(); readHistory(true); } }
|
||||
const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
|
||||
const count = n => Number.isInteger(n) && n > 0 ? n : 0;
|
||||
// A failed read says what the answer's code means here; a request that got no answer says so. A code
|
||||
// shaped like a Mosaic key is not shown, even though it passes admin()'s letters-and-hyphens check.
|
||||
const failText = (error, words) => !error?.code ? (error instanceof TypeError ? 'The Console did not answer.' : String(error?.message ?? 'The Console did not answer.'))
|
||||
: /ms[kotp][-_]/i.test(error.code) ? 'The Console refused the read.' : words[error.code] ? `${words[error.code]} (${error.code})` : error.message;
|
||||
const retryButton = (id, action) => { const button = el('button', 'Read again'); button.type = 'button'; if (id) button.id = id; button.addEventListener('click', action); return button; };
|
||||
// The service's last lines: one read paints every box. The lines show as the answer has them:
|
||||
// the route removes key-shaped text; this page adds nothing and takes nothing away.
|
||||
const LOG_WORDS = { 'not-configured': 'The model service is not installed, so it has no lines yet.', 'outcome-unknown': 'The host could not read the service\'s lines.', 'invalid-request': 'The Console refused the request.' };
|
||||
let logRound = 0, logAnswer = null;
|
||||
function paintLog() {
|
||||
for (const box of root.querySelectorAll('[data-log]')) {
|
||||
if (!logAnswer) { box.replaceChildren(el('p', 'Reading the service\'s lines…', 'small muted')); continue; }
|
||||
// An uninstalled service has no lines: a plain line, not a fault.
|
||||
if (logAnswer.none) { box.replaceChildren(el('p', LOG_WORDS['not-configured'], 'small muted'), retryButton(null, readLog)); continue; }
|
||||
if (logAnswer.error) { box.replaceChildren(el('p', `The service's lines could not be read. ${logAnswer.error}`, 'banner err'), retryButton(null, readLog)); continue; }
|
||||
const { lines, redacted, dropped } = logAnswer, notes = ['Mosaic removes anything that looks like a key.'];
|
||||
if (redacted) notes.push(`It removed something from ${plural(redacted, 'line')}.`);
|
||||
if (dropped) notes.push(`${plural(dropped, 'line')} ${dropped === 1 ? 'was' : 'were'} left out.`);
|
||||
const parts = [el('p', notes.join(' '), 'small muted')];
|
||||
parts.push(lines.length ? el('pre', lines.join('\n'), 'setup-log') : el('p', dropped ? 'No line is left to show.' : 'The service has written nothing yet.', 'small muted'));
|
||||
parts.push(retryButton(null, readLog));
|
||||
box.replaceChildren(...parts);
|
||||
}
|
||||
}
|
||||
// #1873: receipts survive a reload: status carries the last few from proxy-admin.jsonl.
|
||||
function paintReceipts() {
|
||||
if (!Array.isArray(state.receipts) || !state.receipts.length) return;
|
||||
$('proxy-setup-receipts').replaceChildren(); state.receipts.forEach(addReceipt);
|
||||
async function readLog() {
|
||||
if (!enabled) return;
|
||||
// A Read again pressed in a box keeps focus there once the answer is painted.
|
||||
const from = [...root.querySelectorAll('[data-log]')].find(box => box.contains(document.activeElement));
|
||||
const round = ++logRound; logAnswer = null; paintLog();
|
||||
let answer;
|
||||
try {
|
||||
const value = await admin('log?lines=20');
|
||||
if (!value || !Array.isArray(value.lines)) throw Object.assign(new Error('The answer could not be read.'), { code: 'outcome-unknown' });
|
||||
answer = { lines: value.lines.filter(line => typeof line === 'string'), redacted: count(value.redacted), dropped: count(value.dropped) };
|
||||
} catch (error) { answer = error?.code === 'not-configured' ? { none: true } : { error: failText(error, LOG_WORDS) }; }
|
||||
if (round !== logRound || !enabled) return;
|
||||
logAnswer = answer; paintLog();
|
||||
from?.querySelector('button')?.focus();
|
||||
}
|
||||
// When the service key was made. Never the key: the answer has no key, and this shows only its time.
|
||||
// It is the last row of the state list; paintState redraws that list, so the row paints from keyView.
|
||||
const KEY_WORDS = { 'not-configured': 'Model service setup is not available on this Console.', 'outcome-unknown': 'The host could not check the key.' };
|
||||
let keyRound = 0, keyView = { text: 'Not read yet.', failed: false };
|
||||
function paintKey() {
|
||||
const dd = $('proxy-setup-keymade-text')?.parentElement; if (!dd) return;
|
||||
const line = el(keyView.failed ? 'p' : 'span', keyView.text, keyView.failed ? 'banner err' : keyView.reading ? 'muted' : undefined); line.id = 'proxy-setup-keymade-text';
|
||||
dd.replaceChildren(line, ...(keyView.failed ? [retryButton('proxy-setup-keymade-retry', readKey)] : []));
|
||||
}
|
||||
function keyRow(dl) {
|
||||
const dt = document.createElement('dt'), dd = document.createElement('dd'), span = el('span'); span.id = 'proxy-setup-keymade-text';
|
||||
dt.textContent = 'Service key'; dd.append(span); dl.append(dt, dd); paintKey();
|
||||
}
|
||||
async function readKey() {
|
||||
if (!enabled) return;
|
||||
const round = ++keyRound, refocus = document.activeElement?.id === 'proxy-setup-keymade-retry';
|
||||
keyView = { text: 'Reading…', failed: false, reading: true }; paintKey();
|
||||
let text, failed = false;
|
||||
try {
|
||||
const value = await admin('service-key');
|
||||
if (!value || typeof value !== 'object') throw Object.assign(new Error('The answer could not be read.'), { code: 'outcome-unknown' });
|
||||
const renewed = value.renewal !== 'not-built' && Number.isFinite(Date.parse(value.renewedAt)) ? ` Last renewed ${window.MosaicLocalTime(value.renewedAt)}.` : ' Renewing it is not built yet.';
|
||||
if (value.problem === 'missing') text = 'Not made yet. Set up model service in step 1 makes it. You never see it.';
|
||||
else if (value.problem === 'unreadable') text = 'Mosaic can\'t tell when it was made: the service\'s settings file is not one it can check. You never see the key.';
|
||||
else if (Number.isFinite(Date.parse(value.madeAt))) text = `Mosaic made it on ${window.MosaicLocalTime(value.madeAt)}. You never see it.${renewed}`;
|
||||
else text = `When it was made is not known. You never see it.${renewed}`;
|
||||
} catch (error) { failed = true; text = `When it was made could not be read. ${failText(error, KEY_WORDS)}`; }
|
||||
if (round !== keyRound || !enabled) return;
|
||||
keyView = { text, failed }; paintKey();
|
||||
if (refocus) { if (failed) $('proxy-setup-keymade-retry')?.focus(); else { const line = $('proxy-setup-keymade-text'); line.tabIndex = -1; line.focus(); } }
|
||||
}
|
||||
// Setup history, a page at a time. The first page holds the newest entries, oldest first within
|
||||
// it; the list shows newest first. A page can be empty and still name an older one.
|
||||
const HISTORY_WORDS = { 'not-configured': 'Model service setup is not available on this Console.', 'outcome-unknown': 'The host could not read the history.', 'invalid-request': 'The Console refused that page.' };
|
||||
const FEW = 3;
|
||||
const hist = { entries: [], next: null, loading: false, expanded: false, error: null, emptyPage: false, round: 0, read: false };
|
||||
const orgName = id => { const label = typeof id === 'string' ? window.MosaicOrg?.row?.(id)?.label : null; return typeof label === 'string' && label ? label : null; };
|
||||
const providerOf = p => typeof p === 'string' && [...providerSelect.options].some(o => o.value === p) ? providerShort(p) : null;
|
||||
// A name shown as written, unless it holds text shaped like a Mosaic key.
|
||||
const shownName = v => typeof v === 'string' && v && v.length <= 64 && !/ms[kotp][-_]/i.test(v) ? v : null;
|
||||
function historyText(entry) {
|
||||
if (!entry || typeof entry !== 'object' || entry.withheld === true) return null;
|
||||
const org = orgName(entry.org), provider = providerOf(entry.provider), some = org ?? 'An organization';
|
||||
const n = (v, word) => Number.isInteger(v) && v >= 0 ? plural(v, word) : null;
|
||||
const labels = {
|
||||
'account.proxy.apikey.add': provider ? `${provider} account added` : 'Account added',
|
||||
'account.proxy.login.complete': 'Signed in to an account',
|
||||
'account.proxy.priority.set': Number.isInteger(entry.priority) ? `Account order changed, priority ${entry.priority}` : 'Account order changed',
|
||||
'account.proxy.group.models.set': n(entry.models, 'model') ? `Models chosen for an account, ${n(entry.models, 'model')}` : 'Models chosen for an account',
|
||||
fetch: 'Release downloaded and checked', init: 'Set up', 'init-lock.clear': 'Stale setup lock cleared', 'fence.clear': 'Key writes resumed',
|
||||
'unit.install': 'Service installed', 'unit.start': 'Started', 'unit.stop': 'Stopped', 'unit.restart': 'Restarted',
|
||||
'ride-all': 'Organizations switched to your models', 'ride-move': `${some} switched to your models`, 'ride-intent': `Switching ${org ?? 'an organization'} to your models`,
|
||||
'ride-not-added': `${some} was not switched to your models`, 'ride-removed': `${some} stopped using your models`,
|
||||
};
|
||||
const label = typeof entry.op === 'string' && Object.hasOwn(labels, entry.op) ? labels[entry.op] : 'Other setup action';
|
||||
const inOrg = org && String(entry.op).startsWith('account.') ? ` in ${org}` : '';
|
||||
const user = entry.user === '[redacted]' ? 'someone whose name Mosaic hid' : shownName(entry.user);
|
||||
return `${label}${inOrg} · ${window.MosaicLocalTime(entry.time)}${user ? ` · by ${user}` : ''}`;
|
||||
}
|
||||
function paintHistory() {
|
||||
const list = $('proxy-setup-history'), msg = $('proxy-setup-history-message'), all = $('proxy-setup-history-all'), older = $('proxy-setup-history-older'), retry = $('proxy-setup-history-retry');
|
||||
list.replaceChildren(...hist.entries.map((entry, i) => {
|
||||
const text = historyText(entry), li = el('li', text ?? 'Withheld. The Console kept this entry back because it may hold a secret.', text ? undefined : 'muted');
|
||||
if (!text) li.dataset.withheld = '';
|
||||
li.hidden = !hist.expanded && i >= FEW; return li;
|
||||
}));
|
||||
const more = hist.next !== null;
|
||||
// Show all only when some entries are folded away; Show older whenever there is an older page and
|
||||
// nothing read is folded away, so an empty page offers it at once. After an empty page it stays while
|
||||
// the list is folded, since the line below names it.
|
||||
all.hidden = !hist.read || hist.entries.length <= FEW;
|
||||
all.textContent = hist.expanded ? 'Show fewer' : 'Show all'; all.setAttribute('aria-expanded', String(hist.expanded));
|
||||
older.hidden = !more || Boolean(hist.error) || (!hist.expanded && hist.entries.length > FEW && !hist.emptyPage);
|
||||
older.disabled = hist.loading; older.textContent = hist.loading ? 'Reading…' : 'Show older';
|
||||
retry.hidden = !hist.error;
|
||||
msg.className = hist.error ? 'banner err' : 'small muted';
|
||||
msg.textContent = hist.error ? `History could not be read. ${hist.error}`
|
||||
: hist.loading && !hist.entries.length ? 'Reading…'
|
||||
: !hist.read ? 'Not read yet.'
|
||||
: hist.emptyPage && more ? 'That page of history had no entries to show. Show older reads further back.'
|
||||
: !hist.entries.length && !more ? 'No setup history yet.' : '';
|
||||
}
|
||||
async function readHistory(reset) {
|
||||
if (!enabled || (hist.loading && !reset)) return;
|
||||
if (reset) Object.assign(hist, { entries: [], next: null, expanded: false, read: false, emptyPage: false });
|
||||
const round = ++hist.round, before = hist.next, from = ['proxy-setup-history-older', 'proxy-setup-history-retry'].find(id => document.activeElement?.id === id);
|
||||
Object.assign(hist, { loading: true, error: null }); paintHistory();
|
||||
try {
|
||||
const value = await admin(`history?limit=25${before === null ? '' : `&before=${encodeURIComponent(before)}`}`);
|
||||
const next = value?.next;
|
||||
// An older page is further back than the one asked for; one that is not would repeat entries.
|
||||
if (!value || !Array.isArray(value.entries) || !(next === null || (Number.isInteger(next) && next >= 0 && (before === null || next < before)))) throw Object.assign(new Error('The answer could not be read.'), { code: 'outcome-unknown' });
|
||||
if (round !== hist.round || !enabled) return;
|
||||
hist.entries.push(...value.entries.slice().reverse());
|
||||
Object.assign(hist, { next, read: true, emptyPage: value.entries.length === 0 });
|
||||
} catch (error) { if (round !== hist.round || !enabled) return; hist.error = failText(error, HISTORY_WORDS); }
|
||||
hist.loading = false; paintHistory();
|
||||
// The button pressed keeps focus while it stays; when it goes, focus lands on Read again, Show older,
|
||||
// Show fewer or the heading, in that order.
|
||||
if (from) { const back = [$(from), $('proxy-setup-history-retry'), $('proxy-setup-history-older'), $('proxy-setup-history-all')].find(b => !b.hidden); if (back) back.focus(); else { const h = $('proxy-setup-history-title'); h.tabIndex = -1; h.focus(); } }
|
||||
}
|
||||
$('proxy-setup-history-all').addEventListener('click', () => { hist.expanded = !hist.expanded; paintHistory(); });
|
||||
// Show older shows what it reads: the list stays open from then on.
|
||||
$('proxy-setup-history-older').addEventListener('click', () => { if (!hist.loading && hist.next !== null) { hist.expanded = true; readHistory(false); } });
|
||||
$('proxy-setup-history-retry').addEventListener('click', () => readHistory(!hist.read));
|
||||
$('proxy-setup-tech').addEventListener('toggle', () => { if (techOpen() && enabled) { readKey(); readHistory(true); } });
|
||||
$('proxy-setup-tech-lines').addEventListener('toggle', () => { if ($('proxy-setup-tech-lines').open && enabled) readLog(); });
|
||||
function row(dl, term, text) { const dt = document.createElement('dt'), dd = document.createElement('dd'); dt.textContent = term; dd.textContent = text; dl.append(dt, dd); }
|
||||
function paintState() {
|
||||
// #1873 settings slice 5: the timeouts init chose, from the same read. Null is not set in
|
||||
// proxy.json, so the model service uses its default.
|
||||
const timeouts = s => !s || typeof s !== 'object' ? '' : `, wait for a first answer${s.firstOutputSeconds == null ? ': the default' : ` ${human(s.firstOutputSeconds)} seconds`}, old key kept${s.rotateGraceMinutes == null ? ' after a new one: the default' : ` ${human(s.rotateGraceMinutes)} minutes after a new one`}`;
|
||||
const { release, init, unit, fence, initLock } = state, dl = $('proxy-setup-state'); dl.replaceChildren();
|
||||
row(dl, 'Release', !release.fetched ? `Not fetched (pinned ${release.version}, panel ${release.panelVersion})` : release.verified ? `Fetched ${release.version}, panel ${release.panelVersion}, hashes verified` : `Fetched ${release.version}, hashes not verified (${release.problem})`);
|
||||
const files = init.files.filter(f => f.present).map(f => f.label).join(', ') || 'none';
|
||||
row(dl, 'Initialized', init.initialized ? `Yes, port ${init.settings?.port ?? '—'}` : init.partial ? `Partly (${init.problem ?? 'incomplete'}). Present: ${files}` : init.problem ? `No (${init.problem})` : 'No');
|
||||
row(dl, 'Initialized', init.initialized ? `Yes, port ${init.settings?.port ?? '—'}${timeouts(init.settings)}` : init.partial ? `Partly (${init.problem ?? 'incomplete'}). Present: ${files}` : init.problem ? `No (${init.problem})` : 'No');
|
||||
row(dl, 'Service', `${unit.unit}: ${unit.installed ? 'installed' : 'not installed'}, ${unit.active}${unit.pid ? `, pid ${unit.pid}` : ''}${unit.port ? `, port ${unit.port} ${unit.listening ? 'answering' : 'not answering'}` : ''}${unit.error ? ` (${unit.error})` : ''}`);
|
||||
row(dl, 'Fence', !fence.set ? 'Clear' : fence.invalid ? 'Set (unreadable fence file)' : `Set after ${fence.op ?? 'a key write'}${fence.org ? ` for ${fence.org}` : ''}${fence.time ? ` at ${window.MosaicLocalTime(fence.time)}` : ''}`);
|
||||
row(dl, 'Init lock', !initLock.present ? 'None' : initLock.clearable ? 'Stale: the bus is stopped and no model service files exist' : `Held: ${initLock.blockers.join('; ')}`);
|
||||
if (state.restart?.confirmed) row(dl, 'Last restart', `Confirmed at ${window.MosaicLocalTime(state.restart.observedAt)}, new pid ${state.restart.pid}`);
|
||||
if (enabled) keyRow(dl);
|
||||
}
|
||||
// settings-p3 (re-check 3 P3-1): where the hand steps for a held init lock or a partial init are written.
|
||||
const README_STEPS = ['The hand steps for a stale init lock and a partial init are in ', 'packages/model-proxy/README.md'];
|
||||
@@ -1031,8 +1184,8 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
if (failed && (CHAIN.includes(next) || next === 'unit-restart')) {
|
||||
setCard('service', 'bad', `${failed.reason} The steps that finished are kept. No organization was touched.`, { badge: ['badge-danger', 'Setup stopped'] });
|
||||
box.replaceChildren(el('p', 'Try again starts from the step that failed.', 'small muted'), goButton('Try again', next, !sendOk || Boolean(state.busy), runChain));
|
||||
paintProgress(true); lines.hidden = false; lines.open = true;
|
||||
$('proxy-setup-log').textContent = state.unit?.error ? String(state.unit.error) : 'Nothing reported.';
|
||||
paintProgress(true);
|
||||
if (lines.hidden) { lines.hidden = false; lines.open = true; readLog(); }
|
||||
return;
|
||||
}
|
||||
lines.hidden = true;
|
||||
@@ -1118,7 +1271,16 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
function paintOrgsCard() {
|
||||
const line = $('setup-step-organizations').querySelector('[data-step-summary]'), go = $('proxy-ride-go');
|
||||
go.className = 'btn'; delete line.dataset.next;
|
||||
if (!running() || !accountCount) { setCard('organizations', 'wait', 'Opens after your first account.'); return; }
|
||||
// settings-s5: before the first account, an organization the sidebar already marks "can't start" is
|
||||
// named here, so the card and the mark agree.
|
||||
if (!running() || !accountCount) {
|
||||
const blocked = running() ? cantStart().map(f => nameOf(f.id)) : [];
|
||||
if (!blocked.length) { setCard('organizations', 'wait', 'Opens after your first account.'); return; }
|
||||
const one = blocked.length === 1;
|
||||
// The card stays closed (Move needs a model from an account), with the mark's word on its badge.
|
||||
setCard('organizations', 'wait', `Opens after your first account. ${listNames(blocked)} can't start now: ${one ? 'it uses' : 'they use'} stand-in models and ${one ? 'its bus is' : 'their buses are'} stopped. After your first account, move ${one ? 'it' : 'them'} to your models under Use your models in every organization, then start ${one ? 'its bus' : 'their buses'}.`, { badge: ['badge-danger', "Can't start"] });
|
||||
return;
|
||||
}
|
||||
const step = orgStep(), names = needRestart().filter(restartHelps).map(o => nameOf(o.id));
|
||||
// settings-p3 (rebase re-check P3-1, settings-s4 P3): the Ride all box still lists an organization,
|
||||
// so not "every". One that turned the model service off is not waiting on anything: it is named.
|
||||
@@ -1200,7 +1362,11 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
// After init, Advanced shows the settings init wrote, read-only.
|
||||
const dl = $('proxy-setup-settings'), s = init.initialized && init.settings && typeof init.settings === 'object' ? init.settings : null;
|
||||
dl.hidden = !s; $('proxy-setup-settings-note').hidden = !s; dl.replaceChildren();
|
||||
if (s) { row(dl, 'Port', human(s.port)); if (s.firstOutputSeconds !== undefined) row(dl, 'Wait for a first answer', `${human(s.firstOutputSeconds)} seconds`); }
|
||||
if (s) {
|
||||
row(dl, 'Port', human(s.port));
|
||||
if (s.firstOutputSeconds !== undefined) row(dl, 'Wait for a first answer', s.firstOutputSeconds === null ? 'The default' : `${human(s.firstOutputSeconds)} seconds`);
|
||||
if (s.rotateGraceMinutes !== undefined) row(dl, 'Old key kept after a new one', s.rotateGraceMinutes === null ? 'The default' : `${human(s.rotateGraceMinutes)} minutes`);
|
||||
}
|
||||
}
|
||||
// Programs that drive models: the harnesses this Console offers an organization, read on open.
|
||||
let programsRead = false;
|
||||
@@ -1255,15 +1421,15 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
+ 'Admission gets stricter there: every launch route is checked, direct Anthropic routes too, and while the model service is down or fenced every launch in that organization is refused. '
|
||||
+ (ready ? `${ready} ${ready === 1 ? 'organization can' : 'organizations can'} ride now.` : 'No organization is waiting to ride.');
|
||||
const go = $('proxy-ride-go'); go.disabled = !sendOk || Boolean(state.busy) || !ready;
|
||||
$('proxy-ride-skips').replaceChildren(...rideSkips().map(s => li(`Skipped ${s.id}: ${rideReason(s.reason)}`)));
|
||||
$('proxy-ride-skips').replaceChildren(...rideSkips().map(s => li(`Skipped ${nameOf(s.id)}: ${rideReason(s.reason)}`)));
|
||||
const listedFixtures = rideResult?.fixtures ?? fixtures.map(f => ({ id: f.id, running: f.running }));
|
||||
$('proxy-ride-fixtures').replaceChildren(...listedFixtures.map(f => {
|
||||
// running null: no bus status here (the single-business Console), so moving is not available.
|
||||
const name = nameOf(f.id);
|
||||
if (f.running === null) return li(`${name} uses stand-in models. Moving it is not available on this Console.`);
|
||||
// settings-s4 review F2: running false is what the sidebar marks "can't start"; say so, and the fix.
|
||||
const item = li(f.running === false ? `${name} can't start: it uses stand-in models and its bus is stopped. Move it to the owner's models, then start its bus. `
|
||||
: `${name} uses stand-in models, can be moved to the owner's models.${f.running === true ? ' Its bus is running: stop it first.' : ''} `);
|
||||
const item = li(f.running === false ? `${name} can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus. `
|
||||
: `${name} uses stand-in models, can be moved to your models.${f.running === true ? ' Its bus is running: stop it first.' : ''} `);
|
||||
const move = document.createElement('button'); move.type = 'button'; move.className = 'btn'; move.textContent = `Move ${name}`;
|
||||
move.dataset.rideMove = f.id; move.disabled = !sendOk || Boolean(state.busy);
|
||||
move.addEventListener('click', () => { if (!move.disabled) rideMove(f.id); });
|
||||
@@ -1281,22 +1447,22 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
});
|
||||
};
|
||||
const rideMove = id => {
|
||||
if (!window.confirm(`Move ${id} to your models? Its stand-in models are replaced by a model your model service lists. After this, its agents spend real tokens on your account. Its bus stays stopped: start it when you are ready.`)) return;
|
||||
if (!window.confirm(`Move ${nameOf(id)} to your models? Its stand-in models are replaced by a model your model service lists. After this, its agents spend real tokens on your account. Its bus stays stopped: start it when you are ready.`)) return;
|
||||
return act('ride-move', async () => {
|
||||
const result = await admin('ride-move', { org: id });
|
||||
if (!result.moved) { rideSay(`${id} was not moved. ${rideReason(result.reason)}`, 'error'); return; }
|
||||
if (!result.moved) { rideSay(`${nameOf(id)} was not moved. ${rideReason(result.reason)}`, 'error'); return; }
|
||||
addReceipt(result.receipt);
|
||||
if (rideResult) rideResult = { ...rideResult, fixtures: rideResult.fixtures.filter(f => f.id !== id) };
|
||||
rideSay(`${id} now uses ${result.model}. Start its bus when you are ready. It spends real tokens from now on.`, 'success');
|
||||
rideSay(`${nameOf(id)} now uses ${result.model}. Start its bus when you are ready. It spends real tokens from now on.`, 'success');
|
||||
});
|
||||
};
|
||||
$('proxy-ride-go').addEventListener('click', () => { if (!$('proxy-ride-go').disabled) rideAll(); });
|
||||
function paint() {
|
||||
paintState(); paintControls(); paintReceipts(); paintService(); paintRestart(); paintOrgsCard(); paintTriageCard(); paintAccountCard();
|
||||
paintState(); paintControls(); paintService(); paintRestart(); paintOrgsCard(); paintTriageCard(); paintAccountCard();
|
||||
const job = state.fetch;
|
||||
if (job.state === 'running') say(`Downloading: ${STEPS[job.step] ?? job.step ?? 'starting'}…`);
|
||||
else if (job.state === 'failed' && seenFetch !== 'failed') { say(`Fetch failed. ${explain(job.error)}`, 'error'); seenFetch = 'failed'; }
|
||||
else if (job.state === 'done' && job.receipt && seenFetch !== job.receipt.time) { seenFetch = job.receipt.time; if (!state.receipts?.some(r => r.op === 'fetch' && r.time === job.receipt.time)) addReceipt(job.receipt); say(`Fetched ${job.receipt.version}; archive, panel and executable hashes verified.`, 'success'); }
|
||||
else if (job.state === 'done' && job.receipt && seenFetch !== job.receipt.time) { seenFetch = job.receipt.time; addReceipt(job.receipt); say(`Fetched ${job.receipt.version}; archive, panel and executable hashes verified.`, 'success'); }
|
||||
clearTimeout(timer); timer = null;
|
||||
if (enabled && !chain?.running && (job.state === 'running' || state.busy)) timer = setTimeout(load, 1000);
|
||||
// The sidebar's model marks read the same status (MosaicModelDots).
|
||||
@@ -1494,5 +1660,6 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
|
||||
document.addEventListener('mosaic-org-restarted', () => { read(); });
|
||||
const begin = () => { (window.MosaicOrg?.ready ?? Promise.resolve()).then(read, () => {}); };
|
||||
if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', begin, { once: true }); else begin();
|
||||
window.MosaicModelDots = { get: id => marks.get(id) ?? null };
|
||||
// settings-s5: a page that changes what the status says (an organization's Models choice) asks for a fresh read.
|
||||
window.MosaicModelDots = { get: id => marks.get(id) ?? null, read };
|
||||
})();
|
||||
@@ -119,7 +119,10 @@ table.s1-table td code{font-size:12.5px;white-space:nowrap}
|
||||
.proxy-setup-next{display:flex;flex-wrap:wrap;align-items:center;gap:8px 16px;margin:0 0 12px}.proxy-setup-next p{margin:0;flex:1 1 280px}
|
||||
.proxy-setup-buttons{display:flex;flex-wrap:wrap;gap:8px}.proxy-setup-buttons button{min-height:44px}
|
||||
#proxy-setup pre{overflow-x:auto;max-width:100%;font-size:12px}#proxy-setup h3{margin:16px 0 4px}#proxy-setup details{margin:0 0 12px}#proxy-setup summary{min-height:44px;display:flex;align-items:center;cursor:pointer}
|
||||
#proxy-setup-receipts{padding-left:20px;overflow-wrap:anywhere;font-size:13px}
|
||||
/* settings-s5b: the setup history (GET /api/proxy/admin/history), the service key and the service's lines. */
|
||||
#proxy-setup-history{list-style:none;padding-left:0;overflow-wrap:anywhere;font-size:13px;margin:0 0 8px}#proxy-setup-history li{padding:2px 0}
|
||||
.proxy-setup-history-foot{display:flex;flex-wrap:wrap;gap:8px;margin:0}.proxy-setup-history-foot button,[data-log] button,#proxy-setup-keymade-retry{min-height:44px}
|
||||
[data-log] .setup-log{margin:8px 0}[data-log] p{margin:0 0 8px}#proxy-setup-history-message:empty{display:none}
|
||||
/* #1873 settings slice 1 (D3, D4): the kept restart list and Technical details. */
|
||||
.proxy-setup-restart{margin:0 0 12px}
|
||||
.proxy-setup-restart-list{list-style:none;margin:8px 0 0;padding:0;display:grid;gap:8px}
|
||||
@@ -339,6 +342,7 @@ button:disabled,[aria-disabled=true]{cursor:not-allowed}
|
||||
.rows li{display:grid;grid-template-columns:7rem minmax(0,1fr) auto;gap:6px var(--gap,12px);align-items:center;padding:10px 0;border-top:1px solid var(--line)}
|
||||
.rows li>span:first-child{font-weight:600;color:var(--strong)}
|
||||
.rows li>.account-reason{grid-column:2/-1;margin:0}
|
||||
.rows li.muted{display:block}
|
||||
.progress{list-style:none;margin:var(--gap,12px) 0 0;padding:0;display:grid;gap:6px}
|
||||
.progress li::before{display:inline-block;width:1.4em;color:var(--muted)}
|
||||
.progress .ok::before{content:"✓";color:var(--success)}.progress .run::before{content:"●";color:var(--action)}.progress .todo::before{content:"○"}.progress .bad::before{content:"✕";color:var(--danger)}
|
||||
@@ -375,6 +379,19 @@ button:disabled,[aria-disabled=true]{cursor:not-allowed}
|
||||
.settings-content fieldset.harness-control{display:flex;flex-wrap:wrap;align-items:center;gap:6px 12px}
|
||||
.settings-content fieldset.harness-control>legend{flex-basis:100%}
|
||||
.settings-content fieldset.harness-control>:is(button,p){flex-basis:100%}
|
||||
/* #1873 settings slice 5: an organization's one choice (mockup org-models). A choice not built yet is dashed and disabled. */
|
||||
/* settings-s5 review P3-4: the choice cards sit in the form column, as .settings-form does. */
|
||||
.settings-content fieldset.models-source{display:grid;gap:8px;max-width:28rem}
|
||||
.settings-content fieldset.models-source>legend{font-size:14px;color:var(--strong);margin-bottom:8px}
|
||||
.settings-content fieldset.models-source>p{margin:0}
|
||||
.choice{display:grid;grid-template-columns:auto 1fr auto;gap:4px 10px;align-items:start;padding:12px;border:1px solid var(--border);border-radius:var(--r);cursor:pointer}
|
||||
.choice input{margin-top:4px}
|
||||
.choice:has(input:checked){border-color:var(--action);background:var(--raised)}
|
||||
.choice:has(input:disabled){cursor:default}
|
||||
.choice.off{color:var(--muted);cursor:not-allowed;border-style:dashed;background:transparent}
|
||||
.choice strong{color:var(--strong)}.choice.off strong{color:var(--muted)}
|
||||
.choice .small{grid-column:2/4;margin:0}
|
||||
.choice:has(input:focus-visible){outline:2px solid var(--focus);outline-offset:2px}
|
||||
.settings-content :is(.instance-form,.level-form) textarea,.settings-content .assistant-form textarea{display:block;width:100%}
|
||||
.route-definition{display:none}.settings-spinner{display:inline-block;width:16px;height:16px;border:2px solid currentColor;border-right-color:transparent;border-radius:50%;vertical-align:middle;animation:settings-spin .8s linear infinite}@keyframes settings-spin{to{transform:rotate(360deg)}}@media(prefers-reduced-motion:reduce){.settings-spinner{animation:none}}
|
||||
@media(max-width:759px){#routes-table .route-definition{display:inline;float:right;color:var(--muted);font-size:12px;font-weight:400}}
|
||||
|
||||
@@ -1051,7 +1051,8 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
|
||||
origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user,
|
||||
principal: currentSession ? { provider: currentSession.provider, iss: currentSession.iss, sub: currentSession.sub } : null, log });
|
||||
if (path.startsWith('/api/proxy/')) return proxyHTTP(req, res, { path, call: proxyCall, named, tester, granted,
|
||||
send, origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, log });
|
||||
send, origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, log,
|
||||
record: proxyAdmin && typeof proxyAdmin.recordAccount === 'function' ? entry => proxyAdmin.recordAccount({ ...entry, org: orgId }) : null });
|
||||
}
|
||||
// #1873 triage-host: the Triage session's two routes answer only the instance owner's own session on
|
||||
// the public name, with no organization selected. Anyone else falls through to the answer an
|
||||
|
||||
@@ -127,8 +127,8 @@ const CAP = /^[0-9a-f]{64}$/;
|
||||
// The spawn's environment: these names from the Console's own environment, PATH fixed, and the
|
||||
// route's proxy variables. bwrap sets HOME and TMPDIR inside.
|
||||
export const SPAWN_ENV_ALLOW = Object.freeze(["PATH", "LANG", "LC_ALL", "TZ", "TERM"]);
|
||||
// Passed only as an absolute path: the pinned harness binary (packages/seat/src/session.mjs ENV_ALLOW).
|
||||
export const SPAWN_PATH_ALLOW = Object.freeze(["MOSAIC_CLAUDE_BIN"]);
|
||||
// Passed only as an absolute path: a harness binary the Console names (packages/seat/src/session.mjs ENV_ALLOW).
|
||||
export const SPAWN_PATH_ALLOW = Object.freeze(["MOSAIC_CLAUDE_BIN", "MOSAIC_PI_BIN"]);
|
||||
// The names the runner sets for every harness (runner.mjs adapterEnv); the host's own names never replace them.
|
||||
const RUNNER_NAMES = new Set(["MOSAIC_SYSTEM_PROMPT_FILE", "MOSAIC_WORKSPACE", "MOSAIC_SESSION_DIR", "MOSAIC_POLICY_FILE", "MOSAIC_TOOLS_FILE",
|
||||
"MOSAIC_TOOL_SOCKET", "MOSAIC_TURN_MARKER", "MOSAIC_PROVIDER", "MOSAIC_MODEL", "MOSAIC_MODEL_ACTIVITY_DIR", "MOSAIC_UNSLOP_LOG",
|
||||
@@ -826,6 +826,16 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
|
||||
|
||||
const start = async ({ admitted, installRoots, transcriptRoot, mod }) => {
|
||||
ensureDirs();
|
||||
// #1873 pi-unpin re-check 7: a module whose env() reads a check it runs first (pi's fit check)
|
||||
// has it run and awaited before the bundle, which calls env(). A refusal or a throw refuses the
|
||||
// route, as a throw from env() does.
|
||||
if (typeof mod?.ready === "function") {
|
||||
try { await mod.ready(); }
|
||||
catch {
|
||||
log("triage host: route refused: harness-bundle");
|
||||
throw new TriageError("triage-route-invalid", "the model route's answer is not usable");
|
||||
}
|
||||
}
|
||||
const { run, harnessFiles } = writeBundle(admitted, mod);
|
||||
// The key this session holds, and anything shaped like a key, never reaches the transcript.
|
||||
const key = routeKey(admitted.env)?.value ?? null;
|
||||
|
||||
@@ -228,6 +228,9 @@ export function createTriageRoute({ dataRoot, configDir, proxyPort = null, catal
|
||||
// name the host's fence refuses (MOSAIC_* and ANTHROPIC_* among them: the host sets those)
|
||||
// and every name the module does not declare.
|
||||
const session = { model: offered.model, provider: offered.provider ?? "", ...(transport ? { proxyTransport: { ...transport } } : {}) };
|
||||
// #1873 pi-unpin re-check 7: a module whose env() reads a check it runs first (pi's fit
|
||||
// check) has it run here and awaited; a refusal or a throw is incompatible, as env()'s is.
|
||||
if (typeof mod.ready === "function") await mod.ready();
|
||||
const given = mod.env({ files: {}, policy: { tools: [] }, tools: [], session, models: {}, proxy: { ...PROXY_PROBE } });
|
||||
keyName = routeKeyName(given);
|
||||
if (!keyName) return refuse("triage-harness-incompatible");
|
||||
|
||||
@@ -185,6 +185,17 @@ test('dev owner resolves a decision through the real Console wrapper and bus', {
|
||||
const result=await post(`/api/orgs/acme/decisions/${decision.id}/resolve`,{choice:'yes',confirmation:confirmation.body.confirmation});
|
||||
assert.equal(result.status,200,JSON.stringify(result));
|
||||
assert.equal(result.body.choice,'yes');
|
||||
// settings-backend A2: the real Console's riders carry the organization file, so turning a program
|
||||
// off for every organization can read it; without it each organization answers unreadable.
|
||||
const get=path=>new Promise((resolve,reject)=>{const host=`127.0.0.1:${port}`;const req=request({host:'127.0.0.1',port,path,headers:{host}},res=>{let raw='';res.on('data',c=>raw+=c);res.on('end',()=>resolve({status:res.statusCode,body:JSON.parse(raw)}));});req.on('error',reject);req.end();});
|
||||
const status=await get('/api/orgs/acme/proxy/admin/status');
|
||||
assert.equal(status.status,200,JSON.stringify(status));
|
||||
const acmeOn=status.body.programs?.organizations?.find(o=>o.id==='acme')?.on;
|
||||
assert.ok(Array.isArray(acmeOn)&&acmeOn.length>0,JSON.stringify(status.body.programs));
|
||||
const off=await post('/api/orgs/acme/proxy/admin/programs/off',{name:acmeOn[0]});
|
||||
assert.equal(off.status,200,JSON.stringify(off));
|
||||
// The chief's route uses the program in both organizations, so neither file is written.
|
||||
assert.deepEqual(off.body.results,[{id:'acme',outcome:'in-use'},{id:'beta',outcome:'in-use'}],JSON.stringify(off.body));
|
||||
const stopped = new Promise(resolve => bus.once('exit', resolve));
|
||||
const stop = spawnSync(process.execPath,['packages/cli/src/cli.mjs','bus','stop','acme'],{env,encoding:'utf8'}); assert.equal(stop.status,0,stop.stderr); await stopped;
|
||||
busOut=''; bus=spawn(process.execPath,['packages/cli/src/cli.mjs','bus','start','acme','--no-launch'],{env,stdio:['ignore','pipe','pipe']});
|
||||
|
||||
@@ -20,7 +20,13 @@ const ROUTES = [
|
||||
['fence/clear', 'POST', {}], ['init-lock/clear', 'POST', {}],
|
||||
// #1873 ride-default: Ride all, and the move of one stopped fixture organization.
|
||||
['ride-all', 'POST', {}], ['ride-move', 'POST', { org: 'stand-in' }],
|
||||
// #1873 settings-backend A1: the model service log, the service key's made-at time, setup history.
|
||||
['log', 'GET'], ['service-key', 'GET'], ['history', 'GET'],
|
||||
// #1873 settings-backend A2: one program off for every organization, and access health.
|
||||
['programs/off', 'POST', { name: 'alpha' }], ['access', 'GET'],
|
||||
];
|
||||
const A2 = ROUTES.filter(([p]) => ['programs/off', 'access'].includes(p));
|
||||
const READS = ROUTES.filter(([p]) => ['log', 'service-key', 'history'].includes(p));
|
||||
|
||||
function fakeAdmin() {
|
||||
const calls = [];
|
||||
@@ -33,6 +39,12 @@ function fakeAdmin() {
|
||||
fetchStart: () => { calls.push(['fetchStart']); return { state: 'running' }; },
|
||||
init: async (call, args) => { calls.push(['init', args]); await call('proxy.init', args); return { settings: { port: 18432 }, receipt: { op: 'init' } }; },
|
||||
fenceClear: async call => { calls.push(['fenceClear']); return call('proxy.fence.clear', { evidence: {} }); },
|
||||
log: async args => { calls.push(['log', args]); return { unit: 'mosaic-proxy.service', lines: ['ok'], redacted: 0, dropped: 0 }; },
|
||||
serviceKey: () => { calls.push(['serviceKey']); return { madeAt: '2026-11-01T08:00:00.000Z', renewedAt: null, renewal: 'not-built', problem: null }; },
|
||||
history: args => { calls.push(['history', args]); return { entries: [], next: null }; },
|
||||
recordAccount: entry => { calls.push(['recordAccount', entry]); return true; },
|
||||
programsOff: async args => { calls.push(['programsOff', args]); return { name: args.name, results: [], receipt: null }; },
|
||||
access: async () => { calls.push(['access']); return { organizations: [] }; },
|
||||
};
|
||||
}
|
||||
const send = (port, path, { method = 'GET', headers = {}, body } = {}) => new Promise((resolve, reject) => {
|
||||
@@ -54,7 +66,7 @@ async function devServer(t, options = {}) {
|
||||
}
|
||||
const hit = (f, route, extra = {}) => send(f.port, `/api/proxy/admin/${route[0]}`, { method: route[1], headers: { ...f.headers(), ...extra }, body: route[2] });
|
||||
|
||||
test('the route table is exactly the brief: status, render, fetch, init, four unit verbs, fence clear, lock clear, ride all, ride move', () => {
|
||||
test('the route table is exactly the brief: status, render, fetch, init, four unit verbs, fence clear, lock clear, ride all, ride move, log, service key, history, programs off, access', () => {
|
||||
assert.deepEqual(PROXY_ADMIN_PATHS, ROUTES.map(([p]) => `/api/proxy/admin/${p}`));
|
||||
});
|
||||
|
||||
@@ -64,7 +76,8 @@ test('the dev local owner reaches every route; init and fence clear go to the bu
|
||||
const r = await hit(f, route);
|
||||
assert.equal(r.status, route[0] === 'fetch' ? 202 : 200, route[0]);
|
||||
}
|
||||
assert.deepEqual(f.admin.calls.map(c => c[0]), ['status', 'render', 'fetchStart', 'init', 'unitAction', 'unitAction', 'unitAction', 'unitAction', 'fenceClear', 'initLockClear', 'rideAll', 'rideMove']);
|
||||
assert.deepEqual(f.admin.calls.map(c => c[0]), ['status', 'render', 'fetchStart', 'init', 'unitAction', 'unitAction', 'unitAction', 'unitAction', 'fenceClear', 'initLockClear', 'rideAll', 'rideMove', 'log', 'serviceKey', 'history', 'programsOff', 'access']);
|
||||
assert.deepEqual(f.admin.calls.find(c => c[0] === 'programsOff')[1], { name: 'alpha', user: 'Local operator' });
|
||||
assert.deepEqual(f.admin.calls.filter(c => c[0] === 'unitAction').map(c => c[1]), ['install', 'start', 'stop', 'restart']);
|
||||
assert.deepEqual(f.busCalls.map(c => c[0]), ['proxy.init', 'proxy.fence.clear']);
|
||||
assert.deepEqual(f.busCalls[0][1], { generate: true });
|
||||
@@ -245,3 +258,251 @@ test('a signed-in member who is not the instance owner gets human-required for r
|
||||
}
|
||||
assert.deepEqual(member.admin.calls, []);
|
||||
});
|
||||
|
||||
// #1873 settings-backend A1: the three reads. Query keys are each read's own, once each, plain
|
||||
// decimal numbers; the controller clamps the values.
|
||||
test('the reads pass their query to the controller and refuse an unknown, repeated or non-number key', async t => {
|
||||
const f = await devServer(t);
|
||||
const get = path => send(f.port, path, { headers: f.headers() });
|
||||
assert.equal((await get('/api/proxy/admin/log')).status, 200);
|
||||
assert.equal((await get('/api/proxy/admin/log?lines=1000')).status, 200);
|
||||
assert.equal((await get('/api/proxy/admin/history')).status, 200);
|
||||
assert.equal((await get('/api/proxy/admin/history?limit=1000&before=4096')).status, 200);
|
||||
assert.equal((await get('/api/proxy/admin/service-key')).status, 200);
|
||||
assert.deepEqual(f.admin.calls, [['log', {}], ['log', { lines: 1000 }], ['history', { before: null }], ['history', { limit: 1000, before: 4096 }], ['serviceKey']]);
|
||||
f.admin.calls.length = 0;
|
||||
for (const path of ['/api/proxy/admin/log?lines=-1', '/api/proxy/admin/log?lines=1.5', '/api/proxy/admin/log?lines=', '/api/proxy/admin/log?lines=1e3', '/api/proxy/admin/log?lines=5&lines=6',
|
||||
'/api/proxy/admin/log?limit=5', '/api/proxy/admin/log?unit=sshd.service', '/api/proxy/admin/log?lines=0x10', '/api/proxy/admin/log?lines=1234567890123456',
|
||||
'/api/proxy/admin/history?before=abc', '/api/proxy/admin/history?lines=5', '/api/proxy/admin/history?limit=5&limit=6', '/api/proxy/admin/service-key?x=1', '/api/proxy/admin/service-key?key']) {
|
||||
const r = await get(path);
|
||||
assert.equal(r.status, 400, path); assert.deepEqual(r.json, { error: 'invalid-request' }, path);
|
||||
}
|
||||
assert.deepEqual(f.admin.calls, []);
|
||||
for (const route of READS) assert.equal((await send(f.port, `/api/proxy/admin/${route[0]}`, { method: 'POST', headers: f.headers(), body: {} })).status, 405, route[0]);
|
||||
});
|
||||
|
||||
test('a read the controller cannot answer reaches the page as its code only', async t => {
|
||||
const f = await devServer(t);
|
||||
f.admin.log = async () => { throw Object.assign(new Error(`${SENTINEL} journal said /home/owner/x`), { code: 'outcome-unknown' }); };
|
||||
f.admin.history = () => { throw Object.assign(new Error(SENTINEL), { code: 'invalid-request' }); };
|
||||
f.admin.serviceKey = () => { throw new Error(SENTINEL); };
|
||||
assert.deepEqual((await hit(f, ['log', 'GET'])).json, { error: 'outcome-unknown' });
|
||||
assert.equal((await hit(f, ['log', 'GET'])).status, 503);
|
||||
assert.deepEqual((await hit(f, ['history', 'GET'])).json, { error: 'invalid-request' });
|
||||
assert.deepEqual((await hit(f, ['service-key', 'GET'])).json, { error: 'outcome-unknown' });
|
||||
f.admin.log = async () => { throw Object.assign(new Error('x'), { code: 'not-configured' }); };
|
||||
assert.deepEqual((await hit(f, ['log', 'GET'])).json, { error: 'not-configured' });
|
||||
assert.equal(f.logs.join('\n').includes(SENTINEL), false);
|
||||
});
|
||||
|
||||
test('a member, an organization owner and a request on a name that is not the Console\'s get refused on every read', async t => {
|
||||
const organizations = { list: async () => [], resolve: async id => (id === 'x' ? { busHealthy: true } : null) };
|
||||
for (const session of [{ name: 'Bob', provider: 'local-dev', iss: 'local-dev', sub: 'bob', rootOwner: false, instanceRole: 'member' },
|
||||
{ name: 'Olive', provider: 'local-dev', iss: 'local-dev', sub: 'olive', rootOwner: false, instanceRole: 'operator', orgRole: 'owner' }]) {
|
||||
const f = await devServer(t, { organizations, sso: { ...createDevOwner(), session: () => session } });
|
||||
for (const route of READS) {
|
||||
const inOrg = await send(f.port, `/api/orgs/x/proxy/admin/${route[0]}?lines=5`.replace(/\?lines=5$/, ''), { headers: f.headers() });
|
||||
assert.equal(inOrg.status, 403, `${session.sub} ${route[0]}`); assert.deepEqual(inOrg.json, { error: 'human-required' }, `${session.sub} ${route[0]}`);
|
||||
const bad = await send(f.port, `/api/orgs/x/proxy/admin/${route[0]}?nope=1`, { headers: f.headers() });
|
||||
assert.deepEqual(bad.json, { error: 'human-required' }, 'the caller is checked before the query');
|
||||
const plain = await hit(f, route);
|
||||
assert.equal(plain.status >= 400 && plain.status < 500, true, `${route[0]} outside an organization is refused`);
|
||||
}
|
||||
assert.deepEqual(f.admin.calls, []);
|
||||
}
|
||||
const f = await devServer(t);
|
||||
for (const route of READS) {
|
||||
const r = await send(f.port, `/api/proxy/admin/${route[0]}`, { headers: { host: 'console.evil.example' } });
|
||||
assert.equal(r.status, 403, route[0]);
|
||||
}
|
||||
assert.deepEqual(f.admin.calls, []);
|
||||
});
|
||||
|
||||
// The real controller over a scratch config and data root with keys planted in proxy.json, the
|
||||
// management key file, the receipt history and the journal: none reaches an answer.
|
||||
test('end to end with the real controller, no planted key reaches any read', async t => {
|
||||
const { createProxyAdmin } = await import('../../model-proxy/src/admin-control.mjs');
|
||||
const { initFiles, appendReceipt } = await import('../../model-proxy/src/admin.mjs');
|
||||
const root = mkdtempSync(join(tmpdir(), 'pa-a1-'));
|
||||
t.after(() => rmSync(root, { recursive: true, force: true }));
|
||||
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
||||
const files = initFiles(configDir, dataRoot);
|
||||
const TAIL = 'Ab3_dE5-fG7hJ9kL1mN3pQ5rS7tU9vW1xY3zA5bC7dE';
|
||||
const planted = ['msk-tag-qwertyu', 'mso-tag-acme-qwerty', 'mst-tag-triage-zxcvb', 'msp-tag-plmokn', `msk-k1a2-${TAIL}`, `mso-k1a2-acme-${TAIL}`, `mst-k1a2-triage-${TAIL}`, `msp-k1a2-${TAIL}`];
|
||||
const { mkdirSync, writeFileSync } = await import('node:fs');
|
||||
mkdirSync(join(configDir, 'secrets'), { recursive: true, mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 });
|
||||
writeFileSync(files.settings, JSON.stringify({ port: 18432, note: planted[0] }), { mode: 0o600 });
|
||||
writeFileSync(files.key, planted[4], { mode: 0o600 });
|
||||
for (const key of planted) appendReceipt(dataRoot, { time: new Date(0).toISOString(), op: 'init', note: `key ${key}`, [key.replace(/-/g, '_')]: key });
|
||||
const journalCalls = [];
|
||||
const unit = {
|
||||
unit: 'mosaic-proxy-zz.service',
|
||||
status: async () => ({ unit: 'mosaic-proxy-zz.service', installed: true, active: 'active', healthy: true }),
|
||||
log: async (lines, options) => {
|
||||
const { unitLog } = await import('../../model-proxy/src/admin.mjs');
|
||||
return unitLog({ run: async (command, args) => { journalCalls.push([command, ...args]); return { code: 0, stdout: [...planted.map(k => `refused ${k}`), 'auth plainwordsonly', 'served 3 requests'].join('\n') + '\n' }; }, unit: 'mosaic-proxy-zz.service', lines, secrets: options.secrets });
|
||||
},
|
||||
};
|
||||
const admin = createProxyAdmin({ dataRoot, configDir, unit, buses: async () => ({ stopped: true, running: [] }), env: { MOSAIC_PROXY_TOKEN: 'plainwordsonly' } });
|
||||
const f = await devServer(t, { proxyAdmin: admin });
|
||||
const answers = [];
|
||||
for (const path of ['log', 'log?lines=1000', 'service-key', 'history', 'history?limit=2']) {
|
||||
const r = await send(f.port, `/api/proxy/admin/${path}`, { headers: f.headers() });
|
||||
assert.equal(r.status, 200, path);
|
||||
answers.push(r.text);
|
||||
}
|
||||
const all = answers.join('\n') + f.logs.join('\n');
|
||||
for (const bit of [...planted, ...planted.map(k => k.slice(4)), TAIL.slice(0, 10), 'plainwordsonly', root]) assert.equal(all.includes(bit), false, bit);
|
||||
const log = JSON.parse(answers[0]);
|
||||
assert.deepEqual(log.lines.slice(-1), ['served 3 requests']);
|
||||
assert.equal(log.lines.length, planted.length + 1);
|
||||
assert.equal(log.dropped, 1);
|
||||
assert.deepEqual(journalCalls[1].slice(4, 6), ['-n', '200']);
|
||||
const key = JSON.parse(answers[2]);
|
||||
assert.deepEqual(Object.keys(key), ['madeAt', 'renewedAt', 'renewal', 'problem']);
|
||||
assert.equal(key.problem, null); assert.equal(key.renewal, 'not-built');
|
||||
const first = JSON.parse(answers[4]);
|
||||
assert.equal(first.entries.length, 2);
|
||||
const rest = await send(f.port, `/api/proxy/admin/history?limit=100&before=${first.next}`, { headers: f.headers() });
|
||||
assert.equal(rest.json.entries.length, planted.length - 2);
|
||||
assert.equal(rest.json.next, null);
|
||||
assert.equal(rest.text.includes('qwerty'), false);
|
||||
});
|
||||
|
||||
// Account changes made outside the setup page join its history. The bus call's answer is unchanged;
|
||||
// a record that fails adds recorded: false and still answers the bus's result.
|
||||
test('an account write through /api/proxy/* records a labelled entry; reads and login steps record nothing', async t => {
|
||||
const f = await devServer(t);
|
||||
const post = (path, body) => send(f.port, path, { method: 'POST', headers: f.headers(), body });
|
||||
f.busCalls.length = 0;
|
||||
const added = await post('/api/proxy/apikey/add', { provider: 'openai', key: SENTINEL });
|
||||
assert.equal(added.status, 200);
|
||||
assert.deepEqual(added.json, { cleared: true }, 'the bus answer is passed through as it was');
|
||||
await post('/api/proxy/login/start', { provider: 'openai' });
|
||||
await send(f.port, '/api/proxy/accounts', { headers: f.headers() });
|
||||
const records = f.admin.calls.filter(c => c[0] === 'recordAccount').map(c => c[1]);
|
||||
assert.deepEqual(records.map(r => r.verb), ['proxy.apikey.add', 'proxy.login.start']);
|
||||
assert.deepEqual(records[0], { verb: 'proxy.apikey.add', args: { provider: 'openai', key: SENTINEL }, result: { cleared: true }, user: 'Local operator', org: null });
|
||||
f.admin.recordAccount = () => false;
|
||||
const unrecorded = await post('/api/proxy/apikey/add', { provider: 'openai', key: SENTINEL });
|
||||
assert.deepEqual(unrecorded.json, { cleared: true, recorded: false });
|
||||
f.admin.recordAccount = () => { throw new Error(SENTINEL); };
|
||||
const thrown = await post('/api/proxy/apikey/add', { provider: 'openai', key: SENTINEL });
|
||||
assert.deepEqual(thrown.json, { cleared: true, recorded: false });
|
||||
f.admin.recordAccount = () => null;
|
||||
assert.deepEqual((await post('/api/proxy/login/cancel', { state: 's' })).json, { cleared: true }, 'not an account change: nothing added');
|
||||
assert.equal(f.logs.join('\n').includes(SENTINEL), false);
|
||||
});
|
||||
|
||||
test('a refused or failed account write records nothing, and an organization route names its organization', async t => {
|
||||
const f = await devServer(t, { proxyCall: async () => { throw Object.assign(new Error('x'), { code: 'provider-not-allowed' }); } });
|
||||
const r = await send(f.port, '/api/proxy/apikey/add', { method: 'POST', headers: f.headers(), body: { provider: 'openai', key: SENTINEL } });
|
||||
assert.equal(r.status, 400);
|
||||
assert.deepEqual(f.admin.calls, []);
|
||||
const organizations = { list: async () => [], resolve: async id => (id === 'acme' ? { busHealthy: true, send: async () => ({}), proxyCall: async () => ({ added: true }) } : null) };
|
||||
const o = await devServer(t, { organizations });
|
||||
const inOrg = await send(o.port, '/api/orgs/acme/proxy/apikey/add', { method: 'POST', headers: o.headers(), body: { provider: 'openai', key: SENTINEL } });
|
||||
assert.deepEqual(inOrg.json, { added: true });
|
||||
assert.deepEqual(o.admin.calls, [['recordAccount', { verb: 'proxy.apikey.add', args: { provider: 'openai', key: SENTINEL }, result: { added: true }, user: 'Local operator', org: 'acme' }]]);
|
||||
});
|
||||
|
||||
test('a real controller records the account write without the key, and history shows it', async t => {
|
||||
const { createProxyAdmin } = await import('../../model-proxy/src/admin-control.mjs');
|
||||
const root = mkdtempSync(join(tmpdir(), 'pa-a1r-'));
|
||||
t.after(() => rmSync(root, { recursive: true, force: true }));
|
||||
const { mkdirSync } = await import('node:fs');
|
||||
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
||||
mkdirSync(configDir, { mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 });
|
||||
const admin = createProxyAdmin({ dataRoot, configDir, unit: { unit: 'mosaic-proxy-zz.service', status: async () => ({ installed: false }) }, buses: async () => ({ stopped: true, running: [] }), now: () => new Date(0), env: {} });
|
||||
const f = await devServer(t, { proxyAdmin: admin, proxyCall: async () => ({ added: true }) });
|
||||
const r = await send(f.port, '/api/proxy/apikey/add', { method: 'POST', headers: f.headers(), body: { provider: 'openai', key: SENTINEL } });
|
||||
assert.deepEqual(r.json, { added: true });
|
||||
const h = await send(f.port, '/api/proxy/admin/history', { headers: f.headers() });
|
||||
assert.deepEqual(h.json, { entries: [{ time: new Date(0).toISOString(), op: 'account.proxy.apikey.add', provider: 'openai', user: 'Local operator' }], next: null });
|
||||
assert.equal(readFileSync(join(dataRoot, 'state', 'proxy-admin.jsonl'), 'utf8').includes(SENTINEL), false);
|
||||
});
|
||||
|
||||
// #1873 settings-backend A2: programs off and access health.
|
||||
test('A2: a member and an organization owner get human-required on programs off and access, before any controller call', async t => {
|
||||
const organizations = { list: async () => [], resolve: async id => (id === 'x' ? { busHealthy: true } : null) };
|
||||
for (const session of [{ name: 'Bob', provider: 'local-dev', iss: 'local-dev', sub: 'bob', rootOwner: false, instanceRole: 'member' },
|
||||
{ name: 'Olive', provider: 'local-dev', iss: 'local-dev', sub: 'olive', rootOwner: false, instanceRole: 'operator', orgRole: 'owner' }]) {
|
||||
const f = await devServer(t, { organizations, sso: { ...createDevOwner(), session: () => session } });
|
||||
for (const route of A2) {
|
||||
const inOrg = await send(f.port, `/api/orgs/x/proxy/admin/${route[0]}`, { method: route[1], headers: f.headers(), body: route[2] });
|
||||
assert.equal(inOrg.status, 403, `${session.sub} ${route[0]}`); assert.deepEqual(inOrg.json, { error: 'human-required' }, `${session.sub} ${route[0]}`);
|
||||
const plain = await hit(f, route);
|
||||
assert.equal(plain.status >= 400 && plain.status < 500, true, `${session.sub} ${route[0]} outside an organization is refused`);
|
||||
}
|
||||
assert.deepEqual(f.admin.calls, []);
|
||||
}
|
||||
});
|
||||
|
||||
test('A2: programs off takes one plain program name and nothing else; access takes no body', async t => {
|
||||
const f = await devServer(t);
|
||||
for (const body of [{}, { name: '' }, { name: 'Alpha' }, { name: '../x' }, { name: 7 }, { name: 'a'.repeat(33) }, { name: 'alpha', extra: 1 }, { name: ['alpha'] }])
|
||||
assert.deepEqual((await hit(f, ['programs/off', 'POST', body])).json, { error: 'invalid-request' }, JSON.stringify(body));
|
||||
assert.deepEqual(f.admin.calls, []);
|
||||
assert.equal((await send(f.port, '/api/proxy/admin/access', { method: 'POST', headers: f.headers(), body: {} })).status, 405);
|
||||
assert.equal((await send(f.port, '/api/proxy/admin/programs/off', { headers: f.headers() })).status, 405);
|
||||
f.admin.programsOff = async () => { throw Object.assign(new Error(`${SENTINEL} busy`), { code: 'proxy-admin-busy' }); };
|
||||
const busy = await hit(f, ['programs/off', 'POST', { name: 'alpha' }]);
|
||||
assert.equal(busy.status, 409); assert.deepEqual(busy.json, { error: 'proxy-admin-busy' });
|
||||
f.admin.access = async () => { throw new Error(SENTINEL); };
|
||||
assert.deepEqual((await hit(f, ['access', 'GET'])).json, { error: 'outcome-unknown' });
|
||||
assert.equal(f.logs.join('\n').includes(SENTINEL), false);
|
||||
});
|
||||
|
||||
// The real controller behind the real routes, with fake organizations whose answers carry planted keys.
|
||||
test('A2 end to end: programs off writes one receipt, skips a down bus, and no answer, receipt or history holds a key; access never says ok for proxy-uncertain', async t => {
|
||||
const { createProxyAdmin } = await import('../../model-proxy/src/admin-control.mjs');
|
||||
const { mkdirSync } = await import('node:fs');
|
||||
const root = mkdtempSync(join(tmpdir(), 'pa-a2-'));
|
||||
t.after(() => rmSync(root, { recursive: true, force: true }));
|
||||
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
|
||||
mkdirSync(configDir, { mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 });
|
||||
const TAIL = 'Ab3_dE5-fG7hJ9kL1mN3pQ5rS7tU9vW1xY3zA5bC7dE';
|
||||
const planted = [`msk-k1a2-${TAIL}`, `mso-k1a2-acme-${TAIL}`, `mst-k1a2-triage-${TAIL}`, `msp-k1a2-${TAIL}`];
|
||||
const REV = 'c'.repeat(64);
|
||||
const sets = [];
|
||||
const org = (id, { down = false, keys = [], keysError = null } = {}) => ({
|
||||
id, fixture: false, cliproxy: true, changes: '',
|
||||
file: () => ({ document: { roles: {}, plugins: { harness: ['alpha', 'beta'] }, note: planted[1] }, revision: REV }),
|
||||
call: async (verb, args) => {
|
||||
if (down) throw Object.assign(new Error(planted[0]), { code: 'outcome-unknown' });
|
||||
if (verb === 'plugins') return { business: id, revision: REV, plugins: { harness: ['alpha', 'beta'] }, note: planted[0] };
|
||||
if (verb === 'routes') return { business: id, revision: REV, instances: {}, note: planted[2] };
|
||||
if (verb === 'plugins.set') { sets.push([id, args]); return { business: id, revision: 'd'.repeat(64) }; }
|
||||
if (verb === 'proxy.keys') { if (keysError) throw Object.assign(new Error(planted[3]), { code: keysError }); return { keys }; }
|
||||
throw Object.assign(new Error(planted[3]), { code: 'invalid-request' });
|
||||
},
|
||||
});
|
||||
const orgs = [
|
||||
org('acme', { keys: [{ keyId: '0123456789ab', management: 'stack-managed', agent: planted[1], issuedAt: planted[3], state: 'active' }, { keyId: 'abcdefabcdef', management: 'not stack-managed', agent: planted[0], issuedAt: null, state: null }] }),
|
||||
org('bolt', { down: true }),
|
||||
org('crux', { keysError: 'proxy-uncertain' }),
|
||||
];
|
||||
const admin = createProxyAdmin({ dataRoot, configDir, unit: { unit: 'mosaic-proxy-zz.service', status: async () => ({ installed: false }) }, buses: async () => ({ stopped: true, running: [] }), now: () => new Date(0), env: {},
|
||||
riders: async () => orgs, harnesses: () => ['alpha', 'beta'], rootAgents: () => ({ state: 'absent', agents: {}, assistant: null }) });
|
||||
const f = await devServer(t, { proxyAdmin: admin });
|
||||
const unknown = await hit(f, ['programs/off', 'POST', { name: 'gamma' }]);
|
||||
assert.equal(unknown.status, 400); assert.deepEqual(unknown.json, { error: 'invalid-request' });
|
||||
const off = await hit(f, ['programs/off', 'POST', { name: 'alpha' }]);
|
||||
assert.equal(off.status, 200);
|
||||
assert.deepEqual(off.json.results, [{ id: 'acme', outcome: 'off' }, { id: 'bolt', outcome: 'bus-down' }, { id: 'crux', outcome: 'off' }]);
|
||||
assert.deepEqual(off.json.receipt, { time: new Date(0).toISOString(), op: 'programs.off', name: 'alpha', results: off.json.results, user: 'Local operator' });
|
||||
assert.deepEqual(sets.map(([id]) => id), ['acme', 'crux']);
|
||||
const lines = readFileSync(join(dataRoot, 'state', 'proxy-admin.jsonl'), 'utf8').trim().split('\n');
|
||||
assert.equal(lines.length, 1);
|
||||
const access = await hit(f, ['access', 'GET']);
|
||||
assert.equal(access.status, 200);
|
||||
assert.deepEqual(access.json.organizations.map(o => [o.id, o.health, o.reason ?? null]), [['acme', 'ok', null], ['bolt', 'unreadable', 'bus-down'], ['crux', 'attention', 'proxy-uncertain']]);
|
||||
assert.deepEqual(access.json.organizations[0].keys, [{ keyId: '0123456789ab', agent: null, state: 'active', issuedAt: null }]);
|
||||
const status = await hit(f, ['status', 'GET']);
|
||||
assert.deepEqual(status.json.programs, { installed: ['alpha', 'beta'], organizations: [{ id: 'acme', on: ['alpha', 'beta'] }, { id: 'bolt', on: null }, { id: 'crux', on: ['alpha', 'beta'] }] });
|
||||
const history = await hit(f, ['history', 'GET']);
|
||||
assert.deepEqual(history.json.entries, [off.json.receipt]);
|
||||
const all = [unknown.text, off.text, access.text, status.text, history.text, lines.join('\n'), f.logs.join('\n')].join('\n');
|
||||
assert.doesNotMatch(all, /ms[kotp]-[A-Za-z0-9_-]{4,}/);
|
||||
for (const bit of [TAIL, TAIL.slice(0, 10), root]) assert.equal(all.includes(bit), false, bit);
|
||||
});
|
||||
@@ -26,9 +26,12 @@ const scenario = (status, config = {}) => ({ '/api/config': { send: true, devOwn
|
||||
const writes = b => b.evaluate('window.__writes.filter(w=>w.path.startsWith("/api/proxy/admin/")).map(w=>({path:w.path,body:JSON.parse(w.body)}))');
|
||||
// Step 3's line names the step it holds in data-next.
|
||||
const STEP3 = '#setup-step-organizations [data-step-summary]';
|
||||
// settings-s5b: Technical details reads the setup history from GET /api/proxy/admin/history, not from receipts.
|
||||
const history = entries => ({ '/api/proxy/admin/history?limit=25': { entries, next: null }, '/api/proxy/admin/service-key': { madeAt: T, renewedAt: null, renewal: 'not-built', problem: null } });
|
||||
const historyItems = b => b.evaluate('[...document.querySelectorAll("#proxy-setup-history li")].map(li=>li.textContent.split(" · ")[0])');
|
||||
|
||||
test('a fresh instance shows Set up model service as one button, the not-built own proxy, and no terminal note', { timeout: 90000 }, async t => {
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(base), 'POST /api/proxy/admin/fetch': { status: 202, body: { state: 'running' } } } });
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(base), 'POST /api/proxy/admin/fetch': { status: 202, body: { state: 'running' } }, '/api/proxy/admin/log?lines=20': { unit: 'mosaic-proxy.service', lines: [], redacted: 0, dropped: 0 } } });
|
||||
await b.navigate(f.base + '/#/settings/model-setup');
|
||||
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="fetch"');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup").hidden'), false);
|
||||
@@ -46,6 +49,8 @@ test('a fresh instance shows Set up model service as one button, the not-built o
|
||||
await wait('document.querySelector("#setup-step-service").dataset.state==="bad"');
|
||||
assert.deepEqual(await writes(b), [{ path: '/api/proxy/admin/fetch', body: {} }]);
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").textContent'), 'Try again');
|
||||
// settings-s5b: a failed step 1 opens the service's last lines, read from the log route.
|
||||
await wait('document.querySelector("#proxy-setup-lines").open && /written nothing yet/.test(document.querySelector("#proxy-setup-lines [data-log]").textContent)');
|
||||
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
|
||||
});
|
||||
|
||||
@@ -59,7 +64,7 @@ test('without send the next-step button is disabled and nothing is posted', { ti
|
||||
});
|
||||
|
||||
test('init always sends generate; there is no pasted key, and Try again sends generate again', { timeout: 90000 }, async t => {
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fetched), 'POST /api/proxy/admin/init': { body: { settings: { port: 18432 }, receipt: { op: 'init', time: T, port: 18432, generated: true } } } } });
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fetched), ...history([{ op: 'init', time: T }]), 'POST /api/proxy/admin/init': { body: { settings: { port: 18432 }, receipt: { op: 'init', time: T, port: 18432, generated: true } } } } });
|
||||
await b.navigate(f.base + '/#/settings/model-setup');
|
||||
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="init"');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").textContent'), 'Continue setup');
|
||||
@@ -73,7 +78,11 @@ test('init always sends generate; there is no pasted key, and Try again sends ge
|
||||
await b.evaluate('(()=>{const f=document.querySelector("#proxy-setup-init");f.elements.port.value="18432";document.querySelector("#proxy-setup-go").click();})()');
|
||||
await wait('window.__writes.some(w=>w.path==="/api/proxy/admin/init")');
|
||||
assert.deepEqual(await writes(b), [{ path: '/api/proxy/admin/init', body: { generate: true, port: 18432 } }]);
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-setup-receipts").textContent'), /init/);
|
||||
// settings-s5b: the receipt is not shown raw; the history read under Technical details names it.
|
||||
assert.doesNotMatch(await b.evaluate('document.querySelector("#proxy-setup").textContent'), /generated/);
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech").open = true');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 1');
|
||||
assert.deepEqual(await historyItems(b), ['Set up']);
|
||||
// The status still names init, so the run stops there; Try again starts from it.
|
||||
await wait('document.querySelector("#proxy-setup-go")?.textContent==="Try again" && !document.querySelector("#proxy-setup-init [data-setup-write]").disabled');
|
||||
await b.evaluate('(()=>{const f=document.querySelector("#proxy-setup-init");f.elements.port.value="";document.querySelector("#proxy-setup-go").click();})()');
|
||||
@@ -82,14 +91,20 @@ test('init always sends generate; there is no pasted key, and Try again sends ge
|
||||
});
|
||||
|
||||
test('after a confirmed restart the next step clears the fence and shows the receipt', { timeout: 90000 }, async t => {
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fenced), 'POST /api/proxy/admin/fence/clear': { body: { cleared: true, receipt: { op: 'fence.clear', time: T, pid: 4242 } } } } });
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(fenced), ...history([]), 'POST /api/proxy/admin/fence/clear': { body: { cleared: true, receipt: { op: 'fence.clear', time: T, pid: 4242 } } } } });
|
||||
await b.navigate(f.base + '/#/settings/model-setup');
|
||||
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="fence-clear"');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech").open = true');
|
||||
await wait('document.querySelector("#proxy-setup-history-message").textContent === "No setup history yet."');
|
||||
await b.evaluate(`window.__scenario['/api/proxy/admin/history?limit=25'] = { entries: [{ op: 'fence.clear', time: '${T}' }], next: null }`);
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-setup-state").textContent'), /new pid 4242/);
|
||||
await b.evaluate('document.querySelector("#proxy-setup-go").click()');
|
||||
await wait('document.querySelector("#proxy-setup-message").textContent.includes("Fence cleared")');
|
||||
assert.deepEqual(await writes(b), [{ path: '/api/proxy/admin/fence/clear', body: {} }]);
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-setup-receipts").textContent'), /fence\.clear.*pid: 4242/);
|
||||
// settings-s5b: with Technical details open, the write reads the history again.
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 1');
|
||||
assert.deepEqual(await historyItems(b), ['Key writes resumed']);
|
||||
assert.doesNotMatch(await b.evaluate('document.querySelector("#proxy-setup").textContent'), /pid: 4242/);
|
||||
});
|
||||
|
||||
test('a stopped proxy hides the account panels with a setup note, and starting the service brings them back', { timeout: 90000 }, async t => {
|
||||
@@ -143,13 +158,16 @@ test('a fence with no readable time names the --proxy-restarted path instead of
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-next details.proxy-setup-cli p").textContent'), 'Run this in a terminal on this machine: mosaic proxy fence clear --proxy-restarted');
|
||||
});
|
||||
|
||||
test('after a reload the receipts come from status, and an initialized proxy shows its settings read-only', { timeout: 90000 }, async t => {
|
||||
test('after a reload the history comes from the history read, not the status receipts, and an initialized proxy shows its settings read-only', { timeout: 90000 }, async t => {
|
||||
const initialized = { ...base, release: fetched.release, init: { initialized: true, partial: false, settings: { port: 18432 }, files: [] },
|
||||
receipts: [{ op: 'fetch', time: T, version: '8.0.42' }, { op: 'init', time: T, generated: true, port: 18432 }], next: ['unit-install'] };
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(initialized), 'POST /api/proxy/admin/unit/install': { body: { receipt: { op: 'unit.install', time: T } } } } });
|
||||
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(initialized), ...history([{ op: 'fetch', time: T }, { op: 'init', time: T }]), 'POST /api/proxy/admin/unit/install': { body: { receipt: { op: 'unit.install', time: T } } } } });
|
||||
await b.navigate(f.base + '/#/settings/model-setup');
|
||||
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="unit-install"');
|
||||
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-setup-receipts li strong")].map(s=>s.textContent)'), ['init', 'fetch'], 'newest first, from proxy-admin.jsonl');
|
||||
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 0, 'nothing is read before Technical details opens');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech").open = true');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 2');
|
||||
assert.deepEqual(await historyItems(b), ['Set up', 'Release downloaded and checked'], 'newest first, from the history read');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-init").hidden'), true, 'init is done, so its form is gone');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-settings").textContent'), 'Port18432');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-settings-note").textContent'), 'Changing these after setup is not built yet.');
|
||||
@@ -177,7 +195,7 @@ test('Ride all confirms the stricter admission, paints skips and stand-in organi
|
||||
await wait(`document.querySelector("#proxy-ride")?.checkVisibility() && document.querySelector(${JSON.stringify(STEP3)})?.dataset.next==="ride-all"`);
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-ride-go").className'), 'btn primary');
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-ride-text").textContent'), /every launch route is checked, direct Anthropic routes too.*2 organizations can ride now/);
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-ride-fixtures li").textContent'), /^west uses stand-in models, can be moved to the owner's models\./);
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-ride-fixtures li").textContent'), /^west uses stand-in models, can be moved to your models\./);
|
||||
// The first Ride all's own reload paints, then waits on the accounts read for good.
|
||||
await b.evaluate('document.querySelector("#proxy-ride-go").click()');
|
||||
await wait('window.__writes.some(w=>w.path==="/api/proxy/admin/ride-all")');
|
||||
@@ -399,7 +417,7 @@ test('settings-p3: a stand-in organization with no bus status is not offered a M
|
||||
await b.navigate(f.base + '/#/settings/model-setup');
|
||||
await wait('document.querySelector("#proxy-ride-fixtures li")');
|
||||
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-ride-fixtures li")].map(li => li.firstChild.textContent.trim())'),
|
||||
['west uses stand-in models. Moving it is not available on this Console.', "east uses stand-in models, can be moved to the owner's models."]);
|
||||
['west uses stand-in models. Moving it is not available on this Console.', "east uses stand-in models, can be moved to your models."]);
|
||||
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=west]")'), null);
|
||||
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=east]").disabled'), false);
|
||||
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
|
||||
@@ -446,8 +464,8 @@ test('settings-s1 B4: only the next step has a button; done steps, Fence, Init l
|
||||
assert.deepEqual(await b.evaluate(`${visible('.settings-content .primary')}.map(e=>e.id||e.textContent)`), ['proxy-login-go'], 'one primary button on the page');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go")'), null, 'step 1 is done, so it has no button');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-init").checkVisibility()'), false, 'init is done, so its form is gone');
|
||||
const tech = await b.evaluate('(()=>{const d=document.querySelector("#proxy-setup-tech");return {summary:d.querySelector("summary").textContent,open:d.open,terms:[...d.querySelectorAll("dt")].map(x=>x.textContent),units:d.querySelectorAll("[data-unit]").length,receipts:!!d.querySelector("#proxy-setup-receipts")}})()');
|
||||
assert.deepEqual(tech, { summary: 'Technical details: release, service, history', open: false, terms: ['Release', 'Initialized', 'Service', 'Fence', 'Init lock'], units: 4, receipts: true });
|
||||
const tech = await b.evaluate('(()=>{const d=document.querySelector("#proxy-setup-tech");return {summary:d.querySelector("summary").textContent,open:d.open,terms:[...d.querySelectorAll("dt")].map(x=>x.textContent),units:d.querySelectorAll("[data-unit]").length,history:!!d.querySelector("#proxy-setup-history")}})()');
|
||||
assert.deepEqual(tech, { summary: 'Technical details: release, service, history', open: false, terms: ['Release', 'Initialized', 'Service', 'Fence', 'Init lock', 'Service key'], units: 4, history: true });
|
||||
assert.equal(await b.evaluate(`${visible('#proxy-setup dt, #proxy-setup [data-unit]')}.length`), 0, 'nothing technical shows until it is opened');
|
||||
// Technical details opens by keyboard and shows the controls.
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech summary").focus()');
|
||||
|
||||
@@ -197,8 +197,9 @@ test('Routing switch writes the model-provider setting and keeps other modules',
|
||||
await b.call('Page.addScriptToEvaluateOnNewDocument',{source:`const original=window.fetch;window.posts=[];window.fetch=async(url,options={})=>{if(url==='/api/config')return new Response(JSON.stringify({send:true}));if(url==='/api/proxy/plugins')return new Response(JSON.stringify(${JSON.stringify(settings)}));if(url==='/api/proxy/plugins/set'){posts.push(JSON.parse(options.body));return new Promise(r=>window.answer=(status,body)=>r(new Response(JSON.stringify(body),{status})));}return original(url,options);};`});
|
||||
await b.navigate(`http://127.0.0.1:${web.address().port}/#/settings/routing`);
|
||||
const wait=expr=>b.evaluate(`(async()=>{for(let n=0;n<200;n++){if(${expr})return true;await new Promise(r=>setTimeout(r,30));}throw Error('wait failed');})()`);
|
||||
await wait('document.querySelector("#provider-switch")?.textContent.startsWith("Use your models")');
|
||||
await b.evaluate('document.querySelector("#provider-switch").click();true');
|
||||
// settings-s5: the switch is the Use your models choice; choosing it writes at once.
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use your models")&&!document.querySelector("#models-yours").disabled');
|
||||
await b.evaluate('document.querySelector("#models-yours").click();true');
|
||||
await wait('posts.length===1');const payload=await b.evaluate('posts[0]');
|
||||
assert.deepEqual(payload.plugins,{'model-provider':['cliproxy']});
|
||||
const before=JSON.parse(readFileSync(file,'utf8')).plugins;
|
||||
@@ -271,7 +272,7 @@ test('quick fallback edits survive the harness redraw', {timeout:60000}, async t
|
||||
// organization's catalogue is ready with no proxy, and its switch reads Enable.
|
||||
test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disable and removes cliproxy only; a fixture-only org reads Enable', {timeout:90000}, async t => {
|
||||
for (const [providers, label, line, next] of [
|
||||
[['fixture','cliproxy'], 'Stop using the model service', /can't see your models yet\. Your model service isn't set up yet\. A change to thinking alone still saves\. A new model needs the model service: ask the instance owner to set it up, or press Stop using the model service when this organization does not need it\./, ['fixture']],
|
||||
[['fixture','cliproxy'], 'Stop using your models', /can't see your models yet\. Your model service isn't set up yet\. A change to thinking alone still saves\. A new model needs the model service: ask the instance owner to set it up, or press Stop using your models when this organization does not need it\./, ['fixture']],
|
||||
[['fixture'], 'Use your models', /^Model catalogue, observed /, ['fixture','cliproxy']],
|
||||
]) {
|
||||
const root=tmp(t,'d3-switch-'), f=fixture(root,'acme',doc=>{doc.plugins['model-provider']=providers;return doc;});
|
||||
@@ -287,13 +288,17 @@ test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disab
|
||||
await b.call('Page.addScriptToEvaluateOnNewDocument',{source:`const original=window.fetch;window.posts=[];window.fetch=async(url,options={})=>{if(url==='/api/config')return new Response(JSON.stringify({send:true}));if(url==='/api/proxy/plugins')return new Response(JSON.stringify(${JSON.stringify(settings)}));if(url==='/api/proxy/plugins/set'){posts.push(JSON.parse(options.body));return new Promise(r=>window.answer=(status,body)=>r(new Response(JSON.stringify(body),{status})));}return original(url,options);};`});
|
||||
await b.navigate(`http://127.0.0.1:${web.address().port}/#/settings/routing`);
|
||||
const wait=expr=>b.evaluate(`(async()=>{for(let n=0;n<200;n++){if(${expr})return true;await new Promise(r=>setTimeout(r,30));}throw Error('wait failed');})()`);
|
||||
await wait(`document.querySelector("#provider-switch")?.textContent.startsWith(${JSON.stringify(label)})&&!!document.querySelector('[data-harness]')`);
|
||||
// settings-s5: in force, the way back is Stop using your models; not in force, the Use your models choice.
|
||||
const control=label==='Stop using your models'?'#models-stop':'#models-yours';
|
||||
await wait(`!!document.querySelector(${JSON.stringify(control)})&&!document.querySelector(${JSON.stringify(control)}).disabled&&!!document.querySelector('[data-harness]')`);
|
||||
// settings-s5 review P3-3: a Console with no organizations says "this business" mid-sentence.
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-source legend").textContent'),'Where this business gets its models');
|
||||
const [info,...notices]=await b.evaluate('[document.querySelector(".routing-panel > p.small")?.textContent,...[...document.querySelectorAll(".routing-panel > p.small.warn")].slice(1).map(p=>p.textContent)]');
|
||||
assert.match(info,line,providers.join(','));
|
||||
// proxy-pickup (#1873): the bus's cause reads as a plain line; its own words sit under Technical details.
|
||||
assert.deepEqual(notices,[],providers.join(','));
|
||||
assert.deepEqual(await b.evaluate('[...document.querySelectorAll(".routing-panel > details.routes-cause-detail p")].map(p=>p.textContent)'),label==='Stop using the model service'?['The model proxy has not been set up for this instance yet. Set it up on the Model proxy page.']:[],providers.join(','));
|
||||
await b.evaluate('document.querySelector("#provider-switch").click();true');
|
||||
assert.deepEqual(await b.evaluate('[...document.querySelectorAll(".routing-panel > details.routes-cause-detail p")].map(p=>p.textContent)'),label==='Stop using your models'?['The model proxy has not been set up for this instance yet. Set it up on the Model proxy page.']:[],providers.join(','));
|
||||
await b.evaluate(`document.querySelector(${JSON.stringify(control)}).click();true`);
|
||||
await wait('posts.length===1');const payload=await b.evaluate('posts[0]');
|
||||
assert.deepEqual(payload.plugins,{'model-provider':next},providers.join(','));
|
||||
const result=await call('plugins.set',payload);await b.evaluate(`window.answer(200,${JSON.stringify(result)});true`);
|
||||
@@ -309,7 +314,7 @@ test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disab
|
||||
test('D3 Routing: a catalogue refusal names Disable only when it can make the save apply, and sends a tester to the owner', {timeout:90000}, async t => {
|
||||
const refusal=code=>({error:code,message:`${code}: the reason. Nothing changed.`,sent:false});
|
||||
for (const [providers, tester, instance, code, expect] of [
|
||||
[['fixture','cliproxy'], false, 'coder', 'model-catalogue-unavailable', /Nothing changed\. This change does not need the model service: press Stop using the model service, then save again\. Draft kept\.$/],
|
||||
[['fixture','cliproxy'], false, 'coder', 'model-catalogue-unavailable', /Nothing changed\. This change does not need your models: press Stop using your models, then save again\. Draft kept\.$/],
|
||||
[['fixture','cliproxy'], false, 'reviewer', 'model-catalogue-unavailable', /Nothing changed\. Draft kept\.$/],
|
||||
[['fixture'], false, 'reviewer', 'model-provider-unavailable', /Nothing changed\. Draft kept\.$/],
|
||||
[['fixture','cliproxy'], true, 'coder', 'model-catalogue-unavailable', /Nothing changed\. Ask the organization's owner to set up the model service, or to stop using it when the change does not need it\. Draft kept\.$/],
|
||||
|
||||
@@ -187,7 +187,7 @@ test('settings-s4 review F2: a stand-in organization with its bus stopped reads
|
||||
assert.equal(await text(STEP3), "The model service is set up. Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus.");
|
||||
assert.equal(await b.evaluate('document.querySelector("#setup-step-organizations").dataset.state'), 'bad');
|
||||
const item = await b.evaluate('document.querySelector("#proxy-ride-fixtures li").firstChild.textContent.trim()');
|
||||
assert.equal(item, "Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to the owner's models, then start its bus.");
|
||||
assert.equal(item, "Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus.");
|
||||
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=gamma]").textContent'), 'Move Gamma Home');
|
||||
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=gamma]").checkVisibility()'), true);
|
||||
// The organizations that need nothing get no mark.
|
||||
|
||||
@@ -0,0 +1,455 @@
|
||||
// #1873 settings slice 5 (DESIGN.md 3.4, 12 slice 5, mockups org-models and org-models-restart): an
|
||||
// organization's Models page offers one choice, "Use your models" (the cliproxy model-provider module
|
||||
// through plugins.set) or "Use its own model service" (Coming later), says from the plugins read which
|
||||
// one is in force and what a switch changes, and switches both ways. Also the items slice 4 left: the
|
||||
// Ride all lines name an organization by its display name, step 3 and the "can't start" mark agree
|
||||
// before the first account, the sidebar marks follow a switch, a failed turn shows "Details:" once in
|
||||
// Messages, the old Members addresses land on Agents, and Technical details shows the port and
|
||||
// timeouts the status read carries.
|
||||
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 { browser } from './browser.mjs';
|
||||
import { close } from './fixture.mjs';
|
||||
import { ReadError } from '../src/reads.mjs';
|
||||
|
||||
const LIST = [
|
||||
{ id: 'acme', label: 'Acme Studio', theme: 'cobalt', busHealthy: true },
|
||||
{ id: 'gamma', label: 'Gamma Home', theme: 'rosewood', busHealthy: false, busStopped: true },
|
||||
{ id: 'north', label: 'North Works', theme: 'cobalt', busHealthy: true },
|
||||
];
|
||||
const VIEW = {
|
||||
business: 'acme', revision: 'a'.repeat(64), harnesses: ['pi'], models: ['fixture-deterministic'],
|
||||
providerModels: { 'fixture-deterministic': { module: 'fixture', upstream: 'fixture', model: 'fixture-deterministic' } },
|
||||
levels: { pi: ['off', 'low'] }, instances: {}, catalogue: { status: 'ready', observedAt: new Date().toISOString(), models: [], notices: [] },
|
||||
};
|
||||
|
||||
async function orgFixture({ routes = {}, messages = [] } = {}) {
|
||||
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 empty = () => Promise.resolve([]);
|
||||
const member = org => ({
|
||||
id: org.id, doc: { appearance: { theme: org.theme }, roles: { chief: { definition: 'chief-of-staff' } }, projects: {} },
|
||||
status: async () => (org.busHealthy ? { healthy: true, pid: 4242, boot: null } : { healthy: false, boot: { ok: false, at: new Date().toISOString(), lastGood: null, reason: 'stopped by the owner' } }),
|
||||
options: () => ({ bus: { inbox: empty, agents: empty, 'thread.claims': empty, tasks: empty, usage: () => Promise.resolve({}), limits: () => Promise.resolve({}), decisions: empty }, chat: { threads: empty, projects: empty } }),
|
||||
});
|
||||
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;
|
||||
if (!org.busHealthy) return { busHealthy: false, reads: { settings: async () => { throw new ReadError('bus-unavailable'); } }, bus: {}, chat: { projects: empty, threads: empty } };
|
||||
return {
|
||||
busHealthy: true,
|
||||
reads: { business: async () => ({ business: { id, human: 'jason', projects: [], appearance: { theme: org.theme } } }), settings: async () => ({ business: id, release: 'fixture', notifier: {} }), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
|
||||
bus: { messages: async () => ({ messages, unread: 0, total: messages.length }), agents: empty, 'thread.claims': empty, inbox: empty, tasks: empty, usage: async () => ({}), routes: async () => ({ ...VIEW, ...(routes[id] ?? {}), business: id }), instances: async () => ({ business: id, revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }) },
|
||||
chat: { projects: empty, threads: empty },
|
||||
};
|
||||
},
|
||||
};
|
||||
return { organizations, agentLevels: { loadRoot: () => root, rolesDir, ctx: { configDir: '/cfg', dataRoot: '/data', instance: 'test' } } };
|
||||
}
|
||||
|
||||
// The model service is set up and answering. init.settings is what the status read carries after init
|
||||
// (model-proxy admin.mjs initState).
|
||||
const SERVICE_UP = { next: ['accounts'], init: { initialized: true, partial: false, problem: null, settings: { port: 18432, rotateGraceMinutes: 30, firstOutputSeconds: 90 }, files: [] },
|
||||
release: { fetched: true, verified: true, version: '8.0.42', panelVersion: '1.26.7' },
|
||||
unit: { unit: 'mosaic-proxy.service', installed: true, active: 'active', port: 18432, listening: true, healthy: true }, fence: { set: false }, initLock: { present: false, blockers: [] }, fetch: { state: 'idle' }, organizations: [], ride: [] };
|
||||
const SERVICE_DOWN = { ...SERVICE_UP, next: ['unit-start'], unit: { ...SERVICE_UP.unit, active: 'inactive', listening: false, healthy: false } };
|
||||
const REV = n => String(n).repeat(64).slice(0, 64);
|
||||
const pluginsRead = providers => ({ revision: REV('b'), available: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] }, plugins: { harness: ['pi'], 'model-provider': providers } });
|
||||
|
||||
// The instance owner's flags and every model service read and write, by path suffix (display.js
|
||||
// scopes some reads under /api/orgs/<id>/). plugins.set merges the module lists the way the bus does
|
||||
// and may carry a new setup status (__s5.afterSet). window.confirm answers yes and records its text.
|
||||
const ownerStub = ({ service = SERVICE_UP, plugins = pluginsRead(['fixture']), accounts = [], posts = {}, afterSet = null, setStatus = 200 } = {}) => `(() => {
|
||||
const real = window.fetch.bind(window);
|
||||
window.__s5 = ${JSON.stringify({ service, plugins, accounts, posts, afterSet, setStatus })}; window.__sets = []; window.__writes = []; window.__confirms = [];
|
||||
window.confirm = text => { window.__confirms.push(text); return true; };
|
||||
const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
|
||||
window.fetch = async (input, init = {}) => {
|
||||
const url = new URL(typeof input === 'string' ? input : input.url, location.href), path = url.pathname, method = (init.method || 'GET').toUpperCase();
|
||||
if (method !== 'GET' && path.endsWith('/proxy/plugins/set')) {
|
||||
const body = JSON.parse(init.body); window.__sets.push({ path, body });
|
||||
if (__s5.setStatus !== 200) return json({ error: 'plugins-refused', message: 'The bus refused the change (plugins-refused).' }, __s5.setStatus);
|
||||
__s5.plugins = { ...__s5.plugins, revision: String(__s5.sets = (__s5.sets ?? 0) + 1).repeat(64).slice(0, 64), plugins: { ...__s5.plugins.plugins, ...body.plugins } };
|
||||
if (__s5.afterSet) __s5.service = __s5.afterSet;
|
||||
return json({ revision: __s5.plugins.revision, plugins: __s5.plugins.plugins });
|
||||
}
|
||||
if (method !== 'GET' && /\\/proxy\\//.test(path)) { window.__writes.push(path); const key = Object.keys(__s5.posts).find(k => path.endsWith(k)); const a = key ? __s5.posts[key] : { status: 500, body: { error: 'stub' } };
|
||||
if (a.service) __s5.service = a.service; return json(a.body ?? {}, a.status ?? 200); }
|
||||
if (method !== 'GET') return real(input, init);
|
||||
if (/\\/api\\/(orgs\\/[^/]+\\/)?config$/.test(path)) { const c = await (await real(input, init)).json(); return json({ ...c, orgSetup: true, proxyAdmin: true, proxyAdminSend: true, ...(/\\/orgs\\//.test(path) ? { settingsSend: true } : {}) }); }
|
||||
if (path.endsWith('/proxy/plugins')) return json(__s5.plugins);
|
||||
if (path.endsWith('/proxy/admin/status')) return json(__s5.service);
|
||||
if (path.endsWith('/proxy/accounts')) return json({ accounts: __s5.accounts });
|
||||
if (path.endsWith('/proxy/keys')) return json({ keys: [] });
|
||||
if (path.endsWith('/triage/route')) return json({ route: null });
|
||||
return real(input, init);
|
||||
};
|
||||
})();`;
|
||||
|
||||
async function setup(t, { path, viewport = [1440, 900], fixture = {}, stub = {} } = {}) {
|
||||
const { organizations, agentLevels } = await orgFixture(fixture);
|
||||
const server = await startServer({ port: 0, sso: createDevOwner(), organizations, agentLevels, triage: null, send: async () => ({}), log: () => {} });
|
||||
t.after(() => close(server));
|
||||
const b = await browser({ machine: false }); t.after(() => b.close());
|
||||
await b.viewport(...viewport);
|
||||
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: ownerStub(stub) });
|
||||
await b.navigate(`http://127.0.0.1:${server.address().port}${path}`);
|
||||
const wait = expression => b.evaluate(`(async()=>{for(let i=0;i<250;i++){if(${expression})return true;await new Promise(r=>setTimeout(r,30))}throw Error("wait failed: "+${JSON.stringify(expression)}+" HASH "+location.hash)})()`);
|
||||
const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.textContent ?? null`);
|
||||
const click = sel => b.evaluate(`(() => { const el = document.querySelector(${JSON.stringify(sel)}); if (!el) throw Error("no ${sel.replace(/"/g, '')}"); el.click(); return true; })()`);
|
||||
return { b, wait, text, click };
|
||||
}
|
||||
const mark = id => `document.querySelector('[data-workspace-org=${id}] .ws-dot')?.title`;
|
||||
const STEP3 = '#setup-step-organizations [data-step-summary]';
|
||||
|
||||
// ---- Organization > Models --------------------------------------------------------------------
|
||||
test('settings-s5: Acme Studio\'s models reads which choice is in force from the plugins read, switches to your models and back', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-source") && document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
assert.equal(await text('#settings-page-title'), "Acme Studio's models");
|
||||
assert.equal(await text('#models-source legend'), 'Where Acme Studio gets its models');
|
||||
// Review P2-2: the header says where the models come from only from the plugins read.
|
||||
assert.match(await text('.settings-helper'), /The models Acme Studio's agents use\. They come from its own organization file\./);
|
||||
assert.doesNotMatch(await text('.settings-helper'), /your accounts/);
|
||||
// Not in force: the radio is not checked, and the line says what is in force and what a switch changes.
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), false);
|
||||
assert.equal(await text('#models-in-force'), "Now: Acme Studio does not use your models. Its agents use only the models in its own organization file.");
|
||||
assert.match(await text('#models-change'), /^Choose Use your models to switch\. Acme Studio's agents can then use the models your accounts offer\./);
|
||||
// Use its own model service: dashed, disabled, Coming later.
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-own").disabled'), true);
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-own").closest("label").classList.contains("off")'), true);
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-own").closest("label").querySelector(".badge").textContent'), 'Coming later');
|
||||
assert.match(await b.evaluate('document.querySelector("#models-own").closest("label").textContent'), /Planned, not built yet, so you can't choose it today\./);
|
||||
assert.equal(await b.evaluate('getComputedStyle(document.querySelector("#models-own").closest("label")).borderTopStyle'), 'dashed');
|
||||
// The old button is gone.
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#provider-switch")'), false);
|
||||
|
||||
// Switch to your models: one write, the model-provider list only, with cliproxy added.
|
||||
await click('#models-yours');
|
||||
await wait('window.__sets.length === 1');
|
||||
assert.deepEqual(await b.evaluate('window.__sets[0].body'), { revision: REV_B, plugins: { 'model-provider': ['fixture', 'cliproxy'] } });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses your models")');
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), true);
|
||||
assert.match(await text('#models-receipt'), /^Saved\. Acme Studio uses your models\./);
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-receipt").classList.contains("settings-success")'), true);
|
||||
assert.match(await text('#models-change'), /Stop using your models/);
|
||||
// Review P2-4: focus moves to the Saved line.
|
||||
await wait('document.activeElement?.id === "models-receipt"');
|
||||
await wait('/They come from your accounts in Model setup\./.test(document.querySelector(".settings-helper")?.textContent ?? "")');
|
||||
|
||||
// And back: Stop using your models removes cliproxy and keeps the other module.
|
||||
await click('#models-stop');
|
||||
await wait('window.__sets.length === 2');
|
||||
assert.deepEqual(await b.evaluate('window.__sets[1].body.plugins'), { 'model-provider': ['fixture'] });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use your models")');
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), false);
|
||||
assert.match(await text('#models-receipt'), /^Saved\. Acme Studio no longer uses your models\./);
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#models-stop")'), false);
|
||||
await wait('document.activeElement?.id === "models-receipt"');
|
||||
});
|
||||
const REV_B = REV('b');
|
||||
|
||||
test('settings-s5: a refused switch says so and the page keeps the choice the read shows', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { setStatus: 409 } });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
await click('#models-yours');
|
||||
await wait('window.__sets.length === 1 && /refused/.test(document.querySelector("#models-receipt")?.textContent ?? "")');
|
||||
assert.equal(await text('#models-receipt'), 'Not changed. The bus refused the change (plugins-refused).');
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked'), false);
|
||||
assert.match(await text('#models-in-force'), /does not use your models/);
|
||||
});
|
||||
|
||||
test('settings-s5: a stale page does not write, it shows the current choice first', { timeout: 90000 }, async t => {
|
||||
const { b, wait, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
// Someone else switched Acme Studio on since the page read it.
|
||||
await b.evaluate('__s5.plugins = { ...__s5.plugins, plugins: { ...__s5.plugins.plugins, "model-provider": ["fixture", "cliproxy"] } }; true');
|
||||
await click('#models-yours');
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses your models")');
|
||||
assert.equal(await b.evaluate('window.__sets.length'), 0);
|
||||
assert.match(await b.evaluate('document.querySelector("#models-receipt").textContent'), /changed since this page read it/);
|
||||
});
|
||||
|
||||
test('settings-s5: while the plugins read is out the choice waits, and a failed read says so with Read again', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { plugins: { broken: true } } });
|
||||
await wait('/could not be read/.test(document.querySelector("#models-in-force")?.textContent ?? "")');
|
||||
assert.equal(await text('#models-in-force'), "Which models Acme Studio uses could not be read.");
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-yours").disabled'), true);
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#models-read")'), true);
|
||||
});
|
||||
|
||||
test('settings-s5: an organization that needs a restart shows the banner with Restart as the one primary, and the choice waits', { timeout: 90000 }, async t => {
|
||||
const routes = { acme: { catalogue: { status: 'unavailable', notices: [], models: [] } } };
|
||||
const { b, wait, text } = await setup(t, { path: '/#/settings/routing?org=acme', fixture: { routes }, stub: { plugins: pluginsRead(['fixture', 'cliproxy']) } });
|
||||
await wait('document.querySelector("#routes-catalogue.banner [data-primary]") && document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses")');
|
||||
assert.match(await text('#routes-catalogue'), /Acme Studio can't see your models yet\./);
|
||||
assert.match(await text('#routes-catalogue [data-primary]'), /Restart Acme Studio/);
|
||||
// The banner sits above the choice.
|
||||
assert.equal(await b.evaluate('!!(document.querySelector("#routes-catalogue").compareDocumentPosition(document.querySelector("#models-source")) & Node.DOCUMENT_POSITION_FOLLOWING)'), true);
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-yours").checked && document.querySelector("#models-yours").disabled'), true);
|
||||
assert.equal(await text('#models-wait'), "You can change Acme Studio's models after it restarts.");
|
||||
// Review P2-1: Stop using your models waits too: it is not offered until the restart.
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#models-stop")'), false);
|
||||
// One primary: the routes Save is quiet.
|
||||
assert.equal(await b.evaluate('document.querySelector("#routes-form [type=submit]").classList.contains("route-save-quiet")'), true);
|
||||
});
|
||||
|
||||
// Review P2-3: a choice not in force says when the model service behind it is not set up or not
|
||||
// answering, with a link to Model setup. The choice itself still writes.
|
||||
test('settings-s5: Use your models says when the model service is not set up or not answering', { timeout: 90000 }, async t => {
|
||||
for (const [service, line, link] of [
|
||||
[{ ...SERVICE_UP, init: { initialized: false, partial: false, problem: null, files: [] } }, "Your model service isn't set up. Set it up in Model setup.", 'Set it up in Model setup'],
|
||||
[SERVICE_DOWN, "Your model service isn't answering. Restart it in Model setup.", 'Restart it in Model setup'],
|
||||
]) {
|
||||
const { b, wait, text } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { service } });
|
||||
await wait('document.querySelector("#models-service") && document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
assert.equal(await text('#models-service'), line);
|
||||
assert.deepEqual(await b.evaluate('[document.querySelector("#models-service a").textContent, document.querySelector("#models-service a").getAttribute("href")]'), [link, '#/settings/model-setup']);
|
||||
assert.equal(await b.evaluate('document.querySelector("#models-yours").disabled'), false);
|
||||
}
|
||||
// Up and answering: no line.
|
||||
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
await new Promise(r => setTimeout(r, 300));
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#models-service")'), false);
|
||||
});
|
||||
|
||||
// Review P3-1: while Use your models writes, the status line says Saving.
|
||||
test('settings-s5: Use your models shows Saving while its write is out', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
await b.evaluate(`(() => { const f = window.fetch; window.fetch = async (input, init = {}) => { if ((init.method || 'GET') !== 'GET' && String(input).endsWith('/proxy/plugins/set')) await new Promise(r => { window.__release = r; }); return f(input, init); }; return true; })()`);
|
||||
await click('#models-yours');
|
||||
await wait('typeof window.__release === "function" && document.querySelector("#models-receipt")?.textContent.trim() === "Saving…"');
|
||||
assert.equal((await text('#models-receipt')).trim(), 'Saving…');
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#models-receipt .settings-spinner")'), true);
|
||||
await b.evaluate('window.__release(); true');
|
||||
await wait('/^Saved\./.test(document.querySelector("#models-receipt")?.textContent ?? "")');
|
||||
});
|
||||
|
||||
// Recheck N1: the not set up line goes once the owner sets the service up and comes back to Models.
|
||||
test('settings-s5: coming back to Models after setting the service up reads it again, and the not set up line goes', { timeout: 90000 }, async t => {
|
||||
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { service: { ...SERVICE_UP, init: { initialized: false, partial: false, problem: null, files: [] } } } });
|
||||
await wait('document.querySelector("#models-service") && document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
await b.evaluate(`window.__s5.service = ${JSON.stringify(SERVICE_UP)}; location.hash = '#/settings/agents?org=acme'; true`);
|
||||
await wait('location.hash.startsWith("#/settings/agents") && !document.querySelector("#models-in-force") && document.querySelector("#settings-page-title")');
|
||||
await b.evaluate(`location.hash = '#/settings/routing?org=acme'; true`);
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use") && !document.querySelector("#models-service")');
|
||||
});
|
||||
|
||||
// Recheck N2: a switch left while it writes does not move focus on the next visit to Models.
|
||||
test('settings-s5: leaving Models while a switch writes, the next visit focuses the page title, not the outcome line', { timeout: 90000 }, async t => {
|
||||
const { b, wait, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
await b.evaluate(`(() => { const f = window.fetch; window.fetch = async (input, init = {}) => { if ((init.method || 'GET') !== 'GET' && String(input).endsWith('/proxy/plugins/set')) await new Promise(r => { window.__release = r; }); return f(input, init); }; return true; })()`);
|
||||
await click('#models-yours');
|
||||
await wait('typeof window.__release === "function"');
|
||||
await b.evaluate(`location.hash = '#/settings/agents?org=acme'; true`);
|
||||
await wait('location.hash.startsWith("#/settings/agents") && !document.querySelector("#models-in-force") && document.querySelector("#settings-page-title")');
|
||||
await b.evaluate('window.__release(); true');
|
||||
await wait('window.__sets.length === 1');
|
||||
await new Promise(r => setTimeout(r, 400));
|
||||
await b.evaluate(`location.hash = '#/settings/routing?org=acme'; true`);
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("uses your models") && /^Saved\./.test(document.querySelector("#models-receipt")?.textContent ?? "")');
|
||||
await new Promise(r => setTimeout(r, 300));
|
||||
assert.equal(await b.evaluate('document.activeElement?.id'), 'settings-page-title');
|
||||
});
|
||||
|
||||
// Review P3-2: a failed read before the write says nothing was written, and offers Read again.
|
||||
test('settings-s5: a switch whose first read fails says Not changed, not Outcome unknown', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
await b.evaluate('__s5.plugins = { broken: true }; true');
|
||||
await click('#models-yours');
|
||||
await wait('/^Not changed/.test(document.querySelector("#models-receipt")?.textContent ?? "")');
|
||||
assert.equal(await text('#models-receipt'), 'Not changed. Nothing was written.');
|
||||
assert.equal(await b.evaluate('window.__sets.length'), 0);
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#models-read")'), true);
|
||||
assert.equal(await text('#models-in-force'), 'Which models Acme Studio uses could not be read.');
|
||||
});
|
||||
|
||||
test('settings-s5: at 390 the Models page does not scroll sideways and the choice takes a visible focus', { timeout: 90000 }, async t => {
|
||||
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme', viewport: [390, 844] });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
assert.equal(await b.evaluate('document.documentElement.scrollWidth <= document.documentElement.clientWidth'), true);
|
||||
await b.evaluate('document.querySelector("#models-yours").focus(); true');
|
||||
assert.notEqual(await b.evaluate('getComputedStyle(document.activeElement).outlineStyle'), 'none');
|
||||
});
|
||||
|
||||
// Review P3-4: at 1440 the choice cards sit in the form column, not the whole card width.
|
||||
test('settings-s5: at 1440 the choice sits in the form column', { timeout: 90000 }, async t => {
|
||||
const { b, wait } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
const [choice, panel] = await b.evaluate('[document.querySelector("#models-source").getBoundingClientRect().width, document.querySelector(".routing-panel").getBoundingClientRect().width]');
|
||||
assert.ok(choice <= 448 + 1 && panel > choice + 200, `${choice} in ${panel}`);
|
||||
});
|
||||
|
||||
// ---- Sidebar marks follow a switch -------------------------------------------------------------
|
||||
test('settings-s5: the sidebar marks read the setup status again after an organization stops using your models', { timeout: 90000 }, async t => {
|
||||
const paused = { ...SERVICE_DOWN, ride: [{ id: 'acme', state: 'already' }] };
|
||||
const after = { ...SERVICE_DOWN, ride: [{ id: 'acme', state: 'removed' }] };
|
||||
const { wait, click } = await setup(t, { path: '/#/settings/routing?org=acme', stub: { service: paused, plugins: pluginsRead(['fixture', 'cliproxy']), afterSet: after } });
|
||||
await wait(`${mark('acme')} === 'paused' && document.querySelector("#models-stop")`);
|
||||
await click('#models-stop');
|
||||
await wait(`window.__sets.length === 1 && ${mark('acme')} === 'bus running'`);
|
||||
});
|
||||
|
||||
// ---- Model setup: display names, step 3 and the mark ------------------------------------------
|
||||
test('settings-s5: Move, its result and the skipped lines name the organization by its display name, in the Ride line\'s words', { timeout: 90000 }, async t => {
|
||||
const service = { ...SERVICE_UP, organizations: [{ id: 'acme', proxy: 'shared', catalogue: { status: 'ready' } }],
|
||||
ride: [{ id: 'acme', state: 'already' }, { id: 'north', state: 'bus-down' }, { id: 'gamma', state: 'fixture', running: false }] };
|
||||
const moved = { ...service, ride: [{ id: 'acme', state: 'already' }, { id: 'north', state: 'bus-down' }, { id: 'gamma', state: 'already' }] };
|
||||
const accounts = [{ accountId: 'a1', provider: 'claude', displayName: 'Claude work', status: 'active', priority: 1 }];
|
||||
const { b, wait, text, click } = await setup(t, { path: '/#/settings/model-setup', stub: { service, accounts, posts: { '/admin/ride-move': { body: { moved: true, model: 'Claude Sonnet 5.5', receipt: { op: 'ride-move', time: '2026-11-19T10:00:00.000Z' } }, service: moved } } } });
|
||||
await wait('document.querySelector("[data-ride-move=gamma]")');
|
||||
assert.equal(await text('#proxy-ride-skips li'), 'Skipped North Works: Its bus is not running. Start it, then ride again.');
|
||||
const item = await b.evaluate('document.querySelector("#proxy-ride-fixtures li").firstChild.textContent.trim()');
|
||||
assert.equal(item, "Gamma Home can't start: it uses stand-in models and its bus is stopped. Move it to your models under Use your models in every organization, then start its bus.");
|
||||
// Step 3 uses the same words.
|
||||
assert.match(await text(STEP3), /Gamma Home can't start: it uses stand-in models and its bus is stopped\. Move it to your models under Use your models in every organization, then start its bus\./);
|
||||
await click('[data-ride-move=gamma]');
|
||||
await wait('window.__confirms.length === 1');
|
||||
assert.match(await b.evaluate('window.__confirms[0]'), /^Move Gamma Home to your models\?/);
|
||||
await wait('/now uses/.test(document.querySelector("#proxy-ride-message")?.textContent ?? "")');
|
||||
assert.equal(await text('#proxy-ride-message'), 'Gamma Home now uses Claude Sonnet 5.5. Start its bus when you are ready. It spends real tokens from now on.');
|
||||
});
|
||||
|
||||
test('settings-s5: a Move that is refused names the organization by its display name', { timeout: 90000 }, async t => {
|
||||
const service = { ...SERVICE_UP, ride: [{ id: 'gamma', state: 'fixture', running: false }] };
|
||||
const accounts = [{ accountId: 'a1', provider: 'claude', displayName: 'Claude work', status: 'active', priority: 1 }];
|
||||
const { wait, text, click } = await setup(t, { path: '/#/settings/model-setup', stub: { service, accounts, posts: { '/admin/ride-move': { body: { moved: false, reason: 'bus-down' } } } } });
|
||||
await wait('document.querySelector("[data-ride-move=gamma]")');
|
||||
await click('[data-ride-move=gamma]');
|
||||
await wait('/not moved/.test(document.querySelector("#proxy-ride-message")?.textContent ?? "")');
|
||||
assert.equal(await text('#proxy-ride-message'), 'Gamma Home was not moved. Its bus is not running. Start it, then ride again.');
|
||||
});
|
||||
|
||||
test('settings-s5: before the first account, step 3 names the organization the sidebar marks "can\'t start"', { timeout: 90000 }, async t => {
|
||||
const service = { ...SERVICE_UP, ride: [{ id: 'gamma', state: 'fixture', running: false }] };
|
||||
const { b, wait, text } = await setup(t, { path: '/#/settings/model-setup', stub: { service, accounts: [] } });
|
||||
await wait(`${mark('gamma')} === "can't start" && document.querySelector("#setup-step-organizations")?.dataset.state`);
|
||||
await wait(`/Gamma Home/.test(document.querySelector(${JSON.stringify(STEP3)})?.textContent ?? "")`);
|
||||
assert.equal(await text(STEP3), "Opens after your first account. Gamma Home can't start now: it uses stand-in models and its bus is stopped. After your first account, move it to your models under Use your models in every organization, then start its bus.");
|
||||
// The card stays closed until there is an account to move it with, and its badge carries the mark's word.
|
||||
assert.equal(await b.evaluate('document.querySelector("#setup-step-organizations").dataset.state'), 'wait');
|
||||
assert.equal(await text('#setup-step-organizations [data-step-badge]'), "Can't start");
|
||||
assert.equal(await b.evaluate('document.querySelector("#setup-step-organizations [data-step-badge]").classList.contains("badge-danger")'), true); // The empty account list reads as one line, not squeezed into the name column.
|
||||
assert.equal(await b.evaluate('(() => { const li = document.querySelector("#proxy-accounts li.muted"); const r = document.createRange(); r.selectNodeContents(li); return li.textContent === "No accounts yet." && r.getClientRects().length === 1; })()'), true);
|
||||
});
|
||||
|
||||
test('settings-s5: Technical details and Advanced show the port and timeouts the status read carries', { timeout: 90000 }, async t => {
|
||||
const { b, wait } = await setup(t, { path: '/#/settings/model-setup' });
|
||||
await wait('document.querySelector("#proxy-setup-state dd")');
|
||||
const rows = await b.evaluate('Object.fromEntries([...document.querySelectorAll("#proxy-setup-state dt")].map(dt => [dt.textContent, dt.nextElementSibling.textContent]))');
|
||||
assert.equal(rows.Initialized, 'Yes, port 18432, wait for a first answer 90 seconds, old key kept 30 minutes after a new one');
|
||||
const advanced = await b.evaluate('Object.fromEntries([...document.querySelectorAll("#proxy-setup-settings dt")].map(dt => [dt.textContent, dt.nextElementSibling.textContent]))');
|
||||
assert.deepEqual(advanced, { Port: '18432', 'Wait for a first answer': '90 seconds', 'Old key kept after a new one': '30 minutes' });
|
||||
});
|
||||
|
||||
test('settings-s5: timeouts init left at the default read as the default', { timeout: 90000 }, async t => {
|
||||
const service = { ...SERVICE_UP, init: { ...SERVICE_UP.init, settings: { port: 18432, rotateGraceMinutes: null, firstOutputSeconds: null } } };
|
||||
const { b, wait } = await setup(t, { path: '/#/settings/model-setup', stub: { service } });
|
||||
await wait('document.querySelector("#proxy-setup-state dd")');
|
||||
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup-state dt")].find(dt => dt.textContent === "Initialized").nextElementSibling.textContent'),
|
||||
'Yes, port 18432, wait for a first answer: the default, old key kept after a new one: the default');
|
||||
const advanced = await b.evaluate('Object.fromEntries([...document.querySelectorAll("#proxy-setup-settings dt")].map(dt => [dt.textContent, dt.nextElementSibling.textContent]))');
|
||||
assert.deepEqual(advanced, { Port: '18432', 'Wait for a first answer': 'The default', 'Old key kept after a new one': 'The default' });
|
||||
});
|
||||
|
||||
// ---- Messages and the old Members addresses ---------------------------------------------------
|
||||
test('settings-s5: a failed turn in Messages shows its cause, and "Details:" once', { timeout: 90000 }, async t => {
|
||||
const messages = [{ id: 'm1', from_role: 'chief', to_role: 'human', class: 'reply', at: '2026-11-19T10:00:00.000Z', read: true,
|
||||
body: 'The turn failed: Acme Studio can\'t see your models yet. Restart it in Settings.\nDetails: model-catalogue-unavailable' }];
|
||||
const { b, wait } = await setup(t, { path: '/#/orgs/acme/messages', fixture: { messages } });
|
||||
await wait('document.querySelector(".s1-message")');
|
||||
const shown = await b.evaluate('document.querySelector(".s1-message").textContent');
|
||||
assert.equal(shown.match(/Details:/g)?.length, 1, shown);
|
||||
assert.match(shown, /^The assistant couldn't reply: Acme Studio can't see your models yet\. Restart it in Settings\.Details: model-catalogue-unavailable$/);
|
||||
});
|
||||
|
||||
test('settings-s5: a failed turn without a Details part keeps the general line', { timeout: 90000 }, async t => {
|
||||
const messages = [{ id: 'm1', from_role: 'chief', to_role: 'human', class: 'reply', at: '2026-11-19T10:00:00.000Z', read: true, body: 'The turn failed: spawn-refused' }];
|
||||
const { b, wait } = await setup(t, { path: '/#/orgs/acme/messages', fixture: { messages } });
|
||||
await wait('document.querySelector(".s1-message")');
|
||||
assert.equal(await b.evaluate('document.querySelector(".s1-message").textContent'), "The assistant couldn't reply. Try again, or check Agents.Details: spawn-refused");
|
||||
});
|
||||
|
||||
test('settings-s5: #/settings/members and #/orgs/<id>/settings/members land on that organization\'s Agents page', { timeout: 90000 }, async t => {
|
||||
const { b, wait } = await setup(t, { path: '/#/orgs/north/settings/members' });
|
||||
await wait('location.hash === "#/settings/agents?org=north" && document.querySelector("#settings-nav a[href=\'#/settings/agents?org=north\'][aria-current=page]")');
|
||||
await b.evaluate('location.hash = "#/settings/members"; true');
|
||||
await wait('location.hash === "#/settings/agents?org=north" && document.querySelector("#settings-page-title")?.textContent === "Agents"');
|
||||
});
|
||||
|
||||
// Shots for the build report, beside the mockups: run with MOSAIC_UX_SHOTS=<dir>. Each page is shot whole
|
||||
// at 390 and 1440, light and dark, and measured: nothing scrolls sideways, and every control Tab reaches
|
||||
// shows a focus ring.
|
||||
test('shots', { timeout: 900000, skip: !process.env.MOSAIC_UX_SHOTS }, async t => {
|
||||
const { mkdir, writeFile } = await import('node:fs/promises');
|
||||
const { join } = await import('node:path');
|
||||
const dir = process.env.MOSAIC_UX_SHOTS; await mkdir(dir, { recursive: true });
|
||||
const settle = () => new Promise(r => setTimeout(r, 1000));
|
||||
const reasons = [
|
||||
{ accountId: 'a1', provider: 'claude', displayName: 'Claude work', status: 'unavailable', priority: 2, reason: 'The account is out of usage. It resets at 2026-11-20 05:00 UTC. Wait until then, or add another account.' },
|
||||
{ accountId: 'a2', provider: 'codex', displayName: 'Codex home', status: 'error', priority: 1, reason: 'The account needs to sign in again. Sign in again, or add another account.' },
|
||||
{ accountId: 'a3', provider: 'codex', displayName: 'Codex work', status: 'active', priority: 0 },
|
||||
];
|
||||
const failed = [{ id: 'm1', from_role: 'chief', to_role: 'human', class: 'reply', at: '2026-11-19T10:00:00.000Z', read: true,
|
||||
body: 'The turn failed: Acme Studio can\'t see your models yet. Restart it in Settings.\nDetails: model-catalogue-unavailable' }];
|
||||
const PAGES = [
|
||||
{ name: 'org-models', path: '/#/settings/routing?org=acme', ready: 'document.querySelector("#models-in-force")?.textContent.includes("does not use")' },
|
||||
{ name: 'org-models-riding', path: '/#/settings/routing?org=acme', ready: 'document.querySelector("#models-in-force")?.textContent.includes("does not use")',
|
||||
after: async (b, wait) => { await b.evaluate('document.querySelector("#models-yours").click(); true'); await wait('/^Saved/.test(document.querySelector("#models-receipt")?.textContent ?? "")'); } },
|
||||
{ name: 'org-models-not-set-up', path: '/#/settings/routing?org=acme', stub: { service: { ...SERVICE_UP, init: { initialized: false, partial: false, problem: null, files: [] } } },
|
||||
ready: 'document.querySelector("#models-service") && document.querySelector("#models-in-force")?.textContent.includes("does not use")' },
|
||||
{ name: 'org-models-restart', path: '/#/settings/routing?org=acme', fixture: { routes: { acme: { catalogue: { status: 'unavailable', notices: [], models: [] } } } }, stub: { plugins: pluginsRead(['fixture', 'cliproxy']) },
|
||||
ready: 'document.querySelector("#routes-catalogue.banner [data-primary]") && document.querySelector("#models-in-force")?.textContent.startsWith("Now: Acme Studio uses")' },
|
||||
{ name: 'account-reasons', path: '/#/settings/model-setup?step=accounts', stub: { accounts: reasons }, ready: 'document.querySelectorAll("#proxy-accounts .account-reason").length === 2' },
|
||||
{ name: 'step3-cant-start', path: '/#/settings/model-setup', stub: { service: { ...SERVICE_UP, ride: [{ id: 'gamma', state: 'fixture', running: false }] }, accounts: [] },
|
||||
ready: `/Gamma Home/.test(document.querySelector(${JSON.stringify(STEP3)})?.textContent ?? "")` },
|
||||
{ name: 'technical-details', path: '/#/settings/model-setup', ready: 'document.querySelector("#proxy-setup-state dd")',
|
||||
after: async b => { await b.evaluate('document.querySelector("#proxy-setup-advanced").open = true; document.querySelector("#proxy-setup-tech").open = true; true'); } },
|
||||
{ name: 'messages-details', path: '/#/orgs/acme/messages', fixture: { messages: failed }, ready: 'document.querySelector(".s1-message")' },
|
||||
];
|
||||
const report = [];
|
||||
for (const page of PAGES) for (const scheme of ['light', 'dark']) for (const width of [390, 1440]) {
|
||||
const { b, wait } = await setup(t, { path: page.path, fixture: page.fixture, stub: page.stub, viewport: [width, width === 390 ? 844 : 900] });
|
||||
await b.call('Emulation.setScrollbarsHidden', { hidden: true });
|
||||
await b.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: scheme }] });
|
||||
await wait(`(${page.ready}) && !!window.MosaicAppearance`);
|
||||
await b.evaluate(`window.MosaicAppearance.ready.then(() => window.MosaicAppearance.set({ mode: ${JSON.stringify(scheme)} }))`);
|
||||
if (page.after) await page.after(b, wait, width);
|
||||
await settle();
|
||||
const sideways = await b.evaluate('document.documentElement.scrollWidth > document.documentElement.clientWidth');
|
||||
const noRing = [], seen = new Set();
|
||||
for (let i = 0; i < 120; i++) {
|
||||
await b.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
|
||||
await b.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
|
||||
const r = await b.evaluate(`(() => { const e = document.activeElement; if (!e || e === document.body) return null; const cs = getComputedStyle(e);
|
||||
const ring = (cs.outlineStyle !== 'none' && parseFloat(cs.outlineWidth) > 0) || (cs.boxShadow && cs.boxShadow !== 'none');
|
||||
return { key: e.id || e.getAttribute('href') || e.tagName + ':' + (e.textContent || '').trim().slice(0, 30), ring }; })()`);
|
||||
if (!r || seen.has(r.key)) break; seen.add(r.key);
|
||||
if (!r.ring) noRing.push(r.key);
|
||||
}
|
||||
await b.evaluate('document.activeElement?.blur(); window.scrollTo(0, 0); true'); await settle();
|
||||
const shot = `${page.name}-${width}-${scheme}.png`;
|
||||
let metrics = await b.call('Page.getLayoutMetrics'), size = metrics.cssContentSize || metrics.contentSize;
|
||||
await b.viewport(width, Math.ceil(size.height)); await settle();
|
||||
metrics = await b.call('Page.getLayoutMetrics'); size = metrics.cssContentSize || metrics.contentSize;
|
||||
const { data } = await b.call('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true, clip: { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height), scale: 1 } });
|
||||
await writeFile(join(dir, shot), Buffer.from(data, 'base64'));
|
||||
report.push({ page: page.name, width, scheme, shot, sideways, noRing });
|
||||
await b.close();
|
||||
}
|
||||
await writeFile(join(dir, 'measure.json'), JSON.stringify(report, null, 1));
|
||||
for (const r of report) {
|
||||
assert.equal(r.sideways, false, `${r.shot} scrolls sideways`);
|
||||
assert.deepEqual(r.noRing, [], `${r.shot}: controls with no visible focus ring`);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,516 @@
|
||||
// #1873 settings-s5b (DESIGN.md 3.1, mockups models-setup-failed and models-advanced): Model setup
|
||||
// shows the service's last lines (GET /api/proxy/admin/log) on step 1 when setup stopped and under
|
||||
// Technical details, when the service key was made (GET /api/proxy/admin/service-key), and the setup
|
||||
// history a page at a time (GET /api/proxy/admin/history). All three are the instance owner's: a page
|
||||
// without proxyAdmin shows none of them and sends no /api/proxy/admin/ request. Also: a focus request
|
||||
// for an organization's Models outcome line is dropped when the owner goes to any other page.
|
||||
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 { browser } from './browser.mjs';
|
||||
import { close } from './fixture.mjs';
|
||||
|
||||
const LIST = [
|
||||
{ id: 'acme', label: 'Acme Studio', theme: 'cobalt', busHealthy: true },
|
||||
{ id: 'gamma', label: 'Gamma Home', theme: 'rosewood', busHealthy: true },
|
||||
];
|
||||
const VIEW = {
|
||||
business: 'acme', revision: 'a'.repeat(64), harnesses: ['pi'], models: ['fixture-deterministic'],
|
||||
providerModels: { 'fixture-deterministic': { module: 'fixture', upstream: 'fixture', model: 'fixture-deterministic' } },
|
||||
levels: { pi: ['off', 'low'] }, instances: {}, catalogue: { status: 'ready', observedAt: new Date().toISOString(), models: [], notices: [] },
|
||||
};
|
||||
|
||||
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 empty = () => Promise.resolve([]);
|
||||
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: () => ({ bus: { inbox: empty, agents: empty, 'thread.claims': empty, tasks: empty, usage: () => Promise.resolve({}), limits: () => Promise.resolve({}), decisions: empty }, chat: { threads: empty, projects: empty } }),
|
||||
});
|
||||
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: {} }), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
|
||||
bus: { messages: async () => ({ messages: [], unread: 0, total: 0 }), agents: empty, 'thread.claims': empty, inbox: empty, tasks: empty, usage: async () => ({}), routes: async () => ({ ...VIEW, business: id }), instances: async () => ({ business: id, revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }) },
|
||||
chat: { projects: empty, threads: empty },
|
||||
};
|
||||
},
|
||||
};
|
||||
return { organizations, agentLevels: { loadRoot: () => root, rolesDir, ctx: { configDir: '/cfg', dataRoot: '/data', instance: 'test' } } };
|
||||
}
|
||||
|
||||
const T = n => `2026-11-19T10:0${n}:00.000Z`;
|
||||
const SERVICE_UP = { next: ['accounts'], init: { initialized: true, partial: false, problem: null, settings: { port: 18432, rotateGraceMinutes: 30, firstOutputSeconds: 90 }, files: [] },
|
||||
release: { fetched: true, verified: true, version: '8.0.42', panelVersion: '1.26.7' },
|
||||
unit: { unit: 'mosaic-proxy.service', installed: true, active: 'active', port: 18432, listening: true, healthy: true }, fence: { set: false }, initLock: { present: false, blockers: [] }, fetch: { state: 'idle' }, organizations: [], ride: [] };
|
||||
// Setup stopped: the download failed, so step 1 says so and opens the service's last lines.
|
||||
const SERVICE_FAILED = { ...SERVICE_UP, next: ['fetch'], release: { fetched: false, verified: false, version: '8.0.42', panelVersion: '1.26.7' },
|
||||
init: { initialized: false, partial: false, problem: null, files: [] }, unit: { unit: 'mosaic-proxy.service', installed: false, active: 'inactive' },
|
||||
fetch: { state: 'failed', error: 'proxy-install-invalid' } };
|
||||
// Setup stopped at the start step: the service is installed but did not answer, so the start was refused.
|
||||
const SERVICE_START = { ...SERVICE_UP, next: ['unit-start'], unit: { unit: 'mosaic-proxy.service', installed: true, active: 'inactive', port: 18432, listening: false, healthy: false } };
|
||||
const START_REFUSED = { 'POST unit/start': { status: 503, body: { error: 'proxy-unit-unhealthy' } } };
|
||||
const LOG_OK = { unit: 'mosaic-proxy.service', lines: ['Nov 19 10:00:01 host proxy[4242]: listening on 127.0.0.1:18432', 'Nov 19 10:00:02 host proxy[4242]: loaded key [redacted]'], redacted: 1, dropped: 2 };
|
||||
const KEY_OK = { madeAt: T(3), renewedAt: null, renewal: 'not-built', problem: null };
|
||||
// Three pages, newest first: the first holds four entries (one withheld), the second is empty but
|
||||
// names a third, and the third holds the oldest entry.
|
||||
const PAGE1 = { entries: [{ op: 'unit.start', time: T(4), user: 'jason' }, { op: 'init', time: T(5), user: '[redacted]' }, { withheld: true },
|
||||
{ op: 'account.proxy.apikey.add', time: T(7), org: 'acme', accountId: 'a1b2c3d4e5f6', user: 'jason' }], next: 3 };
|
||||
const PAGE2 = { entries: [], next: 1 };
|
||||
const PAGE3 = { entries: [{ op: 'ride-move', time: T(1), org: 'gamma', user: 'jason' }], next: null };
|
||||
const PAGES = { 'history?limit=25': PAGE1, 'history?limit=25&before=3': PAGE2, 'history?limit=25&before=1': PAGE3 };
|
||||
const LOG = 'log?lines=20';
|
||||
const OK = { [LOG]: LOG_OK, 'service-key': KEY_OK, ...PAGES };
|
||||
|
||||
// The instance owner's flags (or not), the setup status, and the three reads by name and query. An
|
||||
// answer may be a list: each read takes the next one and the last one stays. window.__admin records
|
||||
// every /api/proxy/admin/ request the page sends, window.__holds pauses a read by name, and window.__queue
|
||||
// pauses every request to a name, each until its own resolver runs. A write answers from admin['POST name'].
|
||||
const stub = ({ owner = true, service = SERVICE_UP, admin = OK } = {}) => `(() => {
|
||||
const real = window.fetch.bind(window);
|
||||
window.__s5b = ${JSON.stringify({ owner, service, admin })}; window.__admin = []; window.__writes = []; window.__holds = {}; window.__queue = {};
|
||||
const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
|
||||
window.fetch = async (input, init = {}) => {
|
||||
const url = new URL(typeof input === 'string' ? input : input.url, location.href), path = url.pathname, method = (init.method || 'GET').toUpperCase();
|
||||
const at = path.indexOf('/proxy/admin/');
|
||||
if (at >= 0) {
|
||||
const name = path.slice(at + 13) + url.search; window.__admin.push(method + ' ' + name);
|
||||
if (method !== 'GET') { window.__writes.push(path); const w = __s5b.admin[method + ' ' + name]; return w ? json(w.body, w.status) : json({ error: 'stub' }, 500); }
|
||||
if (name === 'status') return json(__s5b.service);
|
||||
if (window.__holds[name]) await new Promise(r => { window.__holds[name] = r; });
|
||||
if (window.__queue[name]) await new Promise(r => window.__queue[name].push(r));
|
||||
let a = __s5b.admin[name];
|
||||
if (Array.isArray(a)) a = a.length > 1 ? a.shift() : a[0];
|
||||
if (!a) return json({ error: 'fixture-unexpected-api' }, 403);
|
||||
return a.status ? json(a.body, a.status) : json(a);
|
||||
}
|
||||
if (method !== 'GET' && /\\/proxy\\//.test(path)) { window.__writes.push(path); return json({ error: 'stub' }, 500); }
|
||||
if (method !== 'GET') return real(input, init);
|
||||
if (/\\/api\\/(orgs\\/[^/]+\\/)?config$/.test(path)) { const c = await (await real(input, init)).json(); return json({ ...c, orgSetup: true, proxyAdmin: __s5b.owner, proxyAdminSend: __s5b.owner, ...(/\\/orgs\\//.test(path) ? { settingsSend: true } : {}) }); }
|
||||
if (path.endsWith('/proxy/plugins')) return json({ revision: 'b'.repeat(64), available: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] }, plugins: { harness: ['pi'], 'model-provider': ['fixture'] } });
|
||||
if (path.endsWith('/proxy/accounts')) return json({ accounts: [] });
|
||||
if (path.endsWith('/proxy/keys')) return json({ keys: [] });
|
||||
if (path.endsWith('/triage/route')) return json({ route: null });
|
||||
return real(input, init);
|
||||
};
|
||||
})();`;
|
||||
|
||||
async function setup(t, { path = '/#/settings/model-setup', viewport = [1440, 900], ...options } = {}) {
|
||||
const { organizations, agentLevels } = await orgFixture();
|
||||
const server = await startServer({ port: 0, sso: createDevOwner(), organizations, agentLevels, triage: null, send: async () => ({}), log: () => {} });
|
||||
t.after(() => close(server));
|
||||
const b = await browser({ machine: false }); t.after(() => b.close());
|
||||
await b.viewport(...viewport);
|
||||
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: stub(options) });
|
||||
await b.navigate(`http://127.0.0.1:${server.address().port}${path}`);
|
||||
const wait = expression => b.evaluate(`(async()=>{for(let i=0;i<250;i++){if(${expression})return true;await new Promise(r=>setTimeout(r,30))}throw Error("wait failed: "+${JSON.stringify(expression)}+" HASH "+location.hash)})()`);
|
||||
const text = sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.textContent ?? null`);
|
||||
const click = sel => b.evaluate(`(() => { const el = document.querySelector(${JSON.stringify(sel)}); if (!el) throw Error("no ${sel.replace(/"/g, '')}"); el.click(); return true; })()`);
|
||||
const reads = () => b.evaluate('window.__admin.filter(r => r !== "GET status")');
|
||||
return { b, wait, text, click, reads };
|
||||
}
|
||||
const READY = 'document.querySelector("#proxy-setup-state dd") && !document.querySelector("#setup-step-service").hidden';
|
||||
const openTech = b => b.evaluate('(() => { const d = document.querySelector("#proxy-setup-tech"); d.open = true; return true; })()');
|
||||
const items = b => b.evaluate('[...document.querySelectorAll("#proxy-setup-history li")].map(li => ({ text: li.textContent, hidden: li.hidden, withheld: li.hasAttribute("data-withheld") }))');
|
||||
const KEY_TEXT = /ms[kotp]-[A-Za-z0-9_-]{4,}/i;
|
||||
|
||||
// ---- Each part renders from its read ---------------------------------------------------------
|
||||
test('settings-s5b: Technical details shows when the service key was made, the service\'s last lines and the newest history, and reads none of them until it opens', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click, reads } = await setup(t);
|
||||
await wait(READY);
|
||||
await new Promise(r => setTimeout(r, 300));
|
||||
assert.deepEqual(await reads(), [], 'nothing is read before Technical details opens');
|
||||
await openTech(b);
|
||||
await wait('/Mosaic made it on/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "") && document.querySelectorAll("#proxy-setup-history li").length === 4');
|
||||
// The service key: when it was made, that renewal is not built, never the key.
|
||||
// It is the last row of the state list, after Release and Service, as models-advanced shows it.
|
||||
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup-state dt")].at(-1).textContent'), 'Service key');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-keymade-text").closest("dl").id'), 'proxy-setup-state');
|
||||
const key = await text('#proxy-setup-keymade-text');
|
||||
assert.match(key, /^Mosaic made it on .+\. You never see it\. Renewing it is not built yet\.$/);
|
||||
assert.equal(key.includes(await b.evaluate(`window.MosaicLocalTime(${JSON.stringify(T(3))})`)), true);
|
||||
// History, newest first, three shown with Show all; the withheld entry is a plain row.
|
||||
const list = await items(b);
|
||||
assert.deepEqual(list.map(i => i.hidden), [false, false, false, true]);
|
||||
assert.match(list[0].text, /^Account added in Acme Studio · .+ · by jason$/);
|
||||
assert.equal(list[1].text, 'Withheld. The Console kept this entry back because it may hold a secret.');
|
||||
assert.equal(list[1].withheld, true);
|
||||
assert.match(list[2].text, /^Set up · .+ · by someone whose name Mosaic hid$/);
|
||||
assert.match(list[3].text, /^Started · .+ · by jason$/);
|
||||
assert.equal(await text('#proxy-setup-history-all'), 'Show all');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), true);
|
||||
// The lines: read when their box opens, shown as the answer has them, with what was removed.
|
||||
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25']);
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech-lines").open = true; true');
|
||||
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
|
||||
assert.equal(await text('#proxy-setup-tech-lines summary'), 'The service\'s last lines');
|
||||
assert.equal(await text('#proxy-setup-tech-lines pre.setup-log'), LOG_OK.lines.join('\n'));
|
||||
assert.equal(await text('#proxy-setup-tech-lines [data-log] p'), 'Mosaic removes anything that looks like a key. It removed something from 1 line. 2 lines were left out.');
|
||||
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25', 'GET log?lines=20']);
|
||||
// Read again reads the lines once more.
|
||||
await click('#proxy-setup-tech-lines [data-log] button');
|
||||
await wait('window.__admin.filter(r => r === "GET log?lines=20").length === 2 && document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
|
||||
});
|
||||
|
||||
test('settings-s5b: when setup stops, step 1 opens the service\'s last lines from the log read', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, reads } = await setup(t, { service: SERVICE_START, admin: { ...OK, ...START_REFUSED } });
|
||||
await wait(READY + ' && document.querySelector("#proxy-setup-go") && !document.querySelector("#proxy-setup-go").hidden');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-go").click(); true');
|
||||
await wait('document.querySelector("#proxy-setup-lines pre.setup-log")');
|
||||
assert.deepEqual(await b.evaluate('window.__writes.map(p => p.slice(p.indexOf("/proxy/admin/") + 13))'), ['unit/start']);
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines").hidden'), false);
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines").open'), true);
|
||||
assert.equal(await text('#proxy-setup-lines pre.setup-log'), LOG_OK.lines.join('\n'));
|
||||
assert.match(await text('#proxy-setup-lines [data-log] p'), /^Mosaic removes anything that looks like a key\./);
|
||||
assert.doesNotMatch(await text('#proxy-setup-lines'), /can't read the service's lines yet|Nothing reported/);
|
||||
// The status read polls; the lines are read once, not on every paint.
|
||||
await new Promise(r => setTimeout(r, 1500));
|
||||
assert.deepEqual(await reads(), ['POST unit/start', 'GET log?lines=20']);
|
||||
});
|
||||
|
||||
test('settings-s5b: a service that is not installed has no lines, and step 1 says so plainly, not as a failed read', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text } = await setup(t, { service: SERVICE_FAILED, admin: { ...OK, [LOG]: { status: 503, body: { error: 'not-configured' } } } });
|
||||
await wait('document.querySelector("#proxy-setup-lines [data-log] p")');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines").open'), true);
|
||||
assert.equal(await text('#proxy-setup-lines [data-log] p'), 'The model service is not installed, so it has no lines yet.');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines [data-log] p").className'), 'small muted');
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#proxy-setup-lines .banner.err")'), false);
|
||||
assert.doesNotMatch(await text('#proxy-setup-lines'), /could not be read/);
|
||||
});
|
||||
|
||||
test('settings-s5b: a service key that is not made yet, or that cannot be checked, says so', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text } = await setup(t, { admin: { ...OK, 'service-key': [{ madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'missing' }, { madeAt: null, renewedAt: null, renewal: 'not-built', problem: 'unreadable' }] } });
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('/Not made yet/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "")');
|
||||
assert.equal(await text('#proxy-setup-keymade-text'), 'Not made yet. Set up model service in step 1 makes it. You never see it.');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
await openTech(b);
|
||||
await wait('/can.t tell/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "")');
|
||||
assert.match(await text('#proxy-setup-keymade-text'), /^Mosaic can't tell when it was made/);
|
||||
});
|
||||
|
||||
// ---- Failed reads -----------------------------------------------------------------------------
|
||||
test('settings-s5b: each failed read shows its line with Read again, and Read again works', { timeout: 90000 }, async t => {
|
||||
const fail = code => ({ status: 503, body: { error: code } });
|
||||
const { b, wait, text, click, reads } = await setup(t, { admin: { ...OK, [LOG]: [fail('outcome-unknown'), LOG_OK], 'service-key': [fail('not-configured'), KEY_OK], 'history?limit=25': [fail('outcome-unknown'), PAGE1] } });
|
||||
await wait(READY); await openTech(b);
|
||||
// The service key.
|
||||
await wait('document.querySelector("#proxy-setup-keymade-retry")');
|
||||
assert.equal(await text('#proxy-setup-keymade-text'), 'When it was made could not be read. Model service setup is not available on this Console. (not-configured)');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-keymade-text").className'), 'banner err', 'the same failure style as the history and the lines');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-keymade-retry").focus(); document.querySelector("#proxy-setup-keymade-retry").click(); true');
|
||||
await wait('/Mosaic made it on/.test(document.querySelector("#proxy-setup-keymade-text")?.textContent ?? "")');
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#proxy-setup-keymade-retry")'), false);
|
||||
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-keymade-text', 'focus stays on the answer, not the page');
|
||||
// History.
|
||||
await wait('!document.querySelector("#proxy-setup-history-retry").hidden');
|
||||
assert.equal(await text('#proxy-setup-history-message'), 'History could not be read. The host could not read the history. (outcome-unknown)');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-message").className'), 'banner err');
|
||||
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 0);
|
||||
await click('#proxy-setup-history-retry');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-retry").hidden'), true);
|
||||
assert.equal(await text('#proxy-setup-history-message'), '');
|
||||
// The lines.
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech-lines").open = true; true');
|
||||
await wait('document.querySelector("#proxy-setup-tech-lines [data-log] .banner.err")');
|
||||
assert.equal(await text('#proxy-setup-tech-lines [data-log] .banner.err'), 'The service\'s lines could not be read. The host could not read the service\'s lines. (outcome-unknown)');
|
||||
assert.equal(await b.evaluate('!!document.querySelector("#proxy-setup-tech-lines pre")'), false);
|
||||
await b.evaluate('(() => { const r = document.querySelector("#proxy-setup-tech-lines [data-log] button"); r.focus(); r.click(); return true; })()');
|
||||
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
|
||||
assert.equal(await b.evaluate('document.activeElement?.closest("[data-log]") !== null && document.activeElement.textContent === "Read again"'), true);
|
||||
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25', 'GET service-key', 'GET history?limit=25', 'GET log?lines=20', 'GET log?lines=20']);
|
||||
});
|
||||
|
||||
// ---- Owner only -------------------------------------------------------------------------------
|
||||
test('settings-s5b: a page that is not the instance owner\'s shows none of the three and sends no /api/proxy/admin/ request', { timeout: 90000 }, async t => {
|
||||
// The owner's page, as the control: the three parts are there and read.
|
||||
{
|
||||
const { b, wait } = await setup(t, { service: SERVICE_FAILED });
|
||||
await wait('document.querySelector("#proxy-setup-lines pre.setup-log")');
|
||||
await openTech(b);
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4 && /Mosaic made it/.test(document.querySelector("#proxy-setup-keymade-text").textContent)');
|
||||
}
|
||||
const { b, wait } = await setup(t, { owner: false, service: SERVICE_FAILED });
|
||||
await wait('window.MosaicProxy && document.querySelector("#proxy-setup") && document.querySelector("#settings-page-title")');
|
||||
await new Promise(r => setTimeout(r, 800));
|
||||
// Opening every box on the page, even the hidden ones, still reads nothing.
|
||||
await b.evaluate('document.querySelectorAll("#proxy-setup details").forEach(d => { d.open = true; }); true');
|
||||
await new Promise(r => setTimeout(r, 800));
|
||||
assert.deepEqual(await b.evaluate('window.__admin'), []);
|
||||
const shown = sel => b.evaluate(`(() => { const e = document.querySelector(${JSON.stringify(sel)}); return !!e && e.getClientRects().length > 0; })()`);
|
||||
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup dt")].some(d => d.textContent === "Service key")'), false);
|
||||
for (const sel of ['#proxy-setup-keymade-text', '#proxy-setup-keymade-retry', '#proxy-setup-tech-lines', '#proxy-setup-lines', '#proxy-setup-history', '#proxy-setup-history-message', '#proxy-setup-history-all'])
|
||||
assert.equal(await shown(sel), false, `${sel} is not shown`);
|
||||
assert.equal(await b.evaluate('document.querySelectorAll("[data-log] pre, [data-log] .banner, #proxy-setup-history li").length'), 0);
|
||||
});
|
||||
|
||||
// ---- History paging ---------------------------------------------------------------------------
|
||||
test('settings-s5b: history pages back one page at a time, shows each entry once, and an empty page with an older one still offers it', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click, reads } = await setup(t);
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
|
||||
await click('#proxy-setup-history-all');
|
||||
assert.deepEqual((await items(b)).map(i => i.hidden), [false, false, false, false]);
|
||||
assert.equal(await text('#proxy-setup-history-all'), 'Show fewer');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").getAttribute("aria-expanded")'), 'true');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
|
||||
// Two quick presses send one read.
|
||||
await b.evaluate('window.__holds["history?limit=25&before=3"] = true; true');
|
||||
await b.evaluate('(() => { const o = document.querySelector("#proxy-setup-history-older"); o.focus(); o.click(); o.click(); return true; })()');
|
||||
await wait('typeof window.__holds["history?limit=25&before=3"] === "function"');
|
||||
assert.equal(await text('#proxy-setup-history-older'), 'Reading…');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").disabled'), true);
|
||||
await b.evaluate('window.__holds["history?limit=25&before=3"](); true');
|
||||
// The empty page: no new entry, a line that says so, and Show older still there.
|
||||
await wait('/no entries to show/.test(document.querySelector("#proxy-setup-history-message").textContent)');
|
||||
assert.equal(await text('#proxy-setup-history-message'), 'That page of history had no entries to show. Show older reads further back.');
|
||||
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 4);
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
|
||||
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-older');
|
||||
// Folding the list keeps Show older, because the line above still names it.
|
||||
await click('#proxy-setup-history-all');
|
||||
assert.equal(await text('#proxy-setup-history-all'), 'Show all');
|
||||
assert.equal(await text('#proxy-setup-history-message'), 'That page of history had no entries to show. Show older reads further back.');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
|
||||
await click('#proxy-setup-history-all');
|
||||
await click('#proxy-setup-history-older');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 5');
|
||||
const list = await items(b);
|
||||
assert.match(list[4].text, /^Gamma Home switched to your models · .+ · by jason$/);
|
||||
assert.equal(new Set(list.map(i => i.text)).size, list.length, 'each entry once');
|
||||
// The last page: no Show older, focus goes to Show fewer, no empty-page line.
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), true);
|
||||
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-all');
|
||||
assert.equal(await text('#proxy-setup-history-message'), '');
|
||||
assert.deepEqual(await reads(), ['GET service-key', 'GET history?limit=25', 'GET history?limit=25&before=3', 'GET history?limit=25&before=1']);
|
||||
// Closing and opening Technical details starts from the newest page again.
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
await openTech(b);
|
||||
await wait('window.__admin.filter(r => r === "GET history?limit=25").length === 2 && document.querySelectorAll("#proxy-setup-history li").length === 4');
|
||||
assert.equal(await text('#proxy-setup-history-all'), 'Show all');
|
||||
});
|
||||
|
||||
test('settings-s5b: a history with no entries says so, and a first page that is empty but names an older one offers it', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click } = await setup(t, { admin: { ...OK, 'history?limit=25': [{ entries: [], next: null }, { entries: [], next: 1 }] } });
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('document.querySelector("#proxy-setup-history-message").textContent === "No setup history yet."');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").hidden'), true);
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
await openTech(b);
|
||||
await wait('/no entries to show/.test(document.querySelector("#proxy-setup-history-message").textContent)');
|
||||
// Nothing is folded away, so there is no Show all, and Show older is offered at once.
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").hidden'), true);
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
|
||||
await click('#proxy-setup-history-older');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 1');
|
||||
assert.match((await items(b))[0].text, /^Gamma Home switched to your models/);
|
||||
assert.equal(await text('#proxy-setup-history-message'), '');
|
||||
});
|
||||
|
||||
test('settings-s5b: a short first page offers Show older at once, and what it reads stays open', { timeout: 90000 }, async t => {
|
||||
const e = (op, n) => ({ op, time: T(n), user: 'jason' });
|
||||
const { b, wait, click } = await setup(t, { admin: { ...OK, 'history?limit=25': { entries: [e('unit.start', 8), e('unit.stop', 9)], next: 7 }, 'history?limit=25&before=7': { entries: [e('init', 4), e('unit.install', 5), e('unit.restart', 6)], next: null } } });
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 2');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").hidden'), true);
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-older").hidden'), false);
|
||||
await click('#proxy-setup-history-older');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 5');
|
||||
assert.deepEqual((await items(b)).map(i => i.hidden), [false, false, false, false, false], 'the older entries it read are shown');
|
||||
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-history-all").textContent'), 'Show fewer');
|
||||
});
|
||||
|
||||
test('settings-s5b: an older page that is not further back than the one asked for is not shown', { timeout: 90000 }, async t => {
|
||||
const { b, wait, text, click } = await setup(t, { admin: { ...OK, 'history?limit=25&before=3': [{ entries: [{ op: 'init', time: T(2), user: 'jason' }], next: 3 }, PAGE2] } });
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
|
||||
await click('#proxy-setup-history-all');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-history-older").focus(); document.querySelector("#proxy-setup-history-older").click(); true');
|
||||
await wait('!document.querySelector("#proxy-setup-history-retry").hidden');
|
||||
assert.match(await text('#proxy-setup-history-message'), /^History could not be read\./);
|
||||
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-history li").length'), 4, 'the repeated page adds nothing');
|
||||
// The pressed button went away, so focus lands on Read again.
|
||||
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-retry');
|
||||
// Read again answers; it goes away, and focus lands on Show older, not Show fewer.
|
||||
await b.evaluate('document.querySelector("#proxy-setup-history-retry").click(); true');
|
||||
await wait('document.querySelector("#proxy-setup-history-retry").hidden && /no entries to show/.test(document.querySelector("#proxy-setup-history-message").textContent)');
|
||||
assert.equal(await b.evaluate('document.activeElement?.id'), 'proxy-setup-history-older');
|
||||
});
|
||||
|
||||
test('settings-s5b: a history answer from before Technical details was closed and opened again is dropped', { timeout: 90000 }, async t => {
|
||||
const STALE = { entries: [{ op: 'init', time: T(1), user: 'stale' }], next: null };
|
||||
const { b, wait } = await setup(t, { admin: { ...OK, 'history?limit=25': [PAGE1, STALE] } });
|
||||
await wait(READY);
|
||||
await b.evaluate('window.__queue["history?limit=25"] = []; true');
|
||||
await openTech(b);
|
||||
await wait('window.__queue["history?limit=25"].length === 1');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech").open = false; true');
|
||||
await new Promise(r => setTimeout(r, 100));
|
||||
await openTech(b);
|
||||
await wait('window.__queue["history?limit=25"].length === 2');
|
||||
// The newer read answers first, then the older one.
|
||||
await b.evaluate('window.__queue["history?limit=25"][1](); true');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
|
||||
await b.evaluate('window.__queue["history?limit=25"][0](); true');
|
||||
await new Promise(r => setTimeout(r, 500));
|
||||
const list = await items(b);
|
||||
assert.equal(list.length, 4);
|
||||
assert.equal(list.some(i => /stale/.test(i.text)), false, 'the older answer is not painted');
|
||||
assert.equal(new Set(list.map(i => i.text)).size, 4, 'one copy of each entry');
|
||||
});
|
||||
|
||||
test('settings-s5b: a history entry whose action is not a known one reads Other setup action', { timeout: 90000 }, async t => {
|
||||
const { b, wait } = await setup(t, { admin: { ...OK, 'history?limit=25': { entries: [{ op: 'toString', time: T(1), user: 'jason' }, { op: 'constructor', time: T(2), user: 'jason' }, { op: 'something.new', time: T(3), user: 'jason' }], next: null } } });
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 3');
|
||||
for (const item of await items(b)) assert.match(item.text, /^Other setup action · .+ · by jason$/);
|
||||
});
|
||||
|
||||
test('settings-s5b: a withheld entry shows as withheld and nothing else from it', { timeout: 90000 }, async t => {
|
||||
const { b, wait } = await setup(t, { admin: { ...OK, 'history?limit=25': { entries: [{ withheld: true, op: 'init', time: T(2), user: 'jason', org: 'acme' }, { withheld: true }], next: null } } });
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 2');
|
||||
for (const item of await items(b)) {
|
||||
assert.equal(item.text, 'Withheld. The Console kept this entry back because it may hold a secret.');
|
||||
assert.equal(item.withheld, true);
|
||||
}
|
||||
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-setup-history li")].every(li => li.classList.contains("muted"))'), true);
|
||||
});
|
||||
|
||||
// ---- No key text ------------------------------------------------------------------------------
|
||||
test('settings-s5b: key-shaped text in an unexpected field of any answer never reaches the page', { timeout: 90000 }, async t => {
|
||||
const k = p => `${p}-AAAAbbbbCCCCdddd0123456789`;
|
||||
const admin = {
|
||||
[LOG]: { unit: k('msk'), lines: ['plain line'], redacted: 0, dropped: 0, key: k('mso'), note: k('mst') },
|
||||
'service-key': { madeAt: k('msk'), renewedAt: k('mso'), renewal: k('mst'), problem: k('msp'), key: k('msk') },
|
||||
'history?limit=25': { entries: [
|
||||
{ op: k('msk'), time: k('mso'), user: k('mst'), org: k('msp'), provider: k('msk'), accountId: k('mso'), models: k('mst'), priority: k('msp'), note: k('msk') },
|
||||
{ op: 'account.proxy.apikey.add', time: T(2), user: `x${k('msk')}`, org: k('mso'), provider: k('mst') },
|
||||
{ op: 'ride-move', time: T(3), org: `${k('msp')}`, user: 'jason' },
|
||||
{ withheld: true, note: k('msk') },
|
||||
], next: null },
|
||||
};
|
||||
{
|
||||
const { b, wait } = await setup(t, { admin });
|
||||
await wait(READY); await openTech(b);
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4 && !/Reading/.test(document.querySelector("#proxy-setup-keymade-text").textContent)');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-history-all").click(); document.querySelector("#proxy-setup-tech-lines").open = true; true');
|
||||
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")');
|
||||
const page = await b.evaluate('document.querySelector("#proxy-setup").textContent + "\\n" + document.body.innerText');
|
||||
assert.doesNotMatch(page, KEY_TEXT);
|
||||
const list = await items(b);
|
||||
assert.match(list[3].text, /^Other setup action · unknown$/);
|
||||
assert.match(list[2].text, /^Account added · /);
|
||||
assert.match(list[1].text, /^An organization switched to your models · /);
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-setup-keymade-text").textContent'), /^When it was made is not known\./);
|
||||
}
|
||||
// A refusal whose code is shaped like a key.
|
||||
const refused = { status: 400, body: { error: 'msk-abcdefghijklmnop' } };
|
||||
const { b, wait } = await setup(t, { admin: { [LOG]: refused, 'service-key': refused, 'history?limit=25': refused } });
|
||||
await wait(READY); await openTech(b);
|
||||
await b.evaluate('document.querySelector("#proxy-setup-tech-lines").open = true; true');
|
||||
await wait('document.querySelector("#proxy-setup-keymade-retry") && !document.querySelector("#proxy-setup-history-retry").hidden && document.querySelector("#proxy-setup-tech-lines .banner.err")');
|
||||
const page = await b.evaluate('document.querySelector("#proxy-setup").textContent + "\\n" + document.body.innerText');
|
||||
assert.doesNotMatch(page, KEY_TEXT);
|
||||
assert.match(await b.evaluate('document.querySelector("#proxy-setup-history-message").textContent'), /^History could not be read\. The Console refused the read\.$/);
|
||||
});
|
||||
|
||||
// ---- Models focus follow-up -------------------------------------------------------------------
|
||||
// The settings-s5 re-check left one window: a switch whose follow-up read is still out when the owner
|
||||
// goes to a page that returns before render's focus chain (Assistant, Projects, the board) kept its focus request.
|
||||
for (const [name, away] of [['Assistant', '#/assistant'], ['the board', '#/board']])
|
||||
test(`settings-s5b: leaving Models for ${name} while a switch's follow-up read is out, the next visit does not focus the outcome line`, { timeout: 90000 }, async t => {
|
||||
const { b, wait, click } = await setup(t, { path: '/#/settings/routing?org=acme' });
|
||||
await wait('document.querySelector("#models-in-force")?.textContent.includes("does not use")');
|
||||
// plugins.set succeeds; the routes read that the render after it awaits waits until released.
|
||||
await b.evaluate(`(() => { const f = window.fetch; window.__sets = 0;
|
||||
window.fetch = async (input, init = {}) => { const u = new URL(String(input?.url ?? input), location.href).pathname, m = (init.method || 'GET').toUpperCase();
|
||||
if (m !== 'GET' && u.endsWith('/proxy/plugins/set')) { window.__sets++; return new Response(JSON.stringify({ revision: 'c'.repeat(64) }), { status: 200, headers: { 'content-type': 'application/json' } }); }
|
||||
if (m === 'GET' && u.endsWith('/proxy/plugins') && window.__sets) return new Response(JSON.stringify({ revision: 'c'.repeat(64), available: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] }, plugins: { harness: ['pi'], 'model-provider': ['fixture', 'cliproxy'] } }), { status: 200, headers: { 'content-type': 'application/json' } });
|
||||
if (m === 'GET' && u.endsWith('/routes') && window.__sets && !window.__released) { await new Promise(r => { window.__release = r; }); window.__released = true; }
|
||||
return f(input, init); }; return true; })()`);
|
||||
await click('#models-yours');
|
||||
await wait('typeof window.__release === "function"');
|
||||
await b.evaluate(`location.hash = ${JSON.stringify(away)}; true`);
|
||||
await wait('!location.hash.startsWith("#/settings/") && !document.querySelector("#models-in-force")');
|
||||
await new Promise(r => setTimeout(r, 300));
|
||||
await b.evaluate('window.__release(); true');
|
||||
await new Promise(r => setTimeout(r, 400));
|
||||
await b.evaluate(`location.hash = '#/settings/routing?org=acme'; true`);
|
||||
await wait('/^Saved\\./.test(document.querySelector("#models-receipt")?.textContent ?? "") && document.querySelector("#models-in-force")?.textContent.includes("uses your models")');
|
||||
await new Promise(r => setTimeout(r, 300));
|
||||
assert.notEqual(await b.evaluate('document.activeElement?.id'), 'models-receipt');
|
||||
});
|
||||
|
||||
// ---- Shots ------------------------------------------------------------------------------------
|
||||
test('shots', { timeout: 900000, skip: !process.env.MOSAIC_UX_SHOTS }, async t => {
|
||||
const { mkdir, writeFile } = await import('node:fs/promises');
|
||||
const { join } = await import('node:path');
|
||||
const dir = process.env.MOSAIC_UX_SHOTS; await mkdir(dir, { recursive: true });
|
||||
const settle = () => new Promise(r => setTimeout(r, 1000));
|
||||
const fail = { status: 503, body: { error: 'outcome-unknown' } };
|
||||
const SHOTS = [
|
||||
{ name: 'setup-start-failed', options: { service: SERVICE_START, admin: { ...OK, ...START_REFUSED } }, ready: READY + ' && document.querySelector("#proxy-setup-go") && !document.querySelector("#proxy-setup-go").hidden',
|
||||
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-go").click(); true'); await wait('document.querySelector("#proxy-setup-lines pre.setup-log")'); } },
|
||||
{ name: 'setup-failed-no-lines', options: { service: SERVICE_FAILED, admin: { ...OK, [LOG]: { status: 503, body: { error: 'not-configured' } } } }, ready: 'document.querySelector("#proxy-setup-lines [data-log] p")' },
|
||||
{ name: 'technical-details', ready: READY,
|
||||
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-tech").open = true; true');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4 && /Mosaic made it/.test(document.querySelector("#proxy-setup-keymade-text").textContent)'); } },
|
||||
{ name: 'technical-details-all', ready: READY,
|
||||
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-tech").open = true; true');
|
||||
await wait('document.querySelectorAll("#proxy-setup-history li").length === 4');
|
||||
await b.evaluate('document.querySelector("#proxy-setup-history-all").click(); document.querySelector("#proxy-setup-tech-lines").open = true; true');
|
||||
await wait('document.querySelector("#proxy-setup-tech-lines pre.setup-log")'); } },
|
||||
{ name: 'technical-details-failed', options: { admin: { [LOG]: fail, 'service-key': fail, 'history?limit=25': fail } }, ready: READY,
|
||||
after: async (b, wait) => { await b.evaluate('document.querySelector("#proxy-setup-tech").open = true; document.querySelector("#proxy-setup-tech-lines").open = true; true');
|
||||
await wait('document.querySelector("#proxy-setup-keymade-retry") && !document.querySelector("#proxy-setup-history-retry").hidden && document.querySelector("#proxy-setup-tech-lines .banner.err")'); } },
|
||||
];
|
||||
const report = [];
|
||||
for (const shot of SHOTS) for (const scheme of ['light', 'dark']) for (const width of [390, 1440]) {
|
||||
const { b, wait } = await setup(t, { ...(shot.options ?? {}), viewport: [width, width === 390 ? 844 : 900] });
|
||||
await b.call('Emulation.setScrollbarsHidden', { hidden: true });
|
||||
await b.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: scheme }] });
|
||||
await wait(`(${shot.ready}) && !!window.MosaicAppearance`);
|
||||
await b.evaluate(`window.MosaicAppearance.ready.then(() => window.MosaicAppearance.set({ mode: ${JSON.stringify(scheme)} }))`);
|
||||
if (shot.after) await shot.after(b, wait);
|
||||
await settle();
|
||||
const sideways = await b.evaluate('document.documentElement.scrollWidth > document.documentElement.clientWidth');
|
||||
const noRing = [], seen = new Set();
|
||||
for (let i = 0; i < 160; i++) {
|
||||
await b.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
|
||||
await b.call('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Tab', code: 'Tab', windowsVirtualKeyCode: 9 });
|
||||
const r = await b.evaluate(`(() => { const e = document.activeElement; if (!e || e === document.body) return null; const cs = getComputedStyle(e);
|
||||
const ring = (cs.outlineStyle !== 'none' && parseFloat(cs.outlineWidth) > 0) || (cs.boxShadow && cs.boxShadow !== 'none');
|
||||
return { key: e.id || e.getAttribute('href') || e.tagName + ':' + (e.textContent || '').trim().slice(0, 30), ring }; })()`);
|
||||
if (!r || seen.has(r.key)) break; seen.add(r.key);
|
||||
if (!r.ring) noRing.push(r.key);
|
||||
}
|
||||
await b.evaluate('document.activeElement?.blur(); window.scrollTo(0, 0); true'); await settle();
|
||||
const file = `${shot.name}-${width}-${scheme}.png`;
|
||||
let metrics = await b.call('Page.getLayoutMetrics'), size = metrics.cssContentSize || metrics.contentSize;
|
||||
await b.viewport(width, Math.ceil(size.height)); await settle();
|
||||
metrics = await b.call('Page.getLayoutMetrics'); size = metrics.cssContentSize || metrics.contentSize;
|
||||
const { data } = await b.call('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true, clip: { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height), scale: 1 } });
|
||||
await writeFile(join(dir, file), Buffer.from(data, 'base64'));
|
||||
report.push({ page: shot.name, width, scheme, shot: file, sideways, noRing });
|
||||
await b.close();
|
||||
}
|
||||
await writeFile(join(dir, 'measure.json'), JSON.stringify(report, null, 1));
|
||||
for (const r of report) {
|
||||
assert.equal(r.sideways, false, `${r.shot} scrolls sideways`);
|
||||
assert.deepEqual(r.noRing, [], `${r.shot}: controls with no visible focus ring`);
|
||||
}
|
||||
});
|
||||
@@ -58,9 +58,13 @@ test("triageEnv keeps the fixed names and the route's proxy variables, and nothi
|
||||
assert.equal(triageEnv(CONSOLE_ENV, { ANTHROPIC_API_KEY: "from-the-route" }).ANTHROPIC_API_KEY, "from-the-route", "the route's key under the name its harness takes");
|
||||
assert.equal(triageEnv(CONSOLE_ENV).ANTHROPIC_API_KEY, undefined, "a key in the Console's environment is not the route's");
|
||||
// #1873 triage-wiring: the pinned harness binary passes as an absolute path, as a bus session's does.
|
||||
assert.deepEqual(SPAWN_PATH_ALLOW, ["MOSAIC_CLAUDE_BIN"]);
|
||||
// #1873 pi-unpin S2: and so does the pi binary the Console names, under the same checks.
|
||||
assert.deepEqual(SPAWN_PATH_ALLOW, ["MOSAIC_CLAUDE_BIN", "MOSAIC_PI_BIN"]);
|
||||
assert.equal(triageEnv({ ...CONSOLE_ENV, MOSAIC_CLAUDE_BIN: "/opt/claude/bin/claude" }).MOSAIC_CLAUDE_BIN, "/opt/claude/bin/claude");
|
||||
for (const bad of ["claude", "bin/claude", "/opt/a\nb", "/" + "x".repeat(300)]) assert.equal(triageEnv({ ...CONSOLE_ENV, MOSAIC_CLAUDE_BIN: bad }).MOSAIC_CLAUDE_BIN, undefined, bad);
|
||||
assert.equal(triageEnv({ ...CONSOLE_ENV, MOSAIC_PI_BIN: "/opt/pi/bin/pi" }).MOSAIC_PI_BIN, "/opt/pi/bin/pi");
|
||||
for (const name of SPAWN_PATH_ALLOW) {
|
||||
for (const bad of ["claude", "bin/claude", "/opt/a\nb", "/" + "x".repeat(300)]) assert.equal(triageEnv({ ...CONSOLE_ENV, [name]: bad })[name], undefined, `${name} ${bad}`);
|
||||
}
|
||||
});
|
||||
|
||||
test("the relay refuses every verb but a message to the person, and any call without the capability", async (t) => {
|
||||
@@ -275,6 +279,26 @@ test("fence 1: a name the harness module does not declare is refused; a declared
|
||||
assert.deepEqual(s.harnessEnv, { FAKE_OK: "yes" });
|
||||
});
|
||||
|
||||
// #1873 pi-unpin re-check 8 P3-2: the host awaits a module's ready() (pi's fit check) before the
|
||||
// bundle. This module's env() works only once its ready() has finished, as pi's reads the check's
|
||||
// pass; a ready() that rejects refuses the route though its env() would answer.
|
||||
test("a module's ready() is awaited before the bundle: env() after it works, and a ready() that rejects refuses the route", async (t) => {
|
||||
const gated = (roots, fail) => async (name) => {
|
||||
if (name !== "fake") return null;
|
||||
let done = false;
|
||||
return {
|
||||
envNames: DECLARED, installRoots: () => roots, transcript: ({ runDir }) => join(runDir, "session"),
|
||||
ready: async () => { await new Promise((r) => setTimeout(r, 20)); if (fail) throw new Error("fit refused"); done = true; },
|
||||
bundle: () => ({ files: {} }),
|
||||
// The host wants the route's key under its own name, as the key itself, and the proxy URL.
|
||||
env: ({ proxy }) => { if (!done && !fail) throw new Error("no passed check"); return { ANTHROPIC_AUTH_TOKEN: proxy.key, ANTHROPIC_BASE_URL: proxy.baseUrl }; },
|
||||
};
|
||||
};
|
||||
await admittedRoute(t, "ready first", () => ({}), (root) => ({ harnessModule: gated([join(root, "install")], false) }));
|
||||
const logs = await refusedRoute(t, "ready rejects", () => ({}), (root) => ({ harnessModule: gated([join(root, "install")], true) }));
|
||||
assert.ok(logs.includes("triage host: route refused: harness-bundle"), logs.join(" | "));
|
||||
});
|
||||
|
||||
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) => () => {
|
||||
@@ -409,6 +433,8 @@ test("the shipped harness modules declare what their own env() and mounts() hand
|
||||
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);
|
||||
// #1873 S3: pi's env() reads the fit check its ready() awaits.
|
||||
if (typeof mod.ready === "function") await mod.ready();
|
||||
const keys = Object.keys(mod.env({
|
||||
files: { settings: "/s", mcp: "/m" }, policy: { tools: ["read"] }, tools: [], session: { model: "m", thinking: "off", provider: "p" },
|
||||
}));
|
||||
@@ -438,7 +464,11 @@ test("a host whose HOME holds the repository starts the shipped pi harness's own
|
||||
// triage-wiring); the module's PI_PROVIDER is not the host's to set.
|
||||
const own = Object.fromEntries(Object.entries(s.harnessEnv).filter(([k]) => !k.startsWith("MOSAIC_")));
|
||||
assert.deepEqual(own, { PI_MODEL: "m", PI_OFFLINE: "1" });
|
||||
assert.deepEqual(Object.keys(s.harnessEnv).filter((k) => k.startsWith("MOSAIC_")).sort(), ["MOSAIC_EXTENSIONS", "MOSAIC_THINKING", "MOSAIC_TOOLS"]);
|
||||
assert.deepEqual(Object.keys(s.harnessEnv).filter((k) => k.startsWith("MOSAIC_")).sort(), ["MOSAIC_EXTENSIONS", "MOSAIC_PI_BIN", "MOSAIC_PI_NO_MCP", "MOSAIC_THINKING", "MOSAIC_TOOLS"]);
|
||||
// #1873 pi-unpin S3: the repository's pi has no --no-mcp, so the module sets it to "0".
|
||||
assert.equal(s.harnessEnv.MOSAIC_PI_NO_MCP, "0");
|
||||
// #1873 pi-unpin S2: the session runs the pi the module found, here the repository's copy.
|
||||
assert.ok(s.harnessEnv.MOSAIC_PI_BIN.startsWith(join(REPO, "node_modules") + "/"), s.harnessEnv.MOSAIC_PI_BIN);
|
||||
// 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] };
|
||||
|
||||
Reference in new issue
Block a user