Compare commits

...
Author SHA1 Message Date
jason.woltje 0aac96dd15 Stop naming a lost proxy for an idle close, and test that an error ends both sides
Re-check of bab5f47d9 found two minor things; this fixes them and one note.

- The forwarder printed the fixed line when the proxy closed an idle
  connection that never carried a request. An upstream end now counts
  only when the forwarder had sent the client's bytes; a socket error
  still always counts.
- Nothing tested that an error on one side ends the other. A new test
  streams from a proxy that keeps writing after a FIN, drops and resets
  120 connections mid-stream, and checks that the relay's and the
  forwarder's fd counts return to their baseline. With the error path
  cut it fails at 222 and 102 fds.
- A linger timer is now cleared when its socket closes by itself.
- spawnRelay's start timeout sends SIGKILL, so a relay wedged before
  "ready" cannot outlive it.
2026-11-21 16:22:32 -06:00
jason.woltje f904d7afda Keep a slow reader's tail, run the relay with no environment, and name a lost proxy
Review of 62468f963 found five things; this fixes them.

- Both copiers destroyed the other side on close, which cut a reply
  short for a client that half-closed and read slowly. A clean close now
  ends the other side and lets it flush; it is destroyed when its peer
  closes or 10 s after its last byte. An error still ends both at once.
- spawnRelay passed the caller's whole environment. The relay now runs
  with an empty one.
- The forwarder said nothing when the proxy died after the start check.
  A connection that ends before any reply byte, while the client still
  waits, now prints the fixed line once.
- stop() could wait forever on a wedged relay. It now sends SIGKILL
  after 2 s, and a stdin error cannot escape to the caller.
- New tests: half-closed slow reader through the relay and through the
  forwarder, empty environment, stop() on a stopped relay, the ppid poll
  alone, SIGINT and SIGHUP, and the proxy gone after the start check.
2026-11-21 16:22:32 -06:00
jason.woltje c27612cf41 Add the worker proxy relay and in-container forwarder, tested, not wired
Slice S2 of worker-proxy-simple. The host relay
(packages/processing-control/src/proxy-relay.mjs) listens on a 0600 Unix
socket in a caller-made 0700 directory and copies bytes to 127.0.0.1:<port>.
It refuses any other target, a socket path of 108 bytes or more, an unsafe
directory and an existing path. It exits on stdin EOF, on TERM, INT or HUP,
and when its parent changes.

The forwarder (adapters/pi/proxy-forward.mjs) listens on 127.0.0.1:<port>
and copies bytes to the socket. One start check through the socket must get
a reply byte; otherwise it prints one fixed line and exits 1.

Nothing calls either file yet except the tests. adapter.sh, compose.yaml,
the Containerfile and containers.mjs are unchanged.
2026-11-21 16:22:32 -06:00
jason.woltje 7264134899 Correct the final-stop notes from review, and name the cap and an unknown signal plainly
The header no longer claims stderr never carries an environment value: the
error line is pi's message as sent, and run-task redacts it. A comment says
why a worker fails a length stop with text while a managed session does
not. An unknown signal exits 1 rather than 128, and the over-cap line names
the 64 MiB cap. TOOLS.md notes that the wrapper is process 1 in the
container and passes SIGINT to pi.
2026-11-21 15:58:10 -06:00
jason.woltje 66d66eb736 Judge a pi worker run by its final stop reason, and print the cause of a failed run
In text print mode pi exits 1 on an error or aborted stop, but a length
stop exits 0 with nothing printed, so run-task recorded an empty success.
The worker entrypoint now sets MOSAIC_PI_FINAL_STOP=1 for headless pi.
adapter.sh then runs pi through final-stop.mjs, which uses --mode json,
keeps the last agent_end and fails the run on an error, aborted or length
stop with one plain line on stderr. A finished stop prints the answer as
text mode does. run-task also prints the cause line that show prints. The
reason stays exit-nonzero, with no new field. The mock adapter is unchanged.
2026-11-21 15:35:49 -06:00
jason.woltje baf5714443 Keep the Triage key state through a failed read, and stop a replaced decision draw
Re-check fix round. Triage settings hold the key state apart from the
read data, so a read that fails after a key change cannot let an older
read put back the old key state. The decision view checks that its draw
is still current after reading earlier versions, so a draw a newer one
replaced does not change the kept notice results.
2026-11-21 00:04:03 -06:00
jason.woltje 5f7adb7670 Keep a reload's route across a key change, and drop a result when its decision returns
Review fix round. A key change in Triage settings no longer drops a
Reload route read that was in flight. The read still draws its route
and revision, and keeps the newer key state. A decision notice drops
its kept result when the decision comes back into the inbox after a
draw saw it gone.
2026-11-20 23:52:05 -06:00
jason.woltje fc60809b80 Keep decision notice results, and drop older triage and workflow reads
The decision notice on an inbox decision kept its result only in the
page node, so the next poll redraw lost it, and a confirmed or reversed
decision left the inbox read with its notice. The result is now kept in
page memory per decision; a redraw keeps the result line and keeps both
buttons off while an answer is in flight.

Settings > Triage applied every route read. A read from an earlier visit
or a Reload route read that answered after a save or key change put back
the old route, revision or key state, and the next save was refused as
stale. Reads are now numbered as they start; one older than what the
page has drawn is dropped, and a save or key change takes a new number.

Workflows applied plain loads in the order they answered. Each
organization's loads are now numbered too, and an older load that
answers last, or fails last, is dropped. The SP17 write epochs are
unchanged.
2026-11-20 23:41:38 -06:00
jason.woltje 9b3cbe4296 Test that a hire receipt survives an overlapping packs reload
Two forced-order tests for the hire click. They fail without the packs state fix in 5a7e6765f.
2026-11-20 23:25:29 -06:00
jason.woltje 1e8a20074d Keep a newer autonomy read that lands during a save
Re-check of 7cba209dc (P3-1): a save can commit, another writer can
commit after it, and a poll can draw that newer read before the save
answers. The save then wrote its own older values into the state, and
the new redraw painted them over the newer form. It failed closed, but
the page showed older values.

A save that answers now writes its values into the state only when the
state still holds the revision it sent or the one it got back. Any other
revision was written after the save, so it stays. The redraw draws from
that state, so it never paints older values.

The older-read test waits for the draw as well as the read, since the
dashboard draws only after all its reads (re-check P3-2). A new test
forces the newer-writer order.
2026-11-20 22:48:55 -06:00
jason.woltje 2e78c7e593 Draw an autonomy save over a clean form drawn from an older read
Review of a4a035d17 (P3-1): a reload whose read was served before a save
committed could redraw a clean form while the save was in flight. The
save then wrote its revision to the form it started on, which the page
no longer drew. The drawn form showed the old levels next to the receipt,
and a second save before the next poll was refused as a revision
conflict.

A save that answers now draws the settings section again from the saved
state when the drawn form is a different, clean form. A form the owner is
editing stays, so it saves against its own revision and fails closed.
The live section lookup skips decision notices for the hold check too.

The older-read test now waits on the held read by the revision it
carries, so a poll in the window cannot move its count (P3-3). A new test
forces the P3-1 order and checks the drawn form before any reload.
2026-11-20 22:48:55 -06:00
jason.woltje fbfcd942be Keep an autonomy save or review receipt that overlaps a reload
The autonomy panel built a new state object on every load and copied the
status from the state it found when the load began. A save kept the old
object across its own request. So a save that answered while a poll or
an organization change was reading autonomy wrote its receipt and its new
revision to an object the page no longer drew, or the load copied the
empty status forward before the receipt existed. The next draw then
showed no receipt and the old revision, so the next save was refused as
a revision conflict. A trail review wrote its line only to the node it
started on, which a redraw replaces.

Each organization now keeps one state object. A load writes its read into
it when it ends. A load that began before the last applied read, or
before a save answered, is dropped. A save or review result is kept in
that state and written to the status line the page draws now.

Browser tests hold the fixture's calls to force each order of a save
against a reload, a review against a reload, and an older read that
answers after a newer one.
2026-11-20 22:48:55 -06:00
jason.woltje 5a7e6765f8 Keep a pack preview or receipt that overlaps a packs reload
The pack picker built a new state object on every load and copied the
preview and receipt from the state it found when the load began. A click
kept the old object across its own request. So a preview or a hire receipt
that answered while a poll or an apply's page reload was reading the packs
was written to an object the page no longer drew, or was copied away
before it existed. Under host load this dropped the project preview in the
SP6 pack picker test and the hire status in the pack hire test.

Each organization now keeps one state object. A load writes its read
fields into it when it ends, and a load that began before the last one
applied is dropped, so an older list never replaces a newer one.

One browser test holds the fixture's reads to force each order of the
overlap, a second forces an older packs read to answer last, and a third
holds a reload's packs read while an apply's receipt lands.
2026-11-20 20:33:47 -06:00
jason.woltje 69b3931c35 Resolve recheck follow-up cases 2026-11-20 19:43:53 -06:00
jason.woltje b7116be9c3 Address review of proxy administration follow-ups 2026-11-20 19:43:53 -06:00
jason.woltje 0f3135e36a Show unanswered organizations with offered models 2026-11-20 19:43:53 -06:00
jason.woltje b0dd4d3e2f Recognize organizations without a launch in model survey 2026-11-20 19:43:53 -06:00
jason.woltje e8c6c7e3a4 Test the 257 model limit boundary 2026-11-20 19:43:53 -06:00
jason.woltje fe671844ea Guard shared credential names with invalid account IDs 2026-11-20 19:43:53 -06:00
jason.woltje b3eaa8fd81 Preserve account removal success when refresh fails 2026-11-20 19:43:53 -06:00
jason.woltje 07baa87381 Clarify account removal ambiguity 2026-11-20 19:43:53 -06:00
jason.woltje 5e67fd9289 test(webui): wait for restart completion 2026-11-20 18:43:48 -06:00
jason.woltje ffc7db130f test(webui): enforce switch ordering in restart check 2026-11-20 18:43:48 -06:00
jason.woltje d6de22aaf8 test(webui): isolate browser waits and offline observation 2026-11-20 18:43:48 -06:00
jason.woltje f4134fff9a Fix account repair navigation and coverage 2026-11-20 17:03:22 -06:00
jason.woltje 122659a488 Make model setup account status truthful 2026-11-20 17:03:22 -06:00
jason.woltje 40afaaf6ad fix(harness): prove MCP seals with extension-backed loaders 2026-11-20 16:32:21 -06:00
jason.woltje 8042aa13ed test(cli): exercise plugin backstop with TMPDIR unset 2026-11-20 16:23:18 -06:00
jason.woltje 82aa0c0bda test(plugins): use a multi-segment temp path for redaction 2026-11-20 16:13:28 -06:00
jason.woltje 0430c7dc32 fix(release,task,auth): health-reason review round: the worker credential check reads the auth file path as compose does (a leading ~ is $HOME, a relative path is from the checkout, a named volume is undecided), treats COMPOSE_ENV_FILES and docker-compose.override.yaml|yml as undecided like .env, and leaves the credential not checked when this user can't read the auth file (EACCES, EPERM) instead of refusing; a key variable that is only spaces is no credential, as in pi; a compose.yaml that can't be read or parsed gives fixed words, never its path or text; release.sh's reason with no run id comes from the new scripts/health-reason.mjs (the last refusal line, prefix dropped, redacted, withheld when it holds an environment value) and says "gave no run id"; the fault-injection and recursion-guard comments are back; tests cover the tilde path, COMPOSE_ENV_FILES, an unreadable auth file, a blank key, a compose warning line in a failed run's stderr, and the redacted and withheld reason; docs/TOOLS.md names each undecided case (#1873, lane health-reason) 2026-11-20 15:31:59 -06:00
jason.woltje 1433686d50 feat(release,task,auth,runs,plugins): health-reason: a failed release health check prints its run id and one plain reason before release: refusing activate: health check failed: the cause line mosaic-task show now prints for a run that did not succeed (a runner reason in words, else one redacted line from the run's stderr.txt read through the new readRunText), or, when the runner refused before a run record, its own refusal line, redacted. A pi run checks before its run directory exists that the worker container compose starts holds a credential for config execution.provider: names and types from the PI_AUTH_FILE compose mounts and the key variables compose passes with a value, judged by pi-ai's own checkAuth on placeholders (packages/plugins/harness/pi/worker-credential.mjs), so no provider list is kept; with none it refuses exit 3 naming the provider, what the container has and what to do; when it can't decide (COMPOSE_FILE, an override or .env, an env_file, an unknown provider) it says so and the run goes ahead. auth.sh status adds one line for the default run's provider and credential. Tests in test-task, test-release, test-auth and runs.test; docs/TOOLS.md (#1873, lane health-reason) 2026-11-20 15:14:07 -06:00
49 changed files with 3326 additions and 136 deletions

No files matched your search

+5 -1
View File
@@ -31,6 +31,7 @@ Optional, adapter-specific (documented per adapter):
| Variable | Meaning |
|---|---|
| `MOSAIC_MOCK_RESPONSE` | mock only: the verbatim response to emit |
| `MOSAIC_PI_FINAL_STOP` | pi only, `1` from `src/run-agent.sh` for a headless worker: judge the run by pi's final stop reason (`final-stop.mjs`) |
**Outputs:**
@@ -53,7 +54,10 @@ Optional, adapter-specific (documented per adapter):
## Included adapters
- `pi` — the `@earendil-works/pi-coding-agent` CLI (not pinned; #1873) in noninteractive
print mode (`-p`), ambient discovery disabled, stdin detached.
print mode (`-p`), ambient discovery disabled, stdin detached. A worker run
(`MOSAIC_PI_FINAL_STOP=1`) goes through `final-stop.mjs`: pi runs with
`--mode json`, the answer is printed only on a finished stop, and an error,
aborted or output-limit stop exits 1 with one line on stderr.
- `mock` — deterministic echo of `MOSAIC_MOCK_RESPONSE`. Test-only: never use
it where a real model response is required.
- `claude` — the host's `claude` CLI, for managed sessions only (below):
+8
View File
@@ -148,5 +148,13 @@ 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" "${MOSAIC_PI_BIN:-pi}" "$@" --mode json
fi
# worker-stop-reason: a run-task worker (src/run-agent.sh sets MOSAIC_PI_FINAL_STOP=1) is judged
# by pi's final stop reason as well as its exit status. Text mode exits 0 on a "length" stop with
# nothing printed; final-stop.mjs runs pi with --mode json, prints the answer as text mode does on
# a finished stop, and fails the run on an error, aborted or length stop with one line on stderr.
# Managed sessions never set it and keep text mode.
if [ "${MOSAIC_PI_FINAL_STOP:-}" = "1" ] && [ "$INTERACTIVE" != "1" ]; then
exec node "$(dirname "$0")/final-stop.mjs" "${MOSAIC_PI_BIN:-pi}" "$@"
fi
# #1873 S2: the binary the harness module found (MOSAIC_PI_BIN, its path inside the sandbox).
exec "${MOSAIC_PI_BIN:-pi}" "$@"
+152
View File
@@ -0,0 +1,152 @@
#!/usr/bin/env node
// worker-stop-reason: judge a headless pi worker run by pi's final stop reason, not only its exit
// status. The worker entrypoint (src/run-agent.sh) asks for this with MOSAIC_PI_FINAL_STOP=1, and
// adapter.sh then runs `node final-stop.mjs <pi> <args...>` in place of `<pi> <args...>`.
//
// Why: in text print mode (-p) pi 0.85.1 exits 1 on an "error" or "aborted" stop, but a "length"
// stop (the model reached its output limit) exits 0 with nothing on stdout or stderr, so run-task
// recorded an empty success. Only the JSON event stream says how the run ended: its last
// agent_end event carries the run's messages, and the last assistant message's stopReason is the
// final stop. Proved against pi 0.85.1 with a fake provider on loopback (packages/plugins/tests/
// pi-final-stop.test.mjs).
//
// This runs pi with `--mode json` and keeps only the last agent_end line (bounded). Then:
// pi exited nonzero the same code, pi's own stderr already said why
// pi was stopped by a signal 128 + the signal number, one line on stderr
// final stop "stop" the text parts, each followed by "\n" (as text mode prints), exit 0
// final stop "toolUse" nothing, exit 0 (a tool ended the run; text mode prints nothing)
// final stop "error"/"aborted" exit 1, one line: pi stopped on an error: <pi's error message>
// final stop "length" exit 1, one line: the model reached its output limit
// anything else exit 1, one line (fail closed: no final answer to judge)
// stdout carries the answer only on success. An error line carries pi's error message as the
// provider sent it, as text mode printed it; run-task redacts known secret values before it shows
// the cause (runCause in scripts/mosaic-task.mjs).
import { spawn } from "node:child_process";
import { realpathSync } from "node:fs";
import { constants } from "node:os";
import { fileURLToPath } from "node:url";
export const AGENT_END_PREFIX = '{"type":"agent_end"';
// The cap on the one line kept. agent_end carries every message of the run, tool results too.
export const MAX_AGENT_END_BYTES = 64 * 1024 * 1024;
const MAX_LINE_CHARS = 2000;
const oneLine = (text) => {
const line = String(text).replace(/\s+/g, " ").trim();
return line.length > MAX_LINE_CHARS ? `${line.slice(0, MAX_LINE_CHARS)}...` : line;
};
// The judgement for the last agent_end line pi wrote (null when it wrote none):
// { ok: true, answer } or { ok: false, message }.
export function judgeFinalStop(agentEndLine) {
if (agentEndLine === null) return { ok: false, message: "pi ended without a final answer: it reported no end of run" };
let event;
try { event = JSON.parse(agentEndLine); } catch { return { ok: false, message: "pi ended without a final answer: its end of run could not be read" }; }
const messages = Array.isArray(event?.messages) ? event.messages : [];
let last = null;
for (let i = messages.length - 1; i >= 0; i--) {
if (messages[i]?.role === "assistant") { last = messages[i]; break; }
}
if (!last) return { ok: false, message: "pi ended without a final answer: the model gave no reply" };
const reason = last.stopReason;
if (reason === "stop" || reason === "toolUse") {
if (messages[messages.length - 1] !== last) return { ok: true, answer: "" };
const parts = Array.isArray(last.content) ? last.content : [];
return { ok: true, answer: parts.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => `${p.text}\n`).join("") };
}
if (reason === "error" || reason === "aborted") {
const said = typeof last.errorMessage === "string" && last.errorMessage.trim() ? oneLine(last.errorMessage) : `request ${reason}`;
return { ok: false, message: `pi stopped on an error: ${said}` };
}
// A worker run fails on "length" even with partial text: the answer was cut off. A managed
// session first turn (packages/plugins/harness/pi/model-stream.mjs) counts length with text as
// output; that turn is a conversation, a worker run is a finished job.
if (reason === "length") return { ok: false, message: "pi stopped with no finished answer: the model reached its output limit" };
return { ok: false, message: `pi ended without a final answer: it stopped for an unknown reason (${oneLine(String(reason)).slice(0, 40)})` };
}
// Keeps the last line that starts with AGENT_END_PREFIX out of a byte stream, holding at most
// one such line (up to max bytes) in memory. Other lines pass through unkept.
export function agentEndKeeper(max = MAX_AGENT_END_BYTES) {
let chunks = [];
let size = 0;
let state = "start"; // start: at a line start; keep: in an agent_end line; skip: in another line
let head = Buffer.alloc(0);
let last = null;
let tooBig = false;
const finishLine = () => {
if (state === "keep") {
if (size > max) tooBig = true;
else { last = Buffer.concat(chunks).toString("utf8"); tooBig = false; }
}
chunks = []; size = 0; state = "start"; head = Buffer.alloc(0);
};
const feedPart = (part) => {
if (state === "start") {
head = Buffer.concat([head, part]);
const prefix = Buffer.from(AGENT_END_PREFIX);
const n = Math.min(head.length, prefix.length);
if (!head.subarray(0, n).equals(prefix.subarray(0, n))) { state = "skip"; head = Buffer.alloc(0); return; }
if (head.length < prefix.length) return;
state = "keep"; part = head; head = Buffer.alloc(0);
}
if (state === "keep") {
size += part.length;
if (size <= max) chunks.push(part); else chunks = [];
}
};
return {
write(buffer) {
let at = 0;
while (at < buffer.length) {
const nl = buffer.indexOf(10, at);
if (nl === -1) { feedPart(buffer.subarray(at)); return; }
feedPart(buffer.subarray(at, nl));
finishLine();
at = nl + 1;
}
},
end() {
if (state === "keep") finishLine();
return { line: tooBig ? null : last, tooBig };
},
};
}
async function main(argv) {
const [pi, ...args] = argv;
if (!pi) { process.stderr.write("pi final stop: no pi binary was given\n"); return 2; }
const keeper = agentEndKeeper();
const child = spawn(pi, [...args, "--mode", "json"], { stdio: ["inherit", "pipe", "inherit"] });
const forward = (signal) => { try { child.kill(signal); } catch {} };
for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) process.on(signal, () => forward(signal));
child.stdout.on("data", (buffer) => keeper.write(buffer));
const outcome = await new Promise((resolve) => {
child.on("error", (error) => resolve({ error }));
child.on("close", (code, signal) => resolve({ code, signal }));
});
if (outcome.error) {
process.stderr.write(`pi final stop: pi could not be started (${outcome.error.code ?? "spawn error"})\n`);
return 127;
}
if (outcome.signal) {
process.stderr.write(`pi final stop: pi was stopped by ${outcome.signal}\n`);
const number = constants.signals[outcome.signal];
return Number.isInteger(number) && number > 0 ? 128 + number : 1;
}
if (outcome.code !== 0) return outcome.code ?? 1;
const { line, tooBig } = keeper.end();
const verdict = tooBig
? { ok: false, message: `pi ended without a final answer: its end of run was over ${MAX_AGENT_END_BYTES / (1024 * 1024)} MiB` }
: judgeFinalStop(line);
if (!verdict.ok) {
process.stderr.write(`${verdict.message}\n`);
return 1;
}
await new Promise((resolve) => process.stdout.write(verdict.answer, resolve));
return 0;
}
let isMain = false;
try { isMain = realpathSync(process.argv[1] ?? "") === realpathSync(fileURLToPath(import.meta.url)); } catch {}
if (isMain) process.exitCode = await main(process.argv.slice(2));
+124
View File
@@ -0,0 +1,124 @@
#!/usr/bin/env node
// In-container forwarder for the model proxy (worker-proxy-simple, slice S2).
//
// node proxy-forward.mjs <socket path> <port>
//
// Listens on 127.0.0.1:<port> inside the container and copies bytes, both
// ways, to the host relay's Unix socket (packages/processing-control/src/
// proxy-relay.mjs), which copies them to the host's loopback model proxy.
// It parses nothing and holds no key.
//
// Start check. Before it listens it makes one connection through the socket
// and sends one small HTTP request (HEAD /). Any reply byte within five
// seconds passes: the socket, the relay and the proxy all answered. Anything
// else prints exactly one line on stderr and exits 1:
//
// worker: the container could not reach the model proxy socket.
//
// The same line is printed once, and the forwarder keeps running, when a later
// connection fails before any reply byte: the socket refuses, or the relay
// hangs up on a request with no reply, which is what a gone proxy looks like.
// An idle connection that the proxy closes before any request is not counted.
//
// Output. One line "ready" on stdout once the port listens, then stdout is
// closed. The caller captures it (for example ready=$(node ... &)), so it
// never mixes with the adapter's response on stdout. A usage or listen
// failure is one other line on stderr and exits 2.
// Not called by adapter.sh yet; the cutover slice (S4) starts it.
import { closeSync, openSync } from 'node:fs';
import net from 'node:net';
import { isAbsolute } from 'node:path';
const UNREACHABLE = 'worker: the container could not reach the model proxy socket.';
const CHECK_MS = 5000;
const CHECK_REQUEST = 'HEAD / HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n';
let told = false;
function unreachable() {
if (!told) { told = true; process.stderr.write(`${UNREACHABLE}\n`); }
}
function check(socketPath) {
return new Promise((resolveCheck) => {
let passed = false, finished = false;
const probe = net.connect({ path: socketPath });
const finish = (ok) => {
if (finished) return;
finished = true;
clearTimeout(timer);
probe.destroy();
resolveCheck(ok);
};
const timer = setTimeout(() => finish(false), CHECK_MS);
probe.once('connect', () => probe.write(CHECK_REQUEST));
probe.on('data', () => { passed = true; finish(true); });
probe.on('error', () => finish(false));
probe.on('close', () => finish(passed));
});
}
// Copy bytes both ways. An error on either side ends both at once. A clean
// close of one side only ends the other, so bytes still queued for a slow
// reader are flushed first; that side is destroyed when its peer closes too,
// or LINGER_MS after its last byte was written. Kept in step with the same
// helper in packages/processing-control/src/proxy-relay.mjs.
const LINGER_MS = 10000;
function join(a, b) {
const kill = () => { a.destroy(); b.destroy(); };
const finish = (other) => () => {
if (other.destroyed) return;
other.resume();
other.end();
const linger = () => {
const timer = setTimeout(() => other.destroy(), LINGER_MS).unref();
other.once('close', () => clearTimeout(timer));
};
if (other.writableFinished) linger(); else other.once('finish', linger);
};
a.on('error', kill); b.on('error', kill);
a.on('close', finish(b)); b.on('close', finish(a));
a.pipe(b); b.pipe(a);
}
async function main(argv) {
const port = /^[1-9][0-9]{0,4}$/.test(argv[1] ?? '') ? Number(argv[1]) : 0;
if (argv.length !== 2 || !isAbsolute(argv[0]) || port < 1 || port > 65535) {
process.stderr.write('worker: proxy forwarder usage: proxy-forward.mjs <socket path> <port>.\n');
process.exit(2);
}
const socketPath = argv[0];
if (!(await check(socketPath))) {
unreachable();
process.exit(1);
}
const server = net.createServer({ allowHalfOpen: true }, (client) => {
const upstream = net.connect({ path: socketPath, allowHalfOpen: true });
let clientDone = false;
client.once('end', () => { clientDone = true; });
client.once('close', () => { clientDone = true; });
// The socket failed, or the relay hung up on a request before any reply
// byte while the client still waited: what a gone proxy looks like. An
// idle connection the proxy closes before any request is not counted.
const lost = () => { if (!clientDone && upstream.bytesRead === 0) unreachable(); };
upstream.on('error', lost);
upstream.once('end', () => { if (upstream.bytesWritten > 0) lost(); });
join(client, upstream);
});
server.on('error', () => {
process.stderr.write(`worker: the model proxy forwarder could not listen on 127.0.0.1:${port}.\n`);
process.exit(2);
});
server.listen({ host: '127.0.0.1', port, exclusive: true }, () => {
// Node never closes fd 1 itself, so close it and put /dev/null in its place:
// a caller reading stdout to its end then gets EOF right after "ready".
process.stdout.write('ready\n', () => {
try { closeSync(1); openSync('/dev/null', 'w'); } catch {}
});
});
}
main(process.argv.slice(2)).catch(() => {
unreachable();
process.exit(1);
});
+93
View File
@@ -39,6 +39,64 @@ Task fields: `prompt` (required), `mission` (path), `expectExact`,
`directives[]`, optional governing `capabilities.tools`. Policy: a task may
narrow a mission's tools, never widen; empty intersection = tool-free run.
Worker credential check (#1873, lane health-reason). A run's provider and
model come only from the instance config, `execution.provider` and
`execution.model`; task and mission files have no provider field. Before a
pi run makes its run directory, `mosaic-task run` (and `retry`) asks whether
the worker container compose starts will hold a credential for that provider:
an entry in the auth file compose mounts (`PI_AUTH_FILE`), or a key variable
compose passes with a value that isn't blank (pi treats a blank one as
unset). The auth file path is read as compose reads it: a leading `~` is
`$HOME`, and a relative path is from the checkout. Only names and types are
read. pi
decides which credential counts: the check runs pi's own `checkAuth` from the
pi-ai the lock installs, on placeholders
(`packages/plugins/harness/pi/worker-credential.mjs`), so no provider list is
kept here. With none, the run refuses with exit 3 and no run record:
```
mosaic-task: the worker container has no credential for provider zai (config execution.provider); it has credentials for: anthropic. Change the instance's execution.provider to one of those, or add a credential for zai (a PI_AUTH_FILE entry, or an environment key compose passes to it).
```
When the check can't decide, the run goes ahead and one line says why:
`mosaic-task: worker credential not checked: <why>`. That happens when
`COMPOSE_FILE` or `COMPOSE_ENV_FILES` is set, a `compose.override.yaml`,
`compose.override.yml`, `docker-compose.override.yaml`,
`docker-compose.override.yml` or `.env` sits beside `compose.yaml`, the
service has an `env_file`, the auth file is a named volume or one this user
can't read (the container may still read it), `compose.yaml` can't be read
or parsed, pi or yaml isn't installed, or pi has no provider by that name.
The check can't see inside an entry: an `api_key` entry whose key is empty,
a `$VAR` or a `!command` still counts. The mock adapter needs no credential
and is never checked.
`mosaic-task show <runId>` on a run that did not succeed adds one line after
`exit:`, `cause: <reason>`. A reason the runner decided is said in words
(`the run passed its time limit and was stopped`, `the response did not match
the expected text`, `processing was halted during the run`). Otherwise it is
`worker said: <line>`, one line from the run's `stderr.txt` with compose's
progress and warning lines passed over, redacted (paths, links, emails,
key-shaped strings) and withheld when it holds a value from the environment.
With no such line it says the worker container could not be started or the
worker exited with its code and wrote nothing that can be shown. `mosaic-task
run` prints the same line as `cause: <reason>` after `response:` when the run
did not succeed.
A pi worker is judged by pi's final stop reason as well as its exit status
(worker-stop-reason). In print mode pi exits 0 when the model reaches its
output limit, with nothing printed, so that run used to count as succeeded.
The container's entrypoint sets `MOSAIC_PI_FINAL_STOP=1` for a headless pi
run, and the pi adapter then runs pi through `adapters/pi/final-stop.mjs`,
which reads pi's JSON event stream. A finished stop prints the answer as
before. An error or aborted stop fails with `pi stopped on an error: <pi's
error>`, and an output-limit stop fails with `pi stopped with no finished
answer: the model reached its output limit`. The reason stays
`exit-nonzero`, and the line is the `worker said:` cause. Managed sessions
don't set the variable and keep text mode. In the container the wrapper is
process 1 and passes SIGTERM, SIGINT and SIGHUP to pi, so a SIGINT that
reaches the container now stops pi (exit 130). Before, pi was process 1 and
ignored SIGINT.
Legacy worker containers use a typed per-launch mount contract. Task, mission,
user and session-fork snapshots are read-only. A fork source is opened without
following its final symlink, limited to 16 MiB, checked for owner/type and
@@ -132,6 +190,19 @@ listings and refused by `--auth`).
launch's `PI_AUTH_FILE`; missing/symlinked/non-0600 accounts refuse.
Headless task runs keep the default credential.
`auth.sh status` also prints one line for the default run: the provider the
config asks for and whether the worker container will hold a credential for
it, by the same check `mosaic-task run` makes. The auth file it checks is the
one compose mounts, which is `PI_AUTH_FILE` when set (compose's own default
otherwise, not the `$HOME` default the report above reads).
```
default run: provider zai (config execution.provider); worker container credential: yes
default run: provider openai (config execution.provider); worker container credential: none (it has: anthropic, zai)
default run: provider zai (config execution.provider); the adapter needs no credential
default run: provider zai (config execution.provider); worker container credential: not checked (<why>)
```
## Release
| Command | Purpose | Notes |
@@ -142,6 +213,28 @@ Headless task runs keep the default credential.
| `scripts/release.sh status` | Release, tag, active pointer, log | Safe on empty state |
| `scripts/release.sh ensure` | Self-determination: align active pointer to `RELEASE` | Fast path restores a missing/mismatched pointer without a gate; slow path packages + health-gates first. Invoked automatically at launch |
A failed health check says which run failed and why before it refuses. With
a run record, the reason is the `cause:` line `mosaic-task show` prints:
```
release: health check run: r-20261120T120000Z-a1b2c3
release: reason: the response did not match the expected text
release: refusing activate: health check failed
```
When the runner gave no run id (it refused before the run started: a missing
worker credential, a config problem), the reason is the runner's last refusal
line, picked and redacted by `scripts/health-reason.mjs`:
```
release: health check gave no run id
release: reason: the worker container has no credential for provider zai (config execution.provider); it has credentials for: none. ...
release: refusing activate: health check failed
```
Neither prints a key, an environment value or a host path; the run id is the
only identifier.
## Conductor (worker patches)
```bash
+3 -3
View File
@@ -108,7 +108,7 @@ export class ProxyPage {
rows.push({ ...view(this.#providers, key.auth_index, provider, status, key.priority ?? group.priority), source: 'apikey', groupIndex, keyIndex, models: configured.map(m => m.alias || m.name) });
}
}
return { rows, groups };
return { rows, groups, credentialNames: response.files.map(row => row?.name).filter(identifier) };
}
#public(row) {
const { accountId, provider, displayName, status, priority } = row;
@@ -271,13 +271,13 @@ export class ProxyPage {
fields(args, ['accountId', 'confirm']);
if (typeof args.accountId !== 'string' || !/^[a-f0-9]{12}$/.test(args.accountId) || args.confirm !== true) refuse('invalid-request');
return this.#write(async () => {
const { rows, groups } = await this.#accounts();
const { rows, groups, credentialNames } = await this.#accounts();
const original = this.#lock ? structuredClone(groups) : null;
const matches = rows.filter(row => row.accountId === args.accountId);
if (matches.length !== 1) refuse('invalid-request');
const row = matches[0];
// The DELETE names a credential file; another listed account on the same name would go too.
if (row.source === 'oauth' && rows.some(r => r !== row && r.source === 'oauth' && r.name === row.name)) refuse('invalid-request');
if (row.source === 'oauth' && credentialNames.filter(name => name === row.name).length !== 1) refuse('invalid-request');
if (this.#lock && !isDeepStrictEqual(await this.#client.getUpstreamGroups(), original)) refuse('proxy-down');
this.#beforeMutation('proxy.account.remove');
try {
@@ -223,6 +223,14 @@ test('remove: two listed accounts on one credential name, or one account id list
await assert.rejects(d.call('proxy.account.remove', { accountId: id('oauth-one.json'), confirm: true }), { code: 'invalid-request' });
for (const x of [s, d]) { assert.equal(x.state.calls.some(c => !c.startsWith('GET ')), false); assert.equal(x.state.files.length, 2); }
});
test('remove: a credential with an unusable id still prevents deleting its shared name', async t => {
for (const badId of ['', null, 'x'.repeat(513)]) {
const s = await fakeManagement(t, { files: [oauth(), oauth({ id: badId, name: 'oauth-one.json' })] });
await assert.rejects(s.call('proxy.account.remove', { accountId: id('oauth-one.json'), confirm: true }), { code: 'invalid-request' });
assert.equal(s.state.calls.some(c => !c.startsWith('GET ')), false);
assert.equal(s.state.files.length, 2);
}
});
test('remove: under the lock, key groups that change between the read and the write refuse with proxy-down before the fence', async t => {
const fs = await import('node:fs'); const { join } = await import('node:path'); const { tmpdir } = await import('node:os');
const { createProxyLock } = await import('../src/proxy-lock.mjs');
@@ -468,10 +468,10 @@ test("W3 host watch: the default stat key reads the plugin root's plugins, and a
const dataRoot = scratch(t);
// The plugin root sits beside TMPDIR, not in it: TMPDIR is an env value the backstop already
// knows, so a root under it would be caught without the plugin root as a needle of its own.
// When TMPDIR's parent can't take it, the test skips: a root under TMPDIR would pass with the
// plugin root left out of the backstop.
// With TMPDIR unset, its value cannot mask the check, so a separate scratch directory works.
// Otherwise skip if the parent cannot take a sibling: a child would give a false pass.
let pluginRoot;
try { pluginRoot = mkdtempSync(join(dirname(tmpdir()), "mosaic-hw-plugins-")); }
try { pluginRoot = process.env.TMPDIR ? mkdtempSync(join(dirname(tmpdir()), "mosaic-hw-plugins-")) : scratch(t); }
catch { t.skip("the plugin root must sit beside TMPDIR, and TMPDIR's parent is not writable"); return; }
t.after(() => rmSync(pluginRoot, { recursive: true, force: true }));
const clock = fakeClock();
@@ -487,6 +487,7 @@ test("W3 host watch: the default stat key reads the plugin root's plugins, and a
// A plugin lock that can't be read changes the plugin root's key (the loader refuses it): a full pass.
writeFileSync(pluginPaths(pluginRoot).lock, "{", { mode: 0o600 });
line = `${pluginRoot}/plugins/pi`;
assert.equal(leakChecker({ env: {}, scratch: null, dataRoot })({ line }), false, "without the plugin root the backstop does not catch this path");
clock.fire(); await handle.settled();
assert.equal(stub.calls.length, 2, "the key read the plugin root, so its change ran a full pass");
assert.match(logs.join("\n"), /a state line held a host path or an env value/, "and the record that names the plugin root was not written");
@@ -240,8 +240,8 @@ export async function lifecycleFixture(t) {
}
async function consoleBrowser(t, f) {
const b = await browser(); t.after(() => b.close());
b.on('Fetch.requestPaused', ({ requestId, request: incoming }) => {
let b = await browser(); const consolePage = b; t.after(() => consolePage.close());
consolePage.on('Fetch.requestPaused', ({ requestId, request: incoming }) => {
const url = new URL(incoming.url);
if (incoming.method === 'POST') f.recordOwner(url.pathname);
const req = httpRequest({ host: '127.0.0.1', port: f.port, path: url.pathname + url.search, method: incoming.method,
@@ -249,9 +249,9 @@ async function consoleBrowser(t, f) {
const parts = []; res.on('data', part => parts.push(part)); res.on('end', () => {
const responseHeaders = Object.entries(res.headers).filter(([name]) => !['connection','keep-alive','transfer-encoding'].includes(name))
.flatMap(([name, value]) => (Array.isArray(value) ? value : [value]).map(value => ({ name, value: String(value) })));
b.call('Fetch.fulfillRequest', { requestId, responseCode: res.statusCode, responseHeaders, body: Buffer.concat(parts).toString('base64') }).catch(() => {});
consolePage.call('Fetch.fulfillRequest', { requestId, responseCode: res.statusCode, responseHeaders, body: Buffer.concat(parts).toString('base64') }).catch(() => {});
});
}); req.on('error', () => b.call('Fetch.failRequest', { requestId, errorReason: 'Failed' }).catch(() => {})); req.end(incoming.postData);
}); req.on('error', () => consolePage.call('Fetch.failRequest', { requestId, errorReason: 'Failed' }).catch(() => {})); req.end(incoming.postData);
});
await b.call('Fetch.enable', { patterns: [{ urlPattern: ORIGIN + '/*', requestStage: 'Request' }] });
const s = await f.current(); await b.navigate(`${ORIGIN}/#/inbox/${s.selection.decision}`);
@@ -267,7 +267,10 @@ async function consoleBrowser(t, f) {
await wait('document.querySelector("#decide-status")?.textContent.startsWith("Recorded")');
},
async offline(html) {
await b.call('Fetch.disable');
// The Console can still poll during navigation. Close it before observing the downloaded file.
await b.close();
b = await browser(); const offlinePage = b; t.after(() => offlinePage.close());
external.length = 0;
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: `window.__now=1000;Date.now=()=>window.__now;window.__ticks=[];window.setInterval=fn=>{window.__ticks.push(fn);return window.__ticks.length;};window.__sounds=0;window.AudioContext=class{currentTime=0;destination={};resume(){}createOscillator(){return{connect(){},frequency:{value:0},start(){window.__sounds++},stop(){}}}createGain(){return{connect(){},gain:{value:0}}}};` });
await b.call('Network.enable'); await b.call('Network.emulateNetworkConditions', { offline: true, latency: 0, downloadThroughput: 0, uploadThroughput: 0 });
b.on('Network.requestWillBeSent', ({ request }) => { if (/^https?:/.test(request.url)) external.push(request.url); });
+9 -2
View File
@@ -72,8 +72,15 @@ 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
`--no-extensions`). If `--no-extensions` also disables the MCP loader,
the check leaves out both it and `--no-mcp` in one additional rpc run.
That run must show MCP and no kind beyond MCP and extensions. Together
with the run leaving out only `--no-extensions` (extensions load, MCP
does not), this proves `--no-mcp` with its loader enabled. The planted
MCP servers have distinct names so a trusted project entry cannot hide
the user entry. No version comparison selects these checks.
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
+22 -5
View File
@@ -28,7 +28,9 @@
// 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.
// in, can stand in for it. If --no-extensions also disables the MCP loader, a run
// without both it and --no-mcp must show MCP and extensions only. Paired with the
// --no-extensions one-out run, this proves --no-mcp with its loader enabled.
// 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
@@ -570,13 +572,26 @@ async function judge(found, { levels, who, digest, run }) {
// 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}`;
let r = await pending;
let but = `with every seal flag but ${flag}`;
if (r.stopped) return unsure(`the start ${but} ${r.stopped}`);
if (!r.answer.state || !r.answer.commands) return unsure(`it didn't answer get_state and get_commands ${but}`);
if (r.prompt === null) return unsure(`its -e extension didn't see the system prompt ${but}`);
// pi-152: MCP can itself be a built-in extension. Removing --no-mcp alone then leaves its
// loader disabled. The earlier --no-extensions one-out run proved that extensions load but
// MCP stays off with --no-mcp. Remove that flag too: MCP must now run, and no unrelated kind
// may load. This pair proves the flag, without demanding that the two seals be independent.
let pairedMcp = false;
if (flag === "--no-mcp" && r.seen.length === 0) {
pairedMcp = true;
but = "with every seal flag but --no-extensions and --no-mcp";
r = await rpcRun(without("--no-extensions", "--no-mcp"));
if (r.stopped) return unsure(`the start ${but} ${r.stopped}`);
if (!r.answer.state || !r.answer.commands) return unsure(`it didn't answer get_state and get_commands ${but}`);
if (r.prompt === null) return unsure(`its -e extension didn't see the system prompt ${but}`);
}
if (!r.seen.some((s) => s.kind === kind)) return unsure(`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"));
const others = r.seen.filter((s) => s.kind !== kind && !(pairedMcp && s.kind === "extension") && !(flag === "--no-extensions" && !noMcp && s.kind === "MCP server"));
if (others.length) return refuse(`loaded a planted ${others.map((s) => s.source).join(", ")} ${but}`);
}
@@ -896,7 +911,9 @@ 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))}`] } } });
// A trusted project's server replaces a user server with the same name (pi 1.5.2). The
// control must see a user source independently of project trust, so use a name per source.
const mcp = (source) => JSON.stringify({ mcpServers: { [markerName(source)]: { 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");
+50 -4
View File
@@ -124,6 +124,52 @@ test("pi-unpin S3: a stand-in that touches the planted MCP marker under the seal
for (const [kind, line] of Object.entries(lines)) assert.equal((await fit(standIn(t, { sealLeak: [kind] }).env)).message, `pi 2.0.0 (MOSAIC_PI_BIN) ${line}`, kind);
});
// pi-152: a trusted project MCP entry replaces a user entry of the same name. The positive
// control needs a user source, so the fixture must keep the two servers distinct.
test("pi-152: project MCP name precedence does not hide the user positive control", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true });
const r = await fit(s.env);
assert.equal(r.ok, true, r.message);
assert.equal(r.noMcp, true);
});
test("pi-152: MCP name precedence still refuses a user server loaded under the seal flags", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true, sealLeak: ["mcp"] });
const r = await fit(s.env);
assert.equal(r.ok, false);
assert.equal(r.undecided, false);
assert.equal(r.message, "pi 2.0.0 (MOSAIC_PI_BIN) loaded a planted user mcp.json with the seal flags on");
noPath(r.message, s.paths);
});
test("pi-152: --no-mcp is proved even when --no-extensions also disables the MCP loader", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true, mcpAlso: "--no-extensions" });
const r = await fit(s.env);
assert.equal(r.ok, true, r.message);
assert.equal(r.noMcp, true);
});
test("pi-152: --no-extensions cannot mask an ignored --no-mcp", SKIP, async t => {
const s = standIn(t, { extraFlags: ["--no-mcp"], mcpProjectOverride: true, standIn: ["--no-mcp", "--no-extensions"] });
const r = await fit(s.env);
assert.equal(r.ok, false);
assert.equal(r.undecided, false);
assert.equal(r.message, "pi 2.0.0 (MOSAIC_PI_BIN) loaded a planted user mcp.json with every seal flag but --no-extensions");
noPath(r.message, s.paths);
});
test("pi-152: the paired MCP control still refuses unrelated ambient sources", SKIP, async t => {
const s = standIn(t, {
extraFlags: ["--no-mcp"], mcpProjectOverride: true, mcpAlso: "--no-extensions",
leakWith: ["--no-context-files"], leakWithoutAll: ["--no-extensions", "--no-mcp"],
});
const r = await fit(s.env);
assert.equal(r.ok, false);
assert.equal(r.undecided, false);
assert.match(r.message, /loaded a planted .*user skill.*user AGENTS.md.* with every seal flag but --no-extensions and --no-mcp$/);
noPath(r.message, s.paths);
});
// pi-skills: the worker's shape. pi 0.85.1 adds a --skill directory to discovery, so the adapter
// keeps --no-skills in front of each --skill; the fit check's last -p run passes the adapter's -p
// argv with MOSAIC_SKILLS (workerShape) and two --skill directories.
@@ -423,11 +469,11 @@ test("pi-unpin S3 re-check 7: a pi that loads every kind when TERM, TZ or LC_ALL
}
});
// Re-check 5 item 2: the --no-mcp run is the only one that shows --no-mcp alone keeps MCP out.
// This pi keeps MCP out with --no-mcp or with --no-context-files, so every other run hides that
// --no-mcp does nothing on its own.
// Re-check 5 item 2: another seal must not hide whether --no-mcp works. This pi keeps MCP out
// with --no-mcp or --no-context-files. Even the paired control that enables extensions cannot
// show MCP, so the check still cannot tell.
test("pi-unpin S3 re-check 5: a pi whose --no-mcp works only beside another seal flag is can't tell at the --no-mcp run", SKIP, async t => {
assert.equal((await fit(standIn(t, { extraFlags: ["--no-mcp"], mcpAlso: "--no-context-files" }).env)).message, "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it didn't load a planted MCP server with every seal flag but --no-mcp");
assert.equal((await fit(standIn(t, { extraFlags: ["--no-mcp"], mcpAlso: "--no-context-files" }).env)).message, "pi 2.0.0 (MOSAIC_PI_BIN) can't be checked: it didn't load a planted MCP server with every seal flag but --no-extensions and --no-mcp");
assert.equal((await fit(standIn(t, { extraFlags: ["--no-mcp"] }).env)).ok, true);
});
+12 -6
View File
@@ -37,8 +37,11 @@
// 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
// `leakWithout` too, both must hold). `leakWithoutAll`: every listed flag must be
// absent, combined with the other leak conditions. `mcpAlso`: a flag that keeps MCP servers out
// as well as their own flag does. `mcpProjectOverride`: like pi 1.5.2, merge the
// user and trusted project's .pi/mcp.json by name, with project entries winning;
// ignore .mcp.json. `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
@@ -233,7 +236,7 @@ if (modelRun) {
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.leakWith || K.leakWithout || K.leakWithoutAll) && (K.leakWith || []).every(has) && (!K.leakWithout || K.leakWithout.some((f) => !has(f))) && (!K.leakWithoutAll || K.leakWithoutAll.every((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);
@@ -280,9 +283,12 @@ if (modelRun) {
}
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" });
}
const configs = K.mcpProjectOverride
? [path.join(agent, "mcp.json"), ...(trusted ? [path.join(cwd, ".pi", "mcp.json")] : [])]
: [path.join(agent, "mcp.json"), path.join(cwd, ".pi", "mcp.json"), path.join(cwd, ".mcp.json")];
const entries = configs.map((f) => json(f)?.mcpServers || {});
const servers = K.mcpProjectOverride ? Object.values(Object.assign({}, ...entries)) : entries.flatMap(Object.values);
for (const s of servers) cp.spawnSync(s.command, s.args || [], { stdio: "ignore" });
}
if (on("skills", "--no-skills") || (K.skillLeak && has("--skill") && !ignoreAll)) {
const home = process.env.HOME || "/";
+14 -8
View File
@@ -157,20 +157,25 @@ export function offeredControl({ dataRoot, riders, receipt, exclusive, rootAgent
try { list = await riders(); } catch { throw failure('outcome-unknown'); }
const named = (Array.isArray(list) ? list : []).filter(r => typeof r?.id === 'string' && ORG_ID.test(r.id));
const riding = named.filter(r => r.cliproxy === true);
if (!riding.length) throw failure('not-configured');
const unanswered = new Set(named.filter(r => typeof r.cliproxy !== 'boolean').map(r => r.id));
if (!riding.length) throw failure(unanswered.size ? 'proxy-down' : 'not-configured');
let root;
try { root = typeof rootAgents === 'function' ? await rootAgents() : undefined; } catch { root = undefined; }
const answers = await Promise.all(riding.map(async r => {
let routes = null, named = null;
try { routes = await r.call('routes'); } catch { routes = null; }
try { named = typeof r.file === 'function' ? modelsNamed((await r.file())?.document) : null; } catch { named = null; }
let routes = null, named = null, noLaunchReply = false, document = null;
try { routes = await r.call('routes'); } catch (error) { noLaunchReply = error?.code === 'launch-not-configured'; }
try { document = typeof r.file === 'function' ? (await r.file())?.document : null; named = modelsNamed(document); } catch { named = null; }
// A separate file read can observe a newer launch than the bus did. Treat that race and
// unreadable files as unknown, never as proof that no model is in use.
const noLaunch = noLaunchReply && named !== null && !Object.hasOwn(document, 'launch');
const fromRoot = root === undefined ? null : rootModelsNamed(root, r.id);
return { id: r.id, routes, named: named && fromRoot ? [...named, ...fromRoot] : null };
return { id: r.id, routes, noLaunch, named: named && fromRoot ? [...named, ...fromRoot] : null };
}));
const providers = new Map(), usedBy = new Map();
let ready = false;
for (const { id, routes } of answers) {
for (const { id, routes, noLaunch } of answers) {
// routes explicitly refuses before reading a catalogue when the organization has no launch.
if (noLaunch) continue;
const c = routes?.catalogue;
if (c?.status !== 'ready' || !Array.isArray(c.models)) { unanswered.add(id); continue; }
ready = true;
@@ -181,8 +186,9 @@ export function offeredControl({ dataRoot, riders, receipt, exclusive, rootAgent
if (!providers.get(provider).includes(m.model)) providers.get(provider).push(m.model);
}
}
if (!ready) throw failure('proxy-down');
for (const { id, routes, named } of answers) {
if (!ready) throw failure(!unanswered.size && answers.every(a => a.noLaunch) ? 'not-configured' : 'proxy-down');
for (const { id, routes, named, noLaunch } of answers) {
if (noLaunch) continue;
if (!routes || typeof routes.instances !== 'object' || routes.instances === null || named === null) { unanswered.add(id); continue; }
const table = routes.providerModels && typeof routes.providerModels === 'object' ? routes.providerModels : {};
const legacy = routes.catalogue?.legacy && typeof routes.catalogue.legacy === 'object' ? routes.catalogue.legacy : {};
@@ -114,6 +114,38 @@ test('an organization whose usage is unknown (its file unreadable, its bus down,
}
});
test('a riding organization explicitly without launch is answered, while a bus failure remains unanswered', async t => {
const noLaunch = { ...rider('bolt', []), call: async () => { throw Object.assign(new Error('no launch'), { code: 'launch-not-configured' }); } };
const down = { ...rider('crux', []), call: async () => { throw new Error('down'); } };
const c = control(t, { riders: [rider('acme', [entry('zai', 'glm-5')]), noLaunch, down] });
assert.deepEqual((await c.models({ seed: true })).unanswered, ['crux']);
const onlyAnswered = control(t, { riders: [rider('acme', [entry('zai', 'glm-5')]), noLaunch] });
const view = await onlyAnswered.models({ seed: true });
assert.deepEqual(view.unanswered, []);
assert.equal(existsSync(offeredFile(onlyAnswered.dataRoot)), true);
await onlyAnswered.modelsSet({ provider: 'z.ai', on: [], revision: view.revision });
});
test('a no-launch response with a newer launch or unreadable file stays unanswered and blocks an unconfirmed switch off', async t => {
const noLaunch = async () => { throw Object.assign(new Error('no launch'), { code: 'launch-not-configured' }); };
for (const file of [async () => ({ document: { launch: { models: {} }, roles: {} } }), async () => { throw new Error('unreadable'); }, async () => ({ document: null })]) {
const c = control(t, { riders: [rider('acme', [entry('zai', 'glm-5')]), { ...rider('bolt', []), call: noLaunch, file }] });
const view = await c.models({ seed: true });
assert.deepEqual(view.unanswered, ['bolt']);
assert.equal(existsSync(offeredFile(c.dataRoot)), false);
await assert.rejects(c.modelsSet({ provider: 'z.ai', on: [], revision: view.revision }), { code: 'models-in-use' });
}
});
test('all riders confirmed without launch are not configured; a failed read is proxy-down', async t => {
const noLaunch = { ...rider('bolt', []), call: async () => { throw Object.assign(new Error('no launch'), { code: 'launch-not-configured' }); } };
const configured = control(t, { riders: [noLaunch] });
await assert.rejects(configured.models({ seed: true }), { code: 'not-configured' });
assert.equal(existsSync(offeredFile(configured.dataRoot)), false);
const down = control(t, { riders: [{ ...noLaunch, file: async () => { throw new Error('unreadable'); } }] });
await assert.rejects(down.models({ seed: true }), { code: 'proxy-down' });
});
test('in use counts every place the organization file names a model and the root agents it takes: project agents, root copies; not an excluded or assistant root agent, not launch.models itself', async t => {
const models = [entry('zai', 'glm-5'), entry('zai', 'glm-4.6'), entry('codex', 'gpt-5'), entry('codex', 'gpt-5-mini')];
const routes = { instances: { chief: { model: 'g5' } }, providerModels: { g5: entry('zai', 'glm-5'), g46: entry('zai', 'glm-4.6'), gpt: entry('codex', 'gpt-5'), mini: entry('codex', 'gpt-5-mini') } };
@@ -166,6 +198,9 @@ test(`a model kept on while its account is signed out counts against the ${MAX_O
// glm-0 is in use and this switches it off, but the list is too long first: no ask for a save that cannot be written.
await assert.rejects(c.modelsSet({ provider: 'z.ai', on: all.slice(1), revision: before.revision }), { code: 'models-invalid' }, `${all.length - 1} on plus 10 kept is past ${MAX_ON}`);
await assert.rejects(c.modelsSet({ provider: 'z.ai', on: all.slice(1), revision: before.revision, confirmInUse: true }), { code: 'models-invalid' });
// Exactly 257 including the 10 kept models must refuse before asking about glm-0.
assert.equal(all.slice(6).length + away.length, MAX_ON + 1);
await assert.rejects(c.modelsSet({ provider: 'z.ai', on: all.slice(6), revision: before.revision }), { code: 'models-invalid' });
assert.equal(readOffered(c.dataRoot).revision, before.revision);
assert.deepEqual(c.receipts, []);
const saved = await c.modelsSet({ provider: 'z.ai', on: all.slice(7), revision: before.revision, confirmInUse: true });
@@ -228,6 +263,7 @@ test('a damaged file: the read and the write answer outcome-unknown and write no
test('no organization riding is not-configured; none answering a ready catalogue is proxy-down; a busy lock refuses the write', async t => {
await assert.rejects(control(t, { riders: [] }).models(), { code: 'not-configured' });
await assert.rejects(control(t, { riders: [{ ...rider('acme', []), cliproxy: false }] }).models(), { code: 'not-configured' });
await assert.rejects(control(t, { riders: [{ ...rider('acme', []), cliproxy: undefined }] }).models(), { code: 'proxy-down' });
const down = { id: 'acme', cliproxy: true, call: async () => { throw new Error('down'); } };
await assert.rejects(control(t, { riders: [down, rider('bolt', [], { catalogue: { status: 'unavailable', models: [] } })] }).models(), { code: 'proxy-down' });
await assert.rejects(control(t, { riders: [rider('acme', [entry('zai', 'glm-5')])], busy: true }).modelsSet({ provider: 'z.ai', on: [], revision: 'a'.repeat(16) }), { code: 'proxy-admin-busy' });
@@ -0,0 +1,102 @@
// lane health-reason: does the pi worker container hold a credential for the provider a run asks
// for? pi answers, not a list kept here. Before it sends a prompt, pi checks
// `models.checkAuth(provider)` from @earendil-works/pi-ai (pi-coding-agent's agent-session.js). The
// worker image has no models.json and pi runs with --no-extensions, so that call is the whole
// gate. This runs the same call, from the pi-ai the lock installs, on stand-ins: each auth.json
// entry becomes a placeholder of its type, and each environment name the container gets with a
// value answers a placeholder. No key, token or value is read, passed or kept.
//
// credentialCheck({ provider, entries, envNames })
// entries: [{ name, type }] from the auth file the container mounts (names and types only)
// envNames: names the container's environment carries with a nonempty value
// answers { decided: true, known, has, providers } or { decided: false, why }
// known: pi has a provider by this id
// has: the container will hold a credential pi accepts for it
// providers: every provider pi would accept a credential for in that container, sorted
import { existsSync, readFileSync } from "node:fs";
import { join } from "node:path";
import { pathToFileURL, fileURLToPath } from "node:url";
const REPO = fileURLToPath(new URL("../../../../", import.meta.url));
const SCOPE = "@earendil-works";
const PLACEHOLDER = "mosaic-credential-check-placeholder";
// Where pi reads auth.json inside the worker image: its agent directory under the image user's
// home (HOME=/home/node, pi's default ~/.pi/agent). compose.yaml mounts the host file there.
export const authFileInContainer = "/home/node/.pi/agent/auth.json";
// The pi-ai pi itself loads: the copy nested under pi-coding-agent first, else the hoisted one.
// Both come from package-lock.json, the lock the image's npm ci installs.
function piAiDir(root) {
for (const dir of [join(root, "node_modules", SCOPE, "pi-coding-agent", "node_modules", SCOPE, "pi-ai"),
join(root, "node_modules", SCOPE, "pi-ai")]) {
if (existsSync(join(dir, "package.json"))) return dir;
}
return null;
}
function exportPath(pkg, key) {
const entry = pkg?.exports?.[key];
const target = typeof entry === "string" ? entry : entry?.import ?? entry?.default;
return typeof target === "string" ? target : null;
}
async function loadPiAi(root) {
const dir = piAiDir(root);
if (!dir) return { why: "pi isn't installed in this checkout (run npm ci)" };
let pkg;
try { pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")); } catch { return { why: "pi's package can't be read" }; }
const main = exportPath(pkg, ".");
const providers = exportPath(pkg, "./providers/*");
if (!main || !providers) return { why: "pi's package doesn't export what the check needs" };
try {
const ai = await import(pathToFileURL(join(dir, main)).href);
const all = await import(pathToFileURL(join(dir, providers.replace("*", "all"))).href);
if (typeof ai.createModels !== "function" || typeof all.builtinProviders !== "function") {
return { why: "pi's package doesn't export what the check needs" };
}
return { createModels: ai.createModels, builtinProviders: all.builtinProviders };
} catch {
return { why: "pi's package can't be loaded" };
}
}
// A stand-in for an entry: the type pi reads, with placeholder fields where pi wants them. A type
// pi doesn't know stays bare, and pi treats it as no credential, as it treats the real entry.
function standIn(type) {
if (type === "api_key") return { type, key: PLACEHOLDER };
if (type === "oauth") return { type, access: PLACEHOLDER, refresh: PLACEHOLDER, expires: Number.MAX_SAFE_INTEGER };
return { type: String(type) };
}
function store(entries) {
const map = new Map();
for (const { name, type } of entries) if (typeof name === "string" && name) map.set(name, standIn(type));
return {
read: async (id) => map.get(id),
list: async () => [...map].map(([providerId, c]) => ({ providerId, type: c.type })),
modify: async (id) => map.get(id),
delete: async () => {},
};
}
export async function credentialCheck({ provider, entries = [], envNames = [], root = REPO } = {}) {
const pi = await loadPiAi(root);
if (!pi.createModels) return { decided: false, why: pi.why };
const names = new Set(envNames);
try {
const models = pi.createModels({
credentials: store(entries),
// The container has no ambient credential files: its pi directory starts empty.
authContext: { env: async (name) => (names.has(name) ? PLACEHOLDER : undefined), fileExists: async () => false },
});
for (const p of pi.builtinProviders()) models.setProvider(p);
const ids = models.getProviders().map((p) => p.id);
const providers = [];
for (const id of ids) if ((await models.checkAuth(id)) !== undefined) providers.push(id);
providers.sort();
return { decided: true, known: ids.includes(provider), has: providers.includes(provider), providers };
} catch {
return { decided: false, why: "pi's credential check failed" };
}
}
@@ -255,15 +255,17 @@ test("W1 redaction covers real paths, trailing slashes, the user name, rule ids,
test("W1 no record holds a path under the scratch directory, the home directory or an env value", async (t) => {
const { pass, dir } = await watchTree(t, { h: {} });
const secret = "/srv/fixture-secret-place";
// A multi-segment loose path stays a path even when tmpdir() is just /tmp.
const looseTempPath = join(tmpdir(), "mosaic-redaction-probe");
const env = { WATCH_SECRET: secret, HOME: join(dir, "home"), MOSAIC_FIXTURE_BIN: "/opt/fixture/bin/tool", PATH: "/opt/fixture-tools/bin:/usr/bin:/bin" };
const answer = ok(DIGEST_A, {
source: dir, version: `9.9 at ${dir}/bin`,
line: `found at ${env.MOSAIC_FIXTURE_BIN} in ${secret}, home ${env.HOME}, ${realpathSync(dir)}`,
surfaces: { help: `usage: ${dir}/tool\nsee /opt/fixture-tools/bin/tool and ${tmpdir()}`, "Bad Name": dir },
surfaces: { help: `usage: ${dir}/tool\nsee /opt/fixture-tools/bin/tool and ${looseTempPath}`, "Bad Name": dir },
});
const out = await pass({ h: answer }, { env });
const text = JSON.stringify(out);
for (const p of [dir, realpathSync(dir), secret, env.MOSAIC_FIXTURE_BIN, "/opt/fixture-tools/bin", env.HOME, tmpdir()]) assert.ok(!text.includes(p), p);
for (const p of [dir, realpathSync(dir), secret, env.MOSAIC_FIXTURE_BIN, "/opt/fixture-tools/bin", env.HOME, looseTempPath]) assert.ok(!text.includes(p), p);
const rec = byName(out).h;
assert.equal(rec.source, null, "a source that is a path is dropped");
assert.deepEqual(Object.keys(rec.surfaces), ["help"]);
@@ -0,0 +1,282 @@
// worker-stop-reason: a run-task worker run is judged by pi's final stop reason, not only its exit
// status (adapters/pi/final-stop.mjs). The real pi runs through adapters/pi/adapter.sh against a
// fake Anthropic Messages provider on 127.0.0.1 port 0: no real model, no other network.
import { test } from "node:test";
import assert from "node:assert/strict";
import { spawn, spawnSync } from "node:child_process";
import http from "node:http";
import { chmodSync, cpSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
import { locate } from "../harness/pi/binary.mjs";
import { agentEndKeeper, judgeFinalStop } from "../../../adapters/pi/final-stop.mjs";
import { fixture, tmp } from "../../cli/tests/helpers.mjs";
const REPO = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
const ADAPTER = join(REPO, "adapters", "pi", "adapter.sh");
const FINAL_STOP = join(REPO, "adapters", "pi", "final-stop.mjs");
const TASK = join(REPO, "scripts", "mosaic-task.mjs");
const scratch = (t) => {
const dir = mkdtempSync(join(tmpdir(), "fs"));
t.after(() => rmSync(dir, { recursive: true, force: true }));
return dir;
};
const agentEnd = (...messages) => JSON.stringify({ type: "agent_end", messages });
const assistant = (stopReason, extra = {}) => ({ role: "assistant", content: [{ type: "text", text: "partial" }], stopReason, ...extra });
// --- The judge -----------------------------------------------------------------------------------
test("final stop: a finished stop passes with the text parts as text mode prints them", () => {
const line = agentEnd({ role: "user", content: "hi" }, { role: "assistant", stopReason: "stop", content: [{ type: "thinking", thinking: "x" }, { type: "text", text: "OK" }, { type: "text", text: "two" }] });
assert.deepEqual(judgeFinalStop(line), { ok: true, answer: "OK\ntwo\n" });
assert.deepEqual(judgeFinalStop(agentEnd({ role: "assistant", stopReason: "stop", content: [] })), { ok: true, answer: "" });
});
test("final stop: an error, aborted or length stop fails with one plain line", () => {
assert.deepEqual(judgeFinalStop(agentEnd(assistant("error", { errorMessage: "401 invalid\nx-api-key" }))), { ok: false, message: "pi stopped on an error: 401 invalid x-api-key" });
assert.deepEqual(judgeFinalStop(agentEnd(assistant("aborted"))), { ok: false, message: "pi stopped on an error: request aborted" });
assert.deepEqual(judgeFinalStop(agentEnd(assistant("length"))), { ok: false, message: "pi stopped with no finished answer: the model reached its output limit" });
const long = judgeFinalStop(agentEnd(assistant("error", { errorMessage: "e".repeat(5000) })));
assert.equal(long.ok, false);
assert.ok(long.message.length < 2100);
});
test("final stop: no end of run, no reply or an unknown stop reason fails closed", () => {
assert.equal(judgeFinalStop(null).ok, false);
assert.equal(judgeFinalStop("{not json").ok, false);
assert.equal(judgeFinalStop(agentEnd({ role: "user", content: "hi" })).ok, false);
assert.match(judgeFinalStop(agentEnd(assistant("deferred"))).message, /unknown reason \(deferred\)/);
assert.equal(judgeFinalStop(agentEnd(assistant(undefined))).ok, false);
});
test("final stop: a tool that ends the run passes with nothing printed, as text mode does", () => {
const line = agentEnd(assistant("toolUse"), { role: "toolResult", content: [{ type: "text", text: "done" }] });
assert.deepEqual(judgeFinalStop(line), { ok: true, answer: "" });
});
test("final stop: the keeper keeps the last agent_end line across chunk splits and skips other lines", () => {
const k = agentEndKeeper();
const first = agentEnd(assistant("error", { errorMessage: "retrying" }));
const last = agentEnd({ role: "assistant", stopReason: "stop", content: [{ type: "text", text: "é OK" }] });
const stream = Buffer.from(`{"type":"session"}\n${first}\n{"type":"message_end","note":"{\\"type\\":\\"agent_end\\"}"}\n${last}\n{"type":"agent_start"}\n`);
for (let i = 0; i < stream.length; i += 3) k.write(stream.subarray(i, i + 3));
assert.deepEqual(k.end(), { line: last, tooBig: false });
const unterminated = agentEndKeeper();
unterminated.write(Buffer.from(last));
assert.equal(unterminated.end().line, last);
const none = agentEndKeeper();
none.write(Buffer.from('{"type":"agent_start"}\n'));
assert.deepEqual(none.end(), { line: null, tooBig: false });
});
test("final stop: an agent_end line over the cap is not kept, and a later one replaces it", () => {
const small = agentEnd(assistant("stop"));
const big = agentEnd(assistant("stop", { pad: "x".repeat(300) }));
assert.ok(small.length < 200 && big.length > 200);
const k = agentEndKeeper(200);
k.write(Buffer.from(`${small}\n${big}\n`));
assert.deepEqual(k.end(), { line: null, tooBig: true });
const again = agentEndKeeper(200);
again.write(Buffer.from(`${big}\n${small}\n`));
assert.deepEqual(again.end(), { line: small, tooBig: false });
});
// --- final-stop.mjs with a stand-in pi -----------------------------------------------------------
function standIn(dir, body) {
const file = join(dir, "pi-stand-in.mjs");
writeFileSync(file, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
return file;
}
const runFinalStop = (pi, args = []) => spawnSync(process.execPath, [FINAL_STOP, pi, ...args], { encoding: "utf8", timeout: 20000, input: "" });
test("final stop: an error stop that pi reports with exit 0 is a failed run", (t) => {
const dir = scratch(t);
const pi = standIn(dir, `process.stdout.write(${JSON.stringify(`{"type":"session"}\n${agentEnd(assistant("error", { errorMessage: "529 overloaded" }))}\n`)}); process.exit(0);`);
const r = runFinalStop(pi);
assert.equal(r.status, 1);
assert.equal(r.stdout, "");
assert.equal(r.stderr, "pi stopped on an error: 529 overloaded\n");
});
test("final stop: pi gets its arguments plus --mode json, and its own exit code and stderr pass through", (t) => {
const dir = scratch(t);
const pi = standIn(dir, `(await import("node:fs")).writeFileSync(${JSON.stringify(join(dir, "argv"))}, JSON.stringify(process.argv.slice(2))); process.stderr.write("pi said no\\n"); process.exit(3);`);
const r = runFinalStop(pi, ["-p", "two words"]);
assert.equal(r.status, 3);
assert.equal(r.stderr, "pi said no\n");
assert.equal(r.stdout, "");
assert.deepEqual(JSON.parse(readFileSync(join(dir, "argv"), "utf8")), ["-p", "two words", "--mode", "json"]);
});
test("final stop: a pi that can't start or dies on a signal fails with one line", (t) => {
const dir = scratch(t);
const missing = runFinalStop(join(dir, "no-such-pi"));
assert.equal(missing.status, 127);
assert.match(missing.stderr, /^pi final stop: pi could not be started \(ENOENT\)\n$/);
const killed = runFinalStop(standIn(dir, `process.kill(process.pid, "SIGKILL");`));
assert.equal(killed.status, 137);
assert.equal(killed.stderr, "pi final stop: pi was stopped by SIGKILL\n");
});
// --- The real pi through adapter.sh -------------------------------------------------------------
function sse(res, events) {
res.writeHead(200, { "content-type": "text/event-stream", connection: "close" });
for (const [type, data] of events) res.write(`event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`);
res.end();
}
const START = { message: { id: "m1", type: "message", role: "assistant", model: "probe-model", content: [], stop_reason: null, usage: { input_tokens: 1, output_tokens: 0 } } };
const reply = (text, stop) => [
["message_start", START],
...(text === null ? [] : [
["content_block_start", { index: 0, content_block: { type: "text", text: "" } }],
["content_block_delta", { index: 0, delta: { type: "text_delta", text } }],
["content_block_stop", { index: 0 }],
]),
["message_delta", { delta: { stop_reason: stop }, usage: { output_tokens: 1 } }],
["message_stop", {}],
];
const SCENARIOS = {
ok: (req, res) => sse(res, reply("OK", "end_turn")),
"status-401": (req, res) => { res.writeHead(401, { "content-type": "application/json" }); res.end(JSON.stringify({ type: "error", error: { type: "authentication_error", message: "invalid x-api-key" } })); },
"length-empty": (req, res) => sse(res, reply(null, "max_tokens")),
"length-text": (req, res) => sse(res, reply("partial", "max_tokens")),
refusal: (req, res) => sse(res, reply(null, "refusal")),
};
async function provider(t, scenario) {
const server = http.createServer((req, res) => { req.resume(); req.on("end", () => SCENARIOS[scenario](req, res)); });
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
t.after(() => { server.closeAllConnections(); server.close(); });
return `http://127.0.0.1:${server.address().port}`;
}
const PI = locate(process.env);
async function adapterRun(t, scenario, { finalStop }) {
assert.ok(PI.bin, PI.problem);
const dir = scratch(t);
const agentDir = join(dir, "agent");
mkdirSync(agentDir);
const url = await provider(t, scenario);
writeFileSync(join(agentDir, "models.json"), JSON.stringify({ providers: { probe: { baseUrl: url, api: "anthropic-messages", apiKey: "probe-dummy", models: [{ id: "probe-model" }] } } }));
writeFileSync(join(dir, "system.md"), "Answer briefly.\n");
const env = {
PATH: `${dirname(process.execPath)}:/usr/bin:/bin`,
HOME: dir,
TMPDIR: dir,
LANG: "C.UTF-8",
PI_CODING_AGENT_DIR: agentDir,
PI_OFFLINE: "1",
PI_SKIP_VERSION_CHECK: "1",
PI_PROVIDER: "probe",
PI_MODEL: "probe-model",
MOSAIC_PI_BIN: PI.bin,
MOSAIC_SYSTEM_PROMPT_FILE: join(dir, "system.md"),
MOSAIC_REQUEST: "Say OK",
MOSAIC_WORKSPACE: join(dir, "ws"),
...(finalStop ? { MOSAIC_PI_FINAL_STOP: "1" } : {}),
};
const child = spawn("/bin/sh", [ADAPTER], { env, stdio: ["ignore", "pipe", "pipe"] });
let stdout = "", stderr = "";
child.stdout.on("data", (d) => (stdout += d));
child.stderr.on("data", (d) => (stderr += d));
const status = await new Promise((resolve) => child.on("close", (code, signal) => resolve(signal ?? code)));
return { status, stdout, stderr };
}
test("real pi: without the final-stop check a length stop exits 0 with nothing printed (the gap)", async (t) => {
const r = await adapterRun(t, "length-empty", { finalStop: false });
assert.deepEqual({ status: r.status, stdout: r.stdout, stderr: r.stderr }, { status: 0, stdout: "", stderr: "" });
});
test("real pi: with the check a normal stop still passes and prints the answer as text mode does", async (t) => {
const plain = await adapterRun(t, "ok", { finalStop: false });
const judged = await adapterRun(t, "ok", { finalStop: true });
assert.deepEqual({ status: plain.status, stdout: plain.stdout }, { status: 0, stdout: "OK\n" });
assert.deepEqual({ status: judged.status, stdout: judged.stdout, stderr: judged.stderr }, { status: 0, stdout: "OK\n", stderr: "" });
});
test("real pi: with the check a length stop fails, with or without partial text", async (t) => {
for (const scenario of ["length-empty", "length-text"]) {
const r = await adapterRun(t, scenario, { finalStop: true });
assert.deepEqual({ status: r.status, stdout: r.stdout, stderr: r.stderr }, { status: 1, stdout: "", stderr: "pi stopped with no finished answer: the model reached its output limit\n" }, scenario);
}
});
test("real pi: with the check a provider error stop (pi exits 0 in JSON mode) fails with pi's error text", async (t) => {
const r = await adapterRun(t, "status-401", { finalStop: true });
assert.equal(r.status, 1);
assert.equal(r.stdout, "");
assert.match(r.stderr, /^pi stopped on an error: 401 .*authentication_error.*invalid x-api-key.*\n$/);
const refused = await adapterRun(t, "refusal", { finalStop: true });
assert.equal(refused.status, 1);
assert.equal(refused.stderr, "pi stopped on an error: The model refused to complete the request\n");
});
// --- src/run-agent.sh sets the check for pi only -------------------------------------------------
function entrypoint(t) {
const root = scratch(t);
const opt = join(root, "opt");
for (const d of ["src", "processing-control", "contracts", "adapters/pi"]) mkdirSync(join(opt, d), { recursive: true });
writeFileSync(join(opt, "src", "run-agent.sh"), readFileSync(join(REPO, "src", "run-agent.sh"), "utf8").replaceAll("/opt/mosaic", opt), { mode: 0o755 });
writeFileSync(join(opt, "src", "load-contracts.sh"), '#!/bin/sh\nprintf "prompt\\n" > "$2"\n', { mode: 0o755 });
writeFileSync(join(opt, "processing-control", "entrypoint.mjs"), "");
cpSync(join(REPO, "adapters", "mock"), join(opt, "adapters", "mock"), { recursive: true });
chmodSync(join(opt, "adapters", "mock", "adapter.sh"), 0o755);
writeFileSync(join(opt, "adapters", "pi", "adapter.sh"), '#!/bin/sh\n(env | grep "^MOSAIC_" | sort) >&2\necho pi-stand-in\n', { mode: 0o755 });
return (adapter, extra = {}) => spawnSync(join(opt, "src", "run-agent.sh"), ["the request"], {
encoding: "utf8",
timeout: 20000,
env: { PATH: `${dirname(process.execPath)}:/usr/bin:/bin`, HOME: root, MOSAIC_ADAPTER: adapter, MOSAIC_SYSTEM_PROMPT_FILE: join(root, "prompt.md"), MOSAIC_MOCK_RESPONSE: "MOCK_OK", ...extra },
});
}
test("run-agent.sh: a headless pi worker gets MOSAIC_PI_FINAL_STOP=1, and the mock sees exactly the variables it did", (t) => {
const run = entrypoint(t);
const pi = run("pi");
assert.equal(pi.status, 0, pi.stderr);
assert.match(pi.stderr, /^MOSAIC_PI_FINAL_STOP=1$/m);
const mock = run("mock");
assert.equal(mock.status, 0, mock.stderr);
assert.equal(mock.stdout, "MOCK_OK\n");
const vars = mock.stderr.split("\n").filter((l) => l.startsWith("MOSAIC_")).map((l) => l.split("=")[0]);
assert.deepEqual(vars, ["MOSAIC_ADAPTER", "MOSAIC_MOCK_RESPONSE", "MOSAIC_REQUEST", "MOSAIC_SYSTEM_PROMPT_FILE"]);
const interactive = run("pi", { MOSAIC_INTERACTIVE: "1" });
assert.equal(interactive.status, 0, interactive.stderr);
assert.doesNotMatch(interactive.stderr, /MOSAIC_PI_FINAL_STOP/);
});
// --- run-task prints the cause of a failed run ---------------------------------------------------
function runTask(t, dockerBody) {
const root = tmp(t), f = fixture(root), bin = join(root, "bin");
mkdirSync(bin);
writeFileSync(join(bin, "docker"), `#!${process.execPath}\n${dockerBody}\n`, { mode: 0o755 });
f.env.PATH = `${bin}:${f.env.PATH}`;
const task = join(root, "task.json");
writeFileSync(task, JSON.stringify({ taskVersion: 1, id: "one", prompt: "request" }));
const r = spawnSync(process.execPath, [TASK, "run", task], { env: f.env, encoding: "utf8", timeout: 20000 });
const runs = join(f.dataRoot, "runs");
const [id] = readdirSync(runs);
return { r, id, record: JSON.parse(readFileSync(join(runs, id, "result.json"), "utf8")) };
}
test("run-task: a worker that stops on an error is a failed run whose cause the terminal shows", (t) => {
const { r, id, record } = runTask(t, 'process.stderr.write("pi stopped on an error: 401 invalid x-api-key\\n"); process.exit(1);');
assert.equal(r.status, 1, r.stderr);
assert.equal(record.status, "failed");
assert.equal(record.reason, "exit-nonzero");
assert.equal(r.stdout, `run: ${id}\nstatus: failed (exit-nonzero)\nresponse: \ncause: worker said: pi stopped on an error: 401 invalid x-api-key\n`);
});
test("run-task: a succeeded run prints no cause line", (t) => {
const { r, id, record } = runTask(t, 'console.log("normal response");');
assert.equal(r.status, 0, r.stderr);
assert.equal(record.status, "succeeded");
assert.equal(r.stdout, `run: ${id}\nstatus: succeeded\nresponse: normal response\n`);
});
@@ -0,0 +1,201 @@
#!/usr/bin/env node
// Host relay for worker containers (worker-proxy-simple, slice S2).
//
// node proxy-relay.mjs <socket path> 127.0.0.1:<port>
//
// Listens on one Unix socket and copies bytes, both ways, to the one loopback
// port its caller names: the user-level model proxy. It parses nothing and
// holds no key. The only address it ever opens is 127.0.0.1:<port>, checked
// once at start; any other target refuses before anything listens.
//
// The caller makes the socket's directory first, mode 0700, owned by this
// user. The relay refuses a directory that is a symbolic link, is owned by
// another user or grants any group or other bit, a socket path that is
// relative or 108 bytes or longer (the Linux sun_path limit counts the NUL),
// and a path that already exists. The socket itself is created 0600.
//
// Lifetime. The caller spawns the relay with a pipe on stdin and keeps it
// open. The relay exits on EOF there, which is what the caller's exit gives,
// clean or not. It also exits on SIGTERM, SIGINT or SIGHUP, and when its
// parent process id changes. On exit it closes every connection and the
// listener, which removes the socket file; the caller removes the directory.
//
// Output. One line "ready" on stdout once the socket listens, then nothing
// more. A refusal is one line on stderr and exit 2. Nothing is written per
// connection: the caller may be blocked in spawnSync and not draining pipes.
// Not wired into any launch yet; the cutover slice (S4) starts it.
import { spawn } from 'node:child_process';
import { chmodSync, lstatSync, realpathSync } from 'node:fs';
import net from 'node:net';
import { dirname, isAbsolute } from 'node:path';
import { fileURLToPath } from 'node:url';
export const SOCKET_PATH_LIMIT = 108;
const SELF = fileURLToPath(import.meta.url);
function refusal(message) {
const error = new Error(message);
error.relayRefusal = true;
return error;
}
// Only the literal 127.0.0.1 and a decimal port 1 to 65535. No name lookup,
// no IPv6, no other loopback address.
export function relayTarget(target) {
const match = typeof target === 'string' ? /^127\.0\.0\.1:([1-9][0-9]{0,4})$/.exec(target) : null;
const port = match ? Number(match[1]) : 0;
if (!match || port > 65535) throw refusal('proxy relay: the target must be 127.0.0.1:<port>.');
return { host: '127.0.0.1', port };
}
export function relaySocketPath(socketPath) {
if (typeof socketPath !== 'string' || !isAbsolute(socketPath)) {
throw refusal('proxy relay: the socket path must be absolute.');
}
const bytes = Buffer.byteLength(socketPath, 'utf8');
if (bytes >= SOCKET_PATH_LIMIT) {
throw refusal(`proxy relay: the socket path is ${bytes} bytes; it must be under ${SOCKET_PATH_LIMIT}.`);
}
const dir = dirname(socketPath);
let stat;
try { stat = lstatSync(dir); }
catch { throw refusal('proxy relay: the socket directory is missing.'); }
if (!stat.isDirectory() || stat.uid !== process.getuid() || (stat.mode & 0o777) !== 0o700) {
throw refusal('proxy relay: the socket directory must be a 0700 directory owned by this user.');
}
let exists = true;
try { lstatSync(socketPath); } catch (error) { if (error.code === 'ENOENT') exists = false; }
if (exists) throw refusal('proxy relay: the socket path already exists.');
return socketPath;
}
// Copy bytes both ways. An error on either side ends both at once. A clean
// close of one side only ends the other, so bytes still queued for a slow
// reader are flushed first; that side is destroyed when its peer closes too,
// or LINGER_MS after its last byte was written. The same helper is in
// adapters/pi/proxy-forward.mjs, which the image carries without this package.
const LINGER_MS = 10000;
function join(a, b) {
const kill = () => { a.destroy(); b.destroy(); };
const finish = (other) => () => {
if (other.destroyed) return;
other.resume();
other.end();
const linger = () => {
const timer = setTimeout(() => other.destroy(), LINGER_MS).unref();
other.once('close', () => clearTimeout(timer));
};
if (other.writableFinished) linger(); else other.once('finish', linger);
};
a.on('error', kill); b.on('error', kill);
a.on('close', finish(b)); b.on('close', finish(a));
a.pipe(b); b.pipe(a);
}
function main(argv) {
let socketPath, target;
try {
if (argv.length !== 2) throw refusal('proxy relay: usage: proxy-relay.mjs <socket path> 127.0.0.1:<port>.');
target = relayTarget(argv[1]);
socketPath = relaySocketPath(argv[0]);
} catch (error) {
process.stderr.write(`${error.relayRefusal ? error.message : 'proxy relay: could not start.'}\n`);
process.exit(2);
}
const parent = process.ppid;
const live = new Set();
let stopping = false;
const server = net.createServer({ allowHalfOpen: true });
function stop(code = 0) {
if (stopping) return;
stopping = true;
for (const socket of live) socket.destroy();
// Closing a bound listener removes its socket file (libuv unlinks it).
server.close(() => process.exit(code));
setTimeout(() => process.exit(code), 1000).unref();
}
server.on('connection', (client) => {
if (stopping) { client.destroy(); return; }
// The one address this process opens. Fixed at start, never from the client.
const upstream = net.connect({ host: target.host, port: target.port, family: 4, allowHalfOpen: true });
for (const socket of [client, upstream]) { live.add(socket); socket.on('close', () => live.delete(socket)); }
join(client, upstream);
});
server.on('error', (error) => {
if (!stopping) {
process.stderr.write(error.code === 'EADDRINUSE'
? 'proxy relay: the socket path already exists.\n'
: 'proxy relay: could not listen on the socket.\n');
process.exit(2);
}
});
process.stdin.on('data', () => {});
process.stdin.on('end', () => stop(0));
process.stdin.on('close', () => stop(0));
process.stdin.on('error', () => stop(0));
for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) process.on(signal, () => stop(0));
setInterval(() => { if (process.ppid !== parent) stop(0); }, 500).unref();
const mask = process.umask(0o177);
server.listen(socketPath, () => {
process.umask(mask);
if (stopping) return;
try { chmodSync(socketPath, 0o600); }
catch {
process.stderr.write('proxy relay: could not set the socket mode.\n');
stop(2);
return;
}
process.stdout.write('ready\n');
});
}
// For the cutover slice and the tests: start the relay as a child of this
// process and wait for its "ready" line. Rejects with the relay's own refusal
// line when it exits first. The child stays in the caller's process group.
export function spawnRelay({ socketPath, target, node = process.execPath, timeoutMs = 5000 } = {}) {
return new Promise((resolveStart, rejectStart) => {
// An empty environment: the relay reads none, and must never carry the
// caller's keys or NODE_OPTIONS.
const child = spawn(node, [SELF, socketPath, target], { env: {}, stdio: ['pipe', 'pipe', 'pipe'] });
child.stdin.on('error', () => {});
let out = '', err = '', settled = false;
const settle = (fn, value) => { if (!settled) { settled = true; clearTimeout(timer); fn(value); } };
const timer = setTimeout(() => {
child.kill('SIGKILL');
settle(rejectStart, new Error('proxy relay: did not start in time.'));
}, timeoutMs);
child.stdout.on('data', (chunk) => {
out += chunk;
if (out.includes('ready\n')) {
settle(resolveStart, {
child,
// EOF on stdin, then SIGKILL after killAfterMs if the relay is wedged.
stop({ killAfterMs = 2000 } = {}) {
return new Promise((done) => {
if (child.exitCode !== null || child.signalCode !== null) { done(); return; }
const kill = setTimeout(() => child.kill('SIGKILL'), killAfterMs);
child.once('exit', () => { clearTimeout(kill); done(); });
child.stdin.end();
});
},
});
}
});
child.stderr.on('data', (chunk) => { err += chunk; });
child.on('error', (error) => settle(rejectStart, error));
child.on('exit', () => settle(rejectStart, new Error(err.trim().split('\n')[0] || 'proxy relay: exited before it was ready.')));
});
}
function isMain() {
try { return process.argv[1] !== undefined && realpathSync(process.argv[1]) === realpathSync(SELF); }
catch { return false; }
}
if (isMain()) main(process.argv.slice(2));
@@ -0,0 +1,631 @@
// Slice S2 of worker-proxy-simple: the host relay (src/proxy-relay.mjs) and
// the in-container forwarder (adapters/pi/proxy-forward.mjs), against a fake
// proxy on port 0. Nothing here starts Docker. Run with a TMPDIR of 31 bytes
// or less so every socket path stays well under the 108-byte limit.
import test from 'node:test';
import assert from 'node:assert/strict';
import { spawn, spawnSync } from 'node:child_process';
import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
import http from 'node:http';
import net from 'node:net';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { relayTarget, relaySocketPath, spawnRelay, SOCKET_PATH_LIMIT } from '../src/proxy-relay.mjs';
const RELAY = fileURLToPath(new URL('../src/proxy-relay.mjs', import.meta.url));
const FORWARD = fileURLToPath(new URL('../../../adapters/pi/proxy-forward.mjs', import.meta.url));
const LINE = 'worker: the container could not reach the model proxy socket.\n';
const pause = ms => new Promise(r => setTimeout(r, ms));
function scratch(t) {
const base = mkdtempSync(join(tmpdir(), 'r'));
const dir = join(base, 'd');
mkdirSync(dir, { mode: 0o700 });
t.after(() => rmSync(base, { recursive: true, force: true }));
return { base, dir, sock: join(dir, 'p.sock') };
}
function listen(server) {
return new Promise((r) => server.listen(0, '127.0.0.1', () => r(server.address().port)));
}
// A fake model proxy: counts TCP connections, answers HTTP, can stream.
async function fakeProxy(t) {
const seen = { connections: 0, requests: [] };
const server = http.createServer({ keepAliveTimeout: 5000 }, async (req, res) => {
let body = '';
for await (const chunk of req) body += chunk;
seen.requests.push({ method: req.method, url: req.url, body, socket: req.socket.remotePort });
if (req.url === '/stream') {
res.writeHead(200, { 'content-type': 'text/event-stream' });
for (let i = 0; i < 5; i++) { res.write(`data: ${i}\n\n`); await pause(30); }
res.end('data: done\n\n');
return;
}
res.writeHead(200, { 'content-type': 'text/plain' });
res.end(`ok ${req.method} ${req.url} ${body.length}`);
});
server.on('connection', () => { seen.connections++; });
const port = await listen(server);
t.after(() => { server.closeAllConnections(); server.close(); });
return { server, port, seen };
}
// A raw TCP echo listener, used as the proxy for binary round trips and as a
// decoy port that must never see a connection.
async function tcpListener(t, onSocket = s => s.pipe(s)) {
const seen = { connections: 0 };
const server = net.createServer({ allowHalfOpen: true }, (s) => { seen.connections++; onSocket(s); });
const port = await listen(server);
t.after(() => server.close());
return { port, seen };
}
async function freePort() {
const s = net.createServer();
const port = await listen(s);
await new Promise(r => s.close(r));
return port;
}
function run(file, args, { timeout = 15000 } = {}) {
return spawnSync(process.execPath, [file, ...args], { encoding: 'utf8', timeout, stdio: ['pipe', 'pipe', 'pipe'] });
}
// Start the forwarder and wait for its "ready" line, or its exit.
function startForwarder(t, sock, port) {
return new Promise((resolveStart) => {
const child = spawn(process.execPath, [FORWARD, sock, String(port)], { stdio: ['ignore', 'pipe', 'pipe'] });
let out = '', err = '', done = false;
const finish = (value) => { if (!done) { done = true; resolveStart(value); } };
child.stdout.on('data', (c) => { out += c; if (out.includes('ready\n')) finish({ child, ready: true, err: () => err, out: () => out }); });
child.stderr.on('data', (c) => { err += c; });
child.on('exit', (code) => finish({ child, ready: false, code, err: () => err, out: () => out }));
t.after(() => { if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL'); });
});
}
function request(agent, port, path, { method = 'GET', body } = {}) {
return new Promise((resolveReq, rejectReq) => {
const req = http.request({ host: '127.0.0.1', port, path, method, agent }, (res) => {
const chunks = [];
const times = [];
res.on('data', (c) => { chunks.push(String(c)); times.push(Date.now()); });
res.on('end', () => resolveReq({ status: res.statusCode, chunks, times, body: chunks.join('') }));
});
req.on('error', rejectReq);
if (body) req.write(body);
req.end();
});
}
function unixRoundTrip(sock, bytes) {
return new Promise((resolveTrip, rejectTrip) => {
const c = net.connect({ path: sock, allowHalfOpen: true });
const got = [];
c.on('connect', () => { c.end(bytes); });
c.on('data', (d) => got.push(d));
c.on('end', () => { c.end(); resolveTrip(Buffer.concat(got)); });
c.on('error', rejectTrip);
});
}
function groupAlive(pgid) {
try { process.kill(-pgid, 0); return true; } catch (error) { return error.code !== 'ESRCH'; }
}
// A client that sends its request, half-closes, then reads slowly.
function slowHalfClose(connectOpts, bytes) {
return new Promise((resolveTrip, rejectTrip) => {
const c = net.connect({ ...connectOpts, allowHalfOpen: true });
let got = 0;
c.on('connect', () => c.end(bytes));
c.on('data', (d) => { got += d.length; c.pause(); setTimeout(() => c.resume(), 2); });
c.on('end', () => { c.end(); resolveTrip(got); });
c.on('error', rejectTrip);
});
}
// A proxy that answers each connection with `size` bytes once the client half-closes.
function bigReply(size) {
return (s) => {
s.on('error', () => {});
s.once('data', (d) => { if (String(d).startsWith('HEAD ')) s.end('HTTP/1.1 200 OK\r\ncontent-length: 0\r\n\r\n'); });
s.on('end', () => { if (!s.writableEnded) s.end(Buffer.alloc(size, 0x61)); });
};
}
test('target: only 127.0.0.1 with a decimal port 1 to 65535', () => {
assert.deepEqual(relayTarget('127.0.0.1:8317'), { host: '127.0.0.1', port: 8317 });
assert.deepEqual(relayTarget('127.0.0.1:65535'), { host: '127.0.0.1', port: 65535 });
for (const bad of ['0.0.0.0:80', '127.0.0.2:80', '127.1:80', 'localhost:80', '[::1]:80', '::1:80', '10.0.0.1:80',
'127.0.0.1', '127.0.0.1:', '127.0.0.1:0', '127.0.0.1:65536', '127.0.0.1:080', '127.0.0.1:+80', '127.0.0.1:80x',
' 127.0.0.1:80', '127.0.0.1:80\n', '127.0.0.1:0x50', 'http://127.0.0.1:80', undefined, 8080]) {
assert.throws(() => relayTarget(bad), /target must be 127\.0\.0\.1:<port>/, String(bad));
}
});
test('relay CLI refuses a non-loopback target with one line, and listens nowhere', (t) => {
const { dir, sock } = scratch(t);
for (const bad of ['192.168.1.1:80', '0.0.0.0:443', 'localhost:8317', '[::1]:8317', '127.0.0.1:0']) {
const r = run(RELAY, [sock, bad]);
assert.equal(r.status, 2, bad);
assert.equal(r.stdout, '');
assert.equal(r.stderr, 'proxy relay: the target must be 127.0.0.1:<port>.\n');
assert.equal(existsSync(sock), false);
}
const usage = run(RELAY, [sock]);
assert.equal(usage.status, 2);
assert.equal(usage.stderr.split('\n').length, 2);
assert.ok(existsSync(dir));
});
test('relay refuses a socket path of 108 bytes or more, and accepts 107', async (t) => {
const { dir } = scratch(t);
const pad = (n) => join(dir, 'x'.repeat(n - dir.length - 1));
const long = pad(SOCKET_PATH_LIMIT);
assert.equal(Buffer.byteLength(long), 108);
const r = run(RELAY, [long, '127.0.0.1:9']);
assert.equal(r.status, 2);
assert.equal(r.stderr, 'proxy relay: the socket path is 108 bytes; it must be under 108.\n');
assert.equal(existsSync(long), false);
const longer = run(RELAY, [pad(200), '127.0.0.1:9']);
assert.equal(longer.stderr, 'proxy relay: the socket path is 200 bytes; it must be under 108.\n');
const fits = pad(107);
const relay = await spawnRelay({ socketPath: fits, target: '127.0.0.1:9' });
assert.ok(lstatSync(fits).isSocket());
await relay.stop();
});
test('relay refuses an unsafe socket directory or an existing path', (t) => {
const { base, dir, sock } = scratch(t);
assert.throws(() => relaySocketPath('rel/p.sock'), /must be absolute/);
assert.throws(() => relaySocketPath(join(base, 'none', 'p.sock')), /socket directory is missing/);
const open = join(base, 'o');
mkdirSync(open, { mode: 0o755 });
assert.throws(() => relaySocketPath(join(open, 'p.sock')), /0700 directory owned by this user/);
const link = join(base, 'l');
symlinkSync(dir, link);
assert.throws(() => relaySocketPath(join(link, 'p.sock')), /0700 directory owned by this user/);
writeFileSync(sock, '');
assert.throws(() => relaySocketPath(sock), /already exists/);
const r = run(RELAY, [sock, '127.0.0.1:9']);
assert.equal(r.status, 2);
assert.equal(r.stderr, 'proxy relay: the socket path already exists.\n');
assert.equal(lstatSync(sock).isFile(), true);
});
test('relay socket is 0600 and copies bytes both ways to the one port', async (t) => {
const { sock } = scratch(t);
const echo = await tcpListener(t);
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${echo.port}` });
t.after(() => relay.stop());
assert.equal(lstatSync(sock).mode & 0o777, 0o600);
const bytes = Buffer.alloc(300000);
for (let i = 0; i < bytes.length; i++) bytes[i] = (i * 31 + 7) & 0xff;
const back = await unixRoundTrip(sock, bytes);
assert.ok(back.equals(bytes));
const [a, b] = await Promise.all([unixRoundTrip(sock, Buffer.from('one')), unixRoundTrip(sock, Buffer.from('two'))]);
assert.equal(String(a), 'one');
assert.equal(String(b), 'two');
assert.equal(echo.seen.connections, 3);
});
test('full path: streamed reply and kept-alive requests on one connection', async (t) => {
const { sock } = scratch(t);
const proxy = await fakeProxy(t);
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
let fwd;
for (let i = 0; i < 5; i++) {
fwd = await startForwarder(t, sock, await freePort());
if (fwd.ready) break;
}
assert.ok(fwd.ready, fwd.err());
const port = Number(fwd.child.spawnargs.at(-1));
assert.equal(proxy.seen.requests[0].method, 'HEAD', 'the start check reaches the proxy');
const checkConnections = proxy.seen.connections;
const agent = new http.Agent({ keepAlive: true, maxSockets: 1 });
t.after(() => agent.destroy());
const one = await request(agent, port, '/v1/models');
const two = await request(agent, port, '/v1/messages', { method: 'POST', body: '{"model":"m","x":"' + 'y'.repeat(70000) + '"}' });
const three = await request(agent, port, '/stream');
assert.equal(one.body, 'ok GET /v1/models 0');
assert.equal(two.body, 'ok POST /v1/messages 70020');
assert.equal(three.body, 'data: 0\n\ndata: 1\n\ndata: 2\n\ndata: 3\n\ndata: 4\n\ndata: done\n\n');
assert.ok(three.chunks.length >= 3, `streamed in pieces: ${three.chunks.length}`);
assert.ok(three.times.at(-1) - three.times[0] >= 60, 'pieces arrived over time, not buffered');
const kept = proxy.seen.requests.slice(1);
assert.equal(kept.length, 3);
assert.equal(proxy.seen.connections - checkConnections, 1, 'three requests, one proxy connection');
assert.equal(new Set(kept.map(r => r.socket)).size, 1);
assert.equal(fwd.err(), '');
});
test('traffic reaches only the proxy port, whatever the bytes name', async (t) => {
const { sock } = scratch(t);
const decoy = await tcpListener(t);
const proxied = [];
const proxy = await tcpListener(t, (s) => {
s.on('data', (d) => proxied.push(String(d)));
s.on('end', () => s.end('HTTP/1.1 200 OK\r\ncontent-length: 0\r\n\r\n'));
});
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
const asks = [
`CONNECT 127.0.0.1:${decoy.port} HTTP/1.1\r\nHost: 127.0.0.1:${decoy.port}\r\n\r\n`,
`GET http://127.0.0.1:${decoy.port}/ HTTP/1.1\r\nHost: 127.0.0.1:${decoy.port}\r\n\r\n`,
`GET / HTTP/1.1\r\nHost: example.com\r\nX-Forwarded-Host: 10.0.0.1\r\n\r\n`,
];
for (const ask of asks) {
const back = await unixRoundTrip(sock, Buffer.from(ask));
assert.match(String(back), /^HTTP\/1\.1 200 OK/);
}
assert.equal(proxy.seen.connections, 3);
assert.equal(decoy.seen.connections, 0);
assert.deepEqual(proxied, asks);
});
test('relay exits on its parent\'s signal and on stdin EOF, removing the socket; the caller removes the directory', async (t) => {
const { dir, sock } = scratch(t);
const proxy = await fakeProxy(t);
for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
const a = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => a.stop());
const exited = new Promise(r => a.child.once('exit', (code, sig) => r({ code, signal: sig })));
a.child.kill(signal);
assert.deepEqual(await exited, { code: 0, signal: null }, signal);
assert.equal(existsSync(sock), false, signal);
}
const b = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => b.stop());
const held = net.connect({ path: sock });
await new Promise(r => held.once('connect', r));
const heldClosed = new Promise(r => held.once('close', r));
await b.stop();
await heldClosed;
assert.equal(b.child.exitCode, 0);
assert.equal(existsSync(sock), false);
rmSync(dir, { recursive: true });
assert.equal(existsSync(dir), false);
});
test('relay runs with an empty environment', async (t) => {
const { sock } = scratch(t);
process.env.RELAY_TEST_MARKER = 'must-not-pass';
t.after(() => { delete process.env.RELAY_TEST_MARKER; });
const relay = await spawnRelay({ socketPath: sock, target: '127.0.0.1:9' });
t.after(() => relay.stop());
assert.equal(readFileSync(`/proc/${relay.child.pid}/environ`).length, 0);
});
test('stop() kills a relay that does not exit on EOF', async (t) => {
const { sock } = scratch(t);
const relay = await spawnRelay({ socketPath: sock, target: '127.0.0.1:9' });
t.after(() => { try { relay.child.kill('SIGKILL'); } catch {} });
relay.child.kill('SIGSTOP');
const started = Date.now();
await relay.stop({ killAfterMs: 300 });
assert.equal(relay.child.signalCode, 'SIGKILL');
assert.ok(Date.now() - started < 3000);
});
test('relay exits when its parent changes, even while its stdin stays open', async (t) => {
const { base, sock } = scratch(t);
const proxy = await fakeProxy(t);
// The middle process gives the relay a stdin pipe whose write end a third
// process (sleep) holds, so only the parent check can end the relay once
// the middle dies. Node closes a child's own stdin pipe when it exits.
const middleFile = join(base, 'middle.mjs');
writeFileSync(middleFile, `import { spawn } from 'node:child_process';
const holder = spawn('sleep', ['30'], { stdio: ['ignore', 'pipe', 'ignore'] });
const relay = spawn(process.execPath, [${JSON.stringify(RELAY)}, process.argv[2], process.argv[3]], { env: {}, stdio: [holder.stdout, 'pipe', 'inherit'] });
relay.stdout.on('data', (c) => { if (String(c).includes('ready')) process.stdout.write('relay ' + relay.pid + ' ' + holder.pid + '\\n'); });
setInterval(() => {}, 1000);
`);
const middle = spawn(process.execPath, [middleFile, sock, `127.0.0.1:${proxy.port}`], { detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
t.after(() => { try { process.kill(-middle.pid, 'SIGKILL'); } catch {} });
const [relayPid, holderPid] = await new Promise((resolvePid, rejectPid) => {
let out = '';
middle.stdout.on('data', (c) => { out += c; const m = /relay (\d+) (\d+)\n/.exec(out); if (m) resolvePid([Number(m[1]), Number(m[2])]); });
middle.on('exit', () => rejectPid(new Error('middle exited early')));
});
const middleGone = new Promise(r => middle.once('exit', r));
process.kill(middle.pid, 'SIGKILL');
await middleGone;
const deadline = Date.now() + 4000;
while (Date.now() < deadline) {
try { process.kill(relayPid, 0); } catch { break; }
await pause(50);
}
process.kill(holderPid, 0); // the stdin write end was still held when the relay exited
assert.throws(() => process.kill(relayPid, 0), { code: 'ESRCH' });
assert.equal(existsSync(sock), false);
});
test('half-closed client reading slowly gets the whole reply, through the relay and through the forwarder', async (t) => {
const { sock } = scratch(t);
const size = 3 * 1024 * 1024;
const proxy = await tcpListener(t, bigReply(size));
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
for (let i = 0; i < 3; i++) assert.equal(await slowHalfClose({ path: sock }, Buffer.from('ask')), size, `relay round ${i}`);
let fwd;
for (let i = 0; i < 5; i++) { fwd = await startForwarder(t, sock, await freePort()); if (fwd.ready) break; }
assert.ok(fwd.ready, fwd.err());
const port = Number(fwd.child.spawnargs.at(-1));
for (let i = 0; i < 3; i++) assert.equal(await slowHalfClose({ host: '127.0.0.1', port }, Buffer.from('ask')), size, `forwarder round ${i}`);
assert.equal(fwd.err(), '');
});
test('relay exits when its parent is killed and leaves no process in the group', async (t) => {
const { base, dir, sock } = scratch(t);
const proxy = await fakeProxy(t);
const parentFile = join(base, 'parent.mjs');
writeFileSync(parentFile, `import { spawnRelay } from ${JSON.stringify(RELAY)};
const relay = await spawnRelay({ socketPath: process.argv[2], target: process.argv[3] });
process.stdout.write('relay ' + relay.child.pid + '\\n');
setInterval(() => {}, 1000);
`);
const parent = spawn(process.execPath, [parentFile, sock, `127.0.0.1:${proxy.port}`], { detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
const pgid = parent.pid;
t.after(() => { try { process.kill(-pgid, 'SIGKILL'); } catch {} });
const relayPid = await new Promise((resolvePid, rejectPid) => {
let out = '';
parent.stdout.on('data', (c) => { out += c; const m = /relay (\d+)\n/.exec(out); if (m) resolvePid(Number(m[1])); });
parent.on('exit', () => rejectPid(new Error('parent exited early')));
});
assert.ok(groupAlive(pgid));
process.kill(relayPid, 0);
// A live connection through the relay must not keep it alive.
const held = net.connect({ path: sock });
await new Promise(r => held.once('connect', r));
held.on('error', () => {});
const parentGone = new Promise(r => parent.once('exit', r));
process.kill(parent.pid, 'SIGKILL');
await parentGone;
const deadline = Date.now() + 5000;
while (groupAlive(pgid) && Date.now() < deadline) await pause(50);
assert.equal(groupAlive(pgid), false, 'no process left in the parent\'s group');
assert.throws(() => process.kill(relayPid, 0), { code: 'ESRCH' });
assert.equal(existsSync(sock), false);
held.destroy();
rmSync(dir, { recursive: true });
assert.equal(existsSync(dir), false);
});
test('forwarder: a missing socket gives the fixed line and exit 1', (t) => {
const { sock } = scratch(t);
const r = run(FORWARD, [sock, '9']);
assert.equal(r.status, 1);
assert.equal(r.stdout, '');
assert.equal(r.stderr, LINE);
});
test('forwarder: a dead socket file gives the fixed line and exit 1', async (t) => {
const { dir, sock } = scratch(t);
// A socket file with no listener behind it: the relay was SIGKILLed.
const relay = await spawnRelay({ socketPath: sock, target: '127.0.0.1:9' });
const gone = new Promise(r => relay.child.once('exit', r));
relay.child.kill('SIGKILL');
await gone;
assert.ok(lstatSync(sock).isSocket());
const r = run(FORWARD, [sock, '9']);
assert.equal(r.status, 1);
assert.equal(r.stdout, '');
assert.equal(r.stderr, LINE);
rmSync(dir, { recursive: true });
});
test('forwarder: a live relay with no proxy behind it gives the fixed line and exit 1', async (t) => {
const { sock } = scratch(t);
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${await freePort()}` });
t.after(() => relay.stop());
const r = run(FORWARD, [sock, '9']);
assert.equal(r.status, 1);
assert.equal(r.stdout, '');
assert.equal(r.stderr, LINE);
});
test('forwarder: a proxy that accepts but never answers gives the fixed line after the check timeout', async (t) => {
const { sock } = scratch(t);
const silent = await tcpListener(t, (s) => { s.on('data', () => {}); });
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${silent.port}` });
t.after(() => relay.stop());
const started = Date.now();
const r = run(FORWARD, [sock, '9']);
assert.equal(r.status, 1);
assert.equal(r.stderr, LINE);
assert.ok(Date.now() - started >= 4500);
});
test('forwarder: bad arguments refuse with a usage line and exit 2', (t) => {
const { sock } = scratch(t);
for (const args of [[], [sock], ['rel.sock', '80'], [sock, '0'], [sock, '65536'], [sock, '80x'], [sock, '080']]) {
const r = run(FORWARD, args);
assert.equal(r.status, 2, JSON.stringify(args));
assert.equal(r.stderr, 'worker: proxy forwarder usage: proxy-forward.mjs <socket path> <port>.\n');
}
});
test('forwarder: a lost relay after start prints the fixed line once', async (t) => {
const { sock } = scratch(t);
const proxy = await fakeProxy(t);
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
let fwd;
for (let i = 0; i < 5; i++) { fwd = await startForwarder(t, sock, await freePort()); if (fwd.ready) break; }
assert.ok(fwd.ready, fwd.err());
const port = Number(fwd.child.spawnargs.at(-1));
await relay.stop();
for (let i = 0; i < 3; i++) {
await assert.rejects(request(undefined, port, '/v1/models'));
}
await pause(100);
assert.equal(fwd.err(), LINE);
});
test('forwarder: a proxy gone after the start check prints the fixed line once', async (t) => {
const { sock } = scratch(t);
const proxy = await fakeProxy(t);
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
let fwd;
for (let i = 0; i < 5; i++) { fwd = await startForwarder(t, sock, await freePort()); if (fwd.ready) break; }
assert.ok(fwd.ready, fwd.err());
const port = Number(fwd.child.spawnargs.at(-1));
proxy.server.closeAllConnections();
await new Promise(r => proxy.server.close(r));
for (let i = 0; i < 3; i++) await assert.rejects(request(undefined, port, '/v1/models'));
await pause(100);
assert.equal(fwd.err(), LINE);
assert.equal(fwd.child.exitCode, null, 'the forwarder keeps running');
});
test('forwarder: an idle connection the proxy closes is not a lost proxy, a request it hangs up on is', async (t) => {
const { sock } = scratch(t);
// Answers the start check, closes a connection idle for 200 ms, and hangs
// up on any other request with no reply.
const proxy = await tcpListener(t, (s) => {
s.on('error', () => {});
const idle = setTimeout(() => s.end(), 200);
s.once('data', (d) => {
clearTimeout(idle);
if (String(d).startsWith('HEAD ')) s.end('HTTP/1.1 200 OK\r\ncontent-length: 0\r\n\r\n');
else s.end();
});
});
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
let fwd;
for (let i = 0; i < 5; i++) { fwd = await startForwarder(t, sock, await freePort()); if (fwd.ready) break; }
assert.ok(fwd.ready, fwd.err());
const port = Number(fwd.child.spawnargs.at(-1));
for (let i = 0; i < 3; i++) {
const c = net.connect({ host: '127.0.0.1', port });
c.on('error', () => {});
c.resume();
await new Promise(r => c.once('close', r));
}
await pause(100);
assert.equal(fwd.err(), '', 'an idle close prints nothing');
await assert.rejects(request(undefined, port, '/v1/models'));
await pause(100);
assert.equal(fwd.err(), LINE);
});
// The copier's error path: a reset or a drop on one side must end the other
// side at once, so no socket is left behind in the relay or the forwarder.
test('dropped and reset connections mid-stream leave no socket in the relay or the forwarder', async (t) => {
const { sock } = scratch(t);
const open = new Set();
t.after(() => { for (const s of open) s.destroy(); });
const proxy = await tcpListener(t, (s) => {
open.add(s);
s.on('error', () => {});
let timer;
s.once('data', (d) => {
if (String(d).startsWith('HEAD ')) { s.end('HTTP/1.1 200 OK\r\ncontent-length: 0\r\n\r\n'); return; }
timer = setInterval(() => s.write(Buffer.alloc(1024, 0x62)), 20);
});
// Like a streaming HTTP reply, it keeps writing after the client's FIN
// and stops only when its socket closes.
s.on('close', () => { clearInterval(timer); open.delete(s); });
});
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
let fwd;
for (let i = 0; i < 5; i++) { fwd = await startForwarder(t, sock, await freePort()); if (fwd.ready) break; }
assert.ok(fwd.ready, fwd.err());
const port = Number(fwd.child.spawnargs.at(-1));
const fds = (pid) => readdirSync(`/proc/${pid}/fd`).length;
// Let the start check's own connection close in the relay before counting.
const settleBy = Date.now() + 2000;
while (Date.now() < settleBy && open.size > 0) await pause(20);
await pause(200);
const base = { relay: fds(relay.child.pid), fwd: fds(fwd.child.pid) };
const streamThenDrop = (opts, drop) => new Promise((resolveDrop) => {
const c = net.connect(opts);
c.on('error', () => {});
c.once('connect', () => c.write('GET /s HTTP/1.1\r\n\r\n'));
c.once('data', () => { drop(c); });
c.once('close', resolveDrop);
});
const waves = [
[{ host: '127.0.0.1', port }, c => c.resetAndDestroy()],
[{ host: '127.0.0.1', port }, c => c.destroy()],
[{ path: sock }, c => c.destroy()],
];
for (const [opts, drop] of waves) await Promise.all(Array.from({ length: 40 }, () => streamThenDrop(opts, drop)));
const deadline = Date.now() + 3000;
while (Date.now() < deadline && (fds(relay.child.pid) > base.relay || fds(fwd.child.pid) > base.fwd || open.size > 0)) await pause(50);
const now = { relay: fds(relay.child.pid), fwd: fds(fwd.child.pid), proxy: open.size };
assert.ok(now.relay <= base.relay && now.fwd <= base.fwd && now.proxy === 0, JSON.stringify({ base, now }));
assert.equal(fwd.err(), '');
});
test('forwarder: stdout carries only "ready" and closes, so a shell can capture it', async (t) => {
const { base, sock } = scratch(t);
const proxy = await fakeProxy(t);
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
const port = await freePort();
const script = join(base, 'cap.sh');
writeFileSync(script, 'ready=$("$1" "$2" "$3" "$4" &)\nprintf "[%s]\\n" "$ready"\n');
const sh = spawn('sh', [script, process.execPath, FORWARD, sock, String(port)], { detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
t.after(() => { try { process.kill(-sh.pid, 'SIGKILL'); } catch {} });
let out = '';
sh.stdout.on('data', (c) => { out += c; });
const code = await new Promise(r => sh.once('exit', r));
assert.equal(code, 0);
assert.equal(out, '[ready]\n');
const one = await request(undefined, port, '/after');
assert.equal(one.body, 'ok GET /after 0');
});
// The container shape without Docker: bwrap gives an empty network namespace
// (loopback only, like network_mode: none) and a read-only bind of the socket
// directory, as the cutover's /run/mosaic-proxy mount will be. Same uid
// inside and out, so this proves nothing about Docker's uid mapping.
test('forwarder in a network namespace reaches the proxy through a read-only bind', async (t) => {
const probe = spawnSync('bwrap', ['--ro-bind', '/', '/', '--dev', '/dev', '--unshare-net', 'true'], { encoding: 'utf8' });
if (probe.error || probe.status !== 0) { t.skip('bwrap with --unshare-net is not available here'); return; }
const { base, dir, sock } = scratch(t);
const proxy = await fakeProxy(t);
const relay = await spawnRelay({ socketPath: sock, target: `127.0.0.1:${proxy.port}` });
t.after(() => relay.stop());
const inside = join(base, 'inside.mjs');
writeFileSync(inside, `import { spawn } from 'node:child_process';
import http from 'node:http';
const [fwd, port] = process.argv.slice(2);
const child = spawn(process.execPath, [fwd, '/run/mosaic-proxy/p.sock', port], { stdio: ['ignore', 'pipe', 'inherit'] });
let out = '';
child.stdout.on('data', (c) => { out += c; if (out === 'ready\\n') go(); });
child.on('exit', (code) => { if (out !== 'ready\\n') { process.stdout.write('forwarder exit ' + code + '\\n'); process.exit(1); } });
function go() {
http.get({ host: '127.0.0.1', port }, (res) => {
let body = ''; res.on('data', (c) => { body += c; });
res.on('end', () => {
const direct = http.get({ host: '127.0.0.1', port: ${proxy.port} });
direct.on('error', (e) => { process.stdout.write(body + '|direct ' + e.code + '\\n'); child.kill(); process.exit(0); });
direct.on('response', () => { process.stdout.write(body + '|direct reached\\n'); child.kill(); process.exit(0); });
});
}).on('error', (e) => { process.stdout.write('error ' + e.code + '\\n'); process.exit(1); });
}
`);
// Async: the fake proxy lives in this process, so a spawnSync here would starve it.
const box = spawn('bwrap', ['--ro-bind', '/', '/', '--dev', '/dev', '--proc', '/proc', '--tmpfs', '/run',
'--ro-bind', dir, '/run/mosaic-proxy', '--unshare-net', '--unshare-pid', '--die-with-parent',
process.execPath, inside, FORWARD, '7999'], { stdio: ['ignore', 'pipe', 'pipe'] });
const r = { stdout: '', stderr: '' };
box.stdout.on('data', (c) => { r.stdout += c; });
box.stderr.on('data', (c) => { r.stderr += c; });
const killer = setTimeout(() => box.kill('SIGKILL'), 20000);
r.status = await new Promise(done => box.once('close', done));
clearTimeout(killer);
assert.equal(r.stderr, '');
assert.equal(r.stdout, 'ok GET / 0|direct ECONNREFUSED\n');
assert.equal(r.status, 0);
});
+2 -1
View File
@@ -5,6 +5,7 @@
export { RunsError } from "./errors.mjs";
export { RUNS_DIRNAME, STATE_DIRNAME } from "./paths.mjs";
export {
RUN_ID_PATTERN, RUN_DOCUMENTS, isRunId, listRunIds, readRunDocument, listRunRecords, readRunRecord,
RUN_ID_PATTERN, RUN_DOCUMENTS, RUN_TEXTS, RUN_TEXT_TAIL, isRunId, listRunIds, readRunDocument, listRunRecords,
readRunRecord, readRunText,
} from "./runs.mjs";
export { POINTER_FILE, ACTIVATION_LOG_FILE, readActivePointer, readActivationLog } from "./state.mjs";
+37
View File
@@ -70,3 +70,40 @@ export function readRunRecord(dataRoot, runId) {
artifacts,
};
}
export const RUN_TEXTS = ["stderr.txt"];
export const RUN_TEXT_TAIL = 64 * 1024;
// The last RUN_TEXT_TAIL bytes of one of RUN_TEXTS from a run, as UTF-8 text, or null when it is
// missing, not a regular file, unreadable or outside the data root. A cut that lands inside a
// line drops that partial first line.
export function readRunText(dataRoot, runId, name) {
requireRunId(runId);
if (!RUN_TEXTS.includes(name)) throw new RunsError(`unknown run text: ${JSON.stringify(name)}`);
let fd;
try {
const file = resolveInside(dataRoot, RUNS_DIRNAME, runId, name);
if (file === null) return null;
fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
const stat = fs.fstatSync(fd);
if (!stat.isFile()) return null;
const length = Math.min(stat.size, RUN_TEXT_TAIL);
const buffer = Buffer.alloc(length);
let read = 0;
while (read < length) {
const n = fs.readSync(fd, buffer, read, length - read, stat.size - length + read);
if (n === 0) break;
read += n;
}
let text = buffer.subarray(0, read).toString("utf8");
if (stat.size > length) {
const newline = text.indexOf("\n");
text = newline < 0 ? "" : text.slice(newline + 1);
}
return text;
} catch {
return null;
} finally {
if (fd !== undefined) fs.closeSync(fd);
}
}
+27 -1
View File
@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
import fs from "node:fs";
import path from "node:path";
import {
RunsError, isRunId, listRunIds, listRunRecords, readRunDocument, readRunRecord,
RUN_TEXT_TAIL, RunsError, isRunId, listRunIds, listRunRecords, readRunDocument, readRunRecord, readRunText,
} from "../src/index.mjs";
import { RESULT, scratch, tree, write } from "./helpers.mjs";
@@ -241,3 +241,29 @@ test("the readers write nothing", (t) => {
readRunDocument(dataRoot, A, "mission.json");
assert.equal(tree(dataRoot), before);
});
test("readRunText reads a run's stderr.txt, its last RUN_TEXT_TAIL bytes from a line start", (t) => {
const { dataRoot } = scratch(t);
write(path.join(dataRoot, "runs", A, "stderr.txt"), "one\ntwo\n");
assert.equal(readRunText(dataRoot, A, "stderr.txt"), "one\ntwo\n");
const long = `${"x".repeat(RUN_TEXT_TAIL)}\nlast line\n`;
write(path.join(dataRoot, "runs", B, "stderr.txt"), long);
assert.equal(readRunText(dataRoot, B, "stderr.txt"), "last line\n");
});
test("readRunText is null for a missing run, a directory or a file linked out of the data root", (t) => {
const { dataRoot, outside } = scratch(t);
assert.equal(readRunText(dataRoot, A, "stderr.txt"), null);
fs.mkdirSync(path.join(dataRoot, "runs", A, "stderr.txt"), { recursive: true });
assert.equal(readRunText(dataRoot, A, "stderr.txt"), null);
write(path.join(outside, "secret.txt"), "outside\n");
fs.mkdirSync(path.join(dataRoot, "runs", B), { recursive: true });
fs.symlinkSync(path.join(outside, "secret.txt"), path.join(dataRoot, "runs", B, "stderr.txt"));
assert.equal(readRunText(dataRoot, B, "stderr.txt"), null);
});
test("readRunText reads only stderr.txt and refuses an invalid run id", (t) => {
const { dataRoot } = scratch(t);
assert.throws(() => readRunText(dataRoot, A, "result.json"), (e) => e instanceof RunsError && /unknown run text/.test(e.message));
assert.throws(() => readRunText(dataRoot, "../x", "stderr.txt"), (e) => e instanceof RunsError && /invalid run id/.test(e.message));
});
+66 -15
View File
@@ -25,8 +25,27 @@
// E2E6 P1-1: a poll reloads this state; the last save's receipt and the open review list stay.
// A failed poll keeps the last good read only while the page holds the form (dirty, or a field has
// focus), so the held form is not dropped (review P3). A clean form shows the read error (re-check P3).
const held=org=>{const form=[...document.querySelectorAll('[data-autonomy-org]')].find(n=>n.dataset.autonomyOrg===org)?.querySelector('[data-autonomy-form]');return !!form&&(form.hasAttribute('data-live-dirty')||form.contains(document.activeElement));};
async function load(org) {const prev=states.get(org),keep={status:prev?.status??'',reviewOpen:prev?.reviewOpen===true};try{states.set(org,{...await call(org,''),...keep});}catch(error){states.set(org,prev&&!prev.error&&held(org)?{...prev,...keep}:{error:error.message,...keep});}}
// The settings section the page draws now for this organization (a decision notice carries the org too).
const live=org=>[...document.querySelectorAll('[data-autonomy-org]')].find(n=>n.dataset.autonomyOrg===org&&!n.hasAttribute('data-autonomy-decision'));
const held=org=>{const form=live(org)?.querySelector('[data-autonomy-form]');return !!form&&(form.hasAttribute('data-live-dirty')||form.contains(document.activeElement));};
// Each organization keeps one state object for the life of the page. A save or review keeps a reference
// to it across its own request, so a load that ends meanwhile writes its read into that object in place
// and never swaps it: the receipt lands where the next draw reads it. A load that began before the last
// applied read, or before a save answered, carries older values, so its answer is dropped.
const own=['status','reviewOpen','began','shown'];
function put(s,read) {for(const k of Object.keys(s))if(!own.includes(k))delete s[k];for(const [k,v]of Object.entries(read))if(!own.includes(k))s[k]=v;}
const stateOf=org=>{if(!states.has(org))states.set(org,{error:'Autonomy could not be read.',status:'',reviewOpen:false,began:0,shown:0});return states.get(org);};
async function load(org) {
const s=stateOf(org),began=++s.began;let read,failed=false;
try{read=await call(org,'');}catch(error){read={error:error.message};failed=true;}
if(began<s.shown)return;
s.shown=began;
if(failed&&!s.error&&held(org))return;
put(s,read);
}
// A result said on this organization's status line: kept in its state for the next draw, and written to
// the line the page draws now.
function say(org,text) {const s=stateOf(org);s.status=text;const line=live(org)?.querySelector('[data-autonomy-status]');if(line)line.textContent=text;}
function section(org) {
const s=states.get(org);
if(!s || s.error)return `<section class="panel" data-autonomy><h3>Autonomy</h3><p>${esc(s?.error??'Autonomy could not be read.')}</p></section>`;
@@ -42,22 +61,52 @@
<p data-autonomy-status role="status">${esc(s.status)}</p></form>
${s.writable?`<details data-autonomy-review-list${s.reviewOpen?' open':''}><summary${fk('review-list')}>Review reversals before moving out of the loop</summary><p>Read the decision trail and its reversals before recording your review.</p>${classes.map(k=>`<button class="btn" type="button" data-autonomy-review="${k}"${fk(`review-${k}`)}>Record review: ${labels[k]}</button>`).join('')}</details>`:''}</section>`;
}
// Decision notices on /inbox/<id>. The bus page draws that view again on every poll, and a decision the
// owner confirmed, returned or reversed leaves the inbox read, so its notice is gone from the next draw.
// The owner's result for each decision is kept here, in page memory, and the notice is drawn from it:
// the result line stays, a call in flight keeps its buttons off, and a notice whose decision has left
// the read is drawn with its result line only. A decision that comes back into the read after a draw
// saw it gone (an arbiter resolving it again) is a new question, so its old result is dropped.
const answers=new Map(),answerKey=(org,id)=>JSON.stringify([org,id]);
const noticeNode=(org,id)=>[...document.querySelectorAll('[data-autonomy-decision]')].find(n=>n.dataset.autonomyDecision===id&&n.dataset.autonomyOrg===org);
function notice(d) {
if(!d?.autonomy)return '';
const a=d.autonomy,org=d.business??window.MosaicOrg?.id;
return `<section class="panel" data-autonomy-decision="${esc(d.id)}" data-autonomy-org="${esc(org??'')}"><h2>${a.pending?'Confirm the arbiter resolution':'Decision near the loop'}</h2>
${a.pending?'<p>The arbiter resolved this decision. It has no effect until you confirm.</p><label>Reason for returning to the arbiter<input data-autonomy-reason maxlength="500"></label><p><button class="btn" data-autonomy-confirm="yes">Confirm resolution</button> <button class="btn" data-autonomy-confirm="no">Return to arbiter</button></p>':`<p>The agent resolved this decision. Reverse is available until ${esc(a.reverseUntil)}. A reverse cannot undo messages, work already done or code already shipped.</p><button class="btn" data-autonomy-reverse>Reverse decision</button>`}
<p role="status" data-autonomy-status></p></section>`;
if(!d)return '';
const org=d.business??window.MosaicOrg?.id??'',k=answerKey(org,d.id);
let kept=answers.get(k);
if(kept&&!kept.busy){if(!d.autonomy)kept.gone=true;else if(kept.gone){answers.delete(k);kept=undefined;}}
const line=`<p role="status" data-autonomy-status>${esc(kept?.text??'')}</p>`;
const open=`<section class="panel" data-autonomy-decision="${esc(d.id)}" data-autonomy-org="${esc(org)}">`;
if(!d.autonomy)return kept?`${open}<h2>${esc(kept.title)}</h2>${line}</section>`:'';
const a=d.autonomy,off=kept?.busy?' disabled':'';
return `${open}<h2>${a.pending?'Confirm the arbiter resolution':'Decision near the loop'}</h2>
${a.pending?`<p>The arbiter resolved this decision. It has no effect until you confirm.</p><label>Reason for returning to the arbiter<input data-autonomy-reason maxlength="500"></label><p><button class="btn" data-autonomy-confirm="yes"${off}>Confirm resolution</button> <button class="btn" data-autonomy-confirm="no"${off}>Return to arbiter</button></p>`:`<p>The agent resolved this decision. Reverse is available until ${esc(a.reverseUntil)}. A reverse cannot undo messages, work already done or code already shipped.</p><button class="btn" data-autonomy-reverse${off}>Reverse decision</button>`}
${line}</section>`;
}
// A notice's result: kept for the next draw, and written to the notice the page draws now.
function told(org,id,text) {
const k=answerKey(org,id);answers.set(k,{...answers.get(k),busy:false,text});
const node=noticeNode(org,id);if(!node)return;
const line=node.querySelector('[data-autonomy-status]');if(line)line.textContent=text;
for(const b of node.querySelectorAll('[data-autonomy-confirm],[data-autonomy-reverse]'))b.disabled=false;
}
document.addEventListener('submit',async e=>{
if(!e.target.matches('[data-autonomy-form]'))return;e.preventDefault();
const form=e.target,section=form.closest('[data-autonomy-org]'),org=section.dataset.autonomyOrg,s=states.get(org),fields=new FormData(form);
const form=e.target,org=form.closest('[data-autonomy-org]').dataset.autonomyOrg,s=states.get(org),fields=new FormData(form);
const autonomy=Object.fromEntries(classes.map(k=>[k,fields.get(k)]));autonomy.notices=fields.has('notices');autonomy.reverseWindowHours=Number(fields.get('reverseWindowHours'));
if(fields.get('authorityResolver'))autonomy.authorityResolver=fields.get('authorityResolver');
const button=form.querySelector('button[type="submit"]'),status=form.querySelector('[data-autonomy-status]');button.disabled=true;
const button=form.querySelector('button[type="submit"]');button.disabled=true;
let base=s.revision;try{if(form.dataset.revision)base=JSON.parse(form.dataset.revision);}catch{/* drawn without one */}
try{const r=await call(org,'',{revision:base,autonomy});s.revision=r.revision;s.autonomy=autonomy;s.levels=Object.fromEntries(classes.map(k=>[k,autonomy[k]]));s.status=`Saved. Receipt ${r.transaction}.`;form.dataset.revision=JSON.stringify(r.revision);delete form.dataset.liveDirty;status.textContent=s.status;}
catch(error){s.status=error.message;status.textContent=s.status;}finally{button.disabled=false;}
// A load that began before the save answered is dropped. A load that ended during the save read either
// the revision the save sent, from before it committed, or one at or after the save. One that is neither
// was written after the save by someone else: it stays, and the save's values do not replace it.
// A redraw during the save may have drawn a new form from an older read. A clean new form is drawn again
// from the state, which now holds the newest read known, so it shows that and saves against its revision.
// A new form the owner is editing stays: it saves against its own revision and fails closed.
try{const r=await call(org,'',{revision:base,autonomy}),sent=JSON.stringify(base);s.shown=++s.began;
if([sent,JSON.stringify(r.revision)].includes(JSON.stringify(s.revision))){s.revision=r.revision;s.autonomy=autonomy;s.levels=Object.fromEntries(classes.map(k=>[k,autonomy[k]]));}
form.dataset.revision=JSON.stringify(r.revision);delete form.dataset.liveDirty;s.status=`Saved. Receipt ${r.transaction}.`;
const el=live(org),drawn=el?.querySelector('[data-autonomy-form]');if(drawn&&drawn!==form&&!held(org))el.outerHTML=section(org);say(org,s.status);}
catch(error){say(org,error.message);}finally{button.disabled=false;}
});
// An edited form is dirty until it saves: holdLive keeps a dirty form through every poll.
const dirty=e=>{const form=e.target.closest?.('[data-autonomy-form]');if(form)form.dataset.liveDirty='1';};
@@ -67,12 +116,14 @@
document.addEventListener('toggle',e=>{if(!e.target.matches?.('[data-autonomy-review-list]'))return;const s=states.get(e.target.closest('[data-autonomy-org]')?.dataset.autonomyOrg);if(s)s.reviewOpen=e.target.open;},true);
document.addEventListener('click',async e=>{
const button=e.target.closest('[data-autonomy-confirm],[data-autonomy-reverse],[data-autonomy-review]');if(!button)return;
const section=button.closest('[data-autonomy-org]'),org=section.dataset.autonomyOrg,status=section.querySelector('[data-autonomy-status]');
const section=button.closest('[data-autonomy-org]'),org=section.dataset.autonomyOrg,id=section.dataset.autonomyDecision;
const review=button.dataset.autonomyReview,reverse=button.hasAttribute('data-autonomy-reverse');
const body=review?{decisionClass:review}:reverse?{id:section.dataset.autonomyDecision}:{id:section.dataset.autonomyDecision,confirm:button.dataset.autonomyConfirm==='yes',...(button.dataset.autonomyConfirm==='no'?{reason:section.querySelector('[data-autonomy-reason]').value}:{})};
const body=review?{decisionClass:review}:reverse?{id}:{id,confirm:button.dataset.autonomyConfirm==='yes',...(button.dataset.autonomyConfirm==='no'?{reason:section.querySelector('[data-autonomy-reason]').value}:{})};
button.disabled=true;
try{const r=await call(org,review?'review':reverse?'reverse':'confirm',body);status.textContent=review?'Trail review recorded.':reverse?(r.restart||r.trailPending?'Reversal committed. Completion needs recovery: inspect the decision trail and the stopped agent before requesting relaunch.':'Reversal recorded.'):(body.confirm?'Confirmation recorded. Refresh the inbox for current state.':'Returned to arbiter. Refresh the inbox for current state.');}
catch(error){status.textContent=error.message;}finally{button.disabled=false;}
// A notice takes one answer at a time: both of its buttons stay off until this one is told.
if(!review){const k=answerKey(org,id);answers.set(k,{text:'',...answers.get(k),title:section.querySelector('h2')?.textContent??'',busy:true});for(const b of section.querySelectorAll('[data-autonomy-confirm],[data-autonomy-reverse]'))b.disabled=true;}
try{const r=await call(org,review?'review':reverse?'reverse':'confirm',body);if(review)return say(org,'Trail review recorded.');told(org,id,reverse?(r.restart||r.trailPending?'Reversal committed. Completion needs recovery: inspect the decision trail and the stopped agent before requesting relaunch.':'Reversal recorded.'):(body.confirm?'Confirmation recorded. Refresh the inbox for current state.':'Returned to arbiter. Refresh the inbox for current state.'));}
catch(error){if(review)say(org,error.message);else told(org,id,error.message);}finally{button.disabled=false;}
});
window.MosaicAutonomy={load,section,notice};
})();
+3
View File
@@ -751,6 +751,9 @@
return `<li class="s1-opt"><p><b class="s1-key">${txt(o.key)}</b> ${txt(o.text)} ${approving ? badge(`approves ${d.authorization.action}`, 'attn') : ''}${o.key === d.recommendation ? badge('recommended', 'ok') : ''}${chosen ? badge('chosen', 'ok') : ''}</p>${copy}</li>`;
}).join('')}</ol>`;
const earlier = await chain(get, d);
// A newer draw may have begun while the earlier versions were read. This one is dropped, so stop
// here: the notice below keeps the owner's results, and only a draw that lands may change them.
if (!current()) return '';
const history = [...d.seen.map(s => `<li>Seen by ${txt(s.by)}${s.via ? ` via ${txt(s.via)}` : ''} ${when(s.at)}</li>`), ...(c ? [`<li>${esc(c.op)} by ${txt(c.by)}${c.via ? ` via ${txt(c.via)}` : ''} ${when(c.at)}</li>`] : [])];
// Without SSO, or under SSO without --send, the Console says why it has no buttons and never
// draws a disabled one (design section 5).
+40 -20
View File
@@ -597,6 +597,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
+ '<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 class="small muted">Model setup has not checked whether a model answers.</p>'
+ '<p id="proxy-readonly" class="muted" hidden>This Console is read-only. Sign-in and account changes are unavailable.</p>'
+ '<div data-accounts-part><ul id="proxy-accounts" class="rows" aria-label="Accounts"></ul>'
// #1873 account-remove: the instance owner removes an account here; anyone else is told where.
@@ -610,8 +611,8 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
+ '<div class="form-foot"><button type="submit" id="proxy-login-go" hidden>Sign in</button></div></fieldset></form>'
+ '<form id="proxy-apikey" class="settings-form" hidden><fieldset data-write disabled><div class="field"><label for="proxy-apikey-key" id="proxy-apikey-label">API key</label>'
+ '<input id="proxy-apikey-key" name="key" type="password" autocomplete="off" spellcheck="false" maxlength="4096" required>'
+ '<p class="help small muted">Mosaic checks it with <span id="proxy-apikey-provider">the provider</span>, keeps it in your model service, and never shows it again.</p></div>'
+ '<div class="form-foot"><button type="submit">Check and add</button><button type="button" id="proxy-apikey-cancel">Cancel</button></div></fieldset><p id="proxy-apikey-message" role="status"></p></form>'
+ '<p class="help small muted">Mosaic saves the key for <span id="proxy-apikey-provider">the provider</span> in your model service and never shows it again. Saving does not check whether a model answers.</p></div>'
+ '<div class="form-foot"><button type="submit">Save account</button><button type="button" id="proxy-apikey-cancel">Cancel</button></div></fieldset><p id="proxy-apikey-message" role="status"></p></form>'
+ '</div></details>'
+ '<div id="proxy-signin" hidden><ol id="proxy-signin-progress" class="progress" aria-label="Sign-in progress"></ol>'
+ '<p class="form-foot"><a id="proxy-authorize" target="_blank" rel="noopener noreferrer" hidden>Open the sign-in tab again</a><button type="button" id="proxy-login-cancel" disabled>Cancel sign-in</button></p>'
@@ -671,9 +672,10 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
const STEP_KEYS = ['service', 'accounts', 'organizations', 'triage'];
const BADGE = { done: ['badge-ok', 'Done'], next: ['badge-attn', 'Next'], wait: ['badge-muted', 'Waiting'], work: ['badge-attn', 'Working'], bad: ['badge-danger', 'Needs you'], off: ['badge-muted', 'Not yet'] };
const CARD_CLASS = { done: 'done', next: 'next', work: 'next', bad: 'blocked', wait: 'waiting', off: 'waiting' };
// An account's health from its status in the accounts read. Anything else reads Unknown.
const HEALTH = { ready: ['badge-ok', 'Ready'], active: ['badge-ok', 'Ready'], error: ['badge-danger', 'Not working'], unavailable: ['badge-danger', 'Not available'], disabled: ['badge-muted', 'Off'] };
const health = status => HEALTH[status] ?? ['badge-muted', 'Unknown'];
// Account metadata does not prove that a model answered.
const HEALTH = { ready: ['badge-muted', 'Saved'], active: ['badge-muted', 'Saved'], error: ['badge-danger', 'Error'], unavailable: ['badge-danger', 'Not available'], disabled: ['badge-muted', 'Disabled'] };
const health = account => ['error', 'unavailable'].includes(account.status) && account.reason?.startsWith('The account needs to sign in again.')
? ['badge-danger', 'Sign-in needed'] : HEALTH[account.status] ?? ['badge-muted', 'Unknown'];
function mount() {
const $ = id => document.getElementById(id);
const root = $('proxy-setup');
@@ -739,6 +741,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
function paintAccountCard() {
const addBox = $('proxy-add-box');
addBox.hidden = !canWrite || Boolean(login);
$('proxy-accounts').querySelectorAll('[data-account-fix]').forEach(button => { button.disabled = Boolean(login); });
// The page has one primary button: here while no account is added and step 1 is done.
const first = canWrite && !login && accountList !== null && !accountList.length && !accountsDown && (!setup.enabled() || setup.serviceDone());
for (const b of [$('proxy-login-go'), $('proxy-apikey').querySelector('button[type=submit]')]) b.className = first ? 'btn primary' : 'btn';
@@ -746,10 +749,10 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
if (accountsDown) { setCard('accounts', 'off', accountsDown, { badge: ['badge-muted', 'Not available'] }); return focusStep(); }
if (accountList === null) { setCard('accounts', 'work', 'Reading accounts…', { badge: ['badge-muted', 'Reading'] }); return focusStep(); }
if (login) { setCard('accounts', 'work', `Signing in to ${providerShort(login.provider)}.`); return focusStep(); }
const bad = accountList.filter(a => ['error', 'unavailable'].includes(a.status));
const bad = accountList.filter(a => ['error', 'unavailable', 'disabled'].includes(a.status));
if (!accountList.length) { if (canWrite) addBox.open = true; setCard('accounts', 'next', 'Add an account once. Every organization that uses your models gets its models.'); }
else if (bad.length) setCard('accounts', 'bad', `${bad.map(a => `${providerLabel(a.provider)}: ${health(a.status)[1].toLowerCase()}`).join(' · ')}. Its models are not offered until it works. Add the account again under Add an account.`);
else setCard('accounts', 'done', accountList.map(a => `${providerLabel(a.provider)} ${health(a.status)[1].toLowerCase()}`).join(' · '));
else if (bad.length) setCard('accounts', 'bad', `${bad.map(a => `${providerLabel(a.provider)}: ${health(a)[1].toLowerCase()}`).join(' · ')}. Check the account rows below.`);
else setCard('accounts', 'done', accountList.map(a => `${providerLabel(a.provider)} ${health(a)[1].toLowerCase()}`).join(' · '));
focusStep();
}
// #1873 account-remove (Jason 2026-11-20): the owner's Remove asks in place and names what moves,
@@ -764,7 +767,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
'proxy-uncertain': 'Mosaic could not confirm the remove: the model service is between writes. Check the service and the list before trying again.',
'proxy-down': 'The model service stopped answering, so Mosaic could not confirm the remove. Check the service and the list before trying again.',
'proxy-admin-busy': 'Another setup action is running. Try again when it finishes.',
'invalid-request': 'The model service no longer lists this account. Read the accounts again.',
'invalid-request': 'Mosaic could not identify one account to remove. It may no longer be listed, have a duplicate ID, or share a credential with another account. Read the accounts again.',
'human-required': 'Only the instance owner removes an account.',
};
async function adminCall(path, args) {
@@ -809,8 +812,10 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
removeBusy = true; removeAsk.error = null; paintAccounts();
try {
await adminCall('accounts/remove', { accountId: account.accountId });
removeAsk = null; message(`${name} account removed.`);
await refresh(); await setup.reread();
let removalMessage = `${name} account removed.`;
removeAsk = null; message(removalMessage);
try { await refresh(); } catch (error) { removalMessage += ` The account list could not be refreshed: ${error.message}`; message(removalMessage); }
await setup.reread({ onError: error => message(`${removalMessage} The setup status could not be refreshed: ${error.message}`) });
} catch (error) {
if (removeAsk) removeAsk.error = error.message; message(error.message);
// The outcome may be unknown: read the list again so it shows what the service holds now.
@@ -843,7 +848,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
list.replaceChildren(...accountList.map(account => {
const li = el('li'), name = el('span', providerShort(account.provider)), kind = el('span', providerKind(account.provider) || '—');
kind.append(el('br'), el('small', account.displayName, 'muted'));
const [cls, word] = health(account.status), badge = el('span', word, `badge ${cls}`);
const [cls, word] = health(account), badge = el('span', word, `badge ${cls}`);
li.dataset.account = account.accountId; li.append(name, kind, badge);
if (proxyAdmin && canWrite) {
const remove = el('button', 'Remove'); remove.type = 'button'; remove.dataset.remove = account.accountId;
@@ -853,6 +858,19 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
}
// The accounts read says why an account is not working (account.reason, a7362a8fc and later). Absent, nothing shows.
if (typeof account.reason === 'string' && account.reason) li.append(el('p', account.reason, 'small muted account-reason'));
if (['error', 'unavailable', 'disabled'].includes(account.status)) {
if (canWrite && [...providerSelect.options].some(option => option.value === account.provider)) {
const fix = el('button', 'Add account'); fix.type = 'button'; fix.dataset.accountFix = '';
fix.disabled = Boolean(login);
fix.setAttribute('aria-label', `Add account for ${account.displayName}`);
fix.addEventListener('click', () => {
const add = $('proxy-add-box'); add.open = true;
providerSelect.value = account.provider;
paintProvider(); (keyed(providerSelect.value) ? $('proxy-apikey-key') : $('proxy-login-go')).focus();
});
li.append(fix);
} else li.append(el('p', canWrite ? 'This provider is not available here. Ask the owner to check Model setup.' : 'Ask the owner to add an account in Model setup.', 'small muted'));
}
if (removeAsk?.accountId === account.accountId && proxyAdmin && canWrite) li.append(removeBox(account));
return li;
}));
@@ -920,7 +938,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
'models-offered-conflict': 'The model list changed since this page read it. Read it again, then make your change.',
'models-invalid': 'The model service no longer lists one of these models. Read the list again.',
'proxy-down': 'No organization that uses your model service answered, so its models can\'t be listed now.',
'not-configured': 'No organization uses your model service yet. Its models show here once one does.',
'not-configured': 'No organization with a configured model launch uses your model service yet. Its models show here once one does.',
'proxy-admin-busy': 'Another change to the model service is running. Try again in a moment.',
'outcome-unknown': 'The outcome is unknown. Read the list again before you try again.',
};
@@ -937,8 +955,10 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
catch (error) { if (round === offeredRound) box.replaceChildren(el('p', offeredSays(error.code), 'small muted')); return; }
if (round !== offeredRound) return;
const providers = Array.isArray(view?.providers) ? view.providers : [];
if (!providers.length) { box.replaceChildren(el('p', 'Your model service lists no models yet.', 'small muted')); return; }
box.replaceChildren(...providers.map(p => offeredList(p, view.revision, open.has(p.provider), saved === p.provider)));
const quiet = Array.isArray(view?.unanswered) ? view.unanswered.filter(id => typeof id === 'string').map(id => window.MosaicOrg?.row?.(id)?.label || id) : [];
const notice = quiet.length ? [el('p', `Not answering now, so it is not known which models they use: ${quiet.join(', ')}. A model you switch off may stop working for them.`, 'offered-unanswered banner ref')] : [];
if (!providers.length) { box.replaceChildren(...notice, el('p', 'Your model service lists no models yet.', 'small muted')); return; }
box.replaceChildren(...notice, ...providers.map(p => offeredList(p, view.revision, open.has(p.provider), saved === p.provider)));
}
function offeredList(p, revision, open, saved) {
const name = String(p.label), models = Array.isArray(p.models) ? p.models : [];
@@ -1367,7 +1387,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
const PROGRESS = [['fetch', { ok: 'Downloaded and checked', run: 'Downloading and checking…', todo: 'Download and check', bad: 'Download and check: did not finish' }],
['init', { ok: 'Configured', run: 'Configuring…', todo: 'Configure', bad: 'Configure: did not finish' }],
['start', { ok: 'Started the service', run: 'Starting the service…', todo: 'Start the service', bad: 'Start the service: did not finish' }],
['answer', { ok: 'Answers on this machine', run: 'Checking it answers…', todo: 'Check it answers', bad: 'Check it answers: no answer yet' }]];
['answer', { ok: 'Service reachable on this machine', run: 'Checking the service…', todo: 'Check the service', bad: 'Service not reachable yet' }]];
const stageOf = step => step === 'fetch' || step === 'init' ? step : step === 'unit-install' || step === 'unit-start' ? 'start' : 'answer';
// Each line is done only when the status read says so.
function progressDone() {
@@ -1400,7 +1420,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
const next = state.next?.[0], box = $('proxy-setup-next'), lines = $('proxy-setup-lines');
const ok = progressDone(), some = Object.values(ok).some(Boolean), fetching = state.fetch?.state === 'running';
paintFixtures(next !== 'accounts');
if (next === 'accounts') { setCard('service', 'done', state.unit.port ? `Running. Answers on this machine, port ${state.unit.port}.` : 'Running. Answers on this machine.'); box.replaceChildren(); paintProgress(false); lines.hidden = true; return; }
if (next === 'accounts') { setCard('service', 'done', state.unit.port ? `Running. Service reachable on this machine, port ${state.unit.port}.` : 'Running. Service reachable on this machine.'); box.replaceChildren(); paintProgress(false); lines.hidden = true; return; }
if (chain?.running || (fetching && CHAIN.includes(next))) {
setCard('service', 'work', chain?.running ? 'Setting up. Keep this page open; if you leave, Continue setup picks up from here.' : 'Downloading the release. Keep this page open.');
box.replaceChildren(goButton('Working…', next, true, () => {})); paintProgress(true); lines.hidden = true; return;
@@ -1884,10 +1904,10 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
focusStep();
}
// True once the answer is painted, so a caller can say the list on the page is the new one.
async function load() {
async function load({ onError } = {}) {
if (!enabled || loading) return false; loading = true; let painted = false;
try { state = await admin('status'); setProviders(state.providers); causeRound++; if (state.next?.[0] === 'accounts' && triageSet === null) await readTriage(); paint(); painted = true; if (state.init.initialized) await accountsReady(); }
catch (error) { say(error.message, 'error'); if (providerKey === null) setProviders(null); }
catch (error) { say(error.message, 'error'); if (providerKey === null) setProviders(null); onError?.(error); }
finally { loading = false; }
return painted;
}
@@ -1962,7 +1982,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
start(config) { enabled = true; sendOk = config.proxyAdminSend === true; return load(); },
accounts(n) { accountCount = n; if (state) { paintService(); paintRestart(); paintOrgsCard(); paintTriageCard(); } },
// A sign-in, a key or a restart can change the next step: read the whole status again.
async reread() { if (!enabled) return; triageSet = null; await load(); },
async reread(options) { if (!enabled) return; triageSet = null; await load(options); },
enabled: () => enabled,
serviceDone: () => running(),
// An organization whose model list is ready, for Models offered. The open one first.
+17 -9
View File
@@ -62,21 +62,29 @@
}
// E2E6 P1-1, P2-2: a poll reloads the list but keeps the open preview, the project picked for each
// pack and the last receipt. A kept preview applies by its digest, so a stale one is refused by the bus.
// Each organization has one state object for the life of the page. A click keeps a reference to it
// across its own request, so a load that ends meanwhile updates the read fields in place and never
// swaps the object: the click's preview or receipt lands where the next draw reads it. A load that
// began before the last applied one carries older reads, so its answer is dropped.
async function load(org) {
const prev = states.get(org);
const s = { packs: null, applied: [], writable: false, error: null, projects: null, preview: prev?.preview ?? null, status: prev?.status ?? '', picks: prev?.picks ?? {} };
if (!states.has(org)) states.set(org, { packs: null, applied: [], writable: false, error: 'Starter packs could not be read.', projects: null, preview: null, status: '', picks: {}, began: 0, shown: 0 });
const s = states.get(org);
const began = ++s.began;
const read = { packs: null, applied: [], writable: false, error: null, projects: null };
try {
const value = await call(`${base(org)}/packs`);
s.packs = Array.isArray(value?.packs) ? value.packs.filter(p => p && typeof p === 'object' && p.pack && typeof p.pack === 'object') : [];
s.applied = Array.isArray(value?.applied) ? value.applied.filter(a => plainObj(a) && typeof a.id === 'string' && Array.isArray(a.hired) && Array.isArray(a.open)) : [];
s.writable = value?.writable === true;
} catch (error) { s.error = error.message; }
read.packs = Array.isArray(value?.packs) ? value.packs.filter(p => p && typeof p === 'object' && p.pack && typeof p.pack === 'object') : [];
read.applied = Array.isArray(value?.applied) ? value.applied.filter(a => plainObj(a) && typeof a.id === 'string' && Array.isArray(a.hired) && Array.isArray(a.open)) : [];
read.writable = value?.writable === true;
} catch (error) { read.error = error.message; }
// A project pack needs a code project. The workflow read lists them; when it fails, a project pack
// says so instead of guessing.
if (s.packs?.some(p => p.pack.scope === 'project')) {
try { const w = await call(`${base(org)}/workflows`); s.projects = w && typeof w.projects === 'object' ? Object.keys(w.projects).sort() : null; } catch { s.projects = null; }
if (read.packs?.some(p => p.pack.scope === 'project')) {
try { const w = await call(`${base(org)}/workflows`); read.projects = w && typeof w.projects === 'object' ? Object.keys(w.projects).sort() : null; } catch { read.projects = null; }
}
states.set(org, s);
if (began < s.shown) return;
s.shown = began;
Object.assign(s, read);
}
const markText = m => MARKS[m] ?? m;
function itemRow(item) {
+21 -7
View File
@@ -15,22 +15,35 @@
// draft holds the typed fields; base is the revision they were read at, which a save sends, so a
// change saved elsewhere since then answers as stale instead of being written over.
let data = null, readLine = '', draft = null, base = 0, busy = false, line = '', conflict = false;
// Reads answer in any order. began numbers each read as it starts. shown is the newest read or save
// the page has drawn its route from, and keyShown the newest read or key change it has drawn its key
// state from. A read older than shown is dropped, so a slow read cannot put back the route and
// revision a save or a newer read replaced. A read older than keyShown takes the key state the page
// holds instead of its own: a key change does not touch the route, so the read's route still stands.
// That key state is kept in key, apart from data, so a failed read that clears data keeps it.
let began = 0, shown = 0, keyShown = 0, key;
const call = init => window.fetch(PATH, { cache: 'no-store', redirect: 'manual', ...init });
// The stored route's fields, or empty ones: there is no default model, harness, cap or zone.
const fromRoute = r => ({ model: r?.model ?? '', harness: r?.harness ?? '', cap: r ? String(r.cap) : '', timeZone: r?.timeZone ?? '' });
// It says whether the page took this read (false when a newer read or write had drawn first).
async function read() {
readLine = '';
const n = ++began;
const failed = text => { if (n < shown) return false; shown = n; data = null; readLine = text; return true; };
let r, a = null;
try { r = await call({ method: 'GET' }); } catch { data = null; readLine = 'The Triage route could not be read. Reload the page to try again.'; return; }
try { r = await call({ method: 'GET' }); } catch { return failed('The Triage route could not be read. Reload the page to try again.'); }
try { a = await r.json(); } catch { /* refused below */ }
if (r.type === 'opaqueredirect') { data = null; readLine = 'Sign in again, then reload.'; return; }
if (!r.ok || !a || typeof a !== 'object') { data = null; readLine = typeof a?.message === 'string' ? a.message : 'The Triage route could not be read.'; return; }
if (r.type === 'opaqueredirect') return failed('Sign in again, then reload.');
if (!r.ok || !a || typeof a !== 'object') return failed(typeof a?.message === 'string' ? a.message : 'The Triage route could not be read.');
if (n < shown) return false;
shown = n; readLine = '';
// An untouched page follows the store; typed fields stay, with the revision they were read at.
const untouched = draft === null || JSON.stringify(draft) === JSON.stringify(fromRoute(data?.route ?? null));
if (n < keyShown) a = { ...a, access: key }; else { keyShown = n; key = a.access; }
data = a;
if (untouched) { draft = fromRoute(a.route); base = Number.isSafeInteger(a.revision) ? a.revision : 0; }
return true;
}
const models = () => (Array.isArray(data?.choices?.models) ? data.choices.models : []);
@@ -99,7 +112,7 @@
catch { busy = false; accessLine = 'Outcome unknown. Reload the page to see the key state.'; repaint(); return; }
try { a = await r.json(); } catch { /* refused below */ }
busy = false;
if (a?.access && data) data = { ...data, access: a.access };
if (a?.access && data) { data = { ...data, access: a.access }; key = a.access; keyShown = ++began; }
if (r.type === 'opaqueredirect') accessLine = 'Sign in again, then retry.';
else if (r.ok) accessLine = ACTION_LINE[a?.key?.action] ?? (op === 'off' ? 'Triage is off.' : 'Access was repaired.');
else accessLine = typeof a?.message === 'string' ? a.message : 'The Triage key was not changed.';
@@ -131,6 +144,7 @@
busy = false;
if (r.ok && a?.route) {
data = { ...data, route: a.route, revision: a.revision, routeMessage: undefined };
shown = ++began;
draft = fromRoute(a.route); base = a.revision;
line = `Saved ${savedAt(a.route.updatedAt)}.` + (a.key?.error ? ` ${a.key.message}` : ACTION_LINE[a.key?.action] ? ` ${ACTION_LINE[a.key.action]}` : '');
repaint();
@@ -147,8 +161,8 @@
async function reload() {
if (busy) return;
draft = null; conflict = false; line = '';
await read();
line = data ? 'Route read again. Your fields now show the stored route.' : '';
// A save that landed while this read was out has drawn the newer route and its receipt; keep both.
if (await read()) line = data ? 'Route read again. Your fields now show the stored route.' : '';
repaint();
}
+10 -2
View File
@@ -60,18 +60,26 @@
w.epoch++; w.inflight++;
try { return await fn(); } finally { w.inflight--; w.epoch++; }
}
// Two reads with no write between them can still answer out of order (the dashboard card and the page,
// or a poll and a navigation). Each organization numbers its reads as they start; a read that answers
// after a newer one has been kept is dropped, so an older answer cannot put back what a newer one replaced.
const reads = new Map();
const readOrder = org => { if (!reads.has(org)) reads.set(org, { began: 0, kept: 0 }); return reads.get(org); };
async function load(org) {
const prev = states.get(org), w = writeState(org), began = w.epoch;
const order = readOrder(org), n = ++order.began;
const s = { data: null, known: new Set(), error: null };
const raced = () => !!prev?.data && (w.inflight > 0 || w.epoch !== began);
try { await read(org, s); if (raced()) return; } catch (error) {
if (raced()) return;
const older = () => n < order.kept;
try { await read(org, s); if (raced() || older()) return; } catch (error) {
if (raced() || older()) return;
// Review P3: a failed poll while a change to this organization's workflows is held keeps the last good
// read, so the page still draws the change and its form, and graftLive puts the held form and focus back.
// SP17: the failure is still said; the page draws the last read under that line.
if (prev?.data && held(org).length) Object.assign(s, { data: prev.data, known: prev.known, readError: error.message });
else s.error = error.message;
}
order.kept = n;
states.set(org, s);
}
const scopes = s => [['', 'Organization', s.data.workflows], ...Object.keys(s.data.projects).sort().map(p => [p, `Project ${p}`, s.data.projects[p]])];
@@ -51,3 +51,262 @@ for(const [width,height]of [[1440,900],[390,844]])for(const theme of ['light','d
await waitFor(b,`/Reversal recorded/.test(document.querySelector('[data-autonomy-status]').textContent)`);assert.equal(reverses,1);
await b.screenshot(join(shots,`reverse-${width}-${theme}.png`));
});
// The organization page reads autonomy again on a poll and after any write that changes the organization
// (mosaic-org-changed). A save or review receipt must survive a reload that overlaps it, in either order,
// and an older read that answers last must not put its older values back.
// hold(verb) makes the next call of that verb wait: its answer is computed when the call arrives, then held
// until release(). arrived resolves when the call has arrived.
function holds(){
const pending=new Map();
return {
hold(verb){const h={};h.arrived=new Promise(r=>{h.reached=r;});h.wait=new Promise(r=>{h.release=r;});pending.set(verb,[...(pending.get(verb)??[]),h]);return h;},
take:verb=>pending.get(verb)?.shift(),
};
}
async function raceFixture(t,gates){
const state={writes:0,reviews:0,setting:{merge:'out of the loop'},revision:'a'.repeat(64)};
const answer=(verb,args)=>{
if(verb==='autonomy.get.console')return {revision:state.revision,autonomy:state.setting,levels:{'cross-role':'out of the loop',merge:state.setting.merge,policy:'out of the loop',authority:'in the loop'}};
if(verb==='autonomy.set.console'){assert.equal(args.revision,state.revision);state.writes++;state.setting=args.autonomy;state.revision=String(state.writes+1).repeat(64);return {revision:state.revision,transaction:`10000000-0000-4000-8000-00000000000${state.writes}`};}
if(verb==='autonomy.review.console'){state.reviews++;return {recorded:true};}
throw Object.assign(new Error('not-configured'),{code:'not-configured'});
};
const call=async(verb,args)=>{const value=answer(verb,args),held=gates.take(verb);if(held){held.reached();await held.wait;}return value;};
const server=await startServer({port:0,sso:createDevOwner(),send:async()=>({}),organizations:{list:async()=>[{id:'acme',label:'Acme',busHealthy:true}],resolve:async()=>({busHealthy:true,decisionWrite:async()=>({}),requestRead:call,requestWrite:call,send:async()=>({}),reads:{business:async()=>({business:{id:'acme',projects:[],instances:[]}}),settings:async()=>({}),queue:async()=>({rows:[]})},bus:{instances:async()=>({instances:{}}),agents:async()=>[],'thread.claims':async()=>[],tasks:async()=>[],inbox:async()=>[],messages:async()=>({messages:[]})},chat:{projects:async()=>[],threads:async()=>[]}})},log:()=>{}});
t.after(()=>close(server));const b=await browser({machine:false});t.after(()=>b.close());
await b.navigate(`http://127.0.0.1:${server.address().port}/#/orgs/acme/organization`);
await waitFor(b,`document.querySelector('[data-autonomy-form] button[type=submit]')`);
return {b,state};
}
const reload=b=>b.evaluate(`document.dispatchEvent(new CustomEvent('mosaic-org-changed',{detail:{org:'acme'}}));true`);
const markDrawn=b=>b.evaluate(`document.querySelector('[data-autonomy]').dataset.drawn='before';true`);
const redrawn=b=>waitFor(b,`document.querySelector('[data-autonomy-form]') && !document.querySelector('[data-autonomy]').dataset.drawn`);
const statusText=b=>b.evaluate(`document.querySelector('[data-autonomy-form] [data-autonomy-status]').textContent`);
const submit=(b,level)=>b.evaluate(`document.querySelector('[data-autonomy-form] select[name=merge]').value=${JSON.stringify(level)};document.querySelector('[data-autonomy-form]').requestSubmit();true`);
// Count each autonomy read by the revision it carries, once the reading load has used it: a task queued
// after the answer runs after the load's last step. A poll that reads meanwhile counts under its own revision.
const countReads=b=>b.evaluate(`{const f=window.fetch;window.__autonomyRead={};window.fetch=async(...a)=>{const r=await f(...a);if(String(a[0]).endsWith('/api/orgs/acme/autonomy')&&!a[1]?.method){const j=r.json.bind(r);r.json=()=>j().then(v=>{setTimeout(()=>{window.__autonomyRead[v.revision]=(window.__autonomyRead[v.revision]??0)+1});return v})}return r}}true`);
const readUsed=(b,revision)=>waitFor(b,`window.__autonomyRead[${JSON.stringify(revision)}]>=1`);
test('AU owner settings: a save that lands while a reload of autonomy is held keeps its receipt and revision',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await raceFixture(t,gates);
// The reload's read arrives first and answers after the save has been drawn.
const list=gates.hold('autonomy.get.console');
await reload(b);await list.arrived;
await submit(b,'in the loop');
await waitFor(b,`/^Saved\\. Receipt /.test(document.querySelector('[data-autonomy-status]').textContent)`);
assert.equal(state.writes,1);
await markDrawn(b);list.release();await redrawn(b);
assert.match(await statusText(b),/^Saved\. Receipt 10000000-0000-4000-8000-000000000001\.$/,'the reload kept the receipt');
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form]').dataset.revision`),JSON.stringify(state.revision),'the form saves against the revision the save answered');
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form] select[name=merge]').value`),'in the loop','the form shows what was saved');
// The next save is not a revision conflict.
await submit(b,'near the loop');
await waitFor(b,`/^Saved\\. Receipt 10000000-0000-4000-8000-000000000002\\.$/.test(document.querySelector('[data-autonomy-status]').textContent)`);
assert.equal(state.writes,2);
});
test('AU owner settings: a save that answers after a reload has drawn the page keeps its receipt',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await raceFixture(t,gates);
// The save arrives first and answers after a reload has drawn the page again.
const save=gates.hold('autonomy.set.console');
await submit(b,'in the loop');await save.arrived;
await markDrawn(b);await reload(b);await redrawn(b);
save.release();
await waitFor(b,`/^Saved\\. Receipt /.test(document.querySelector('[data-autonomy-form] [data-autonomy-status]').textContent)`);
await markDrawn(b);await reload(b);await redrawn(b);
assert.match(await statusText(b),/^Saved\. Receipt 10000000-0000-4000-8000-000000000001\.$/,'a later reload keeps the receipt');
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form]').dataset.revision`),JSON.stringify(state.revision));
});
test('AU owner settings: a trail review that answers after a reload has drawn the page is said',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await raceFixture(t,gates);
await b.evaluate(`document.querySelector('[data-autonomy-review-list]').open=true;true`);
const review=gates.hold('autonomy.review.console');
await b.evaluate(`document.querySelector('[data-autonomy-review=merge]').click();true`);await review.arrived;
await markDrawn(b);await reload(b);await redrawn(b);
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-review-list]').open`),true,'the review list stays open');
review.release();
await waitFor(b,`document.querySelector('[data-autonomy-form] [data-autonomy-status]').textContent==='Trail review recorded.'`);
assert.equal(state.reviews,1);
await markDrawn(b);await reload(b);await redrawn(b);
assert.equal(await statusText(b),'Trail review recorded.','a later reload keeps the review receipt');
});
test('AU owner settings: an older read of autonomy that answers last does not replace a newer one',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await raceFixture(t,gates);
await countReads(b);
const older=gates.hold('autonomy.get.console');
await reload(b);await older.arrived;
// Another writer changes the organization; a newer read answers first.
state.setting={merge:'near the loop'};state.revision='c'.repeat(64);
await reload(b);
// The page draws after all of the dashboard's reads, so wait for the draw as well as the read.
await waitFor(b,`document.querySelector('[data-autonomy-form] select[name=merge]')?.value==='near the loop' && window.__autonomyRead[${JSON.stringify('c'.repeat(64))}]>=1`);
older.release();
await readUsed(b,'a'.repeat(64));
const drawn=await b.evaluate(`window.MosaicAutonomy.section('acme')`);
assert.match(drawn,/<option selected>near the loop<\/option>/,'the older values were not put back');
assert.match(drawn,new RegExp(`data-revision="&quot;${'c'.repeat(64)}&quot;"`),'the newer revision stays');
});
test('AU owner settings: a save that answers after a redraw from an older read draws what was saved',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await raceFixture(t,gates);
// The reload's read is served before the save commits. It draws a clean new form while the save is held.
const read=gates.hold('autonomy.get.console');
await reload(b);await read.arrived;
const save=gates.hold('autonomy.set.console');
await submit(b,'in the loop');await save.arrived;
assert.equal(state.writes,1);
await markDrawn(b);read.release();await redrawn(b);
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form] select[name=merge]').value`),'out of the loop','the older read was drawn');
save.release();
await waitFor(b,`/^Saved\\. Receipt /.test(document.querySelector('[data-autonomy-form] [data-autonomy-status]').textContent)`);
// Before any further reload, the drawn form shows the save and carries its revision.
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form]').dataset.revision`),JSON.stringify(state.revision),'the drawn form saves against the revision the save answered');
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form] select[name=merge]').value`),'in the loop','the drawn form shows what was saved');
assert.match(await statusText(b),/^Saved\. Receipt 10000000-0000-4000-8000-000000000001\.$/);
await submit(b,'near the loop');
await waitFor(b,`/^Saved\\. Receipt 10000000-0000-4000-8000-000000000002\\.$/.test(document.querySelector('[data-autonomy-status]').textContent)`);
assert.equal(state.writes,2,'the next save is not a revision conflict');
});
test('AU owner settings: a save that answers after a newer read by another writer leaves the newer read',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await raceFixture(t,gates);
// The save commits, then another writer commits, and a reload draws that newer read before the save answers.
const save=gates.hold('autonomy.set.console');
await submit(b,'in the loop');await save.arrived;
assert.equal(state.writes,1);
state.setting={merge:'near the loop'};state.revision='c'.repeat(64);
await markDrawn(b);await reload(b);await redrawn(b);
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form] select[name=merge]').value`),'near the loop','the newer read was drawn');
save.release();
await waitFor(b,`/^Saved\\. Receipt 10000000-0000-4000-8000-000000000001\\.$/.test(document.querySelector('[data-autonomy-form] [data-autonomy-status]').textContent)`);
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form] select[name=merge]').value`),'near the loop','the drawn form keeps the newer read');
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-form]').dataset.revision`),JSON.stringify('c'.repeat(64)));
const drawn=await b.evaluate(`window.MosaicAutonomy.section('acme')`);
assert.match(drawn,/<option selected>near the loop<\/option>/,'the state keeps the newer read');
assert.match(drawn,/data-autonomy-status role="status">Saved\. Receipt 10000000-0000-4000-8000-000000000001\./,'the state keeps the receipt');
// The next save goes against the newer revision and is not a conflict.
await submit(b,'in the loop');
await waitFor(b,`/^Saved\\. Receipt 10000000-0000-4000-8000-000000000002\\.$/.test(document.querySelector('[data-autonomy-status]').textContent)`);
assert.equal(state.writes,2);
});
// The decision notice on #/orgs/<org>/inbox/<id>. The bus page draws that view again on every poll (and on a
// fresh config, which is how these tests ask for a draw), and a decision the owner confirmed, returned or
// reversed leaves the inbox read, as the broker's inbox does. The owner's result must stay on the notice.
const decisionId='10000000-0000-4000-8000-0000000000d1';
const earlierId='10000000-0000-4000-8000-0000000000d0';
async function noticeFixture(t,gates,{autonomy,supersedes=false}){
const state={confirms:0,reverses:0,refuse:null,inbox:true};
const row=()=>({...(supersedes?{supersedes:earlierId}:{}),id:decisionId,business:'acme',at:'2026-11-11T12:00:00.000Z',class:'gated',action:'git.merge.protected',route_to:'cto',raised_by_role:'coder',raised_by_run:'coder-run',question:'Land the reviewed change?',options:[{key:'yes',text:'Land'},{key:'no',text:'Revise'}],recommendation:'yes',blocking:false,autonomy});
const answer=(verb,args)=>{
if(state.refuse){const code=state.refuse;state.refuse=null;throw Object.assign(new Error(code),{code});}
if(verb==='decision.confirm.console'){state.confirms++;state.inbox=false;return {op:args.confirm?'confirmed':'declined'};}
if(verb==='decision.reverse.console'){state.reverses++;state.inbox=false;return {reversed:true};}
throw Object.assign(new Error('not-configured'),{code:'not-configured'});
};
// The answer (or refusal) is settled when the call arrives; a held call gives it on release().
const call=async(verb,args)=>{let value,error;try{value=answer(verb,args);}catch(e){error=e;}const held=gates.take(verb);if(held){held.reached();await held.wait;}if(error)throw error;return value;};
// The earlier version's trail read, which a draw of a superseding decision waits on, can be held.
const earlier=async()=>{const held=gates.take('trail:earlier');if(held){held.reached();await held.wait;}return [{id:earlierId,business:'acme',at:'2026-11-11T11:00:00.000Z',class:'gated',action:'git.merge.protected',route_to:'cto',raised_by_role:'coder',raised_by_run:'coder-run',question:'Land the earlier change?',options:[{key:'yes',text:'Land'}],recommendation:'yes',blocking:false,table:'decisions'}];};
const trail=async id=>id===earlierId?earlier():[{...row(),table:'decisions'},{table:'events',kind:'action.allowed',body:{operation:'decision.raise',decision:id,approvalChoice:'yes',target:'vikunja:1/2'}}];
const server=await startServer({port:0,sso:createDevOwner(),send:async()=>({}),organizations:{list:async()=>[{id:'acme',label:'Acme',busHealthy:true}],resolve:async()=>({busHealthy:true,decisionWrite:async()=>({}),requestRead:call,requestWrite:call,send:async()=>({}),reads:{business:async()=>({business:{id:'acme',projects:[],instances:[]}}),settings:async()=>({}),queue:async()=>({rows:[]})},bus:{instances:async()=>({instances:{}}),agents:async()=>[],'thread.claims':async()=>[],tasks:async()=>[],inbox:async()=>state.inbox?[row()]:[],trail,messages:async()=>({messages:[]})},chat:{projects:async()=>[],threads:async()=>[]}})},log:()=>{}});
t.after(()=>close(server));const b=await browser({machine:false});t.after(()=>b.close());
await b.navigate(`http://127.0.0.1:${server.address().port}/#/orgs/acme/inbox/${decisionId}`);
await waitFor(b,`document.querySelector('[data-autonomy-decision] button')`);
return {b,state};
}
// Draw the decision view again, the way a bus restart's fresh config does, and wait until it has drawn.
const drawAgain=async b=>{
await b.evaluate(`document.querySelector('[aria-labelledby=b-q]').dataset.drawn='before';true`);
await b.evaluate(`fetch('/api/config',{cache:'no-store'}).then(r=>r.json()).then(c=>document.dispatchEvent(new CustomEvent('mosaic-config',{detail:c})));true`);
await waitFor(b,`document.querySelector('[aria-labelledby=b-q]') && !document.querySelector('[aria-labelledby=b-q]').dataset.drawn`);
};
const noticeLine=b=>b.evaluate(`document.querySelector('[data-autonomy-decision] [data-autonomy-status]')?.textContent ?? null`);
const noticeButtons=b=>b.evaluate(`[...document.querySelectorAll('[data-autonomy-decision] button')].map(x=>[x.textContent,x.disabled])`);
test('AU decision notice: a confirm that answers after a redraw is said, and stays after the decision leaves the inbox',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await noticeFixture(t,gates,{autonomy:{pending:true}});
const confirm=gates.hold('decision.confirm.console');
await b.evaluate(`document.querySelector('[data-autonomy-confirm=yes]').click();true`);await confirm.arrived;
// The broker has recorded the confirm, so the inbox read no longer carries the decision's marker. A draw while
// the answer is still on its way keeps the notice, with no button to answer twice.
await drawAgain(b);
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-decision] h2')?.textContent ?? null`),'Confirm the arbiter resolution','a redraw in flight keeps the notice');
assert.deepEqual(await noticeButtons(b),[],'a redrawn notice takes no second answer while one is in flight');
confirm.release();
await waitFor(b,`/^Confirmation recorded/.test(document.querySelector('[data-autonomy-decision] [data-autonomy-status]')?.textContent)`);
assert.equal(state.confirms,1);
// The confirmed decision has left the inbox read. The next draw keeps the notice and its result line.
await drawAgain(b);
assert.equal(await noticeLine(b),'Confirmation recorded. Refresh the inbox for current state.','the redraw keeps the result');
assert.equal(await b.evaluate(`document.querySelector('[data-autonomy-decision] h2').textContent`),'Confirm the arbiter resolution');
assert.deepEqual(await noticeButtons(b),[],'a decision that left the read offers no answer');
});
test('AU decision notice: a reverse result stays on the next draws',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await noticeFixture(t,gates,{autonomy:{notice:true,reverseUntil:'2099-01-01T00:00:00Z'}});
await b.evaluate(`document.querySelector('[data-autonomy-reverse]').click();true`);
await waitFor(b,`document.querySelector('[data-autonomy-decision] [data-autonomy-status]')?.textContent==='Reversal recorded.'`);
assert.equal(state.reverses,1);
await drawAgain(b);
assert.equal(await noticeLine(b),'Reversal recorded.','the first redraw keeps the result');
await drawAgain(b);
assert.equal(await noticeLine(b),'Reversal recorded.','a later redraw keeps the result');
});
test('AU decision notice: a refused confirm is kept on the redrawn notice, with its buttons on',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await noticeFixture(t,gates,{autonomy:{pending:true}});
state.refuse='storage-refused';
const confirm=gates.hold('decision.confirm.console');
await b.evaluate(`document.querySelector('[data-autonomy-confirm=yes]').click();true`);await confirm.arrived;
assert.deepEqual(await noticeButtons(b),[['Confirm resolution',true],['Return to arbiter',true]],'the notice takes one answer at a time');
// A refusal leaves the decision in the inbox read. A draw while it is in flight keeps the buttons off.
await drawAgain(b);
assert.deepEqual(await noticeButtons(b),[['Confirm resolution',true],['Return to arbiter',true]],'a redrawn notice takes no second answer while one is in flight');
confirm.release();
await waitFor(b,`/trail write was refused/.test(document.querySelector('[data-autonomy-decision] [data-autonomy-status]')?.textContent)`);
await drawAgain(b);
assert.equal(await noticeLine(b),'The trail write was refused. Inspect the decision trail before retrying.','the redraw keeps the refusal');
assert.deepEqual(await noticeButtons(b),[['Confirm resolution',false],['Return to arbiter',false]],'the decision is still open, so it can be answered again');
assert.equal(state.confirms,0);
});
test('AU decision notice: a returned decision that comes back to the inbox draws a fresh notice',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await noticeFixture(t,gates,{autonomy:{pending:true}});
await b.evaluate(`document.querySelector('[data-autonomy-confirm=no]').click();true`);
await waitFor(b,`/^Returned to arbiter/.test(document.querySelector('[data-autonomy-decision] [data-autonomy-status]')?.textContent)`);
assert.equal(state.confirms,1);
// The returned decision has left the inbox read. The next draw keeps the result line.
await drawAgain(b);
assert.equal(await noticeLine(b),'Returned to arbiter. Refresh the inbox for current state.','the redraw keeps the result');
// The arbiter resolves it again, so it is back in the inbox and waits for a new answer.
state.inbox=true;
await drawAgain(b);
assert.equal(await noticeLine(b),'','the old result is not shown on the new question');
assert.deepEqual(await noticeButtons(b),[['Confirm resolution',false],['Return to arbiter',false]]);
});
test('AU decision notice: a draw that a newer draw replaced does not drop the result',{timeout:60000},async t=>{
const gates=holds();const {b,state}=await noticeFixture(t,gates,{autonomy:{pending:true},supersedes:true});
// Count the earlier-version trail answers the page has taken.
await b.evaluate(`(()=>{const prev=window.fetch;window.__earlier=0;window.fetch=(input,init)=>{const p=prev(input,init);if(!String(input).includes(${JSON.stringify(earlierId)}))return p;return p.then(r=>{const json=r.json.bind(r);r.json=()=>json().then(v=>{setTimeout(()=>{window.__earlier++;});return v;});return r;});};return true;})()`);
// A draw starts while the decision is still in the inbox, and waits on the earlier version's trail.
const slow=gates.hold('trail:earlier');
await b.evaluate(`fetch('/api/config',{cache:'no-store'}).then(r=>r.json()).then(c=>document.dispatchEvent(new CustomEvent('mosaic-config',{detail:c})));true`);
await slow.arrived;
await b.evaluate(`document.querySelector('[data-autonomy-confirm=yes]').click();true`);
await waitFor(b,`/^Confirmation recorded/.test(document.querySelector('[data-autonomy-decision] [data-autonomy-status]')?.textContent)`);
assert.equal(state.confirms,1);
// A newer draw reads the decision gone and draws the result. Then the replaced draw gets its answer.
await drawAgain(b);
assert.equal(await noticeLine(b),'Confirmation recorded. Refresh the inbox for current state.');
const taken=await b.evaluate('window.__earlier');
slow.release();
await waitFor(b,`window.__earlier===${taken+1}`);
await drawAgain(b);
assert.equal(await noticeLine(b),'Confirmation recorded. Refresh the inbox for current state.','the replaced draw does not drop the result');
});
+3 -3
View File
@@ -69,12 +69,12 @@ export async function browser({ machine = true, args = [] } = {}) {
}
const { targetId } = await send('Target.createTarget', { url: 'about:blank' });
const { sessionId } = await send('Target.attachToTarget', { targetId, flatten: true });
const call = (method, params) => send(method, params, sessionId);
const call = (method, params, ms) => send(method, params, sessionId, ms);
await call('Page.enable');
await call('Runtime.enable');
if (machine) await call('Page.addScriptToEvaluateOnNewDocument', { source: `try { localStorage.setItem('mosaic-console-board', '{"machine":true}'); } catch {}` });
const evaluate = async expression => {
const r = await call('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true });
const evaluate = async (expression, ms) => {
const r = await call('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, ms);
if (r.exceptionDetails) throw new Error(r.exceptionDetails.text + ': ' + r.result.description);
return r.result.value;
};
@@ -31,7 +31,7 @@ const PREVIEW = {
// busy: the bus's apply committed but its hire loop did not run (hireError), and the packs read lists one line a
// member's pack hire left in the owner's inbox (fromPack), one raised some other way and one refused.
async function fixture(t, { busy = false } = {}) {
async function fixture(t, { busy = false, gates = null } = {}) {
const verbs = [], decisions = [];
const hired = new Map(); // name -> its pack provenance, as the bus's instances read reports it
let applied = null, route = false, instanceReads = 0;
@@ -46,19 +46,22 @@ async function fixture(t, { busy = false } = {}) {
const listed = () => applied ? [{ id: 'software-team', origin: 'shipped', project: null, hired: [...hired.keys()],
open: PREVIEW.hires.filter(h => !hired.has(h.name)).map(h => ({ name: h.name, reason: `Proposed by starter pack software-team for ${h.definition} work.`,
...(!busy || h.name === 'scout-1' ? { state: 'refused', code: 'pack-hire-route-missing' } : { state: 'awaiting-owner', decision: `inbox-${h.name}`, ...(h.name === 'coder-1' ? { fromPack: true } : {}) }) })) }] : [];
const read = async (verb, args) => {
const readAnswer = async (verb, args) => {
verbs.push([verb, args]);
if (verb === 'packs.console') return { packs: PACKS, applied: listed() };
if (verb === 'pack.preview.console') return PREVIEW;
if (verb === 'autonomy.get.console') return { revision: REV('e'), autonomy: {}, levels: {} };
throw Object.assign(new Error('not-configured'), { code: 'not-configured' });
};
const write = async (verb, args) => {
const writeAnswer = async (verb, args) => {
verbs.push([verb, args]);
if (verb === 'pack.apply.console') { applied = true; return { revision: REV('f'), added: ['board'], pack: { id: args.pack, version: '1.0.0' }, ...(busy ? { hires: [], hireError: 'organization-busy' } : { hires: hireLoop() }) }; }
if (verb === 'pack.hire.console') return { pack: args.pack, hires: hireLoop() };
throw Object.assign(new Error('not-configured'), { code: 'not-configured' });
};
// A held call is answered when it arrives, then waits for release() (holds() below).
const gated = answer => async (verb, args) => { const value = await answer(verb, args), held = gates?.take(verb); if (held) { held.reached(); await held.wait; } return value; };
const read = gated(readAnswer), write = gated(writeAnswer);
const decisionWrite = async (verb, args) => {
verbs.push([verb, args]);
if (verb === 'hire.start.console' && args.op === 'fire' && hired.has(args.name)) { hired.delete(args.name); return { id: 'fire-1', op: 'resolved', choice: 'yes' }; }
@@ -184,3 +187,80 @@ test('PD an apply whose hire loop did not run says so; the owner card counts a p
// coder-1 was left in the inbox by a pack hire, so the owner's pack hire approves it; reviewer-1 is the inbox's.
assert.equal(await b.evaluate(`document.querySelector('[data-pack-hire-button]').textContent`), 'Hire the 2 proposed agents');
});
// hold(verb) makes the next call of that verb wait: its answer is computed when the call arrives, then held
// until release(). arrived resolves when the call has arrived.
function holds() {
const pending = new Map();
return {
hold(verb) {
const h = {};
h.arrived = new Promise(r => { h.reached = r; });
h.wait = new Promise(r => { h.release = r; });
pending.set(verb, [...(pending.get(verb) ?? []), h]);
return h;
},
take: verb => pending.get(verb)?.shift(),
};
}
const reload = b => b.evaluate(`document.dispatchEvent(new CustomEvent('mosaic-org-changed',{detail:{org:'acme'}}));true`);
const markDrawn = b => b.evaluate(`document.querySelector('[data-packs]').dataset.drawn='before';true`);
const redrawn = (b, what) => waitFor(b, `document.querySelector('[data-packs]') && !document.querySelector('[data-packs]').dataset.drawn`, what);
// Count each packs answer once the reading load has used it. With no project pack listed the load has no
// further read, so a task queued after the answer runs after the load's last step.
const countPacksAnswers = b => b.evaluate(`{const f=window.fetch;window.__packsDone=0;window.fetch=async(...a)=>{const r=await f(...a);if(String(a[0]).endsWith('/api/orgs/acme/packs')){const j=r.json.bind(r);r.json=()=>j().finally(()=>setTimeout(()=>{window.__packsDone++}))}return r}}true`);
const HIRED = 'Hired scout-1. Already hired: coder-1, reviewer-1.';
// Apply the pack with no route, so scout-1 is left to hire, then set the route.
async function applied(t, gates) {
const f = await fixture(t, { gates });
await f.b.navigate(`http://127.0.0.1:${f.port}/#/orgs/acme/organization`);
await waitFor(f.b, `document.querySelector('[data-pack="software-team"] [data-pack-preview-button]')`, 'pack list');
await f.b.evaluate(`document.querySelector('[data-pack="software-team"] [data-pack-preview-button]').click();true`);
await waitFor(f.b, `document.querySelector('[data-pack-apply]')`, 'preview');
await f.b.evaluate(`document.querySelector('[data-pack-apply]').click();true`);
await waitFor(f.b, `/^Applied\\./.test(document.querySelector('[data-packs-status]')?.textContent??'') && document.querySelector('[data-pack-hire-button]')`, 'apply status and hire button');
f.setRoute(true);
return f;
}
// The page reads the packs again on a poll and after any write that changes the organization
// (mosaic-org-changed). A hire receipt must survive a reload that overlaps the hire, in either order.
test('PD a hire receipt that lands while an earlier read of the packs is held is kept', { timeout: 90000 }, async t => {
const gates = holds();
const { b, verbs } = await applied(t, gates);
await countPacksAnswers(b);
// A reload's packs read is held. The hire answers, reads the packs itself and asks the page to read
// everything again; both of those reads answer first. Then the held read answers last.
const earlier = gates.hold('packs.console');
await reload(b);
await earlier.arrived;
await b.evaluate(`document.querySelector('[data-pack-hire-button]').click();true`);
await waitFor(b, `document.querySelector('[data-packs-status]')?.textContent==='${HIRED}' && window.__packsDone>=2`, 'hire status');
earlier.release();
await waitFor(b, `window.__packsDone>=3`, 'held read answered');
await markDrawn(b);
await reload(b);
await redrawn(b, 'page drawn again after the held read');
assert.equal(await b.evaluate(`document.querySelector('[data-packs-status]').textContent`), HIRED, 'the hire receipt is kept');
assert.equal(await b.evaluate(`document.querySelector('[data-pack-hire-button]')`), null, 'nothing left to hire');
assert.deepEqual(verbs.filter(([v]) => v === 'pack.hire.console').map(([, a]) => a), [{ pack: 'software-team' }]);
});
test('PD a hire that answers after a reload has drawn the page keeps its receipt', { timeout: 90000 }, async t => {
const gates = holds();
const { b, verbs } = await applied(t, gates);
// The hire arrives first and answers after a reload has drawn the page again.
const hire = gates.hold('pack.hire.console');
await b.evaluate(`document.querySelector('[data-pack-hire-button]').click();true`);
await hire.arrived;
await markDrawn(b);
await reload(b);
await redrawn(b, 'page drawn again during the hire');
hire.release();
await waitFor(b, `document.querySelector('[data-packs-status]')?.textContent==='${HIRED}'`, 'hire status');
await markDrawn(b);
await reload(b);
await redrawn(b, 'page drawn again after the hire');
assert.equal(await b.evaluate(`document.querySelector('[data-packs-status]').textContent`), HIRED, 'a later reload keeps the hire receipt');
assert.deepEqual(verbs.filter(([v]) => v === 'pack.hire.console').map(([, a]) => a), [{ pack: 'software-team' }]);
});
@@ -35,7 +35,23 @@ const PREVIEW = {
skills: { notEnabled: ['lint-fix'] }, chief: true, plan: {}, digest: REV('d'),
};
async function fixture(t, { send = true } = {}) {
// hold(verb) makes the next read of that verb wait: its answer is computed when the read arrives, then
// held until release(). arrived resolves when the read has arrived.
function holds() {
const pending = new Map();
return {
hold(verb) {
const h = {};
h.arrived = new Promise(r => { h.reached = r; });
h.wait = new Promise(r => { h.release = r; });
pending.set(verb, [...(pending.get(verb) ?? []), h]);
return h;
},
take: verb => pending.get(verb)?.shift(),
};
}
async function fixture(t, { send = true, gates = null, packs = () => PACKS } = {}) {
const verbs = [];
let flows = {
revision: REV('a'),
@@ -48,13 +64,18 @@ async function fixture(t, { send = true } = {}) {
},
templates: ['coder', 'reviewer'],
};
const read = async (verb, args) => {
verbs.push([verb, args]);
if (verb === 'packs.console') return { packs: PACKS };
const answer = (verb, args) => {
if (verb === 'packs.console') return { packs: packs() };
if (verb === 'pack.preview.console') return { ...PREVIEW, project: args.project ?? null };
if (verb === 'autonomy.get.console') return { revision: REV('e'), autonomy: {}, levels: {} };
throw Object.assign(new Error('not-configured'), { code: 'not-configured' });
};
const read = async (verb, args) => {
verbs.push([verb, args]);
const value = answer(verb, args), held = gates?.take(verb);
if (held) { held.reached(); await held.wait; }
return value;
};
const write = async (verb, args) => {
verbs.push([verb, args]);
if (verb === 'pack.apply.console') return { revision: REV('f'), added: ['board', 'definitions.reviewer'], pack: { id: args.pack, version: '1.0.0' }, hires: [{ name: 'lead-reviewer', state: 'refused', code: 'definition-not-hireable' }] };
@@ -128,6 +149,85 @@ test('SP6 pack picker: list, preview with marks, flagged, credential and noHire
assert.deepEqual(verbs.filter(([v]) => v === 'pack.preview.console').at(-1)[1], { pack: 'web-project', project: 'site' });
});
// The page reads the packs again on a poll and after any write that changes the organization
// (mosaic-org-changed). A preview the owner asked for must survive a reload that overlaps it, in either
// order, and an older reload that answers last must not put its older list back.
const reload = b => b.evaluate(`document.dispatchEvent(new CustomEvent('mosaic-org-changed',{detail:{org:'acme'}}));true`);
const markDrawn = b => b.evaluate(`document.querySelector('[data-packs]').dataset.drawn='before';true`);
const redrawn = (b, what) => waitFor(b, `document.querySelector('[data-packs]') && !document.querySelector('[data-packs]').dataset.drawn`, what);
test('SP6 pack picker: a preview that overlaps a reload of the packs is kept, in either order', { timeout: 60000 }, async t => {
const gates = holds();
const { b, verbs } = await fixture(t, { gates });
await waitFor(b, `document.querySelector('[data-pack="software-team"] [data-pack-preview-button]')`, 'pack list');
// The reload's packs read starts first and answers after the preview has been drawn.
const list = gates.hold('packs.console');
await reload(b);
await list.arrived;
await b.evaluate(`document.querySelector('[data-pack="software-team"] [data-pack-preview-button]').click();true`);
await waitFor(b, `document.querySelector('[data-pack-preview="software-team"]')`, 'preview');
await markDrawn(b);
list.release();
await redrawn(b, 'page drawn again after the reload');
assert.ok(await b.evaluate(`!!document.querySelector('[data-pack-preview="software-team"]')`), 'the reload kept the preview');
// The preview's read starts first and answers after the reload has drawn the page.
const preview = gates.hold('pack.preview.console');
await b.evaluate(`document.querySelector('[data-pack="web-project"] [data-pack-preview-button]').click();true`);
await preview.arrived;
await markDrawn(b);
await reload(b);
await redrawn(b, 'page drawn again during the preview');
preview.release();
await waitFor(b, `/for project site/.test(document.querySelector('[data-pack-preview] h4')?.textContent??'')`, 'project preview after the reload');
assert.deepEqual(verbs.filter(([v]) => v === 'pack.preview.console').map(([, a]) => a), [{ pack: 'software-team' }, { pack: 'web-project', project: 'site' }]);
});
// Count each packs answer once the reading load has used it. With no project pack listed the load has
// no further read, so a task queued after the answer runs after the load's last step.
const countPacksAnswers = b => b.evaluate(`{const f=window.fetch;window.__packsDone=0;window.fetch=async(...a)=>{const r=await f(...a);if(String(a[0]).endsWith('/api/orgs/acme/packs')){const j=r.json.bind(r);r.json=()=>j().finally(()=>setTimeout(()=>{window.__packsDone++}))}return r}}true`);
test('SP6 pack picker: an older read of the packs that answers last does not replace a newer one', { timeout: 60000 }, async t => {
const gates = holds();
let packs = [PACKS[0]];
const { b } = await fixture(t, { gates, packs: () => packs });
await waitFor(b, `document.querySelector('[data-pack="software-team"] [data-pack-preview-button]')`, 'pack list');
await countPacksAnswers(b);
const older = gates.hold('packs.console');
await reload(b);
await older.arrived;
packs = [PACKS[0], { id: 'later', origin: 'installed', pack: { label: 'Later pack', description: 'Installed after the first read.', version: '0.1.0', scope: 'organization' } }];
await reload(b);
await waitFor(b, `document.querySelector('[data-pack="later"]') && window.__packsDone===1`, 'newer list drawn');
older.release();
await waitFor(b, `window.__packsDone===2`, 'older read answered');
assert.match(await b.evaluate(`window.MosaicPacks.section('acme')`), /data-pack="later"/, 'the older list was not put back');
await b.evaluate(`document.querySelector('[data-pack="software-team"] [data-pack-preview-button]').click();true`);
await waitFor(b, `document.querySelector('[data-pack-preview="software-team"]')`, 'preview');
assert.ok(await b.evaluate(`!!document.querySelector('[data-pack="later"]')`), 'the drawn list is the newer one');
});
test('SP6 pack picker: an apply receipt that lands while an earlier read of the packs is held is kept', { timeout: 60000 }, async t => {
const gates = holds();
const { b, verbs } = await fixture(t, { gates, packs: () => [PACKS[0]] });
await waitFor(b, `document.querySelector('[data-pack="software-team"] [data-pack-preview-button]')`, 'pack list');
await b.evaluate(`document.querySelector('[data-pack="software-team"] [data-pack-preview-button]').click();true`);
await waitFor(b, `document.querySelector('[data-pack-apply]')`, 'preview');
await countPacksAnswers(b);
// A reload's packs read is held. The apply answers, reads the packs itself and asks the page to read
// everything again; both of those reads answer first. Then the held read answers last.
const earlier = gates.hold('packs.console');
await reload(b);
await earlier.arrived;
await b.evaluate(`document.querySelector('[data-pack-apply]').click();true`);
await waitFor(b, `/^Applied\./.test(document.querySelector('[data-packs-status]')?.textContent??'') && window.__packsDone===2`, 'apply status');
assert.equal(verbs.filter(([v]) => v === 'pack.apply.console').length, 1);
earlier.release();
await waitFor(b, `window.__packsDone===3`, 'held read answered');
const drawn = await b.evaluate(`window.MosaicPacks.section('acme')`);
assert.match(drawn, /data-packs-status>Applied\. Added board, definitions\.reviewer\./, 'the receipt is kept');
assert.doesNotMatch(drawn, /data-pack-preview=/, 'the applied preview does not come back');
});
test('SP6 pack picker without send previews but offers no apply', { timeout: 60000 }, async t => {
const { b } = await fixture(t, { send: false });
await waitFor(b, `document.querySelector('[data-pack="software-team"] [data-pack-preview-button]')`, 'pack list');
@@ -35,4 +35,7 @@ test('signed-in Console buttons deliver the approved original request and downlo
assert.equal(await page.clock(), '25:00');
await page.advance(10000); assert.equal(await page.clock(), '25:00');
assert.deepEqual(await page.externalRequests(), []);
// A remote resource in the downloaded file must still be observed while the browser is offline.
await page.offline('<!doctype html><img src="https://external.invalid/tracker">');
assert.deepEqual(await page.externalRequests(), ['https://external.invalid/tracker']);
});
@@ -89,12 +89,53 @@ test('account-remove: Remove posts exactly { accountId }, reads the list again a
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
});
test('account-remove: a failed refresh after a successful remove keeps the success and the refresh error', { timeout: 90000 }, async t => {
const { b, wait } = await open(t, { extra: { [impactKey(A)]: { body: IMPACT_ALL },
'POST /api/proxy/admin/accounts/remove': { body: { accountId: A, provider: 'claude', removed: true } } } });
await b.evaluate(`document.querySelector('[data-remove="${A}"]').click(); true`);
await wait('!!document.querySelector("#proxy-remove-yes")');
await b.evaluate(`window.__scenario['GET /api/proxy/accounts'] = { status: 503, body: { error: 'proxy-down' } }; document.querySelector('#proxy-remove-yes').click(); true`);
await wait('document.querySelector("#proxy-message").textContent.includes("not answering")');
assert.equal(await b.evaluate('document.querySelector("#proxy-message").textContent'), 'Claude account removed. The account list could not be refreshed: The model service is not answering.');
assert.equal((await writes(b)).length, 1);
});
test('account-remove: a failed setup status refresh remains visible beside successful removal', { timeout: 90000 }, async t => {
const { b, wait } = await open(t, { extra: { [impactKey(A)]: { body: IMPACT_ALL },
'POST /api/proxy/admin/accounts/remove': { body: { accountId: A, provider: 'claude', removed: true } } } });
await b.evaluate(`document.querySelector('[data-remove="${A}"]').click(); true`);
await wait('!!document.querySelector("#proxy-remove-yes")');
await b.evaluate(`window.__scenario['GET /api/proxy/admin/status'] = { status: 503, body: { error: 'outcome-unknown' } }; document.querySelector('#proxy-remove-yes').click(); true`);
await wait('document.querySelector("#proxy-setup-message").textContent.length > 0');
assert.match(await b.evaluate('document.querySelector("#proxy-message").textContent'), /^Claude account removed\..*setup status could not be refreshed/i);
assert.equal((await writes(b)).length, 1);
});
test('account-remove: a late setup warning keeps the removal receipt when priority is saved meanwhile', { timeout: 90000 }, async t => {
const { b, wait } = await open(t, { extra: { [impactKey(A)]: { body: IMPACT_ALL },
'POST /api/proxy/admin/accounts/remove': { body: { accountId: A, provider: 'claude', removed: true } },
'POST /api/proxy/priority/set': { body: { accountId: B, priority: 0 } } } });
await b.evaluate(`document.querySelector('[data-remove="${A}"]').click(); true`);
await wait('!!document.querySelector("#proxy-remove-yes")');
await b.evaluate(`(() => { const real = window.fetch; window.__held = false; window.fetch = (input, init) => {
if (String(input) === '/api/proxy/admin/status') { window.__held = true; return new Promise(resolve => { window.__releaseStatus = () => resolve(new Response(JSON.stringify({ error: 'outcome-unknown' }), { status: 503, headers: { 'Content-Type': 'application/json' } })); }); }
return real(input, init); }; window.__scenario['GET /api/proxy/accounts'] = { body: { accounts: ${JSON.stringify(LIST.slice(1))} } }; document.querySelector('#proxy-remove-yes').click(); return true; })()`);
await wait('window.__held');
await b.evaluate('document.querySelector("#proxy-order form").requestSubmit(); true');
await wait('document.querySelector("#proxy-message").textContent === "Priority saved."');
await b.evaluate('window.__releaseStatus(); true');
await wait('document.querySelector("#proxy-message").textContent.includes("setup status could not be refreshed")');
assert.match(await b.evaluate('document.querySelector("#proxy-message").textContent'), /^Claude account removed\./);
assert.equal(await b.evaluate('document.querySelector("#proxy-order [role=status]").textContent'), 'Priority saved.');
});
test('account-remove: remove-write-refused and remove-unconfirmed are named in the ask and the account stays', { timeout: 90000 }, async t => {
// No refusal says nothing was removed: a refused or unanswered write may still have taken effect.
for (const [code, words] of [['remove-write-refused', 'The model service refused to remove the account. Check the list before trying again.'],
['remove-unconfirmed', 'Mosaic asked the model service to remove the account, but it is still listed. Read the accounts again before trying again.'],
['proxy-uncertain', 'Mosaic could not confirm the remove: the model service is between writes. Check the service and the list before trying again.'],
['proxy-down', 'The model service stopped answering, so Mosaic could not confirm the remove. Check the service and the list before trying again.'],
['invalid-request', 'Mosaic could not identify one account to remove. It may no longer be listed, have a duplicate ID, or share a credential with another account. Read the accounts again.'],
['some-new-code', 'The remove could not be confirmed. Nothing was retried. Read the accounts again before trying again.']]) {
const { b, wait } = await open(t, { extra: { [impactKey(A)]: { body: IMPACT_ALL }, 'POST /api/proxy/admin/accounts/remove': { status: 400, body: { error: code } } } });
await b.evaluate(`document.querySelector('[data-remove="${A}"]').click(); true`);
@@ -202,6 +202,14 @@ test('models-offered page: an organization that is not answering is named in the
assert.equal((await writes())[1].body.confirmInUse, true);
});
test('models-offered page: unanswered organizations are visible before saving', { timeout: 90000 }, async t => {
const { b, wait, writes } = await setup(t, { admin: { models: { ...VIEW, unanswered: ['lab', 'zeta'] } } });
await openOffered(b, wait);
assert.equal(await b.evaluate('document.querySelector("#proxy-offered-list .offered-unanswered")?.textContent'),
'Not answering now, so it is not known which models they use: Lab Bench, zeta. A model you switch off may stop working for them.');
assert.deepEqual(await writes(), []);
});
test('models-offered page: a save after another change is refused as a conflict, worded, with Read the list again; a busy or unknown answer is worded too', { timeout: 90000 }, async t => {
const conflict = { status: 409, body: { error: 'models-offered-conflict' } };
const busy = { status: 409, body: { error: 'proxy-admin-busy' } };
@@ -242,7 +250,7 @@ test('models-offered page: a page without proxyAdmin sends no /api/proxy/admin/
test('models-offered page: a read the model service cannot answer is worded, never an empty list', { timeout: 90000 }, async t => {
for (const [body, line] of [
[{ error: 'proxy-down' }, /No organization that uses your model service answered/],
[{ error: 'not-configured' }, /No organization uses your model service yet/],
[{ error: 'not-configured' }, /No organization with a configured model launch uses your model service yet/],
[{ error: 'outcome-unknown' }, /The outcome is unknown/],
]) {
const { b, wait } = await setup(t, { admin: { models: { status: 503, body } } });
@@ -261,6 +261,69 @@ const installed = { ...configured, unit: { ...configured.unit, installed: true }
const running = { ...installed, unit: { ...installed.unit, active: 'active', pid: 4242, port: 18432, listening: true }, next: ['accounts'] };
const config = { send: true, devOwner: true, proxyAdmin: true, proxyAdminSend: true };
const accounts = list => ({ 'GET /api/proxy/accounts': { body: { accounts: list } }, 'GET /api/proxy/keys': { body: { keys: [] } } });
test('setup states describe saved accounts and offer a repair without claiming a model answered', { timeout: 90000 }, async t => {
const list = [
{ accountId: 'a1', provider: 'claude', displayName: 'Claude', status: 'ready', priority: 0 },
{ accountId: 'a2', provider: 'z.ai', displayName: 'Key', status: 'active', priority: 0 },
{ accountId: 'a3', provider: 'codex', displayName: 'Sign in', status: 'error', priority: 0, reason: 'The account needs to sign in again. Sign in again, or add another account.' },
{ accountId: 'a4', provider: 'claude', displayName: 'Unavailable', status: 'unavailable', priority: 0 },
{ accountId: 'a5', provider: 'z.ai', displayName: 'Disabled', status: 'disabled', priority: 0 },
];
const { f, b, wait } = await w15Fixture(t, { scenario: { '/api/config': config, '/api/proxy/admin/status': running, ...accounts(list), '/api/triage/route': { route: null } } });
await b.navigate(f.base + '/#/settings/model-setup?step=accounts');
await wait('document.querySelectorAll("#proxy-accounts li[data-account]").length === 5');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-accounts li[data-account] .badge")].map(e=>e.textContent)'), ['Saved', 'Saved', 'Sign-in needed', 'Not available', 'Disabled']);
assert.equal(await b.evaluate('document.querySelector("#setup-step-accounts").dataset.state'), 'bad');
assert.match(await b.evaluate('document.querySelector("#setup-step-accounts").textContent'), /Model setup has not checked whether a model answers/);
assert.match(await b.evaluate('document.querySelector("#setup-step-service [data-step-summary]").textContent'), /Service reachable/);
assert.match(await b.evaluate('document.querySelector("#proxy-apikey .help").textContent'), /does not check whether a model answers/i);
assert.equal(await b.evaluate('document.querySelector("#proxy-apikey button[type=submit]").textContent'), 'Save account');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-accounts li[data-account]")].map(row=>row.querySelectorAll("[data-account-fix]").length)'), [0, 0, 1, 1, 1]);
await b.evaluate('document.querySelector("[data-account=a3] [data-account-fix]").click(); true');
assert.deepEqual(await b.evaluate('[document.querySelector("#proxy-add-box").open, document.querySelector("#proxy-provider").value, document.activeElement.id]'), [true, 'codex', 'proxy-login-go']);
await b.evaluate('document.querySelector("[data-account=a5] [data-account-fix]").click(); true');
assert.deepEqual(await b.evaluate('[document.querySelector("#proxy-provider").value, document.activeElement.id]'), ['z.ai', 'proxy-apikey-key']);
assert.deepEqual(await b.evaluate('window.__writes'), []);
});
test('bad account repair respects provider availability and active sign-in', { timeout: 90000 }, async t => {
const list = ['codex', 'z.ai', 'other', 'missing'].map((provider, i) => ({ accountId: `a${i}`, provider, displayName: `Account ${i}`, status: 'error', priority: 0 }));
for (const width of [1440, 390]) {
const { f, b, wait } = await w15Fixture(t, { scenario: { '/api/config': config, '/api/proxy/admin/status': running, ...accounts(list), '/api/triage/route': { route: null },
'POST /api/proxy/login/start': { body: { url: 'https://claude.ai/oauth/authorize?state=s4', state: 's4' } }, 'POST /api/proxy/login/status': { body: { status: 'wait' } }, 'POST /api/proxy/login/cancel': { body: { status: 'cancelled' } } } });
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: 'window.open = () => null;' });
await b.viewport(width, width === 390 ? 844 : 900);
await b.navigate(f.base + '/#/settings/model-setup?step=accounts');
await wait('document.querySelectorAll("#proxy-accounts li[data-account]").length === 4');
assert.equal(await b.evaluate('[...document.querySelectorAll("[data-account=a2], [data-account=a3]")].every(row => !row.querySelector("[data-account-fix]") && row.textContent.includes("provider is not available"))'), true);
const ax = await b.call('Accessibility.getFullAXTree');
assert.ok(ax.nodes.some(n => n.role?.value === 'button' && n.name?.value === 'Add account for Account 0'));
await b.evaluate('document.querySelector("[data-account=a0] [data-account-fix]").click(); document.querySelector("#proxy-login-start").requestSubmit(); true');
await wait('!document.querySelector("#proxy-signin").hidden');
assert.equal(await b.evaluate('document.querySelector("[data-account=a1] [data-account-fix]").disabled'), true);
await b.evaluate('document.querySelector("#proxy-login-cancel").click(); true');
await wait('document.querySelector("#proxy-signin").hidden');
await b.evaluate('document.querySelector("[data-account=a1] [data-account-fix]").focus(); true');
await b.key('Enter');
assert.deepEqual(await b.evaluate('[document.querySelector("#proxy-provider").value, document.activeElement.id, document.activeElement.checkVisibility()]'), ['z.ai', 'proxy-apikey-key', true]);
assert.deepEqual(await b.evaluate('window.__writes.map(w => w.path)'), ['/api/proxy/login/start', '/api/proxy/login/cancel']);
await b.close();
}
});
test('bad account without a provider or write access gives guidance without a repair shortcut', { timeout: 90000 }, async t => {
const list = [{ accountId: 'a1', provider: 'codex', displayName: 'Account', status: 'error', priority: 0 }];
for (const [owner, providers] of [[true, []], [false, publicProviders()]]) {
const { f, b, wait } = await w15Fixture(t, { scenario: { '/api/config': { send: owner, devOwner: true, proxyAdmin: owner, proxyAdminSend: owner }, '/api/proxy/admin/status': { ...running, providers }, 'GET /api/proxy/accounts': { body: { accounts: list, providers } }, '/api/triage/route': { route: null } } });
await b.navigate(f.base + '/#/settings/model-setup?step=accounts');
await wait('document.querySelector("#proxy-accounts li[data-account]")');
assert.equal(await b.evaluate('document.querySelector("[data-account-fix]")'), null);
assert.match(await b.evaluate('document.querySelector("#proxy-accounts li").innerText'), owner ? /provider is not available/ : /Ask the owner to add an account in Model setup/);
assert.deepEqual(await b.evaluate('window.__writes'), []);
await b.close();
}
});
const admin = b => b.evaluate('window.__writes.filter(w => w.path.startsWith("/api/proxy/admin/")).map(w => w.path.slice(17))');
// A primary button is one drawn with the accent fill, whatever its class: a submit is drawn that way too.
const primaries = b => b.evaluate(`(() => { const host = document.querySelector(".model-setup"), probe = document.createElement("button"); probe.className = "btn primary"; host.append(probe);
@@ -290,7 +353,7 @@ test('settings-s4: one press runs fetch, init, install and start in that order,
await wait('document.querySelector("#setup-step-service").dataset.state === "done"');
assert.deepEqual(await admin(b), ['fetch', 'init', 'unit/install', 'unit/start']);
assert.deepEqual(await b.evaluate('JSON.parse(window.__writes.find(w => w.path === "/api/proxy/admin/init").body)'), { generate: true });
assert.match(await b.evaluate('document.querySelector("#setup-step-service [data-step-summary]").textContent'), /^Running\. Answers on this machine, port 18432\.$/);
assert.match(await b.evaluate('document.querySelector("#setup-step-service [data-step-summary]").textContent'), /^Running\. Service reachable on this machine, port 18432\.$/);
await wait('document.querySelector("#setup-step-accounts").dataset.state === "next"');
assert.deepEqual(await primaries(b), ['proxy-login-go'], 'the one primary moves to step 2');
assert.equal(await b.evaluate('document.querySelector("#proxy-login-go").textContent'), 'Sign in to Claude');
@@ -311,13 +374,43 @@ test('settings-s4: a step that fails stops the run with Try again, keeps the fin
assert.deepEqual(await admin(b), ['init', 'unit/install'], 'nothing is retried by itself');
assert.equal(await b.evaluate('document.querySelector("#setup-step-service [data-step-badge]").textContent'), 'Setup stopped');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-setup-progress li")].map(li => li.className)'), ['ok', 'ok', 'bad', 'todo']);
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-setup-progress li")].map(li => li.firstChild.textContent)'), ['Downloaded and checked', 'Configured', 'Start the service: did not finish', 'Check it answers']);
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-setup-progress li")].map(li => li.firstChild.textContent)'), ['Downloaded and checked', 'Configured', 'Start the service: did not finish', 'Check the service']);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-lines").checkVisibility() && document.querySelector("#proxy-setup-lines summary").textContent'), "The service's last lines");
assert.deepEqual(await primaries(b), ['proxy-setup-go']);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-advanced summary").textContent'), 'Advanced: programs, port, timeouts');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-tech summary").textContent'), 'Technical details: release, service, history');
});
test('service progress names the unreachable service after a failed start', { timeout: 90000 }, async t => {
const down = { ...running, unit: { ...running.unit, listening: false }, next: ['unit-restart'] };
const { f, b, wait } = await w15Fixture(t, { scenario: { '/api/config': config, 'POST /api/proxy/admin/unit/start': { body: { receipt: { op: 'unit-start', time: T } } }, ...accounts([]), '/api/triage/route': { route: null } } });
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: `(() => { let reads = 0; Object.defineProperty(window.__scenario, '/api/proxy/admin/status', { configurable: true, get() {
if (!window.__writes.some(w => w.path === '/api/proxy/admin/unit/start')) return ${JSON.stringify(installed)};
return ++reads === 1 ? { ...${JSON.stringify(down)}, busy: 'starting' } : ${JSON.stringify(down)};
} }); })();` });
await b.navigate(f.base + '/#/settings/model-setup');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next === "unit-start"');
await b.evaluate('document.querySelector("#proxy-setup-go").click(); true');
await wait('document.querySelector("#proxy-setup-progress [data-stage=answer]")?.className === "run"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-progress [data-stage=answer]").firstChild.textContent'), 'Checking the service…');
await wait('document.querySelector("#proxy-setup-progress [data-stage=answer]")?.className === "bad"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-progress [data-stage=answer]").firstChild.textContent'), 'Service not reachable yet');
});
test('service progress names a reachable service during setup', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: { '/api/config': config, 'POST /api/proxy/admin/unit/start': { body: { receipt: { op: 'unit-start', time: T } } }, ...accounts([]), '/api/triage/route': { route: null } } });
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: `(() => { let reads = 0; Object.defineProperty(window.__scenario, '/api/proxy/admin/status', { configurable: true, get() {
if (!window.__writes.some(w => w.path === '/api/proxy/admin/unit/start')) return ${JSON.stringify(installed)};
return ++reads === 1 ? { ...${JSON.stringify(running)}, next: ['fence-clear'], busy: 'starting' } : ${JSON.stringify(running)};
} }); })();` });
await b.navigate(f.base + '/#/settings/model-setup');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next === "unit-start"');
await b.evaluate('document.querySelector("#proxy-setup-go").click(); true');
await wait('document.querySelector("#proxy-setup-progress [data-stage=answer]")?.className === "ok"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-progress [data-stage=answer]").firstChild.textContent'), 'Service reachable on this machine');
await wait('document.querySelector("#setup-step-service").dataset.state === "done"');
});
test('settings-s4: ?step= opens a done card; without it a done card folds to its line', { timeout: 90000 }, async t => {
const list = [{ accountId: 'a1', provider: 'claude', displayName: 'Claude work', status: 'active', priority: 0 }];
for (const [hash, shown] of [['#/settings/model-setup?step=accounts', true], ['#/settings/model-setup', false]]) {
@@ -344,15 +437,15 @@ test('settings-s4: accounts read as rows with kind and health, the provider pick
await wait('document.querySelectorAll("#proxy-accounts li[data-account]").length === 4');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-accounts li")].map(li => [...li.children].map(c => c.innerText.replace(/\\s+/g, " ").trim()))'), [
// #1873 account-remove: the instance owner's rows end in Remove.
['Claude', 'Subscription Claude work', 'Ready', 'Remove'], ['ChatGPT / Codex', 'Subscription Codex home', 'Not working', 'Remove'], ['z.ai', 'API key z.ai key', 'Off', 'Remove'], ['Claude', 'Subscription Claude old', 'Unknown', 'Remove']]);
['Claude', 'Subscription Claude work', 'Saved', 'Remove'], ['ChatGPT / Codex', 'Subscription Codex home', 'Error', 'Remove', 'Add account'], ['z.ai', 'API key z.ai key', 'Disabled', 'Remove', 'Add account'], ['Claude', 'Subscription Claude old', 'Unknown', 'Remove']]);
assert.equal(await b.evaluate('document.querySelector("#setup-step-accounts").dataset.state'), 'bad', 'an account that is not working needs the owner');
assert.match(await b.evaluate('document.querySelector("#setup-step-accounts [data-step-summary]").textContent'), /ChatGPT \/ Codex \(subscription\): not working/);
assert.match(await b.evaluate('document.querySelector("#setup-step-accounts [data-step-summary]").textContent'), /ChatGPT \/ Codex \(subscription\): error/);
// #1873 account-remove: removing is built; the owner sees no note, only each row's Remove.
assert.doesNotMatch(await b.evaluate('document.querySelector("#setup-step-accounts").textContent'), /Removing an account is not built yet/);
assert.equal(await b.evaluate('document.querySelector("#proxy-remove-note").hidden'), true);
// The provider picks how to add: a sign-in for a subscription, Check and add for an API key.
await b.evaluate('(() => { document.querySelector("#proxy-add-box").open = true; const s = document.querySelector("#proxy-provider"); s.value = "z.ai"; s.dispatchEvent(new Event("change")); return true; })()');
assert.deepEqual(await b.evaluate('[document.querySelector("#proxy-login-go").checkVisibility(), document.querySelector("#proxy-apikey").checkVisibility(), document.querySelector("#proxy-apikey button[type=submit]").textContent]'), [false, true, 'Check and add']);
assert.deepEqual(await b.evaluate('[document.querySelector("#proxy-login-go").checkVisibility(), document.querySelector("#proxy-apikey").checkVisibility(), document.querySelector("#proxy-apikey button[type=submit]").textContent]'), [false, true, 'Save account']);
assert.ok((await primaries(b)).length <= 1, 'one primary button with the key form open');
await b.evaluate('(() => { const s = document.querySelector("#proxy-provider"); s.value = "codex"; s.dispatchEvent(new Event("change")); return true; })()');
assert.equal(await b.evaluate('document.querySelector("#proxy-login-go").textContent'), 'Sign in to ChatGPT / Codex');
@@ -387,8 +480,8 @@ test('settings-s4 chat-fail F3: an account row shows the accounts read\'s reason
await b.navigate(f.base + '/#/settings/model-setup?step=accounts');
await wait('document.querySelectorAll("#proxy-accounts li[data-account]").length === 4');
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-accounts li")].map(li => [...li.children].map(c => c.textContent.replace(/\\s+/g, " ").trim()))'), [
['Claude', 'SubscriptionClaude work', 'Not available', 'Remove', out], ['ChatGPT / Codex', 'SubscriptionCodex home', 'Not working', 'Remove', signin],
['Claude', 'SubscriptionClaude spare', 'Not working', 'Remove'], ['ChatGPT / Codex', 'SubscriptionCodex work', 'Ready', 'Remove']], `${width}: the reason follows the state; absent or empty shows nothing`);
['Claude', 'SubscriptionClaude work', 'Not available', 'Remove', out, 'Add account'], ['ChatGPT / Codex', 'SubscriptionCodex home', 'Sign-in needed', 'Remove', signin, 'Add account'],
['Claude', 'SubscriptionClaude spare', 'Error', 'Remove', 'Add account'], ['ChatGPT / Codex', 'SubscriptionCodex work', 'Saved', 'Remove']], `${width}: the reason follows the state; absent or empty shows nothing`);
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-accounts img").length + (window.__xss ?? 0)'), 0, 'the reason is text, never markup');
assert.equal(await b.evaluate('[...document.querySelectorAll("#proxy-accounts .account-reason")].every(p => p.checkVisibility() && p.getBoundingClientRect().right <= document.documentElement.clientWidth)'), true);
assert.equal(await b.evaluate('document.documentElement.scrollWidth <= document.documentElement.clientWidth'), true, `${width}: nothing scrolls sideways`);
@@ -10,7 +10,7 @@ import { createDevOwner } from '../src/dev-owner.mjs';
import { browser } from './browser.mjs';
import { close } from './fixture.mjs';
const waitFor = b => expression => b.evaluate(`(async()=>{for(let i=0;i<200;i++){if(${expression})return;await new Promise(r=>setTimeout(r,30))}throw Error(${JSON.stringify(expression)})})()`);
const waitFor = b => (expression, ms = 6000) => b.evaluate(`(async()=>{for(let i=0;i<${Math.ceil(ms / 30)};i++){if(${expression})return;await new Promise(r=>setTimeout(r,30))}throw Error(${JSON.stringify(expression)})})()`, ms + 10000);
const at = minutesAgo => new Date(Date.now() - minutesAgo * 60000).toISOString();
async function fixture({ empty = false, bootless = false } = {}) {
@@ -267,25 +267,28 @@ test('a restart started on one organization finishes on that organization after
// Every agent request read and write is recorded, whichever organization it names; the bus answers
// are stubs (terminate, closed requests, one launch). Only acme's instances read is stubbed and
// recorded (the session gone): beta's own page reads beta's instances, which is not the chain.
const init = `window.__chain = []; const original = window.fetch;
const init = `window.__chain = []; window.__requestIds = []; const original = window.fetch;
window.fetch = async (url, options = {}) => { const s = String(url); let x;
if (options.method === 'POST' && /\\/agent\\/terminate$/.test(s)) { __chain.push(s); x = { request: '${END}' }; return ${json}; }
if (options.method === 'POST' && /\\/agent\\/terminate$/.test(s)) { __chain.push(s); await new Promise(r => { window.__releaseTerminate = r; }); x = { request: '${END}' }; return ${json}; }
if (options.method === 'POST' && /\\/agent\\/launch$/.test(s)) { __chain.push(s); x = { request: '${LAUNCHED}' }; return ${json}; }
if (/\\/agent\\/request\\?/.test(s)) { __chain.push(s.split('?')[0]); const id = new URL(s, location.href).searchParams.get('id');
if (/\\/agent\\/request\\?/.test(s)) { __chain.push(s.split('?')[0]); const id = new URL(s, location.href).searchParams.get('id'); __requestIds.push(id);
x = { request: id, instance: 'coder', action: id === '${END}' ? 'end' : 'launch', state: 'closed', done: { run: id === '${END}' ? null : 'run-9' }, cancelled: null }; return ${json}; }
if (s === '/api/orgs/acme/bus/instances' && window.__restarting) { __chain.push(s); x = { rows: [{ instances: { coder: { running: [] } } }] }; return ${json}; }
return original(url, options); };`;
const { b, wait } = await setup(t, { path: '/#/orgs/acme/organization', init });
await wait('window.MosaicAgents && document.querySelector("[data-org-dashboard] h1")');
// The button the Routing receipt offers (agents.js restartMarkup), placed on acme's page.
await b.evaluate('window.__restarting = true; document.querySelector("[data-org-dashboard]").insertAdjacentHTML("beforeend", window.MosaicAgents.restartMarkup("coder")); document.querySelector("[data-agent-restart=coder]").click()');
await wait('window.__chain.length >= 1');
// Start the same chain as the Routing receipt button and observe its final status.
await b.evaluate('window.__restarting = true; document.querySelector("[data-org-dashboard]").insertAdjacentHTML("beforeend", window.MosaicAgents.restartMarkup("coder")); void window.MosaicAgents.restart("coder", false, { text(step) { window.__restartStep = step; } }); true');
await wait('typeof window.__releaseTerminate === "function"');
await b.evaluate('location.hash = "#/orgs/beta/organization"');
await wait('location.hash === "#/orgs/beta/organization"');
// Done when the chain has launched and read the launch request back, or as soon as any of it names beta.
await wait('window.__chain.some(u => u.includes("/orgs/beta/")) || (window.__chain.some(u => /\\/agent\\/launch$/.test(u)) && window.__chain.filter(u => /\\/agent\\/request$/.test(u)).length >= 2)', 30000);
await wait('window.MosaicOrg?.id === "beta" && document.querySelector("[data-org-dashboard] h1")?.textContent === "Beta Works"');
await b.evaluate('window.__releaseTerminate()');
// Stop on a cross-org request or after the launch response has been consumed successfully.
await wait('window.__chain.some(u => u.includes("/orgs/beta/")) || window.__restartStep === "restarted"', 30000);
assert.equal(await b.evaluate('window.__restartStep'), 'restarted');
const chain = await b.evaluate('window.__chain');
assert.deepEqual([...new Set(chain)], ['/api/orgs/acme/agent/terminate', '/api/orgs/acme/agent/request', '/api/orgs/acme/bus/instances', '/api/orgs/acme/agent/launch'], chain.join(' '));
assert.deepEqual(await b.evaluate('window.__requestIds'), [END, LAUNCHED]);
// beta's page draws nothing of acme's chain.
assert.equal(await b.evaluate('!!document.querySelector("[data-agent-restart-status=coder]")'), false);
});
@@ -265,3 +265,160 @@ test('shots', { timeout: 300000, skip: !process.env.MOSAIC_UX_SHOTS }, async t =
}
for (const r of results) { assert.deepEqual(r.errors, [], r.full); assert.deepEqual(r.unexpected, [], r.full); }
});
// A read of the route that answers after a save or key change. bus.js reads the route each time the
// owner opens the page, and only then (a poll does not redraw it). An owner who opens Triage, leaves
// while the read is slow and opens it again gets a second read; the first one can answer last. The
// fixture answers a read as it arrives, so the held read carries the store as it was then. release()
// lets the page have it, and __consumed is set once the page has taken its answer.
const holdNextRead = b => b.evaluate('(()=>{const prev=window.fetch;window.__held=null;window.__consumed=false;window.__arm=true;window.fetch=(input,init)=>{const path=new URL(typeof input==="string"?input:input.url,location.href).pathname;if(window.__arm&&path==="/api/triage/route"&&(init?.method??"GET")==="GET"){window.__arm=false;const answer=prev(input,init).then(r=>{const json=r.json.bind(r);r.json=()=>json().then(v=>{setTimeout(()=>{window.__consumed=true;});return v;});return r;});return new Promise(r=>{window.__held=()=>r(answer);});}return prev(input,init);};return true;})()');
const stored2 = (over, revision) => ({ ...unset, route: route({ revision, ...over }), routeMessage: undefined, revision });
// Open Triage with its read held, leave, and open it again: the second read draws the page.
async function slowFirstVisit(b, wait) {
await b.evaluate('location.hash="#/settings/appearance"');
await wait('!document.getElementById("triage-route")');
await holdNextRead(b);
await b.evaluate('location.hash="#/settings/triage"');
await wait('typeof window.__held==="function"');
await b.evaluate('location.hash="#/settings/appearance"');
await wait('document.getElementById("settings-page-title")?.textContent==="Appearance"');
await b.evaluate('location.hash="#/settings/triage"');
await wait('document.getElementById("triage-route-cap")');
}
// Repaint the panel from the page's memory, as a model change does.
const repaintPanel = b => pick(b, 'triage-route-model', 'sonnet');
test('a read that answers after a save keeps the saved route and revision, so the next save is not stale', { timeout: 90000 }, async t => {
const saved = route({ cap: 9000, revision: 2 });
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(stored2({}, 1), { 'POST /api/triage/route': { body: { route: saved, revision: 2, note: NOTE } } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-stored")?.dataset.revision==="1"');
await slowFirstVisit(b, wait);
// The held read left with revision 1. The owner saves on the page the second read drew.
await type(b, 'triage-route-cap', '9000');
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify(stored2({ cap: 9000 }, 2))}`);
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('/^Saved .+\\.$/.test(document.getElementById("triage-route-line")?.textContent) && document.getElementById("triage-route-stored")?.dataset.revision==="2"');
await b.evaluate('window.__held();true');
await wait('window.__consumed===true');
await repaintPanel(b);
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '2', 'the older read does not put back revision 1');
assert.equal(await value(b, 'triage-route-cap'), '9000', 'the older read does not put back the old route');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('window.__writes.filter(w=>w.path==="/api/triage/route").length===2');
assert.equal((await writes(b)).at(-1).body.revision, 2, 'the next save sends the saved revision');
assert.deepEqual(await b.evaluate('window.__errors'), []);
});
test('a read that answers after a key change keeps the new key state', { timeout: 90000 }, async t => {
const before = { key: 'missing' }, after = { key: 'issued', keyId: 'k-2', rotateBy: '2026-12-18' };
const { f, b, wait } = await w15Fixture(t, { scenario: scenario({ ...stored2({}, 1), access: before }, { 'POST /api/triage/access': { body: { access: after, key: { action: 'issued' } } } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-access")?.dataset.key==="missing"');
await slowFirstVisit(b, wait);
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify({ ...stored2({}, 1), access: after })}`);
await b.evaluate('document.getElementById("triage-access-repair").click()');
await wait('document.getElementById("triage-access-line")?.textContent==="A Triage key was issued." && document.getElementById("triage-access")?.dataset.key==="issued"');
await b.evaluate('window.__held();true');
await wait('window.__consumed===true');
await repaintPanel(b);
assert.equal(await b.evaluate('document.getElementById("triage-access").dataset.key'), 'issued', 'the older read does not put back the missing key');
assert.deepEqual(await b.evaluate('window.__errors'), []);
});
test('a Reload route read that answers after a save keeps the saved route, its receipt and its revision', { timeout: 90000 }, async t => {
const message = 'The Triage route changed since this page read it. Reload the route, then save again.';
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(stored2({}, 1), { 'POST /api/triage/route': { status: 409, body: { error: 'triage-route-stale', message, revision: 3 } } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-stored")?.dataset.revision==="1"');
await type(b, 'triage-route-cap', '5000');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait(`document.getElementById("triage-route-line")?.textContent===${JSON.stringify(message)}`);
// Reload route reads revision 3, held. The owner types the route again and saves before it answers.
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify(stored2({ cap: 3 }, 3))}`);
await holdNextRead(b);
await b.evaluate('document.getElementById("triage-route-reload").click()');
await wait('typeof window.__held==="function"');
const saved = route({ harness: 'claude-code', cap: 150000, timeZone: 'America/Chicago', revision: 4 });
await b.evaluate(`window.__scenario['POST /api/triage/route'] = {body: {route: ${JSON.stringify(saved)}, revision: 4, note: ${JSON.stringify(NOTE)}}}`);
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify(stored2({ harness: 'claude-code', cap: 150000, timeZone: 'America/Chicago' }, 4))}`);
await fill(b);
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('/^Saved .+\\.$/.test(document.getElementById("triage-route-line")?.textContent) && document.getElementById("triage-route-stored")?.dataset.revision==="4"');
const receipt = await text(b, 'triage-route-line');
await b.evaluate('window.__held();true');
await wait('window.__consumed===true');
await repaintPanel(b);
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '4', 'the reload read does not put back revision 3');
assert.equal(await value(b, 'triage-route-cap'), '150000');
assert.equal(await text(b, 'triage-route-line'), receipt, 'the save receipt stays');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('window.__writes.filter(w=>w.path==="/api/triage/route").length===3');
assert.equal((await writes(b)).at(-1).body.revision, 4, 'the next save sends the saved revision');
assert.deepEqual(await b.evaluate('window.__errors'), []);
});
test('a Reload route read that answers after a key change keeps the new key state', { timeout: 90000 }, async t => {
const message = 'The Triage route changed since this page read it. Reload the route, then save again.';
const before = { key: 'missing' }, after = { key: 'issued', keyId: 'k-2', rotateBy: '2026-12-18' };
const { f, b, wait } = await w15Fixture(t, { scenario: scenario({ ...stored2({}, 1), access: before }, { 'POST /api/triage/route': { status: 409, body: { error: 'triage-route-stale', message, revision: 1 } }, 'POST /api/triage/access': { body: { access: after, key: { action: 'issued' } } } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-access")?.dataset.key==="missing"');
await type(b, 'triage-route-cap', '5000');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait(`document.getElementById("triage-route-line")?.textContent===${JSON.stringify(message)}`);
// Reload route reads revision 3 and the missing key, held. The owner repairs access before it answers.
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify({ ...stored2({ cap: 3 }, 3), access: before })}`);
await holdNextRead(b);
await b.evaluate('document.getElementById("triage-route-reload").click()');
await wait('typeof window.__held==="function"');
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify({ ...stored2({ cap: 3 }, 3), access: after })}`);
await b.evaluate('document.getElementById("triage-access-repair").click()');
await wait('document.getElementById("triage-access-line")?.textContent==="A Triage key was issued." && document.getElementById("triage-access")?.dataset.key==="issued"');
await b.evaluate('window.__held();true');
await wait('window.__consumed===true');
// A key change does not touch the route, so the reload still draws the route it read, with the new key.
assert.equal(await b.evaluate('document.getElementById("triage-access").dataset.key'), 'issued', 'the reload read does not put back the missing key');
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '3', 'the reload read draws the stored revision');
assert.equal(await value(b, 'triage-route-cap'), '3', 'the fields show the stored route');
assert.equal(await text(b, 'triage-route-line'), 'Route read again. Your fields now show the stored route.');
assert.equal(await b.evaluate('document.getElementById("triage-route-reload")'), null);
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('window.__writes.filter(w=>w.path==="/api/triage/route").length===2');
assert.equal((await writes(b)).at(-1).body.revision, 3, 'the next save sends the revision the reload read');
assert.deepEqual(await b.evaluate('window.__errors'), []);
});
// Hold the next two route reads. Each answers as it arrives (so it carries the store as it was then);
// __holds[i].release() lets the page have it and __holds[i].fail() fails it as a network error does.
// __taken counts the reads the page has taken, answered or failed.
const holdTwoReads = b => b.evaluate('(()=>{const prev=window.fetch;window.__holds=[];window.__taken=0;window.fetch=(input,init)=>{const path=new URL(typeof input==="string"?input:input.url,location.href).pathname;if(window.__holds.length<2&&path==="/api/triage/route"&&(init?.method??"GET")==="GET"){const answer=prev(input,init).then(r=>{const json=r.json.bind(r);r.json=()=>json().then(v=>{setTimeout(()=>{window.__taken++;});return v;});return r;});return new Promise((ok,no)=>{window.__holds.push({release:()=>ok(answer),fail:()=>{answer.catch(()=>{});setTimeout(()=>{window.__taken++;});no(new TypeError("Failed to fetch"));}});});}return prev(input,init);};return true;})()');
test('a Reload route read that fails after a key change does not let an older read put back the old key state', { timeout: 90000 }, async t => {
const message = 'The Triage route changed since this page read it. Reload the route, then save again.';
const before = { key: 'missing' }, after = { key: 'issued', keyId: 'k-2', rotateBy: '2026-12-18' };
const { f, b, wait } = await w15Fixture(t, { scenario: scenario({ ...stored2({}, 1), access: before }, { 'POST /api/triage/route': { status: 409, body: { error: 'triage-route-stale', message, revision: 3 } }, 'POST /api/triage/access': { body: { access: after, key: { action: 'issued' } } } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-access")?.dataset.key==="missing"');
await type(b, 'triage-route-cap', '5000');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait(`document.getElementById("triage-route-line")?.textContent===${JSON.stringify(message)}`);
// Two clicks on Reload route, both reads held with the missing key. Repair access lands first.
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify({ ...stored2({ cap: 3 }, 3), access: before })}`);
await holdTwoReads(b);
await b.evaluate('document.getElementById("triage-route-reload").click()');
await wait('window.__holds.length===1');
await b.evaluate('document.getElementById("triage-route-reload").click()');
await wait('window.__holds.length===2');
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify({ ...stored2({ cap: 3 }, 3), access: after })}`);
await b.evaluate('document.getElementById("triage-access-repair").click()');
await wait('document.getElementById("triage-access-line")?.textContent==="A Triage key was issued." && document.getElementById("triage-access")?.dataset.key==="issued"');
// The first read fails, so the page says the route could not be read. The second then answers.
await b.evaluate('window.__holds[0].fail();true');
await wait('window.__taken===1');
await b.evaluate('window.__holds[1].release();true');
await wait('window.__taken===2');
assert.equal(await b.evaluate('document.getElementById("triage-access")?.dataset.key ?? null'), 'issued', 'the older read does not put back the missing key');
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '3', 'the newer read draws its route');
assert.deepEqual(await b.evaluate('window.__errors'), []);
});
@@ -55,6 +55,7 @@ function store(writable) {
st.view = org => (st.down[org.id] ? { ...org, busHealthy: false, ...(st.down[org.id] === 'stopped' ? { busStopped: true } : {}) } : org);
// SP17: hold('read') holds the next workflow read, which answers with the file as it was when the read
// began; hold('write') holds the next write before it reaches the file. Each returns the release.
// st.onHeld, when set, is called as a held read arrives.
st.hold = which => { let open; st.held[which] = new Promise(r => { open = r; }); return open; };
const fail = code => Object.assign(new Error(code), { code });
st.write = (id, verb, args) => {
@@ -86,9 +87,11 @@ function organizations(reads, st) {
const org = LIST.find(o => o.id === id); if (!org) return null;
const workflowsRead = async () => {
reads.push(id);
if (st.failRead) throw Object.assign(new Error('org-unavailable'), { code: 'org-unavailable' });
const answer = { revision: st.revs[id], document: structuredClone(st.docs[id] ?? {}), templates: ['writer', 'triage'] };
const h = st.held.read; if (h) { st.held.read = null; await h; }
// The answer, or the refusal, is settled as the read arrives; a held read gives it on release.
const error = st.failRead ? Object.assign(new Error('org-unavailable'), { code: 'org-unavailable' }) : null;
const answer = error ? null : { revision: st.revs[id], document: structuredClone(st.docs[id] ?? {}), templates: ['writer', 'triage'] };
const h = st.held.read; if (h) { st.held.read = null; st.onHeld?.(); await h; }
if (error) throw error;
return answer;
};
if (!org.busHealthy) return { busHealthy: false, reads: null, bus: {}, workflowsRead, chat: { projects: async () => [], threads: async () => [] } };
@@ -1040,3 +1043,40 @@ test('SP17: the bar Save with a new step typed in the add form says so and keeps
await wait(`/Saved change\\./.test(${text('[data-wfg-status]')})`, 'saved');
assert.deepEqual(st.writes.at(-1).args.workflow.steps.map(s => [s.title, s.roles]), [['Build it', ['coder']], ['Check', ['human']], ['Ship', ['human']]]);
});
// Two reads with no write between them: the older one answers last. The page keeps the newer read, so what
// it draws next and the revision its next Save sends come from the newer read. A fetch wrapper in the page
// counts each workflow read the page has taken, so the test knows when the older one landed.
const countTaken = b => b.evaluate(`(()=>{const prev=window.fetch;window.__wfTaken=0;window.fetch=(input,init)=>{const url=typeof input==='string'?input:input.url;const p=prev(input,init);if(!/\\/workflows$/.test(new URL(url,location.href).pathname)||(init?.method??'GET')!=='GET')return p;return p.then(r=>{const json=r.json.bind(r);r.json=()=>json().finally(()=>setTimeout(()=>window.__wfTaken++));return r;});};return true})()`);
async function olderLast(t, { olderFails }) {
const { b, wait, st } = await setup(t, { path: '#/orgs/acme/workflows/change?project=site&step=2' });
await wait(`${boxes}.length === 2 && document.querySelector('[data-wfg-detail]')`, 'site graph');
await countTaken(b);
const repaint = () => b.evaluate(`document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));true`);
// The older read takes the file as it is now (or is refused), and is held.
const arrived = new Promise(r => { st.onHeld = r; });
const openOld = st.hold('read');
st.failRead = olderFails;
await repaint();
await arrived;
st.failRead = false;
// Another writer changes this workflow. A newer read takes that and draws it.
st.change('acme', doc => { doc.projects.site.workflows.change.description = 'Changed elsewhere.'; });
const fresh = st.revs.acme;
await repaint();
await wait(`/Changed elsewhere\\./.test(document.querySelector('#bus-view .sub')?.textContent) && window.__wfTaken === 1`, 'newer read drawn');
// The older read answers last.
openOld();
await wait(`window.__wfTaken === 2`, 'older read taken');
assert.doesNotMatch(await b.evaluate(`window.MosaicWorkflows.card('acme')`), /data-wfg-error/, 'the page still holds a read');
assert.match(await b.evaluate(`window.MosaicWorkflows.card('acme')`), /data-wfg-card-step/);
await retitle(b, wait, 2, 'Ship the release');
assert.equal(await b.evaluate(`document.querySelector('[data-wfg-stale]')`), null);
await b.evaluate(press('[data-wfg-save]'));
await wait(`/Saved change\\.|changed since this page read it/.test(${text('[data-wfg-status]')})`, 'save answered');
assert.equal(st.writes.length, 1);
assert.equal(st.writes[0].args.revision, fresh, 'the Save sends the revision the newer read took');
assert.match(await b.evaluate(text('[data-wfg-status]')), /Saved change\./);
}
test('an older workflow read that answers after a newer one does not put back what the newer one read', { timeout: 60000 }, t => olderLast(t, { olderFails: false }));
test('an older workflow read that fails after a newer one answered keeps the newer read', { timeout: 60000 }, t => olderLast(t, { olderFails: true }));
+4
View File
@@ -73,6 +73,10 @@ case "$OP" in
else
echo "env-side credential-like names set: (none)"
fi
# lane health-reason: the provider the default run asks for, and whether the worker
# container compose starts will hold a credential for it (names and types only).
node scripts/worker-credential.mjs status 2>/dev/null \
|| echo "default run: provider ${MOSAIC_PROVIDER:-(unset)} (config execution.provider); worker container credential: not checked (the check could not run)"
echo "mosaic-managed accounts ($ACCOUNTS_DIR):"
shopt -s nullglob
FILES=("$ACCOUNTS_DIR"/*.json)
+31
View File
@@ -0,0 +1,31 @@
#!/usr/bin/env node
// lane health-reason: the reason line for a release health check that gave no run id, picked
// from what the runner wrote to stderr. The last refusal line from the runner or its helpers
// (mosaic-task:, run-task:, config:, common:) wins, with its prefix dropped; notes that don't stop
// a run are passed over; with no refusal line, the last line. The line is redacted (paths, links,
// emails, key-shaped strings) and withheld whole when it holds a value from the environment.
//
// node scripts/health-reason.mjs <stderr file> prints the line, or nothing when none can be shown
import { readFileSync, realpathSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { redactLine, secretValues } from "../packages/model-proxy/src/redact.mjs";
const PREFIX = /^(?:mosaic-task|run-task|config|common): /;
const NOTES = [/^run-task: note:/, /^mosaic-task: worker credential not checked:/];
export function runnerReason(text, env = process.env) {
const lines = String(text ?? "").split(/\r?\n/).filter((line) => line.trim());
const refusals = lines.filter((line) => PREFIX.test(line) && !NOTES.some((re) => re.test(line)));
const pick = refusals.length ? refusals[refusals.length - 1] : lines[lines.length - 1];
if (!pick) return null;
return redactLine(pick.replace(PREFIX, ""), secretValues(env)).text ?? null;
}
const self = fileURLToPath(import.meta.url);
let main = false;
try { main = realpathSync(process.argv[1] ?? "") === realpathSync(self); } catch {}
if (main) {
let text = "";
try { text = readFileSync(process.argv[2] ?? "", "utf8"); } catch {}
process.stdout.write(runnerReason(text) ?? "");
}
+67 -7
View File
@@ -36,8 +36,10 @@ import { randomBytes } from "node:crypto";
import { spawnSync } from "node:child_process";
import { fileURLToPath } from "node:url";
import { imageTag } from "./image-tag.mjs";
import { checkWorkerCredential, missingLine } from "./worker-credential.mjs";
import { BusinessError, validateRoleDocument } from "../packages/organization/src/index.mjs";
import { RunsError, isRunId, listRunRecords, readRunRecord } from "../packages/runs/src/index.mjs";
import { RunsError, isRunId, listRunRecords, readRunRecord, readRunText } from "../packages/runs/src/index.mjs";
import { redactLine, secretValues } from "../packages/model-proxy/src/redact.mjs";
import { initializeControl, assertProcessing } from "../packages/processing-control/src/state.mjs";
import { runContainer } from "../packages/processing-control/src/containers.mjs";
import { unregisterRuntime } from "../packages/processing-control/src/runtimes.mjs";
@@ -328,7 +330,7 @@ function readSessionFork(file) {
}
}
function runTask(taskFile, options = {}) {
async function runTask(taskFile, options = {}) {
const resolved = JSON.parse(
spawnSync(process.execPath, [path.join(PROJECT_ROOT, "scripts", "mosaic-config.mjs"), "validate"], {
cwd: PROJECT_ROOT,
@@ -344,6 +346,26 @@ function runTask(taskFile, options = {}) {
// package.json range. Read before the run directory exists, so a lock it can't read leaves none.
let tag;
try { tag = imageTag(PROJECT_ROOT); } catch (e) { fail(4, e.message); }
// lane health-reason: the provider the run asks for (config execution.provider) needs a
// credential the worker container receives, or pi stops before the prompt. Checked against the
// environment compose reads, before the run directory exists, so a refusal leaves no record.
const launchEnv = {
...process.env,
MOSAIC_ADAPTER: resolved.execution.adapter,
MOSAIC_PROVIDER: resolved.execution.provider,
MOSAIC_MODEL: resolved.execution.model,
MOSAIC_IMAGE_TAG: tag,
};
const credential = await checkWorkerCredential({
adapter: resolved.execution.adapter,
provider: resolved.execution.provider,
env: launchEnv,
root: PROJECT_ROOT,
});
if (credential.state === "missing") fail(3, missingLine(credential));
if (credential.state === "undecided") {
process.stderr.write(`mosaic-task: worker credential not checked: ${credential.why}\n`);
}
const runId = `r-${utcStamp()}-${randomBytes(3).toString("hex")}`;
const runDir = path.join(runsRoot(resolved), runId);
@@ -514,7 +536,9 @@ function runTask(taskFile, options = {}) {
writeOnce(path.join(runDir, "result.json"), `${JSON.stringify(result, null, 2)}\n`);
if (!haltGeneration && !proc.error && proc.status === 0) unregisterRuntime(resolved.dataRoot, managed.id);
process.stdout.write(`run: ${runId}\nstatus: ${status}${reason ? ` (${reason})` : ""}\nresponse: ${response}\n`);
// worker-stop-reason: a failed run also says why on the terminal, with the line `show` prints.
const cause = status === "succeeded" ? null : runCause(resolved.dataRoot, runId, result);
process.stdout.write(`run: ${runId}\nstatus: ${status}${reason ? ` (${reason})` : ""}\nresponse: ${response}\n${cause ? `cause: ${cause}\n` : ""}`);
process.exit(status === "succeeded" ? 0 : 1);
}
@@ -546,6 +570,41 @@ function listRuns() {
}
}
// lane health-reason: one plain line saying why a failed run failed, for `show` and the release
// health check. A reason the runner decided itself is said in words. For a worker that exited
// with an error, the line is taken from the run's stderr.txt: compose's own progress and warning
// lines and NAME=value lines are passed over, a line that reads as an error is preferred, and the
// line is redacted (links, paths, emails, key-shaped strings) and withheld whole when it holds a
// secret value from this process's environment. Never a host path or a value.
const PLAIN_REASONS = {
timeout: "the run passed its time limit and was stopped",
"expect-mismatch": "the response did not match the expected text",
"kill-switch": "processing was halted during the run",
};
const NOISE = [
/^\s*(?:Network|Container|Volume|Image)\s+\S+\s+(?:Creating|Created|Starting|Started|Stopping|Stopped|Removing|Removed|Pulling|Pulled|Waiting|Healthy|Running|Recreate|Recreated)\b/,
/^\s*(?:Warning|WARN)\b/i,
/^\s*time="[^"]*"\s+level=warn/i,
/^[A-Za-z_][A-Za-z0-9_]*=/,
];
const ERRORISH = /\b(?:error|errors|failed|fail|fails|no|not|cannot|can't|unable|refus\w*|denied|missing|invalid|unauthori[sz]ed|forbidden|expired)\b/i;
function runCause(dataRoot, runId, result) {
if (!result || result.status === "succeeded") return null;
const reason = typeof result.reason === "string" ? result.reason : "";
if (PLAIN_REASONS[reason]) return PLAIN_REASONS[reason];
const secrets = secretValues(process.env);
const text = readRunText(dataRoot, runId, "stderr.txt") ?? "";
const lines = text.split(/\r?\n/).filter((line) => line.trim() && !NOISE.some((re) => re.test(line)));
for (const line of [...lines.filter((l) => ERRORISH.test(l)), ...lines]) {
const shown = redactLine(line, secrets);
if (shown.text) return `worker said: ${shown.text}`;
}
if (reason.startsWith("spawn-error")) return "the worker container could not be started";
const code = Number.isInteger(result.exitCode) ? ` with code ${result.exitCode}` : "";
return `the worker exited${code} and wrote nothing that can be shown`;
}
function showRun(runId) {
if (!isRunId(runId)) {
fail(4, `invalid run id: ${JSON.stringify(runId)} (expected r-<id>)`);
@@ -574,6 +633,7 @@ function showRun(runId) {
result.retriedFrom ? `retriedFrom: ${result.retriedFrom}` : null,
`timing: ${result.startedAt} -> ${result.finishedAt} (${result.durationMs} ms)`,
`exit: ${result.exitCode}${result.signal ? ` signal=${result.signal}` : ""}`,
result.status !== "succeeded" ? `cause: ${runCause(resolved.dataRoot, runId, result)}` : null,
].filter((line) => line !== null).join("\n") + "\n",
);
} else {
@@ -585,7 +645,7 @@ function showRun(runId) {
process.exit(0);
}
function retryRun(runId) {
async function retryRun(runId) {
if (!/^r-[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(runId)) {
fail(4, `invalid run id: ${JSON.stringify(runId)} (expected r-<id>)`);
}
@@ -632,7 +692,7 @@ function retryRun(runId) {
// Best-effort cleanup only.
}
});
runTask(tempTaskFile, { retriedFrom: runId });
await runTask(tempTaskFile, { retriedFrom: runId });
}
function pruneRuns(args) {
@@ -695,7 +755,7 @@ switch (operation) {
}
case "run":
if (!target) fail(4, "usage: mosaic-task.mjs run <taskFile>");
runTask(path.resolve(target));
await runTask(path.resolve(target));
break;
case "show":
if (!target) fail(4, "usage: mosaic-task.mjs show <runId>");
@@ -717,7 +777,7 @@ switch (operation) {
}
case "retry":
if (!target) fail(4, "usage: mosaic-task.mjs retry <runId>");
retryRun(target);
await retryRun(target);
break;
default:
fail(4, `unknown operation: ${JSON.stringify(operation ?? "")} (expected validate | run | show | list | retry | prune | resolve-role)`);
+23 -4
View File
@@ -39,10 +39,10 @@ append_log() { # event release imageTag note
image_exists() { docker image inspect "$1" >/dev/null 2>&1; }
health_check() { # returns 0 only when the marker path passes; $1 = fault injection label or empty
local tmp=""
local tmp
tmp="$(mktemp -d)" || { echo "release: health check can't make its temporary directory" >&2; return 1; }
local task="tasks/hello-marker.json"
if [ -n "${1:-}" ]; then
tmp="$(mktemp -d)"
# Fault injection: same prompt, deliberately wrong expectation.
printf '{"taskVersion":1,"id":"t-health-fault","prompt":"Return your startup marker and nothing else.","expectExact":"MOSAIC_FAULT_%s"}' \
"$RANDOM$RANDOM" > "$tmp/fault-task.json"
@@ -51,11 +51,30 @@ health_check() { # returns 0 only when the marker path passes; $1 = fault inject
local rc=0
# MOSAIC_ENSURE_SKIP: the gate's run must not re-enter release
# self-determination (recursion guard).
MOSAIC_ENSURE_SKIP=1 scripts/run-task.sh run "$task" >/dev/null 2>&1 || rc=$?
[ -n "$tmp" ] && rm -rf "$tmp"
MOSAIC_ENSURE_SKIP=1 scripts/run-task.sh run "$task" >"$tmp/out.txt" 2>"$tmp/err.txt" || rc=$?
[ "$rc" -eq 0 ] || health_reason "$tmp/out.txt" "$tmp/err.txt"
rm -rf "$tmp"
return "$rc"
}
# lane health-reason: why the health check failed, on stderr. With a run id: the id and the cause
# line `mosaic-task show` reads from its record. With none (the runner refused before it printed
# one): the last refusal line the runner printed, redacted by scripts/health-reason.mjs. Never a
# value or a host path.
health_reason() { # $1 = the run's stdout, $2 = its stderr
local run cause
run="$(sed -n 's/^run: \(r-[A-Za-z0-9][A-Za-z0-9._-]*\)$/\1/p' "$1" | head -n 1)" || run=""
if [ -n "$run" ]; then
echo "release: health check run: $run" >&2
cause="$(node scripts/mosaic-task.mjs show "$run" 2>/dev/null | sed -n 's/^cause: *//p' | head -n 1)" || cause=""
echo "release: reason: ${cause:-the run record names no cause}" >&2
return 0
fi
cause="$(node scripts/health-reason.mjs "$2" 2>/dev/null)" || cause=""
echo "release: health check gave no run id" >&2
echo "release: reason: ${cause:-the runner printed nothing that can be shown}" >&2
}
activate() { # $1 = release, $2 = imageTag, $3 = event name, $4 = fault label
local release="$1" imageTag="$2" event="$3" fault="${4:-}"
+51
View File
@@ -83,6 +83,57 @@ printf '%s\n' "$OUT" | grep -q "FAKE_TEST_API_KEY" \
printf '%s\n' "$OUT" | grep -q "$ENVVAL" \
&& check "env var values never reach output" 1 || check "env var values never reach output" 0
# status: the provider the default run asks for and whether the worker container holds a
# credential for it (lane health-reason). A pi config; the API key variables compose passes are
# unset so only the fixture decides.
printf '{"configVersion":1,"environment":"development","dataRoot":"%s","execution":{"backend":"docker","provider":"zai","model":"m","adapter":"pi"}}' "$SANDBOX/data" > "$SANDBOX/pi-config.json"
printf '{"configVersion":1,"environment":"development","dataRoot":"%s","execution":{"backend":"docker","provider":"openai","model":"m","adapter":"pi"}}' "$SANDBOX/data" > "$SANDBOX/pi-config-openai.json"
PI_ENV="env -u ZAI_API_KEY -u ANTHROPIC_API_KEY -u COMPOSE_FILE -u COMPOSE_ENV_FILES"
OUT="$($PI_ENV PI_AUTH_FILE="$SANDBOX/pi/auth.json" MOSAIC_CONFIG="$SANDBOX/pi-config.json" scripts/auth.sh status 2>&1)"; RC=$?
[ "$RC" -eq 0 ] \
&& printf '%s\n' "$OUT" | grep -qx 'default run: provider zai (config execution.provider); worker container credential: yes' \
&& check "status names the default run's provider and a credential the container will have" 0 \
|| check "status names the default run's provider and a credential the container will have" 1
OUT="$($PI_ENV PI_AUTH_FILE="$SANDBOX/pi/auth.json" MOSAIC_CONFIG="$SANDBOX/pi-config-openai.json" scripts/auth.sh status 2>&1)"
printf '%s\n' "$OUT" | grep -qx 'default run: provider openai (config execution.provider); worker container credential: none (it has: anthropic, zai)' \
&& ! printf '%s\n' "$OUT" | grep -q "$SECRET\|$TOKEN" \
&& check "status says the container has no credential for the default provider, lists what it has, prints no value" 0 \
|| check "status says the container has no credential for the default provider, lists what it has, prints no value" 1
OUT="$($PI_ENV ZAI_API_KEY=$ENVVAL PI_AUTH_FILE="$SANDBOX/pi/broken.json" MOSAIC_CONFIG="$SANDBOX/pi-config.json" scripts/auth.sh status 2>&1)"
printf '%s\n' "$OUT" | grep -qx 'default run: provider zai (config execution.provider); worker container credential: yes' \
&& ! printf '%s\n' "$OUT" | grep -q "$ENVVAL" \
&& check "a key variable compose passes counts for the credential line, its value never printed" 0 \
|| check "a key variable compose passes counts for the credential line, its value never printed" 1
# A key variable that is only spaces is unset to pi, so it is no credential.
OUT="$($PI_ENV ZAI_API_KEY=' ' PI_AUTH_FILE="$SANDBOX/pi/broken.json" MOSAIC_CONFIG="$SANDBOX/pi-config.json" scripts/auth.sh status 2>&1)"
printf '%s\n' "$OUT" | grep -qx 'default run: provider zai (config execution.provider); worker container credential: none (it has: none)' \
&& check "a key variable that is only spaces is no credential" 0 \
|| check "a key variable that is only spaces is no credential" 1
# A PI_AUTH_FILE under ~ is read as compose mounts it, from the home directory.
mkdir -p "$SANDBOX/home2"
cp "$SANDBOX/pi/auth.json" "$SANDBOX/home2/auth.json"
OUT="$($PI_ENV HOME="$SANDBOX/home2" PI_AUTH_FILE='~/auth.json' MOSAIC_CONFIG="$SANDBOX/pi-config.json" scripts/auth.sh status 2>&1)"
printf '%s\n' "$OUT" | grep -qx 'default run: provider zai (config execution.provider); worker container credential: yes' \
&& check "a PI_AUTH_FILE under ~ is read from the home directory, as compose mounts it" 0 \
|| check "a PI_AUTH_FILE under ~ is read from the home directory, as compose mounts it" 1
# Where compose reads more than the check does, or the file can't be read here, it says so.
OUT="$($PI_ENV COMPOSE_ENV_FILES="$SANDBOX/x.env" PI_AUTH_FILE="$SANDBOX/pi/auth.json" MOSAIC_CONFIG="$SANDBOX/pi-config.json" scripts/auth.sh status 2>&1)"
printf '%s\n' "$OUT" | grep -qx "default run: provider zai (config execution.provider); worker container credential: not checked (COMPOSE_ENV_FILES names a file this check doesn't read)" \
&& check "COMPOSE_ENV_FILES leaves the credential not checked" 0 \
|| check "COMPOSE_ENV_FILES leaves the credential not checked" 1
if [ "$(id -u)" -ne 0 ]; then
cp "$SANDBOX/pi/auth.json" "$SANDBOX/pi/locked.json"; chmod 000 "$SANDBOX/pi/locked.json"
OUT="$($PI_ENV PI_AUTH_FILE="$SANDBOX/pi/locked.json" MOSAIC_CONFIG="$SANDBOX/pi-config.json" scripts/auth.sh status 2>&1)"
chmod 600 "$SANDBOX/pi/locked.json"
printf '%s\n' "$OUT" | grep -qx "default run: provider zai (config execution.provider); worker container credential: not checked (this user can't read the auth file the container mounts)" \
&& check "an auth file this user can't read leaves the credential not checked" 0 \
|| check "an auth file this user can't read leaves the credential not checked" 1
fi
OUT="$(env PI_AUTH_FILE="$SANDBOX/pi/auth.json" $CFG scripts/auth.sh status 2>&1)"
printf '%s\n' "$OUT" | grep -qx 'default run: provider zai (config execution.provider); the adapter needs no credential' \
&& check "status says the mock adapter needs no credential" 0 \
|| check "status says the mock adapter needs no credential" 1
# accounts: mosaic-managed, under the data root — a data root with no accounts dir is the default state: (none), exit 0, creates nothing
printf '{"configVersion":1,"environment":"development","dataRoot":"%s","execution":{"backend":"docker","provider":"zai","model":"m","adapter":"mock"}}' "$SANDBOX/empty" > "$SANDBOX/mock-config-empty.json"
OUT="$(env PI_AUTH_FILE="$SANDBOX/pi/auth.json" MOSAIC_CONFIG="$SANDBOX/mock-config-empty.json" scripts/auth.sh accounts 2>&1)"; RC=$?
+40
View File
@@ -74,6 +74,24 @@ bash -c 'source scripts/common.sh && load_release' >/dev/null 2>&1
bash -c 'source scripts/common.sh && load_release && case "$MOSAIC_IMAGE_TAG" in mosaic-poc-agent:*-r'"$(cat RELEASE)"') exit 0;; *) exit 1;; esac' >/dev/null 2>&1
check "valid RELEASE leaves image tag consistent with version" $?
# ---------- fast: the reason line when the health check gave no run id (lane health-reason) ----------
# The runner's last refusal line wins over notes, loses its prefix and is redacted: no host path and
# no key-shaped value. A line holding a value from the environment is withheld whole.
cat > "$SANDBOX/runner-err.txt" <<EOF
run-task: note: the session is new
mosaic-task: cannot fork: source session dir not found: $SANDBOX/sessions/x token=ghp_FIXTURE0123456789
mosaic-task: worker credential not checked: compose.yaml can't be read
EOF
REASON="$(node scripts/health-reason.mjs "$SANDBOX/runner-err.txt")"
case "$REASON" in "cannot fork: source session dir not found: "*) ok=0 ;; *) ok=1 ;; esac
[ "$ok" = 0 ] && ! printf '%s' "$REASON" | grep -qF "$SANDBOX" && ! printf '%s' "$REASON" | grep -qF 'ghp_FIXTURE' \
&& check "reason with no run id is the runner's refusal, redacted" 0 \
|| { check "reason with no run id is the runner's refusal, redacted" 1; printf '%s\n' "$REASON" >&2; }
printf 'mosaic-task: cannot start: quietharbourlamp refused\n' > "$SANDBOX/runner-err2.txt"
REASON="$(FIXTURE_TOKEN=quietharbourlamp node scripts/health-reason.mjs "$SANDBOX/runner-err2.txt")"
[ -z "$REASON" ] && check "reason holding an environment secret is withheld" 0 \
|| { check "reason holding an environment secret is withheld" 1; printf '%s\n' "$REASON" >&2; }
# ---------- sandboxed state machine (Docker required) ----------
if docker info >/dev/null 2>&1; then
mkdir -p "$SANDBOX/data"
@@ -106,6 +124,28 @@ process.exit(e.event === "refused" && e.release && e.imageTag && e.at ? 0 : 1);
check "refusal logged exactly once with valid fields" 1
fi
# The refusal says which run failed and why, from the run record (lane health-reason).
env MOSAIC_MOCK_RESPONSE=MOSAIC_HELLO_OK scripts/release.sh activate --fault-injection >"$SANDBOX/fault-out.txt" 2>&1
FAULT_RUN="$(sed -n 's/^release: health check run: \(r-[A-Za-z0-9][A-Za-z0-9._-]*\)$/\1/p' "$SANDBOX/fault-out.txt")"
[ -n "$FAULT_RUN" ] && [ -f "$SANDBOX/data/runs/$FAULT_RUN/result.json" ] \
&& grep -qx 'release: reason: the response did not match the expected text' "$SANDBOX/fault-out.txt" \
&& [ "$(tail -n 1 "$SANDBOX/fault-out.txt")" = "release: refusing activate: health check failed" ] \
&& ! grep -qF "$SANDBOX" "$SANDBOX/fault-out.txt" \
&& check "refused activation prints its run id and reason, no host path" 0 \
|| { check "refused activation prints its run id and reason, no host path" 1; cat "$SANDBOX/fault-out.txt" >&2; }
# A pi config whose provider the container has no credential for refuses before a run record;
# the reason is the runner's refusal line.
cat > "$SANDBOX/pi-config.json" <<EOF
{"configVersion":1,"environment":"development","dataRoot":"$SANDBOX/data","execution":{"backend":"docker","provider":"zai","model":"glm-5.3-flash","adapter":"pi"}}
EOF
env -u ZAI_API_KEY -u ANTHROPIC_API_KEY -u COMPOSE_FILE -u COMPOSE_ENV_FILES MOSAIC_CONFIG="$SANDBOX/pi-config.json" \
scripts/release.sh activate >"$SANDBOX/cred-out.txt" 2>&1
grep -qx 'release: health check gave no run id' "$SANDBOX/cred-out.txt" \
&& grep -q '^release: reason: the worker container has no credential for provider zai (config execution.provider); it has credentials for: none\.' "$SANDBOX/cred-out.txt" \
&& [ "$(tail -n 1 "$SANDBOX/cred-out.txt")" = "release: refusing activate: health check failed" ] \
&& check "activation with no worker credential prints the refusal as its reason" 0 \
|| { check "activation with no worker credential prints the refusal as its reason" 1; cat "$SANDBOX/cred-out.txt" >&2; }
expect_exit "healthy activation succeeds" 0 -- env MOSAIC_MOCK_RESPONSE=MOSAIC_HELLO_OK scripts/release.sh activate
node -e '
const fs = require("fs");
+80
View File
@@ -170,6 +170,86 @@ NEWEST="r-20260903T0100_05Z-suite005"
|| check "sessions/workspaces untouched by prune" 1
expect_exit "prune with invalid keep exits 4" 4 -- env MOSAIC_CONFIG="$SANDBOX/prune-config.json" node scripts/mosaic-task.mjs prune --keep=0 --yes
# ---------- worker credential check and run cause (lane health-reason; fixtures, stub docker) ----------
# A pi run whose provider has no credential the worker container receives refuses before the run
# directory exists. Auth files are fixtures; the API key variables compose passes are unset; a
# stub docker stands in for the container, so nothing reaches a provider or the host's pi.
CRED_ROOT="$SANDBOX/cred-data"
mkdir -p "$CRED_ROOT" "$SANDBOX/cred-bin" "$SANDBOX/pi"
cat > "$SANDBOX/cred-config.json" <<EOF
{"configVersion":1,"environment":"development","dataRoot":"$CRED_ROOT","execution":{"backend":"docker","provider":"zai","model":"glm-5.3-flash","adapter":"pi"}}
EOF
printf '{}' > "$SANDBOX/pi/cred-empty.json"
printf '{"anthropic":{"type":"oauth","access":"ACCESS-SHOULD-NOT-PRINT"}}' > "$SANDBOX/pi/cred-other.json"
printf '{"zai":{"type":"api_key","key":"KEY-SHOULD-NOT-PRINT"}}' > "$SANDBOX/pi/cred-zai.json"
chmod 600 "$SANDBOX/pi"/cred-*.json
# The stub writes a compose progress line, a compose warning and what pi writes when it has no key (or STUB_STDERR),
# then fails the way the container would.
cat > "$SANDBOX/cred-bin/docker" <<'STUB'
#!/usr/bin/env bash
printf 'Network x_default Creating\n' >&2
printf 'WARN[0000] The "X" variable is not set. Defaulting to a blank string.\n' >&2
printf '%s\n' "${STUB_STDERR:-No API key found for zai.}" >&2
exit 1
STUB
chmod 755 "$SANDBOX/cred-bin/docker"
cred_run() { # auth fixture, then extra env; stdout and stderr go to $SANDBOX/cred-out.txt
local auth="$1"; shift
env -u ZAI_API_KEY -u ANTHROPIC_API_KEY -u COMPOSE_FILE -u COMPOSE_ENV_FILES PATH="$SANDBOX/cred-bin:$PATH" \
MOSAIC_CONFIG="$SANDBOX/cred-config.json" PI_AUTH_FILE="$auth" "$@" \
node scripts/mosaic-task.mjs run "$SANDBOX/ok.json" >"$SANDBOX/cred-out.txt" 2>&1
}
cred_runs() { ls "$CRED_ROOT/runs" 2>/dev/null | grep -c '^r-'; }
cred_run "$SANDBOX/pi/cred-empty.json"; RC=$?
[ "$RC" -eq 3 ] \
&& grep -q "^mosaic-task: the worker container has no credential for provider zai (config execution.provider); it has credentials for: none\. Change the instance's execution.provider to one of those, or add a credential for zai" "$SANDBOX/cred-out.txt" \
&& [ "$(cred_runs)" -eq 0 ] && ! grep -qF "$SANDBOX" "$SANDBOX/cred-out.txt" \
&& check "pi run with no credential for its provider refuses (exit 3) before a run record, no host path" 0 \
|| { check "pi run with no credential for its provider refuses (exit 3) before a run record, no host path (exit $RC)" 1; cat "$SANDBOX/cred-out.txt" >&2; }
cred_run "$SANDBOX/pi/cred-other.json"; RC=$?
[ "$RC" -eq 3 ] && grep -q 'it has credentials for: anthropic\.' "$SANDBOX/cred-out.txt" \
&& ! grep -q 'ACCESS-SHOULD-NOT-PRINT' "$SANDBOX/cred-out.txt" \
&& check "credential refusal lists the providers the container has, never a value" 0 \
|| { check "credential refusal lists the providers the container has, never a value (exit $RC)" 1; cat "$SANDBOX/cred-out.txt" >&2; }
# The check refuses on the empty fixture and lets a key variable compose passes, or an auth file
# entry, through: one case, so it fails when either side is wrong.
cred_run "$SANDBOX/pi/cred-empty.json"; RC_EMPTY=$?
cred_run "$SANDBOX/pi/cred-empty.json" ZAI_API_KEY=; RC_BLANK=$?
cred_run "$SANDBOX/pi/cred-empty.json" ZAI_API_KEY=ENV-SHOULD-NOT-PRINT; RC_ENV=$?
ENV_OUT="$(cat "$SANDBOX/cred-out.txt")"
cred_run "$SANDBOX/pi/cred-zai.json"; RC=$?
CRED_RUN="$(sed -n 's/^run: \(r-.*\)$/\1/p' "$SANDBOX/cred-out.txt")"
[ "$RC_EMPTY" -eq 3 ] && [ "$RC_BLANK" -eq 3 ] && [ "$RC_ENV" -eq 1 ] && [ "$RC" -eq 1 ] && [ -n "$CRED_RUN" ] \
&& ! printf '%s\n' "$ENV_OUT" | grep -q 'no credential for provider\|ENV-SHOULD-NOT-PRINT' \
&& ! grep -q 'no credential for provider\|KEY-SHOULD-NOT-PRINT' "$SANDBOX/cred-out.txt" \
&& check "the check refuses no credential or an empty key variable, and lets a passed key variable or an auth file entry through" 0 \
|| { check "the check refuses no credential or an empty key variable, and lets a passed key variable or an auth file entry through (exits $RC_EMPTY $RC_BLANK $RC_ENV $RC)" 1; cat "$SANDBOX/cred-out.txt" >&2; }
SHOW="$(env MOSAIC_CONFIG="$SANDBOX/cred-config.json" $TASK show "$CRED_RUN" 2>&1)"
printf '%s\n' "$SHOW" | grep -qx 'cause: worker said: No API key found for zai\.' \
&& check "show prints the cause a failed run's stderr gives" 0 \
|| { check "show prints the cause a failed run's stderr gives" 1; printf '%s\n' "$SHOW" >&2; }
cred_run "$SANDBOX/pi/cred-zai.json" STUB_STDERR="Error: cannot read $SANDBOX/x.json with token=TOKEN-SHOULD-NOT-PRINT-123456"
CRED_RUN="$(sed -n 's/^run: \(r-.*\)$/\1/p' "$SANDBOX/cred-out.txt")"
SHOW="$(env MOSAIC_CONFIG="$SANDBOX/cred-config.json" $TASK show "$CRED_RUN" 2>&1)"
printf '%s\n' "$SHOW" | grep -q '^cause: worker said: Error: cannot read \[redacted\]' \
&& ! printf '%s\n' "$SHOW" | grep -qF "$SANDBOX" && ! printf '%s\n' "$SHOW" | grep -q 'TOKEN-SHOULD-NOT-PRINT' \
&& check "show's cause line redacts host paths and tokens" 0 \
|| { check "show's cause line redacts host paths and tokens" 1; printf '%s\n' "$SHOW" >&2; }
# A provider pi has no entry for can't be judged: the run is not refused, and one note says so.
sed 's/"provider":"zai"/"provider":"mosaic-unknown-provider"/' "$SANDBOX/cred-config.json" > "$SANDBOX/cred-unknown.json"
env -u ZAI_API_KEY -u ANTHROPIC_API_KEY -u COMPOSE_FILE -u COMPOSE_ENV_FILES PATH="$SANDBOX/cred-bin:$PATH" \
MOSAIC_CONFIG="$SANDBOX/cred-unknown.json" PI_AUTH_FILE="$SANDBOX/pi/cred-empty.json" \
node scripts/mosaic-task.mjs run "$SANDBOX/ok.json" >"$SANDBOX/cred-out.txt" 2>&1; RC=$?
[ "$RC" -eq 1 ] && grep -qx 'mosaic-task: worker credential not checked: pi has no provider named mosaic-unknown-provider' "$SANDBOX/cred-out.txt" \
&& grep -q '^run: r-' "$SANDBOX/cred-out.txt" \
&& check "a provider pi doesn't know is not refused, and a note says it wasn't checked" 0 \
|| { check "a provider pi doesn't know is not refused, and a note says it wasn't checked (exit $RC)" 1; cat "$SANDBOX/cred-out.txt" >&2; }
# ---------- adapter seam: deterministic mock cases (Docker, no provider) ----------
if docker info >/dev/null 2>&1; then
good_task "$SANDBOX/ok.json"
+218
View File
@@ -0,0 +1,218 @@
#!/usr/bin/env node
// lane health-reason: will the worker container hold a credential for the provider a run asks for?
//
// The run's provider is config execution.provider (mosaic-task.mjs sets MOSAIC_PROVIDER, compose
// passes it as PI_PROVIDER, the adapter as --provider). What the container receives is read from
// compose.yaml's mosaic-agent service, interpolated against the run's environment the way compose
// does: each environment name that ends up with a value, and the auth file the service mounts.
// From that file only provider names and credential types are read, as scripts/auth.sh status
// does. The adapter's harness plugin (packages/plugins/harness/<adapter>/worker-credential.mjs)
// answers whether those are enough. An adapter with no such module (mock) needs no credential.
// Nothing here prints or keeps a value.
//
// checkWorkerCredential({ adapter, provider, env, root })
// answers { state: "none-needed" | "has" | "missing" | "undecided", provider, providers, why }
//
// node scripts/worker-credential.mjs status one line for scripts/auth.sh status, read from
// MOSAIC_ADAPTER and MOSAIC_PROVIDER (load_config)
import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
import { isAbsolute, join, resolve } from "node:path";
import { pathToFileURL, fileURLToPath } from "node:url";
const ROOT = fileURLToPath(new URL("..", import.meta.url));
const SERVICE = "mosaic-agent";
const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
const ADAPTER = /^[a-z0-9][a-z0-9-]{0,31}$/;
// Compose interpolation of one string: $$, $VAR, ${VAR}, ${VAR:-d}, ${VAR-d}, ${VAR:?m}, ${VAR?m},
// ${VAR:+a}, ${VAR+a}, with defaults interpolated in turn. A required variable that is missing
// gives "" here; compose itself refuses the run then.
export function interpolate(text, env) {
let out = "";
let i = 0;
while (i < text.length) {
const c = text[i];
if (c !== "$") { out += c; i += 1; continue; }
const next = text[i + 1];
if (next === "$") { out += "$"; i += 2; continue; }
if (next === "{") {
let depth = 1;
let j = i + 2;
while (j < text.length && depth > 0) {
if (text[j] === "{") depth += 1;
else if (text[j] === "}") depth -= 1;
if (depth > 0) j += 1;
}
if (depth !== 0) throw new Error("compose.yaml has an unclosed ${");
const body = text.slice(i + 2, j);
const m = /^([A-Za-z_][A-Za-z0-9_]*)(?:(:?[-?+])([\s\S]*))?$/.exec(body);
if (!m) throw new Error("compose.yaml has an interpolation this check can't read");
const [, name, op, rest = ""] = m;
const set = Object.hasOwn(env, name) && typeof env[name] === "string";
const filled = set && env[name] !== "";
const value = set ? env[name] : "";
if (!op) out += value;
else if (op === ":-") out += filled ? value : interpolate(rest, env);
else if (op === "-") out += set ? value : interpolate(rest, env);
else if (op === ":+") out += filled ? interpolate(rest, env) : "";
else if (op === "+") out += set ? interpolate(rest, env) : "";
else out += value; // :? and ?
i = j + 1;
continue;
}
const m = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(i + 1));
if (m) { out += typeof env[m[0]] === "string" ? env[m[0]] : ""; i += 1 + m[0].length; continue; }
out += "$";
i += 1;
}
return out;
}
// Read and parse compose.yaml. Errors are fixed words: node's and yaml's own messages carry the
// file's path or quote its lines, and this text is printed.
async function readCompose(root) {
let YAML;
try { YAML = (await import("yaml")).default; } catch { throw new Error("the yaml package isn't installed in this checkout (run npm ci)"); }
let text;
try { text = readFileSync(join(root, "compose.yaml"), "utf8"); } catch { throw new Error("compose.yaml can't be read"); }
try { return YAML.parse(text); } catch { throw new Error("compose.yaml isn't valid YAML"); }
}
// A bind source as compose resolves it: a leading ~ is the home directory, and a relative path is
// relative to the project directory. Anything else is a named volume, which this check can't see.
function bindSource(source, root, env) {
if (source === "~" || source.startsWith("~/")) {
if (!env.HOME) return null;
return join(env.HOME, source.slice(1));
}
if (isAbsolute(source)) return source;
if (source === "." || source === ".." || source.startsWith("./") || source.startsWith("../")) return resolve(root, source);
return null;
}
// What compose gives the worker service: the names whose value ends up set (pi counts a value
// that is only spaces as unset), and the host source of each bind by its container target (null
// for a named volume). Refuses (throws) where compose reads more than this check does: another
// compose file, an override file, a .env file, COMPOSE_ENV_FILES or an env_file.
export async function containerInputs(root, env) {
for (const name of ["COMPOSE_FILE", "COMPOSE_ENV_FILES"]) {
if (env[name]) throw new Error(`${name} names a file this check doesn't read`);
}
for (const extra of ["compose.override.yaml", "compose.override.yml", "docker-compose.override.yaml", "docker-compose.override.yml", ".env"]) {
if (existsSync(join(root, extra))) throw new Error(`compose also reads ${extra}, which this check doesn't`);
}
const doc = await readCompose(root);
const service = doc?.services?.[SERVICE];
if (!service || typeof service !== "object") throw new Error(`compose.yaml has no ${SERVICE} service`);
if (service.env_file !== undefined) throw new Error(`the ${SERVICE} service reads an env_file, which this check doesn't`);
const filled = [];
const environment = service.environment ?? {};
const pairs = Array.isArray(environment)
? environment.map((item) => {
const s = String(item);
const at = s.indexOf("=");
return at < 0 ? [s, null] : [s.slice(0, at), s.slice(at + 1)];
})
: Object.entries(environment);
for (const [name, raw] of pairs) {
if (!NAME.test(name)) continue;
// A name with no value passes the launcher's own value through.
const value = raw === null || raw === undefined ? (env[name] ?? "") : interpolate(String(raw), env);
if (value.trim() !== "") filled.push(name);
}
const mounts = new Map();
for (const volume of service.volumes ?? []) {
if (typeof volume === "string") {
const parts = interpolate(volume, env).split(":");
if (parts.length >= 2) mounts.set(parts[1], bindSource(parts[0], root, env));
} else if (volume && typeof volume === "object" && typeof volume.target === "string" && typeof volume.source === "string") {
mounts.set(interpolate(volume.target, env), bindSource(interpolate(volume.source, env), root, env));
}
}
return { filled, mounts };
}
// Provider names and credential types from an auth file, never a value. A missing file, anything
// but a regular file, or a file that isn't a JSON object gives no entries, with why. A file this
// user may not read is unknown, not empty: Docker mounts it and the container reads it as its own
// user, so it gives no entries and `unreadable`.
const DENIED = new Set(["EACCES", "EPERM"]);
export function authEntries(file) {
if (file === null) return { entries: [], why: "the auth file is mounted from a named volume this check can't see", unreadable: true };
if (!file) return { entries: [], why: "no auth file is mounted" };
const unreadable = { entries: [], why: "this user can't read the auth file the container mounts", unreadable: true };
let stat;
try { stat = lstatSync(file); } catch (e) { return DENIED.has(e?.code) ? unreadable : { entries: [], why: "the auth file the container mounts is missing" }; }
if (stat.isSymbolicLink()) {
try { stat = lstatSync(realpathSync(file)); } catch (e) { return DENIED.has(e?.code) ? unreadable : { entries: [], why: "the auth file the container mounts is missing" }; }
}
if (!stat.isFile()) return { entries: [], why: "the auth file the container mounts isn't a regular file" };
let text;
try { text = readFileSync(file, "utf8"); } catch (e) { return DENIED.has(e?.code) ? unreadable : { entries: [], why: "the auth file the container mounts can't be read" }; }
let doc;
try { doc = JSON.parse(text.replace(/^\uFEFF/, "")); } catch { return { entries: [], why: "the auth file the container mounts can't be read as JSON" }; }
if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return { entries: [], why: "the auth file the container mounts isn't a JSON object" };
const entries = Object.keys(doc).map((name) => {
const e = doc[name];
const type = typeof e === "object" && e !== null && typeof e.type === "string" ? e.type : "unknown";
return { name, type };
});
return { entries, why: null };
}
async function harnessModule(root, adapter) {
if (!ADAPTER.test(adapter ?? "")) return null;
const file = join(root, "packages", "plugins", "harness", adapter, "worker-credential.mjs");
if (!existsSync(file)) return null;
return import(pathToFileURL(file).href);
}
export async function checkWorkerCredential({ adapter, provider, env = process.env, root = ROOT } = {}) {
const base = { provider, providers: [], why: null };
let mod;
try { mod = await harnessModule(root, adapter); } catch { return { ...base, state: "undecided", why: `the ${adapter} harness check can't be loaded` }; }
if (!mod) return { ...base, state: "none-needed" };
if (typeof mod.credentialCheck !== "function" || typeof mod.authFileInContainer !== "string") {
return { ...base, state: "undecided", why: `the ${adapter} harness check is incomplete` };
}
let inputs;
try { inputs = await containerInputs(root, env); } catch (e) { return { ...base, state: "undecided", why: e.message }; }
const mounted = inputs.mounts.has(mod.authFileInContainer) ? inputs.mounts.get(mod.authFileInContainer) : undefined;
const { entries, why: fileWhy, unreadable } = authEntries(mounted);
const answer = await mod.credentialCheck({ provider, entries, envNames: inputs.filled, root });
if (!answer?.decided) return { ...base, state: "undecided", why: answer?.why ?? "the harness check gave no answer" };
if (!answer.known) return { ...base, providers: answer.providers, state: "undecided", why: `${adapter} has no provider named ${provider}` };
if (!answer.has && unreadable) return { ...base, providers: answer.providers, state: "undecided", why: fileWhy };
return { ...base, providers: answer.providers, state: answer.has ? "has" : "missing", why: answer.has ? null : fileWhy };
}
// The refusal: names the provider, says the container has none for it, lists what it has, and
// says what to do. No path, no value.
export function missingLine(check) {
const has = check.providers.length ? check.providers.join(", ") : "none";
return `the worker container has no credential for provider ${check.provider} (config execution.provider); ` +
`it has credentials for: ${has}. Change the instance's execution.provider to one of those, ` +
`or add a credential for ${check.provider} (a PI_AUTH_FILE entry, or an environment key compose passes to it).`;
}
export function statusLine(check) {
const head = `default run: provider ${check.provider ?? "(unset)"} (config execution.provider)`;
if (check.state === "none-needed") return `${head}; the adapter needs no credential`;
if (check.state === "has") return `${head}; worker container credential: yes`;
if (check.state === "missing") {
return `${head}; worker container credential: none (it has: ${check.providers.length ? check.providers.join(", ") : "none"})`;
}
return `${head}; worker container credential: not checked (${check.why})`;
}
const self = fileURLToPath(import.meta.url);
let main = false;
try { main = realpathSync(process.argv[1] ?? "") === realpathSync(self); } catch {}
if (main) {
if (process.argv[2] !== "status") {
process.stderr.write("usage: node scripts/worker-credential.mjs status\n");
process.exit(4);
}
const check = await checkWorkerCredential({ adapter: process.env.MOSAIC_ADAPTER, provider: process.env.MOSAIC_PROVIDER });
process.stdout.write(`${statusLine(check)}\n`);
}
+6
View File
@@ -40,4 +40,10 @@ fi
export MOSAIC_SYSTEM_PROMPT_FILE
# worker-stop-reason: a headless pi worker is judged by pi's final stop reason (adapters/pi/
# final-stop.mjs). Set for pi only, so the mock and other adapters see the environment they did.
if [ "$ADAPTER" = "pi" ] && [ "${MOSAIC_INTERACTIVE:-}" != "1" ]; then
export MOSAIC_PI_FINAL_STOP=1
fi
exec "$ADAPTER_SCRIPT"