Compare commits

...
Author SHA1 Message Date
jason.woltje 4f63176676 test(triage): review round 5: a host bundle file replaced with a FIFO is refused before the host reads it (#1873, lane harness-matrix) 2026-11-19 14:43:26 -06:00
jason.woltje 1e0aba8b37 fix(triage): review round 4: the host refuses a pi command value (a string that starts with "!") in any file the module wrote, checks each host bundle file after env() whether or not the scan reaches it, and records ctime for the rest of the run directory (#1873, lane harness-matrix) 2026-11-19 14:43:26 -06:00
jason.woltje 680bb90af3 fix(triage): review round 3: the host checks every URL in a file the module wrote under bundle/, home/, work/ or tmp/, as written or as a URL parser reads it; refuses a backslash in a file JSON.parse refuses; refuses a change to its own bundle files or the rest of the run directory; and a refused start removes work/ and tmp/ too (#1873, lane harness-matrix) 2026-11-19 14:43:26 -06:00
jason.woltje 6a24cf743d test(triage): a declared harness file with a second hard link is refused (#1873, lane harness-matrix) 2026-11-19 14:43:26 -06:00
jason.woltje 06ee172a9d fix(triage): review round 2: the host reads every file under the run's bundle/, home/, work/ and tmp/ after bundle() and env(), refuses a link or a key there, and reads a JSON file decoded too, so an escaped key or URL is seen as the harness sees it (#1873, lane harness-matrix) 2026-11-19 14:43:26 -06:00
jason.woltje 66676804eb test(triage): write() refuses a bundle file that holds the key before the file exists, so the key never rests on disk until the scan (#1873, lane harness-matrix) 2026-11-19 14:43:26 -06:00
jason.woltje a3ad6578c4 fix(harness): review round: a legacy model entry (a provider or route name, no module) carries no account data, so a Claude-named model on it is treated as OAuth and held to claude-code; the Triage host refuses a key in any bundle/ file and any URL but the proxy's in a harness file; the models.json comment says what route() can and cannot see (#1873, lane harness-matrix) 2026-11-19 14:43:26 -06:00
jason.woltje 77a951cfe7 fix(harness): the harness rule keys on the account kind: a Claude model from an API key runs on claude-code and pi; an OAuth Claude model, or a group model whose name an OAuth Claude account offers, runs on claude-code only (#1873, lane harness-matrix)
Jason 2026-11-19: Claude models through an API key may run on any harness; OAuth Claude models only
on claude-code. The name check is gone. The catalogue reads every Claude OAuth account's model names,
whatever the account's state, and holds a group model with one of those names to claude-code, since
the proxy routes by name across every account. route() has no account data, so it holds upstream
claude only; admission and Triage hold the rest through the catalogue.
2026-11-19 14:43:26 -06:00
jason.woltje cd58ac23cd feat(harness): an OAuth Claude model runs on claude-code only; Triage runs on claude-code or pi through the proxy (#1873, lane harness-matrix)
cliproxy holds a model to claude-code when its upstream is claude, when an OAuth Claude account
offers the same name, or when the name contains "claude"; every other proxy model runs on
claude-code and pi. The catalogue, the launch (sessionModel and the models.json list) and the
provider route apply the one rule and refuse with model-harness-incompatible, so a stored
Claude-on-pi route is refused, never rewritten. The other route's pi provider is mosaic-proxy-other.

Triage: the route asks the provider for the transport on the stored harness and holds the
harness's env() to one contract (the key, unchanged, under exactly one of ANTHROPIC_AUTH_TOKEN or
ANTHROPIC_API_KEY; the URL only as ANTHROPIC_BASE_URL), with no list of harness names. The host
gives the module the real proxy and transport, checks each file it writes under the session's HOME
(regular, one link, no key) and binds it read-only after the run directory, and refuses a route env
with no key name or two. PATH starts with node_modules/.bin, as a bus session's does.

Tests: claude-code runs a z.ai and a codex proxy model against a stand-in (real claude binary);
pi answers Triage through a stand-in under bwrap; every new fence has a test.
2026-11-19 14:43:26 -06:00
jason.woltje fbaae25d06 fix(webui): settings slice 1: no harness names written into the page: Settings > Triage shows each harness by the id its module is installed under, from the route read, and its help line says the list holds only the programs the model runs with; the drawer's harness refusal reads the route and names its harness by that id, or keeps a plain line without a name when the route can't be read (#1873, lane settings-s1) 2026-11-19 14:38:04 -06:00
jason.woltje c9d64a341e fix(webui): settings slice 1: the failed settings read and failedView share one copy of the line every failed read ends with, so the shipped-strings pin in shell.test finds it once again (#1873, lane settings-s1) 2026-11-19 14:04:14 -06:00
jason.woltje 4cbf3f07b0 fix(webui): settings slice 1 review round 2: a model-key-collision catalogue says two models share a short name and offers no Restart, so it no longer holds Model setup's next step; the dev fixture line says it can't be changed from Console yet instead of asking for a Routing change that does not remove the fixture; Model setup owner text says model service in the init lock, repair and fence steps, and the fence clear command sits under Technical details with where to run it; the Health list and the stopped-organization page show the reason the workspace read already carries; the stopped page links to Model setup by its name; the hire start refusals point at Settings > Routing for models (#1873, lane settings-s1) 2026-11-19 14:04:14 -06:00
jason.woltje 48a2ed675c fix(webui): settings slice 1 review round: Model setup reads each organization's own routes and offers Restart only where the bus names no cause or one a restart clears, so the dev fixture gets its plain line and a Routing link and only a restartable organization holds the next step; the bus's cause codes read as plain lines with its words under Technical details, and the lock cause gets a primary Restart; a set fence reads as a restart to finish; a failed status read offers Check again; Save routes steps back while Restart is the primary; the page is named Model setup and owner text says model service; Routing explains harness and preflight; the drawer's harness refusal asks for a model that runs with Claude Code; the Triage page says daily token limit and that Triage also needs its key (#1873, lane settings-s1) 2026-11-19 14:04:14 -06:00
jason.woltje e70b6bd684 feat(webui): settings slice 1: Routing says why an organization can't see your models: the model service is not set up or not running (a link to its page), the bus names its cause (that line and Check again, plus Restart only for the lock cause), or the service runs and the bus names none (Restart); Model proxy keeps a Restart per organization whose catalogue is not ready, rereads the whole status after a sign-in, works out the steps after accounts from accounts, organizations and the Triage route, and shows only the next step's button with the rest under Technical details; Triage refusals are plain lines with a link to the page that fixes them, and the harness refusal names Claude Code; a stopped organization keeps its refused restart on screen and keeps the instance pages reachable; at phone width a Routing model select takes the whole row (#1873, lane settings-s1) 2026-11-19 14:03:27 -06:00
jason.woltje 2db4f24fd8 fix(model-proxy): re-check 3: mosaic org update that takes cliproxy off an organization records the removal in the proxy's receipts first and saves nothing if it cannot; Ride all reads the receipts again before each add, so a removal saved during a run is honoured; the bus-running and unreadable skip lines say what to do (#1873, lane ride-default) 2026-11-19 13:13:05 -06:00
jason.woltje 9bfe101176 fix(model-proxy): round 3: a Console save that takes cliproxy off an organization records the removal in the proxy's receipts first, and Ride all skips as removed any organization with any sign it was or may have been on cliproxy; a receipt line that does not parse fails closed; each add records an intent before it starts and an unknown outcome stays recorded; the fixture move and listing read stopped from the bus status and its process id; receipt and change-log reads check owner, mode and no symlink (#1873, lane ride-default) 2026-11-19 13:13:05 -06:00
jason.woltje 869d259036 fix(model-proxy): review round: an organization the proxy once put cliproxy on and that lacks it now is skipped as removed, read from the proxy's own receipts; an organization riding now is already riding whatever its history; a repeated catalogue key keeps the usable row; the page paints a Ride all answer while a load waits, names org-forbidden in plain words and gives a neutral fallback (#1873, lane ride-default) 2026-11-19 13:13:05 -06:00
jason.woltje 8200ea238c feat(model-proxy): Ride all puts the owner's existing organizations on the instance model proxy, and a cliproxy preset starts a new one on the owner's models (#1873, lane ride-default)
A cliproxy organization preset offers a model from the owner's catalogue and says in plain words
why it can't be used: no proxy, no riding bus answered, or no catalogue model is available. The
organization service passes an optional model to a preset's overlay; other presets ignore it.

Ride all, an instance-owner action on the Model proxy page, adds cliproxy to each organization
through that organization's own plugins.set. It skips and names an organization whose change log
shows cliproxy removed, whose bus is down, or whose bus has no proxy client. Proxy admin status
names it as the next step. A fixture organization is listed as using stand-in models; one more
confirmed click moves a stopped one to the owner's models through the organization service's
existing whole-document update at the revision read.

A fenced proxy then refuses each riding organization's launches with proxy-uncertain, a direct
anthropic route included.
2026-11-19 13:13:05 -06:00
jason.woltje 196505e6ef fix(bus): review round: the restart notice shows only on a ready catalogue, since a fenced, colliding or down proxy still refuses after a restart (#1873, lane pickup-launch)
A bus booted with the proxy on a fenced instance reads the same unavailable catalogue, so the
notice sent the owner to a restart that stops running agents and starts none. The test proves
that and shows the notice again once the fence is gone. The disabled check goes away with it;
the disabled test now says the routes verb answers disabled itself.
2026-11-19 12:08:41 -06:00
jason.woltje f7c0e4f46c fix(bus): a bus that picked up the shared proxy says on its catalogue that a restart is needed to start agents on these models (#1873, lane pickup-launch)
A picked-up client serves accounts and the catalogue, but a launch on it is refused at bus
admission (model-provider-unavailable): the host launcher keeps its boot system with no proxy,
and the bus has no ModelKeys. While the bus holds a late client and the catalogue is not
disabled, the catalogue appends one notice after its own: "Restart this organization to start
agents on these models." A boot proxy, a disabled catalogue, refused settings and a dropped
client carry no such notice. Tests cover the launch refusal, refused settings, a dropped
client and a key scan over the launch path.
2026-11-19 12:08:41 -06:00
jason.woltje 5c975faddd fix(model-proxy): review round: the preflight comment says every v8 proxy applies a key PUT by an async reload; a re-probe waits about the time left, not the client default; the README says the proxy unit reads PIN from the tree it was installed from and names .codex-refresh; two test headers stop naming only 8.0.42 (#1873, lane proxy-pin) 2026-11-19 11:08:23 -06:00
jason.woltje 462215b4bd chore(model-proxy): pin CLIProxyAPI 8.0.79; proxy.json from an earlier PIN stays valid; preflight re-probes a just-issued key's 401 briefly (#1873, lane proxy-pin)
The PIN moves from 8.0.42 to 8.0.79 with the upstream archive checksum and the
extracted binary checksum. The panel stays 1.26.7.

proxy.json keeps the binary path of the PIN it was created under. A path of the
form <dataRoot>/opt/cliproxyapi/<version>/cli-proxy-api now validates and reads
as the current pinned path, so an instance created on 8.0.42 needs no edit. The
runner still runs only the verified pinned install.

8.0.79 applies a key-list PUT by an async reload a few milliseconds after it
answers, so a just-issued key answers 401 at first. Preflight now probes again
on 401 only, for at most ISSUE_PROBE_TIMEOUT_MS (2 s). Any other non-2xx still
refuses on the first answer.
2026-11-19 11:08:23 -06:00
jason.woltje d0293d6602 fix(bus): review round: proxy init creates the lock before it installs the client, so a lock that refuses leaves no client; a default-instance bus test proves the catalogue refreshes at once on pickup and on drop (#1873, lane proxy-pickup) 2026-11-19 09:51:39 -06:00
jason.woltje 912138ff61 feat(bus): a running organization bus picks up the shared proxy without a restart (#1873, lane proxy-pickup)
A bus started before the instance had a proxy checks once at the next accounts, page, catalogue
or fence request, and loads the client through the start path's checks, loader and lock. A client
got that way, or by the bus's own init, is checked again at each such request and dropped when
proxy.json goes away, no longer loads, moves port, the key stops loading, the lock refuses, or a
dev fixture the host would refuse is in use. While there is no client, the bus names the cause in
one plain line on not-configured and on the unavailable catalogue, and the Console shows it.
2026-11-19 09:39:41 -06:00
jason.woltje 4a8d310cd5 docs(webui): the Triage settings comment says the host reads the stored route at its next admit, now that the host has a route (#1873, lane triage-wiring) 2026-11-18 16:01:19 -06:00
jason.woltje c28ca57af6 fix(triage): review round: the host writes claude-code's bundle and sets its MOSAIC_ names, so a real harness answers; pi is refused as incompatible; proxy.json is read at each admit; a persistent marker makes the start after an unknown end fresh across a restart; the session key and key-shaped strings are removed from Triage lines (#1873, lane triage-wiring) 2026-11-18 16:01:12 -06:00
jason.woltje 255c1575bb feat(triage): the Console resolves Triage's model route at each admit
The Triage host got route: null. It now gets a route read fresh at each
admit from the route store, the key file, each active organization's
model catalogue (held to checkRoutes) and the harness module. The spawn
env adds only ANTHROPIC_BASE_URL (the instance proxy) and
ANTHROPIC_AUTH_TOKEN (the Triage key); the host sets every MOSAIC_ name.

The key file reader moves to packages/cli/src/triage-key-file.mjs so the
Console reads the key with the key verbs' checks without loading the
proxy management client; triage-key.mjs re-exports it. Each refusal (no
route, no key, unsafe key, proxy down, model not offered, no catalogue,
harness incompatible) launches nothing and answers 409 with one plain
line. Every admit runs the host's fences on the answer, a session
running or not.

The cap fails closed: two turns in a row with unknown usage end the
session with a host line; the next message starts a new run with a
fresh session directory, and its usage counts again.

#1873, lane triage-wiring
2026-11-18 16:01:12 -06:00
jason.woltje 0ba50111f6 test(webui): the Triage drawer's no-Triage-request checks skip the static triage-settings.js script every page loads; it carries no data, and the Settings panel's own test shows a non-owner reads no route (#1873, lane triage-settings) 2026-11-18 15:06:03 -06:00
jason.woltje dab07f0ff5 fix(webui): Triage route review round: a save sends the revision its fields were read at, so a route saved elsewhere answers as stale instead of being written over, and an untouched page follows the store; a read follows the repo GET convention, so a LAN dev host with no Fetch Metadata reads the route while a write still needs one matching Origin and same-origin; a zone in another case is stored in its canonical spelling; focus lands on the saved line; the organization catalogues are read in parallel (#1873, lane triage-settings) 2026-11-18 14:40:22 -06:00
jason.woltje 561ff77e48 feat(webui): Settings > Triage reads and saves the Triage route (#1873, lane triage-settings)
GET and POST /api/triage/route, owner only behind the proxy-admin gate, with one
Origin and Sec-Fetch-Site same-origin on a write and Fetch Metadata on a read.
GET returns the stored route or says it is not set, plus the merged catalogue
choices (model keys, availability, compatible installed harnesses) with no
provider, upstream, module, key or path. POST takes model, harness, cap, time
zone and revision, checks the route with checkRoutes against the merged
catalogue (offered, available, compatible, installed), requires a known time
zone with no default, and writes through the store's writeRoute, so the lock,
the revision compare and the receipt are the store's. A stale revision answers
409 with the stored revision. updatedBy is the signed-in owner.

The Settings > Triage page shows only to the owner /api/config marks proxyAdmin.
Model and harness selects (the harness list is the chosen model's), a cap in
tokens, reset 00:00 read only, a time zone, Save. Not set before a first save;
a refusal is one line and keeps the fields; a stale save offers Reload route; a
second Save while one runs does nothing; one line says saving does not start
Triage. cli.mjs keeps route: null for the Triage host.
2026-11-18 14:40:21 -06:00
jason.woltje e1642be760 test(webui): drawer Stop review round: two Stops run at once in two drawers; coder's Stop the bus takes ends and repaints the page while ideas' still runs, and ideas keeps its running state; then ideas' is refused and each drawer keeps its own line (#1873, lane sp20-drawer-stop) 2026-11-18 14:33:52 -06:00
jason.woltje b23ccdfc12 fix(webui): Stop in the agent drawer: an archived or unavailable organization says so in Restart's plain line ending Nothing changed, not Outcome unknown, with one test each; each Stop keeps its own state per agent, as each restart does, so a second Stop or question in another drawer no longer drops a running Stop's line or its running state, with a two-drawer test (#1873, lane sp20-drawer-stop) 2026-11-18 14:33:52 -06:00
jason.woltje 57af33630d test(triage): a repeated usage.begin keeps the first baseline (review round, #1873, lane triage-cap) 2026-11-18 14:03:50 -06:00
jason.woltje 17b972b92d feat(triage): the host holds the daily token cap
Each turn's usage goes to <dataRoot>/triage/usage.jsonl, one line per
usage.end, 0600 and owned by the running user; a link, wrong mode or
owner, or a non-file refuses. The host holds the stored cap through
daily-quota mayLaunch and report before each start and each queued
message, lets a crossing turn finish, drains the queue with a host
line, sums the file again after a restart (a torn line counts as an
unknown turn), and GET /api/triage adds usageToday, cap and resetsAt.
With no route stored the fields say "not set". cli.mjs keeps route
null. (#1873, lane triage-cap)
2026-11-18 14:03:50 -06:00
jason.woltje d531d7181d fix(triage): review round for the triage key verbs
- The grace is the earliest retire time, not a timer: rotate, status and the
  README say the old key stays live until retire runs after it.
- A temp file left by a kill before the rename is removed under the lock by
  the next issue, rotate or retire; status counts it.
- The receipts file is checked under the lock before any change
  (triage-key-receipts-unsafe); a receipt that fails after the change is
  triage-key-unrecorded.
- A failed directory sync after the rename is triage-key-unsynced, after the
  receipt is written, not triage-key-unwritten.
- proxy-lock-busy points at mosaic proxy fence status.
- Tests: a sentinel lost on the read-back, FIFO key and receipts files, a stale
  lock reaped, a crash before the rename, the receipts checks, the sync
  failure; the no-op assertion is gone. (#1873)
2026-11-18 13:54:13 -06:00
jason.woltje 67e1ff193d feat(triage): mosaic triage key issue|rotate|retire|status, Triage's own model proxy key
issue adds one mst-<tag>-triage- key under the instance proxy lock (read,
sentinel, re-read, fence, PUT, read back, confirm) and writes it to
<configDir>/secrets/triage/model (directory 0700, file 0600, the running
user's; a link, a non-file, a second link, a wrong mode or owner refuses).
rotate adds a new key and keeps the old one until now plus the bus's
rotateGraceMinutes from proxy.json; retire removes retiring keys once due.
status reads the file and the list, takes no lock and writes nothing.
Outputs, errors and receipts carry key ids only. A crash at each step
leaves a state status names and the next verb clears. Org and no-org bus
reconciles leave the key alone. Nothing wires the key into the host (#1873)
2026-11-18 13:54:13 -06:00
jason.woltje 9a3004cba4 test(webui): the agents.js export pin names the restart chain SP19 adds for the agent drawer (#1873, lane sp19-drawer-restart) 2026-11-18 13:15:20 -06:00
jason.woltje 4b833d23e9 fix(webui): drawer restart review round: each restart keeps its own state per agent, so another drawer's Stop or question no longer drops its line or its running state, with a two-drawer test; once the agent was ended (a refused launch, a thread ended, a restart done) the drawer repaints from a fresh instances read and focus goes to its heading, so an agent with no run no longer offers Stop and Restart; a refusal before the end keeps focus on Restart; an archived or unavailable organization says so instead of outcome unknown, with a test (#1873, lane sp19-drawer-restart) 2026-11-18 12:51:38 -06:00
jason.woltje 05be6c62bd feat(webui): Restart in the agent drawer: beside Stop and only where Stop is offered, in Stop's confirm step and status line, it ends the agent through its own organization's /agent/terminate with the reason restart from the agent drawer, waits for the request to close and its runs to reach 0, then launches it through /agent/launch; a conversation agent is ended and not launched; it never regenerates; not owner, bus stopped, end refused, launch refused and runs never reaching 0 each say so in one line and leave the buttons usable; a second click while it runs does nothing. The agents.js restart chain takes org, reason, a text callback and a status callback; the Routing receipt's Restart now keeps its reason and words, pinned by two new tests (#1873, lane sp19-drawer-restart) 2026-11-18 12:35:34 -06:00
jason.woltje c9fad00d25 fix(triage): review round for the route store
The file owner check has its own test through a file-owner seam, for
route.json on read and write and for route-receipts.jsonl on write. The
directory, temp file and a new receipts file get their modes on the open
descriptor, so a narrow umask cannot leave a route the next read refuses;
an existing receipts file is never repaired. A failed temp write refuses
and removes the temp file. A failure after the rename refuses as
triage-route-unrecorded and names the new revision. The input zone check
uses the stored cap's rule, so +05:00 refuses as an unknown zone. A
changed cap keeps its since, as an organization's token limits do, so
lowering the cap never drops tokens already counted (#1873, lane
triage-route-store).
2026-11-18 12:05:07 -06:00
jason.woltje 4c8527fcd3 feat(triage): the owner-only route store and mosaic triage route show|set
<dataRoot>/triage/route.json holds Triage's model route and daily cap as names only:
a catalogue model key, a harness name and a daily-quota cap leaf, with no env value
and no key. The directory is 0700 and the file 0600, owned by the running user; a
link, a hard link, a non-file, a wrong mode or owner, an unknown field or an unknown
time zone refuses. A write is compare-and-set on revision under an exclusive lock,
atomic (temp file, fsync, rename, directory fsync), and appends one receipt line.
The reset is 00:00 in a zone the owner gives, with no default. The file location,
field names and reset rule each live in one place.

mosaic triage route show|set are human verbs and refuse an agent run before any read.
Nothing is wired into the Triage host: the Console keeps route: null. Held for
Jason's ruling on the design's four questions (#1873, lane triage-route-store).
2026-11-18 12:05:07 -06:00
jason.woltje 2d44750b96 fix(webui): drawer polish review round 3 notes: with the runs not read and no claim, Last activity names the agents and claims reads, with a test for chief; the Project scroll test waits for the Projects page heading; a test comment matches the one of its runs wording (#1873, lane sp18-drawer-polish) 2026-11-18 11:26:45 -06:00
jason.woltje 9343baffff fix(webui): drawer polish review round 2: the kept scroll place is dropped as soon as the address leaves the page under the sheet, so a project or Assistant page that bus.js draws without afterPaint no longer leaves it for a later page; the scroll tests make every page long first and wait for the linked page's own content; Last activity says one of its N runs, and a run when the runs were not read (#1873, lane sp18-drawer-polish) 2026-11-18 11:18:18 -06:00
jason.woltje 38ea639d70 fix(webui): drawer polish review round: at 390 the page under the sheet goes back to its place only when the drawer closes onto that same page, so a link in the sheet opens its page at the top and a later page does not jump; Last activity counts a role or conversation claim only when the instances read lists its run as running, says when a running run holds nothing yet, and names the latest of several runs (#1873, lane sp18-drawer-polish) 2026-11-18 11:18:18 -06:00
jason.woltje fc558df31a fix(webui): drawer and page polish: at 390 the open agent sheet is the whole screen and the page under it no longer scrolls behind it, and Close puts the page back where it was; the drawer's Last activity is when the agent's current run took its role or conversation, from the claim time the workspace read already carries; the Dashboard's two columns line up with its tile row; the organization page's left column holds Autonomy and Starter packs; the workflows section() stub and its duplicate stopped panel are gone (#1873, lane sp18-drawer-polish) 2026-11-18 11:18:18 -06:00
jason.woltje 56cc7b59dd fix(seat,unslop-hook): review round: the linked fixed path test puts the stand-in's real path outside HOME so only its own guard refuses the source; the Stop hook's notes name the late-fallback turn a later Stop can check again and say a second Stop after a blocking hook waits and logs one late entry; the plugins README names the Perl, Ruby, less and resolver hooks and points to REFUSED_NAMES (#1873, lane triage-p3s) 2026-11-18 11:05:35 -06:00
jason.woltje c641dbfbc9 fix(webui): the triage snapshot reads every organization's bus and processing sockets at once and limits only the config checks, which start node children; the deadline tests count reads and use the injected clock instead of tight wall-clock margins (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje eb1146ebad fix(webui): a triage reply settles its entry only when it is the runner's RESULT answer; a progress note that names the message leaves it queued, so a session that dies after the note still reports it unanswered (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje 4b5d027361 fix(seat): hosted route fences P3s: realOr runs once per fixed path, a test hook adds a stand-in fixed path so a linked one is tested, the refuse list adds LUA_INIT, CURL_HOME and SSLKEYLOGFILE, and the plugins README names every refused suffix and hook (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje 80ce06851d fix(unslop-hook): the Stop hook records the last prompt it checked per session in <log>.stop.json and waits while the transcript still ends with that turn, so a Stop with no last_assistant_message, or one whose reply has the last turn's text, no longer checks the last turn as this one; the 2 s wait stays (#1873, lane triage-p3s) 2026-11-18 10:52:53 -06:00
jason.woltje b39d5e2ff3 fix(unslop-hook): review round, the Stop fallback logs late: true and the comment names the two stale cases left: an input with no last_assistant_message, and a reply whose text equals the last turn's last reply; cli.mjs notes that the packs-http read is the tested gate for system-only templates (#1873, lane triage-followups) 2026-11-16 16:05:43 -06:00
jason.woltje c85c768a4a fix(webui): the first render's heading focus leaves an open drawer or dialog alone: a reader who opened the Triage drawer, an agent drawer, the narrow-screen menu or a dialog before the first render ended keeps focus there; on load a second render can draw the agents rows while the first still reads, so the agent drawer had the same fault (#1873, lane triage-followups) 2026-11-16 15:54:12 -06:00
jason.woltje b7649ecd73 fix(webui): the workflows read leaves out system-only templates
The workflows read listed the triage template, which only the client hid.
The read handler now drops every template the organization vocabulary marks
system-only, and the Console's read supplier in cli.mjs drops them too. The
client filter stays. (#1873, lane triage-followups)
2026-11-16 15:46:57 -06:00
jason.woltje 0354452971 fix(unslop-hook): the Claude Stop hook waits for the turn to reach the transcript
Claude Code 2.1.319, 2.1.322 and 2.1.325 can run the Stop hook before they
write the turn to the transcript. The hook then read the last turn's reply,
logged it a second time, and missed this turn's reply. That made
claude-session.test.mjs row 66 red in most runs.

The hook now reads the transcript again, for up to 2 s, until its last reply
matches last_assistant_message. If it never does, it checks
last_assistant_message alone with an empty entryId, never the last turn
again. (#1873, lane triage-followups)
2026-11-16 15:45:09 -06:00
jason.woltje bbbefb3f28 fix(webui): triage fences re-check, only HOME may hold the stack's code: the code root names its holder, which must be a protected path, and no other protected path sets a source aside; a code root in or around the run dir or a fixed path is refused in either path's real spelling too; the mount, install root and protected lists are copied once so a changing list cannot pass one check and feed another; the refuse list adds PERLLIB, LESSOPEN, LESSCLOSE, HOSTALIASES and names ending _ASKPASS, _CA_BUNDLE or _BASE_URL (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje 2f91ff5bea fix(webui): triage fences review, HOME is not counted against the stack's own code: a caller's protected path that holds the code root sets aside a source whose named and real paths both lie in it, never the run dir or a fixed path, so pi starts from a copy or worktree under HOME; a refusal at the binds answers triage-route-invalid and removes what the start wrote; each mount field is read once and no dest lies in or around another; values refuse every C0 and C1 control and U+2028/U+2029; the token shape drops the m flag; the refuse list adds MALLOC_, NPM_CONFIG_, XDG_, names ending _DIR, _CONF or _CONFIG, and the libc, shell, OpenSSL and Java hooks (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
jason.woltje 1ca3a38f86 feat(webui): triage fences, the host checks a copy of the route's answer before anything is written or spawned: harnessEnv names must be declared by the harness module and are refused outright when MOSAIC_, NODE_, LD_, DYLD_, PYTHON, BASH_, GIT_, PATH, HOME, TMPDIR, ENV, a founder or a provider name; values are short clean strings; route env holds only the proxy's two names with a loopback base URL, and the host's port and token shape when given; the adapter and at most 8 mounts resolve inside the module's install roots and never in or around the data root, the config dir, HOME, /srv/mosaic or a secrets path, with dests clear of /tmp, the run dir and the system binds, checked again in hostedBinds; a refused answer answers triage-route-invalid and leaves a host line (#1873, lane triage-fences) 2026-11-16 15:34:31 -06:00
104 changed files with 12047 additions and 470 deletions

No files matched your search

+6 -1
View File
@@ -280,6 +280,11 @@ const canonical = (x) =>
typeof x === 'string' && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(x) &&
Number.isFinite(Date.parse(x)) &&
new Date(x).toISOString() === x;
// proxy-pickup (#1873): the one plain line a bus without a proxy client gives for not-configured.
// The runtime writes it from static text and a refusal code; only that line passes, and never
// into refusal evidence.
const proxyCause = error => error instanceof BusError && error.code === 'not-configured' && typeof error.reason === 'string' && error.reason.length <= 300 ? error.reason : undefined;
export class BusError extends Error {
// Guidance is static policy text; never quote arguments or file bytes here.
constructor(code, reason) {
@@ -6089,7 +6094,7 @@ export class Broker {
const args = request.args ?? {};
if (!object(args)) fail('invalid-request');
return Promise.resolve().then(() => this.#proxyPage(request.verb, args, { business: s.business, human: s.human }))
.catch(error => { throw this.#refused(s, new BusError(PROXY_PAGE_CODES.includes(error.code) ? error.code : 'proxy-down'), { verb: request.verb }); });
.catch(error => { throw this.#refused(s, new BusError(PROXY_PAGE_CODES.includes(error.code) ? error.code : 'proxy-down', proxyCause(error)), { verb: request.verb }); });
}
// #1873: the fence clear takes restart evidence, which the runtime re-proves on the host
// before the lock clears. Owner only, before every other gate, like the proxy page verbs.
+17 -3
View File
@@ -6,6 +6,8 @@ import { isDeepStrictEqual } from 'node:util';
import { BusError } from './broker.mjs';
export const REVOKE_TIMEOUT_MS = 5000;
export const REVOKE_POLL_MS = 25;
export const ISSUE_PROBE_TIMEOUT_MS = 2000;
export const ISSUE_REPROBE_MIN_MS = 250;
export const MODEL_STOP_TIMEOUT_MS = 5000;
const keyId = key => createHash('sha256').update(key).digest('hex').slice(0, 12);
const fail = code => { throw new BusError(code); };
@@ -223,9 +225,21 @@ export class ModelKeys {
this.#sentinel(keys);
return this.#issue(instance, false, keys);
});
let status;
try { status = await this.#client.probeKey(proxy.key); }
catch { fail('proxy-down'); }
// Every v8 CLIProxyAPI applies a key-list PUT by an async reload after it answers, so a
// just-issued key can answer 401 for a moment. On 8.0.79 that moment outlasts the confirming
// GET (measured, #1873). Only 401 is probed again, until a short deadline; a re-probe waits
// about the time left, at least ISSUE_REPROBE_MIN_MS. Any other non-2xx refuses on the first
// answer, as before.
const deadline = performance.now() + ISSUE_PROBE_TIMEOUT_MS;
let status, first = true;
for (;;) {
const options = first ? undefined : { timeout: Math.max(ISSUE_REPROBE_MIN_MS, Math.ceil(deadline - performance.now())) };
first = false;
try { status = await this.#client.probeKey(proxy.key, options); }
catch { fail('proxy-down'); }
if (status !== 401 || performance.now() >= deadline) break;
await new Promise(resolve => setTimeout(resolve, REVOKE_POLL_MS));
}
if (status < 200 || status >= 300) fail('proxy-key-refused');
return proxy;
}
+81 -9
View File
@@ -32,7 +32,7 @@ import { loadManagementClient } from '../../model-proxy/src/client.mjs';
import { ProxyPage } from './proxy-page.mjs';
import { createModelCatalogue } from './model-catalogue.mjs';
import { sha256 } from '../../model-proxy/src/common.mjs';
import { initializeProxy } from '../../model-proxy/src/settings.mjs';
import { initializeProxy, loadProxy } from '../../model-proxy/src/settings.mjs';
import { createProxyLock } from './proxy-lock.mjs';
import { verifyRestart } from '../../model-proxy/src/admin.mjs';
import { ModelKeys, modelOrganization, stopModelRuns, MODEL_STOP_TIMEOUT_MS } from './model-keys.mjs';
@@ -631,6 +631,7 @@ export async function startBroker({
builtinBinding = null,
modelCatalogue = null, // in-process fixture seam; boot JSON cannot supply a service
makeProviderLoader = createLoader, // in-process fixture seam; boot JSON cannot supply a function
initProxy = initializeProxy, // in-process fixture seam (a test install pin); boot JSON cannot supply a function
// #1873 A3: the boot's root and project agent copies (cli config.mjs copiesAtBoot), plain data. Every
// reload of the organization file below re-applies this snapshot, never the root file.
copies = null,
@@ -638,6 +639,7 @@ export async function startBroker({
// In-process only, like librarySync; production passes none.
copyTransport = null,
}) {
if (typeof initProxy !== 'function') throw new BusError('invalid-host-request');
if (copies !== null && (typeof copies !== 'object' || Array.isArray(copies) || typeof copies.org !== 'string'
|| !Object.hasOwn(businesses ?? {}, copies.org) || copies.copies === null || typeof copies.copies !== 'object' || Array.isArray(copies.copies)))
throw new BusError('invalid-host-request');
@@ -835,7 +837,72 @@ export async function startBroker({
// records. A daily key quota moved within one agent's lineage keeps its since and its count.
const keyLineage=(business,keyId)=>modelKeyLineage(credentials.status(),business,keyId);
const settings=organization?launchSettings({...organization,sessions:()=>readSessions(dataRoot),levels,keyLineage}):null;
modelCatalogues = modelCatalogue ?? (settings ? createModelCatalogue({ pluginDataRoot:instanceRoot ?? dataRoot, client: () => modelProxyClient, settings: id => settings.current(id).plugins ?? {}, proxyLock }) : null);
// #1873 proxy-pickup: a bus started before the instance had a shared proxy picks it up at the
// first request that needs one, through the start path's checks, loader and lock. A client got
// that way (or by this bus's own proxy.init) is checked again at every such request and dropped
// when the start path would now refuse it. A bus started with a proxy keeps its boot client:
// its ModelKeys holds that client. `proxyCause` is the one plain line the owner sees while there
// is no client: static text and a refusal code, never a path or a key.
let lateProxy = false, proxyCause = null, proxySync = Promise.resolve();
const dropLateProxy = cause => {
if (lateProxy) { modelProxyClient = null; proxyPage = null; proxyPort = null; proxyLock = null; lateProxy = false; modelCatalogues?.invalidate?.(); }
proxyCause = cause;
};
// The host refuses fixture-proxy-configured at boot when a dev fixture is recorded for the
// instance and the organization routes a launch to the fixture (cli dev-fixture.mjs
// fixtureLauncherOptions). Anything but a plain absence of the record counts as recorded.
const fixtureRecorded = () => { try { lstatSync(join(instanceRoot ?? dataRoot, 'dev-fixture', 'fixture.json')); return true; } catch (error) { return error.code !== 'ENOENT'; } };
const usesFixture = id => {
try {
const doc = settings.current(id), providers = doc.plugins?.['model-provider'];
return (Array.isArray(providers) && providers.includes('fixture')) || Object.values(doc.launch?.models ?? {}).some(m => m?.module === 'fixture');
} catch { return true; }
};
async function pickProxy() {
if (proxy || !organization || !settings) return;
if (org !== null && (!org || typeof org.id !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(org.id) || typeof instanceDataRoot !== 'string' || typeof instanceConfigDir !== 'string'))
return dropLateProxy('This bus has no valid organization binding for the shared proxy (invalid-host-request). Restart it from the host.');
const configDir = org ? instanceConfigDir : organization.dir;
let found;
try { found = loadProxy(configDir, instanceRoot ?? dataRoot); }
catch (error) { return dropLateProxy(`The model proxy settings do not load (${/^proxy-[a-z-]+$/.test(error?.code ?? '') ? error.code : 'proxy-config-invalid'}). This organization reads no accounts or catalogue until they do.`); }
if (found === undefined) return dropLateProxy('The model proxy has not been set up for this instance yet. Set it up on the Model proxy page.');
if (modelProxyClient && found.port !== proxyPort) dropLateProxy(null);
if (fixtureRecorded() && Object.keys(businesses).some(usesFixture))
return dropLateProxy('This organization routes launches to the dev fixture, which the host refuses next to a model proxy (fixture-proxy-configured). Remove the fixture or stop using it here.');
let client;
try { client = await loadManagementClient({ configDir, proxy: found, receipt: proxyReceipt }); }
catch { return dropLateProxy('The model proxy management key does not load (proxy-management-key-invalid). This bus cannot reach the proxy until the key file is fixed.'); }
let lock = null;
if (org) {
try { lock = createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${found.port}` }); }
catch { return dropLateProxy('The shared proxy lock does not load (proxy-lock-invalid). Check the proxy state for this instance, then restart this bus.'); }
}
proxyCause = null;
// Same port, key and lock still load: keep the client and its page, which holds login states.
if (modelProxyClient) return;
modelProxyClient = client; proxyPort = found.port; proxyLock = lock; lateProxy = true;
configureProxyPage(); modelCatalogues?.invalidate?.();
}
// One check at a time; an unexpected failure drops a late client, never keeps it.
const syncProxy = () => (proxySync = proxySync.then(pickProxy).catch(() => dropLateProxy('The model proxy could not be checked (proxy-down). Try again shortly.')));
// Unavailable with no client: the catalogue names the cause instead of a bare unavailable.
// pickup-launch: a late client serves accounts and the catalogue, but a launch on it needs what
// only the start path builds (ModelKeys here, the proxy in the host launcher's boot system), so
// while this bus holds one a ready catalogue says plainly that a restart is needed. Not on an
// unavailable one: a fence, a collision or a down proxy still refuses after a restart.
const RESTART_TO_LAUNCH = 'Restart this organization to start agents on these models.';
const explainCatalogue = value => {
if (value?.status === 'unavailable' && value.reason === undefined && !modelProxyClient && proxyCause)
return { ...value, reason: 'proxy-not-configured', notices: [proxyCause] };
if (lateProxy && value?.status === 'ready')
return { ...value, notices: [...(value?.notices ?? []), RESTART_TO_LAUNCH] };
return value;
};
const baseCatalogue = settings ? createModelCatalogue({ pluginDataRoot:instanceRoot ?? dataRoot, client: () => modelProxyClient, settings: id => settings.current(id).plugins ?? {},
// A view, so a lock taken by a later pickup or init counts as it does for the start path's.
proxyLock: { assertCertain: () => proxyLock?.assertCertain(), generation: () => proxyLock?.generation() } }) : null;
modelCatalogues = modelCatalogue ?? (baseCatalogue ? { ...baseCatalogue, read: async (id, options) => { await syncProxy(); return explainCatalogue(await baseCatalogue.read(id, options)); } } : null);
// Resolve legacy table entries with the enabled modules' declarations. A
// missing or ambiguous mapping never becomes an available route.
async function catalogueFor(id, options = {}) {
@@ -1340,22 +1407,27 @@ export async function startBroker({
// Row 199 (#1697, design section 6): issue, rotate, revoke and delete, live with no restart; each
// rewrites or records through the organization writer, so changes.jsonl holds the receipt.
proxyPage: async (verb, args, scope) => {
if (!proxyPage) throw new BusError('not-configured');
await syncProxy();
if (!proxyPage) throw new BusError('not-configured', proxyCause ?? undefined);
return proxyPage.request(verb, args, scope);
},
proxyInit: organization ? async args => {
const settings = await initializeProxy({ configDir: organization.dir, dataRoot: instanceRoot ?? dataRoot, ...args });
modelProxyClient = await loadManagementClient({ configDir: organization.dir, proxy: settings, receipt: proxyReceipt });
proxyPort = settings.port;
const settings = await initProxy({ configDir: organization.dir, dataRoot: instanceRoot ?? dataRoot, ...args });
const client = await loadManagementClient({ configDir: organization.dir, proxy: settings, receipt: proxyReceipt });
// #1873: an org bus that initializes the shared proxy also holds its write lock from now on.
if (org && !proxyLock) proxyLock = createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${settings.port}` });
configureProxyPage();
// proxy-pickup: the lock comes first, so a lock that refuses leaves no client behind.
const lock = org && !proxyLock ? createProxyLock({ stateDir: join(instanceDataRoot, 'proxy'), identity: `${instanceConfigDir}:${settings.port}` }) : proxyLock;
// proxy-pickup: a client this bus did not boot with is checked again like a picked-up one.
if (!proxy) { lateProxy = true; proxyCause = null; }
modelProxyClient = client; proxyPort = settings.port; proxyLock = lock;
configureProxyPage(); modelCatalogues?.invalidate?.();
return settings;
} : null,
// #1873: clear the uncertain-write fence only on restart evidence this host re-proves: the
// process on the proxy port is new, alive and started after the fence was set.
proxyFenceClear: organization ? async ({ evidence }) => {
if (!proxyLock || !modelProxyClient) throw new BusError('not-configured');
await syncProxy();
if (!proxyLock || !modelProxyClient) throw new BusError('not-configured', proxyCause ?? undefined);
return proxyLock.clear({ restarted: true, read: () => modelProxyClient.getKeys(), verify: previous => verifyRestart(evidence, { fence: previous, port: proxyPort }) });
} : null,
credentialVerbs: organization
@@ -0,0 +1,50 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { startBroker } from '../src/runtime.mjs';
import { checkedTransport } from '../../harness/src/bundle.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
// #1873 harness-matrix: an OAuth Claude model runs on claude-code only. A stored route that puts an
// OAuth Claude model on pi is refused at launch admission with model-harness-incompatible, even when a stale
// catalogue row still says pi. A z.ai and a codex model are admitted on pi.
const roles = { chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery'], crossRole: [] } }, coder: { authority: { withinRole: [], crossRole: [] } } };
async function admission(t, entry, catalogueRow) {
const root = mkdtempSync(join(tmpdir(), 'harness-matrix-')); t.after(() => rmSync(root, { recursive: true, force: true }));
const rolesDir = rolesCopy(root), doc = businessDoc(root, 'demo');
doc.plugins = { ...doc.plugins, harness: ['pi'], 'model-provider': ['cliproxy'] };
doc.launch.models['fixture-key'] = entry;
doc.roles.coder.vars = { ...doc.roles.coder.vars, harness: 'pi', model: 'fixture-key', thinking: 'low' };
writeJson(join(root, 'businesses/demo.json'), doc); mkdirSync(join(root, 'data'), { mode: 0o700 });
const modelCatalogue = { invalidate() {}, read: async () => ({ status: 'ready', notices: [], models: [{ module: 'cliproxy', available: true, ...catalogueRow }] }) };
const bus = await startBroker({ dataRoot: join(root, 'data'), businesses: { demo: { id: 'demo', human: 'jason', arbiters: { technical: 'chief', delivery: 'chief' }, roles } }, organization: { dir: root, rolesDir, system: systemFor(root) }, modelCatalogue });
t.after(() => bus.close());
const human = bus.broker.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
const revision = bus.broker.request(human, { verb: 'limits' }).revision;
// The launcher's own transport check refuses first; admission is the second gate, so the request
// carries the transport the provider would give with no harness named.
const transport = checkedTransport(entry);
return bus.modelAdmission({ business: 'demo', instance: 'coder', modelKey: 'fixture-key', harness: 'pi', revision, entry, provider: entry.provider, model: entry.model, account: null, route: 'primary', transport });
}
test('#1873 a stored Claude route on pi is refused model-harness-incompatible at admission, even with a stale catalogue row that says pi', async t => {
const entry = { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' };
assert.deepEqual(await admission(t, entry, { upstream: 'claude', model: 'claude-opus-5-5', harnesses: ['claude-code', 'pi'] }), { allow: false, code: 'model-harness-incompatible' });
});
test('#1873 a Claude model from an API-key group (upstream other) is admitted on pi; one whose name an OAuth account offers is refused', async t => {
const entry = { provider: 'other', model: 'anthropic/claude-sonnet-5-5', module: 'cliproxy', upstream: 'other' };
assert.deepEqual(await admission(t, entry, { upstream: 'other', model: 'anthropic/claude-sonnet-5-5', harnesses: ['claude-code', 'pi'] }), { allow: true });
// The catalogue holds a group model to claude-code when an OAuth Claude account offers its name.
assert.deepEqual(await admission(t, entry, { upstream: 'other', model: 'anthropic/claude-sonnet-5-5', harnesses: ['claude-code'] }), { allow: false, code: 'model-harness-incompatible' });
});
test('#1873 a z.ai and a codex model are admitted on pi', async t => {
for (const [provider, upstream, model] of [['zai', 'zai', 'glm-fixture'], ['codex', 'codex', 'gpt-fixture']]) {
const entry = { provider, model, module: 'cliproxy', upstream };
assert.deepEqual(await admission(t, entry, { upstream, model, harnesses: ['claude-code', 'pi'] }), { allow: true }, provider);
}
});
@@ -27,7 +27,9 @@ export async function ownershipFixture(t,{launches=true,listed=true,keep=false,r
// Available before any acquired resource/setup can fail; no later f/launcher TDZ.
const launchLog=()=>{const file=launchLogFile(join(root,'data'),'acme');return fs.existsSync(file)?fs.readFileSync(file,'utf8').trim().split('\n').filter(Boolean).map(line=>JSON.parse(line)):[];};
t.after(async()=>{const failures=[];for(const g of gates)g.release();try{await waitFor(()=>active.size===0,'owned operations did not settle',5000);}catch{failures.push('owned-operation-close');}for(const close of [...closers].reverse()){try{await close();}catch{failures.push('owned-close');}}try{server?.closeAllConnections();if(server?.listening)await new Promise((resolve,reject)=>server.close(e=>e?reject(e):resolve()));}catch{failures.push('owned-server-close');}try{checkHistory({logs,proxyReceipts,trace});}catch{failures.push('value-free-receipts');}try{checkHistory({launch:launchLog()});}catch{failures.push('owned-launch-log-guard');}if(stderr)process.stderr.write=stderr;try{fs.rmSync(root,{recursive:true,force:true});}catch{failures.push('owned-root-close');}if(failures.length)throw new AggregateError(failures.map(code=>Error(code)),'owned managed fixture cleanup failed');});
const f=fixture(root,'acme',doc=>{doc.plugins={...doc.plugins,harness:['pi']};for(const role of Object.values(doc.roles))role.vars={...role.vars,harness:'pi'};doc.roles.chief.vars.model='claude-opus-5-5';doc.roles.aide={definition:'aide',vars:{harness:'pi',model:'claude-opus-5-5',thinking:'high'}};if(listed)doc.launch.instances.push('aide');if(keep)doc.launch.keep=['aide'];if(retired)doc.retired=['alpha'];if(noHire)doc.launch.noHire=['aide'];if(!listed)delete doc.roles.aide;return doc;});
const f=fixture(root,'acme',doc=>{doc.plugins={...doc.plugins,harness:['pi']};for(const role of Object.values(doc.roles))role.vars={...role.vars,harness:'pi'};doc.roles.chief.vars.model='claude-opus-5-5';doc.roles.aide={definition:'aide',vars:{harness:'pi',model:'claude-opus-5-5',thinking:'high'}};if(listed)doc.launch.instances.push('aide');if(keep)doc.launch.keep=['aide'];if(retired)doc.retired=['alpha'];if(noHire)doc.launch.noHire=['aide'];if(!listed)delete doc.roles.aide;doc.launch.models['claude-opus-5-5']={provider:'zai',model:'fixture-aide-model'};return doc;});
// #1873 harness-matrix: an OAuth Claude model runs on claude-code only, so on pi the model key
// claude-opus-5-5 names a non-Claude upstream model.
// The established scratch aide pattern only; repository roles/policy stay untouched.
for(const name of ['aide','helper']){fs.writeFileSync(join(f.roles,name+'.md'),'# Scratch aide\n\n## Authority\n');writeJson(join(f.roles,name+'.json'),{roleVersion:2,name,title:'Aide',contract:name+'.md',tools:['read'],network:'api-only',authority:{withinRole:['message.send'],crossRole:[]},credentials:[]});}
const chiefFile=join(f.roles,'chief-of-staff.json');
+26 -2
View File
@@ -11,7 +11,7 @@ import { tmpdir } from 'node:os';
import { createHash, randomBytes } from 'node:crypto';
import { Credentials } from '../src/credentials.mjs';
import { ManagementClient } from '../../model-proxy/src/client.mjs';
import { ModelKeys, REVOKE_TIMEOUT_MS, REVOKE_POLL_MS } from '../src/model-keys.mjs';
import { ModelKeys, REVOKE_TIMEOUT_MS, REVOKE_POLL_MS, ISSUE_PROBE_TIMEOUT_MS, ISSUE_REPROBE_MIN_MS } from '../src/model-keys.mjs';
import { startBroker } from '../src/runtime.mjs';
import { busOrganization } from '../src/organization-context.mjs';
import { Registry } from '../../seat/src/session.mjs';
@@ -42,6 +42,7 @@ async function fixture(t, { delayed = 0 } = {}) {
const key = req.headers.authorization?.slice(7);
const accepted = state.keys.includes(key) || (state.removed.has(key) && performance.now() - state.removed.get(key) < state.delay);
state.onProbe?.(state.status ?? (accepted ? 200 : 401));
if (state.stallProbe?.()) return;
res.writeHead(state.status ?? (accepted ? 200 : 401)); res.end('{}');
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
@@ -123,10 +124,33 @@ test('proxy-revoke-revision-conflict keeps local revoking record and ids-only re
assert.equal(JSON.stringify(f.receipts).includes(key), false);
await f.create().reconcile(); assert.equal(f.credentials.modelRecord('demo/coder') === null, true);
});
for (const status of [401, 503, 302]) test(`proxy-key-refused: preflight rejects HTTP ${status} with exactly one probe`, async t => {
for (const status of [503, 302]) test(`proxy-key-refused: preflight rejects HTTP ${status} with exactly one probe`, async t => {
const f = await fixture(t); await f.manager.reconcile(); await f.manager.ensure('demo/coder'); f.state.status = status;
await assert.rejects(f.manager.preflight('demo/coder'), failCode('proxy-key-refused')); assert.equal(f.state.probes, 1);
});
test('proxy-key-refused: a key that keeps answering 401 refuses once the short probe deadline passes', async t => {
const f = await fixture(t); await f.manager.reconcile(); await f.manager.ensure('demo/coder'); f.state.status = 401;
const started = performance.now();
await assert.rejects(f.manager.preflight('demo/coder'), failCode('proxy-key-refused'));
const took = performance.now() - started;
assert.ok(f.state.probes > 1, 'a 401 is probed again'); assert.ok(took >= ISSUE_PROBE_TIMEOUT_MS && took < ISSUE_PROBE_TIMEOUT_MS + 2000, `bounded: ${took}`);
});
test('proxy-down: a re-probe that stalls ends near the probe deadline, not the client default', async t => {
const f = await fixture(t); await f.manager.reconcile(); await f.manager.ensure('demo/coder'); f.state.status = 401;
f.state.stallProbe = () => f.state.probes >= 2;
const started = performance.now();
await assert.rejects(f.manager.preflight('demo/coder'), failCode('proxy-down'));
const took = performance.now() - started;
assert.equal(f.state.probes, 2); assert.ok(took < ISSUE_PROBE_TIMEOUT_MS + ISSUE_REPROBE_MIN_MS + 1000, `bounded: ${took}`);
});
// Every v8 CLIProxyAPI applies the PUT by an async reload; on 8.0.79 a just-issued key answers 401
// past the confirming GET (#1873).
test('first launch passes when the proxy applies the new key a moment after the PUT answers', async t => {
const f = await fixture(t); await f.manager.reconcile(); f.state.status = 401;
f.state.onProbe = () => { if (f.state.probes === 3) f.state.status = null; };
const answer = await f.manager.preflight('demo/coder');
assert.equal(f.state.probes, 3); assert.equal(f.state.keys.includes(answer.key), true);
});
test('rotate keeps old key while its run lives, new launches use new, exit removes old', async t => {
const f = await fixture(t); await f.manager.reconcile(); const first = await f.manager.ensure('demo/coder');
f.runs.push({ instance: 'demo/coder', run: 'old', keyId: hash(first.key) });
+299
View File
@@ -0,0 +1,299 @@
// #1873 pickup-launch: a bus that picked up the shared proxy late serves accounts and a ready
// catalogue, but a launch on a proxy model still needs a restart (no ModelKeys on the bus, no proxy
// in the host launcher's boot system). While it holds such a client, its catalogue answer says so
// in one plain notice, and a launch refuses exactly as before. A refused or dropped client shows
// its cause instead. Real buses, a real launcher whose model ops go to the bus, a fake loopback
// management server; no live config.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createHash, randomBytes } from 'node:crypto';
import { pathToFileURL } from 'node:url';
import { startBroker } from '../src/runtime.mjs';
import { busOrganization } from '../src/organization-context.mjs';
import { createProxyLock } from '../src/proxy-lock.mjs';
import { Registry, launchLogFile } from '../../seat/src/session.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { resolveInstance } from '../../organization/src/resolve.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
import { PIN } from '../../model-proxy/src/common.mjs';
import { initializeProxy, installPaths, loadProxy } from '../../model-proxy/src/settings.mjs';
import { createLauncher } from '../../cli/src/launcher.mjs';
import { initializeControl } from '../../processing-control/src/state.mjs';
import { ZAI_URL } from '../../plugins/model-provider/cliproxy/index.mjs';
import { fakeHarnesses, humanEnv, withoutHostCredentials } from '../../cli/tests/helpers.mjs';
import { REPO_SKILLS } from '../../harness/tests/helpers.mjs';
const RESTART = 'Restart this organization to start agents on these models.';
const MODEL = 'claude-claude-opus-5-5';
const sha = value => createHash('sha256').update(value).digest('hex');
// A loopback stand-in for the proxy's management API: one ready Claude account with one model,
// and an access key list that keeps what a PUT sends, so a boot ModelKeys reconciles against it.
async function fakeProxy(t, key, port = 0, { groups = [] } = {}) {
const seen = { calls: 0, wrongKey: 0 };
let accessKeys = [];
const server = http.createServer((req, res) => {
seen.calls++;
if (req.headers.authorization !== `Bearer ${key}`) { seen.wrongKey++; res.writeHead(401); res.end('{}'); return; }
const url = new URL(req.url, 'http://127.0.0.1');
if (url.pathname === '/v8/management/config/access/api-keys' && req.method === 'PUT') {
const chunks = [];
req.on('data', c => chunks.push(c));
req.on('end', () => { accessKeys = JSON.parse(Buffer.concat(chunks)); res.end(JSON.stringify({ status: 'ok' })); });
return;
}
const answer = url.pathname === '/v8/management/credentials' ? { files: [{ id: 'acct-1', name: 'acct-1', provider: 'claude', status: 'ready', priority: 1 }] }
: url.pathname === '/v8/management/credentials/models' ? { models: [{ id: 'claude-opus-5-5' }] }
: url.pathname === '/v8/management/config/api-keys/claude' ? groups
: url.pathname === '/v8/management/config/access/api-keys' ? accessKeys
: null;
if (answer === null) { res.writeHead(404); res.end('{}'); return; }
res.end(JSON.stringify(answer));
});
await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
t.after(async () => { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); });
return { port: server.address().port, seen, server };
}
// One instance (config dir + data root) and a fake proxy install whose bytes a test pin names.
function instance(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'pl-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'instance');
fs.mkdirSync(join(configDir, 'secrets', 'agents'), { recursive: true, mode: 0o700 });
fs.chmodSync(join(configDir, 'secrets'), 0o700);
fs.mkdirSync(dataRoot, { mode: 0o700 });
const paths = installPaths(dataRoot);
fs.mkdirSync(join(paths.dir, 'static'), { recursive: true, mode: 0o700 });
fs.writeFileSync(paths.binary, 'fixture proxy binary\n', { mode: 0o700 });
fs.writeFileSync(paths.panel, '<!doctype html>\n', { mode: 0o600 });
const pin = { ...PIN, binary: { ...PIN.binary, sha256: sha('fixture proxy binary\n') }, panel: { ...PIN.panel, sha256: sha('<!doctype html>\n') } };
const rolesDir = rolesCopy(root), system = systemFor(root);
const key = `pl1873-${randomBytes(24).toString('hex')}`;
return { root, configDir, dataRoot, paths, pin, rolesDir, system, key };
}
// A real organization bus on the instance, started with no proxy unless `binding.proxy` gives one.
async function orgBus(t, f, id, { providers = ['cliproxy'], binding = {} } = {}) {
const doc = businessDoc(f.root, id);
doc.plugins = { harness: ['pi'], 'model-provider': providers };
writeJson(join(f.configDir, 'businesses', `${id}.json`), doc);
const business = loadBusiness(id, { dir: f.configDir, rolesDir: f.rolesDir }), resolved = {};
for (const name of Object.keys(business.roles)) resolved[name] = resolveInstance({ system: f.system, business, instance: name });
const dataRoot = join(f.root, `${id}-bus`); fs.mkdirSync(dataRoot, { mode: 0o700 }); new Registry(dataRoot);
const bus = await startBroker({ dataRoot, businesses: { [id]: busOrganization(business, resolved) },
organization: { dir: f.configDir, rolesDir: f.rolesDir, system: f.system },
instanceRoot: f.dataRoot, org: { id }, instanceDataRoot: f.dataRoot, instanceConfigDir: f.configDir,
initProxy: args => initializeProxy({ ...args, pin: f.pin }), ...binding });
t.after(() => bus.close().catch(() => {}));
const human = bus.broker.bindHuman({ business: id, human: 'jason', via: 'cli', outsideAgent: true });
const ask = (verb, args) => Promise.resolve().then(() => bus.broker.request(human, { verb, args }));
return { id, bus, ask, dataRoot };
}
// Every stderr line written while `run` is in flight.
async function capture(run) {
const write = process.stderr.write, lines = [];
process.stderr.write = (chunk, ...rest) => { lines.push(String(chunk)); return write.call(process.stderr, chunk, ...rest); };
try { return { value: await run(), lines }; } finally { process.stderr.write = write; }
}
async function initThroughA(t, f, a, options) {
const settings = await a.ask('proxy.init', { key: f.key });
const proxy = await fakeProxy(t, f.key, settings.port, options);
return { settings, proxy };
}
// The owner picks the catalogue's proxy model for the coder on the Routing page, through the bus.
async function pickModel(o) {
const view = await o.ask('routes');
assert.equal(view.catalogue.status, 'ready');
assert.ok(view.catalogue.models.some(m => m.key === MODEL));
await o.ask('routes.set', { revision: view.revision, routes: { coder: { harness: 'pi', model: MODEL, thinking: 'low', fallback: null } } });
}
// The host launcher as cli.mjs builds it for a bus that booted with no proxy.json: its system has
// no proxy. The model ops go to the bus itself; the rest are the launch-routes stub, and
// authorizeLaunch stops a launch that passed every check before it.
async function hostLauncher(t, f, o, { system = {} } = {}) {
initializeControl(o.dataRoot);
// A launch whose role names a skill that is not enabled refuses before the model gate.
if (!fs.existsSync(join(f.dataRoot, 'skills-enabled'))) fs.cpSync(REPO_SKILLS, join(f.dataRoot, 'skills-enabled'), { recursive: true });
const env = withoutHostCredentials(humanEnv({ MOSAIC_CONFIG: join(f.configDir, 'config.json'), MOSAIC_ROLES_DIR: f.rolesDir }), { piKey: true });
const answers = [], ops = [];
const host = { business: o.id, beforeClose: () => {}, op: async m => {
ops.push(m.op);
if (m.op === 'identity') return { business: o.id, role: 'pm' };
if (m.op === 'mayLaunch') return { allow: true };
if (m.op === 'modelAdmission' || m.op === 'modelPreflight') { const answer = await o.bus[m.op](m); answers.push({ op: m.op, answer }); return answer; }
if (m.op === 'authorizeLaunch') throw Object.assign(Error('fixture authorization stop'), { code: 'fixture-policy' });
return {};
} };
const cliproxy = JSON.stringify(pathToFileURL(new URL('../../plugins/model-provider/cliproxy/index.mjs', import.meta.url).pathname).href);
const makeLoader = await fakeHarnesses(t, { pi: null }, write => write('model-provider', 'cliproxy', `export * from ${cliproxy};\n`));
// The validated system config shape (mosaic-config.mjs), as cli.mjs passes it with the org root.
const config = { configVersion: 1, environment: 'development', dataRoot: o.dataRoot, instanceRoot: f.dataRoot,
execution: { backend: 'docker', provider: 'zai', model: 'glm-5.3-flash', adapter: 'mock' }, ...system };
const launcher = createLauncher({ host, system: config, env, makeLoader, bwrap: '/usr/bin/true', log: () => {} });
t.after(() => launcher.close?.().catch?.(() => {}));
const events = () => { try { return fs.readFileSync(launchLogFile(o.dataRoot, o.id), 'utf8').trim().split('\n').filter(Boolean).map(l => JSON.parse(l)); } catch { return []; } };
return { launch: () => launcher.fromSession('fixture-cap', 'coder'), answers, ops, events };
}
const restartNotices = view => view.catalogue.notices.filter(n => n === RESTART).length;
test('a bus that picked up the proxy says on its ready catalogue that a restart starts agents on these models, and the launch refuses as before', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const before = await b.ask('routes');
assert.equal(before.catalogue.status, 'unavailable');
assert.equal(restartNotices(before), 0, 'no client yet: the not-set-up cause, not the restart notice');
await initThroughA(t, f, a);
await pickModel(b);
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'ready');
assert.equal(restartNotices(view), 1);
assert.equal(restartNotices(await b.ask('routes')), 1, 'one notice at every read');
// The bus that ran init holds a client it did not boot with too.
const own = await a.ask('routes');
assert.equal(own.catalogue.status, 'ready');
assert.equal(restartNotices(own), 1);
// The launch refuses as before, with the existing code and line, before any key or run: the
// launcher booted with no proxy sends no proxy transport, and the bus's admission refuses that.
const host = await hostLauncher(t, f, b);
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.deepEqual(host.answers, [{ op: 'modelAdmission', answer: { allow: false, code: 'model-provider-unavailable' } }]);
assert.equal(host.ops.includes('authorizeLaunch'), false);
assert.equal(host.ops.includes('modelPreflight'), false);
const refused = host.events().filter(e => e.event === 'refused');
assert.equal(refused.length, 1);
assert.equal(refused[0].code, 'model-provider-unavailable');
assert.equal(refused[0].why, 'model cliproxy/claude/claude-opus-5-5 unavailable (model-provider-unavailable)');
// The bus side has no ModelKeys: a preflight issues no key.
assert.equal(await b.bus.modelPreflight({ business: 'beta', role: 'coder' }), null);
});
test('the restart notice is added after the notices the catalogue already carries', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
// A z.ai upstream group with no models: the cliproxy catalogue's own notice.
await initThroughA(t, f, a, { groups: [{ 'base-url': ZAI_URL, keys: [{ name: 'group-1' }] }] });
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'ready');
assert.deepEqual(view.catalogue.notices, ['z.ai account has no models configured. Add them on Model proxy.', RESTART]);
});
test('a bus started with the proxy shows no restart notice', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
await initThroughA(t, f, a);
const c = await orgBus(t, f, 'gamma', { binding: { proxy: loadProxy(f.configDir, f.dataRoot) } });
const view = await c.ask('routes');
assert.equal(view.catalogue.status, 'ready', JSON.stringify(view.catalogue));
assert.deepEqual(view.catalogue.notices, []);
});
test('an organization with no model provider shows a disabled catalogue with no restart notice (the routes verb answers disabled itself)', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta', { providers: [] });
await initThroughA(t, f, a);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy, 'the client is held');
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'disabled');
assert.deepEqual(view.catalogue.notices, []);
});
test('a fenced catalogue on a picked-up client reads unavailable with no restart notice, since a restart would not help', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const { proxy } = await initThroughA(t, f, a);
assert.equal(restartNotices(await b.ask('routes')), 1);
createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:${proxy.port}` }).fence({ org: 'alpha' });
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.ok(b.bus.modelProxy);
assert.equal(restartNotices(view), 0);
// A bus that booted with the proxy on the same fenced instance, which is what a restart gives,
// reads the same unavailable catalogue: the restart notice would have sent the owner nowhere.
const c = await orgBus(t, f, 'gamma', { binding: { proxy: loadProxy(f.configDir, f.dataRoot) } });
assert.equal((await c.ask('routes')).catalogue.status, 'unavailable');
// Once the fence is gone, the ready catalogue says again that a restart is needed.
fs.rmSync(join(f.dataRoot, 'proxy', 'mosaic-keys.uncertain'));
const after = await b.ask('routes');
assert.equal(after.catalogue.status, 'ready', JSON.stringify(after.catalogue));
assert.equal(restartNotices(after), 1);
});
test('refused settings still refuse the launch and name their cause, not the restart notice', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
await pickModel(b);
// The management key file stops being private: the start path refuses it.
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.equal(view.catalogue.notices.length, 1);
assert.match(view.catalogue.notices[0], /management key does not load/);
assert.equal(b.bus.modelProxy, null);
const host = await hostLauncher(t, f, b);
// The bus itself refuses now: the catalogue keeps the model it saw, marked unavailable.
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.deepEqual(host.answers, [{ op: 'modelAdmission', answer: { allow: false, code: 'model-provider-unavailable' } }]);
assert.match(host.events().at(-1).why, /^model cliproxy\/claude\/claude-opus-5-5 unavailable \(model-provider-unavailable\)$/);
});
test('a dropped client refuses the next launch, and the catalogue names the cause instead of the restart notice', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
await pickModel(b);
const host = await hostLauncher(t, f, b);
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.equal(restartNotices(await b.ask('routes')), 1);
fs.rmSync(join(f.configDir, 'proxy.json'));
// The next launch refuses with the same code and line.
assert.deepEqual(await host.launch(), { ok: false, error: 'model-provider-unavailable' });
assert.deepEqual(host.answers.map(a => a.answer), [{ allow: false, code: 'model-provider-unavailable' }, { allow: false, code: 'model-provider-unavailable' }]);
assert.equal(host.events().filter(e => e.event === 'refused').length, 2);
// The page's next read drops the client and names the cause.
const view = await b.ask('routes');
assert.equal(b.bus.modelProxy, null);
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.deepEqual(view.catalogue.notices.length, 1);
assert.match(view.catalogue.notices[0], /not been set up/);
});
test('the management key is in no stderr line, response, refusal, launch log or file the launch path writes', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
await pickModel(b);
const host = await hostLauncher(t, f, b);
const outputs = [];
const { lines } = await capture(async () => {
outputs.push(await b.ask('routes'));
outputs.push(await host.launch());
outputs.push(await b.bus.modelPreflight({ business: 'beta', role: 'coder' }));
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
outputs.push(await b.ask('routes'));
outputs.push(await host.launch());
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o600);
outputs.push(await b.ask('routes'));
outputs.push(await host.launch());
});
outputs.push(host.answers, host.events());
assert.equal(lines.join('').includes(f.key), false, 'stderr');
assert.equal(JSON.stringify(outputs).includes(f.key), false, 'responses, answers and launch log');
const walk = dir => fs.readdirSync(dir, { withFileTypes: true }).flatMap(e => e.isDirectory() ? walk(join(dir, e.name)) : e.isFile() ? [join(dir, e.name)] : []);
const files = [...walk(b.dataRoot), ...walk(join(f.dataRoot, 'proxy')).filter(p => !p.endsWith('/config.yaml'))];
assert.ok(files.some(p => p === launchLogFile(b.dataRoot, 'beta')), 'the launch log is scanned');
for (const file of files) assert.equal(fs.readFileSync(file).includes(f.key), false, file);
});
+371
View File
@@ -0,0 +1,371 @@
// #1873 proxy-pickup: a running organization bus picks up the shared model proxy that another
// organization's bus initialized, with no restart, through the start path's loader and lock. A
// bus whose proxy settings the start path would refuse still refuses, and names the cause in one
// plain line. Real buses and a fake loopback management server; no live config.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createHash, randomBytes } from 'node:crypto';
import { startBroker } from '../src/runtime.mjs';
import { busOrganization } from '../src/organization-context.mjs';
import { createProxyLock } from '../src/proxy-lock.mjs';
import { Registry } from '../../seat/src/session.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { resolveInstance } from '../../organization/src/resolve.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
import { PIN } from '../../model-proxy/src/common.mjs';
import { initializeProxy, installPaths } from '../../model-proxy/src/settings.mjs';
import { FIXTURE_ENTRY, FIXTURE_KEY_NAME } from '../../plugins/model-provider/fixture/index.mjs';
const sha = value => createHash('sha256').update(value).digest('hex');
// A loopback stand-in for the proxy's management API: one ready Claude account with one model.
async function fakeProxy(t, key, port = 0) {
const seen = { calls: 0, wrongKey: 0 };
const server = http.createServer((req, res) => {
seen.calls++;
if (req.headers.authorization !== `Bearer ${key}`) { seen.wrongKey++; res.writeHead(401); res.end('{}'); return; }
const url = new URL(req.url, 'http://127.0.0.1');
const answer = url.pathname === '/v8/management/credentials' ? { files: [{ id: 'acct-1', name: 'acct-1', provider: 'claude', status: 'ready', priority: 1 }] }
: url.pathname === '/v8/management/credentials/models' ? { models: [{ id: 'claude-opus-5-5' }] }
: url.pathname === '/v8/management/config/api-keys/claude' ? []
: url.pathname === '/v8/management/config/access/api-keys' ? []
: null;
if (answer === null) { res.writeHead(404); res.end('{}'); return; }
res.end(JSON.stringify(answer));
});
await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
t.after(async () => { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); });
return { port: server.address().port, seen, server };
}
// One instance (config dir + data root) and a fake proxy install whose bytes a test pin names.
// The pin keeps the shipped version, so the pinned binary path is the one loadProxy accepts.
function instance(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'pk-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'instance');
fs.mkdirSync(join(configDir, 'secrets', 'agents'), { recursive: true, mode: 0o700 });
fs.chmodSync(join(configDir, 'secrets'), 0o700);
fs.mkdirSync(dataRoot, { mode: 0o700 });
const paths = installPaths(dataRoot);
fs.mkdirSync(join(paths.dir, 'static'), { recursive: true, mode: 0o700 });
fs.writeFileSync(paths.binary, 'fixture proxy binary\n', { mode: 0o700 });
fs.writeFileSync(paths.panel, '<!doctype html>\n', { mode: 0o600 });
const pin = { ...PIN, binary: { ...PIN.binary, sha256: sha('fixture proxy binary\n') }, panel: { ...PIN.panel, sha256: sha('<!doctype html>\n') } };
const rolesDir = rolesCopy(root), system = systemFor(root);
const key = `pk1873-${randomBytes(24).toString('hex')}`;
return { root, configDir, dataRoot, paths, pin, rolesDir, system, key, closers: [] };
}
// A real organization bus on the instance, started with no proxy (as cli bootConfig does when the
// instance has no proxy.json at boot).
async function orgBus(t, f, id, { providers = ['cliproxy'], edit = () => {}, org = { id }, binding = {} } = {}) {
const doc = businessDoc(f.root, id);
doc.plugins = { harness: ['pi'], 'model-provider': providers };
edit(doc);
writeJson(join(f.configDir, 'businesses', `${id}.json`), doc);
const business = loadBusiness(id, { dir: f.configDir, rolesDir: f.rolesDir }), resolved = {};
for (const name of Object.keys(business.roles)) resolved[name] = resolveInstance({ system: f.system, business, instance: name });
const dataRoot = join(f.root, `${id}-bus`); fs.mkdirSync(dataRoot, { mode: 0o700 }); new Registry(dataRoot);
const bus = await startBroker({ dataRoot, businesses: { [id]: busOrganization(business, resolved) },
organization: { dir: f.configDir, rolesDir: f.rolesDir, system: f.system },
instanceRoot: f.dataRoot, org, instanceDataRoot: f.dataRoot, instanceConfigDir: f.configDir,
initProxy: args => initializeProxy({ ...args, pin: f.pin }), ...binding });
t.after(() => bus.close().catch(() => {}));
const human = bus.broker.bindHuman({ business: id, human: 'jason', via: 'cli', outsideAgent: true });
const ask = (verb, args) => Promise.resolve().then(() => bus.broker.request(human, { verb, args }));
return { bus, ask, dataRoot };
}
// Every stderr line written while `run` is in flight.
async function capture(run) {
const write = process.stderr.write, lines = [];
process.stderr.write = (chunk, ...rest) => { lines.push(String(chunk)); return write.call(process.stderr, chunk, ...rest); };
try { return { value: await run(), lines }; } finally { process.stderr.write = write; }
}
// The proxy init through bus A writes proxy.json and the key, then the proxy starts on that port.
async function initThroughA(t, f, a) {
const settings = await a.ask('proxy.init', { key: f.key });
const proxy = await fakeProxy(t, f.key, settings.port);
return { settings, proxy };
}
const notConfigured = (pattern) => e => e.code === 'not-configured' && typeof e.reason === 'string' && pattern.test(e.reason) && e.reason.length <= 300;
test('a running organization bus answers accounts and a cliproxy catalogue once another bus initialized the shared proxy, with no restart', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
// Before init: bus B has nothing to pick up, and says so.
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/not been set up/));
const before = await b.ask('routes');
assert.equal(before.catalogue.status, 'unavailable');
assert.equal(before.catalogue.reason, 'proxy-not-configured');
assert.equal(before.catalogue.notices.length, 1);
const { proxy } = await initThroughA(t, f, a);
// Bus A holds the client from its own init; bus B picks it up at its next read.
assert.deepEqual((await a.ask('proxy.accounts', {})).accounts.map(r => r.provider), ['claude']);
const accounts = await b.ask('proxy.accounts', {});
assert.deepEqual(accounts.accounts.map(r => [r.provider, r.status]), [['claude', 'ready']]);
const after = await b.ask('routes');
assert.equal(after.catalogue.status, 'ready');
assert.deepEqual(after.catalogue.models.map(m => m.key), ['claude-claude-opus-5-5']);
assert.equal(after.catalogue.reason, undefined);
assert.equal(proxy.seen.wrongKey, 0);
// Bus B reached the proxy through the same lock identity the start path uses.
assert.ok(createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:${proxy.port}` }));
});
test('a bus started before the proxy existed and asked only for a catalogue picks the proxy up', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
assert.equal((await b.ask('routes')).catalogue.status, 'unavailable');
await initThroughA(t, f, a);
assert.equal((await b.ask('routes')).catalogue.status, 'ready');
});
// Each case writes the shared proxy's files by hand into a state the start path refuses.
const refusedStates = [
['proxy.json names an unpinned binary', /settings do not load/, f => writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: '/elsewhere/cli-proxy-api' })],
['proxy.json is not JSON', /settings do not load/, f => fs.writeFileSync(join(f.configDir, 'proxy.json'), '{', { mode: 0o600 })],
['the management key file is readable by others', /management key does not load/, f => {
writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary });
fs.writeFileSync(join(f.configDir, 'secrets', 'proxy-management.key'), f.key, { mode: 0o644 });
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
}],
['the management key file is missing', /management key does not load/, f => writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary })],
['the proxy state names another port', /proxy lock/, f => {
writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary });
fs.writeFileSync(join(f.configDir, 'secrets', 'proxy-management.key'), f.key, { mode: 0o600 });
fs.mkdirSync(join(f.dataRoot, 'proxy'), { mode: 0o700 });
createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:40998` });
}],
['the proxy state directory is open to others', /proxy lock/, f => {
writeJson(join(f.configDir, 'proxy.json'), { port: 40999, binary: f.paths.binary });
fs.writeFileSync(join(f.configDir, 'secrets', 'proxy-management.key'), f.key, { mode: 0o600 });
fs.mkdirSync(join(f.dataRoot, 'proxy'), { mode: 0o755 }); fs.chmodSync(join(f.dataRoot, 'proxy'), 0o755);
}],
];
for (const [name, cause, arrange] of refusedStates) test(`no pickup when ${name}: accounts and catalogue refuse with the cause`, async t => {
const f = instance(t);
const b = await orgBus(t, f, 'beta');
arrange(f);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(cause));
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.match(view.catalogue.notices[0], cause);
assert.equal(b.bus.modelProxy, null);
});
// The host refuses fixture-proxy-configured only when a dev fixture is recorded for the instance.
const recordFixture = f => {
fs.mkdirSync(join(f.dataRoot, 'dev-fixture'), { mode: 0o700 });
fs.writeFileSync(join(f.dataRoot, 'dev-fixture', 'fixture.json'), '{}\n', { mode: 0o600 });
};
test('no pickup for an organization on the fixture model provider, which the host refuses with a proxy', async t => {
const f = instance(t);
recordFixture(f);
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { providers: ['fixture', 'cliproxy'], edit: doc => { doc.launch.models[FIXTURE_KEY_NAME] = { ...FIXTURE_ENTRY }; } });
await initThroughA(t, f, a);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
const view = await b.ask('routes');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
assert.match(view.catalogue.notices[0], /fixture/);
});
test('no pickup for an organization whose launch table names the fixture module only', async t => {
const f = instance(t);
recordFixture(f);
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { edit: doc => { doc.launch.models[FIXTURE_KEY_NAME] = { ...FIXTURE_ENTRY }; } });
await initThroughA(t, f, a);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('an organization that lists the fixture still picks the proxy up when no fixture is recorded, as the host would start it', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { providers: ['fixture', 'cliproxy'] });
await initThroughA(t, f, a);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy);
// A fixture recorded later drops the client at the next request.
recordFixture(f);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('a picked-up client is dropped when proxy.json goes away, its port changes, or the key stops loading', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const { settings } = await initThroughA(t, f, a);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy);
const file = join(f.configDir, 'proxy.json'), keyFile = join(f.configDir, 'secrets', 'proxy-management.key');
const saved = fs.readFileSync(file);
// Port change: the lock identity is bound to the port, so the bus refuses until a restart.
writeJson(file, { ...settings, port: settings.port + 1 === 8317 ? settings.port + 2 : settings.port + 1 });
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/proxy lock/));
assert.equal(b.bus.modelProxy, null);
assert.equal((await b.ask('routes')).catalogue.status, 'unavailable');
// Back to the original port, the bus picks it up again.
fs.writeFileSync(file, saved);
await b.ask('proxy.accounts', {});
assert.ok(b.bus.modelProxy);
// Key file no longer 0600.
fs.chmodSync(keyFile, 0o640);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/management key does not load/));
assert.equal(b.bus.modelProxy, null);
fs.chmodSync(keyFile, 0o600);
await b.ask('proxy.accounts', {});
// proxy.json removed.
fs.rmSync(file);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/not been set up/));
assert.equal(b.bus.modelProxy, null);
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.equal(view.catalogue.reason, 'proxy-not-configured');
});
test('a default-instance bus (no organization binding, no lock) follows a port change to the new client, never the old one', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), d = await orgBus(t, f, 'delta', { org: null });
const { settings, proxy } = await initThroughA(t, f, a);
assert.deepEqual((await d.ask('proxy.accounts', {})).accounts.map(r => r.provider), ['claude']);
const old = d.bus.modelProxy;
// A listener on the new port that answers nothing to the right key: reaching it proves the move.
const moved = await fakeProxy(t, `other-${f.key.slice(0, 6)}`);
writeJson(join(f.configDir, 'proxy.json'), { ...settings, port: moved.port });
const before = proxy.seen.calls;
await assert.rejects(d.ask('proxy.accounts', {}));
assert.ok(d.bus.modelProxy && d.bus.modelProxy !== old);
assert.ok(moved.seen.calls > 0);
assert.equal(proxy.seen.calls, before);
});
test('a picked-up bus reads its catalogue through the shared lock: a fence makes it unavailable', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
const { proxy } = await initThroughA(t, f, a);
assert.equal((await b.ask('routes')).catalogue.status, 'ready');
createProxyLock({ stateDir: join(f.dataRoot, 'proxy'), identity: `${f.configDir}:${proxy.port}` }).fence({ org: 'alpha' });
const view = await b.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.ok(b.bus.modelProxy, 'the client stays; the fence alone holds the catalogue');
});
test('a fixture record path in any state but absent counts as recorded', async t => {
const f = instance(t);
fs.writeFileSync(join(f.dataRoot, 'dev-fixture'), 'not a directory\n', { mode: 0o600 });
const a = await orgBus(t, f, 'alpha');
const b = await orgBus(t, f, 'beta', { providers: ['fixture', 'cliproxy'] });
await initThroughA(t, f, a);
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('with a fixture recorded, an organization document that no longer validates counts as using it', async t => {
const f = instance(t);
recordFixture(f);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
fs.writeFileSync(join(f.configDir, 'businesses', 'beta.json'), '{', { mode: 0o600 });
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/fixture-proxy-configured/));
assert.equal(b.bus.modelProxy, null);
});
test('the bus that ran init also drops its client when the key stops loading', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
await initThroughA(t, f, a);
await a.ask('proxy.accounts', {});
fs.rmSync(join(f.configDir, 'secrets', 'proxy-management.key'));
await assert.rejects(a.ask('proxy.accounts', {}), notConfigured(/management key does not load/));
assert.equal(a.bus.modelProxy, null);
});
test('an init whose lock refuses leaves the init bus holding no client: no ready catalogue without the lock', async t => {
const f = instance(t);
// The real init, then the proxy state dir is left readable by the group, which the lock refuses.
const initProxy = async args => { const settings = await initializeProxy({ ...args, pin: f.pin });
fs.mkdirSync(join(f.dataRoot, 'proxy'), { recursive: true }); fs.chmodSync(join(f.dataRoot, 'proxy'), 0o750); return settings; };
const a = await orgBus(t, f, 'alpha', { binding: { initProxy } });
await assert.rejects(a.ask('proxy.init', { key: f.key }));
await fakeProxy(t, f.key, JSON.parse(fs.readFileSync(join(f.configDir, 'proxy.json'), 'utf8')).port);
assert.equal(a.bus.modelProxy, null);
const view = await a.ask('routes');
assert.equal(view.catalogue.status, 'unavailable');
assert.match(view.catalogue.notices[0], /proxy-lock-invalid/);
assert.equal(a.bus.modelProxy, null);
});
test('a default-instance bus (no lock generation) refreshes its catalogue at once on pickup and on drop', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), d = await orgBus(t, f, 'delta', { org: null });
// An unavailable catalogue read before init must not be served after the pickup.
assert.equal((await d.ask('routes')).catalogue.status, 'unavailable');
await initThroughA(t, f, a);
assert.equal((await d.ask('routes')).catalogue.status, 'ready');
// A ready catalogue read through the picked-up client must not be served after the drop.
fs.rmSync(join(f.configDir, 'proxy.json'));
const gone = await d.ask('routes');
assert.equal(gone.catalogue.status, 'unavailable');
assert.equal(gone.catalogue.reason, 'proxy-not-configured');
assert.equal(d.bus.modelProxy, null);
});
test('a picked-up bus clears a proxy fence through the same client and lock', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
// proxy.fence.clear on a bus that has not read anything yet still picks the proxy up first; the
// restart evidence check is the existing one and refuses this empty evidence.
await assert.rejects(b.ask('proxy.fence.clear', { evidence: {} }));
assert.ok(b.bus.modelProxy);
});
test('a bus serving an invalid organization id never picks up a proxy', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha');
await initThroughA(t, f, a);
let b;
try { b = await orgBus(t, f, 'beta', { binding: { instanceConfigDir: 42 } }); }
catch (error) { assert.equal(error.code, 'invalid-host-request'); return; }
await assert.rejects(b.ask('proxy.accounts', {}), notConfigured(/organization binding/));
assert.equal(b.bus.modelProxy, null);
});
test('the management key is in no stderr line, response, refusal, event or file the pickup path writes', async t => {
const f = instance(t);
const a = await orgBus(t, f, 'alpha'), b = await orgBus(t, f, 'beta');
await initThroughA(t, f, a);
const outputs = [];
const { lines } = await capture(async () => {
outputs.push(await b.ask('proxy.accounts', {}));
outputs.push(await b.ask('routes'));
// A refusal after the key stops loading, and the pickup after it loads again.
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o644);
await b.ask('proxy.accounts', {}).catch(error => outputs.push({ code: error.code, reason: error.reason, message: error.message, next: error.next }));
outputs.push(await b.ask('routes'));
fs.chmodSync(join(f.configDir, 'secrets', 'proxy-management.key'), 0o600);
outputs.push(await b.ask('proxy.accounts', {}));
});
assert.ok(lines.some(line => line.startsWith('model-proxy: ')), 'the pickup client writes its usual receipts');
assert.equal(lines.join('').includes(f.key), false, 'stderr');
assert.equal(JSON.stringify(outputs).includes(f.key), false, 'responses');
// Every file under bus B's data root (store, WAL, sessions) and the proxy state directory,
// except the proxy's own config.yaml that init writes for the proxy process.
const walk = dir => fs.readdirSync(dir, { withFileTypes: true }).flatMap(e => e.isDirectory() ? walk(join(dir, e.name)) : e.isFile() ? [join(dir, e.name)] : []);
const files = [...walk(b.dataRoot), ...walk(join(f.dataRoot, 'proxy')).filter(p => !p.endsWith('/config.yaml'))];
assert.ok(files.length > 0);
for (const file of files) assert.equal(fs.readFileSync(file).includes(f.key), false, file);
});
+97
View File
@@ -1425,3 +1425,100 @@ installer writes `<dataRoot>/.deployed` as mode 0444 naming the instance.
`webui-service.sh` refuses accounts and deployed instances because its user
manager runs under a human or development seat uid. The receipt uid identifies
the invoking process; it does not attribute a human or resist tampering by that uid.
## Triage route (#1873, held for Jason's ruling)
`mosaic triage route show` prints the Triage route the instance owner set, or
`triage route: not set` (exit 0). `mosaic triage route set --model KEY
--harness NAME --cap TOKENS --time-zone ZONE [--revision N]` writes it. Both
refuse inside an agent run before anything is read (exit 3).
The file is `<dataRoot>/triage/route.json`
(packages/webui/src/triage-route-store.mjs): a catalogue model key, a harness
name and a daily cap leaf `{limit, since, reset, timeZone}`. It holds no env
value and no key. The day resets at 00:00 in the zone given, which has no
default; an unknown zone refuses. The first cap counts from the time it is
set; a later change keeps that `since`, as an organization's token limits do,
so lowering the cap never drops tokens already spent. The directory is 0700 and the file 0600,
owned by the running user; a link, a non-file, a wrong mode or owner, or an
unknown field refuses (exit 3). A write is compare-and-set on `revision`
(`--revision 0`: only when nothing is set), atomic, and appends one line with
the old and new values to `route-receipts.jsonl`. A write that died leaves
`route.lock`; the next write refuses and names it, and you remove it by hand.
If the route changed but its receipt line could not be written, the write
refuses with `triage-route-unrecorded` (exit 3) and names the new revision.
`set` checks the harness against packages/plugins/harness/; it does not check
the model key against a catalogue yet.
The Console does not read this file: the Triage host keeps `route: null` until
the wiring slice.
## Triage key (#1873)
`mosaic triage key issue|rotate|retire|status` manage Triage's own model
proxy client key. Every verb refuses inside an agent run before anything is
read (exit 3), and takes no options.
The key is `mst-<tag>-triage-<43 base64url>`, where `<tag>` is the first 12
hex of sha256 of the config directory, the tag on the instance's own `msk-`
sentinel. An org bus reconciles only its `mso-<tag>-<org>-key-` names and a
no-org bus only its `msk-<tag>-` names, so neither removes it. The file is
`<configDir>/secrets/triage/model`: `{version, key, keyId, issuedAt,
rotateBy, retiring}`. The directory is 0700 and the file 0600, owned by the
running user. A link, a non-file, a second hard link, a wrong mode or owner, a
file over 64 KiB, or a record that does not match the shape refuses every verb
with `triage-key-unreadable` (exit 3).
- `issue` adds one key and writes the file. It refuses `triage-key-issued`
when a key is already issued; that is `rotate`.
- `rotate` adds a new key and moves the old one to `retiring`, with a retire
time of now plus `rotateGraceMinutes` from proxy.json, where the bus reads
it (default 120). `rotateBy` is 30 days on, as for an org key. An old key
the proxy no longer holds is dropped at once.
- `retire` removes retiring keys whose grace has passed or that the proxy no
longer holds. It changes nothing before then.
Nothing runs on a timer. The retire time is the earliest a retiring key may
go; the key stays live in the proxy until someone runs `retire` (or a later
`rotate` or `issue`) after it. `rotateBy` works the same way: `status` marks
it due, and only `rotate` replaces the key.
- `status` prints whether a key is issued, its key id, its age, its rotate-by
day, each retiring key, what the proxy list holds, a set fence, any key in
the Triage namespace the file does not hold, and the next command. It takes
no lock and writes nothing.
`issue`, `rotate` and `retire` hold the instance proxy lock that org buses
take (`<dataRoot>/proxy`). Each reads the list, refuses without this
instance's sentinel (`triage-key-proxy-open`), reads it again and refuses if
it moved (`triage-key-raced`), sets the fence, writes, reads back and clears
the fence. The proxy changes first and the file second. Each run that
changes something appends one line of key ids, never keys, to
`<dataRoot>/proxy/mosaic-keys.receipts.jsonl`. That file is checked under the
lock before anything changes; an unsafe one refuses
`triage-key-receipts-unsafe`. A receipt line that still fails after the change
refuses `triage-key-unrecorded`. No output, error or receipt holds a key.
The file is written to a 0600 temp file in the same directory, synced, renamed
into place, and the directory is synced. A failed directory sync after the
rename refuses `triage-key-unsynced`: the file is in place but may not survive
a power loss. `proxy-lock-busy` means another proxy writer holds the lock; if
none is running, `mosaic proxy fence status` shows the lock state.
After a crash:
- Killed after the proxy write and before the read-back: the fence stays set
and every proxy writer on the instance refuses `proxy-uncertain`. `status`
shows the fence. Restart the proxy, run `mosaic proxy fence clear
--proxy-restarted`, then run the verb again.
- Killed after the read-back and before the file write: the proxy holds a key
the file does not. `status` names it; the next `issue`, `rotate` or `retire`
removes it. A file that could not be written refuses
`triage-key-unwritten` and says to run the verb again.
- Killed after the temp file is written and before its rename: a
`.model.<pid>.<hex>.tmp` file that may hold a key stays in the triage
directory. `status` counts it; the next `issue`, `rotate` or `retire`
removes it under the lock.
- A `retire` killed after the proxy write leaves a retiring key the proxy no
longer holds. `status` marks it; the next `retire` drops it from the file.
Nothing gives the key to the Triage host yet; that is the wiring slice.
+4
View File
@@ -56,6 +56,7 @@ import { ORG_CONFIG, runConfigCommand } from "../../organization/src/config-comm
import { devCommand, DEV_USAGE, fixtureLaunchEnv, fixtureLauncherOptions } from "./dev-fixture.mjs";
import { runCommand, RUN_USAGE } from "./run-evidence.mjs";
import { tasksWriteCommand, TASKS_WRITE_OPS, TASKS_WRITE_USAGE } from "./tasks-write.mjs";
import { triageCommand, TRIAGE_USAGE } from "./triage.mjs";
export const USAGE = `usage:
${ACCOUNTS_USAGE}
@@ -103,6 +104,7 @@ export const USAGE = `usage:
mosaic console start [--dev-local-owner [--dev-insecure-bind ADDR --dev-allow-host NAME[,NAME...]]] [--detach] [--port auto|N]
mosaic console stop|status
mosaic console restart
${TRIAGE_USAGE}
${DEV_USAGE}
${RUN_USAGE}`;
@@ -818,6 +820,8 @@ export async function main(argv, io = { env: process.env, stdin: process.stdin,
if (verb === "launches") return launches(rest, io, deps);
if (verb === "bus") return bus(rest, io, deps);
if (verb === "console") return consoleCommand(rest, io, deps);
// triage-route-store (#1873): the owner's Triage route file, read and written as the person.
if (verb === "triage") return triageCommand(rest, io, deps);
if (verb === "dev") return devCommand(rest, io, { system: deps.system });
if (verb === "run") return runCommand(rest, io, { system: deps.system, callFor: (p) => channelCallFor(p, io, deps) });
if (verb === "-h" || verb === "--help") return io.stdout.write(`${USAGE}\n`);
+14 -1
View File
@@ -5,6 +5,7 @@ import { listOrgs, orgLock, resolveOrg } from '../../organization/src/org-regist
import { organizationWriter } from '../../organization/src/organization.mjs';
import { templateRender, validateOrg, createOrg, showOrg, updateOrg, queueInit, queueShow, projectRepoInit, projectRepoShow, projectRepoSet, deleteOrg, archiveOrg, restoreOrg } from '../../organization/src/org-service.mjs';
import { installedStarterPacks } from '../../plugins/src/starter-pack.mjs';
import { appendReceipt } from '../../model-proxy/src/admin.mjs';
import { DEV_OWNER, devOwnerInstance } from './dev-local-owner.mjs';
import { loadSystem, orgPaths, rolesDir } from './config.mjs';
import { CliError } from './errors.mjs';
@@ -173,6 +174,18 @@ async function templateCommand(args, io, deps) {
io.stdout.write(JSON.stringify(result, null, 2) + '\n');
}
const busStartVerb = id => `mosaic bus start ${id} --dev-local-owner --detach`;
// #1873 ride-default: `mosaic org update` that takes cliproxy off an organization records the removal
// in the instance's proxy receipts first, where Ride all reads it, as the Console's admin save does.
// A record that cannot be written refuses the update and writes nothing. A stale revision records
// nothing and is left to updateOrg's own refusal.
const providerList = doc => (Array.isArray(doc?.plugins?.['model-provider']) ? doc.plugins['model-provider'] : []);
export async function orgUpdate(ctx, id, doc, { ifRevision, record = org => appendReceipt(ctx.dataRoot, { time: new Date().toISOString(), op: 'ride-removed', org }) } = {}) {
const shown = await showOrg(ctx, id);
if (shown.revision === ifRevision && providerList(shown.doc).includes('cliproxy') && !providerList(doc).includes('cliproxy')) {
try { await record(id); } catch { throw new CliError('the removal of the model proxy could not be recorded, so nothing was saved', 3); }
}
return updateOrg(ctx, id, doc, { ifRevision });
}
export async function orgCommand(args, io, deps = {}) {
try {
// #1873 T1: the definitions verbs take their own options.
@@ -195,7 +208,7 @@ export async function orgCommand(args, io, deps = {}) {
const instance = devOwnerInstance(io.env); const system = deps.system ?? loadSystem({ env: io.env, instance }); const ctx = { configDir: configDir(io.env), dataRoot: system.dataRoot, instance, principal: DEV_OWNER };
if (words[0] === 'lock' && ['show', 'clear'].includes(words[1]) && words.length === 3) { allowed([], []); result = await orgLock(ctx, words[2], { clear: words[1] === 'clear' }); }
else if (words[0] === 'create' && words.length === 2) { allowed([], ['--from']); result = await createOrg(ctx, words[1], await document(need('--from'))); }
else if (words[0] === 'update' && words.length === 2) { allowed([], ['--from', '--if-revision']); const r = need('--if-revision'); if (!/^[1-9][0-9]*$/.test(r)) throw new CliError('invalid revision', 4); result = await updateOrg(ctx, words[1], await document(need('--from')), { ifRevision: Number(r) }); }
else if (words[0] === 'update' && words.length === 2) { allowed([], ['--from', '--if-revision']); const r = need('--if-revision'); if (!/^[1-9][0-9]*$/.test(r)) throw new CliError('invalid revision', 4); result = await orgUpdate(ctx, words[1], await document(need('--from')), { ifRevision: Number(r) }); }
else if (words[0] === 'archive' && words.length === 2) result = await archiveOrg(ctx, words[1], { ...lifecycle, busStop: busStopForDelete, copyRemote: await (deps.copyRemoteFor ?? copyRemoteFor)(ctx) });
else if (words[0] === 'restore' && words.length === 2) {
const startBus = !p.flags.has('--no-bus');
+117
View File
@@ -0,0 +1,117 @@
// #1873 triage-wiring: the Triage key file's reader, moved out of triage-key.mjs so the Console can
// read the key at each Triage spawn without loading the proxy management client or the proxy lock.
// It imports node built-ins only; packages/webui/tests/triage-wiring.test.mjs fails if the Console's
// Triage modules load model-proxy/src/client.mjs. triage-key.mjs (the owner's key verbs) imports
// these and re-exports what it exported before, so its callers are unchanged.
//
// <configDir>/secrets/triage/model (directory 0700, file 0600, the running user's)
// { version, key, keyId, issuedAt, rotateBy, retiring: [{ key, keyId, issuedAt, retireAt }] }
//
// Messages name files, never values.
import { closeSync, constants, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync } from "node:fs";
import { createHash } from "node:crypto";
import { join } from "node:path";
export const KEY_VERSION = 1;
const FIELDS = Object.freeze(["version", "key", "keyId", "issuedAt", "rotateBy", "retiring"]);
const RETIRING_FIELDS = Object.freeze(["key", "keyId", "issuedAt", "retireAt"]);
const MAX_BYTES = 64 * 1024;
export const MAX_RETIRING = 16;
export const SECRET = /^[A-Za-z0-9_-]{43}$/;
const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
const DAY = /^\d{4}-\d{2}-\d{2}$/;
export class TriageKeyError extends Error {
constructor(code, message, exitCode = 3) {
super(message);
this.name = "TriageKeyError";
this.code = code;
this.exitCode = exitCode;
}
}
export const unreadable = (why) => new TriageKeyError("triage-key-unreadable", `the Triage key store is unreadable: ${why}`);
export const keyIdOf = (key) => createHash("sha256").update(key).digest("hex").slice(0, 12);
export const instanceTag = (configDir) => createHash("sha256").update(configDir).digest("hex").slice(0, 12);
export const keyPrefix = (configDir) => `mst-${instanceTag(configDir)}-triage-`;
const ownKey = (configDir) => (k) => typeof k === "string" && k.startsWith(keyPrefix(configDir)) && SECRET.test(k.slice(keyPrefix(configDir).length));
export function keyPaths(configDir) {
const secrets = join(configDir, "secrets");
const dir = join(secrets, "triage");
return { secrets, dir, file: join(dir, "model") };
}
const plain = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
const exactKeys = (v, keys) => plain(v) && Object.keys(v).length === keys.length && keys.every((k) => Object.hasOwn(v, k));
const canonicalTime = (s) => typeof s === "string" && ISO.test(s) && !Number.isNaN(Date.parse(s)) && new Date(s).toISOString() === s;
const canonicalDay = (s) => typeof s === "string" && DAY.test(s) && !Number.isNaN(Date.parse(`${s}T00:00:00Z`)) && new Date(`${s}T00:00:00Z`).toISOString().slice(0, 10) === s;
export function validRecord(doc, configDir) {
const own = ownKey(configDir);
return exactKeys(doc, FIELDS)
&& doc.version === KEY_VERSION
&& own(doc.key) && doc.keyId === keyIdOf(doc.key)
&& canonicalTime(doc.issuedAt) && canonicalDay(doc.rotateBy)
&& Array.isArray(doc.retiring) && doc.retiring.length <= MAX_RETIRING
&& doc.retiring.every((r) => exactKeys(r, RETIRING_FIELDS) && own(r.key) && r.key !== doc.key && r.keyId === keyIdOf(r.key)
&& canonicalTime(r.issuedAt) && canonicalTime(r.retireAt))
&& new Set(doc.retiring.map((r) => r.key)).size === doc.retiring.length;
}
const uidOf = (opts) => opts.uid ?? process.getuid();
// A real directory, the running user's, mode 0700. Missing: false, or made when `create` is on.
export function checkDir(dir, uid, what, { create }) {
let st;
try { st = lstatSync(dir); }
catch (e) {
if (e.code !== "ENOENT") throw unreadable(`${what} cannot be read`);
if (!create) return false;
try { mkdirSync(dir, { mode: 0o700 }); } catch { throw unreadable(`${what} cannot be made`); }
try {
const fd = openSync(dir, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
try { fchmodSync(fd, 0o700); } finally { closeSync(fd); }
} catch { throw unreadable(`${what} cannot be made`); }
st = lstatSync(dir);
}
if (st.isSymbolicLink()) throw unreadable(`${what} is a link`);
if (!st.isDirectory()) throw unreadable(`${what} is not a directory`);
if (st.uid !== uid) throw unreadable(`${what} is not owned by this user`);
if ((st.mode & 0o777) !== 0o700) throw unreadable(`${what} mode is not 0700`);
return true;
}
export function checkFile(fd, uid, what, fail = unreadable) {
const st = fstatSync(fd);
if (!st.isFile()) throw fail(`${what} is not a regular file`);
if (st.nlink !== 1) throw fail(`${what} has more than one link`);
if (st.uid !== uid) throw fail(`${what} is not owned by this user`);
if ((st.mode & 0o777) !== 0o600) throw fail(`${what} mode is not 0600`);
return st;
}
// The stored record, or null when no key is issued. Throws triage-key-unreadable on anything unsafe.
// opts.uid (both directories and the file) and opts.fileUid (the file only) are test seams for the
// owner checks.
export function readKey(configDir, opts = {}) {
const { secrets, dir, file } = keyPaths(configDir);
const uid = uidOf(opts);
if (!checkDir(secrets, uid, "the secrets directory", { create: false })) return null;
if (!checkDir(dir, uid, "the triage secrets directory", { create: false })) return null;
let fd;
try { fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
catch (e) {
if (e.code === "ENOENT") return null;
if (e.code === "ELOOP") throw unreadable("the key file is a link");
throw unreadable("the key file cannot be opened");
}
try {
const st = checkFile(fd, opts.fileUid ?? uid, "the key file");
if (st.size > MAX_BYTES) throw unreadable("the key file is too large");
let doc;
try { doc = JSON.parse(readFileSync(fd, "utf8")); } catch { throw unreadable("the key file is not JSON"); }
if (!validRecord(doc, configDir)) throw unreadable("the key file does not match the key shape");
return doc;
} finally { closeSync(fd); }
}
+294
View File
@@ -0,0 +1,294 @@
// #1873 triage-key: Triage's own model proxy client key, issued from the owner's terminal
// (design report reports/triage-route-design.md slice 3, Jason's ruling 2026-11-18).
//
// <configDir>/secrets/triage/model (directory 0700, file 0600, the running user's)
// { version, key, keyId, issuedAt, rotateBy, retiring: [{ key, keyId, issuedAt, retireAt }] }
//
// The key is `mst-<instance tag>-triage-<43 base64url>`, where the tag is the first 12 hex of
// sha256(configDir), the tag the instance's own `msk-` sentinel carries. An org bus reconciles only
// its own `mso-<tag>-<org>-key-` names and a no-org bus only `msk-<tag>-`, so neither touches it.
//
// Every proxy write runs under the instance proxy lock (packages/bus/src/proxy-lock.mjs), the lock
// org buses take: read the list, check this instance's sentinel, fence, PUT, read back, confirm.
// The proxy changes first and the file second, as the bus does for an agent key. A crash between
// leaves a key in the Triage namespace that the file does not hold; the next issue, rotate or retire
// removes it, and status names it. A crash after the PUT and before the read-back leaves the lock's
// uncertain fence, which every proxy writer on the instance refuses until a human clears it
// (`mosaic proxy fence clear --proxy-restarted`).
//
// Nothing runs on a timer. rotate records when the old key's grace ends; the key stays in the proxy
// until a later retire, rotate or issue removes it, and status says when that is due. The same goes
// for rotateBy: status marks it due; only rotate replaces the key.
//
// Nothing here prints, logs or records a key. Receipts and output carry key ids only (the first 12
// hex of sha256(key), the id the bus uses). Messages name files and options, never values.
// The Console reads the key at each Triage spawn through triage-key-file.mjs, never this module.
import { closeSync, constants, fchmodSync, fsyncSync, lstatSync, openSync, readdirSync, renameSync, unlinkSync, writeSync } from "node:fs";
import { randomBytes } from "node:crypto";
import { join } from "node:path";
import { isDeepStrictEqual } from "node:util";
import { createProxyLock } from "../../bus/src/proxy-lock.mjs";
import { loadManagementClient } from "../../model-proxy/src/client.mjs";
// #1873 triage-wiring: the key file's reader lives in triage-key-file.mjs (node built-ins only), so
// the Console reads the key without this module's proxy client. Re-exported here unchanged.
import { KEY_VERSION, MAX_RETIRING, SECRET, TriageKeyError, checkDir, checkFile, instanceTag, keyIdOf, keyPaths, keyPrefix, readKey, unreadable, validRecord } from "./triage-key-file.mjs";
export { KEY_VERSION, TriageKeyError, instanceTag, keyIdOf, keyPaths, keyPrefix, readKey, validRecord };
// The org key lifetime and the rotate grace default. The bus holds both as literals
// (packages/bus/src/model-keys.mjs #issue: 30 days to rotateBy; packages/bus/src/runtime.mjs:
// `proxy.rotateGraceMinutes ?? 120`) and exports neither, and this lane may not change the bus.
// packages/cli/tests/triage-key.test.mjs drives the bus's own ModelKeys with the same clock and
// proves these give the same rotateBy and retireAt, so a change on either side goes red there.
// The grace itself is read from proxy.json first, where the bus reads it.
export const KEY_LIFETIME_DAYS = 30;
export const DEFAULT_ROTATE_GRACE_MINUTES = 120;
const sentinelPrefix = (configDir) => `msk-${instanceTag(configDir)}-sentinel-`;
// Any name under the prefix is Triage's to remove, well formed or not, as the bus treats its own
// `msk-<tag>-` names. Only a well-formed key may be stored in the file.
const inNamespace = (configDir) => (k) => typeof k === "string" && k.startsWith(keyPrefix(configDir));
// Both directories, checked (and the triage one made) before any proxy write, so a store that cannot
// be written refuses while the proxy is still untouched.
function prepareDirs(configDir, uid) {
const { secrets, dir } = keyPaths(configDir);
if (!checkDir(secrets, uid, "the secrets directory", { create: false })) throw unreadable("the secrets directory is missing");
checkDir(dir, uid, "the triage secrets directory", { create: true });
}
// A temp file writeKey left when it was killed before its rename. It may hold a key.
const TEMP = /^\.model\.\d+\.[0-9a-f]{12}\.tmp$/;
const tempsIn = (dir) => { try { return readdirSync(dir).filter((n) => TEMP.test(n)); } catch { return []; } };
// Under the lock no other Triage writer runs, so every temp file left in the directory is dead.
function removeTemps(configDir) {
const { dir } = keyPaths(configDir);
for (const name of tempsIn(dir)) {
try { if (!lstatSync(join(dir, name)).isDirectory()) unlinkSync(join(dir, name)); }
catch { throw unreadable("a leftover temp file in the triage secrets directory cannot be removed"); }
}
}
// A directory sync that failed after the rename: the file is in place but may not be durable.
class NotSynced extends Error {}
// Atomic: a 0600 temp file in the same directory, fsync, rename, fsync of the directory.
function writeKey(configDir, record, uid, hook = () => {}) {
const { dir, file } = keyPaths(configDir);
prepareDirs(configDir, uid);
const temp = join(dir, `.model.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
let fd;
try { fd = openSync(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600); }
catch { throw unreadable("the key file cannot be written"); }
try {
try { fchmodSync(fd, 0o600); writeSync(fd, `${JSON.stringify(record, null, 2)}\n`); fsyncSync(fd); }
finally { closeSync(fd); }
hook("rename");
renameSync(temp, file);
} catch { try { unlinkSync(temp); } catch {} throw unreadable("the key file cannot be written"); }
try {
hook("sync");
const dfd = openSync(dir, constants.O_RDONLY | constants.O_DIRECTORY);
try { fsyncSync(dfd); } finally { closeSync(dfd); }
} catch { throw new NotSynced(); }
}
// One line per write in the proxy lock's receipts file, ids only. `receiptsReady` runs under the
// lock before any change, so an unsafe receipts file refuses while nothing has changed yet.
const RECEIPTS_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW | constants.O_NONBLOCK;
const receiptsUnsafe = (why) => new TriageKeyError("triage-key-receipts-unsafe", `${why}; nothing was changed`);
function receiptsReady(stateDir, uid) {
let fd;
try { fd = openSync(join(stateDir, "mosaic-keys.receipts.jsonl"), RECEIPTS_FLAGS, 0o600); }
catch { throw receiptsUnsafe("the proxy receipts file cannot be opened"); }
try { checkFile(fd, uid, "the proxy receipts file", receiptsUnsafe); } finally { closeSync(fd); }
}
function receipt(stateDir, uid, entry) {
const unrecorded = new TriageKeyError("triage-key-unrecorded", "the change was made but its receipt line was not written; run mosaic triage key status");
let fd;
try { fd = openSync(join(stateDir, "mosaic-keys.receipts.jsonl"), RECEIPTS_FLAGS, 0o600); } catch { throw unrecorded; }
try {
checkFile(fd, uid, "the proxy receipts file", () => unrecorded);
writeSync(fd, `${JSON.stringify(entry)}\n`);
fsyncSync(fd);
} catch { throw unrecorded; }
finally { closeSync(fd); }
}
// The grace the bus uses: proxy.json's rotateGraceMinutes, or the bus default.
export const graceMinutes = (proxy) => proxy?.rotateGraceMinutes ?? DEFAULT_ROTATE_GRACE_MINUTES;
export const rotateByFor = (nowMs) => new Date(nowMs + KEY_LIFETIME_DAYS * 86400_000).toISOString().slice(0, 10);
export const retireAtFor = (nowMs, proxy) => new Date(nowMs + graceMinutes(proxy) * 60_000).toISOString();
const proxyFailure = (code) => {
const words = {
"proxy-lock-busy": "another proxy writer holds the instance proxy lock; try again when it ends, and if no writer is running, see mosaic proxy fence status",
"proxy-lock-uncertain": "the instance proxy lock is in a state this verb will not guess about; check <dataRoot>/proxy by hand",
"proxy-lock-invalid": "the instance proxy lock directory is missing or unsafe, or names another proxy",
"proxy-uncertain": "an earlier proxy write has an uncertain outcome; see mosaic proxy fence status",
"proxy-management-key-invalid": "the proxy management key file is missing or unsafe",
"proxy-client-invalid": "the proxy settings are not usable",
"proxy-client-down": "the proxy did not answer",
"proxy-client-refused": "the proxy refused the management request",
"proxy-client-redirect": "the proxy answered with a redirect",
"proxy-client-response": "the proxy gave an answer this verb cannot use",
};
return new TriageKeyError(code, words[code] ?? "the proxy write failed");
};
// opts.uid, opts.now and opts.hook(stage) are test seams; a stage hook may throw or kill the process.
function context({ configDir, system, uid, fileUid, now, hook }) {
if (!system?.proxy || !Number.isInteger(system.proxy.port)) throw new TriageKeyError("triage-key-no-proxy", "the instance has no model proxy set up (proxy.json)");
return {
configDir, dataRoot: system.dataRoot, proxy: system.proxy, stateDir: join(system.dataRoot, "proxy"),
uid: uid ?? process.getuid(), fileUid, now: now ?? Date.now, hook: hook ?? (() => {}),
};
}
function lockFor(c) {
try { return createProxyLock({ stateDir: c.stateDir, identity: `${c.configDir}:${c.proxy.port}` }); }
catch (e) { throw proxyFailure(e.code ?? "proxy-lock-invalid"); }
}
async function clientFor(c) {
try { return await loadManagementClient({ configDir: c.configDir, proxy: c.proxy }); }
catch (e) { throw proxyFailure(e.code ?? "proxy-management-key-invalid"); }
}
function checkSentinel(c, keys) {
const prefix = sentinelPrefix(c.configDir);
if (!keys.some((k) => k.startsWith(prefix) && SECRET.test(k.slice(prefix.length)))) {
throw new TriageKeyError("triage-key-proxy-open", "the proxy's key list has no sentinel for this instance, so it may be another proxy");
}
}
// Under the instance proxy lock: read the list, check the sentinel, run `plan`, write the result.
// `plan(keys, record)` returns { after, record, removed, added, done }; `record` null leaves the
// file alone. The proxy changes first, then the file, then one receipt line.
async function change(c, op, plan) {
const lock = lockFor(c);
const client = await clientFor(c);
try {
return await lock.run(async () => {
const before = await client.getKeys();
checkSentinel(c, before);
const current = readKey(c.configDir, { uid: c.uid, fileUid: c.fileUid });
const result = plan(before, current);
if (result.record) prepareDirs(c.configDir, c.uid);
removeTemps(c.configDir);
receiptsReady(c.stateDir, c.uid);
const after = result.after;
const removed = before.filter((k) => !after.includes(k));
const added = after.filter((k) => !before.includes(k));
// A key in another namespace never leaves the list.
if (removed.some((k) => !inNamespace(c.configDir)(k))) throw new TriageKeyError("triage-key-failed", "the change would remove a key outside the Triage namespace");
if (added.length || removed.length) {
// As the bus does: a list that moved since the first read is not overwritten.
if (!isDeepStrictEqual(await client.getKeys(), before)) throw new TriageKeyError("triage-key-raced", "the proxy's key list changed while this verb ran; run it again");
lock.fence({ org: null, op: `triage.${op}` });
await client.putKeys(after);
c.hook("put");
const confirmed = await client.getKeys();
if (!confirmed.some((k) => k.startsWith(sentinelPrefix(c.configDir))) || added.some((k) => !confirmed.includes(k)) || removed.some((k) => confirmed.includes(k))) {
throw new TriageKeyError("triage-key-unconfirmed", "the proxy did not confirm the change; the instance proxy fence stays set, see mosaic proxy fence status");
}
lock.confirm();
}
c.hook("write");
let unsynced = false;
if (result.record) {
try { writeKey(c.configDir, result.record, c.uid, c.hook); }
catch (e) {
if (e instanceof NotSynced) unsynced = true;
else throw new TriageKeyError("triage-key-unwritten", `the proxy list changed but ${keyPaths(c.configDir).file} was not written (${e.message}); fix the file's directory, then run mosaic triage key ${op} again, which clears what this run left`);
}
}
c.hook("receipt");
// A run that changed neither the proxy nor the file leaves no receipt.
if (added.length || removed.length || result.record) receipt(c.stateDir, c.uid, { op: `triage.key.${op}`, time: new Date(c.now()).toISOString(), addedKeyIds: added.map(keyIdOf), removedKeyIds: removed.map(keyIdOf) });
// The file is in place and the receipt written; only its durability is in doubt.
if (unsynced) throw new TriageKeyError("triage-key-unsynced", `${keyPaths(c.configDir).file} was written but its directory could not be synced, so it may not survive a power loss; run mosaic triage key status`);
return { ...result.done, addedKeyIds: added.map(keyIdOf), removedKeyIds: removed.map(keyIdOf) };
});
} catch (e) {
if (e instanceof TriageKeyError) throw e;
throw proxyFailure(typeof e?.code === "string" && /^proxy-[a-z-]+$/.test(e.code) ? e.code : "triage-key-failed");
}
}
const newKey = (configDir) => keyPrefix(configDir) + randomBytes(32).toString("base64url");
// Keys in the Triage namespace that the file does not hold: left by a crash between the PUT and the
// file write, or by a file that was removed by hand.
const orphansOf = (configDir, keys, record) => {
const held = record ? [record.key, ...record.retiring.map((r) => r.key)] : [];
return keys.filter((k) => inNamespace(configDir)(k) && !held.includes(k));
};
export async function issueKey(opts) {
const c = context(opts);
return change(c, "issue", (before, current) => {
if (current) throw new TriageKeyError("triage-key-issued", "a Triage key is already issued; use mosaic triage key rotate");
const orphans = orphansOf(c.configDir, before, null);
const key = newKey(c.configDir), nowMs = c.now();
const record = { version: KEY_VERSION, key, keyId: keyIdOf(key), issuedAt: new Date(nowMs).toISOString(), rotateBy: rotateByFor(nowMs), retiring: [] };
return { after: [...before.filter((k) => !orphans.includes(k)), key], record, done: { keyId: record.keyId, rotateBy: record.rotateBy } };
});
}
// Retiring keys whose grace has passed, or that the proxy no longer holds.
const dueOf = (record, keys, nowMs) => record.retiring.filter((r) => Date.parse(r.retireAt) <= nowMs || !keys.includes(r.key));
export async function rotateKey(opts) {
const c = context(opts);
return change(c, "rotate", (before, current) => {
if (!current) throw new TriageKeyError("triage-key-not-issued", "no Triage key is issued; use mosaic triage key issue");
const nowMs = c.now();
const orphans = orphansOf(c.configDir, before, current);
const due = dueOf(current, before, nowMs);
const keep = before.includes(current.key);
const retiring = [...current.retiring.filter((r) => !due.includes(r)),
...(keep ? [{ key: current.key, keyId: current.keyId, issuedAt: current.issuedAt, retireAt: retireAtFor(nowMs, c.proxy) }] : [])];
if (retiring.length > MAX_RETIRING) throw new TriageKeyError("triage-key-failed", "too many keys are retiring; run mosaic triage key retire once their grace has passed");
const key = newKey(c.configDir);
const record = { version: KEY_VERSION, key, keyId: keyIdOf(key), issuedAt: new Date(nowMs).toISOString(), rotateBy: rotateByFor(nowMs), retiring };
const drop = [...orphans, ...due.map((r) => r.key)];
return {
after: [...before.filter((k) => !drop.includes(k)), key], record,
done: { keyId: record.keyId, rotateBy: record.rotateBy, old: keep ? { keyId: current.keyId, retireAt: retiring.at(-1).retireAt } : { keyId: current.keyId, lost: true } },
};
});
}
export async function retireKeys(opts) {
const c = context(opts);
return change(c, "retire", (before, current) => {
const nowMs = c.now();
const orphans = orphansOf(c.configDir, before, current);
const due = current ? dueOf(current, before, nowMs) : [];
const record = current && due.length ? { ...current, retiring: current.retiring.filter((r) => !due.includes(r)) } : null;
const drop = [...orphans, ...due.map((r) => r.key)];
return { after: before.filter((k) => !drop.includes(k)), record, done: { droppedKeyIds: due.map((r) => r.keyId) } };
});
}
// Read only: the file, and when the proxy is set up, what its list holds. No lock, no write.
// The fence is checked by name only, so status writes nothing, not even the lock's identity file.
export async function keyStatus(opts) {
const { configDir, system, uid, fileUid } = opts;
const record = readKey(configDir, { uid, fileUid });
const proxy = { state: "not-set-up", fence: false, leftoverTemps: tempsIn(keyPaths(configDir).dir).length };
if (system?.proxy && Number.isInteger(system.proxy.port)) {
try { lstatSync(join(system.dataRoot, "proxy", "mosaic-keys.uncertain")); proxy.fence = true; }
catch (e) { if (e.code !== "ENOENT") proxy.fence = true; }
try {
const client = await loadManagementClient({ configDir, proxy: system.proxy });
const keys = await client.getKeys();
const prefix = sentinelPrefix(configDir);
proxy.state = keys.some((k) => k.startsWith(prefix) && SECRET.test(k.slice(prefix.length))) ? "read" : "no-sentinel";
proxy.holdsKey = record ? keys.includes(record.key) : null;
proxy.retiringHeld = record ? record.retiring.map((r) => keys.includes(r.key)) : [];
proxy.orphanKeyIds = orphansOf(configDir, keys, record).map(keyIdOf);
} catch (e) { proxy.state = "unreadable"; proxy.code = typeof e?.code === "string" && /^proxy-[a-z-]+$/.test(e.code) ? e.code : "proxy-client-response"; }
}
return { record, proxy };
}
+188
View File
@@ -0,0 +1,188 @@
// #1873 triage-route-store: the owner's terminal verbs for the Triage route file,
// <dataRoot>/triage/route.json (packages/webui/src/triage-route-store.mjs).
//
// mosaic triage route show
// mosaic triage route set --model KEY --harness NAME --cap TOKENS --time-zone ZONE [--revision N]
//
// Both are human verbs: an agent run is refused before anything is read (exit 3), from this
// process's environment and the one the command was given, as the bus and Console lifecycle verbs
// refuse it. `show` with no file prints "not set" and exits 0. Without --revision a write
// compares with the revision read under the store's lock; pass --revision from `show` to make the
// write conditional on what was shown (0: only when no route is set yet).
//
// Nothing here wires the route into the Triage host: the Console keeps `route: null` until the
// wiring slice. `set` checks the harness against the repository's harness modules; it does not
// check the model key against a catalogue, since none exists outside an organization's bus yet.
//
// mosaic triage key issue | rotate | retire | status
//
// Triage's own model proxy client key (packages/cli/src/triage-key.mjs). Human verbs as well,
// refused in an agent run before anything is read. No output names a key, only its id.
import { lstatSync } from "node:fs";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { readRoute, RouteStoreError, writeRoute } from "../../webui/src/triage-route-store.mjs";
import { loadSystem } from "./config.mjs";
import { configDir } from "../../organization/src/organization-config.mjs";
import { issueKey, keyPaths, keyStatus, retireKeys, rotateKey, TriageKeyError } from "./triage-key.mjs";
import { CliError } from "./errors.mjs";
import { refuseInsideAgent } from "./transport.mjs";
export const TRIAGE_USAGE = "mosaic triage route show | set --model KEY --harness NAME --cap TOKENS --time-zone ZONE [--revision N] | key issue | rotate | retire | status";
const KEY_VERBS = ["issue", "rotate", "retire", "status"];
const HARNESS_ROOT = fileURLToPath(new URL("../../plugins/harness/", import.meta.url));
const VALUES = ["--model", "--harness", "--cap", "--time-zone", "--revision"];
const WHOLE = /^(0|[1-9][0-9]*)$/;
// The actor every terminal write records: the instance owner, the only person who runs this verb.
const ACTOR = "owner";
const usage = (why) => new CliError(`${why}\nusage: ${TRIAGE_USAGE}`, 4);
// Option names, never values, in a refusal.
function parse(args) {
const values = {}, positional = [];
for (let i = 0; i < args.length; i++) {
const a = args[i];
if (VALUES.includes(a)) {
if (i + 1 >= args.length) throw usage(`${a} needs one value`);
if (Object.hasOwn(values, a)) throw usage(`${a} is given twice`);
values[a] = args[++i];
} else if (a.startsWith("--")) throw usage("unknown option");
else positional.push(a);
}
return { values, positional };
}
function whole(text, name) {
if (!WHOLE.test(text)) throw new CliError(`triage-route-invalid: ${name} must be a whole number`, 2);
return Number(text);
}
function knownHarness(name) {
if (!/^[a-z][a-z0-9-]{0,31}$/.test(name)) return false;
try { return lstatSync(join(HARNESS_ROOT, name, "index.mjs")).isFile(); } catch { return false; }
}
function storeError(error) {
if (!(error instanceof RouteStoreError)) throw error;
return new CliError(`${error.code}: ${error.message}`, error.code === "triage-route-invalid" ? 2 : 3);
}
function show(route) {
if (!route) return "triage route: not set\n";
const { cap } = route;
return [
`triage route: revision ${route.revision}`,
`model: ${route.model}`,
`harness: ${route.harness}`,
`cap: ${cap.limit} tokens a day, resets ${cap.reset} ${cap.timeZone}, counted since ${cap.since}`,
`updated: ${route.updatedAt} by ${route.updatedBy}`,
"",
].join("\n");
}
// A key error prints its code and fixed words. Anything else becomes one fixed line, so no value
// that an unexpected error might carry reaches the terminal.
function keyError(error) {
if (error instanceof CliError) return error;
if (error instanceof TriageKeyError) return new CliError(`${error.code}: ${error.message}`, error.exitCode);
return new CliError("triage-key-failed: the key verb stopped on an unexpected error; run mosaic triage key status", 3);
}
const age = (ms) => {
const m = Math.max(0, Math.floor(ms / 60_000));
return `${Math.floor(m / 1440)}d ${Math.floor((m % 1440) / 60)}h ${m % 60}m`;
};
const ids = (list) => (list.length ? list.join(", ") : "none");
function statusText({ record, proxy }, nowMs, file) {
const lines = [`triage key: ${record ? "issued" : "not issued"}`, `file: ${file}`];
const rotateDue = record && Date.parse(`${record.rotateBy}T00:00:00Z`) <= nowMs;
const retireDue = record ? record.retiring.filter((r) => Date.parse(r.retireAt) <= nowMs) : [];
if (record) {
lines.push(`key id: ${record.keyId}`, `issued: ${record.issuedAt} (age ${age(nowMs - Date.parse(record.issuedAt))})`, `rotate by: ${record.rotateBy}${rotateDue ? " (due)" : ""}`);
record.retiring.forEach((r, i) => {
const held = proxy.retiringHeld?.[i];
lines.push(`retiring: ${r.keyId}, live until a retire after ${r.retireAt}${Date.parse(r.retireAt) <= nowMs ? " (due)" : ""}${held === false ? " (not in the proxy list)" : ""}`);
});
}
const state = {
"not-set-up": "not set up for this instance (no proxy.json)",
"no-sentinel": "its key list has no sentinel for this instance",
unreadable: `not read (${proxy.code})`,
read: record ? (proxy.holdsKey ? "holds the key" : "does not hold the key") : "read",
}[proxy.state];
lines.push(`proxy: ${state}`);
if (proxy.fence) lines.push("proxy fence: set, an earlier proxy write has an uncertain outcome");
if (proxy.leftoverTemps) lines.push(`leftover temp files in the triage secrets directory: ${proxy.leftoverTemps} (the next issue, rotate or retire removes them)`);
if (proxy.orphanKeyIds?.length) lines.push(`keys in the Triage namespace the file does not hold: ${ids(proxy.orphanKeyIds)}`);
let next;
if (proxy.fence) next = "restart the proxy, then mosaic proxy fence clear --proxy-restarted";
else if (proxy.state !== "read") next = proxy.state === "not-set-up" ? "set up the model proxy first (mosaic proxy init)" : "check the proxy with mosaic proxy status";
else if (!record) next = "mosaic triage key issue";
else if (!proxy.holdsKey || rotateDue) next = "mosaic triage key rotate";
else if (retireDue.length || proxy.leftoverTemps || proxy.orphanKeyIds?.length || proxy.retiringHeld?.includes(false)) next = "mosaic triage key retire";
else next = "nothing";
lines.push(`next: ${next}`, "");
return lines.join("\n");
}
async function keyCommand(sub, args, io, deps) {
if (!KEY_VERBS.includes(sub)) throw usage("unknown triage key command");
if (args.length) throw usage(args[0].startsWith("--") ? "unknown option" : "unexpected argument");
try {
const system = deps.system ?? loadSystem({ env: io.env });
const dir = configDir(io.env);
const now = deps.now ? () => deps.now().getTime() : Date.now;
const opts = { configDir: dir, system, now, uid: deps.triageKeyUid, fileUid: deps.triageKeyFileUid, hook: deps.triageKeyHook };
if (sub === "status") {
io.stdout.write(statusText(await keyStatus(opts), now(), keyPaths(dir).file));
return;
}
if (sub === "issue") {
const r = await issueKey(opts);
io.stdout.write(`triage key issued: ${r.keyId}, rotate by ${r.rotateBy}\nfile: ${keyPaths(dir).file}\n`);
if (r.removedKeyIds.length) io.stdout.write(`removed keys this file did not hold: ${ids(r.removedKeyIds)}\n`);
return;
}
if (sub === "rotate") {
const r = await rotateKey(opts);
io.stdout.write(`triage key rotated: ${r.keyId}, rotate by ${r.rotateBy}\n`);
io.stdout.write(r.old.lost
? `old key ${r.old.keyId} was not in the proxy list; nothing to retire\n`
: `old key ${r.old.keyId} stays live until mosaic triage key retire runs at or after ${r.old.retireAt}\n`);
if (r.removedKeyIds.length) io.stdout.write(`removed: ${ids(r.removedKeyIds)}\n`);
return;
}
const r = await retireKeys(opts);
io.stdout.write(r.removedKeyIds.length ? `triage key retire: removed ${ids(r.removedKeyIds)}\n` : "triage key retire: nothing to remove\n");
} catch (e) { throw keyError(e); }
}
export function triageCommand(rest, io, deps = {}) {
refuseInsideAgent(process.env);
refuseInsideAgent(io.env);
const [noun, sub, ...args] = rest;
if (noun === "key" && sub !== undefined) return keyCommand(sub, args, io, deps);
if (noun !== "route" || !["show", "set"].includes(sub)) throw usage("unknown triage command");
const { values, positional } = parse(args);
if (positional.length) throw usage("unexpected argument");
const dataRoot = () => (deps.system ?? loadSystem({ env: io.env })).dataRoot;
if (sub === "show") {
if (Object.keys(values).length) throw usage("show takes no options");
let route;
try { route = readRoute(dataRoot()); } catch (e) { throw storeError(e); }
io.stdout.write(show(route));
return;
}
for (const name of ["--model", "--harness", "--cap", "--time-zone"]) if (!Object.hasOwn(values, name)) throw usage(`set needs ${name}`);
if (!knownHarness(values["--harness"])) throw new CliError("triage-route-invalid: no harness module has that name", 2);
const input = {
model: values["--model"], harness: values["--harness"], limit: whole(values["--cap"], "--cap"),
timeZone: values["--time-zone"], by: ACTOR,
...(Object.hasOwn(values, "--revision") ? { revision: whole(values["--revision"], "--revision") } : {}),
};
let route;
try { route = writeRoute(dataRoot(), input, deps.now ? { now: deps.now } : {}); } catch (e) { throw storeError(e); }
io.stdout.write(`triage route set: revision ${route.revision}\n`);
}
+2 -1
View File
@@ -151,7 +151,8 @@ const log = (f) => readFileSync(launchLogFile(f.dataRoot, "acme"), "utf8").trim(
test('P3 proxy key reaches the spawned runner but never session.json or the bundle', { skip, timeout: 30000 }, async t => {
const proxy = { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' };
const prepared = prepare(t, doc => {
doc.launch.models['claude-opus-5-5'] = { provider: 'proxy', model: 'claude-fixture', route: 'anthropic' };
// #1873 harness-matrix: a Claude route on pi is refused, so the key check rides a non-Claude proxy route.
doc.launch.models['claude-opus-5-5'] = { provider: 'proxy', model: 'fixture-route-model', route: 'glm' };
return doc;
});
const { launcher, f, close } = await setup(t, doc => doc, prepared, { testProxy: proxy });
@@ -21,12 +21,20 @@ const id = value => createHash('sha256').update(value).digest('hex').slice(0,12)
// #774 R2: extra names more harnesses to switch on and load (a fallback route's); real names the
// harnesses loaded as the real module, so their own preflight runs; hostEnv adds launcher env
// such as MOSAIC_CLAUDE_BIN.
// #1873 harness-matrix: an OAuth Claude model runs on claude-code only, so the pi stream case reads
// a non-Claude model the proxy serves in Anthropic format (upstream other) from a stand-in catalogue.
// The chief's model key stays claude-opus-5-5; on pi its upstream model is not a Claude name.
export const PI_CHIEF_MODEL='fixture-chief-model';
const STREAM_OTHER=Object.freeze({provider:'other',model:'fixture-stream-model',module:'cliproxy',upstream:'other'});
const streamCatalogue=()=>({invalidate(){},read:async()=>({status:'ready',observedAt:'2026-11-19T00:00:00.000Z',notices:[],
models:[{key:'other-fixture-stream-model',module:'cliproxy',upstream:'other',provider:'other',model:'fixture-stream-model',label:'other / fixture-stream-model',available:true,reason:'unverified',harnesses:['claude-code','pi']}]})});
export async function managedLaunchFixture(t,{proxy=true,launches=true,refuseProbe=false,harness='pi',bwrap=null,admit=null,extra=[],real=[],hostEnv={},modelStream=null,modelCatalogue=null}={}){
const root=fs.mkdtempSync(join(tmpdir(),'ml653-')),closers=[],history=new Set(['fx653-manage']),proxyReceipts=[],logs=[];
let server,bus,launcher,stderr;const trace={preflightAttempts:0,successfulPreflights:0,enableBeforeSpawn:[],bindings:[],stalls:[],ops:[]};
const checkHistory=entries=>{const text=JSON.stringify(entries);for(const value of history)if(text.includes(value))throw Error('fixture credential leaked');};
t.after(async()=>{const failures=[];for(const close of [...closers].reverse()){try{await close();}catch{failures.push('owned-close');}}try{server?.closeAllConnections();if(server?.listening)await new Promise((resolve,reject)=>server.close(e=>e?reject(e):resolve()));}catch{failures.push('owned-server-close');}try{checkHistory({logs,proxyReceipts,trace});}catch{failures.push('value-free-receipts');}if(stderr)process.stderr.write=stderr;try{fs.rmSync(root,{recursive:true,force:true});}catch{failures.push('owned-root-close');}if(failures.length)throw new AggregateError(failures.map(code=>Error(code)),'owned managed fixture cleanup failed');});
const f=fixture(root,'acme',doc=>{doc.plugins={...doc.plugins,harness:[harness,...extra]};for(const role of Object.values(doc.roles))role.vars={...role.vars,harness};doc.roles.chief.vars.model='claude-opus-5-5';if(modelStream){doc.launch.models['claude-opus-5-5']={provider:'anthropic',model:'claude-opus-5-5'};}return doc;});
const f=fixture(root,'acme',doc=>{doc.plugins={...doc.plugins,harness:[harness,...extra]};for(const role of Object.values(doc.roles))role.vars={...role.vars,harness};doc.roles.chief.vars.model='claude-opus-5-5';if(harness==='pi')doc.launch.models['claude-opus-5-5']={provider:'zai',model:PI_CHIEF_MODEL};if(modelStream){doc.launch.models['claude-opus-5-5']=harness==='pi'?STREAM_OTHER:{provider:'anthropic',model:'claude-opus-5-5'};if(harness==='pi')doc.plugins={...doc.plugins,'model-provider':['cliproxy']};}return doc;});
if(modelStream&&harness==='pi'&&!modelCatalogue)modelCatalogue=streamCatalogue();
const env={PATH:process.env.PATH,HOME:process.env.HOME,TMPDIR:process.env.TMPDIR,MOSAIC_CONFIG:f.config,MOSAIC_ROLES_DIR:f.roles,...hostEnv};
// The nonproxy positive fixture supplies its own fake pi login. Managed
// proxy fixtures deliberately hold no upstream credential at all.
@@ -0,0 +1,93 @@
// #1873 ride-default, re-check 3 P1-1: `mosaic org update` that takes cliproxy off an organization
// records the removal in the instance's proxy receipts before it writes, as the Console's admin save
// does, so Ride all leaves the organization off.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { orgUpdate } from '../src/org.mjs';
import * as orgService from '../../organization/src/org-service.mjs';
import { createProxyAdmin } from '../../model-proxy/src/admin-control.mjs';
import { receiptFile } from '../../model-proxy/src/admin.mjs';
const owner = { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' };
function scratch(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'org-upd-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
return { configDir, dataRoot, instance: 'test', principal: owner };
}
const receipts = dataRoot => { try { return fs.readFileSync(receiptFile(dataRoot), 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse); } catch { return []; } };
const withProviders = (doc, list) => ({ ...doc, plugins: { ...(doc.plugins ?? {}), 'model-provider': list } });
async function cliproxyOrg(ctx, id) {
const doc = withProviders(await orgService.templateRender(id), ['cliproxy']);
await orgService.createOrg(ctx, id, doc);
return orgService.showOrg(ctx, id);
}
test('the reviewer probe: an organization taken off cliproxy by mosaic org update is skipped by Ride all as removed', async t => {
const ctx = scratch(t);
const shown = await cliproxyOrg(ctx, 'cli');
await orgUpdate(ctx, 'cli', withProviders(shown.doc, []), { ifRevision: shown.revision });
assert.deepEqual((await orgService.showOrg(ctx, 'cli')).doc.plugins['model-provider'], []);
assert.deepEqual(receipts(ctx.dataRoot).map(r => [r.op, r.org]), [['ride-removed', 'cli']]);
const writes = [];
const call = async verb => {
if (verb === 'plugins') return { revision: 'r', plugins: { 'model-provider': [] } };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { writes.push('cli'); return { revision: 'r2' }; }
throw new Error(`unexpected ${verb}`);
};
const proxy = createProxyAdmin({ dataRoot: ctx.dataRoot, configDir: ctx.configDir, unit: { unit: 'u', status: async () => ({}) }, buses: async () => ({ stopped: true, running: [] }), fetch: async () => ({}),
riders: async () => [{ id: 'cli', fixture: false, cliproxy: false, changes: '', call }] });
const r = await proxy.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 'cli', reason: 'removed' }]);
assert.deepEqual(writes, []);
});
test('mosaic org update records only a removal of cliproxy, and saves nothing when the record cannot be written', async t => {
const ctx = scratch(t);
const recorded = [];
const record = async id => { recorded.push(id); };
// Keeping cliproxy, or an organization that never had it, records nothing.
let shown = await cliproxyOrg(ctx, 'keep');
await orgUpdate(ctx, 'keep', { ...shown.doc }, { ifRevision: shown.revision, record });
const plain = await orgService.templateRender('plain');
await orgService.createOrg(ctx, 'plain', withProviders(plain, []));
shown = await orgService.showOrg(ctx, 'plain');
await orgUpdate(ctx, 'plain', { ...shown.doc }, { ifRevision: shown.revision, record });
assert.deepEqual(recorded, []);
// A stale revision records nothing and is refused by the service.
shown = await cliproxyOrg(ctx, 'stale');
await assert.rejects(orgUpdate(ctx, 'stale', withProviders(shown.doc, []), { ifRevision: shown.revision + 1, record }), { code: 'revision-conflict' });
assert.deepEqual(recorded, []);
// A record that fails refuses the update: the organization keeps cliproxy, at the same revision.
await assert.rejects(orgUpdate(ctx, 'stale', withProviders(shown.doc, []), { ifRevision: shown.revision, record: async () => { throw Object.assign(new Error('disk full at /x/proxy-admin.jsonl'), { code: 'ENOSPC' }); } }),
err => err.exitCode === 3 && err.message === 'the removal of the model proxy could not be recorded, so nothing was saved');
const after = await orgService.showOrg(ctx, 'stale');
assert.deepEqual(after.doc.plugins['model-provider'], ['cliproxy']); assert.equal(after.revision, shown.revision);
// The removal itself records once, before the write.
await orgUpdate(ctx, 'stale', withProviders(shown.doc, []), { ifRevision: shown.revision, record: async id => { recorded.push(id); assert.deepEqual((await orgService.showOrg(ctx, 'stale')).doc.plugins['model-provider'], ['cliproxy'], 'recorded before the write'); } });
assert.deepEqual(recorded, ['stale']);
});
test('the mosaic org update command records the removal in the instance\'s own proxy receipts', async t => {
const { spawnSync } = await import('node:child_process');
const { resolve } = await import('node:path');
const repo = resolve(import.meta.dirname, '../../..');
const home = fs.mkdtempSync(join(tmpdir(), 'org-upd-cli-'));
t.after(() => fs.rmSync(home, { recursive: true, force: true }));
const env = { ...process.env, HOME: home, MOSAIC_CONFIG: join(home, '.config/mosaic-orgupd/config.json') };
const run = (cmd, ...args) => { const r = spawnSync(join(repo, cmd), args, { cwd: repo, env, encoding: 'utf8' }); assert.equal(r.status, 0, r.stderr); return r.stdout; };
run('scripts/bootstrap.sh', '--instance', 'orgupd');
const on = join(home, 'on.json'), off = join(home, 'off.json');
const doc = withProviders(await orgService.templateRender('cliw'), ['cliproxy']);
fs.writeFileSync(on, JSON.stringify(doc)); fs.writeFileSync(off, JSON.stringify(withProviders(doc, [])));
run('scripts/mosaic', 'org', 'create', 'cliw', '--from', on);
const { revision } = JSON.parse(run('scripts/mosaic', 'org', 'show', 'cliw', '--json'));
run('scripts/mosaic', 'org', 'update', 'cliw', '--from', off, '--if-revision', String(revision));
assert.deepEqual(JSON.parse(run('scripts/mosaic', 'org', 'show', 'cliw', '--json')).doc.plugins['model-provider'], []);
assert.deepEqual(receipts(join(home, '.mosaic-orgupd')).map(r => [r.op, r.org]), [['ride-removed', 'cliw']]);
});
+27 -7
View File
@@ -34,10 +34,11 @@ function privateArtifacts(f, session, keys) {
f.valueFree();
}
// #1873 harness-matrix: an OAuth Claude model runs on claude-code only, so pi joins the z.ai and
// codex routes on a non-Claude model, and a Claude route on pi refuses below.
const ROUTE_MODEL = 'fixture-route-model';
for (const [provider, route, generated, api] of [
['zai', null, 'mosaic-proxy-glm', 'openai-completions'],
['anthropic', null, 'anthropic', 'anthropic-messages'],
['proxy', 'anthropic', 'anthropic', 'anthropic-messages'],
['proxy', 'glm', 'mosaic-proxy-glm', 'openai-completions'],
['proxy', 'codex', 'mosaic-proxy-codex', 'openai-responses'],
]) {
@@ -45,8 +46,7 @@ for (const [provider, route, generated, api] of [
const f = await managedLaunchFixture(t);
assert.deepEqual(f.upstreamCredentialNames, [], 'managed proxy fixture has no inherited fake upstream credential');
editBusiness(f, doc => {
doc.launch.models['claude-opus-5-5'].provider = provider;
if (route) doc.launch.models['claude-opus-5-5'].route = route;
doc.launch.models['claude-opus-5-5'] = { provider, model: ROUTE_MODEL, ...(route ? { route } : {}) };
});
const answer = await f.launcher.launchPm();
const session = f.sessions().find(value => value.run === answer.run);
@@ -69,7 +69,7 @@ for (const [provider, route, generated, api] of [
assert.equal(models.providers[generated].api, api);
assert.equal(models.providers[generated].baseUrl,
other.baseUrl + (api === 'anthropic-messages' ? '' : '/v1'));
assert.equal(models.providers[generated].models.some(model => model.id === 'claude-opus-5-5'), true);
assert.equal(models.providers[generated].models.some(model => model.id === ROUTE_MODEL), true);
for (const value of Object.values(models.providers)) assert.equal(value.apiKey, '$ANTHROPIC_API_KEY');
for (const key of [own.key, other.key]) assert.equal(text.includes(key), false, 'models contain no key value');
assert.equal(fs.statSync(path).mode & 0o777, 0o600);
@@ -79,6 +79,26 @@ for (const [provider, route, generated, api] of [
});
}
// A legacy entry with no provider plugin gets no catalogue check, so a Claude-named model on a z.ai
// or codex route is treated as OAuth too (review P1-1).
for (const [provider, route, name] of [['anthropic', null], ['proxy', 'anthropic'], ['zai', null, 'claude-opus-5-5'], ['proxy', 'glm', 'claude-opus-5-5'], ['proxy', 'codex', 'claude-sonnet-5-5']]) {
test(`#1873 a stored Claude route ${provider}${route ? ':' + route : ''}${name ? ' ' + name : ''} on pi refuses model-harness-incompatible with no key acquisition or session`, { skip, timeout: 30000 }, async t => {
const f = await managedLaunchFixture(t);
editBusiness(f, doc => {
doc.launch.models['claude-opus-5-5'].provider = provider;
if (route) doc.launch.models['claude-opus-5-5'].route = route;
if (name) doc.launch.models['claude-opus-5-5'].model = name;
});
await assert.rejects(f.launcher.launchPm(), error => error.code === 'model-harness-incompatible');
assert.equal(f.trace.preflightAttempts, 0, 'refused before P2 issues a key');
assert.equal(f.trace.bindings.length, 0);
assert.equal(f.sessions().length, 0);
assert.equal(f.runDirectories().length, 0);
assert.equal(f.launchLog().some(e => e.event === 'refused' && e.code === 'model-harness-incompatible'), true);
f.valueFree();
});
}
test('P3 joined Claude harness receives the admitted P2 key only through transient auth env', { skip, timeout: 30000 }, async t => {
const f = await managedLaunchFixture(t, { harness: 'claude-code' });
assert.deepEqual(f.upstreamCredentialNames, [], 'Claude proxy fixture holds no upstream credential');
@@ -117,7 +137,7 @@ test('P3 joined unsupported provider refuses with no key acquisition, fallback,
test('row 332 R2 joined pi launch goes live when launch.models also holds an unroutable entry, which models.json leaves out', { skip, timeout: 30000 }, async t => {
const f = await managedLaunchFixture(t);
editBusiness(f, doc => {
doc.launch.models['claude-opus-5-5'].provider = 'anthropic';
doc.launch.models['claude-opus-5-5'] = { provider: 'zai', model: ROUTE_MODEL };
doc.launch.models.router = { provider: 'openrouter', model: 'x' };
});
const answer = await f.launcher.launchPm();
@@ -126,7 +146,7 @@ test('row 332 R2 joined pi launch goes live when launch.models also holds an unr
assert.equal(f.trace.successfulPreflights, 1);
assert.equal(f.runDirectories().length, 1, 'one run directory, the live one');
const { providers } = JSON.parse(fs.readFileSync(join(session.runDir, 'home', '.pi', 'agent', 'models.json'), 'utf8'));
assert.equal(providers.anthropic.models.some(model => model.id === 'claude-opus-5-5'), true);
assert.equal(providers['mosaic-proxy-glm'].models.some(model => model.id === ROUTE_MODEL), true);
assert.equal(Object.values(providers).some(value => value.models.some(model => model.id === 'x')), false, 'no openrouter entry');
privateArtifacts(f, session, [f.bus.credentials.modelRecord('acme/chief').key]);
});
+695
View File
@@ -0,0 +1,695 @@
// #1873 triage-key: `mosaic triage key issue|rotate|retire|status`, Triage's own model proxy key.
// A stand-in management server on loopback and a temporary config directory only; nothing here
// reads a real config, proxy or secret. Every stdout, stderr, receipt and file the verbs leave is
// scanned for every key the stand-in ever saw, at the end of each test and once more at the end.
import { test } from "node:test";
import assert from "node:assert/strict";
import { spawn, spawnSync } from "node:child_process";
import fs from "node:fs";
import http from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createHash, randomBytes } from "node:crypto";
import { run } from "../src/cli.mjs";
import { AGENT_MARKERS } from "../src/transport.mjs";
import { DEFAULT_ROTATE_GRACE_MINUTES, keyPaths, retireAtFor, rotateByFor } from "../src/triage-key.mjs";
import { ModelKeys } from "../../bus/src/model-keys.mjs";
import { ManagementClient } from "../../model-proxy/src/client.mjs";
import { startBroker } from "../../bus/src/runtime.mjs";
import { busOrganization } from "../../bus/src/organization-context.mjs";
import { Registry } from "../../seat/src/session.mjs";
import { loadBusiness } from "../../organization/src/organization-config.mjs";
import { resolveInstance } from "../../organization/src/resolve.mjs";
import { businessDoc, rolesCopy, systemFor, writeJson } from "../../organization/tests/helpers.mjs";
import { humanEnv, io } from "./helpers.mjs";
const REPO = new URL("../../../", import.meta.url).pathname;
const NOW = Date.parse("2026-11-18T12:00:00.000Z");
const MIN = 60_000, HOUR = 60 * MIN, DAY = 24 * HOUR;
const MANAGE = "fx1873-manage";
const KEY_PATH = "/v8/management/config/access/api-keys";
const sha = (s) => createHash("sha256").update(s).digest("hex");
const tag = (dir) => sha(dir).slice(0, 12);
const id = (key) => sha(key).slice(0, 12);
const b64 = () => randomBytes(32).toString("base64url");
const iso = (ms) => new Date(ms).toISOString();
// Every output any verb produced in this file, and every Triage key the stand-in ever held.
const OUTPUTS = [];
const SEEN = new Set();
const VERBS = ["issue", "rotate", "retire", "status"];
function leaks(text, keys = SEEN) {
for (const key of keys) {
const secret = key.slice(-43);
if (text.includes(key) || text.includes(secret)) return true;
for (let i = 0; i + 8 <= secret.length; i++) if (text.includes(secret.slice(i, i + 8))) return true;
}
return false;
}
function walk(dir, skip, out = []) {
for (const name of fs.readdirSync(dir)) {
const p = join(dir, name), st = fs.lstatSync(p);
if (st.isDirectory()) walk(p, skip, out);
else if (st.isFile() && !skip.includes(p)) out.push(p);
}
return out;
}
async function fixture(t, { sentinel = true } = {}) {
const root = fs.realpathSync(fs.mkdtempSync(join(tmpdir(), "tk-")));
const configDir = join(root, "config");
fs.mkdirSync(join(configDir, "secrets"), { recursive: true, mode: 0o700 });
fs.chmodSync(configDir, 0o700); fs.chmodSync(join(configDir, "secrets"), 0o700);
fs.writeFileSync(join(configDir, "secrets", "proxy-management.key"), MANAGE, { mode: 0o600 });
fs.mkdirSync(join(root, "proxy"), { mode: 0o700 });
const prefix = `mst-${tag(configDir)}-triage-`;
const state = {
keys: [...(sentinel ? [`msk-${tag(configDir)}-sentinel-${b64()}`] : []), "foreign-client-key", `mso-${tag(configDir)}-demo-key-${b64()}`],
gets: 0, puts: [], ignorePut: false, dropSentinelOnPut: false, onGet: null,
};
const server = http.createServer(async (req, res) => {
if (req.url !== KEY_PATH) {
const key = req.headers.authorization?.slice(7);
res.writeHead(state.keys.includes(key) ? 200 : 401); res.end("{}"); return;
}
if (req.headers.authorization !== `Bearer ${MANAGE}`) { res.writeHead(401); res.end("{}"); return; }
if (req.method === "GET") { state.gets++; const body = JSON.stringify(state.keys); state.onGet?.(state.gets); res.end(body); return; }
const chunks = []; for await (const c of req) chunks.push(c);
const next = JSON.parse(Buffer.concat(chunks));
for (const k of next) if (/^mst-.*-[A-Za-z0-9_-]{43}$/.test(k)) SEEN.add(k);
state.puts.push(next);
if (state.dropSentinelOnPut) state.keys = next.filter((k) => !k.startsWith("msk-") || !k.includes("-sentinel-"));
else if (!state.ignorePut) state.keys = next;
res.end('{"status":"ok"}');
});
await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
const port = server.address().port;
const closers = [];
t.after(async () => {
for (const close of closers) await close();
server.closeAllConnections(); await new Promise((resolve) => server.close(resolve));
fs.rmSync(root, { recursive: true, force: true });
});
const f = {
root, configDir, prefix, state, server, port, closers, now: NOW,
system: { dataRoot: root, proxy: { port, binary: "/fixture-unused" } },
file: keyPaths(configDir).file, dir: keyPaths(configDir).dir,
env: (extra = {}) => humanEnv({ MOSAIC_CONFIG: join(configDir, "config.json"), ...extra }),
async cli(argv, { env, deps = {}, system = f.system } = {}) {
const s = io(env ?? f.env());
const code = await run(argv, s, { system, now: () => new Date(f.now), ...deps });
const out = { code, stdout: s.out.text, stderr: s.err.text };
OUTPUTS.push(out.stdout, out.stderr);
return out;
},
// The same verb in a child process that SIGKILLs itself at `stage`.
crash(argv, stage) {
const script = `
import { run } from ${JSON.stringify(new URL("../src/cli.mjs", import.meta.url).href)};
import { io } from ${JSON.stringify(new URL("./helpers.mjs", import.meta.url).href)};
const p = JSON.parse(process.env.TK_CRASH);
const s = io(process.env);
const code = await run(p.argv, s, { system: p.system, now: () => new Date(p.now),
triageKeyHook: (stage) => { if (stage === p.stage) process.kill(process.pid, "SIGKILL"); } });
process.stdout.write(s.out.text); process.stderr.write(s.err.text); process.exitCode = code;`;
const env = f.env({ TK_CRASH: JSON.stringify({ argv, stage, system: f.system, now: f.now }) });
return new Promise((resolve) => {
const child = spawn(process.execPath, ["--input-type=module", "-e", script], { env, stdio: ["ignore", "pipe", "pipe"] });
let stdout = "", stderr = "";
child.stdout.on("data", (d) => { stdout += d; });
child.stderr.on("data", (d) => { stderr += d; });
child.on("exit", (code, signal) => { OUTPUTS.push(stdout, stderr); resolve({ code, signal, stdout, stderr }); });
});
},
record: () => JSON.parse(fs.readFileSync(f.file, "utf8")),
triageKeys: () => state.keys.filter((k) => k.startsWith(prefix)),
receipts: () => {
const file = join(root, "proxy", "mosaic-keys.receipts.jsonl");
return fs.existsSync(file) ? fs.readFileSync(file, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)) : [];
},
fenced: () => fs.existsSync(join(root, "proxy", "mosaic-keys.uncertain")),
// No file under the fixture but the key file itself holds a key; neither does any output.
scan(alsoKeyFiles = []) {
for (const k of state.keys) if (/^mst-.*-[A-Za-z0-9_-]{43}$/.test(k)) SEEN.add(k);
for (const p of walk(root, [f.file, join(configDir, "secrets", "proxy-management.key"), ...alsoKeyFiles])) {
assert.equal(leaks(fs.readFileSync(p, "latin1")), false, `a key is in ${p}`);
}
for (const text of OUTPUTS) assert.equal(leaks(text), false, "a key is in an output");
},
};
return f;
}
const ok = (r) => assert.equal(r.code, 0, r.stderr);
const refusal = (r, code, words) => {
assert.equal(r.code, 3, r.stderr);
assert.equal(r.stdout, "");
assert.match(r.stderr, new RegExp(`^mosaic: ${code}: ${words ?? ""}`));
};
test("issue adds one key under the lock, writes the 0600 file, and records ids only", async (t) => {
const f = await fixture(t);
const before = [...f.state.keys];
const r = await f.cli(["triage", "key", "issue"]);
ok(r);
const rec = f.record();
assert.deepEqual(Object.keys(rec), ["version", "key", "keyId", "issuedAt", "rotateBy", "retiring"]);
assert.match(rec.key, new RegExp(`^${f.prefix}[A-Za-z0-9_-]{43}$`));
assert.equal(rec.keyId, id(rec.key));
assert.equal(rec.issuedAt, iso(NOW));
assert.equal(rec.rotateBy, "2026-12-18");
assert.deepEqual(rec.retiring, []);
assert.equal(r.stdout, `triage key issued: ${rec.keyId}, rotate by 2026-12-18\nfile: ${f.file}\n`);
assert.deepEqual(f.state.keys, [...before, rec.key]);
assert.equal(f.state.puts.length, 1);
const file = fs.lstatSync(f.file), dir = fs.lstatSync(f.dir);
assert.equal(file.mode & 0o777, 0o600); assert.equal(dir.mode & 0o777, 0o700);
assert.equal(file.uid, process.getuid()); assert.equal(dir.uid, process.getuid());
assert.deepEqual(f.receipts(), [{ op: "triage.key.issue", time: iso(NOW), addedKeyIds: [rec.keyId], removedKeyIds: [] }]);
assert.equal(f.fenced(), false);
assert.equal(fs.readFileSync(join(f.root, "proxy", "keys.generation"), "utf8"), "1\n");
// A second issue refuses and changes nothing; rotate is the verb for that.
const again = await f.cli(["triage", "key", "issue"]);
refusal(again, "triage-key-issued", "a Triage key is already issued; use mosaic triage key rotate\n$");
assert.equal(f.state.puts.length, 1);
assert.deepEqual(f.record(), rec);
f.scan();
});
test("status reads the file and the list and writes nothing", async (t) => {
const f = await fixture(t);
const none = await f.cli(["triage", "key", "status"]);
ok(none);
assert.equal(none.stdout, `triage key: not issued\nfile: ${f.file}\nproxy: read\nnext: mosaic triage key issue\n`);
ok(await f.cli(["triage", "key", "issue"]));
const rec = f.record(), puts = f.state.puts.length, receipts = f.receipts().length;
f.now = NOW + 3 * DAY + 4 * HOUR + 5 * MIN;
const shown = await f.cli(["triage", "key", "status"]);
ok(shown);
assert.equal(shown.stdout, [
"triage key: issued", `file: ${f.file}`, `key id: ${rec.keyId}`, `issued: ${iso(NOW)} (age 3d 4h 5m)`,
"rotate by: 2026-12-18", "proxy: holds the key", "next: nothing", "",
].join("\n"));
f.now = Date.parse("2026-12-18T00:00:00.000Z");
assert.match((await f.cli(["triage", "key", "status"])).stdout, /rotate by: 2026-12-18 \(due\)\n[^]*next: mosaic triage key rotate\n$/);
f.now = NOW + HOUR;
f.state.keys = f.state.keys.filter((k) => k !== rec.key);
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy: does not hold the key\nnext: mosaic triage key rotate\n$/);
assert.equal(f.state.puts.length, puts);
assert.equal(f.receipts().length, receipts);
assert.equal(fs.readdirSync(join(f.root, "proxy")).includes("mosaic-keys.lock"), false);
f.scan();
});
test("rotate adds a new key and keeps the old one for the bus grace; retire removes it once due", async (t) => {
const f = await fixture(t);
refusal(await f.cli(["triage", "key", "rotate"]), "triage-key-not-issued", "no Triage key is issued; use mosaic triage key issue\n$");
assert.equal(f.state.puts.length, 0);
ok(await f.cli(["triage", "key", "issue"]));
const first = f.record();
f.now = NOW + HOUR;
const r = await f.cli(["triage", "key", "rotate"]);
ok(r);
const second = f.record();
const retireAt = iso(NOW + HOUR + 120 * MIN);
assert.notEqual(second.key, first.key);
assert.equal(second.issuedAt, iso(NOW + HOUR));
assert.deepEqual(second.retiring, [{ key: first.key, keyId: first.keyId, issuedAt: first.issuedAt, retireAt }]);
assert.equal(r.stdout, `triage key rotated: ${second.keyId}, rotate by 2026-12-18\nold key ${first.keyId} stays live until mosaic triage key retire runs at or after ${retireAt}\n`);
assert.deepEqual(f.triageKeys(), [first.key, second.key]);
f.now = NOW + HOUR + 119 * MIN;
const early = await f.cli(["triage", "key", "retire"]);
ok(early);
assert.equal(early.stdout, "triage key retire: nothing to remove\n");
assert.equal(f.state.puts.length, 2);
assert.match((await f.cli(["triage", "key", "status"])).stdout, new RegExp(`retiring: ${first.keyId}, live until a retire after ${retireAt}\\n[^]*next: nothing\\n$`));
f.now = NOW + HOUR + 120 * MIN;
assert.match((await f.cli(["triage", "key", "status"])).stdout, new RegExp(`retiring: ${first.keyId}, live until a retire after ${retireAt} \\(due\\)\\n[^]*next: mosaic triage key retire\\n$`));
const done = await f.cli(["triage", "key", "retire"]);
ok(done);
assert.equal(done.stdout, `triage key retire: removed ${first.keyId}\n`);
assert.deepEqual(f.triageKeys(), [second.key]);
assert.deepEqual(f.record(), { ...second, retiring: [] });
assert.deepEqual(f.receipts().map((e) => e.op), ["triage.key.issue", "triage.key.rotate", "triage.key.retire"]);
assert.deepEqual(f.receipts()[2].removedKeyIds, [first.keyId]);
f.scan();
});
test("rotate takes the grace from proxy.json, where the bus reads it, and drops an old key the proxy lost", async (t) => {
const f = await fixture(t);
f.system = { ...f.system, proxy: { ...f.system.proxy, rotateGraceMinutes: 30 } };
ok(await f.cli(["triage", "key", "issue"]));
const first = f.record();
ok(await f.cli(["triage", "key", "rotate"]));
const second = f.record();
assert.equal(second.retiring[0].retireAt, iso(NOW + 30 * MIN));
// The proxy lost the current key: rotate drops it at once, as the bus does for an agent key.
f.state.keys = f.state.keys.filter((k) => k !== second.key);
const r = await f.cli(["triage", "key", "rotate"]);
ok(r);
assert.match(r.stdout, new RegExp(`old key ${second.keyId} was not in the proxy list; nothing to retire\\n$`));
assert.deepEqual(f.record().retiring.map((e) => e.keyId), [first.keyId]);
// A retiring key past its time, or no longer in the list, leaves on the next rotate.
f.now = NOW + 31 * MIN;
ok(await f.cli(["triage", "key", "rotate"]));
const last = f.record();
assert.deepEqual(last.retiring.map((e) => e.keyId), [id(f.triageKeys()[0])]);
assert.equal(f.triageKeys().includes(first.key), false);
assert.equal(f.triageKeys().length, 2);
f.scan();
});
test("lifetime and grace match the bus's own ModelKeys for the same clock and proxy settings", async (t) => {
const runtime = fs.readFileSync(join(REPO, "packages/bus/src/runtime.mjs"), "utf8");
const literal = runtime.match(/rotateGraceMinutes: proxy\.rotateGraceMinutes \?\? (\d+)/);
assert.ok(literal, "the bus no longer reads rotateGraceMinutes as this test expects");
assert.equal(Number(literal[1]), DEFAULT_ROTATE_GRACE_MINUTES);
for (const grace of [undefined, 45]) {
const f = await fixture(t);
if (grace !== undefined) f.system = { ...f.system, proxy: { ...f.system.proxy, rotateGraceMinutes: grace } };
ok(await f.cli(["triage", "key", "issue"]));
f.now = NOW + 3 * HOUR;
ok(await f.cli(["triage", "key", "rotate"]));
const ours = f.record();
// The bus, driven the way runtime.mjs drives it, on its own in-memory list.
let keys = [`msk-${tag(f.configDir)}-sentinel-${b64()}`], record = null, now = NOW;
const credentials = { registerModel() {}, modelRecord: () => record, writeModel: (_, r) => { record = r; }, status: () => [] };
const client = { getKeys: async () => [...keys], putKeys: async (k) => { keys = [...k]; return { ok: true }; } };
const bus = new ModelKeys({ credentials, client, configDir: f.configDir, baseUrl: "http://127.0.0.1:1", now: () => now,
...(grace === undefined ? {} : { rotateGraceMinutes: f.system.proxy.rotateGraceMinutes ?? Number(literal[1]) }) });
await bus.reconcile();
await bus.ensure("demo/x");
assert.equal(record.rotateBy, rotateByFor(NOW));
now = NOW + 3 * HOUR;
await bus.rotate("demo/x");
assert.equal(ours.rotateBy, record.rotateBy);
assert.equal(ours.retiring[0].retireAt, record.retiring[0].retireAt);
assert.equal(ours.retiring[0].retireAt, retireAtFor(now, f.system.proxy));
f.scan();
}
});
test("an agent caller is refused before anything is read, for every key verb", async (t) => {
const f = await fixture(t);
for (const marker of AGENT_MARKERS) {
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb], { env: { ...f.env(), [marker]: "1" } });
assert.equal(r.code, 3, marker);
assert.equal(r.stderr, `mosaic: refused: this runs only from a human shell, outside any agent run (found ${marker} in the environment)\n`);
}
const saved = process.env[marker];
process.env[marker] = "1";
try {
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb]);
assert.equal(r.code, 3, marker);
assert.match(r.stderr, new RegExp(`found ${marker} in the environment`));
}
} finally { if (saved === undefined) delete process.env[marker]; else process.env[marker] = saved; }
}
assert.equal(f.state.gets, 0);
assert.equal(f.state.puts.length, 0);
assert.equal(fs.existsSync(f.dir), false);
assert.deepEqual(fs.readdirSync(join(f.root, "proxy")), []);
});
test("usage: unknown key verbs, options and arguments exit 4 and echo no value", async (t) => {
const f = await fixture(t);
for (const argv of [["triage", "key"], ["triage", "key", "nope"], ["triage", "key", "issue", "extra"], ["triage", "key", "status", "--json"]]) {
const r = await f.cli(argv);
assert.equal(r.code, 4, argv.join(" "));
assert.equal(r.stdout, "");
assert.match(r.stderr, /\nusage: mosaic triage route show [^\n]*\| key issue \| rotate \| retire \| status\n$/);
}
const r = await f.cli(["triage", "key", "rotate", "--key", "secret-value"]);
assert.equal(r.code, 4);
assert.match(r.stderr, /^mosaic: unknown option\n/);
assert.doesNotMatch(r.stderr, /secret-value/);
assert.equal(f.state.gets, 0);
});
test("an unsafe key store refuses every verb before any proxy write", async (t) => {
const uid = process.getuid();
const cases = [
["file mode", (f) => fs.chmodSync(f.file, 0o644), {}, "the key file mode is not 0600"],
["file owner", () => {}, { triageKeyFileUid: uid + 1 }, "the key file is not owned by this user"],
["file link", (f) => { fs.renameSync(f.file, join(f.dir, "real")); fs.symlinkSync(join(f.dir, "real"), f.file); }, {}, "the key file is a link"],
["file is a directory", (f) => { fs.rmSync(f.file); fs.mkdirSync(f.file, { mode: 0o700 }); }, {}, "the key file is not a regular file"],
["file is a FIFO", (f) => { fs.rmSync(f.file); assert.equal(spawnSync("mkfifo", ["-m", "600", f.file]).status, 0); }, {}, "the key file is not a regular file"],
["hard link", (f) => fs.linkSync(f.file, join(f.dir, "second")), {}, "the key file has more than one link"],
["not JSON", (f) => fs.writeFileSync(f.file, "{"), {}, "the key file is not JSON"],
["extra field", (f) => fs.writeFileSync(f.file, JSON.stringify({ ...f.record(), extra: 1 })), {}, "the key file does not match the key shape"],
["another instance's key", (f) => { const r = f.record(); const key = `mst-${tag("/elsewhere")}-triage-${b64()}`; fs.writeFileSync(f.file, JSON.stringify({ ...r, key, keyId: id(key) })); }, {}, "the key file does not match the key shape"],
["wrong key id", (f) => fs.writeFileSync(f.file, JSON.stringify({ ...f.record(), keyId: "000000000000" })), {}, "the key file does not match the key shape"],
["too large", (f) => fs.writeFileSync(f.file, " ".repeat(64 * 1024 + 1)), {}, "the key file is too large"],
["triage directory mode", (f) => fs.chmodSync(f.dir, 0o755), {}, "the triage secrets directory mode is not 0700"],
["triage directory link", (f) => { fs.renameSync(f.dir, join(f.configDir, "secrets", "moved")); fs.symlinkSync(join(f.configDir, "secrets", "moved"), f.dir); }, {}, "the triage secrets directory is a link"],
["triage directory is a file", (f) => { fs.rmSync(f.dir, { recursive: true }); fs.writeFileSync(f.dir, "", { mode: 0o600 }); }, {}, "the triage secrets directory is not a directory"],
["secrets mode", (f) => fs.chmodSync(join(f.configDir, "secrets"), 0o750), {}, "the secrets directory mode is not 0700"],
["owner", () => {}, { triageKeyUid: uid + 1 }, "the secrets directory is not owned by this user"],
];
for (const [name, spoil, deps, words] of cases) {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "issue"]));
spoil(f);
const keys = [...f.state.keys], puts = f.state.puts.length;
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb], { deps });
refusal(r, "triage-key-unreadable", `the Triage key store is unreadable: ${words.replace(/[.()]/g, "\\$&")}\n$`);
assert.equal(f.state.puts.length, puts, `${name}: ${verb}`);
}
assert.deepEqual(f.state.keys, keys);
// The spoils above move or link the key file itself; those copies are the key file.
f.scan([join(f.dir, "real"), join(f.dir, "second"), join(f.configDir, "secrets", "moved", "model")]);
}
// No secrets directory at all: status says not issued; issue refuses before the proxy changes.
const f = await fixture(t);
fs.rmSync(join(f.configDir, "secrets"), { recursive: true });
fs.mkdirSync(join(f.configDir, "secrets"), { mode: 0o700 });
fs.writeFileSync(join(f.configDir, "secrets", "proxy-management.key"), MANAGE, { mode: 0o600 });
fs.chmodSync(join(f.configDir, "secrets"), 0o755);
refusal(await f.cli(["triage", "key", "issue"]), "triage-key-unreadable", "the Triage key store is unreadable: the secrets directory mode is not 0700\n$");
assert.equal(f.state.puts.length, 0);
});
test("the instance proxy lock, the fence, the sentinel and the proxy itself each refuse plainly", async (t) => {
// Lock held by a live process: busy after the lock's wait, and nothing changes.
const f = await fixture(t);
const lockFile = join(f.root, "proxy", "mosaic-keys.lock");
ok(await f.cli(["triage", "key", "status"]));
fs.writeFileSync(lockFile, `${JSON.stringify({ pid: process.pid, token: "a".repeat(32) })}\n`, { mode: 0o600 });
const busy = await f.cli(["triage", "key", "issue"]);
refusal(busy, "proxy-lock-busy", "another proxy writer holds the instance proxy lock; try again when it ends, and if no writer is running, see mosaic proxy fence status\n$");
assert.equal(f.state.gets, 1);
// A lock left by a process that is gone is reaped, and the verb goes ahead.
const dead = spawnSync(process.execPath, ["-e", ""]).pid;
fs.writeFileSync(lockFile, `${JSON.stringify({ pid: dead, token: "b".repeat(32) })}\n`, { mode: 0o600 });
ok(await f.cli(["triage", "key", "issue"]));
assert.equal(fs.existsSync(lockFile), false);
assert.equal(f.triageKeys().length, 1);
fs.rmSync(f.file);
f.state.keys = f.state.keys.filter((k) => !k.startsWith(f.prefix));
// A set fence: every write refuses, status names it and the way out.
const putsBefore = f.state.puts.length;
fs.writeFileSync(join(f.root, "proxy", "mosaic-keys.uncertain"), "{}\n", { mode: 0o600 });
for (const verb of ["issue", "rotate", "retire"]) refusal(await f.cli(["triage", "key", verb]), "proxy-uncertain");
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy fence: set, an earlier proxy write has an uncertain outcome\nnext: restart the proxy, then mosaic proxy fence clear --proxy-restarted\n$/);
assert.equal(f.state.puts.length, putsBefore);
// No sentinel for this instance (another instance's does not count).
const g = await fixture(t, { sentinel: false });
g.state.keys.push(`msk-${tag("/elsewhere")}-sentinel-${b64()}`);
refusal(await g.cli(["triage", "key", "issue"]), "triage-key-proxy-open");
assert.match((await g.cli(["triage", "key", "status"])).stdout, /proxy: its key list has no sentinel for this instance\nnext: check the proxy with mosaic proxy status\n$/);
assert.equal(g.state.puts.length, 0);
// No proxy set up, no management key, proxy down.
const h = await fixture(t);
const bare = { dataRoot: h.root };
refusal(await h.cli(["triage", "key", "issue"], { system: bare }), "triage-key-no-proxy");
assert.equal((await h.cli(["triage", "key", "status"], { system: bare })).stdout,
`triage key: not issued\nfile: ${h.file}\nproxy: not set up for this instance (no proxy.json)\nnext: set up the model proxy first (mosaic proxy init)\n`);
fs.chmodSync(join(h.configDir, "secrets", "proxy-management.key"), 0o644);
refusal(await h.cli(["triage", "key", "issue"]), "proxy-management-key-invalid");
fs.chmodSync(join(h.configDir, "secrets", "proxy-management.key"), 0o600);
h.server.closeAllConnections(); await new Promise((resolve) => h.server.close(resolve));
h.server.close = (cb) => cb();
refusal(await h.cli(["triage", "key", "issue"]), "proxy-client-down");
assert.match((await h.cli(["triage", "key", "status"])).stdout, /proxy: not read \(proxy-client-down\)\n/);
assert.equal(fs.existsSync(h.file), false);
f.scan(); g.scan(); h.scan();
});
test("a write the proxy does not confirm keeps the fence; a list that moves mid-verb is not overwritten", async (t) => {
const f = await fixture(t);
f.state.ignorePut = true;
refusal(await f.cli(["triage", "key", "issue"]), "triage-key-unconfirmed");
assert.equal(f.fenced(), true);
assert.equal(fs.existsSync(f.file), false);
// The store's directory was made and checked before the proxy changed, not after.
assert.equal(fs.lstatSync(f.dir).mode & 0o777, 0o700);
assert.deepEqual(f.receipts(), []);
// A PUT the proxy takes but whose read-back has lost this instance's sentinel is not confirmed.
const s = await fixture(t);
s.state.dropSentinelOnPut = true;
refusal(await s.cli(["triage", "key", "issue"]), "triage-key-unconfirmed");
assert.equal(s.fenced(), true);
assert.equal(fs.existsSync(s.file), false);
s.scan();
const g = await fixture(t);
g.state.onGet = (n) => { if (n === 1) g.state.keys = [...g.state.keys, "late-foreign-key"]; };
refusal(await g.cli(["triage", "key", "issue"]), "triage-key-raced");
assert.equal(g.state.puts.length, 0);
assert.equal(g.fenced(), false);
f.scan(); g.scan();
});
test("keys outside the Triage namespace are never touched; Triage keys the file does not hold are removed", async (t) => {
const f = await fixture(t);
const agent = `msk-${tag(f.configDir)}-${b64()}`, other = `mst-${tag("/elsewhere")}-triage-${b64()}`;
const orphan = `${f.prefix}${b64()}`, odd = `${f.prefix}short`;
f.state.keys.push(agent, other, orphan, odd);
const foreign = f.state.keys.filter((k) => k !== orphan && k !== odd);
const r = await f.cli(["triage", "key", "issue"]);
ok(r);
// A malformed name under the Triage prefix is still Triage's, as the bus treats its own prefix.
assert.match(r.stdout, new RegExp(`removed keys this file did not hold: ${id(orphan)}, ${id(odd)}\\n$`));
for (const verb of ["rotate", "retire"]) { f.now += 3 * HOUR; ok(await f.cli(["triage", "key", verb])); }
for (const k of foreign) assert.ok(f.state.keys.includes(k), "a key outside the namespace left the list");
assert.equal(f.state.keys.includes(orphan), false);
assert.equal(f.state.keys.includes(odd), false);
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("crash after the PUT, before the read-back: the fence holds; status says so; clear, then issue recovers", async (t) => {
const f = await fixture(t);
const crashed = await f.crash(["triage", "key", "issue"], "put");
assert.equal(crashed.signal, "SIGKILL");
assert.equal(f.fenced(), true);
assert.equal(f.triageKeys().length, 1);
assert.equal(fs.existsSync(f.file), false);
const status = await f.cli(["triage", "key", "status"]);
ok(status);
assert.match(status.stdout, new RegExp(`proxy fence: set[^\\n]*\\nkeys in the Triage namespace the file does not hold: ${id(f.triageKeys()[0])}\\nnext: restart the proxy, then mosaic proxy fence clear --proxy-restarted\\n$`));
refusal(await f.cli(["triage", "key", "issue"]), "proxy-uncertain");
ok(await f.cli(["proxy", "fence", "clear", "--proxy-restarted"]));
assert.equal(f.fenced(), false);
const stray = f.triageKeys()[0];
const r = await f.cli(["triage", "key", "issue"]);
ok(r);
assert.match(r.stdout, new RegExp(`removed keys this file did not hold: ${id(stray)}\\n$`));
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("crash after the read-back, before the file write: no fence; status names the stray key; issue removes it", async (t) => {
const f = await fixture(t);
assert.equal((await f.crash(["triage", "key", "issue"], "write")).signal, "SIGKILL");
assert.equal(f.fenced(), false);
assert.equal(fs.existsSync(f.file), false);
const [stray] = f.triageKeys();
assert.match((await f.cli(["triage", "key", "status"])).stdout,
new RegExp(`^triage key: not issued\\n[^]*keys in the Triage namespace the file does not hold: ${id(stray)}\\nnext: mosaic triage key issue\\n$`));
ok(await f.cli(["triage", "key", "issue"]));
assert.deepEqual(f.triageKeys(), [f.record().key]);
// The same crash in rotate: the file keeps the old key, the stray new one is named, retire removes it.
const held = f.record();
assert.equal((await f.crash(["triage", "key", "rotate"], "write")).signal, "SIGKILL");
assert.deepEqual(f.record(), held);
const strayNew = f.triageKeys().find((k) => k !== held.key);
assert.match((await f.cli(["triage", "key", "status"])).stdout,
new RegExp(`proxy: holds the key\\nkeys in the Triage namespace the file does not hold: ${id(strayNew)}\\nnext: mosaic triage key retire\\n$`));
const retired = await f.cli(["triage", "key", "retire"]);
ok(retired);
assert.equal(retired.stdout, `triage key retire: removed ${id(strayNew)}\n`);
assert.deepEqual(f.triageKeys(), [held.key]);
f.scan();
});
test("file written but the old key not yet retired: status shows it due; a crash inside retire recovers on the next retire", async (t) => {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "issue"]));
const first = f.record();
ok(await f.cli(["triage", "key", "rotate"]));
f.now = NOW + 121 * MIN;
assert.match((await f.cli(["triage", "key", "status"])).stdout, new RegExp(`retiring: ${first.keyId}, live until a retire after [^\\n]* \\(due\\)\\n[^]*next: mosaic triage key retire\\n$`));
// retire dies after the proxy dropped the key but before the file was rewritten.
assert.equal((await f.crash(["triage", "key", "retire"], "write")).signal, "SIGKILL");
assert.equal(f.state.keys.includes(first.key), false);
assert.equal(f.record().retiring.length, 1);
assert.match((await f.cli(["triage", "key", "status"])).stdout, /\(due\) \(not in the proxy list\)\n[^]*next: mosaic triage key retire\n$/);
const puts = f.state.puts.length;
const r = await f.cli(["triage", "key", "retire"]);
ok(r);
assert.equal(f.state.puts.length, puts);
assert.deepEqual(f.record().retiring, []);
// And a retire killed after its PUT leaves the fence, like any other write.
ok(await f.cli(["triage", "key", "rotate"]));
f.now += 121 * MIN;
assert.equal((await f.crash(["triage", "key", "retire"], "put")).signal, "SIGKILL");
assert.equal(f.fenced(), true);
refusal(await f.cli(["triage", "key", "retire"]), "proxy-uncertain");
ok(await f.cli(["proxy", "fence", "clear", "--proxy-restarted"]));
ok(await f.cli(["triage", "key", "retire"]));
assert.deepEqual(f.record().retiring, []);
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("a file that cannot be written after the proxy changed is reported with its recovery", async (t) => {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "status"]));
fs.mkdirSync(f.dir, { mode: 0o700 });
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "write") fs.chmodSync(f.dir, 0o755); } } });
refusal(r, "triage-key-unwritten", "the proxy list changed but ");
assert.match(r.stderr, /run mosaic triage key issue again, which clears what this run left\n$/);
assert.equal(f.triageKeys().length, 1);
fs.chmodSync(f.dir, 0o700);
ok(await f.cli(["triage", "key", "issue"]));
assert.deepEqual(f.triageKeys(), [f.record().key]);
f.scan();
});
test("crash after the temp file, before its rename: status counts it; the next verb removes it", async (t) => {
const f = await fixture(t);
assert.equal((await f.crash(["triage", "key", "issue"], "rename")).signal, "SIGKILL");
assert.equal(fs.existsSync(f.file), false);
const temps = fs.readdirSync(f.dir).filter((n) => n.endsWith(".tmp"));
assert.equal(temps.length, 1);
assert.match(temps[0], /^\.model\.\d+\.[0-9a-f]{12}\.tmp$/);
// The temp file holds the key the proxy now has; that is why it must go.
const [stray] = f.triageKeys();
assert.ok(fs.readFileSync(join(f.dir, temps[0]), "utf8").includes(stray));
const status = await f.cli(["triage", "key", "status"]);
ok(status);
assert.match(status.stdout, new RegExp(`leftover temp files in the triage secrets directory: 1 \\(the next issue, rotate or retire removes them\\)\\nkeys in the Triage namespace the file does not hold: ${id(stray)}\\nnext: mosaic triage key issue\\n$`));
// Something else in the directory is not a leftover and stays.
fs.writeFileSync(join(f.dir, "notes.tmp"), "", { mode: 0o600 });
ok(await f.cli(["triage", "key", "issue"]));
assert.deepEqual(fs.readdirSync(f.dir).sort(), ["model", "notes.tmp"]);
assert.deepEqual(f.triageKeys(), [f.record().key]);
// Retire, with nothing else to do, still removes a leftover.
assert.equal((await f.crash(["triage", "key", "rotate"], "rename")).signal, "SIGKILL");
ok(await f.cli(["triage", "key", "retire"]));
assert.deepEqual(fs.readdirSync(f.dir).sort(), ["model", "notes.tmp"]);
assert.doesNotMatch((await f.cli(["triage", "key", "status"])).stdout, /leftover/);
f.scan();
});
test("the receipts file is checked before the proxy changes; a receipt that fails after is named", async (t) => {
const receipts = (f) => join(f.root, "proxy", "mosaic-keys.receipts.jsonl");
const spoils = [
["mode", (f) => { fs.writeFileSync(receipts(f), "", { mode: 0o644 }); fs.chmodSync(receipts(f), 0o644); }, "the proxy receipts file mode is not 0600"],
["link", (f) => { fs.writeFileSync(join(f.root, "elsewhere"), "", { mode: 0o600 }); fs.symlinkSync(join(f.root, "elsewhere"), receipts(f)); }, "the proxy receipts file cannot be opened"],
["FIFO", (f) => assert.equal(spawnSync("mkfifo", ["-m", "600", receipts(f)]).status, 0), "the proxy receipts file cannot be opened"],
];
for (const [name, spoil, words] of spoils) {
const f = await fixture(t);
spoil(f);
refusal(await f.cli(["triage", "key", "issue"]), "triage-key-receipts-unsafe", `${words}; nothing was changed\n$`);
assert.equal(f.state.puts.length, 0, name);
assert.equal(f.fenced(), false, name);
assert.equal(fs.existsSync(f.file), false, name);
f.scan();
}
// Safe before the change, unsafe at the receipt: the change stands and the refusal says so.
const f = await fixture(t);
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "receipt") fs.chmodSync(receipts(f), 0o644); } } });
refusal(r, "triage-key-unrecorded", "the change was made but its receipt line was not written; run mosaic triage key status\n$");
assert.deepEqual(f.triageKeys(), [f.record().key]);
assert.equal(f.fenced(), false);
assert.equal(fs.readFileSync(receipts(f), "utf8"), "");
f.scan();
});
test("a directory sync that fails after the rename is named, and the receipt is still written", async (t) => {
const f = await fixture(t);
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "sync") throw new Error("EIO"); } } });
refusal(r, "triage-key-unsynced", `${f.file.replace(/[.]/g, "\\.")} was written but its directory could not be synced, so it may not survive a power loss; run mosaic triage key status\n$`);
const rec = f.record();
assert.deepEqual(f.triageKeys(), [rec.key]);
assert.deepEqual(f.receipts().map((e) => e.addedKeyIds), [[rec.keyId]]);
assert.equal(f.fenced(), false);
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy: holds the key\nnext: nothing\n$/);
f.scan();
});
test("an unexpected error prints fixed words, never the error's own text", async (t) => {
const f = await fixture(t);
const secret = `mst-${tag(f.configDir)}-triage-${b64()}`;
SEEN.add(secret);
// Outside the proxy write: the verb's own fallback line.
const broken = { dataRoot: f.root, get proxy() { throw new Error(`boom ${secret}`); } };
for (const verb of VERBS) {
const r = await f.cli(["triage", "key", verb], { system: broken });
assert.equal(r.code, 3, verb);
assert.equal(r.stderr, "mosaic: triage-key-failed: the key verb stopped on an unexpected error; run mosaic triage key status\n");
}
// Inside the proxy write: the write's own fixed line, and the fence stays for a human.
const r = await f.cli(["triage", "key", "issue"], { deps: { triageKeyHook: (stage) => { if (stage === "put") throw new Error(`boom ${secret}`); } } });
refusal(r, "triage-key-failed", "the proxy write failed\n$");
assert.equal(f.fenced(), true);
f.scan();
});
// The org bus reconciles its own `mso-` namespace at start and a no-org bus its `msk-` one; a
// Triage key sits in neither, so both leave it. Stray keys in each namespace show the reconcile ran.
test("an org bus that starts and reconciles, and a no-org reconcile, both leave the Triage key alone", async (t) => {
const f = await fixture(t);
ok(await f.cli(["triage", "key", "issue"]));
const triage = f.record().key;
const strayOrg = `mso-${tag(f.configDir)}-demo-key-${b64()}`;
f.state.keys.push(strayOrg);
const rolesDir = rolesCopy(f.root), system = systemFor(f.root), doc = businessDoc(f.root, "demo");
doc.plugins = { ...doc.plugins, harness: ["pi"] };
const file = writeJson(join(f.configDir, "businesses", "demo.json"), doc);
assert.ok(file);
const business = loadBusiness("demo", { dir: f.configDir, rolesDir }), resolved = {};
for (const instance of Object.keys(business.roles)) resolved[instance] = resolveInstance({ system, business, instance });
fs.mkdirSync(join(f.root, "data"), { mode: 0o700 });
new Registry(join(f.root, "data"));
const bus = await startBroker({ dataRoot: join(f.root, "data"), businesses: { demo: busOrganization(business, resolved) },
organization: { dir: f.configDir, rolesDir, system }, proxy: { port: f.port, binary: "/fixture-unused" },
org: { id: "demo" }, instanceDataRoot: f.root, instanceConfigDir: f.configDir });
f.closers.push(() => bus.close());
const orgKey = (await bus.modelPreflight({ business: "demo", role: "chief" })).key;
assert.ok(orgKey.startsWith(`mso-${tag(f.configDir)}-demo-key-`));
assert.equal(f.state.keys.includes(strayOrg), false, "the org reconcile did not run");
assert.ok(f.state.keys.includes(triage), "the org bus removed the Triage key");
// A no-org reconcile on the same instance.
const strayAgent = `msk-${tag(f.configDir)}-${b64()}`;
f.state.keys.push(strayAgent);
const client = new ManagementClient({ baseUrl: `http://127.0.0.1:${f.port}`, key: MANAGE });
const keys = new ModelKeys({ credentials: { status: () => [], modelRecord: () => null }, client, configDir: f.configDir, baseUrl: `http://127.0.0.1:${f.port}` });
await keys.reconcile();
assert.equal(f.state.keys.includes(strayAgent), false, "the no-org reconcile did not run");
assert.ok(f.state.keys.includes(triage), "the no-org reconcile removed the Triage key");
// Triage still works under the shared lock while the org bus runs, and leaves the org key.
f.now += HOUR;
ok(await f.cli(["triage", "key", "rotate"]));
assert.ok(f.state.keys.includes(orgKey));
assert.match((await f.cli(["triage", "key", "status"])).stdout, /proxy: holds the key\n/);
f.scan();
});
test("scripts/mosaic routes triage key status with the instance's own config directory", (t) => {
const home = fs.mkdtempSync(join(tmpdir(), "tkm-"));
t.after(() => fs.rmSync(home, { recursive: true, force: true }));
const env = humanEnv({ HOME: home, MOSAIC_CONFIG: join(home, ".config/mosaic-tktest/config.json") });
const setup = spawnSync(join(REPO, "scripts/bootstrap.sh"), ["--instance", "tktest"], { env, encoding: "utf8" });
assert.equal(setup.status, 0, setup.stderr);
const r = spawnSync(join(REPO, "scripts/mosaic"), ["triage", "key", "status"], { env, encoding: "utf8", timeout: 60000 });
OUTPUTS.push(r.stdout, r.stderr);
assert.equal(r.status, 0, r.stderr);
assert.equal(r.stdout, `triage key: not issued\nfile: ${join(home, ".config/mosaic-tktest/secrets/triage/model")}\nproxy: not set up for this instance (no proxy.json)\nnext: set up the model proxy first (mosaic proxy init)\n`);
const refused = spawnSync(join(REPO, "scripts/mosaic"), ["triage", "key", "issue"], { env: { ...env, CLAUDECODE: "1" }, encoding: "utf8", timeout: 60000 });
assert.equal(refused.status, 3);
assert.match(refused.stderr, /found CLAUDECODE in the environment/);
});
test("no output of any verb in this file holds any key the stand-in saw", () => {
assert.ok(SEEN.size >= 20, `only ${SEEN.size} keys were seen`);
assert.ok(OUTPUTS.length >= 100);
for (const text of OUTPUTS) assert.equal(leaks(text), false);
});
+149
View File
@@ -0,0 +1,149 @@
// #1873 triage-route-store: `mosaic triage route show|set`, the owner's terminal verbs for the
// Triage route file (packages/webui/src/triage-route-store.mjs). Human verbs: an agent run is
// refused before anything is read (exit 3), as the other human verbs refuse it. `show` with no
// file says the route is not set and exits 0.
import { test } from "node:test";
import assert from "node:assert/strict";
import { spawnSync } from "node:child_process";
import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { run } from "../src/cli.mjs";
import { AGENT_MARKERS } from "../src/transport.mjs";
import { routePaths } from "../../webui/src/triage-route-store.mjs";
import { humanEnv, io } from "./helpers.mjs";
const REPO = new URL("../../../", import.meta.url).pathname;
const MOSAIC = join(REPO, "scripts/mosaic");
const NOW = new Date("2026-11-18T12:00:00.000Z");
const SET = ["triage", "route", "set", "--model", "glm-5", "--harness", "claude-code", "--cap", "200000", "--time-zone", "America/Chicago"];
function dataRoot(t) {
const d = mkdtempSync(join(tmpdir(), "tr-"));
t.after(() => rmSync(d, { recursive: true, force: true }));
return d;
}
async function cli(argv, d, env = humanEnv()) {
const s = io(env);
const code = await run(argv, s, { system: { dataRoot: d }, now: () => NOW });
return { code, stdout: s.out.text, stderr: s.err.text };
}
test("show with no route says it is not set and exits 0", async (t) => {
const d = dataRoot(t);
assert.deepEqual(await cli(["triage", "route", "show"], d), { code: 0, stdout: "triage route: not set\n", stderr: "" });
assert.equal(existsSync(routePaths(d).dir), false);
});
test("set writes the route; show reads it back", async (t) => {
const d = dataRoot(t);
const set = await cli(SET, d);
assert.equal(set.code, 0, set.stderr);
assert.equal(set.stdout, "triage route set: revision 1\n");
const shown = await cli(["triage", "route", "show"], d);
assert.equal(shown.code, 0);
assert.equal(shown.stdout, [
"triage route: revision 1",
"model: glm-5",
"harness: claude-code",
"cap: 200000 tokens a day, resets 00:00 America/Chicago, counted since 2026-11-18T12:00:00.000Z",
"updated: 2026-11-18T12:00:00.000Z by owner",
"",
].join("\n"));
const doc = JSON.parse(readFileSync(routePaths(d).file, "utf8"));
assert.equal(doc.updatedBy, "owner");
// --revision makes the write conditional on what show printed.
const five = ["triage", "route", "set", "--model", "glm-5", "--harness", "claude-code", "--cap", "5", "--time-zone", "America/Chicago", "--revision", "1"];
assert.equal((await cli(five, d)).code, 0);
assert.equal(JSON.parse(readFileSync(routePaths(d).file, "utf8")).cap.limit, 5);
const stale = await cli([...SET, "--revision", "1"], d);
assert.equal(stale.code, 3);
assert.match(stale.stderr, /^mosaic: triage-route-stale: /);
});
test("refused input exits 2 or 4 and writes nothing", async (t) => {
const d = dataRoot(t);
const without = (flag) => { const a = [...SET]; const i = a.indexOf(flag); a.splice(i, 2); return a; };
const swap = (flag, value) => { const a = [...SET]; a[a.indexOf(flag) + 1] = value; return a; };
const cases = [
[without("--model"), 4], [without("--harness"), 4], [without("--cap"), 4], [without("--time-zone"), 4],
[swap("--cap", "-1"), 2], [swap("--cap", "1e3"), 2], [swap("--cap", "01"), 2], [swap("--cap", "9007199254740993"), 2],
[swap("--time-zone", "Atlantis/Lost"), 2], [swap("--model", "Has Space"), 2],
[swap("--harness", "nonesuch"), 2], [swap("--harness", "../pi"), 2],
[[...SET, "--revision", "x"], 2], [[...SET, "--revision", "-1"], 2],
[[...SET, "--cap", "5"], 4], [[...SET, "--unknown", "1"], 4], [[...SET, "extra"], 4],
[["triage", "route", "show", "--model", "x"], 4], [["triage", "route", "show", "extra"], 4],
[["triage", "route"], 4], [["triage", "route", "remove"], 4], [["triage"], 4], [["triage", "key"], 4],
];
for (const [argv, want] of cases) {
const r = await cli(argv, d);
assert.equal(r.code, want, `${argv.join(" ")}: ${r.stderr}`);
assert.equal(r.stdout, "");
}
// An unknown option is named as one, and its value never reaches the message.
const unknown = await cli([...SET, "--unknown", "secret-value"], d);
assert.equal(unknown.code, 4);
assert.match(unknown.stderr, /^mosaic: unknown option\n/);
assert.doesNotMatch(unknown.stderr, /secret-value/);
assert.equal(existsSync(routePaths(d).file), false);
});
test("an unreadable store exits 3 on show and on set", async (t) => {
const d = dataRoot(t);
assert.equal((await cli(SET, d)).code, 0);
chmodSync(routePaths(d).file, 0o644);
for (const argv of [["triage", "route", "show"], [...SET, "--revision", "1"]]) {
const r = await cli(argv, d);
assert.equal(r.code, 3);
assert.match(r.stderr, /^mosaic: triage-route-unreadable: the Triage route store is unreadable: route\.json mode is not 0600\n$/);
}
});
test("an agent caller is refused before anything is read, for show and set", async (t) => {
const d = dataRoot(t);
for (const marker of AGENT_MARKERS) {
for (const argv of [["triage", "route", "show"], SET]) {
const r = await cli(argv, d, { ...humanEnv(), [marker]: "1" });
assert.equal(r.code, 3, marker);
assert.equal(r.stderr, `mosaic: refused: this runs only from a human shell, outside any agent run (found ${marker} in the environment)\n`);
}
}
assert.equal(existsSync(routePaths(d).dir), false);
});
test("scripts/mosaic routes triage to the verb; a marker in the process env refuses", (t) => {
const home = mkdtempSync(join(tmpdir(), "trm-"));
t.after(() => rmSync(home, { recursive: true, force: true }));
const env = humanEnv({ HOME: home, MOSAIC_CONFIG: join(home, ".config/mosaic-trtest/config.json") });
const setup = spawnSync(join(REPO, "scripts/bootstrap.sh"), ["--instance", "trtest"], { env, encoding: "utf8" });
assert.equal(setup.status, 0, setup.stderr);
const mosaic = (args, extra = {}) => spawnSync(MOSAIC, args, { env: { ...env, ...extra }, encoding: "utf8", timeout: 60000 });
const shown = mosaic(["triage", "route", "show"]);
assert.equal(shown.status, 0, shown.stderr);
assert.equal(shown.stdout, "triage route: not set\n");
const set = mosaic(SET.slice(0));
assert.equal(set.status, 0, set.stderr);
assert.equal(set.stdout, "triage route set: revision 1\n");
const dataDir = join(home, ".mosaic-trtest");
assert.equal(JSON.parse(readFileSync(routePaths(dataDir).file, "utf8")).model, "glm-5");
const refused = mosaic(["triage", "route", "show"], { CLAUDECODE: "1" });
assert.equal(refused.status, 3);
assert.match(refused.stderr, /found CLAUDECODE in the environment/);
assert.equal(refused.stdout, "");
});
test("a marker in this process's own environment refuses even when the command's env is clean", async (t) => {
const d = dataRoot(t);
for (const marker of AGENT_MARKERS) {
const saved = process.env[marker];
process.env[marker] = "1";
try {
for (const argv of [["triage", "route", "show"], SET]) {
const r = await cli(argv, d, humanEnv());
assert.equal(r.code, 3, marker);
assert.match(r.stderr, new RegExp(`found ${marker} in the environment`));
}
} finally { if (saved === undefined) delete process.env[marker]; else process.env[marker] = saved; }
}
assert.equal(existsSync(routePaths(d).dir), false);
});
+8 -3
View File
@@ -100,7 +100,8 @@ export function sessionModel(resolved, models = null, which = "primary", { proxy
if (models === null) return { harness, provider: null, model, thinking };
const entry = Object.hasOwn(models, model) ? models[model] : null;
if (!entry) throw new BundleError(`instance ${resolved.instance}: unknown model table selection for ${ROUTE_VARS[which][1]} var`);
const transport = entry.provider === "proxy" || proxy ? checkedTransport(entry, null, resolver) : null;
// #1873 harness-matrix: the route's own harness, so a model the module holds off it refuses here.
const transport = entry.provider === "proxy" || proxy ? checkedTransport(entry, harness, resolver) : null;
return { harness, provider: entry.provider, model: entry.model, modelKey: model, thinking,
...(transport ? { proxyRoute: transport.routeId, proxyTransport: transport } : {}) };
@@ -432,9 +433,13 @@ export function buildBundle({ dir, resolved, contract, arbiter = false, tracker
];
// The module's own files. A name the bundle already wrote refuses at write (flag wx).
const transports = {};
// #1873 harness-matrix: only models the provider's route() lets this session's harness run, so a
// pi session's models.json never names an upstream claude model or a Claude-named legacy entry.
// route() has no account data: a module entry the catalogue holds to claude-code for an OAuth name
// can still be listed. Only the session's own model is admitted against the catalogue.
if (proxy) for (const [key, entry] of Object.entries(models ?? {})) {
try { transports[key] = checkedTransport(entry, null, resolver); }
catch (e) { if (e?.code !== 'proxy-provider-unsupported') throw e; }
try { transports[key] = checkedTransport(entry, model.harness, resolver); }
catch (e) { if (!['proxy-provider-unsupported', 'model-harness-incompatible'].includes(e?.code)) throw e; }
}
const own = harness.bundle({ dir, files: { ...files }, session: { ...session, ...model }, write, quote, models, proxy, transports });
Object.assign(files, own.files);
@@ -0,0 +1,142 @@
import { fixtureCacheEnv } from '../../../scripts/testing/lane-fixtures.mjs';
// #1873 harness-matrix: claude-code runs a proxy model that is not a Claude model. The host's claude
// CLI runs through adapters/claude with the bundle and env a z.ai or codex selection gives, against a
// local stand-in for the proxy's Anthropic-format route. The stand-in records the path, the model
// name claude sends and the hash of the key it carries. Scratch CLAUDE_CONFIG_DIR and HOME, a fixture
// key, nonessential traffic off: nothing reaches a real model or account. Whether the real proxy
// turns that request into a z.ai or codex call is proved only on the dev instance.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createHash } from 'node:crypto';
import { createServer as createHttp } from 'node:http';
import { spawn, spawnSync } from 'node:child_process';
import { mkdirSync, readFileSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { buildBundle, checkedTransport } from '../src/bundle.mjs';
import { adapterEnv } from '../src/runner.mjs';
import { fakeToolSocket, HARNESS, REPO, REPO_SKILLS, resolvedFor, scratch } from './helpers.mjs';
import * as cliproxy from '../../plugins/model-provider/cliproxy/index.mjs';
const ADAPTER = join(REPO, 'adapters', 'claude', 'adapter.sh');
const which = spawnSync('sh', ['-c', 'command -v claude'], { encoding: 'utf8' });
const CLAUDE = which.status === 0 ? which.stdout.trim() : null;
const skip = CLAUDE ? false : 'claude is not on PATH';
const sha = (s) => createHash('sha256').update(s).digest('hex');
// The proxy's Anthropic-format route, as a stand-in: every /v1/messages answers with one text block.
async function standIn(t, text) {
const seen = [];
const server = createHttp((req, res) => {
let raw = '';
req.on('data', (c) => (raw += c));
req.on('end', () => {
const auth = String(req.headers.authorization ?? '').replace(/^Bearer /, '');
const apiKey = String(req.headers['x-api-key'] ?? '');
if (req.method !== 'POST' || !/^\/v1\/messages(\?|$)/.test(req.url)) {
seen.push({ path: req.url, method: req.method, authSha: auth ? sha(auth) : null, apiKeySha: apiKey ? sha(apiKey) : null });
res.writeHead(req.url.includes('count_tokens') ? 200 : 404, { 'content-type': 'application/json' });
return res.end(JSON.stringify(req.url.includes('count_tokens') ? { input_tokens: 10 } : { type: 'error', error: { type: 'not_found_error', message: 'stand-in' } }));
}
const body = JSON.parse(raw || '{}');
seen.push({ path: req.url.split('?')[0], method: req.method, model: body.model, authSha: auth ? sha(auth) : null, apiKeySha: apiKey ? sha(apiKey) : null });
const send = (event, data) => res.write(`event: ${event}\ndata: ${JSON.stringify({ type: event, ...data })}\n\n`);
if (!body.stream) {
res.writeHead(200, { 'content-type': 'application/json' });
return res.end(JSON.stringify({ id: 'msg_si', type: 'message', role: 'assistant', model: body.model, content: [{ type: 'text', text }], stop_reason: 'end_turn', stop_sequence: null, usage: { input_tokens: 10, output_tokens: 5 } }));
}
res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
send('message_start', { message: { id: 'msg_si', type: 'message', role: 'assistant', model: body.model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 10, output_tokens: 1, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 } } });
send('content_block_start', { index: 0, content_block: { type: 'text', text: '' } });
send('content_block_delta', { index: 0, delta: { type: 'text_delta', text } });
send('content_block_stop', { index: 0 });
send('message_delta', { delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: { output_tokens: 5 } });
send('message_stop', {});
res.end();
});
});
await new Promise((r) => server.listen(0, '127.0.0.1', r));
t.after(() => server.close());
return { url: `http://127.0.0.1:${server.address().port}`, seen };
}
function turn(env, request, cwd) {
return new Promise((resolve) => {
const child = spawn('/bin/sh', [ADAPTER], { cwd, env: { ...env, ...fixtureCacheEnv(env.CLAUDE_CONFIG_DIR), MOSAIC_REQUEST: request }, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
let stdout = '', stderr = '';
child.stdout.on('data', (b) => (stdout += b));
child.stderr.on('data', (b) => (stderr += b));
const clock = setTimeout(() => process.kill(-child.pid, 'SIGKILL'), 120_000);
child.on('close', (code) => { clearTimeout(clock); resolve({ code, stdout, stderr }); });
});
}
const SELECTIONS = {
zai: { provider: 'zai', model: 'glm-fixture', module: 'cliproxy', upstream: 'zai' },
codex: { provider: 'codex', model: 'gpt-fixture', module: 'cliproxy', upstream: 'codex' },
};
// The route's api and endpoint describe pi's wire. claude-code ignores them: its env is the proxy
// root and the key, and it always posts Anthropic Messages there, whatever the upstream.
test('#1873 the catalogue offers a z.ai and a codex model to claude-code and pi, and the route admits both harnesses', async () => {
const c = await cliproxy.catalogue({
listAccounts: async () => ({ files: [{ provider: 'codex', name: 'codex-fixture.json', status: 'active' }] }),
listModels: async () => ({ models: [{ id: 'gpt-fixture' }] }),
listGroups: async () => [{ 'base-url': cliproxy.ZAI_URL, keys: [{}], models: [{ name: 'glm-fixture' }] }],
now: () => 1,
});
assert.equal(c.status, 'ready');
for (const [name, entry] of Object.entries(SELECTIONS)) {
const row = c.models.find((m) => m.upstream === entry.upstream && m.model === entry.model);
assert.deepEqual(row?.harnesses, ['claude-code', 'pi'], name);
for (const harness of ['claude-code', 'pi']) {
assert.deepEqual(cliproxy.preflight({ selection: entry, harness, catalogue: c }), { allow: true }, `${name} ${harness}`);
assert.equal(checkedTransport(entry, harness).piProvider, `mosaic-proxy-${entry.upstream === 'zai' ? 'glm' : 'codex'}`, `${name} ${harness}`);
}
}
});
for (const [name, entry] of Object.entries(SELECTIONS)) {
test(`#1873 claude-code sends the ${name} model name to the proxy's Anthropic-format route with the session key`, { skip }, async (t) => {
const dir = scratch(t, 'mosaic-claude-proxy-');
const workspace = join(dir, 'ws'); mkdirSync(workspace);
const runDir = join(dir, 'run'); mkdirSync(runDir, { mode: 0o700 });
const api = await standIn(t, `stand-in answer for ${entry.model}`);
const key = `fx1873-claude-${name}`;
const resolved = resolvedFor(t, 'coder', (d) => {
d.launch.models.proxied = entry;
d.roles.coder.vars = { harness: 'claude-code', model: 'proxied', thinking: 'low', 'limits.tools': ['read'] };
});
const sock = await fakeToolSocket(t, dir, (tool, args) => ({ tool, args }));
const session = { workspace, sessionDir: join(dir, 'session'), toolSocket: sock.path, turnMarker: join(dir, 'turn.done'), runDir };
const bundle = buildBundle({
dir: join(runDir, 'bundle'), resolved, models: { proxied: entry }, contract: '# Coder\n',
harness: HARNESS['claude-code'], skillsDir: REPO_SKILLS, proxy: { baseUrl: api.url, key },
session: { ...session, run: 'r1873', launchedBy: 'pm' },
});
// The proxy's names come from the harness module's env, and nothing on disk holds the key.
assert.equal(bundle.env.ANTHROPIC_BASE_URL, api.url);
assert.equal(bundle.env.ANTHROPIC_AUTH_TOKEN, key);
assert.equal(Object.hasOwn(bundle.env, 'ANTHROPIC_API_KEY'), false);
for (const file of Object.values(bundle.files)) if (typeof file === 'string') {
let text = ''; try { text = readFileSync(file, 'utf8'); } catch {}
assert.equal(text.includes(key), false, file);
}
const s = { ...session, harness: 'claude-code', provider: entry.provider, model: entry.model, bundle: bundle.files, harnessEnv: bundle.env };
const env = adapterEnv(s, {
PATH: `${dirname(CLAUDE)}:${dirname(process.execPath)}:/usr/bin:/bin`,
HOME: join(dir, 'home'), CLAUDE_CONFIG_DIR: join(dir, 'claude-config'),
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1', DISABLE_TELEMETRY: '1', DISABLE_AUTOUPDATER: '1', DISABLE_ERROR_REPORTING: '1',
});
const r = await turn(env, 'Message 1 from pm, class ASSIGNMENT:\n\nsay hello', workspace);
assert.equal(r.code, 0, r.stderr.replaceAll(key, '<key>'));
assert.match(r.stdout, new RegExp(`stand-in answer for ${entry.model}`));
const messages = api.seen.filter((x) => x.path === '/v1/messages');
assert.ok(messages.length >= 1, JSON.stringify(api.seen));
// The main turn names the selected model. Claude Code may add its own small background
// requests; every request carries the session key as a bearer token and none uses x-api-key.
assert.ok(messages.some((x) => x.model === entry.model), JSON.stringify(messages.map((x) => x.model)));
for (const x of api.seen) { assert.equal(x.authSha, sha(key), x.path); assert.equal(x.apiKeySha, null, x.path); }
assert.equal(r.stdout.includes(key) || r.stderr.includes(key), false);
});
}
+34 -23
View File
@@ -10,6 +10,7 @@ const models = {
a: { provider: 'proxy', model: 'claude-fixture', route: 'anthropic' },
z: { provider: 'proxy', model: 'glm-fixture', route: 'glm' },
g: { provider: 'proxy', model: 'gpt-fixture', route: 'codex' },
o: { provider: 'other', model: 'fixture-other', module: 'cliproxy', upstream: 'other' },
};
function build(t, selection, proxy, declared) {
const root = scratch(t, 'p332-'), runDir = join(root, 'run');
@@ -32,14 +33,22 @@ function assertSafe(value) {
else if (value && typeof value === 'object') for (const item of Object.values(value)) assertSafe(item);
}
test('P3 Anthropic route uses messages at proxy root and the declared model id', t => {
const b = build(t, 'a', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, { a: models.a });
const { anthropic } = JSON.parse(b.text).providers;
assert.equal(anthropic.api, 'anthropic-messages');
assert.equal(anthropic.baseUrl, 'http://127.0.0.1:12345');
assert.deepEqual(anthropic.models.map(m => m.id), ['claude-fixture']);
assert.equal(b.env.PI_PROVIDER, 'anthropic');
assert.equal(b.env.PI_MODEL, 'claude-fixture');
// #1873 harness-matrix: a Claude account model runs on claude-code only, so a pi session on it
// refuses before any file is written.
test('a proxy Claude route on pi refuses model-harness-incompatible before model config generation', t => {
for (const a of [models.a, { provider: 'anthropic', model: 'fixture-chat' }, { provider: 'anthropic', model: 'fixture-chat', module: 'cliproxy', upstream: 'claude' }])
assert.throws(() => build(t, 'a', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, { a }), { code: 'model-harness-incompatible' }, JSON.stringify(a));
});
test('an other-upstream route uses messages at proxy root under its own pi provider, never pi\'s built-in anthropic', t => {
const b = build(t, 'o', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, { o: models.o });
const providers = JSON.parse(b.text).providers;
assert.deepEqual(Object.keys(providers), ['mosaic-proxy-other']);
assert.equal(providers['mosaic-proxy-other'].api, 'anthropic-messages');
assert.equal(providers['mosaic-proxy-other'].baseUrl, 'http://127.0.0.1:12345');
assert.deepEqual(providers['mosaic-proxy-other'].models.map(m => m.id), ['fixture-other']);
assert.equal(b.env.PI_PROVIDER, 'mosaic-proxy-other');
assert.equal(b.env.PI_MODEL, 'fixture-other');
});
test('P3 omitted route refuses proxy-route-missing before model config generation', t => {
@@ -82,9 +91,11 @@ test('P3 a declared Codex route generates only the single build-time responses p
test('P3 models file is private, references the one session key, and stores no executable values or keys', t => {
const key = 'fx332-agent-a';
const b = build(t, 'a', { baseUrl: 'http://127.0.0.1:12345', key }, { a: models.a, z: models.z });
const b = build(t, 'z', { baseUrl: 'http://127.0.0.1:12345', key }, { a: models.a, z: models.z, o: models.o });
const document = JSON.parse(b.text);
assert.deepEqual(Object.keys(document.providers).sort(), ['anthropic', 'mosaic-proxy-glm']);
// #1873: the Claude account entry is left out of a pi session's file.
assert.deepEqual(Object.keys(document.providers).sort(), ['mosaic-proxy-glm', 'mosaic-proxy-other']);
assert.ok(!b.text.includes('claude-fixture'));
for (const provider of Object.values(document.providers)) assert.equal(provider.apiKey, '$ANTHROPIC_API_KEY');
assertSafe(document);
assert.ok(!b.text.includes(key));
@@ -96,20 +107,20 @@ test('P3 models file is private, references the one session key, and stores no e
});
test('P3 every launch regenerates proxy port, declared models and own key without caching', t => {
const first = build(t, 'a', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, { a: models.a, z: models.z });
const second = build(t, 'a', { baseUrl: 'http://127.0.0.1:23456', key: 'fx332-agent-b' }, {
a: { provider: 'proxy', model: 'changed-model-id', route: 'anthropic' },
const first = build(t, 'z', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, { g: models.g, z: models.z });
const second = build(t, 'z', { baseUrl: 'http://127.0.0.1:23456', key: 'fx332-agent-b' }, {
g: { provider: 'proxy', model: 'changed-model-id', route: 'codex' },
z: { provider: 'proxy', model: 'changed-glm-id', route: 'glm' },
});
assert.equal(second.env.ANTHROPIC_API_KEY, 'fx332-agent-b');
assert.ok(!JSON.stringify(second).includes('fx332-agent-a'));
const { providers } = JSON.parse(second.text);
assert.deepEqual(Object.keys(providers), ['anthropic', 'mosaic-proxy-glm']);
assert.equal(providers.anthropic.baseUrl, 'http://127.0.0.1:23456');
assert.deepEqual(providers.anthropic.models.map(m => m.id), ['changed-model-id']);
assert.deepEqual(Object.keys(providers), ['mosaic-proxy-codex', 'mosaic-proxy-glm']);
assert.equal(providers['mosaic-proxy-codex'].baseUrl, 'http://127.0.0.1:23456/v1');
assert.deepEqual(providers['mosaic-proxy-codex'].models.map(m => m.id), ['changed-model-id']);
assert.equal(providers['mosaic-proxy-glm'].baseUrl, 'http://127.0.0.1:23456/v1');
assert.deepEqual(providers['mosaic-proxy-glm'].models.map(m => m.id), ['changed-glm-id']);
assert.equal(JSON.parse(first.text).providers.anthropic.baseUrl, 'http://127.0.0.1:12345');
assert.equal(JSON.parse(first.text).providers['mosaic-proxy-glm'].baseUrl, 'http://127.0.0.1:12345/v1');
});
// Row 332 R2 (#1830, review F2): launch.models is open table data. An entry whose provider has no
@@ -121,14 +132,14 @@ test('row 332 R2 an unroutable model table entry is left out of models.json and
glm: { provider: 'zai', model: 'glm-fixture' },
router: { provider: 'openrouter', model: 'x' },
};
const b = build(t, 'opus', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, declared);
const b = build(t, 'glm', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, declared);
const { providers } = JSON.parse(b.text);
assert.deepEqual(Object.keys(providers).sort(), ['anthropic', 'mosaic-proxy-glm']);
assert.deepEqual(providers.anthropic.models.map(m => m.id), ['claude-fixture']);
// #1873: the Claude account entry is one a pi session can't run, so it is left out too.
assert.deepEqual(Object.keys(providers).sort(), ['mosaic-proxy-glm']);
assert.deepEqual(providers['mosaic-proxy-glm'].models.map(m => m.id), ['glm-fixture']);
assert.ok(!Object.values(providers).some(p => p.models.some(m => m.id === 'x')), 'the openrouter entry is not written');
assert.equal(b.env.PI_MODEL, 'claude-fixture');
assert.throws(() => build(t, 'opus', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, {
assert.equal(b.env.PI_MODEL, 'glm-fixture');
assert.throws(() => build(t, 'glm', { baseUrl: 'http://127.0.0.1:12345', key: 'fx332-agent-a' }, {
...declared, broken: { provider: 'proxy', model: 'claude-fixture' },
}), { code: 'proxy-route-missing' });
});
@@ -140,7 +151,7 @@ test('row 332 R2 a session proxy context without a key or loopback URL refuses i
{ baseUrl: 'http://localhost:12345', key: 'fx332-agent-a' },
{ baseUrl: 'http://127.0.0.1:12345' },
]) {
assert.throws(() => build(t, 'a', proxy, { a: models.a }),
assert.throws(() => build(t, 'z', proxy, { z: models.z }),
{ code: 'invalid-proxy-context', message: 'invalid session proxy context' }, JSON.stringify(proxy));
}
});
+25 -5
View File
@@ -3,12 +3,12 @@ import test from 'node:test';
import assert from 'node:assert/strict';
import { sessionModel } from '../src/bundle.mjs';
const resolved = { instance: 'fixture', vars: { harness: 'pi', model: 'selected', thinking: 'low' } };
for (const [provider, model, expected] of [
['anthropic', 'glm-looking-id', 'anthropic'],
['zai', 'gpt-looking-id', 'glm'],
for (const [provider, model, expected, harness] of [
['anthropic', 'glm-looking-id', 'anthropic', 'claude-code'],
['zai', 'gpt-looking-id', 'glm', 'pi'],
]) {
test(`joined proxy context maps provider ${provider} by identity, not model name`, () => {
const selected = sessionModel(resolved, { selected: { provider, model } }, 'primary', { proxy: true });
const selected = sessionModel({ ...resolved, vars: { ...resolved.vars, harness } }, { selected: { provider, model } }, 'primary', { proxy: true });
assert.equal(selected.proxyRoute, expected);
assert.equal(selected.provider, provider, 'public/accounting provider identity is retained');
assert.equal(selected.model, model);
@@ -31,7 +31,7 @@ test('provider proxy still requires an explicit route inside joined context', ()
assert.throws(() => sessionModel(resolved, { selected: { provider: 'proxy', model: 'fixture', route: 'custom' } }, 'primary', { proxy: true }), {
code: 'proxy-route-unknown',
});
assert.equal(sessionModel(resolved, { selected: { provider: 'proxy', model: 'claude-looking-id', route: 'codex' } }, 'primary', { proxy: true }).proxyRoute, 'codex');
assert.equal(sessionModel(resolved, { selected: { provider: 'proxy', model: 'fixture-codex-id', route: 'codex' } }, 'primary', { proxy: true }).proxyRoute, 'codex');
});
test('a module-backed selection carries the provider transport descriptor without changing accounting', () => {
const selected = sessionModel(resolved, { selected: { provider: 'codex', model: 'fixture-codex', module: 'cliproxy', upstream: 'codex' } }, 'primary', { proxy: true });
@@ -52,3 +52,23 @@ test('transport accepts bounded compatibility flags declared by a provider modul
const resolver=()=>({provider:'fixture',model:'fixture-id',routeId:'fixture',endpoint:'v1',api:'openai-completions',piProvider:'fixture',compat:{supportsStore:false,thinkingFormat:'openai'}});
assert.deepEqual(sessionModel(resolved,{selected:entry},'primary',{proxy:true,resolver}).proxyTransport.compat,{supportsStore:false,thinkingFormat:'openai'});
});
// #1873 harness-matrix: the launch checks the route's own harness, so a stored OAuth Claude route on pi
// is refused before any run, with or without a model-provider module switched on.
test('a stored proxy Claude route on pi refuses model-harness-incompatible at launch', () => {
for (const selected of [{ provider: 'anthropic', model: 'fixture-chat' }, { provider: 'proxy', route: 'anthropic', model: 'fixture-chat' },
{ provider: 'anthropic', model: 'fixture-chat', module: 'cliproxy', upstream: 'claude' }])
assert.throws(() => sessionModel(resolved, { selected }, 'primary', { proxy: true }), { code: 'model-harness-incompatible' }, JSON.stringify(selected));
// Jason 2026-11-19: the rule keys on the account kind. A module entry, whose kind the catalogue
// knows, runs on pi with a Claude name. A legacy entry carries no account data, so a Claude name
// there is treated as OAuth.
for (const selected of [{ provider: 'other', model: 'anthropic/claude-sonnet-5-5', module: 'cliproxy', upstream: 'other' },
{ provider: 'zai', model: 'claude-looking-id', module: 'cliproxy', upstream: 'zai' }, { provider: 'zai', model: 'glm-fixture' }])
assert.equal(sessionModel(resolved, { selected }, 'primary', { proxy: true }).model, selected.model, JSON.stringify(selected));
for (const selected of [{ provider: 'proxy', route: 'codex', model: 'claude-looking-id' }, { provider: 'zai', model: 'claude-looking-id' }, { provider: 'proxy', route: 'glm', model: 'claude-opus-5-5' }])
assert.throws(() => sessionModel(resolved, { selected }, 'primary', { proxy: true }), { code: 'model-harness-incompatible' }, JSON.stringify(selected));
const claudeCode = { ...resolved, vars: { ...resolved.vars, harness: 'claude-code' } };
assert.equal(sessionModel(claudeCode, { selected: { provider: 'anthropic', model: 'fixture-chat' } }, 'primary', { proxy: true }).proxyRoute, 'anthropic');
for (const selected of [{ provider: 'zai', model: 'fixture-zai' }, { provider: 'codex', model: 'fixture-codex', module: 'cliproxy', upstream: 'codex' }])
assert.equal(sessionModel(claudeCode, { selected }, 'primary', { proxy: true }).provider, selected.provider);
});
+5 -5
View File
@@ -1,12 +1,12 @@
{
"version": "8.0.42",
"version": "8.0.79",
"archive": {
"asset": "CLIProxyAPI_8.0.42_linux_amd64.tar.gz",
"url": "https://github.com/router-for-me/CLIProxyAPI/releases/download/v8.0.42/CLIProxyAPI_8.0.42_linux_amd64.tar.gz",
"sha256": "1e10566fe0042ed5a9b80306cf296bf86a83de590cd967a8b177988b896c8d31"
"asset": "CLIProxyAPI_8.0.79_linux_amd64.tar.gz",
"url": "https://github.com/router-for-me/CLIProxyAPI/releases/download/v8.0.79/CLIProxyAPI_8.0.79_linux_amd64.tar.gz",
"sha256": "7cbb9709ed939ff3684e10592a45cc538ee82d5da759daa7e18c7e1dc3b32acd"
},
"binary": {
"sha256": "74661f8cf949977870231359e8bf4344e07946766a673c08fa25a3e5f72fc95e"
"sha256": "4968bd27b04f813849add020b95a26dc7abf3e30810b97d291c0d88f495fe601"
},
"panel": {
"version": "1.26.7",
+22 -2
View File
@@ -56,8 +56,28 @@ uses a new temp root and private network namespace, with made-up credentials,
and calls the page's bus verbs. If the page cannot pass against the new PIN,
the upgrade stops; Sage takes Q46's fallback to Jason through Mos.
A running instance takes a new PIN in three steps, in this order. First run
the new code: update the checkout or pinned copy the bus, Console and proxy
unit start from. The proxy unit runs `run.mjs` and reads `PIN` from the tree
it was installed from (`systemctl --user cat <unit>` shows it). If the new
code is in that same tree, a restart picks it up. If it is in another tree,
the unit keeps the old PIN until it is installed again from the new tree:
stop it, remove its unit file, then `mosaic proxy unit install` from the new
tree, because install never replaces a unit. Then run `mosaic proxy fetch` (or Fetch on the Console's
Model proxy settings), which installs the new release beside the old one
under `<dataRoot>/opt/cliproxyapi/<version>/`. Then restart the proxy with
`mosaic proxy unit restart`. Before the fetch, the proxy fails to start with
`proxy-install-missing`, and keeps failing until the fetch is done. Restart the bus and
Console as well so their status and Fetch use the new PIN. `proxy.json` keeps
the path from the PIN it was created under. That path stays valid, and the
proxy always runs the hash-verified install for the current PIN. Signed-in
accounts in `<dataRoot>/proxy/auth/` carry over. From 8.0.55 the proxy also
keeps a `kv.db` file in that directory, and 8.0.79 adds a `.codex-refresh/`
directory there once a Codex account renews. The old release directory can be
removed once the new one runs.
The native `/proxy` page uses human-only bus verbs; only the bus holds the
management client. On PIN 8.0.42, OAuth credentials are listed under
management client. On PIN 8.0.79, OAuth credentials are listed under
`/v8/management/credentials` and priority is patched as `{name, priority}`.
API-key groups are absent from that list: z.ai keys use the Claude-compatible
provider configuration at `/v8/management/config/api-keys/claude`, whose keys
@@ -128,7 +148,7 @@ follow-up; do not run those writers concurrently with organization buses.
### Setup from the Console (#1873)
Settings > Model proxy has a Proxy setup panel for the instance owner: the
Settings > Model setup (route `#/settings/model-proxy`) has a Proxy setup panel for the instance owner: the
`--dev-local-owner` owner on a dev Console, or the root owner under `--sso`.
Agents, testers and grant holders get `human-required` on every setup route,
read or write. The panel shows the release (pinned version, hashes verified),
+109 -3
View File
@@ -2,10 +2,12 @@
// `mosaic proxy status|unit|init-lock|fence clear --restart`. Host actions run here; init and
// the fence clear go to the bus, which decides them. Results and receipts carry labels, key IDs
// and process ids only: never a key, token, absolute path or upstream text.
import fs from 'node:fs';
import { homedir } from 'node:os';
import { fetchPinned } from './fetch.mjs';
import { PIN } from './common.mjs';
import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, createUnitControl, FILE_LABELS } from './admin.mjs';
import { localRide, riddenOrgs } from './ride.mjs';
import { releaseState, initState, fenceState, initLockStatus, clearInitLock, appendReceipt, recentReceipts, receiptsText, createUnitControl, FILE_LABELS } from './admin.mjs';
export const proxyCode = (error, fallback) => (/^proxy-[a-z-]+$/.test(error?.code ?? '') ? error.code : fallback);
const failure = code => Object.assign(new Error(code), { code });
@@ -13,7 +15,12 @@ const failure = code => Object.assign(new Error(code), { code });
// `buses()` proves the init-lock condition "bus stopped" ({stopped, running:[label]}).
// `orgs()` lists the organizations this proxy serves: [{id, catalogue}]. `unit` and `fetch` are
// (and `pin`) seams for tests; the defaults run the real proxy-service.sh, systemctl and pinned fetch.
export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir = null, unit = null, fetch = fetchPinned, buses, orgs = async () => [], now = () => new Date(), env = process.env, pin = PIN }) {
// #1873 ride-default: `riders()` lists the owner's active organizations for Ride all, read locally:
// [{id, fixture, cliproxy, changes, call, status}] where `changes` is the text of the organization's
// change log, `call(verb, args)` reaches its bus as the owner and `status()` is its bus status. `ownerModels()` answers
// {proxy, riding, models} from the riding buses' catalogues. `move(id, models, principal)` moves a
// stopped fixture organization to the owner's models through the organization service.
export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir = null, unit = null, fetch = fetchPinned, buses, orgs = async () => [], riders = async () => [], ownerModels = async () => ({ proxy: false, riding: false, models: [] }), move = null, now = () => new Date(), env = process.env, pin = PIN }) {
const port = () => { try { return initState(configDir, dataRoot).settings?.port ?? null; } catch { return null; } };
const control = unit ?? createUnitControl({ instance, unitDir, port, env });
let job = { state: 'idle', step: null, receipt: null, error: null };
@@ -30,6 +37,54 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
async function unitStatus() {
try { return await control.status(); } catch (error) { return { unit: control.unit, installed: false, active: 'unknown', healthy: false, error: proxyCode(error, 'proxy-unit-failed') }; }
}
// The organizations this proxy's own receipts show cliproxy was or may have been on (riddenOrgs).
// No receipt file yet is none; a file that fails receiptsText's check, or holds a line that does
// not parse, is null, and localRide skips every organization without cliproxy as unreadable.
function ridden() {
const ids = riddenOrgs(receiptsText(dataRoot));
return id => (ids === null ? null : ids.has(id));
}
const decide = (rider, wasRidden) => localRide({ ...rider, ridden: wasRidden(rider.id) });
// Stopped is the organization admin page's test (org-admin bus stop): a bus status with no
// process id. A status that cannot be read, or a rider with no status, is not stopped.
async function stopped(rider) {
if (typeof rider.status !== 'function') return false;
try { return !Number.isSafeInteger((await rider.status())?.pid); } catch { return false; }
}
const failCode = error => (/^[a-z][a-z-]{0,63}$/.test(error?.code ?? '') ? error.code : 'failed');
// Ride all, one organization: the local rules first, then the organization's bus, which must
// answer and must hold the proxy client. The bus decides the write (plugins.set) as it would
// for the owner on the Settings page. The answer names a reason, never bus or upstream text.
// A ride-intent receipt is on disk before plugins.set is sent; with no receipt there is no write.
// When plugins.set fails and the bus then shows no cliproxy, a ride-not-added receipt clears that
// intent. Any other failure leaves it: the add may have happened.
async function rideOne(rider, wasRidden) {
const id = rider.id, local = decide(rider, wasRidden);
if (local === 'fixture') return { id, outcome: 'fixture', running: !(await stopped(rider)) };
if (local !== 'ready') return { id, outcome: local === 'already' ? 'already' : 'skipped', reason: local };
let current;
try { current = await rider.call('plugins'); } catch { return { id, outcome: 'skipped', reason: 'bus-down' }; }
try { await rider.call('proxy.accounts'); } catch (error) { return { id, outcome: 'skipped', reason: error?.code === 'not-configured' ? 'no-proxy-client' : 'proxy-check-failed' }; }
const providers = Array.isArray(current?.plugins?.['model-provider']) ? current.plugins['model-provider'] : [];
if (providers.includes('cliproxy')) return { id, outcome: 'already' };
// The receipts are read again here: a removal saved while this run worked on earlier
// organizations is on file now, and the decision above came from the run's first read.
const now = ridden()(id);
if (now !== false) return { id, outcome: 'skipped', reason: now === null ? 'unreadable' : 'removed' };
try { receipt({ op: 'ride-intent', org: id }); } catch { return { id, outcome: 'skipped', reason: 'not-recorded' }; }
try { await rider.call('plugins.set', { revision: current.revision, plugins: { 'model-provider': [...providers, 'cliproxy'] } }); }
catch (error) {
try {
const after = await rider.call('plugins');
if (Array.isArray(after?.plugins?.['model-provider']) && !after.plugins['model-provider'].includes('cliproxy')) receipt({ op: 'ride-not-added', org: id });
} catch { /* unknown outcome: the intent stands */ }
return { id, outcome: 'failed', reason: failCode(error) };
}
return { id, outcome: 'added' };
}
async function rideSummary() {
try { const wasRidden = ridden(); return (await riders()).map(r => ({ id: r.id, state: decide(r, wasRidden) })); } catch { return null; }
}
function nextSteps({ release, init, unitState, fence, lock }) {
if (!release.fetched || release.problem) return ['fetch'];
if (lock.present) return lock.clearable ? ['init-lock-clear'] : ['init-lock-wait'];
@@ -54,6 +109,10 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
const lock = init.lock ? initLockStatus({ configDir, dataRoot, buses: await buses() }) : { present: false, clearable: false, blockers: [] };
let organizations = null;
try { organizations = await orgs(); } catch { organizations = null; }
const ride = await rideSummary();
const next = nextSteps({ release, init, unitState, fence, lock });
// Ride all comes after the proxy runs with no fence, while an organization can still ride.
if (next[0] === 'accounts' && ride?.some(r => r.state === 'ready' || r.state === 'fixture')) next.push('ride-all');
return {
release: { version: release.version, panelVersion: release.panelVersion, fetched: release.fetched, verified: release.verified, problem: release.problem },
init: {
@@ -71,7 +130,8 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
// Ruling 8: the system config holds one proxy per instance; an organization's own proxy
// needs a config format that does not exist yet.
ownProxy: { available: false, state: 'not built', reason: 'This instance has one shared proxy. A separate proxy per organization is not built yet.' },
next: nextSteps({ release, init, unitState, fence, lock }),
ride,
next,
};
},
// Runs in the background; the page polls status for its step and receipt.
@@ -133,6 +193,52 @@ export function createProxyAdmin({ dataRoot, configDir, instance = null, unitDir
return { cleared: result.cleared === true, receipt: receipt({ op: 'fence.clear', cleared: result.cleared === true, evidence: result.evidence ?? null }) };
});
},
// Ride all: adds cliproxy to each organization that can take it, and names every one it skips.
// Fixture organizations are listed, not changed: moving one spends real tokens, so it is a
// separate confirmed action (rideMove).
async rideAll() {
return exclusive('ride-all', async () => {
const list = await riders(), wasRidden = ridden();
const results = [];
for (const rider of list) results.push(await rideOne(rider, wasRidden));
const added = results.filter(r => r.outcome === 'added').map(r => r.id);
const skipped = results.filter(r => r.outcome === 'skipped' || r.outcome === 'failed').map(r => ({ id: r.id, reason: r.reason }));
const fixtures = results.filter(r => r.outcome === 'fixture').map(r => ({ id: r.id, running: r.running }));
const already = results.filter(r => r.outcome === 'already').map(r => r.id);
// Each add already left its ride-intent receipt, so a summary that cannot be written still
// answers what happened, with no receipt.
let summary = null;
try { summary = receipt({ op: 'ride-all', added, skipped, fixtures: fixtures.map(f => f.id) }); } catch { summary = null; }
return { added, already, skipped, fixtures, receipt: summary };
});
},
// Moves one stopped fixture organization to the owner's models. Its bus is refused at start
// beside a real proxy, so the organization service writes its document (the same whole-document
// update the organization's admin page uses); the owner starts its bus afterwards.
async rideMove({ org, principal } = {}) {
return exclusive('ride-move', async () => {
const rider = (await riders()).find(r => r.id === org);
if (!rider) return { org, moved: false, reason: 'unknown' };
const local = decide(rider, ridden());
if (local !== 'fixture') return { org, moved: false, reason: local };
if (!(await stopped(rider))) return { org, moved: false, reason: 'bus-running' };
if (typeof move !== 'function') return { org, moved: false, reason: 'not-available' };
const owner = await ownerModels();
if (owner?.proxy !== true) return { org, moved: false, reason: 'no-proxy' };
if (owner.riding !== true) return { org, moved: false, reason: 'no-riding-bus' };
let result;
try { result = await move(org, owner.models, principal); }
catch (error) { result = { moved: false, reason: failCode(error) }; }
if (!result?.moved) return { org, moved: false, reason: result?.reason ?? 'failed' };
return { org, moved: true, model: result.model, receipt: receipt({ op: 'ride-move', org, model: result.model }) };
});
},
// The organization admin page calls this before it saves a document that drops cliproxy from
// the model providers, and saves nothing when it throws. Ride all then leaves that organization off.
rideRemoved(org) {
if (typeof org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(org)) throw failure('proxy-org-invalid');
return receipt({ op: 'ride-removed', org });
},
async initLockClear() {
return exclusive('init-lock-clear', async () => ({ receipt: clearInitLock({ configDir, dataRoot, buses: await buses(), now }) }));
},
+20
View File
@@ -107,6 +107,26 @@ export function appendReceipt(dataRoot, record) {
return record;
}
// A file's text, read the way fenceState checks the fence file: opened without following a symlink
// (and without blocking on a FIFO), a regular file the Console's own user owns, with none of the
// `mask` permission bits. A missing file throws its ENOENT; any other failure throws
// proxy-file-refused. `uid` is a test seam.
export function ownedText(file, { mask = 0o077, uid = process.getuid() } = {}) {
const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
try {
const stat = fs.fstatSync(fd);
if (!stat.isFile() || stat.uid !== uid || (stat.mode & mask)) throw Object.assign(new Error('proxy-file-refused'), { code: 'proxy-file-refused' });
return fs.readFileSync(fd, 'utf8');
} finally { fs.closeSync(fd); }
}
// The whole receipt file's text for Ride all, which decides from it (ownedText, no group or other
// bits). No file yet answers ''; anything else that fails answers null, and the caller treats every
// organization without cliproxy as unreadable.
export function receiptsText(dataRoot, { uid = process.getuid() } = {}) {
try { return ownedText(receiptFile(dataRoot), { uid }); } catch (error) { return error?.code === 'ENOENT' ? '' : null; }
}
// The last few receipts, oldest first, for the page after a reload. Reads only the file's tail and
// skips a line that does not parse (a torn last write). Receipts never hold a key or a body.
export function recentReceipts(dataRoot, limit = 10) {
+166
View File
@@ -0,0 +1,166 @@
// #1873 ride-default slice 1: the rules for "Ride all", which adds the instance's model proxy
// (the cliproxy model provider) to the owner's existing organizations. Pure functions: the
// Console wiring (webui cli.mjs) reads each organization and its bus, and admin-control runs them.
import { usableModel } from '../../plugins/model-provider/cliproxy/index.mjs';
export { usableModel };
const has = (list, name) => Array.isArray(list) && list.includes(name);
// The model providers one change-log change shows before and after, by the change's path: the
// list itself, the plugins object, or the whole document. Any other path shows none.
function providersOf(change) {
const at = value => change?.path === 'plugins.model-provider' ? value
: change?.path === 'plugins' ? value?.['model-provider']
: change?.path === '' ? value?.plugins?.['model-provider'] : undefined;
return [at(change?.old), at(change?.new)];
}
const touchesProviders = path => path === '' || path === 'plugins' || path === 'plugins.model-provider';
// What the organization's change log shows of cliproxy, from its committed writes: `removed` when
// a write took it off, `seen` when any write shows it on the organization before or after, or wrote
// the providers without logging their values (a paths-only entry). A log that cannot be read
// answers null, and the caller skips the organization as unreadable.
export function cliproxyHistory(text) {
if (typeof text !== 'string') return null;
let removed = false, seen = false;
try {
for (const line of text.split('\n')) {
if (!line.trim()) continue;
const event = JSON.parse(line);
if (event?.state !== 'committed' || !Array.isArray(event.changes)) continue;
for (const change of event.changes) {
if (!touchesProviders(change?.path)) continue;
if (!Object.hasOwn(change, 'old') && !Object.hasOwn(change, 'new')) { seen = true; continue; }
const [before, after] = providersOf(change);
if (has(before, 'cliproxy') && !has(after, 'cliproxy')) removed = true;
if (has(before, 'cliproxy') || has(after, 'cliproxy')) seen = true;
}
}
return { removed, seen };
} catch { return null; }
}
export function cliproxyRemoved(text) { const h = cliproxyHistory(text); return h === null ? null : h.removed; }
// The organizations the proxy's own receipts (proxy-admin.jsonl) show cliproxy was or may have
// been on: each ride-all receipt's added list, each ride-move's org, each ride-removed's org (the
// organization admin page writes one before it saves a document without cliproxy), and each
// ride-intent's org (Ride all writes one before each plugins.set) unless a later ride-not-added for
// that organization shows the bus did not take it. Any line that does not parse, and any ride
// record of the wrong shape, answers null: the caller then skips every organization without
// cliproxy as unreadable. Text that is not a string answers null too.
const RIDE_ORG = new Set(['ride-move', 'ride-removed', 'ride-intent', 'ride-not-added']);
export function riddenOrgs(text) {
if (typeof text !== 'string') return null;
const ids = new Set(), pending = new Set();
for (const line of text.split('\n')) {
if (!line.trim()) continue;
let r; try { r = JSON.parse(line); } catch { return null; }
if (!r || typeof r !== 'object' || Array.isArray(r)) return null;
if (r.op === 'ride-all') {
if (!Array.isArray(r.added) || !r.added.every(id => typeof id === 'string')) return null;
for (const id of r.added) ids.add(id);
} else if (RIDE_ORG.has(r.op)) {
if (typeof r.org !== 'string') return null;
if (r.op === 'ride-intent') pending.add(r.org);
else if (r.op === 'ride-not-added') pending.delete(r.org);
else ids.add(r.org);
}
}
for (const id of pending) ids.add(id);
return ids;
}
// The local part of the decision, with no bus call: what Ride all does with one organization
// before it asks the organization's bus anything. An organization that uses cliproxy now (and is
// not a fixture organization) is already riding, whatever its history. One without cliproxy now
// that had it, or may have had it, is removed: its change log or the proxy's receipts show it
// (`ridden` is true from the receipts, null when they cannot be read).
export function localRide({ fixture, cliproxy, changes, ridden = false }) {
if (typeof fixture !== 'boolean' || typeof cliproxy !== 'boolean') return 'unreadable';
if (cliproxy && !fixture) return 'already';
const history = cliproxyHistory(changes);
if (history === null || (ridden === null && !cliproxy)) return 'unreadable';
if (history.removed || (!cliproxy && (ridden === true || history.seen))) return 'removed';
if (fixture) return 'fixture';
return 'ready';
}
// One organization as Ride all reads it, without its bus: `read()` gives its document and
// `readLog()` the text of its change log. A document that cannot be read leaves `fixture` and
// `cliproxy` undefined, a log that does not exist yet is empty, and any other log failure is null;
// localRide names either as unreadable. `isFixture(doc)` is the CLI's own fixture test.
export function readRider({ id, read, readLog, isFixture }) {
let doc = null, changes = null;
try { doc = read(); } catch {}
try { changes = readLog(); } catch (e) { changes = e?.code === 'ENOENT' ? '' : null; }
const ok = !!doc && typeof doc === 'object';
return { id, fixture: ok ? isFixture(doc) === true : undefined,
cliproxy: ok ? (Array.isArray(doc.plugins?.['model-provider']) ? doc.plugins['model-provider'] : []).includes('cliproxy') : undefined, changes };
}
// The owner's models: `proxy` is true when the instance's proxy.json names a port. Each organization
// that lists cliproxy is asked for its routes at once, so a hung bus costs one timeout, not one each.
// It rides when its bus answers a ready catalogue; the models are the cliproxy rows those
// catalogues list, once each.
export async function ownerModelsFrom({ proxy, riders }) {
if (proxy !== true) return { proxy: false, riding: false, models: [] };
const catalogues = await Promise.all((Array.isArray(riders) ? riders : []).filter(r => r?.cliproxy === true)
.map(async r => { try { return (await r.call('routes'))?.catalogue; } catch { return null; } }));
const models = new Map(); let riding = false;
for (const catalogue of catalogues) {
if (catalogue?.status !== 'ready' || !Array.isArray(catalogue.models)) continue;
riding = true;
// A key two buses list keeps the first usable row: one bus's stale row does not hide the model.
for (const m of catalogue.models) {
if (m?.module !== 'cliproxy' || typeof m.key !== 'string') continue;
if (!models.has(m.key) || (!usableModel(models.get(m.key)) && usableModel(m))) models.set(m.key, m);
}
}
return { proxy: true, riding, models: [...models.values()] };
}
// The owner's model for an organization: the first usable catalogue model from claude, else
// the first usable one, that serves every harness in `harnesses`.
export function pickModel(models, harnesses = []) {
const fits = (Array.isArray(models) ? models : []).filter(m => usableModel(m) && harnesses.every(h => m.harnesses.includes(h)));
return fits.find(m => m.upstream === 'claude') ?? fits[0] ?? null;
}
// A fixture organization moved to the owner's models: the fixture model provider becomes
// cliproxy, each fixture model entry goes, and every role that used one uses the owner's model.
// Answers { doc, model } or { reason } when no catalogue model serves the roles' harnesses.
export function fixtureMove(doc, models) {
const next = structuredClone(doc);
const fixtureKeys = Object.entries(next.launch?.models ?? {}).filter(([, m]) => m?.module === 'fixture').map(([key]) => key);
const uses = [];
const visit = vars => {
if (!vars || typeof vars !== 'object') return;
for (const prefix of ['', 'fallback.']) if (fixtureKeys.includes(vars[prefix + 'model'])) uses.push({ vars, prefix });
};
// A model is an agent-layer var: an organization's roles and each project's own agents carry one.
for (const role of Object.values(next.roles ?? {})) visit(role?.vars);
for (const project of Object.values(next.projects ?? {})) for (const agent of Object.values(project?.agents ?? {})) visit(agent?.vars);
const harnesses = [...new Set(uses.map(({ vars, prefix }) => vars[prefix + 'harness']).filter(h => typeof h === 'string'))];
const model = pickModel(models, harnesses);
if (!model) return { reason: 'no-model' };
for (const key of fixtureKeys) delete next.launch.models[key];
next.launch = next.launch ?? {}; next.launch.models = next.launch.models ?? {};
next.launch.models[model.key] = { provider: model.provider, model: model.model, module: 'cliproxy', upstream: model.upstream };
for (const { vars, prefix } of uses) vars[prefix + 'model'] = model.key;
const providers = (next.plugins?.['model-provider'] ?? []).filter(n => n !== 'fixture');
next.plugins = { ...(next.plugins ?? {}), 'model-provider': providers.includes('cliproxy') ? providers : [...providers, 'cliproxy'] };
return { doc: next, model };
}
// The move itself, through the organization service's existing whole-document update: read,
// change, validate, then write only if the revision read is still current. Owner-only twice:
// the Console route admits only the instance owner, and the service checks `ctx.principal`.
export async function moveFixtureOrg({ service, ctx, id, models }) {
const shown = await service.showOrg(ctx, id);
const moved = fixtureMove(shown.doc, models);
if (moved.reason) return { moved: false, reason: moved.reason };
const checked = await service.validateOrg(moved.doc);
if (!checked?.ok) return { moved: false, reason: 'invalid' };
await service.updateOrg(ctx, id, moved.doc, { ifRevision: shown.revision });
return { moved: true, model: moved.model.key };
}
+13 -2
View File
@@ -7,12 +7,23 @@ export function installPaths(dataRoot, pin = PIN) {
const dir = path.join(dataRoot, 'opt', 'cliproxyapi', pin.version);
return { dir, binary: path.join(dir, 'cli-proxy-api'), panel: path.join(dir, 'static', 'management.html') };
}
// proxy.json records the install path from the PIN it was created under, and nothing
// rewrites it. After a PIN bump an earlier release's path under this data root stays valid
// and reads as the current pinned path. The runner executes only the hash-verified pinned
// install, never the recorded path, so an old value selects nothing.
const releasePath = (dataRoot, binary) => {
const base = path.join(dataRoot, 'opt', 'cliproxyapi') + path.sep;
if (typeof binary !== 'string' || !binary.startsWith(base)) return false;
const [version, file, ...rest] = binary.slice(base.length).split(path.sep);
return rest.length === 0 && file === 'cli-proxy-api' && /^\d{1,4}\.\d{1,4}\.\d{1,6}$/.test(version);
};
export function validateProxy(value, dataRoot, pin = PIN) {
const pinned = installPaths(dataRoot, pin).binary;
if (!value || typeof value !== 'object' || Array.isArray(value)
|| Object.keys(value).some(k => !['binary', 'port', 'rotateGraceMinutes', 'firstOutputSeconds'].includes(k))
|| !Number.isInteger(value.port) || value.port < 1024 || value.port > 65535 || value.port === 8317
|| value.binary !== installPaths(dataRoot, pin).binary) refuse('proxy-config-invalid');
return { port: value.port, binary: value.binary, ...proxyTiming(value) };
|| (value.binary !== pinned && !releasePath(dataRoot, value.binary))) refuse('proxy-config-invalid');
return { port: value.port, binary: pinned, ...proxyTiming(value) };
}
export function loadProxy(configDir, dataRoot) {
const file = path.join(configDir, 'proxy.json');
@@ -1,4 +1,4 @@
// P4 pinned8.0.42 regression: absent Claude provider config is HTTP404.
// P4 regression since PIN 8.0.42 (still so on 8.0.79): absent Claude provider config is HTTP 404.
// Normalize only that fixed GET; all other methods/endpoints/statuses refuse.
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -13,3 +13,13 @@ for (const [field, maximum, code] of [['rotateGraceMinutes', 1440, 'proxy-rotate
assert.throws(() => validateProxy({ ...base, [field]: value }, dataRoot), e => e.code === code);
});
}
// #1873 PIN bump: a sidecar written under an earlier PIN keeps the instance config valid.
test('a proxy.json written under an earlier PIN reads as the current pinned path', () => {
const old = { ...base, binary: '/fixture-data/opt/cliproxyapi/8.0.42/cli-proxy-api' };
assert.deepEqual(validateProxy(old, dataRoot), base);
assert.deepEqual(validateProxy({ ...old, rotateGraceMinutes: 60 }, dataRoot), { ...base, rotateGraceMinutes: 60 });
});
for (const binary of ['/bad', '/fixture-data/opt/cliproxyapi/8.0.42/other', '/fixture-data/opt/cliproxyapi/latest/cli-proxy-api',
'/fixture-data/opt/cliproxyapi/8.0.42/x/cli-proxy-api', '/fixture-data/opt/cliproxyapi/../cliproxyapi/8.0.42/cli-proxy-api',
'/other-data/opt/cliproxyapi/8.0.42/cli-proxy-api', '/fixture-data/opt/cliproxyapi/8.0/cli-proxy-api', 7])
test(`proxy-config-invalid: binary ${JSON.stringify(binary)}`, () => assert.throws(() => validateProxy({ ...base, binary }, dataRoot), e => e.code === 'proxy-config-invalid'));
@@ -1,4 +1,4 @@
// P4 client contract; endpoint/payload cases are probe-pending on PIN8.0.42.
// P4 client contract; endpoint/payload cases were probe-pending on PIN 8.0.42.
// Catches management key/body/query values leaking into receipts, redirects/retries.
import test from 'node:test';
import assert from 'node:assert/strict';
@@ -0,0 +1,134 @@
// #1873 ride-default slice 1: once Ride all adds the model proxy to an organization, a fenced
// proxy refuses each of that organization's launches with proxy-uncertain, a direct anthropic
// route included. A real organization bus bound to the instance's proxy, a loopback stand-in for
// the proxy's management API (made-up key, kept in this test's memory), and the real Ride all.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import http from 'node:http';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { startBroker } from '../../bus/src/runtime.mjs';
import { busOrganization } from '../../bus/src/organization-context.mjs';
import { createProxyLock } from '../../bus/src/proxy-lock.mjs';
import { Registry } from '../../seat/src/session.mjs';
import { loadBusiness } from '../../organization/src/organization-config.mjs';
import { resolveInstance } from '../../organization/src/resolve.mjs';
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
import { createProxyAdmin } from '../src/admin-control.mjs';
const MANAGE = 'ride-fence-manage';
async function ridingBus(t) {
const root = fs.mkdtempSync(join(tmpdir(), 'ride-fence-')), configDir = join(root, 'config');
fs.mkdirSync(join(configDir, 'secrets'), { recursive: true, mode: 0o700 });
fs.mkdirSync(join(root, 'proxy'), { mode: 0o700 });
let keys = ['msk-ride-fence-sentinel'];
const server = http.createServer(async (req, res) => {
const chunks = []; for await (const c of req) chunks.push(c);
if (req.headers.authorization !== `Bearer ${MANAGE}`) { res.writeHead(401); res.end('{}'); return; }
if (req.url === '/v8/management/config/access/api-keys') {
if (req.method === 'PUT') keys = JSON.parse(Buffer.concat(chunks));
res.end(JSON.stringify(req.method === 'GET' ? keys : { status: 'ok' })); return;
}
if (req.url.startsWith('/v8/management/credentials')) { res.end(JSON.stringify({ files: [], observed_at: '2026-11-19T00:00:00Z' })); return; }
if (req.url.startsWith('/v8/management/config/api-keys/')) { res.end('[]'); return; }
res.writeHead(404); res.end('{}');
});
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
const port = server.address().port;
const rolesDir = rolesCopy(root), system = systemFor(root), doc = businessDoc(root, 'demo');
// A direct anthropic route and no model provider: before Ride all, no launch asks the proxy.
doc.plugins = { ...doc.plugins, harness: ['pi'] };
doc.launch.models['claude-opus-5-5'] = { provider: 'anthropic', model: 'claude-opus-5-5' };
doc.roles.coder.vars = { ...doc.roles.coder.vars, harness: 'pi', model: 'claude-opus-5-5', thinking: 'low' };
writeJson(join(configDir, 'businesses', 'demo.json'), doc);
fs.writeFileSync(join(configDir, 'secrets', 'proxy-management.key'), MANAGE, { mode: 0o600 });
const business = loadBusiness('demo', { dir: configDir, rolesDir }), resolved = {};
for (const instance of Object.keys(business.roles)) resolved[instance] = resolveInstance({ system, business, instance });
fs.mkdirSync(join(root, 'data'), { mode: 0o700 }); new Registry(join(root, 'data'));
const bus = await startBroker({ dataRoot: join(root, 'data'), businesses: { demo: busOrganization(business, resolved) },
organization: { dir: configDir, rolesDir, system }, proxy: { port, binary: '/fixture-unused' },
org: { id: 'demo' }, instanceDataRoot: root, instanceConfigDir: configDir });
t.after(async () => { await bus.close(); server.closeAllConnections(); await new Promise(r => server.close(r)); fs.rmSync(root, { recursive: true, force: true }); });
const human = bus.broker.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
const call = async (verb, args = {}) => bus.broker.request(human, { verb, args });
const lock = createProxyLock({ stateDir: join(root, 'proxy'), identity: `${configDir}:${port}` });
const admission = async () => {
const current = JSON.parse(fs.readFileSync(join(configDir, 'businesses', 'demo.json'), 'utf8'));
const revision = (await call('plugins')).revision, entry = current.launch.models['claude-opus-5-5'];
return bus.modelAdmission({ business: 'demo', instance: 'coder', modelKey: 'claude-opus-5-5', harness: 'pi', revision, entry,
provider: entry.provider, model: entry.model, account: null, route: 'primary', transport: null });
};
return { root, configDir, bus, call, lock, admission, doc: () => JSON.parse(fs.readFileSync(join(configDir, 'businesses', 'demo.json'), 'utf8')) };
}
test('a fenced proxy refuses each riding organization\'s launches with proxy-uncertain, direct anthropic included', async t => {
const b = await ridingBus(t);
const dir = fs.mkdtempSync(join(tmpdir(), 'ride-fence-admin-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
const admin = createProxyAdmin({ dataRoot: dir, configDir: dir, unit: { status: async () => ({}) }, buses: async () => [], fetch: async () => ({}),
riders: async () => [{ id: 'demo', fixture: false, cliproxy: (b.doc().plugins['model-provider'] ?? []).includes('cliproxy'), changes: '', call: b.call }] });
const ride = await admin.rideAll();
assert.deepEqual(ride.added, ['demo'], JSON.stringify(ride));
assert.deepEqual(b.doc().plugins['model-provider'], ['cliproxy']);
assert.equal(b.doc().launch.models['claude-opus-5-5'].module, undefined, 'the direct anthropic route stays as it was');
await b.lock.run(async () => b.lock.fence({ org: 'demo', op: 'ride-fence-test' }));
assert.deepEqual(await b.admission(), { allow: false, code: 'proxy-uncertain' });
assert.deepEqual((await admin.rideAll()).already, ['demo'], 'a second Ride all leaves a riding organization alone');
});
// The launcher half: on an instance with a model proxy, a direct anthropic route never asks the
// bus's admission until the organization lists a model provider. After Ride all it does, so the
// fenced answer above refuses the launch before any run exists.
test('after Ride all the launcher asks admission for a direct anthropic route and a fenced answer refuses the launch', async t => {
const { readFileSync } = fs;
const { createLauncher } = await import('../../cli/src/launcher.mjs');
const { initializeControl } = await import('../../processing-control/src/state.mjs');
const { fakeHarnesses, fixture, tmp, withoutHostCredentials } = await import('../../cli/tests/helpers.mjs');
// Ride all writes the organization's providers through its bus's plugins.set; this stand-in bus
// applies that write to the organization file the launcher reads.
const ride = async file => {
const dir = fs.mkdtempSync(join(tmpdir(), 'ride-fence-admin-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
const call = async (verb, args = {}) => {
const doc = JSON.parse(readFileSync(file, 'utf8'));
if (verb === 'plugins') return { revision: 'r1', plugins: doc.plugins };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { assert.equal(args.revision, 'r1'); doc.plugins = { ...doc.plugins, ...args.plugins }; fs.writeFileSync(file, JSON.stringify(doc)); return { revision: 'r2' }; }
throw Object.assign(Error('unexpected verb'), { code: 'invalid-request' });
};
const admin = createProxyAdmin({ dataRoot: dir, configDir: dir, unit: { status: async () => ({}) }, buses: async () => [], fetch: async () => ({}),
riders: async () => [{ id: 'acme', fixture: false, cliproxy: false, changes: '', call }] });
assert.deepEqual((await admin.rideAll()).added, ['acme']);
};
const launchOf = async riding => {
const root = tmp(t);
const f = fixture(root, 'acme', doc => {
doc.plugins = { ...doc.plugins, harness: ['pi'] };
doc.launch.models['claude-opus-5-5'] = { provider: 'anthropic', model: 'claude-opus-5-5' };
doc.roles.coder.vars = { harness: 'pi', model: 'claude-opus-5-5', thinking: 'low' };
return doc;
});
if (riding) await ride(join(root, 'config', 'businesses', 'acme.json'));
initializeControl(f.dataRoot); withoutHostCredentials(f.env, { piKey: true });
const ops = [];
const host = { business: 'acme', beforeClose: () => {}, op: async x => {
ops.push(x.op);
if (x.op === 'identity') return { business: 'acme', role: 'pm' };
if (x.op === 'mayLaunch') return { allow: true };
if (x.op === 'modelAdmission') return { allow: false, code: 'proxy-uncertain' };
if (x.op === 'authorizeLaunch') throw Object.assign(Error('fixture authorization stop'), { code: 'fixture-policy' });
return {};
} };
const makeLoader = await fakeHarnesses(t, { pi: null }, write => write('model-provider', 'cliproxy', `export * from ${JSON.stringify(new URL('../../plugins/model-provider/cliproxy/index.mjs', import.meta.url).href)};`));
const system = { ...JSON.parse(readFileSync(f.config, 'utf8')), proxy: { port: 1, binary: '/fixture-unused' } };
const launcher = createLauncher({ host, system, env: f.env, makeLoader, bwrap: '/usr/bin/true', log: () => {} });
return { answer: await launcher.fromSession('fixture-cap', 'coder'), ops };
};
const before = await launchOf(false);
assert.equal(before.ops.includes('modelAdmission'), false, JSON.stringify(before));
assert.equal(before.ops.includes('mayLaunch'), true, 'the before launch reached the limit checks');
assert.notDeepEqual(before.answer, { ok: false, error: 'proxy-uncertain' });
const after = await launchOf(true);
assert.equal(after.ops.includes('modelAdmission'), true, JSON.stringify(after));
assert.deepEqual(after.answer, { ok: false, error: 'proxy-uncertain' });
});
+504
View File
@@ -0,0 +1,504 @@
// #1873 ride-default slice 1: Ride all adds the instance's model proxy (cliproxy) to the owner's
// organizations, skips and names the ones it must not change, and lists fixture organizations,
// which move to the owner's models only by a separate confirmed action.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { createHash } from 'node:crypto';
import { createProxyAdmin } from '../src/admin-control.mjs';
import { initFiles, receiptFile, appendReceipt, receiptsText, ownedText } from '../src/admin.mjs';
import { execFileSync } from 'node:child_process';
import { PIN } from '../src/common.mjs';
import { cliproxyRemoved, localRide, riddenOrgs, pickModel, fixtureMove, moveFixtureOrg, readRider, ownerModelsFrom } from '../src/ride.mjs';
import * as orgService from '../../organization/src/org-service.mjs';
import { orgUsesFixture } from '../../cli/src/dev-fixture.mjs';
const stopped = async () => ({ stopped: true, running: [] });
const row = (over = {}) => ({ key: 'claude-claude-opus-5-5', module: 'cliproxy', upstream: 'claude', provider: 'anthropic', model: 'claude-opus-5-5', label: 'Claude Opus 5.5', available: true, reason: null, harnesses: ['claude-code', 'pi'], ...over });
const glm = row({ key: 'zai-glm-5-3', upstream: 'zai', provider: 'zai', model: 'glm-5.3', label: 'GLM 5.3', harnesses: ['pi'] });
const committed = changes => JSON.stringify({ state: 'committed', changes }) + '\n';
const busError = code => Object.assign(new Error('bus text that must not leak'), { code });
// A fake organization bus: `plugins` answers the providers and revision; `proxy.accounts` answers
// or throws; `plugins.set` records the write.
function bus({ providers = ['fixture'], down = false, client = true, accounts = null, set = null } = {}) {
const calls = [];
const call = async (verb, args) => {
calls.push([verb, args]);
if (down) throw busError('no-bus-host');
if (verb === 'plugins') return { business: 'x', revision: 'rev-1', plugins: { 'model-provider': providers }, available: {} };
if (verb === 'proxy.accounts') { if (accounts) throw accounts; if (!client) throw busError('not-configured'); return { accounts: [] }; }
if (verb === 'plugins.set') { if (set) throw set; providers = args.plugins['model-provider']; return { revision: 'rev-2' }; }
throw new Error(`unexpected ${verb}`);
};
return { call, calls };
}
function admin(t, { riders, ownerModels, move, unitState } = {}) {
const root = fs.mkdtempSync(join(tmpdir(), 'rd-'));
t.after(() => fs.rmSync(root, { recursive: true, force: true }));
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
const state = unitState ?? { installed: false, active: 'inactive', healthy: false };
const unit = { unit: 'mosaic-proxy-zz.service', status: async () => ({ unit: 'mosaic-proxy-zz.service', ...state }) };
const sha = text => createHash('sha256').update(text).digest('hex');
const pin = { ...PIN, archive: { ...PIN.archive, sha256: sha('a') }, binary: { sha256: sha('b') }, panel: { ...PIN.panel, sha256: sha('p') } };
const a = createProxyAdmin({ dataRoot, configDir, unit, buses: stopped, fetch: async () => ({}), now: () => new Date(0), pin,
...(riders ? { riders } : {}), ...(ownerModels ? { ownerModels } : {}), ...(move !== undefined ? { move } : {}) });
return { admin: a, configDir, dataRoot, pin, state };
}
const receipts = dataRoot => { try { return fs.readFileSync(receiptFile(dataRoot), 'utf8').trim().split('\n').filter(Boolean).map(JSON.parse); } catch { return []; } };
test('a change log shows cliproxy removed only when a committed write took it off', () => {
assert.equal(cliproxyRemoved(''), false);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['fixture', 'cliproxy'] }])), false);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }])), true);
assert.equal(cliproxyRemoved(committed([{ path: 'plugins', old: { 'model-provider': ['cliproxy'] }, new: { 'model-provider': ['fixture'] } }])), true);
assert.equal(cliproxyRemoved(JSON.stringify({ state: 'staged', changes: [{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }] }) + '\n'), false, 'a write that did not commit removed nothing');
assert.equal(cliproxyRemoved(committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }, { path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]) ), true, 'a removal stays a removal once seen');
assert.equal(cliproxyRemoved('{not json\n'), null);
assert.equal(cliproxyRemoved(null), null);
});
test('the local rule names unreadable, removed, fixture, already and ready in that order', () => {
const removed = committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]);
assert.equal(localRide({ fixture: undefined, cliproxy: false, changes: '' }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: undefined, changes: '' }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: null }), 'unreadable');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: removed }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: '' }), 'fixture');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '' }), 'already');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '' }), 'ready');
// Review round: an organization that uses cliproxy now is already riding, whatever its history.
assert.equal(localRide({ fixture: false, cliproxy: true, changes: removed }), 'already', 'removed once and added back');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: null }), 'already');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: '' }), 'fixture');
// The proxy's receipts show it put cliproxy on the organization, and it lacks cliproxy now.
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '', ridden: true }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: false, changes: '', ridden: true }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '', ridden: true }), 'already');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: '', ridden: null }), 'unreadable');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: '', ridden: null }), 'already');
});
test('the proxy receipts name each organization ride all added, tried to add, moved or saw removed', () => {
const lines = records => records.map(r => JSON.stringify(r)).join('\n') + '\n';
const text = lines([{ op: 'ride-all', added: ['a', 'b'], skipped: [{ id: 'c', reason: 'bus-down' }], fixtures: ['d'] }, { op: 'ride-move', org: 'e', model: 'm' },
{ op: 'fetch', added: ['f'] }, { op: 'ride-intent', org: 'g' }, { op: 'ride-removed', org: 'h' }]);
assert.deepEqual([...riddenOrgs(text)].sort(), ['a', 'b', 'e', 'g', 'h']);
assert.deepEqual([...riddenOrgs('')], []);
assert.equal(riddenOrgs(null), null);
// Round 3 (P2a): a line that does not parse, or a ride record of the wrong shape, fails closed.
assert.equal(riddenOrgs(text + '{torn'), null, 'a torn line');
assert.equal(riddenOrgs(lines([{ op: 'ride-all', added: [7] }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-all', added: 'a' }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-intent' }])), null);
assert.equal(riddenOrgs(lines([{ op: 'ride-removed', org: 3 }])), null);
assert.equal(riddenOrgs('7\n'), null, 'a line that is not a record');
// Round 3 (P2b): an intent the bus then showed was not applied is cleared, and only that intent.
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], []);
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-all', added: ['g'] }, { op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], ['g'], 'an earlier add stays');
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-removed', org: 'g' }, { op: 'ride-intent', org: 'g' }, { op: 'ride-not-added', org: 'g' }]))], ['g'], 'an earlier removal stays');
assert.deepEqual([...riddenOrgs(lines([{ op: 'ride-not-added', org: 'g' }, { op: 'ride-intent', org: 'g' }]))], ['g'], 'a later intent stands');
});
test('a change log that shows cliproxy on the organization at any time, or a write to its providers it cannot read, counts as removed once cliproxy is gone', () => {
// Round 3 (P1 case b): added on the Settings page, then removed on the admin page, which writes no log entry.
const added = committed([{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]);
assert.equal(localRide({ fixture: false, cliproxy: false, changes: added }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: true, changes: added }), 'already');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: added }), 'fixture', 'a fixture organization that lists cliproxy is still listed to move');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins', old: null, new: { 'model-provider': ['cliproxy'] } }]) }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: '', old: null, new: { plugins: { 'model-provider': ['cliproxy'] } } }]) }), 'removed');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', oldPresent: true, newPresent: true }]) }), 'removed', 'a paths-only write to the providers');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'roles.chief.vars', oldPresent: true, newPresent: true }]) }), 'ready', 'a paths-only write elsewhere');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['openai'] }]) }), 'ready');
assert.equal(localRide({ fixture: false, cliproxy: false, changes: JSON.stringify({ state: 'aborted', changes: [{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }] }) + '\n' }), 'ready', 'a write that did not commit');
});
test('the reviewer probe: an organization created from the cliproxy preset and saved without it on its admin page is skipped as removed', async t => {
// P1 case a. Nothing in the change log: the preset made it, the admin page took it off. The
// admin page leaves a ride-removed receipt (proxy admin rideRemoved) before it saves.
const b = bus({ providers: [] });
const { admin: a, dataRoot } = admin(t, { riders: async () => [{ id: 'p', fixture: false, cliproxy: false, changes: '', call: b.call }] });
assert.equal(a.rideRemoved('p').op, 'ride-removed');
const r = await a.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 'p', reason: 'removed' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(dataRoot).filter(x => x.op === 'ride-removed').map(x => x.org), ['p']);
assert.throws(() => a.rideRemoved('../x'), /proxy-org-invalid|invalid/);
});
test('the reviewer probe: an organization added on the Settings page and removed on its admin page is skipped as removed', async t => {
// P1 case b, with no ride-removed receipt at all: the change log's add is enough.
const b = bus({ providers: [] });
const log = committed([{ path: 'plugins.model-provider', old: [], new: ['cliproxy'] }]);
const { admin: a } = admin(t, { riders: async () => [{ id: 's', fixture: false, cliproxy: false, changes: log, call: b.call }] });
const r = await a.rideAll();
assert.deepEqual(r.added, []); assert.deepEqual(r.skipped, [{ id: 's', reason: 'removed' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
});
test('each add leaves its intent receipt before plugins.set, and an add whose outcome is unknown stays recorded', async t => {
// P2b. The bus reads the receipts at the moment of the write.
let seen = null, dataRootOf = null;
const order = [];
const watching = id => { const b = bus({ providers: [] }); const call = async (verb, args) => { if (verb === 'plugins.set') { order.push(id); seen = receipts(dataRootOf()).map(r => `${r.op}:${r.org ?? ''}`); } return b.call(verb, args); }; return { ...b, call }; };
const one = watching('one'), two = watching('two');
const f = admin(t, { riders: async () => [{ id: 'one', fixture: false, cliproxy: false, changes: '', call: one.call }, { id: 'two', fixture: false, cliproxy: false, changes: '', call: two.call }] });
dataRootOf = () => f.dataRoot;
await f.admin.rideAll();
assert.deepEqual(order, ['one', 'two']);
assert.deepEqual(seen, ['ride-intent:one', 'ride-intent:two'], 'the first add is on record before the second starts');
// Probe C: plugins.set commits, then the call times out. The bus shows cliproxy, so the intent stands.
let providers = [];
const timeout = { calls: [], call: async (verb, args) => {
if (verb === 'plugins') return { revision: 'r1', plugins: { 'model-provider': providers } };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { providers = args.plugins['model-provider']; throw busError('timeout'); }
} };
let cp = false;
const c = admin(t, { riders: async () => [{ id: 't', fixture: false, cliproxy: cp, changes: '', call: timeout.call }] });
const first = await c.admin.rideAll();
assert.deepEqual(first.skipped, [{ id: 't', reason: 'timeout' }]);
assert.deepEqual(receipts(c.dataRoot).filter(r => r.org === 't').map(r => r.op), ['ride-intent']);
providers = []; // the owner took it off
assert.deepEqual((await c.admin.rideAll()).skipped, [{ id: 't', reason: 'removed' }]);
// A refusal the bus shows was not applied clears the intent, so the organization can ride later.
const refusedBus = bus({ providers: [], set: busError('revision-conflict') });
const d = admin(t, { riders: async () => [{ id: 'q', fixture: false, cliproxy: false, changes: '', call: refusedBus.call }] });
assert.deepEqual((await d.admin.rideAll()).skipped, [{ id: 'q', reason: 'revision-conflict' }]);
assert.deepEqual(receipts(d.dataRoot).filter(r => r.org === 'q').map(r => r.op), ['ride-intent', 'ride-not-added']);
assert.deepEqual((await d.admin.status()).ride, [{ id: 'q', state: 'ready' }]);
// A bus that does not answer the re-read leaves the intent: the add may have happened.
let gone = false;
const lost = { call: async (verb, args) => { if (gone) throw busError('no-bus-host'); if (verb === 'plugins') return { revision: 'r1', plugins: { 'model-provider': [] } }; if (verb === 'proxy.accounts') return { accounts: [] }; if (verb === 'plugins.set') { gone = true; throw busError('timeout'); } } };
const e = admin(t, { riders: async () => [{ id: 'l', fixture: false, cliproxy: false, changes: '', call: lost.call }] });
await e.admin.rideAll();
assert.deepEqual(receipts(e.dataRoot).filter(r => r.org === 'l').map(r => r.op), ['ride-intent']);
});
test('a removal saved while Ride all works on earlier organizations is read before the later add', async t => {
// Re-check 3, P3-1: the run's first read of the receipts showed nothing for 'late'. While the run
// reads 'first', the owner takes cliproxy off 'late' on its admin page (a ride-removed receipt).
let a = null;
const first = bus({ providers: [] }), late = bus({ providers: [] });
const firstCall = async (verb, args) => { if (verb === 'plugins') a.rideRemoved('late'); return first.call(verb, args); };
const f = admin(t, { riders: async () => [{ id: 'first', fixture: false, cliproxy: false, changes: '', call: firstCall }, { id: 'late', fixture: false, cliproxy: false, changes: '', call: late.call }] });
a = f.admin;
const r = await a.rideAll();
assert.deepEqual(r.added, ['first']); assert.deepEqual(r.skipped, [{ id: 'late', reason: 'removed' }]);
assert.equal(late.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual(receipts(f.dataRoot).filter(x => x.org === 'late').map(x => x.op), ['ride-removed']);
// Receipts that turn unreadable during the run skip the later add as unreadable.
const g1 = bus({ providers: [] }), g2 = bus({ providers: [] });
let g = null;
const tear = async (verb, args) => { if (verb === 'plugins') { appendReceipt(g.dataRoot, { op: 'fetch' }); fs.appendFileSync(receiptFile(g.dataRoot), '{torn\n'); } return g1.call(verb, args); };
g = admin(t, { riders: async () => [{ id: 'one', fixture: false, cliproxy: false, changes: '', call: tear }, { id: 'two', fixture: false, cliproxy: false, changes: '', call: g2.call }] });
const s = await g.admin.rideAll();
assert.deepEqual(s.skipped, [{ id: 'one', reason: 'unreadable' }, { id: 'two', reason: 'unreadable' }]);
assert.equal(g2.calls.some(([v]) => v === 'plugins.set'), false);
});
test('an intent receipt that cannot be written stops that add before plugins.set', async t => {
const b = bus({ providers: [] });
const f = admin(t, { riders: async () => [{ id: 'w', fixture: false, cliproxy: false, changes: '', call: b.call }] });
appendReceipt(f.dataRoot, { op: 'fetch' });
fs.chmodSync(receiptFile(f.dataRoot), 0o400); // readable by its owner only, not writable
const r = await f.admin.rideAll();
assert.deepEqual(r.skipped, [{ id: 'w', reason: 'not-recorded' }]);
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
});
test('receipts that are torn, a symlink, not the owner\'s or open to others are unreadable, and every organization without cliproxy is skipped', async t => {
// P2a and P3 (probes D and E).
const b = bus({ providers: [] });
const f = admin(t, { riders: async () => [{ id: 'z', fixture: false, cliproxy: false, changes: '', call: b.call }, { id: 'y', fixture: false, cliproxy: true, changes: '', call: b.call }] });
const file = receiptFile(f.dataRoot);
appendReceipt(f.dataRoot, { op: 'fetch' });
fs.appendFileSync(file, '{"op":"ride-all","added":["z"]');
let r = await f.admin.rideAll();
assert.deepEqual(r.skipped, [{ id: 'z', reason: 'unreadable' }], 'torn'); assert.deepEqual(r.already, ['y']);
fs.rmSync(file); fs.writeFileSync(join(f.dataRoot, 'state', 'empty'), '', { mode: 0o600 });
fs.symlinkSync(join(f.dataRoot, 'state', 'empty'), file);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'symlink');
assert.equal(fs.lstatSync(file).isSymbolicLink(), true);
fs.rmSync(file); fs.writeFileSync(file, '', { mode: 0o600 }); fs.chmodSync(file, 0o640);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'group-readable');
fs.rmSync(file); fs.mkdirSync(file);
assert.deepEqual((await f.admin.rideAll()).skipped, [{ id: 'z', reason: 'unreadable' }], 'not a file');
fs.rmSync(file, { recursive: true });
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false);
assert.deepEqual((await f.admin.rideAll()).added, ['z'], 'no receipt file is no history');
});
test('the receipts are read only when the Console\'s own user owns them', t => {
const f = admin(t);
appendReceipt(f.dataRoot, { op: 'ride-removed', org: 'p' });
assert.match(receiptsText(f.dataRoot), /"ride-removed"/);
assert.equal(receiptsText(f.dataRoot, { uid: process.getuid() + 1 }), null, 'another user\'s file');
});
test('a FIFO in place of the receipts is unreadable and never blocks the read', t => {
const f = admin(t);
fs.mkdirSync(join(f.dataRoot, 'state'), { mode: 0o700 });
execFileSync('mkfifo', ['-m', '600', receiptFile(f.dataRoot)]);
assert.equal(receiptsText(f.dataRoot), null);
});
test('the change log read takes the writer\'s rule: group readable is fine, group writable, a symlink or a missing file is not', t => {
const dir = fs.mkdtempSync(join(tmpdir(), 'rdo-')); t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
const file = join(dir, 'changes.jsonl'); fs.writeFileSync(file, 'x\n', { mode: 0o600 }); fs.chmodSync(file, 0o640);
assert.equal(ownedText(file, { mask: 0o022 }), 'x\n');
fs.chmodSync(file, 0o660);
assert.throws(() => ownedText(file, { mask: 0o022 }), { code: 'proxy-file-refused' });
fs.chmodSync(file, 0o600); fs.symlinkSync(file, join(dir, 'link'));
assert.throws(() => ownedText(join(dir, 'link'), { mask: 0o022 }), { code: 'ELOOP' });
assert.throws(() => ownedText(join(dir, 'gone'), { mask: 0o022 }), { code: 'ENOENT' });
// readRider, as the Console wires it: a refused log is unreadable, a missing one is empty.
const doc = { plugins: { 'model-provider': [] } };
fs.chmodSync(file, 0o660);
assert.equal(readRider({ id: 'a', read: () => doc, readLog: () => ownedText(file, { mask: 0o022 }), isFixture: () => false }).changes, null);
assert.equal(readRider({ id: 'a', read: () => doc, readLog: () => ownedText(join(dir, 'gone'), { mask: 0o022 }), isFixture: () => false }).changes, '');
});
test('a fixture organization that uses cliproxy now, with a removal in its log, is removed, not movable', () => {
const log = committed([{ path: 'plugins.model-provider', old: ['fixture', 'cliproxy'], new: ['fixture'] }]) + committed([{ path: 'plugins.model-provider', old: ['fixture'], new: ['fixture', 'cliproxy'] }]);
assert.equal(localRide({ fixture: true, cliproxy: true, changes: log }), 'removed');
assert.equal(localRide({ fixture: true, cliproxy: true, changes: '' }), 'fixture');
});
test('an organization ride all once added and its owner then saved without cliproxy is skipped as removed', async t => {
// The organization's file as the Console reads it. The organization admin page saves a whole
// document and writes no change-log entry, so the log stays empty after the owner's removal.
let cliproxy = false;
const b = bus({ providers: [] });
const { admin: a, dataRoot } = admin(t, { riders: async () => [{ id: 'a', fixture: false, cliproxy, changes: '', call: b.call }] });
assert.deepEqual((await a.rideAll()).added, ['a']);
cliproxy = true;
assert.deepEqual((await a.rideAll()).already, ['a']);
cliproxy = false; // the owner saved the organization without cliproxy on its admin page
const second = await a.rideAll();
assert.deepEqual(second.skipped, [{ id: 'a', reason: 'removed' }], JSON.stringify(second));
assert.equal(b.calls.filter(([verb]) => verb === 'plugins.set').length, 1, 'no second write');
assert.deepEqual((await a.status()).ride, [{ id: 'a', state: 'removed' }]);
// A fixture organization the proxy once moved, and its owner then put back on stand-in models, is not moved again.
const moved = { id: 'f', fixture: true, cliproxy: false, changes: '', call: bus({ down: true }).call };
const m = admin(t, { riders: async () => [moved], ownerModels: async () => ({ proxy: true, riding: true, models: [row()] }), move: async () => ({ moved: true, model: row().key }) });
appendReceipt(m.dataRoot, { op: 'ride-move', org: 'f', model: row().key });
assert.deepEqual(await m.admin.rideMove({ org: 'f' }), { org: 'f', moved: false, reason: 'removed' });
// Receipts that cannot be read name every organization without cliproxy unreadable.
fs.chmodSync(receiptFile(dataRoot), 0o200);
assert.deepEqual((await a.rideAll()).skipped, [{ id: 'a', reason: 'unreadable' }]);
});
test('the owner model is a usable catalogue row that serves every harness, claude first', () => {
assert.equal(pickModel([glm, row()]).key, 'claude-claude-opus-5-5');
assert.equal(pickModel([glm]).key, 'zai-glm-5-3');
assert.equal(pickModel([glm, row()], ['claude-code']).key, 'claude-claude-opus-5-5');
assert.equal(pickModel([glm], ['claude-code']), null);
assert.equal(pickModel([row({ available: false }), row({ reason: 'unverified' }), row({ module: 'fixture' })]), null, 'a model the catalogue does not offer is never picked');
assert.equal(pickModel(null), null);
});
test('ride all adds cliproxy through plugins.set and skips and names each organization it must not change', async t => {
const ready = bus({ providers: [] }), noClient = bus({ providers: [], client: false }), down = bus({ down: true }), checkFails = bus({ providers: [], accounts: busError('proxy-down') });
const refused = bus({ providers: [], set: busError('revision-conflict') }), alreadyBus = bus({ providers: ['cliproxy'] }), removedBus = bus({ providers: [] }), fixtureBus = bus({ down: true });
const unreadable = bus({ providers: [] }), raced = bus({ providers: ['cliproxy'] });
const riders = async () => [
{ id: 'ready', fixture: false, cliproxy: false, changes: '', call: ready.call },
{ id: 'removed', fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]), call: removedBus.call },
{ id: 'down', fixture: false, cliproxy: false, changes: '', call: down.call },
{ id: 'noclient', fixture: false, cliproxy: false, changes: '', call: noClient.call },
{ id: 'checkfails', fixture: false, cliproxy: false, changes: '', call: checkFails.call },
{ id: 'refused', fixture: false, cliproxy: false, changes: '', call: refused.call },
{ id: 'already', fixture: false, cliproxy: true, changes: '', call: alreadyBus.call },
{ id: 'raced', fixture: false, cliproxy: false, changes: '', call: raced.call },
{ id: 'unreadable', fixture: undefined, cliproxy: undefined, changes: '', call: unreadable.call },
{ id: 'stand-in', fixture: true, cliproxy: false, changes: '', call: fixtureBus.call, status: async () => ({ pid: null }) },
];
const { admin: a, dataRoot } = admin(t, { riders });
const result = await a.rideAll();
assert.deepEqual(result.added, ['ready']);
assert.deepEqual(result.already, ['already', 'raced']);
assert.deepEqual(result.skipped, [
{ id: 'removed', reason: 'removed' }, { id: 'down', reason: 'bus-down' }, { id: 'noclient', reason: 'no-proxy-client' },
{ id: 'checkfails', reason: 'proxy-check-failed' }, { id: 'refused', reason: 'revision-conflict' }, { id: 'unreadable', reason: 'unreadable' },
]);
assert.deepEqual(result.fixtures, [{ id: 'stand-in', running: false }]);
assert.deepEqual(ready.calls.find(([v]) => v === 'plugins.set'), ['plugins.set', { revision: 'rev-1', plugins: { 'model-provider': ['cliproxy'] } }]);
for (const [name, b] of Object.entries({ removedBus, down, noClient, checkFails, alreadyBus, raced, unreadable, fixtureBus }))
assert.equal(b.calls.some(([v]) => v === 'plugins.set'), false, `${name} gets no write`);
assert.equal(JSON.stringify(result).includes('must not leak'), false);
const last = receipts(dataRoot).at(-1);
assert.equal(last.op, 'ride-all'); assert.deepEqual(last.added, ['ready']); assert.deepEqual(last.fixtures, ['stand-in']);
});
test('ride all keeps the providers an organization already has', async t => {
const b = bus({ providers: ['openai'] });
const { admin: a } = admin(t, { riders: async () => [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: b.call }] });
assert.deepEqual((await a.rideAll()).added, ['o']);
assert.deepEqual(b.calls.find(([v]) => v === 'plugins.set')[1].plugins, { 'model-provider': ['openai', 'cliproxy'] });
});
test('status names ride all after accounts while an organization can still ride', async t => {
let list = [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: bus().call }];
const f = admin(t, { riders: async () => list, unitState: { installed: true, active: 'active', healthy: true, pid: 3 } });
const binDir = join(f.dataRoot, 'opt', 'cliproxyapi', PIN.version);
fs.mkdirSync(join(binDir, 'static'), { recursive: true });
fs.writeFileSync(join(binDir, 'cli-proxy-api'), 'b'); fs.writeFileSync(join(binDir, 'static', 'management.html'), 'p');
const files = initFiles(f.configDir, f.dataRoot);
fs.mkdirSync(join(f.configDir, 'secrets'), { mode: 0o700 }); fs.writeFileSync(files.key, 'fixture', { mode: 0o600 });
fs.mkdirSync(files.proxyDir, { mode: 0o700 });
fs.writeFileSync(files.settings, JSON.stringify({ binary: join(binDir, 'cli-proxy-api'), port: 18432 }), { mode: 0o600 });
let status = await f.admin.status();
assert.deepEqual(status.next, ['accounts', 'ride-all']);
assert.deepEqual(status.ride, [{ id: 'o', state: 'ready' }]);
list = [{ id: 'o', fixture: true, cliproxy: false, changes: '', call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['accounts', 'ride-all'], 'a fixture organization can still be moved');
list = [{ id: 'o', fixture: false, cliproxy: true, changes: '', call: bus().call }];
status = await f.admin.status();
assert.deepEqual(status.next, ['accounts']);
list = [{ id: 'o', fixture: false, cliproxy: false, changes: committed([{ path: 'plugins.model-provider', old: ['cliproxy'], new: [] }]), call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['accounts'], 'a removed organization is not a reason to ride');
f.state.healthy = false;
list = [{ id: 'o', fixture: false, cliproxy: false, changes: '', call: bus().call }];
assert.deepEqual((await f.admin.status()).next, ['unit-restart'], 'never before the proxy answers');
});
test('a fixture organization moves only when stopped, with a proxy, a riding bus and a move seam', async t => {
const owner = { proxy: true, riding: true, models: [row()] };
const moves = [];
const move = async (id, models, principal) => { moves.push({ id, models, principal }); return { moved: true, model: models[0].key }; };
let stoppedBus = bus({ down: true }), runningBus = bus();
// Round 3 (P2c): stopped is the organization admin page's test, a bus status with no process id.
const stopped = async () => ({ healthy: false, pid: null }), running = async () => ({ healthy: true, pid: 4242 });
const riders = async () => [
{ id: 'stand-in', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: stopped },
{ id: 'live', fixture: true, cliproxy: false, changes: '', call: runningBus.call, status: running },
{ id: 'busy', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: async () => ({ healthy: false, pid: 4343 }) },
{ id: 'unproven', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call, status: async () => { throw busError('stale-host'); } },
{ id: 'no-status', fixture: true, cliproxy: false, changes: '', call: stoppedBus.call },
{ id: 'real', fixture: false, cliproxy: false, changes: '', call: stoppedBus.call, status: stopped },
];
let ownerNow = owner;
const f = admin(t, { riders, ownerModels: async () => ownerNow, move });
const principal = { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' };
assert.deepEqual(await f.admin.rideMove({ org: 'nope', principal }), { org: 'nope', moved: false, reason: 'unknown' });
assert.deepEqual(await f.admin.rideMove({ org: 'real', principal }), { org: 'real', moved: false, reason: 'ready' });
assert.deepEqual(await f.admin.rideMove({ org: 'live', principal }), { org: 'live', moved: false, reason: 'bus-running' });
// A slow or busy bus that does not answer, a status that cannot be read, or no status at all is running.
for (const org of ['busy', 'unproven', 'no-status']) assert.deepEqual(await f.admin.rideMove({ org, principal }), { org, moved: false, reason: 'bus-running' }, org);
const listed = await f.admin.rideAll();
assert.deepEqual(listed.fixtures, [{ id: 'stand-in', running: false }, { id: 'live', running: true }, { id: 'busy', running: true }, { id: 'unproven', running: true }, { id: 'no-status', running: true }]);
ownerNow = { ...owner, proxy: false };
assert.deepEqual(await f.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'no-proxy' });
ownerNow = { ...owner, riding: false };
assert.deepEqual(await f.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'no-riding-bus' });
assert.equal(moves.length, 0);
ownerNow = owner;
const done = await f.admin.rideMove({ org: 'stand-in', principal });
assert.equal(done.moved, true); assert.equal(done.model, 'claude-claude-opus-5-5');
assert.deepEqual(moves, [{ id: 'stand-in', models: [row()], principal }]);
const last = receipts(f.dataRoot).at(-1);
assert.deepEqual({ op: last.op, org: last.org, model: last.model }, { op: 'ride-move', org: 'stand-in', model: 'claude-claude-opus-5-5' });
const none = admin(t, { riders, ownerModels: async () => owner, move: null });
assert.deepEqual(await none.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'not-available' });
const throws = admin(t, { riders, ownerModels: async () => owner, move: async () => { throw Object.assign(new Error('raw text'), { code: 'revision-conflict' }); } });
assert.deepEqual(await throws.admin.rideMove({ org: 'stand-in', principal }), { org: 'stand-in', moved: false, reason: 'revision-conflict' });
});
test('the fixture move rewrites the model provider, the model entry and every role that used it', async () => {
const doc = await orgService.templateRender('alpha', { fixture: 'local' });
Object.assign(doc.roles.assistant.vars, { 'fallback.harness': 'pi', 'fallback.model': 'fixture-deterministic', 'fallback.thinking': 'off' });
doc.projects.work.agents = { helper: { definition: 'coder', vars: { harness: 'pi', model: 'fixture-deterministic', thinking: 'off' } } };
assert.deepEqual(await orgService.validateOrg(doc), { ok: true, errors: [] });
assert.equal(orgUsesFixture(doc), true);
const { doc: next, model } = fixtureMove(doc, [glm, row()]);
assert.equal(model.key, 'claude-claude-opus-5-5', 'the fixture assistant runs pi; of the models that serve pi, claude comes first');
assert.equal(orgUsesFixture(next), false);
assert.deepEqual(next.plugins['model-provider'], ['cliproxy']);
assert.deepEqual(next.launch.models, { 'claude-claude-opus-5-5': { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' } });
assert.equal(next.roles.assistant.vars.model, 'claude-claude-opus-5-5');
assert.equal(next.roles.assistant.vars['fallback.model'], 'claude-claude-opus-5-5');
assert.equal(next.roles.assistant.vars.harness, 'pi', 'the harness is left as it was');
assert.equal(next.projects.work.agents.helper.vars.model, 'claude-claude-opus-5-5', 'a project\'s own agent moves too');
assert.deepEqual(await orgService.validateOrg(next), { ok: true, errors: [] });
const zai = fixtureMove(doc, [glm]);
assert.equal(zai.model.key, 'zai-glm-5-3');
assert.deepEqual(zai.doc.launch.models, { 'zai-glm-5-3': { provider: 'zai', model: 'glm-5.3', module: 'cliproxy', upstream: 'zai' } });
assert.deepEqual(await orgService.validateOrg(zai.doc), { ok: true, errors: [] });
assert.equal(doc.plugins['model-provider'][0], 'fixture', 'the input is not changed');
assert.deepEqual(fixtureMove(doc, [row({ harnesses: ['claude-code'] })]), { reason: 'no-model' }, 'a model that cannot serve the harness is not used');
assert.deepEqual(fixtureMove(doc, [row({ available: false, harnesses: ['pi'] })]), { reason: 'no-model' }, 'a model the catalogue does not offer is not used');
});
test('the fixture move writes through the organization service as the owner, and only at the revision read', async () => {
const root = fs.mkdtempSync(join(tmpdir(), 'rd-svc-'));
try {
const configDir = join(root, 'config'), dataRoot = join(root, 'data');
fs.mkdirSync(configDir, { mode: 0o700 }); fs.mkdirSync(dataRoot, { mode: 0o700 });
const ctx = { configDir, dataRoot, instance: 'test', principal: { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' } };
await orgService.createOrg(ctx, 'alpha', await orgService.templateRender('alpha', { fixture: 'local' }));
const stranger = { ...ctx, principal: { provider: 'sso', iss: 'https://idp.invalid', sub: 'someone' } };
await assert.rejects(moveFixtureOrg({ service: orgService, ctx: stranger, id: 'alpha', models: [row()] }));
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true, 'a stranger moved nothing');
assert.deepEqual(await moveFixtureOrg({ service: orgService, ctx, id: 'alpha', models: [row({ harnesses: ['claude-code'] })] }), { moved: false, reason: 'no-model' });
// A moved document the service does not accept is not written.
const refusing = { ...orgService, validateOrg: async () => ({ ok: false, errors: [{ path: '$', message: 'no' }] }) };
assert.deepEqual(await moveFixtureOrg({ service: refusing, ctx, id: 'alpha', models: [row()] }), { moved: false, reason: 'invalid' });
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true, 'an invalid move wrote nothing');
// A write between the read and the update loses: the service refuses the stale revision.
const racing = { ...orgService, validateOrg: async d => { const now = await orgService.showOrg(ctx, 'alpha'); await orgService.updateOrg(ctx, 'alpha', now.doc, { ifRevision: now.revision }); return orgService.validateOrg(d); } };
await assert.rejects(moveFixtureOrg({ service: racing, ctx, id: 'alpha', models: [row()] }), { code: 'revision-conflict' });
assert.equal(orgUsesFixture((await orgService.showOrg(ctx, 'alpha')).doc), true);
assert.deepEqual(await moveFixtureOrg({ service: orgService, ctx, id: 'alpha', models: [row()] }), { moved: true, model: 'claude-claude-opus-5-5' });
const after = (await orgService.showOrg(ctx, 'alpha')).doc;
assert.equal(orgUsesFixture(after), false);
assert.deepEqual(after.plugins['model-provider'], ['cliproxy']);
assert.equal(after.roles.assistant.vars.model, 'claude-claude-opus-5-5');
assert.deepEqual(after.launch.models['claude-claude-opus-5-5'], { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' });
} finally { fs.rmSync(root, { recursive: true, force: true }); }
});
test('an organization is read from its file and change log; a missing log is empty and any other failure unreadable', () => {
const enoent = () => { throw Object.assign(new Error('missing'), { code: 'ENOENT' }); };
const eacces = () => { throw Object.assign(new Error('denied'), { code: 'EACCES' }); };
const doc = providers => ({ plugins: { 'model-provider': providers } });
assert.deepEqual(readRider({ id: 'a', read: () => doc(['cliproxy']), readLog: () => 'log', isFixture: () => false }), { id: 'a', fixture: false, cliproxy: true, changes: 'log' });
assert.deepEqual(readRider({ id: 'b', read: () => doc(['fixture']), readLog: enoent, isFixture: () => true }), { id: 'b', fixture: true, cliproxy: false, changes: '' });
assert.deepEqual(readRider({ id: 'c', read: () => ({}), readLog: eacces, isFixture: () => false }), { id: 'c', fixture: false, cliproxy: false, changes: null });
const unread = readRider({ id: 'd', read: () => { throw new Error('bad json'); }, readLog: () => '', isFixture: () => true });
assert.deepEqual(unread, { id: 'd', fixture: undefined, cliproxy: undefined, changes: '' });
assert.equal(localRide(unread), 'unreadable');
assert.equal(localRide(readRider({ id: 'c', read: () => ({}), readLog: eacces, isFixture: () => false })), 'unreadable');
// The real fixture test decides the fixture field.
assert.equal(readRider({ id: 'e', read: () => doc(['fixture']), readLog: () => '', isFixture: orgUsesFixture }).fixture, true);
});
test('the owner models come only from riding buses that answer a ready catalogue, cliproxy rows once each', async () => {
const asked = [];
const rider = (id, cliproxy, answer) => ({ id, cliproxy, call: async verb => { asked.push([id, verb]); if (answer instanceof Error) throw answer; return answer; } });
const ready = models => ({ catalogue: { status: 'ready', models } });
assert.deepEqual(await ownerModelsFrom({ proxy: false, riders: [rider('a', true, ready([row()]))] }), { proxy: false, riding: false, models: [] });
assert.deepEqual(asked, [], 'no proxy asks no bus');
const fixtureRow = row({ key: 'fixture-deterministic', module: 'fixture' });
const answer = await ownerModelsFrom({ proxy: true, riders: [
rider('a', true, ready([row(), fixtureRow])), rider('b', true, ready([row({ label: 'later copy' }), glm])), rider('c', false, ready([row({ key: 'not-riding' })])),
rider('d', true, { catalogue: { status: 'unavailable', models: [row({ key: 'fenced' })] } }), rider('e', true, busError('no-bus-host')),
] });
assert.deepEqual(answer, { proxy: true, riding: true, models: [row(), glm] });
assert.deepEqual(asked.map(([id]) => id).sort(), ['a', 'b', 'd', 'e'], 'only organizations that list cliproxy are asked');
assert.deepEqual(await ownerModelsFrom({ proxy: true, riders: [rider('d', true, { catalogue: { status: 'unavailable', models: [] } }), rider('e', true, busError('no-bus-host'))] }), { proxy: true, riding: false, models: [] });
// A hung bus does not hold the others back: they are asked together.
let release; const hung = { id: 'h', cliproxy: true, call: () => new Promise(r => { release = r; }) };
const pending = ownerModelsFrom({ proxy: true, riders: [hung, rider('a', true, ready([row()]))] });
await new Promise(r => setImmediate(r));
assert.equal(asked.filter(([id]) => id === 'a').length, 2, 'the second bus was asked while the first hung');
release(null); assert.deepEqual((await pending).models, [row()]);
// Review round: a key one bus lists as unavailable and another as usable keeps the usable row.
const stale = row({ available: false, reason: 'proxy-down', label: 'stale' });
assert.deepEqual((await ownerModelsFrom({ proxy: true, riders: [rider('s', true, ready([stale])), rider('a', true, ready([row()]))] })).models, [row()]);
assert.deepEqual((await ownerModelsFrom({ proxy: true, riders: [rider('a', true, ready([row()])), rider('s', true, ready([stale]))] })).models, [row()]);
});
+8 -4
View File
@@ -83,15 +83,18 @@ async function discoverPresets() {
}
return presets;
}
export async function orgPresets({ env = process.env } = {}) {
// `owner` (#1873 ride-default) is what the Console read from the owner's model proxy:
// {proxy, riding, models}. A preset that does not use it ignores it.
export async function orgPresets({ env = process.env, owner } = {}) {
const presets = await discoverPresets();
return Promise.all([...presets.values()].map(async p => {
const availability = await p.available({ env });
const availability = await p.available({ env, owner });
if (!availability || typeof availability.ok !== 'boolean' || (!availability.ok && (typeof availability.reason !== 'string' || !availability.reason))) fail('org-invalid', 'invalid preset availability');
return { name: p.name, label: p.label, description: p.description, thinking: structuredClone(p.thinking), available: availability.ok ? { ok: true } : { ok: false, reason: availability.reason } };
}));
}
export async function templateRender(id, { fixture, preset, thinking } = {}) {
// `model` (#1873 ride-default) is one row of the owner's catalogue, for a preset that routes to it.
export async function templateRender(id, { fixture, preset, thinking, model } = {}) {
if (fixture !== undefined && fixture !== 'local') fail('org-invalid', 'unknown fixture');
if (fixture !== undefined && preset !== undefined) fail('org-invalid', 'choose fixture or preset');
if (fixture === 'local') preset = 'fixture';
@@ -105,7 +108,8 @@ export async function templateRender(id, { fixture, preset, thinking } = {}) {
if (!p) fail('org-invalid', 'unknown preset');
const level = thinking === undefined ? p.thinking.default : thinking;
if (!p.thinking.levels.includes(level)) fail('org-invalid', 'unknown thinking level');
const overlay = await p.overlay({ thinking: level });
let overlay;
try { overlay = await p.overlay({ thinking: level, model }); } catch (e) { fail('org-invalid', e?.code === 'org-invalid' && typeof e.message === 'string' ? e.message : 'invalid preset overlay'); }
if (!overlay || typeof overlay !== 'object' || !overlay.plugins || !overlay.launch || !overlay.assistantVars) fail('org-invalid', 'invalid preset overlay');
doc.plugins = structuredClone(overlay.plugins); doc.launch = structuredClone(overlay.launch);
doc.roles.assistant.vars = structuredClone(overlay.assistantVars);
@@ -30,3 +30,45 @@ test('unknown presets and thinking levels refuse', async () => {
await assert.rejects(templateRender('alpha', { preset: 'claude-code', thinking: 'off' }), /thinking/);
await assert.rejects(templateRender('alpha', { thinking: 'low' }), /thinking/);
});
// #1873 ride-default slice 1: the cliproxy preset routes a new organization to a model the
// owner's catalogue lists, and says plainly why it is unavailable.
const row = (over = {}) => ({ key: 'claude-claude-opus-5-5', module: 'cliproxy', upstream: 'claude', provider: 'anthropic', model: 'claude-opus-5-5',
label: 'claude / claude-opus-5-5', available: true, reason: null, harnesses: ['claude-code', 'pi'], ...over });
const cliproxyOf = async owner => (await service.orgPresets({ env: { PATH: '/usr/bin:/bin' }, owner })).find(p => p.name === 'cliproxy');
test('the cliproxy preset is discovered and names each reason it is unavailable', async () => {
const none = await cliproxyOf(undefined);
assert.equal(none.available.ok, false); assert.match(none.available.reason, /Set up the model proxy first/);
assert.match((await cliproxyOf({ proxy: false, riding: true, models: [row()] })).available.reason, /Set up the model proxy first/);
assert.match((await cliproxyOf({ proxy: true, riding: false, models: [row()] })).available.reason, /No organization uses the model proxy yet/);
assert.match((await cliproxyOf({ proxy: true, riding: true, models: [] })).available.reason, /lists no model you can use/);
for (const bad of [row({ available: false }), row({ reason: 'unverified' }), row({ module: 'fixture' }), row({ harnesses: [] })])
assert.match((await cliproxyOf({ proxy: true, riding: true, models: [bad] })).available.reason, /lists no model you can use/);
const ok = await cliproxyOf({ proxy: true, riding: true, models: [row()] });
assert.deepEqual(ok.available, { ok: true });
assert.deepEqual(ok.thinking, { levels: ['low', 'medium', 'high', 'xhigh', 'max'], default: 'low' });
});
test('the cliproxy overlay routes to the catalogue model it is given and validates', async () => {
const doc = await templateRender('alpha', { preset: 'cliproxy', model: row() });
assert.deepEqual(doc.plugins['model-provider'], ['cliproxy']);
assert.deepEqual(doc.launch.models, { 'claude-claude-opus-5-5': { provider: 'anthropic', model: 'claude-opus-5-5', module: 'cliproxy', upstream: 'claude' } });
assert.deepEqual(doc.roles.assistant.vars, { harness: 'claude-code', model: 'claude-claude-opus-5-5', thinking: 'low' });
assert.equal(doc.vars, undefined);
assert.deepEqual(await validateOrg(doc), { ok: true, errors: [] });
const glm = await templateRender('alpha', { preset: 'cliproxy', thinking: 'high', model: row({ key: 'zai-glm-5-3', upstream: 'zai', provider: 'zai', model: 'glm-5.3', harnesses: ['pi'] }) });
assert.deepEqual(glm.roles.assistant.vars, { harness: 'pi', model: 'zai-glm-5-3', thinking: 'high' });
assert.deepEqual(glm.plugins.harness, ['pi']);
assert.deepEqual(await validateOrg(glm), { ok: true, errors: [] });
await assert.rejects(templateRender('alpha', { preset: 'cliproxy' }), /lists no such model/);
await assert.rejects(templateRender('alpha', { preset: 'cliproxy', model: row({ available: false }) }), /lists no such model/);
});
test('existing presets ignore the new model and owner inputs', async () => {
assert.deepEqual(await templateRender('alpha', { preset: 'fixture', model: row() }), await templateRender('alpha', { preset: 'fixture' }));
assert.deepEqual(await templateRender('alpha', { preset: 'claude-code', model: row() }), await templateRender('alpha', { preset: 'claude-code' }));
const presets = await service.orgPresets({ env: { PATH: '/usr/bin:/bin' }, owner: { proxy: true, riding: true, models: [row()] } });
assert.equal(presets.find(p => p.name === 'fixture').available.ok, true);
assert.equal(presets.find(p => p.name === 'claude-code').available.ok, false);
});
+22
View File
@@ -258,6 +258,28 @@ export returns:
`gateTimeout`, `bundle`, `env`, `turnEnd`, `outputPolicy` and `transcript` give its
sandbox binds, web, tool names, S0 lines, bundle files, adapter variables,
how a turn ends and where its transcripts land.
- `envNames` and `installRoots({env})` (#1873 triage-fences) are optional and
outside `kinds.mjs`. A session the Console hosts with no organization
(Triage) reads them; organization launches do not. `envNames` lists the
names `env()` returns, less the provider's. The host takes a route's
`harnessEnv` name only when it is listed here and is not one the host
always refuses: `MOSAIC_*`, `NODE_*`, `LD_*`, `DYLD_*`, `PYTHON*`, `BASH_*`,
`GIT_*`, `MALLOC_*`, `NPM_CONFIG_*`, `XDG_*`, any name ending in `_DIR`,
`_CONF`, `_CONFIG`, `_ASKPASS`, `_CA_BUNDLE` or `_BASE_URL`, PATH, HOME,
TMPDIR, ENV, the founder's and the provider's names, and named shell,
proxy, resolver, libc, OpenSSL and Java hooks, Perl and Ruby start
options and library paths, less's input filters, Lua's start code,
curl's config home and a TLS key log. The full list is
`REFUSED_NAMES` in `packages/webui/src/triage-host.mjs`. `installRoots` lists the directories
where the adapter and the mounts live. A hosted adapter or mount source
must resolve inside one of them, and never in or around the data root,
the config directory, HOME, `/srv/mosaic` or a path with a `secret`
segment. HOME does not count against a source inside the stack's own
code, so a copy or a worktree under HOME still passes. Every claude-code
name is `MOSAIC_*`, so a hosted session cannot run Claude Code yet. pi's
`MOSAIC_TOOLS`, `MOSAIC_EXTENSIONS` and `MOSAIC_THINKING` are refused the
same way, so a hosted pi gets no tools and no extension until the host
sets those names itself.
- `compactions({store, cursors, budget, streams, first})` reads a thread
session's native store for row 270's compaction count (row 307). Core keeps
the ledger (`packages/seat/src/compactions.mjs`) and passes `store` as
+11 -1
View File
@@ -6,7 +6,7 @@
// session.json. packages/plugins/README.md lists the interface.
import { spawnSync } from "node:child_process";
import { accessSync, constants, realpathSync, statSync } from "node:fs";
import { delimiter, isAbsolute, join } from "node:path";
import { delimiter, dirname, isAbsolute, join } from "node:path";
import { fileURLToPath } from "node:url";
import { claudeBuiltins, MCP_PREFIX } from "../../../harness/src/gate.mjs";
import { hasSessionCredential, SESSION_CREDENTIALS } from "../../../seat/src/session.mjs";
@@ -145,6 +145,16 @@ export function env({ files, policy, session, proxy = null }) {
};
}
// #1873 triage-fences: the names env() returns, less the proxy's, and the directories its adapter
// and mounts live in: the pinned binary's when MOSAIC_CLAUDE_BIN is set. A hosted session's host
// (Triage) takes harnessEnv names and mount sources only from these; launches don't read them.
export const envNames = Object.freeze(["MOSAIC_TOOLS", "MOSAIC_CLAUDE_SETTINGS", "MOSAIC_CLAUDE_MCP_CONFIG", "MOSAIC_THINKING", "MOSAIC_MODEL_ACTIVITY_SOURCE"]);
export function installRoots({ env = {} } = {}) {
const roots = [join(REPO, "adapters", "claude"), join(REPO, "tools", "unslop-hook")];
if (env.MOSAIC_CLAUDE_BIN) roots.push(dirname(realpathSync(env.MOSAIC_CLAUDE_BIN)));
return roots;
}
// A turn ends when claude exits; there is no marker.
export const turnEnd = () => "exit";
export const transcript = ({ runDir, store = null }) => (store ? store.projects : join(runDir, "home", ".claude", "projects"));
+8
View File
@@ -118,6 +118,14 @@ export function env({ policy, tools, session, proxy = null }) {
};
}
// #1873 triage-fences: the names env() returns, less the provider key, and the directories its
// adapter and mounts live in. A hosted session's host (Triage) takes harnessEnv names and mount
// sources only from these; launches don't read them. The host refuses every MOSAIC_* name from a
// route, so MOSAIC_TOOLS, MOSAIC_EXTENSIONS and MOSAIC_THINKING are listed only to say what env()
// hands a session: a hosted pi needs the host to set them itself (a later slice).
export const envNames = Object.freeze(["PI_OFFLINE", "MOSAIC_TOOLS", "MOSAIC_EXTENSIONS", "PI_PROVIDER", "PI_MODEL", "MOSAIC_THINKING"]);
export const installRoots = () => [join(REPO, "adapters", "pi"), join(REPO, "packages", "plugins", "harness", "pi"), realpathSync(join(REPO, "node_modules")), join(REPO, "tools", "unslop-hook")];
// The extension writes the turn marker at agent_end; an exit without it is a failed turn.
export const turnEnd = () => "marker";
export const transcript = ({ runDir, store = null }) => (store ? store.session : join(runDir, "session"));
@@ -5,7 +5,12 @@ export const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/;
const MODEL = MODEL_ID;
const MAX_MODELS = 10000;
const family = url => url === ZAI_URL ? 'zai' : 'other';
const harnesses = upstream => upstream === 'claude' ? ['claude-code', 'pi'] : ['pi'];
// #1873 (Jason 2026-11-19): a Claude model from an OAuth account runs on claude-code only;
// a model from an API key, Claude or not, runs on claude-code and pi. The rule keys on the account
// kind: the proxy lists OAuth accounts (credentials, upstream `claude`) apart from API-key groups.
// It routes a request by model name across every account, so a group model whose name an OAuth
// Claude account offers (`oauth`) could be served by that account and is held to claude-code too.
const harnesses = (upstream, oauth = false) => upstream === 'claude' || oauth ? ['claude-code'] : ['claude-code', 'pi'];
const slug = (upstream, model) => `${upstream}-${model}`.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+$/g, '');
export async function catalogue({ listAccounts, listModels, listGroups, now }) {
@@ -25,12 +30,20 @@ export async function catalogue({ listAccounts, listModels, listGroups, now }) {
reason: upstream === 'other' || upstream === 'codex' ? 'unverified' : null, harnesses: harnesses(upstream) });
if (models.length > MAX_MODELS) throw Error();
};
// Every OAuth Claude account's names, whatever its state: one disabled, cooling down or signed
// out now can serve a request later, before the catalogue is read again.
const oauth = new Set();
for (const row of accounts.files) {
if (!['claude', 'codex'].includes(row?.provider) || row.disabled === true || row.unavailable === true || !['ready', 'active'].includes(row.status)) continue;
if (!['claude', 'codex'].includes(row?.provider)) continue;
const listed = row.disabled !== true && row.unavailable !== true && ['ready', 'active'].includes(row.status);
if (!listed && row.provider !== 'claude') continue;
if (typeof row.name !== 'string' || !row.name || row.name.length > 512) throw Error();
const response = await listModels(row.name);
if (!Array.isArray(response?.models) || response.models.length > MAX_MODELS) throw Error();
for (const model of response.models) add(row.provider, model?.id);
for (const model of response.models) {
if (row.provider === 'claude' && typeof model?.id === 'string') oauth.add(model.id.toLowerCase());
if (listed) add(row.provider, model?.id);
}
}
for (const group of groups) {
if (!Array.isArray(group?.keys)) throw Error();
@@ -43,6 +56,7 @@ export async function catalogue({ listAccounts, listModels, listGroups, now }) {
if (!Array.isArray(group.models) || group.models.length > MAX_MODELS) throw Error();
for (const model of group.models) add(upstream, model?.alias || model?.name);
}
for (const m of models) m.harnesses = harnesses(m.upstream, oauth.has(m.model.toLowerCase()));
return { status: 'ready', observedAt: now(), models, notices: [...new Set(notices)] };
} catch (error) {
return { status: 'unavailable', observedAt: null, models: [], notices: [], ...(error.code === 'model-key-collision' ? { reason: error.code } : {}) };
@@ -61,7 +75,9 @@ const ROUTES = Object.freeze({
claude: { routeId: 'anthropic', endpoint: 'root', api: 'anthropic-messages', piProvider: 'anthropic', compat: null },
zai: { routeId: 'glm', endpoint: 'v1', api: 'openai-completions', piProvider: 'mosaic-proxy-glm', compat: { thinkingFormat: 'zai', zaiToolStream: true } },
codex: { routeId: 'codex', endpoint: 'v1', api: 'openai-responses', piProvider: 'mosaic-proxy-codex', compat: null },
other: { routeId: 'anthropic', endpoint: 'root', api: 'anthropic-messages', piProvider: 'anthropic', compat: null },
// #1873: its own pi provider, never pi's built-in "anthropic", whose Claude models an entry there
// would keep and send to the proxy.
other: { routeId: 'anthropic', endpoint: 'root', api: 'anthropic-messages', piProvider: 'mosaic-proxy-other', compat: null },
});
export function route({ selection, harness }) {
let upstream = selection?.upstream;
@@ -72,7 +88,40 @@ export function route({ selection, harness }) {
}
if (!upstream) upstream = ({ anthropic: 'claude', zai: 'zai' })[selection?.provider];
if (!Object.hasOwn(ROUTES, upstream ?? '')) return { code: 'proxy-provider-unsupported' };
if (harness && !harnesses(upstream).includes(harness)) return { code: 'model-harness-incompatible' };
// A selection that names this module came from the catalogue, which knows the account kind and is
// checked at admission. A legacy one (a provider or route name only) gets no catalogue check, so
// the kind is unknown and a model named as Claude is treated as OAuth.
const legacyClaude = selection?.module !== 'cliproxy' && /claude/i.test(String(selection?.model ?? ''));
if (harness && !harnesses(upstream, legacyClaude).includes(harness)) return { code: 'model-harness-incompatible' };
if (typeof selection.model !== 'string' || !MODEL.test(selection.model)) return { code: 'model-provider-unavailable' };
return { provider: selection.provider ?? upstream, model: selection.model, upstream, ...ROUTES[upstream] };
}
// #1873 ride-default slice 1: a new organization that uses the owner's models through the
// instance's model proxy. The Console reads the owner's catalogue from a riding bus and passes
// it as `owner`; this module never reaches the proxy itself.
const THINKING = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
export const usableModel = m => !!m && m.module === 'cliproxy' && m.available === true && m.reason === null
&& typeof m.key === 'string' && /^[a-z][a-z0-9-]{0,63}$/.test(m.key) && typeof m.upstream === 'string' && Object.hasOwn(ROUTES, m.upstream)
&& typeof m.provider === 'string' && typeof m.model === 'string' && MODEL.test(m.model)
&& Array.isArray(m.harnesses) && (m.harnesses.includes('claude-code') || m.harnesses.includes('pi'));
export function orgPresets() {
return [{ name: 'cliproxy', label: 'Your models through the model proxy',
description: 'Uses a model your model proxy lists. Each reply spends your own account.',
thinking: { levels: [...THINKING], default: 'low' },
available: ({ owner } = {}) => {
if (!owner || owner.proxy !== true) return { ok: false, reason: 'Set up the model proxy first, on the Model proxy page.' };
if (owner.riding !== true) return { ok: false, reason: 'No organization uses the model proxy yet, or none answered. Use Ride all on the Model proxy page.' };
if (!Array.isArray(owner.models) || !owner.models.some(usableModel)) return { ok: false, reason: 'The model proxy lists no model you can use. Sign in to an account on the Model proxy page.' };
return { ok: true };
},
overlay: ({ thinking, model }) => {
if (!usableModel(model)) throw Object.assign(Error('the model proxy lists no such model'), { code: 'org-invalid' });
const harness = model.harnesses.includes('claude-code') ? 'claude-code' : 'pi';
return {
plugins: { channel: ['cli', 'webui'], harness: [harness], 'model-provider': ['cliproxy'] },
launch: { by: 'chief', instances: ['assistant'], models: { [model.key]: { provider: model.provider, model: model.model, module: 'cliproxy', upstream: model.upstream } } },
assistantVars: { harness, model: model.key, thinking },
};
} }];
}
@@ -17,15 +17,16 @@ test('catalogue attributes configured accounts, uses aliases, and enforces harne
const result = await catalogue(deps());
assert.equal(result.status, 'ready');
const zai = result.models.find(x => x.upstream === 'zai');
assert.deepEqual([zai.key, zai.model, zai.available, zai.harnesses], ['zai-fixture-alias', 'fixture-alias', true, ['pi']]);
assert.deepEqual([zai.key, zai.model, zai.available, zai.harnesses], ['zai-fixture-alias', 'fixture-alias', true, ['claude-code', 'pi']]);
const claude = result.models.find(x => x.upstream === 'claude');
assert.deepEqual(claude.harnesses, ['claude-code', 'pi']);
assert.deepEqual(preflight({ selection: zai, harness: 'claude-code', catalogue: result }), { allow: false, code: 'model-harness-incompatible' });
assert.deepEqual(claude.harnesses, ['claude-code']);
assert.deepEqual(preflight({ selection: zai, harness: 'claude-code', catalogue: result }), { allow: true });
assert.deepEqual(preflight({ selection: zai, harness: 'fixture-harness', catalogue: result }), { allow: false, code: 'model-harness-incompatible' });
assert.deepEqual(preflight({ selection: zai, harness: 'pi', catalogue: result }), { allow: true });
assert.ok(!JSON.stringify(result).includes('credential-1'));
});
test('an empty group offers no models; unknown groups offer pi only and are unverified', async () => {
test('an empty group offers no models; unknown groups offer claude-code and pi and are unverified', async () => {
const d = deps();
d.listAccounts = async () => ({ files: [] });
d.listGroups = async () => [
@@ -34,7 +35,7 @@ test('an empty group offers no models; unknown groups offer pi only and are unve
];
const c = await catalogue(d);
assert.equal(c.models.length, 1);
assert.deepEqual([c.models[0].upstream, c.models[0].harnesses, c.models[0].reason], ['other', ['pi'], 'unverified']);
assert.deepEqual([c.models[0].upstream, c.models[0].harnesses, c.models[0].reason], ['other', ['claude-code', 'pi'], 'unverified']);
assert.ok(c.notices.includes('z.ai account has no models configured. Add them on Model proxy.'));
});
@@ -50,7 +51,7 @@ test('module declares only supported transports and legacy routes without wideni
assert.deepEqual(route({ selection: { upstream: 'codex', model: 'fixture-codex' }, harness: 'pi' }), {
provider: 'codex', model: 'fixture-codex', upstream: 'codex', routeId: 'codex', endpoint: 'v1', api: 'openai-responses', piProvider: 'mosaic-proxy-codex', compat: null,
});
assert.equal(route({ selection: { upstream: 'zai', model: 'fixture-zai' }, harness: 'claude-code' }).code, 'model-harness-incompatible');
assert.equal(route({ selection: { upstream: 'zai', model: 'fixture-zai' }, harness: 'fixture-harness' }).code, 'model-harness-incompatible');
assert.equal(route({ selection: { provider: 'proxy', route: 'unknown', model: 'fixture' }, harness: 'pi' }).code, 'proxy-route-unknown');
assert.equal(route({ selection: { provider: 'proxy', model: 'fixture' }, harness: 'pi' }).code, 'proxy-route-missing');
});
@@ -68,3 +69,113 @@ test('a second fixture module resolves independently and ambiguous legacy mappin
assert.equal(selectModelProvider([first,second],{...entry,module:'first-fixture'}),null);
assert.equal(selectModelProvider([first,second,{...second,name:'third-fixture'}],entry),null);
});
// #1873 harness-matrix (Jason 2026-11-19): a Claude model from an OAuth account runs on
// claude-code only; every other proxy model runs on claude-code and pi.
test('an OAuth Claude model is offered on claude-code only and refused on pi at catalogue, preflight and route', async () => {
const { route } = await import('../model-provider/cliproxy/index.mjs');
const c = await catalogue(deps());
const claude = c.models.find(x => x.upstream === 'claude');
assert.deepEqual(claude.harnesses, ['claude-code']);
assert.deepEqual(preflight({ selection: claude, harness: 'pi', catalogue: c }), { allow: false, code: 'model-harness-incompatible' });
assert.deepEqual(preflight({ selection: claude, harness: 'claude-code', catalogue: c }), { allow: true });
for (const selection of [{ upstream: 'claude', model: 'fixture-chat' }, { provider: 'anthropic', model: 'fixture-chat' }, { provider: 'proxy', route: 'anthropic', model: 'fixture-chat' }]) {
assert.equal(route({ selection, harness: 'pi' }).code, 'model-harness-incompatible', JSON.stringify(selection));
assert.equal(route({ selection, harness: 'claude-code' }).upstream, 'claude');
}
});
test('a z.ai and a codex model run on claude-code and pi', async () => {
const { route } = await import('../model-provider/cliproxy/index.mjs');
const d = deps();
d.listAccounts = async () => ({ files: [{ name: 'credential-3', provider: 'codex', status: 'active' }] });
d.listModels = async () => ({ models: [{ id: 'fixture-codex' }] });
const c = await catalogue(d);
for (const upstream of ['zai', 'codex']) {
const m = c.models.find(x => x.upstream === upstream);
assert.deepEqual(m.harnesses, ['claude-code', 'pi'], upstream);
for (const harness of ['claude-code', 'pi']) {
assert.deepEqual(preflight({ selection: m, harness, catalogue: c }), { allow: true }, `${upstream} ${harness}`);
assert.equal(route({ selection: { upstream, model: m.model }, harness }).upstream, upstream, `${upstream} ${harness}`);
}
}
assert.equal(route({ selection: { provider: 'zai', model: 'fixture-zai' }, harness: 'claude-code' }).routeId, 'glm');
assert.equal(route({ selection: { provider: 'proxy', route: 'codex', model: 'fixture-codex' }, harness: 'claude-code' }).routeId, 'codex');
});
test('an API-key model runs on claude-code and pi whatever its name; the rule keys on the account kind', async () => {
const { route } = await import('../model-provider/cliproxy/index.mjs');
const d = deps();
// Jason 2026-11-19: a Claude model from an API key runs on any harness. A name that says Claude,
// or an OpenRouter-style anthropic/ name, is not an OAuth account.
d.listGroups = async () => [{ 'base-url': 'https://fixture.invalid', keys: [{ auth_index: 'k' }], models: [
{ name: 'upstream-x', alias: 'Claude-Fixture' }, { name: 'anthropic/claude-sonnet-5-5' }, { name: 'claude-upstream', alias: 'fixture-safe' }] },
{ 'base-url': ZAI, keys: [{ auth_index: 'z' }], models: [{ name: 'claude-zai-fixture' }] }];
const c = await catalogue(d);
for (const [upstream, model] of [['other', 'Claude-Fixture'], ['other', 'anthropic/claude-sonnet-5-5'], ['other', 'fixture-safe'], ['zai', 'claude-zai-fixture']]) {
const row = c.models.find(x => x.upstream === upstream && x.model === model);
assert.deepEqual(row.harnesses, ['claude-code', 'pi'], model);
for (const harness of ['claude-code', 'pi'])
assert.deepEqual(preflight({ selection: row, harness, catalogue: c }), { allow: true }, `${model} ${harness}`);
}
for (const upstream of ['other', 'zai', 'codex'])
for (const model of ['claude-fixture', 'anthropic/claude-sonnet-5-5', 'fixture-safe'])
for (const harness of ['claude-code', 'pi'])
assert.equal(route({ selection: { module: 'cliproxy', upstream, model }, harness }).upstream, upstream, `${upstream} ${model} ${harness}`);
});
test('a legacy selection carries no account data, so a Claude-named model on it is treated as OAuth and held to claude-code', async () => {
const { route } = await import('../model-provider/cliproxy/index.mjs');
// A legacy entry (a provider or route name, no module) gets no catalogue check at launch, and the
// proxy may serve its name from an OAuth Claude account.
for (const selection of [{ provider: 'zai', model: 'claude-opus-5-5' }, { provider: 'proxy', route: 'glm', model: 'Claude-Opus-5-5' },
{ provider: 'proxy', route: 'codex', model: 'claude-sonnet-5-5' }, { upstream: 'other', model: 'anthropic/claude-sonnet-5-5' }]) {
assert.equal(route({ selection, harness: 'pi' }).code, 'model-harness-incompatible', JSON.stringify(selection));
assert.equal(route({ selection, harness: 'claude-code' }).model, selection.model, JSON.stringify(selection));
// The same name from the catalogue, where the account kind is known, runs on pi.
if (selection.upstream || selection.provider === 'zai') assert.equal(route({ selection: { ...selection, module: 'cliproxy' }, harness: 'pi' }).model, selection.model);
}
for (const selection of [{ provider: 'zai', model: 'glm-fixture' }, { provider: 'proxy', route: 'codex', model: 'gpt-fixture' }])
assert.equal(route({ selection, harness: 'pi' }).model, selection.model, JSON.stringify(selection));
});
test('an API-key model whose name an OAuth Claude account offers stays on claude-code, the account listed or not (fail closed)', async () => {
const { route } = await import('../model-provider/cliproxy/index.mjs');
// The proxy routes by model name across every account, so a group model named as an OAuth Claude
// account's model can be served by that account. A disabled, unavailable or signed-out account
// can serve it later, before the catalogue is read again, so its names count too.
for (const state of [{ status: 'active' }, { status: 'active', disabled: true }, { status: 'active', unavailable: true }, { status: 'error' }]) {
const d = deps();
d.listAccounts = async () => ({ files: [{ name: 'credential-1', provider: 'claude', ...state }, { name: 'credential-2', provider: 'codex', status: 'active' }] });
d.listModels = async name => ({ models: name === 'credential-1' ? [{ id: 'Fixture-Chat' }] : [{ id: 'fixture-codex' }] });
d.listGroups = async () => [{ 'base-url': 'https://fixture.invalid', keys: [{ auth_index: 'k' }], models: [{ name: 'fixture-chat' }, { name: 'fixture-safe' }] },
{ 'base-url': ZAI, keys: [{ auth_index: 'z' }], models: [{ name: 'upstream', alias: 'FIXTURE-CHAT' }] }];
const c = await catalogue(d);
const label = JSON.stringify(state);
assert.equal(c.status, 'ready', label);
const by = (upstream, model) => c.models.find(x => x.upstream === upstream && x.model === model);
assert.deepEqual(by('other', 'fixture-chat').harnesses, ['claude-code'], label);
assert.deepEqual(by('zai', 'FIXTURE-CHAT').harnesses, ['claude-code'], label);
assert.deepEqual(by('other', 'fixture-safe').harnesses, ['claude-code', 'pi'], label);
assert.deepEqual(by('codex', 'fixture-codex').harnesses, ['claude-code', 'pi'], label);
assert.deepEqual(preflight({ selection: by('other', 'fixture-chat'), harness: 'pi', catalogue: c }), { allow: false, code: 'model-harness-incompatible' }, label);
// Only a usable account's models are offered as rows.
assert.equal(c.models.some(x => x.upstream === 'claude'), state.status === 'active' && !state.disabled && !state.unavailable, label);
}
// route() has no account data: it holds upstream claude only, and admission holds the rest by the catalogue.
assert.equal(route({ selection: { upstream: 'other', model: 'fixture-chat' }, harness: 'pi' }).upstream, 'other');
});
test('a Claude OAuth account whose models cannot be read makes the catalogue unavailable, listed or not', async () => {
for (const state of [{ status: 'active' }, { status: 'active', disabled: true }]) {
const d = deps();
d.listAccounts = async () => ({ files: [{ name: 'credential-1', provider: 'claude', ...state }] });
d.listModels = async () => { throw new Error('fixture private error'); };
assert.equal((await catalogue(d)).status, 'unavailable', JSON.stringify(state));
}
// A codex account that is not usable is not read at all.
const d = deps();
d.listAccounts = async () => ({ files: [{ name: 'credential-2', provider: 'codex', status: 'active', disabled: true }] });
d.listModels = async () => { throw new Error('fixture private error'); };
assert.equal((await catalogue(d)).status, 'ready');
});
+133 -4
View File
@@ -34,7 +34,7 @@
// the launch (sandbox-unavailable).
import { spawnSync } from "node:child_process";
import { existsSync, lstatSync, mkdirSync, readlinkSync, realpathSync } from "node:fs";
import { existsSync, lstatSync, mkdirSync, readlinkSync, realpathSync, statSync } from "node:fs";
import { dirname, isAbsolute, join, relative, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { ID_PATTERN } from "../../organization/src/vocabulary.mjs";
@@ -193,6 +193,117 @@ export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWR
return [bwrap, ...NAMESPACES, ...argsOf(list), "--remount-ro", "/", "--setenv", "HOME", join(runDir, "home"), "--setenv", "TMPDIR", "/tmp", ...identity, "--chdir", runDir, "--", ...KILL_WITH_PARENT, ...command];
}
// #1873 triage-fences: what a model route may hand a hosted session, checked before the host
// writes anything and again in hostedBinds. The adapter and each mount's source must be a clean
// absolute path whose real path lies under one of the harness module's install roots, named under
// that same root, and outside every protected path: the data root, the config directory and HOME
// the caller passes, the run directory, ALWAYS_PROTECTED, and any path with a segment that
// contains "secret" in any case. A protected path counts in its own spelling and its real path, and
// a source may neither lie inside one nor contain one. The bind's source is the real path, so a
// link swapped after the check cannot steer it. A mount's dest (its source when it names none) is
// never /tmp, the run directory or a system bind's dest, nor inside or around one, never a parent
// of or equal to a runner file, the adapter or node, and never in or around another mount's dest.
// At most HOSTED_MOUNTS_MAX mounts. A refusal is a HostedRouteError naming its fence, never a path.
// `codeRoot` is the stack's own code and `codeHolder` the one protected path that may hold it:
// HOME, when the stack runs from a copy or a worktree under it. That path does not refuse a source
// whose named and real paths both lie in the code root. Every other check still applies to it, and
// no other protected path, the run directory or ALWAYS_PROTECTED is ever set aside. A code root in
// or around the run directory or ALWAYS_PROTECTED, in either path's spelling or real path, is refused.
export const HOSTED_MOUNTS_MAX = 8;
const ROOTS_MAX = 16;
const PATH_MAX = 4096;
const ALWAYS_PROTECTED = Object.freeze(["/srv/mosaic", "/proc", "/sys", "/dev", "/run", "/root", "/boot"]);
const MOUNT_KEYS = Object.freeze(["src", "dest", "why"]);
export class HostedRouteError extends Error {
constructor(fence, message) {
super(`hosted binds: ${message}`);
this.code = "hosted-binds-refused";
this.fence = fence;
}
}
const refuseRoute = (fence, message) => { throw new HostedRouteError(fence, message); };
// Absolute, already normal (no "..", ".", "//" or trailing slash), not "/", no NUL.
const cleanPath = (p) => typeof p === "string" && p.length > 1 && p.length <= PATH_MAX && !p.includes("\0") && isAbsolute(p) && resolve(p) === p;
const within = (child, parent) => child === parent || child.startsWith(parent + "/");
const overlaps = (a, b) => within(a, b) || within(b, a);
const secretPath = (p) => p.split("/").some((seg) => /secret/i.test(seg));
const realOr = (p) => { try { return realpathSync(p); } catch { return p; } };
const plainObject = (o) => o !== null && typeof o === "object" && !Array.isArray(o) && [Object.prototype, null].includes(Object.getPrototypeOf(o));
// `alsoFixed` is a test hook: it adds stand-in fixed paths and never removes a shipped one.
export function checkHostedRoute({ adapter, harnessMounts, installRoots, protectedPaths, codeRoot = null, codeHolder = null, runDir, node = process.execPath, alsoFixed = [] }) {
if (!cleanPath(runDir)) refuseRoute("protected", "the run directory is not a clean absolute path");
if (!Array.isArray(protectedPaths)) refuseRoute("protected", "no protected paths were given");
if (!Array.isArray(alsoFixed)) refuseRoute("protected", "the added fixed paths are not a list");
// Lists are copied once, so a Proxy cannot answer one length to a check and another to the map.
protectedPaths = Array.from(protectedPaths);
// Each guarded entry: its spellings, and whether a source in the code root is clear of it. The
// fixed paths and the run dir never hold the code. Their spellings are looked up once, here, and
// serve both the code-root check and their guards, so the two always see the same real path.
const fixed = [...ALWAYS_PROTECTED, ...Array.from(alsoFixed), runDir].map((p) => {
if (!cleanPath(p)) refuseRoute("protected", "a protected path is not a clean absolute path");
return { spellings: [p, realOr(p)], holdsCode: false };
});
let code = null;
if (codeRoot !== null) {
if (!cleanPath(codeRoot)) refuseRoute("protected", "the code root is not a clean absolute path");
if (!protectedPaths.includes(codeHolder)) refuseRoute("protected", "the code root's holder is not a protected path");
code = [codeRoot, realOr(codeRoot)];
if (code.some((c) => fixed.some((g) => g.spellings.some((s) => overlaps(c, s))))) refuseRoute("protected", "the code root is in or around a path that is never set aside");
}
const guarded = [...fixed];
for (const p of protectedPaths) {
if (!cleanPath(p)) refuseRoute("protected", "a protected path is not a clean absolute path");
const spellings = [p, realOr(p)];
const holdsCode = p === codeHolder && code !== null && spellings.some((g) => code.some((c) => c !== g && within(c, g)));
guarded.push({ spellings, holdsCode });
}
if (!Array.isArray(installRoots)) refuseRoute("roots", "the harness module declares no usable install roots");
installRoots = Array.from(installRoots);
if (installRoots.length === 0 || installRoots.length > ROOTS_MAX) refuseRoute("roots", "the harness module declares no usable install roots");
const roots = installRoots.map((r) => {
if (!cleanPath(r)) refuseRoute("roots", "an install root is not a clean absolute path");
let real;
try { real = realpathSync(r); } catch { refuseRoute("roots", "an install root is missing"); }
if (real === "/" || !statSync(real).isDirectory()) refuseRoute("roots", "an install root is not a directory");
return { named: r, real };
});
const source = (src, fence, what) => {
if (!cleanPath(src)) refuseRoute(fence, `${what} is not a clean absolute path`);
let real;
try { real = realpathSync(src); } catch { refuseRoute(fence, `${what} is missing`); }
if (!roots.some((r) => (within(src, r.named) || within(src, r.real)) && within(real, r.real))) refuseRoute(fence, `${what} is not under an install root`);
const inCode = code !== null && code.some((c) => within(src, c)) && within(real, code[1]);
if (guarded.some((g) => !(g.holdsCode && inCode) && [src, real].some((p) => g.spellings.some((s) => overlaps(p, s))))) refuseRoute(fence, `${what} is in or around a protected path`);
if ([src, real].some(secretPath)) refuseRoute(fence, `${what} is in a secrets path`);
return real;
};
const adapterReal = source(adapter, "adapter", "the adapter");
if (!statSync(adapterReal).isFile()) refuseRoute("adapter", "the adapter is not a file");
if (!Array.isArray(harnessMounts)) refuseRoute("mounts", `a hosted session takes at most ${HOSTED_MOUNTS_MAX} harness mounts`);
harnessMounts = Array.from(harnessMounts);
if (harnessMounts.length > HOSTED_MOUNTS_MAX) refuseRoute("mounts", `a hosted session takes at most ${HOSTED_MOUNTS_MAX} harness mounts`);
const apart = ["/tmp", runDir, ...systemBinds(node).map((b) => b.dest ?? b.src)];
const kept = [...RUNNER_FILES, adapter, node];
const dests = [];
const mounts = harnessMounts.map((m, i) => {
const what = `harness mount ${i + 1}`;
if (!plainObject(m) || Object.keys(m).some((k) => !MOUNT_KEYS.includes(k))) refuseRoute("mounts", `${what} is not { src, dest, why }`);
// Each field is read once, so a getter cannot answer one value to a check and another to the bind.
const { src, dest: named, why } = m;
if (typeof why !== "string" || !why || why.length > 256) refuseRoute("mounts", `${what} is not { src, dest, why }`);
if (named !== undefined && !cleanPath(named)) refuseRoute("mount-dest", `${what}'s dest is not a clean absolute path`);
const real = source(src, "mount-src", what);
const dest = named ?? src;
if (apart.some((p) => overlaps(dest, p)) || kept.some((p) => within(p, dest)) || dests.some((d) => overlaps(dest, d))) refuseRoute("mount-dest", `${what}'s dest would cover a path the session needs`);
dests.push(dest);
return { src: real, dest, why };
});
return { adapter: { src: adapterReal, dest: adapter }, mounts };
}
// #1873 triage-host: the binds for a session the Console hosts in no organization (Triage). It
// gets the system part, the runner's files, the adapter and the harness module's mounts like any
// session, and from the data root exactly two directories: its own `runDir` read-write, and
@@ -200,7 +311,9 @@ export function sandboxArgv(list, runDir, command, { business, role, bwrap = BWR
// calls through stay read-only inside it, and its tmp/ is /tmp. There is no workspace, broker,
// launch or git socket, thread store or org root. Each source inside runDir must be what the host
// just made there, never a link the session left: bwrap resolves a bind's source on the host.
export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], relaySocket, node = process.execPath, readOnly = [] }) {
// The adapter and the mounts pass checkHostedRoute against `installRoots`, `protectedPaths` and
// `codeRoot` with its `codeHolder` here too; without install roots nothing binds.
export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], installRoots, protectedPaths, codeRoot = null, codeHolder = null, relaySocket, node = process.execPath, readOnly = [], harnessFiles = [] }) {
if (relaySocket !== join(runDir, "relay.sock")) throw new Error("hosted binds: the relay socket must be the run directory's relay.sock");
const healthDest = join(runDir, "work", "health");
for (const p of [runDir, healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work"), healthDest]) {
@@ -213,16 +326,32 @@ export function hostedBinds({ runDir, healthDir, adapter, harnessMounts = [], re
try { st = lstatSync(p); } catch { throw new Error(`hosted binds: ${relative(runDir, p)} is missing`); }
if (!ok(st)) throw new Error(`hosted binds: ${relative(runDir, p)} is not what the host made`);
}
// #1873 harness-matrix: a harness's own config file the host wrote under the session's HOME (pi's
// models.json), bound read-only over the writable run directory so the session cannot change
// the proxy it reaches. Each is a regular file, not a link, inside runDir/home.
const homeDir = join(runDir, "home");
if (!Array.isArray(harnessFiles) || harnessFiles.length > HOSTED_MOUNTS_MAX) refuseRoute("harness-files", "too many harness files");
for (const f of harnessFiles) {
if (!cleanPath(f) || !f.startsWith(homeDir + "/")) refuseRoute("harness-files", "a harness file is outside the session's HOME");
let st;
try { st = lstatSync(f); } catch { refuseRoute("harness-files", "a harness file is missing"); }
if (!st.isFile() || st.nlink !== 1) refuseRoute("harness-files", "a harness file is not a regular file");
for (let parent = dirname(f); parent.length > runDir.length; parent = dirname(parent)) {
if (lstatSync(parent).isSymbolicLink()) refuseRoute("harness-files", "a harness file's directory is a link");
}
}
const route = checkHostedRoute({ adapter, harnessMounts, installRoots, protectedPaths, codeRoot, codeHolder, runDir, node });
const out = systemBinds(node);
for (const f of RUNNER_FILES) out.push({ kind: "ro", src: f, why: "a repository file the runner loads" });
out.push({ kind: "ro", src: adapter, why: "the harness adapter the runner starts each turn" });
for (const m of harnessMounts) out.push({ kind: "ro", src: m.src, ...(m.dest ? { dest: m.dest } : {}), why: m.why });
out.push({ kind: "ro", src: route.adapter.src, ...(route.adapter.src !== adapter ? { dest: adapter } : {}), why: "the harness adapter the runner starts each turn" });
for (const m of route.mounts) out.push({ kind: "ro", src: m.src, ...(m.dest !== m.src ? { dest: m.dest } : {}), why: m.why });
for (const f of readOnly) out.push({ kind: "ro", src: f, why: "a test fixture" });
out.push(
{ kind: "rw", src: runDir, why: "the session's own state: turns/, session/, work/, tools.sock, turn.done, home/, tmp/" },
{ kind: "ro", src: healthDir, dest: healthDest, why: "the health snapshots the Console writes, read-only, inside the workspace the read tools reach" },
{ kind: "ro", src: join(runDir, "bundle"), why: "the run's bundle stays as the host wrote it" },
{ kind: "ro", src: join(runDir, "session.json"), why: "the session file stays as the host wrote it" },
...harnessFiles.map((f) => ({ kind: "ro", src: f, why: "the harness's own config file, as the host wrote it" })),
{ kind: "ro", src: relaySocket, why: "the host's relay, the only broker the runner reaches" },
{ kind: "rw", src: join(runDir, "tmp"), dest: "/tmp", why: "a private /tmp, on disk in the run directory" },
);
+201 -8
View File
@@ -4,9 +4,9 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { createServer } from "node:net";
import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { RUNNER_FILES, hostedArgv, hostedBinds } from "../src/sandbox.mjs";
import { linkSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { HOSTED_MOUNTS_MAX, RUNNER_FILES, checkHostedRoute, hostedArgv, hostedBinds } from "../src/sandbox.mjs";
function layout(t) {
const root = mkdtempSync(join(process.env.TMPDIR, "hb-"));
@@ -15,19 +15,21 @@ function layout(t) {
const healthDir = join(dataRoot, "triage", "health");
for (const d of [join(dataRoot, "orgs"), join(dataRoot, "triage", "host"), healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work", "health")]) mkdirSync(d, { recursive: true });
writeFileSync(join(runDir, "session.json"), "{}");
const adapter = join(root, "adapter.sh");
const install = join(root, "install");
mkdirSync(install);
const adapter = join(install, "adapter.sh");
writeFileSync(adapter, "exit 0\n");
return new Promise((resolve) => {
const server = createServer().listen(join(runDir, "relay.sock"), () => {
t.after(() => server.close());
resolve({ root, dataRoot, runDir, healthDir, adapter, relaySocket: join(runDir, "relay.sock") });
resolve({ root, dataRoot, runDir, healthDir, adapter, install, relaySocket: join(runDir, "relay.sock"), installRoots: [install], protectedPaths: [dataRoot] });
});
});
}
test("hosted binds hold the run directory and the health directory of the data root, and nothing else of it", async (t) => {
const p = await layout(t);
const list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket });
const list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths });
const fromData = list.filter((b) => typeof b.src === "string" && b.src.startsWith(p.dataRoot + "/"));
assert.deepEqual(fromData.map((b) => [b.kind, b.src, b.dest ?? null]), [
["rw", p.runDir, null],
@@ -46,7 +48,7 @@ test("hosted binds hold the run directory and the health directory of the data r
test("hosted binds refuse a relay socket elsewhere, and any source in the run directory that the host did not make", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket };
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
assert.throws(() => hostedBinds({ ...base, relaySocket: join(p.root, "bus.sock") }), /relay socket must be the run directory's relay\.sock/);
// A link in place of each directory the binds read: bwrap would follow it on the host.
for (const d of ["bundle", "tmp", "work"]) {
@@ -72,7 +74,7 @@ test("hosted binds refuse a relay socket elsewhere, and any source in the run di
test("the hosted command line sets no git identity and runs the command under the namespaces", async (t) => {
const p = await layout(t);
const argv = hostedArgv(hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket }), p.runDir, ["node", "runner.mjs", p.runDir], { bwrap: "/b/bwrap" });
const argv = hostedArgv(hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }), p.runDir, ["node", "runner.mjs", p.runDir], { bwrap: "/b/bwrap" });
assert.equal(argv[0], "/b/bwrap");
assert.deepEqual(argv.slice(1, 5), ["--unshare-user", "--unshare-pid", "--unshare-ipc", "--as-pid-1"]);
assert.deepEqual(argv.slice(-3), ["node", "runner.mjs", p.runDir]);
@@ -81,3 +83,194 @@ test("the hosted command line sets no git identity and runs the command under th
assert.equal(argv[home + 1], join(p.runDir, "home"));
assert.ok(argv.includes("--remount-ro"));
});
// #1873 triage-fences: hostedBinds checks the adapter and the mounts again, so a caller that skips
// the host's own check still binds nothing outside the install roots.
test("hosted binds refuse without install roots or protected paths, and refuse an adapter or a mount source outside the roots or in a protected path", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label);
refused({ installRoots: undefined }, "roots", "no roots");
refused({ installRoots: [] }, "roots", "empty roots");
refused({ installRoots: ["/"] }, "roots", "root /");
refused({ installRoots: [join(p.root, "absent")] }, "roots", "missing root");
refused({ installRoots: [p.adapter] }, "roots", "a file as root");
refused({ protectedPaths: undefined }, "protected", "no protected paths");
refused({ protectedPaths: ["relative"] }, "protected", "relative protected path");
writeFileSync(join(p.root, "out.sh"), "x");
refused({ adapter: join(p.root, "out.sh") }, "adapter", "adapter outside");
symlinkSync(join(p.root, "out.sh"), join(p.install, "link.sh"));
refused({ adapter: join(p.install, "link.sh") }, "adapter", "adapter link out");
refused({ adapter: p.install }, "adapter", "adapter is a directory");
refused({ harnessMounts: [{ src: join(p.install, "link.sh"), why: "w" }] }, "mount-src", "mount link out");
refused({ harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }], installRoots: [p.root] }, "mount-src", "mount in the data root");
refused({ harnessMounts: [{ src: p.root, why: "w" }], installRoots: [p.root] }, "mount-src", "mount around the data root");
mkdirSync(join(p.install, "secrets"));
writeFileSync(join(p.install, "secrets", "k"), "x");
refused({ harnessMounts: [{ src: join(p.install, "secrets", "k"), why: "w" }] }, "mount-src", "mount in secrets");
writeFileSync(join(p.install, "m"), "x");
refused({ harnessMounts: Array.from({ length: HOSTED_MOUNTS_MAX + 1 }, (_, i) => ({ src: join(p.install, "m"), dest: `/opt/m${i}`, why: "w" })) }, "mounts", "too many");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/tmp/m", why: "w" }] }, "mount-dest", "dest under /tmp");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: p.runDir, why: "w" }] }, "mount-dest", "dest is the run dir");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: join(p.runDir, "session.json"), why: "w" }] }, "mount-dest", "dest is session.json");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/usr", why: "w" }] }, "mount-dest", "dest is a system bind");
refused({ harnessMounts: [{ src: join(p.install, "m"), dest: dirname(RUNNER_FILES[0]), why: "w" }] }, "mount-dest", "dest holds a runner file");
refused({ harnessMounts: [{ src: join(p.install, "m"), why: "w", kind: "rw" }] }, "mounts", "a kind of its own");
});
test("hosted binds bind the real file of a link that stays inside the install root, at the path the route named", async (t) => {
const p = await layout(t);
writeFileSync(join(p.install, "real.mjs"), "x");
symlinkSync(join(p.install, "real.mjs"), join(p.install, "named.mjs"));
symlinkSync(p.adapter, join(p.install, "adapter-link.sh"));
const list = hostedBinds({
runDir: p.runDir, healthDir: p.healthDir, adapter: join(p.install, "adapter-link.sh"), relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths,
harnessMounts: [{ src: join(p.install, "named.mjs"), why: "w" }, { src: join(p.install, "real.mjs"), dest: "/opt/real.mjs", why: "w2" }],
});
assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter && b.dest === join(p.install, "adapter-link.sh")));
assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === join(p.install, "named.mjs") && b.why === "w"));
assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === "/opt/real.mjs" && b.why === "w2"));
assert.ok(!list.some((b) => b.src === join(p.install, "named.mjs")));
});
test("a protected path that holds the code root (HOME over a copy or a worktree) does not refuse a source inside the code root; everything else still holds", async (t) => {
const p = await layout(t);
// home/ holds the code root code/, which holds the install root.
const home = join(p.root, "home");
const code = join(home, "code");
const inst = join(code, "inst");
mkdirSync(join(inst, "secrets"), { recursive: true });
for (const f of ["adapter.sh", "m", join("secrets", "k")]) writeFileSync(join(inst, f), "x");
writeFileSync(join(home, "outside"), "x");
mkdirSync(join(code, "data"));
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: join(inst, "adapter.sh"), relaySocket: p.relaySocket, installRoots: [inst], protectedPaths: [p.dataRoot, home], codeRoot: code, codeHolder: home };
const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label);
const list = hostedBinds({ ...base, harnessMounts: [{ src: join(inst, "m"), dest: "/opt/m", why: "w" }] });
assert.ok(list.some((b) => b.src === join(inst, "adapter.sh")) && list.some((b) => b.src === join(inst, "m") && b.dest === "/opt/m"));
// Without the code root, HOME refuses the same adapter.
refused({ codeRoot: null }, "adapter", "no code root");
// A code root that is HOME itself sets nothing aside.
refused({ codeRoot: home }, "adapter", "code root is HOME");
// A source under HOME outside the code root, even inside an install root.
refused({ installRoots: [home], adapter: join(home, "outside") }, "adapter", "outside the code root");
// A link inside the code root to a file outside it.
symlinkSync(join(home, "outside"), join(inst, "out"));
refused({ installRoots: [inst, home], harnessMounts: [{ src: join(inst, "out"), why: "w" }] }, "mount-src", "link out of the code root");
// A protected path inside the code root still refuses.
writeFileSync(join(code, "data", "f"), "x");
refused({ installRoots: [code], protectedPaths: [p.dataRoot, home, join(code, "data")], harnessMounts: [{ src: join(code, "data", "f"), why: "w" }] }, "mount-src", "protected path in the code root");
// The secrets check still holds inside the code root.
refused({ harnessMounts: [{ src: join(inst, "secrets", "k"), why: "w" }] }, "mount-src", "secrets in the code root");
// The run directory and the fixed list are never set aside, and a code root around them is refused.
refused({ codeRoot: p.root, installRoots: [p.root], harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }] }, "protected", "code root holds the run dir");
refused({ codeRoot: "/srv/mosaic/x" }, "protected", "code root in a fixed path");
refused({ codeRoot: "relative" }, "protected", "relative code root");
// Only the named holder sets the code aside: another protected path that holds the code still refuses.
refused({ protectedPaths: [p.dataRoot, home, p.root] }, "adapter", "a second protected path holds the code");
refused({ codeHolder: null }, "protected", "no holder");
refused({ codeHolder: join(p.root, "elsewhere") }, "protected", "a holder that is not a protected path");
// A run directory named through a link: a code root in its real path is refused before any check.
const realRun = join(home, "run");
mkdirSync(join(realRun, "code", "inst"), { recursive: true });
writeFileSync(join(realRun, "code", "inst", "a.sh"), "x");
symlinkSync(realRun, join(p.root, "runlink"));
assert.throws(() => checkHostedRoute({ adapter: join(realRun, "code", "inst", "a.sh"), harnessMounts: [], installRoots: [join(realRun, "code", "inst")], protectedPaths: [p.dataRoot, home], codeRoot: join(realRun, "code"), codeHolder: home, runDir: join(p.root, "runlink") }), (e) => e.fence === "protected", "code root in the run dir's real path");
});
test("a fixed path named through a link: a code root in its real path is refused before any guard, and a source there is refused by its guard", async (t) => {
const p = await layout(t);
// None of the shipped fixed paths is a link on a test host, so the test hook adds a stand-in.
const home = join(p.root, "home");
// The real path lies outside HOME and the data root, so only the stand-in's own guard can refuse
// a source there.
const real = join(p.root, "fixedreal");
const inst = join(real, "code", "inst");
mkdirSync(inst, { recursive: true });
writeFileSync(join(inst, "a.sh"), "x");
const link = join(p.root, "fixedlink");
symlinkSync(real, link);
const base = { adapter: join(inst, "a.sh"), harnessMounts: [], installRoots: [inst], protectedPaths: [p.dataRoot, home], codeHolder: home, runDir: p.runDir, alsoFixed: [link] };
const refused = (opts, fence, message, label) => assert.throws(() => checkHostedRoute({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence && message.test(e.message), label);
// The code root lies in the stand-in's real path, not under the name the list gives.
refused({ codeRoot: join(real, "code") }, "protected", /never set aside/, "code root in a fixed path's real path");
// With the code root in HOME, the source in the stand-in's real path is refused by the stand-in's
// guard, which holds the same real spelling. No other guard holds that path.
mkdirSync(join(home, "code"), { recursive: true });
refused({ codeRoot: join(home, "code") }, "adapter", /protected path/, "source in a fixed path's real path");
// The same source passes without the stand-in: only the stand-in refused it.
assert.equal(checkHostedRoute({ ...base, alsoFixed: [], codeRoot: join(home, "code") }).adapter.src, join(inst, "a.sh"));
// The hook adds fixed paths and never removes one, and takes only a list of clean absolute paths.
refused({ alsoFixed: [], codeRoot: "/srv/mosaic/x" }, "protected", /never set aside/, "shipped fixed path with an empty hook");
refused({ alsoFixed: ["relative"], codeRoot: join(real, "code") }, "protected", /clean absolute/, "relative stand-in");
refused({ alsoFixed: "/x", codeRoot: join(real, "code") }, "protected", /clean absolute|list/, "a hook that is not a list");
});
test("a list that answers one length to the check and another later is read once", async (t) => {
const p = await layout(t);
const items = [];
for (let i = 0; i <= HOSTED_MOUNTS_MAX; i++) { writeFileSync(join(p.install, `m${i}`), "x"); items.push({ src: join(p.install, `m${i}`), dest: `/opt/m${i}`, why: "w" }); }
let reads = 0;
const mounts = new Proxy(items, { get: (o, k) => (k === "length" ? (reads++ === 0 ? 1 : o.length) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: mounts, installRoots: p.installRoots, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "mounts");
// Install roots: two short answers pass the count, then a long one would add roots the count never saw.
const roots = [];
for (let i = 0; i <= 16; i++) { roots.push(join(p.root, `r${i}`)); mkdirSync(roots[i]); }
writeFileSync(join(roots[16], "a.sh"), "x");
let rootReads = 0;
const rootList = new Proxy(roots, { get: (o, k) => (k === "length" ? (rootReads++ < 2 ? 1 : o.length) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: join(roots[16], "a.sh"), harnessMounts: [], installRoots: rootList, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "adapter");
// Protected paths: the holder check sees HOME, then a shorter answer would leave HOME unguarded.
const home = join(p.root, "home");
mkdirSync(join(home, "code"), { recursive: true });
writeFileSync(join(home, "f"), "x");
let guardReads = 0;
const guards = new Proxy([p.dataRoot, home], { get: (o, k) => (k === "length" ? (guardReads++ === 0 ? 2 : 1) : o[k]) });
assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: [{ src: join(home, "f"), dest: "/opt/f", why: "w" }], installRoots: [p.install, home], protectedPaths: guards, codeRoot: join(home, "code"), codeHolder: home, runDir: p.runDir }), (e) => e.fence === "protected" || e.fence === "mount-src");
});
test("each mount field is read once, and no mount's dest lies in or around another's", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
writeFileSync(join(p.install, "m"), "x");
writeFileSync(join(p.install, "n"), "x");
let reads = 0;
const list = hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), why: "w", get dest() { return reads++ === 0 ? undefined : "/opt/../tmp"; } }] });
assert.equal(reads, 1);
assert.ok(list.some((b) => b.src === join(p.install, "m") && b.dest === undefined));
assert.ok(!list.some((b) => b.dest === "/opt/../tmp"));
for (const [a, b] of [["/opt/x", "/opt/x/f"], ["/opt/x/f", "/opt/x"], ["/opt/x", "/opt/x"]]) {
assert.throws(() => hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: a, why: "w" }, { src: join(p.install, "n"), dest: b, why: "w" }] }), (e) => e.fence === "mount-dest", `${a} then ${b}`);
}
assert.equal(hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: "/opt/x", why: "w" }, { src: join(p.install, "n"), dest: "/opt/xy", why: "w" }] }).filter((b) => b.dest?.startsWith("/opt/")).length, 2);
});
// #1873 harness-matrix: a harness's own config file under the session's HOME (pi's models.json) is
// bound read-only after the writable run directory, so the session cannot change the proxy it
// reaches. A file outside HOME, a link, a hard link, a missing file or a linked directory is refused.
test("hosted binds hold a harness file read-only over the run directory, and refuse one outside HOME or not a plain file", async (t) => {
const p = await layout(t);
const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths };
const agentDir = join(p.runDir, "home", ".pi", "agent");
mkdirSync(agentDir, { recursive: true });
const file = join(agentDir, "models.json");
writeFileSync(file, "{}");
const list = hostedBinds({ ...base, harnessFiles: [file] });
const rw = list.findIndex((b) => b.kind === "rw" && b.src === p.runDir);
const ro = list.findIndex((b) => b.kind === "ro" && b.src === file && b.dest === undefined);
assert.ok(rw >= 0 && ro > rw, "read-only, after the writable run directory");
const refused = (files, label) => assert.throws(() => hostedBinds({ ...base, harnessFiles: files }), (e) => e.code === "hosted-binds-refused" && e.fence === "harness-files", label);
writeFileSync(join(p.runDir, "work", "x.json"), "{}");
refused([join(p.runDir, "work", "x.json")], "outside HOME");
refused([join(p.runDir, "home", "..", "work", "x.json")], "a .. path");
refused([join(p.runDir, "home", "absent.json")], "missing");
refused([join(p.runDir, "home")], "a directory");
symlinkSync(join(p.runDir, "work", "x.json"), join(p.runDir, "home", "link.json"));
refused([join(p.runDir, "home", "link.json")], "a link");
linkSync(join(p.runDir, "work", "x.json"), join(p.runDir, "home", "hard.json"));
refused([join(p.runDir, "home", "hard.json")], "a hard link");
mkdirSync(join(p.runDir, "work", "d"));
writeFileSync(join(p.runDir, "work", "d", "m.json"), "{}");
symlinkSync(join(p.runDir, "work", "d"), join(p.runDir, "home", "dlink"));
refused([join(p.runDir, "home", "dlink", "m.json")], "a linked directory");
refused(Array.from({ length: 9 }, () => file), "too many");
});
+11 -1
View File
@@ -1376,7 +1376,7 @@ The existing user notice names the governance records visible to the owner.
## Model proxy page (P4, #1828)
The owner's Settings → Model proxy page (`/settings/model-proxy`) signs in Claude/Codex accounts, accepts write-only
The owner's Settings → Model setup page (named Model proxy before #1873) (`/settings/model-proxy`) signs in Claude/Codex accounts, accepts write-only
z.ai API keys, sets account priority, and lists client-key IDs. It uses only
`/api/proxy/` routes over the owner's human bus transport. The old `/proxy` bookmark redirects to this page after the same access checks. A missing instance
proxy refuses `not-configured`; it does not ask for a management key. That key
@@ -1394,6 +1394,16 @@ retires the state. Refreshing the page does not restore a pending login.
Usage is reserved on this page for P5; P4 adds no usage source. PIN changes
require the offline upgrade acceptance documented in packages/model-proxy.
Settings slice 1 (#1873). Once the service runs, the page lists each organization that can't see
the models, or is not running. For each one that can't see them it reads that organization's own
routes (`GET /api/orgs/<id>/bus/routes`, the read Routing uses) and shows the bus's cause as a
plain line, with the bus's words under Technical details. A Restart shows only when the bus names
no cause or a cause a fresh start clears. With the dev fixture a restart is refused and stops the
organization, and no endpoint removes the fixture provider yet, so that row says it can't be changed
from Console. Two models that get the same short name (`model-key-collision`) get no Restart either.
Only an organization a restart can help holds the next step. A refused restart keeps its reason on its row. Only the next step has a
button; done steps, Fence, Init lock and the service controls sit under Technical details.
Archived project routes use the inclusive project read for the name, saved threads and room history. They offer Unarchive in send mode; thread creation, resume, sending and clear controls are unavailable while archived. Archive styling uses only `.project-archive-control` and `.project-archived-filter`.
### Recovering local process state
+83 -8
View File
@@ -19,6 +19,10 @@ import { loadSystem, socketPath, orgPaths, REPO, rolesDir } from '../../cli/src/
import { busStatus as orgBusStatus, busRevive as orgBusRevive } from '../../cli/src/org-bus.mjs';
import { listOrgs, resolveOrg } from '../../organization/src/org-registry.mjs';
import { showOrg } from '../../organization/src/org-service.mjs';
import * as orgService from '../../organization/src/org-service.mjs';
import { orgUsesFixture } from '../../cli/src/dev-fixture.mjs';
import { moveFixtureOrg, ownerModelsFrom, readRider } from '../../model-proxy/src/ride.mjs';
import { ownedText } from '../../model-proxy/src/admin.mjs';
import { configDir } from '../../organization/src/organization-config.mjs';
import { loadRootAgents } from '../../organization/src/agent-levels.mjs';
import { organizationWriter } from '../../organization/src/organization.mjs';
@@ -35,11 +39,14 @@ import { actionTrail } from './action-trail.mjs';
import { reviveBuses } from './bus-revive.mjs';
import { createProxyAdmin, orgCatalogue } from './proxy-admin.mjs';
import { createTriageHost } from './triage-host.mjs';
import { createTriageRoute, triageTokenPattern } from './triage-route.mjs';
import { loadProxy } from '../../model-proxy/src/settings.mjs';
import { composeSnapshot, readSystemConfig, readOrgConfig } from './triage-snapshot.mjs';
import { busesStopped } from '../../cli/src/proxy-admin-host.mjs';
import { agentLevelsWriteRoutes } from './agent-levels-write.mjs';
import { triageRouteRoutes } from './triage-route-http.mjs';
import { RESTART_EXIT } from '../../cli/src/org-console.mjs';
import { ID_PATTERN } from '../../organization/src/vocabulary.mjs';
import { ID_PATTERN, systemOnly } from '../../organization/src/vocabulary.mjs';
import { selectorScope } from '../../organization/src/selector.mjs';
// The bus verifies the Console's exact same-tree script in /proc, whose argv preserves a
// relative shell argument even though Node's process.argv resolves it. Re-exec the same
@@ -204,8 +211,9 @@ try {
// and the preview are reads over requestRead.
templatesWrite: session.user === undefined && sendOn ? templatesCaller(consoleCall({ dataRoot: root, socket: paths.socket, business: id })) : null,
// Starter packs SP6 (#1873): the owner's workflow read, the organization file and its revision as the
// writer reads them (the read `mosaic org workflow set` takes its revision from), and the V2 template names.
workflowsRead: session.user === undefined ? () => ({ ...organizationWriter({ dir: configDir(), rolesDir: rolesDir() }).read(id), templates: templateHashes(rolesDir()).map(t => t.template) }) : null,
// writer reads them (the read `mosaic org workflow set` takes its revision from), and the V2 template names
// less the system-only ones. packs-http's workflowsRead drops them again and is the tested gate.
workflowsRead: session.user === undefined ? () => ({ ...organizationWriter({ dir: configDir(), rolesDir: rolesDir() }).read(id), templates: templateHashes(rolesDir()).map(t => t.template).filter(t => !systemOnly(t)) }) : null,
reads: consoleReads({ root: REPO, queueRoot: options.checkout ?? REPO, system, configDir: configDir(), rolesDir: rolesDir(), business: id, orgRoot: root }),
};
},
@@ -214,6 +222,31 @@ try {
const agentLevels = organizations ? { loadRoot: () => loadRootAgents(configDir(), { rolesDir: rolesDir() }), rolesDir: rolesDir(), ctx: { configDir: configDir(), dataRoot: system.dataRoot, instance } } : null;
// #1873: proxy setup for the instance owner (dev local owner, or the root owner under --sso).
// Instance-wide: one pinned release, one proxy.json, one unit. Each organization uses it (shared).
// #1873 ride-default: each active organization as Ride all reads it, from its file and change log
// (read only) and, through `call`, from its bus as the owner. A file that cannot be read gives
// undefined fields, which Ride all names as unreadable. The change log is read with the writer's
// own check (no symlink, a regular file this user owns, not group or world writable).
const rideRiders = async () => {
const writer = organizationWriter({ dir: configDir(), rolesDir: rolesDir() });
const local = id => readRider({ id, read: () => writer.read(id).document, readLog: () => ownedText(writer.logFile(id), { mask: 0o022 }), isFixture: orgUsesFixture });
const down = async () => { throw Object.assign(new Error('the bus is not reachable'), { code: 'no-bus-host' }); };
// The single-business Console has no bus status here: its organization never reads as stopped.
if (!organizations) return ownerCall && options.business ? [{ ...local(options.business), call: ownerCall }] : [];
const out = [];
for (const org of await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })) {
if (org.state !== 'active') continue;
let call = down; try { const paths = orgPaths(org.root); call = busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }); } catch {}
// The organization admin page's stopped test reads this bus status (its process id).
out.push({ ...local(org.id), call, status: () => orgBusStatus({ configDir: configDir(), dataRoot: system.dataRoot, instance }, org.id) });
}
return out;
};
// The owner's models (ride.mjs ownerModelsFrom): the proxy is set up when proxy.json names a port.
const ownerModels = system && (devOwner || ssoOn) ? async () => {
let proxy = false;
try { proxy = Number.isInteger(loadProxy(configDir(), system.dataRoot)?.port); } catch {}
return ownerModelsFrom({ proxy, riders: proxy ? await rideRiders() : [] });
} : null;
const proxyAdmin = system && (devOwner || ssoOn) ? createProxyAdmin({
dataRoot: system.dataRoot, configDir: configDir(), instance, unitDir: options.proxyUnitDir ?? null,
buses: () => busesStopped({ dataRoot: system.dataRoot, configDir: configDir() }),
@@ -228,12 +261,37 @@ try {
}
return out;
},
riders: rideRiders,
ownerModels,
// A stopped fixture organization moves through the organization service's whole-file update, the
// write `POST /api/orgs/ID/admin` makes, as the signed-in owner. The owner starts its bus after.
move: (id, models, principal) => moveFixtureOrg({ service: orgService, ctx: { configDir: configDir(), dataRoot: system.dataRoot, instance, principal }, id, models }),
}) : null;
// #1873 triage-host: the instance owner's Triage session, hosted by the Console in no organization.
// Nothing starts here; the owner's first message starts it. No model route store exists without a
// schema change, so none is wired: the read says no route is set and nothing launches.
const triage = system && (devOwner || ssoOn) ? createTriageHost({
dataRoot: system.dataRoot, route: null, devOwner: Boolean(devOwner), log: line => console.log(line),
// Nothing starts here; the owner's first message starts it.
// #1873 triage-wiring: the route is resolved at each admit from the route store, the key file, each
// active organization's model catalogue (its bus `routes` verb, as proxy setup reads it) and the
// harness module (triage-route.mjs). The host's fences hold the proxy port and the key's shape.
// The port is read from proxy.json at each admit, so a proxy set up after the Console started counts.
const triageProxyPort = () => {
try { const p = loadProxy(configDir(), system.dataRoot)?.port; return Number.isInteger(p) ? p : null; } catch { return null; }
};
const triageRoute = system && (devOwner || ssoOn) ? createTriageRoute({
dataRoot: system.dataRoot, configDir: configDir(), proxyPort: triageProxyPort,
catalogues: async () => {
// A bus that does not answer gives a catalogue that is not ready, so it confirms nothing.
const read = async call => { try { return (await call('routes'))?.catalogue ?? { status: 'unknown' }; } catch { return { status: 'bus-unavailable' }; } };
if (!organizations) return ownerCall ? [await read(ownerCall)] : [];
const active = (await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })).filter(org => org.state === 'active');
return Promise.all(active.map(org => {
let paths; try { paths = orgPaths(org.root); } catch { return { status: 'bus-unavailable' }; }
return read(busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }));
}));
},
}) : null;
const triage = triageRoute ? createTriageHost({
dataRoot: system.dataRoot, route: triageRoute, proxyPort: triageProxyPort, tokenPattern: triageTokenPattern(configDir()),
devOwner: Boolean(devOwner), log: line => console.log(line),
readSnapshot: () => composeSnapshot({
orgs: () => listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance }),
busStatus: id => orgBusStatus({ configDir: configDir(), dataRoot: system.dataRoot, instance }, id),
@@ -261,8 +319,25 @@ try {
const trail = system ? actionTrail(join(system.dataRoot, 'console')) : null;
// #1873 A2: Settings > Agents writes for the root and project levels, beside the levels read.
const agentLevelRoutes = organizations ? [agentLevelsWriteRoutes({ configDir: configDir(), rolesDir: rolesDir(), trail })] : [];
// #1873 triage-settings: Settings > Triage reads and saves the route store for the instance owner.
// The model is checked against the catalogue each active organization's bus answers with, as an
// organization's route change is. Saving starts nothing: the Triage host above reads the store at its
// next admit.
const triageRoutes = system && (devOwner || ssoOn) ? [triageRouteRoutes({
dataRoot: system.dataRoot, log: line => console.log(line),
catalogues: async () => {
const read = async call => { try { return (await call('routes'))?.catalogue ?? { status: 'unknown' }; } catch { return { status: 'bus-unavailable' }; } };
if (!organizations) return ownerCall ? [await read(ownerCall)] : [];
// Every active organization is asked at once, so a hung bus costs one timeout, not one each.
const active = (await listOrgs({ configDir: configDir(), dataRoot: system.dataRoot, instance })).filter(org => org.state === 'active');
return Promise.all(active.map(org => {
let paths; try { paths = orgPaths(org.root); } catch { return { status: 'bus-unavailable' }; }
return read(busCaller({ dataRoot: org.root, socket: paths.socket, business: org.id, timeoutMs: 5000 }));
}));
},
})] : [];
try {
server = await startServer({ restart, trail, ...(lan ? { host: lan.bind, devAllowHosts: lan.allowHosts } : {}), board: options.board, port: options.port, bus, reads, preview: options.preview, sso, proof, send, settingsWrite, projectFiles, projectFile, libraryFile, libraryStatus, librarySync, libraryRevert, librarySave, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite, agentWrite, proxyCall, proxyAdmin, triage, processing, decisionWrite, requestRead, requestWrite, userOptions, federation: system?.federation ?? null, organizations, agentLevels, routes: agentLevelRoutes, preselect: options.business ?? null });
server = await startServer({ restart, trail, ...(lan ? { host: lan.bind, devAllowHosts: lan.allowHosts } : {}), board: options.board, port: options.port, bus, reads, preview: options.preview, sso, proof, send, settingsWrite, projectFiles, projectFile, libraryFile, libraryStatus, librarySync, libraryRevert, librarySave, projectSave, chat, nameWrite, assistantStop, instancesWrite, routesWrite, agentWrite, proxyCall, proxyAdmin, triage, processing, decisionWrite, requestRead, requestWrite, userOptions, federation: system?.federation ?? null, organizations, agentLevels, ownerModels, rideRemoved: proxyAdmin ? id => proxyAdmin.rideRemoved(id) : null, routes: [...agentLevelRoutes, ...triageRoutes], preselect: options.business ?? null });
} catch (err) { sso?.close(); throw err; }
if (testerSocket) {
const call = busCaller({ dataRoot: system.dataRoot, socket: socketPath(system.dataRoot), business: options.business ?? null, cli: TESTER_CLI });
+4 -4
View File
@@ -60,11 +60,11 @@ const NONE = ' Nothing was applied.';
const EITHER = ' Part of it may already be applied: check the Agents page before trying again.';
const CHECK = ' Check the Agents page and the inbox before trying again.';
const HIRE_START_REFUSALS = {
'model-provider-unavailable': [409, 'The model proxy does not offer this model, or its catalogue is not ready. Pick a model it offers, or ask the owner to check Settings > Model proxy.' + NONE],
'model-catalogue-unavailable': [503, 'The model catalogue could not be read, so this model could not be checked. Check Settings > Model proxy, then try again.' + NONE],
'model-provider-unavailable': [409, 'The model service does not offer this model, or its catalogue is not ready. Pick a model it offers, or ask the owner to check Settings > Model setup.' + NONE],
'model-catalogue-unavailable': [503, 'The model catalogue could not be read, so this model could not be checked. Check Settings > Model setup, then try again.' + NONE],
'model-harness-incompatible': [409, 'This model does not run on the chosen harness. Pick another model or harness.' + NONE],
'thinking-unsupported': [409, 'The chosen harness does not apply this thinking level. Clear Thinking or pick a level it applies.' + NONE],
'unknown-model': [409, 'This model is not one of the organization\'s models. Pick a model listed under Settings > Model proxy.' + NONE],
'unknown-model': [409, 'This model is not one of the organization\'s models. Pick a model listed under Settings > Routing.' + NONE],
'harness-off': [409, 'This harness is not switched on for the organization. Pick a harness listed under Settings > Routing, or ask the owner to switch it on.' + NONE],
'harness-refused': [409, 'The harness refused this route. Clear Thinking, or pick another model or harness under Settings > Routing.' + NONE],
'template-system-only': [409, 'This role template is for the system, not for an organization. Pick another template.' + NONE],
@@ -100,7 +100,7 @@ const HIRE_START_REFUSALS = {
'credential-scope-exceeded': [409, 'The requested credential scope is wider than the role allows.' + CHECK],
// The fields passed the shape check below, so a malformed answer here is a value the organization
// checks refused: most often a model that is not a launch.models key.
'invalid-request': [400, 'The bus refused a value in this proposal. Pick a model listed under Settings > Model proxy and a role the organization checks accept.' + EITHER],
'invalid-request': [400, 'The bus refused a value in this proposal. Pick a model listed under Settings > Routing and a role the organization checks accept.' + EITHER],
};
// A reply the endpoint cannot read as a definite answer: no answer, or the bus server's request
// codes. Anything else that reads as a code is a definite refusal.
+54 -18
View File
@@ -27,6 +27,7 @@
// handler returns false for them.
import { open } from 'node:fs/promises';
import { pickModel, usableModel } from '../../model-proxy/src/ride.mjs';
import { lstatSync } from 'node:fs';
import { checkProject, initProject, projectRepo, recordContext } from '../../project/src/index.mjs';
import { refuseInsideAgent } from '../../cli/src/transport.mjs';
@@ -285,33 +286,53 @@ function refusal(res, error, { step, id, unknownOk = false }) {
// Default service wiring: the real C1/C2/C3 modules, loaded on first use.
// A missing module (a branch without S1 yet) answers not-configured.
async function load(spec) { try { return await import(spec); } catch (e) { if (e?.code === 'ERR_MODULE_NOT_FOUND') return null; throw e; } }
export function defaultOrgAdmin(env = process.env) {
export function defaultOrgAdmin(env = process.env, { ownerModels = null, rideRemoved = null } = {}) {
let system = null;
// The same context `mosaic org` builds (packages/cli/src/org.mjs): the named
// instance from MOSAIC_CONFIG, its data root and its config directory.
const context = async () => {
if (!system) {
const { loadSystem } = await import('../../cli/src/config.mjs');
const { configDir } = await import('../../organization/src/organization-config.mjs');
const { devOwnerInstance } = await import('../../cli/src/dev-local-owner.mjs');
let instance; try { instance = devOwnerInstance(env); } catch { return null; }
system = { configDir: configDir(env), dataRoot: loadSystem({ env, instance }).dataRoot, instance };
}
return system;
};
return createOrgAdmin({
ownerModels, rideRemoved: rideRemoved ?? removalRecorder(context),
service: () => load('../../organization/src/org-service.mjs'),
registry: () => load('../../organization/src/org-registry.mjs'),
bus: () => load('../../cli/src/org-bus.mjs'),
// The same context `mosaic org` builds (packages/cli/src/org.mjs): the named
// instance from MOSAIC_CONFIG, its data root and its config directory.
context: async () => {
if (!system) {
const { loadSystem } = await import('../../cli/src/config.mjs');
const { configDir } = await import('../../organization/src/organization-config.mjs');
const { devOwnerInstance } = await import('../../cli/src/dev-local-owner.mjs');
let instance; try { instance = devOwnerInstance(env); } catch { return null; }
system = { configDir: configDir(env), dataRoot: loadSystem({ env, instance }).dataRoot, instance };
}
return system;
},
context,
});
}
// A Console without the proxy setup page still records a removal of cliproxy, in the instance's
// proxy receipts (model-proxy admin.mjs appendReceipt), where Ride all reads it. `context()` gives
// the instance's data root; with none, the record and the save are refused.
export function removalRecorder(context) {
return async id => {
const ctx = await context(), proxy = await load('../../model-proxy/src/admin.mjs');
if (!ctx?.dataRoot || !proxy) throw Object.assign(new Error('not-configured'), { code: 'not-configured' });
return proxy.appendReceipt(ctx.dataRoot, { time: new Date().toISOString(), op: 'ride-removed', org: id });
};
}
// `service`, `registry` and `bus` are module objects or functions returning
// them (or null when absent). `context()` gives { configDir, dataRoot, instance }.
export function createOrgAdmin({ service, registry = null, bus = null, context }) {
// `ownerModels()` (#1873 ride-default) answers {proxy, riding, models} from the owner's model
// proxy, read through the riding buses; without it the cliproxy preset reads unavailable.
// `rideRemoved(id)` records in the proxy's receipts that a save took cliproxy off the organization,
// so Ride all leaves it off; without it such a save is refused.
export function createOrgAdmin({ service, registry = null, bus = null, context, ownerModels = null, rideRemoved = null }) {
const get = async x => (typeof x === 'function' ? x() : x);
return { service: () => get(service), registry: () => get(registry), bus: () => get(bus), context: () => get(context) };
const owner = async () => { if (typeof ownerModels !== 'function') return { proxy: false, riding: false, models: [] }; try { return await ownerModels(); } catch { return { proxy: false, riding: false, models: [] }; } };
return { service: () => get(service), registry: () => get(registry), bus: () => get(bus), context: () => get(context), ownerModels: owner, rideRemoved };
}
const providersOf = doc => (Array.isArray(doc?.plugins?.['model-provider']) ? doc.plugins['model-provider'] : []);
const ownerOf = admin => (typeof admin.ownerModels === 'function' ? admin.ownerModels() : { proxy: false, riding: false, models: [] });
// The handler. Returns true when it answered. `owner` is the signed-in owner
// session (provider, iss, sub) or null; `send` says --send is on; `origin` is
@@ -413,17 +434,26 @@ async function route(req, res, { path, search, org, admin, principal, write, log
if (path === '/api/org-presets' && !write) {
if (new URLSearchParams(search).size) return json(res, 422, { error: 'invalid', message: 'unexpected query parameter' });
const service = await need(admin, 'service', res, 'presets'); if (!service) return;
try { return json(res, 200, { presets: await service.orgPresets() }); }
try { return json(res, 200, { presets: await service.orgPresets({ owner: await ownerOf(admin) }) }); }
catch (e) { return refusal(res, e, { step: 'presets' }); }
}
if (path === '/api/org-template' && !write) {
const params = new URLSearchParams(search);
for (const [key] of params) if (!['id', 'preset', 'thinking'].includes(key) || params.getAll(key).length !== 1) return json(res, 422, { error: 'invalid', message: 'invalid template query' });
for (const [key] of params) if (!['id', 'preset', 'thinking', 'model'].includes(key) || params.getAll(key).length !== 1) return json(res, 422, { error: 'invalid', message: 'invalid template query' });
if (params.has('model') && params.get('preset') !== 'cliproxy') return json(res, 422, { error: 'invalid', message: 'model applies to the cliproxy preset only' });
const id = params.has('id') ? params.get('id') : 'new-org';
if (!ID.test(id)) return json(res, 422, { error: 'invalid', errors: [{ path: '$.id', field: 'id', message: 'invalid organization id' }] });
const service = await need(admin, 'service', res, 'template'); if (!service) return;
// #1873 ride-default: the cliproxy preset routes to a model the owner's catalogue lists. A named
// model must be one of them; otherwise the Console picks one (claude first).
let model;
if (params.get('preset') === 'cliproxy') {
const owner = await ownerOf(admin), models = Array.isArray(owner?.models) ? owner.models : [];
model = params.has('model') ? models.find(m => usableModel(m) && m.key === params.get('model')) : (owner?.proxy === true && owner?.riding === true ? pickModel(models) : null);
if (!model) return json(res, 422, { error: 'invalid', step: 'template', errors: [{ path: '$.model', field: 'model', message: params.has('model') ? 'the model proxy lists no such model' : 'the model proxy lists no model you can use' }] });
}
let doc;
try { doc = await service.templateRender(id, params.has('preset') || params.has('thinking') ? { ...(params.has('preset') ? { preset: params.get('preset') } : {}), ...(params.has('thinking') ? { thinking: params.get('thinking') } : {}) } : { fixture: 'local' }); } catch (e) { return refusal(res, e, { step: 'template' }); }
try { doc = await service.templateRender(id, params.has('preset') || params.has('thinking') ? { ...(params.has('preset') ? { preset: params.get('preset') } : {}), ...(params.has('thinking') ? { thinking: params.get('thinking') } : {}), ...(model ? { model } : {}) } : { fixture: 'local' }); } catch (e) { return refusal(res, e, { step: 'template' }); }
const shown = forBrowser(doc);
return json(res, 200, { id, doc: shown.doc, held: shown.held, verb: verbFor('create', id) });
}
@@ -509,6 +539,12 @@ async function route(req, res, { path, search, org, admin, principal, write, log
const doc = toCanonical(id, body.doc, shown.doc);
const checked = await service.validateOrg(doc);
if (!checked.ok) return json(res, 422, { error: 'invalid', step: 'update', errors: withField(checked.errors ?? []) });
// #1873 ride-default: a save that takes cliproxy off leaves a proxy receipt first, so Ride all
// does not put it back. No record, no save.
if (providersOf(shown.doc).includes('cliproxy') && !providersOf(doc).includes('cliproxy')) {
if (typeof admin.rideRemoved !== 'function') return json(res, 503, { error: 'not-configured', step: 'update', message: 'this Console cannot record that the model proxy was taken off, so nothing was saved' });
try { await admin.rideRemoved(id); } catch { return json(res, 500, { error: 'internal', step: 'update', message: 'the removal of the model proxy could not be recorded, so nothing was saved' }); }
}
let receipt;
try { receipt = await service.updateOrg(ctx, id, doc, { ifRevision: body.ifRevision }); } catch (e) { return refusal(res, e, { step: 'update', id, unknownOk: true }); }
return json(res, 200, { outcome: 'done', step: 'update', receipt: forReceipt(ctx, receipt), verb: verbFor('update', id, { revision: body.ifRevision }) });
+4 -1
View File
@@ -24,6 +24,8 @@
// console cap alone, and runs the merge, the digest and the held-credential check itself. `workflows`
// (SP6) is the owner's read of the organization file as the writer reads it ({document, revision,
// templates}), the same read `mosaic org workflow set` takes its revision from; no bus verb answers it.
import { systemOnly } from '../../organization/src/vocabulary.mjs';
export const PACKS_ROUTE = /^\/api\/(?:packs(?:\/(preview|apply|hire))?|board|workflows(?:\/([^/]+))?)$/;
// Which requests the pack route answers. GET and HEAD /api/board stay the Board read (the Console's own task
// board through its upstream); every other method on /api/board is this route's (POST writes, the rest 405).
@@ -171,7 +173,8 @@ async function workflowsRead(res, { workflows, live, session, writable }) {
}
const roles = {
definitions: Object.keys(plain(doc.definitions) ? doc.definitions : {}).sort(),
templates: current.templates.filter(n => typeof n === 'string').sort(),
// #1873 triage-followups: a system-only template (organization vocabulary SYSTEM_ONLY) is never offered.
templates: current.templates.filter(n => typeof n === 'string' && !systemOnly(n)).sort(),
};
return json(res, 200, { workflows: flowsOf(doc), projects, roles, revision: current.revision, writable });
}
+9 -1
View File
@@ -28,6 +28,9 @@ const ROUTES = Object.freeze({
'/api/proxy/admin/unit/restart': ['POST', []],
'/api/proxy/admin/fence/clear': ['POST', []],
'/api/proxy/admin/init-lock/clear': ['POST', []],
// #1873 ride-default: Ride all, and the confirmed move of one stopped fixture organization.
'/api/proxy/admin/ride-all': ['POST', []],
'/api/proxy/admin/ride-move': ['POST', ['org']],
});
export const PROXY_ADMIN_PATHS = Object.freeze(Object.keys(ROUTES));
const INIT_KEYS = ['generate', 'key', 'confirm', 'port', 'rotateGraceMinutes', 'firstOutputSeconds'];
@@ -46,7 +49,8 @@ const STATUS = { 'human-required': 403, 'proxy-key-transport': 403, 'not-configu
// `owner` is true only for the instance owner's session (the dev local owner, or the root owner
// signed in under --sso). `call` is the owner's transport to the selected bus, or null.
export async function proxyAdminHTTP(req, res, { path, admin, call, named, tester, granted, owner, send, origin, user, log }) {
// `principal` is that session's {provider, iss, sub}; the organization service checks it again.
export async function proxyAdminHTTP(req, res, { path, admin, call, named, tester, granted, owner, send, origin, user, principal = null, log }) {
const route = ROUTES[path];
const done = (status, value) => {
// Path, method and status only: never a body, key, evidence or exception text.
@@ -105,6 +109,10 @@ export async function proxyAdminHTTP(req, res, { path, admin, call, named, teste
if (!call) return refuse('not-configured');
return done(200, await admin.fenceClear(call));
case '/api/proxy/admin/init-lock/clear': return done(200, await admin.initLockClear());
case '/api/proxy/admin/ride-all': return done(200, await admin.rideAll());
case '/api/proxy/admin/ride-move':
if (typeof args.org !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(args.org)) return refuse('invalid-request');
return done(200, await admin.rideMove({ org: args.org, principal }));
}
} catch (error) {
const code = ['human-required', 'not-configured', 'invalid-request'].includes(error?.code) ? error.code : proxyCode(error, 'outcome-unknown');
+3 -1
View File
@@ -51,6 +51,8 @@ export async function proxyHTTP(req, res, { path, call, named, tester, granted,
try { return done(200, await call(route[1], args)); }
catch (error) {
const code = codes.includes(error.code) || (path === '/api/proxy/plugins/set' && typeof error.code === 'string' && /^[a-z-]{1,64}$/.test(error.code)) ? error.code : 'outcome-unknown';
return done(code === 'human-required' ? 403 : ['not-configured', 'proxy-down', 'outcome-unknown'].includes(code) ? 503 : 400, { error: code });
// proxy-pickup (#1873): a bus with no proxy client names the cause in one plain line.
const reason = code === 'not-configured' && typeof error.reason === 'string' ? { reason: error.reason.slice(0, 300) } : {};
return done(code === 'human-required' ? 403 : ['not-configured', 'proxy-down', 'outcome-unknown'].includes(code) ? 503 : 400, { error: code, ...reason });
}
}
+30 -22
View File
@@ -193,7 +193,7 @@
catch { return { unknown: true }; }
if (res.type === 'opaqueredirect') return { signedOut: true };
try { result = await res.json(); } catch { return { unknown: true }; }
return { ok: res.ok, result };
return { ok: res.ok, status: res.status, result };
}
// The request's closing read, or a reason the chain stops.
async function closing(request, org) {
@@ -215,31 +215,39 @@
return e ? (Array.isArray(e.running) ? e.running.length : 0) : 0;
} catch { return null; }
}
async function restartAgent(name, thread) {
const org = window.MosaicOrg?.id ?? null;
const r = restarts[name] = { busy: true, text: `Terminating ${name}…` };
const paint = () => paintRestart(name, org);
const stop = text => { r.busy = false; r.text = text; paint(); };
paint();
const asked = await send(pin(org, '/api/agent/terminate'), { instance: name, reason: 'route change' });
if (asked.signedOut) return stop('Sign in again, then retry.');
if (asked.unknown || !asked.ok || !REQUEST_ID.test(asked.result?.request ?? '')) return stop(asked.ok || asked.unknown ? UNKNOWN : refused(asked.result));
// SP19 (#1873): the agent drawer's Restart runs this same chain. `org` is the agent's own organization
// (on #/agents the page has none), `reason` goes with the terminate, `text(step, detail)` may give the
// words for a step (nothing keeps the route-change words below), and `onStatus({ step, busy, text })`
// takes each line in place of the Routing receipt's button. The chain never regenerates.
async function restartAgent(name, thread, { org = window.MosaicOrg?.id ?? null, reason = 'route change', text, onStatus } = {}) {
const r = { busy: true, text: '' };
if (!onStatus) restarts[name] = r;
const paint = step => onStatus ? onStatus({ step, busy: r.busy, text: r.text }) : paintRestart(name, org);
const words = (step, detail, own) => (typeof text === 'function' ? text(step, detail) : undefined) ?? own;
const say = (step, detail, own) => { r.text = words(step, detail, own); paint(step); };
const stop = (step, detail, own) => { r.busy = false; say(step, detail, own); };
say('ending', {}, `Terminating ${name}…`);
const asked = await send(pin(org, '/api/agent/terminate'), { instance: name, reason });
if (asked.signedOut) return stop('signedOut', {}, 'Sign in again, then retry.');
if (asked.unknown || !asked.ok || !REQUEST_ID.test(asked.result?.request ?? '')) return asked.ok || asked.unknown ? stop('endUnknown', {}, UNKNOWN) : stop('endRefused', { status: asked.status, result: asked.result }, refused(asked.result));
const ended = await closing(asked.result.request, org);
if (ended.stop) return stop(ended.stop);
if (ended.done.reason) return stop(`${name}: ${ended.done.reason}. It was not restarted.`);
r.text = `Terminated ${name}. Waiting for its session to end…`; paint();
if (ended.stop) return stop('endOpen', { stop: ended.stop }, ended.stop);
if (ended.done.reason) return stop('endClosed', { reason: ended.done.reason }, `${name}: ${ended.done.reason}. It was not restarted.`);
say('ended', {}, `Terminated ${name}. Waiting for its session to end…`);
let left = false;
for (let i = 0; i < RESTART_WAIT && !left; i++) { await new Promise(res => setTimeout(res, POLL_MS)); left = (await runs(name, org)) === 0; }
if (!left) return stop(`${name} was asked to end but its session is still running. Launch it from Agents once it has ended.`);
if (thread) return stop(`Terminated ${name} at ${new Date().toLocaleTimeString()}. Its next message starts it on the new route.`);
r.text = `Launching ${name}…`; paint();
if (!left) return stop('stillRunning', {}, `${name} was asked to end but its session is still running. Launch it from Agents once it has ended.`);
const time = new Date().toLocaleTimeString();
if (thread) return stop('threadEnded', { time }, `Terminated ${name} at ${time}. Its next message starts it on the new route.`);
say('launching', {}, `Launching ${name}…`);
const launch = await send(pin(org, '/api/agent/launch'), { instance: name });
if (launch.signedOut) return stop('Sign in again. It was terminated and not launched.');
if (launch.unknown || !launch.ok || !REQUEST_ID.test(launch.result?.request ?? '')) return stop(launch.ok || launch.unknown ? `${UNKNOWN} It was terminated.` : `${refused(launch.result)} It was terminated and not launched.`);
if (launch.signedOut) return stop('launchSignedOut', {}, 'Sign in again. It was terminated and not launched.');
if (launch.unknown || !launch.ok || !REQUEST_ID.test(launch.result?.request ?? '')) return launch.ok || launch.unknown ? stop('launchUnknown', {}, `${UNKNOWN} It was terminated.`) : stop('launchRefused', { status: launch.status, result: launch.result }, `${refused(launch.result)} It was terminated and not launched.`);
const started = await closing(launch.result.request, org);
if (started.stop) return stop(started.stop);
if (started.done.reason) return stop(`${name}: ${started.done.reason}. It was terminated and not launched.`);
return stop(`Restarted ${name} on the new route${started.done.done?.run ? ` (run ${started.done.done.run})` : ''}.`);
if (started.stop) return stop('launchOpen', { stop: started.stop }, started.stop);
if (started.done.reason) return stop('launchClosed', { reason: started.done.reason }, `${name}: ${started.done.reason}. It was terminated and not launched.`);
const run = started.done.done?.run ?? null;
return stop('restarted', { run }, `Restarted ${name} on the new route${run ? ` (run ${run})` : ''}.`);
}
document.addEventListener('click', e => {
const b = e.target.closest?.('[data-agent-restart]');
@@ -247,7 +255,7 @@
restartAgent(b.dataset.agentRestart, b.dataset.agentThread === 'yes');
});
window.MosaicAgents = Object.freeze({ section, restartMarkup, isThread: definition => threadDefinitions.has(definition) });
window.MosaicAgents = Object.freeze({ section, restartMarkup, restart: restartAgent, isThread: definition => threadDefinitions.has(definition) });
})();
/* #1873 A2: Settings > Agents, the root and project agent levels. bus.js awaits section() for the
+95 -20
View File
@@ -321,7 +321,7 @@
// render. That read marks nothing. Row 150 (#1644): since row 142, `mosaic talk` prints only the
// reply to its own message, so a reply to a Console send stays unread in `mosaic inbox` until
// the human marks it read with `mosaic inbox --read`.
let isTester = false, orgSetup = false;
let isTester = false, orgSetup = false, triageOwner = false;
// Both Docs and project direction use the same owner-only records setup action.
window.MosaicRecords = {
markup(project) {
@@ -1306,6 +1306,50 @@
const ROUTE_CELLS=[['harness','Harness'],['model','Model'],['thinking','Thinking'],['fallback.harness','Fallback harness'],['fallback.model','Fallback model'],['fallback.thinking','Fallback thinking']];
const routeCells=r=>({harness:r.harness??'',model:r.model??'',thinking:r.thinking??'','fallback.harness':r.fallback?.harness??'','fallback.model':r.fallback?.model??'','fallback.thinking':r.fallback?.thinking??''});
const sameCells=(a,b)=>ROUTE_CELLS.every(([k])=>a[k]===b[k]);
// #1873 settings slice 1 (D2): an organization that lists the model service but cannot see its
// models. For the instance owner the page reads the model service's state once per visit, so the
// line says which is true: the service is not set up, not running or waiting on a restart after
// a key write (a link to its page), or it runs and this organization still cannot read it. A
// running bus picks the service up at its next catalogue read (proxy-pickup), so a Restart is
// offered only when the state says it helps: the bus names no cause, or names one a fresh start
// clears (MosaicConsole.catalogueCause). With the dev fixture a restart is refused and stops the
// organization, so that cause gets its plain line and Check again. The Restart is never a guess.
let serviceState=null, serviceLoading=false;
function readService(){
if(serviceLoading||serviceState!==null||isTester||!triageOwner||!window.MosaicOrg)return; serviceLoading=true;const epoch=orgEpoch;
fetch('/api/proxy/admin/status',{cache:'no-store',redirect:'manual'}).then(async r=>{const v=await r.json();if(epoch!==orgEpoch)return;if(!r.ok||!v||typeof v!=='object')throw Error();
serviceState=v.init?.initialized!==true?'not-set-up':v.fence?.set===true?'fenced':v.unit?.active==='active'&&v.unit?.healthy===true?'running':'not-running';})
.catch(()=>{if(epoch!==orgEpoch)return;serviceState=false;}).finally(()=>{if(epoch!==orgEpoch)return;serviceLoading=false;if(routeOf().split('?')[0]==='/settings/routing')render(false);});
}
function catalogueLine(proxyOn,catalogue){
const label=window.MosaicOrg?.label||'This organization', org=txt(label), id=window.MosaicOrg?.id, owner=canSend&&!isTester;
const lead=`<b>${org} can't see your models yet.</b>`, thinking='A change to thinking alone still saves.';
// The bus's cause (proxy-pickup). A known cause reads as one plain line with the bus's words
// under Technical details; an unknown one shows the bus's words as they are.
const cause=window.MosaicConsole?.catalogueCause?.(label,catalogue?.notices,catalogue?.reason)??null;
const words=!cause?'':cause.plain?`<details class="routes-cause-detail"><summary>Technical details</summary><p class="small muted">${txt(cause.detail)}</p></details>`:`<p class="small warn">${txt(cause.detail)}</p>`;
const plain=cause?.plain?` ${txt(cause.plain)}`:'';
const setupLink=text=>`<a href="#/settings/model-proxy">${text}</a>`;
if(!proxyOn)return `<p class="small warn" id="routes-catalogue">${lead}${plain} ${thinking}</p>${words}`;
if(owner)readService();
const recheck='<button type="button" id="routes-recheck">Check again</button>';
const restart=primary=>window.MosaicConsole?.orgRestartButton?.(id,{name:label,primary})??'';
if(owner&&serviceState==='running'&&cause){
const fix=cause.fix==='service'?` ${setupLink('Open Model setup')}.`:'';
const next=cause.restart?`Restart ${org} to try again. It stops for a moment and starts again.`:cause.code==='fixture-proxy-configured'?'':'Check again once that is fixed.';
return `<div class="banner routes-catalogue" id="routes-catalogue" role="status"><p>${lead} ${cause.plain?`Your model service is running.${plain}${fix}`:`Your model service is running, but ${org} can't use it. ${org} says why:`}</p>${cause.plain?'':words}<p>${next} ${thinking}</p><p class="actions">${cause.restart?restart(true)+' ':''}${recheck}</p>${cause.plain?words:''}</div>`;
}
if(owner&&serviceState==='running')return `<div class="banner routes-catalogue" id="routes-catalogue" role="status"><p>${lead} Your model service is running, but ${org} can't read your models from it. Restart ${org} to connect it again. It stops for a moment and starts again. ${thinking}</p>${restart(true)}</div>`;
if(owner&&serviceState==='not-set-up')return `<p class="small warn" id="routes-catalogue">${lead} Your model service isn't set up yet. ${setupLink('Set up the model service')}. ${thinking}</p>`;
if(owner&&serviceState==='fenced')return `<p class="small warn" id="routes-catalogue">${lead} Your model service is waiting for a restart to finish. ${setupLink('Open Model setup to finish it')}. ${thinking}</p>`;
if(owner&&serviceState==='not-running')return `<p class="small warn" id="routes-catalogue">${lead} The model service is not running. ${setupLink('Open Model setup')}. ${thinking}</p>${words}`;
if(owner&&(serviceLoading||(serviceState===null&&triageOwner)))return `<p class="small warn" id="routes-catalogue">${lead} Checking the model service. ${thinking}</p>`;
if(owner&&serviceState===false)return `<div class="banner routes-catalogue" id="routes-catalogue" role="status"><p>${lead}${plain} The model service's status could not be read. ${thinking}</p>${words}<p class="actions">${recheck}</p></div>`;
return `<p class="small warn" id="routes-catalogue">${lead}${plain} ${thinking}${owner?' A new model needs the model service: ask the instance owner to set it up, or press Stop using the model service when this organization does not need it.':''}</p>${words}`;
}
// Check again rereads Routing; the bus looks for the model service at that read. A draft is kept.
document.addEventListener('click',e=>{if(e.target.id!=='routes-recheck')return;e.target.disabled=true;serviceState=null;routesView=null;last.delete('routes');render(true);});
document.addEventListener('mosaic-org-restarted',e=>{if(e.detail?.id!==window.MosaicOrg?.id)return;serviceState=null;routesView=null;last.delete('routes');const path=routeOf().split('?')[0];if(path==='/settings/routing'||document.querySelector('[data-org-down]'))render(true);});
function routesSection(view,instanceInfo){
const title='<h2 id="routes-title">Routing</h2>';
readHarnesses();
@@ -1334,11 +1378,11 @@
// fixture-only catalogue is ready with no model proxy). Before the setting is read it falls
// back to the catalogue status, as before.
const proxyOn=harnessSettings?(Array.isArray(harnessSettings.plugins?.['model-provider'])?harnessSettings.plugins['model-provider']:[]).includes('cliproxy'):v.catalogue?.status!=='disabled';
const catalogueInfo=v.catalogue?.status==='ready'?`<p class="small muted">Model catalogue, observed ${txt(window.MosaicLocalTime(v.catalogue.observedAt))}.</p>${(v.catalogue.notices??[]).map(n=>`<p class="small warn">${txt(n)}</p>`).join('')}`:v.catalogue?.status==='unavailable'?`<p class="small warn">Model catalogue unavailable. A change to thinking alone still saves.${proxyOn&&canSend&&!isTester?' A new model needs the catalogue: set up the model proxy, or, when this organization has none, press Disable model proxy catalogue.':''}</p>`:'<p class="small muted">Model catalogue not enabled.</p>';
const providerControl=canSend&&!isTester?`<button type="button" id="provider-switch" data-enabled="${proxyOn}">${proxyOn?'Disable':'Enable'} model proxy catalogue</button><p role="status" id="provider-switch-status"></p>`:'';
const catalogueInfo=v.catalogue?.status==='ready'?`<p class="small muted">Model catalogue, observed ${txt(window.MosaicLocalTime(v.catalogue.observedAt))}.</p>${(v.catalogue.notices??[]).map(n=>`<p class="small warn">${txt(n)}</p>`).join('')}`:v.catalogue?.status==='unavailable'?catalogueLine(proxyOn,v.catalogue):'<p class="small muted">Model catalogue not enabled.</p>';
const providerControl=canSend&&!isTester?`<button type="button" id="provider-switch" data-enabled="${proxyOn}">${proxyOn?'Stop using the model service':'Use your models'}</button><p role="status" id="provider-switch-status"></p>`:'';
const harnessControl=canSend&&!isTester?`<fieldset class="harness-control"><legend>Harnesses</legend>${harnessSettings ? [...new Set([...harnessSettings.available.harness,...(harnessSettings.plugins.harness??[])])].map(name=>`<label><input type="checkbox" data-harness="${esc(name)}"${(harnessDraft??harnessSettings.plugins.harness??[]).includes(name)?' checked':''}${harnessBusy?' disabled':''}> ${txt(name)}</label>`).join('')+` <button type="button" id="harness-save"${harnessBusy?' disabled':''}>Save harnesses</button>` : '<p>Harnesses unavailable.</p><button type="button" id="harness-read">Read harnesses again</button>'}<p role="status" id="harness-status">${txt(harnessReceipt)}</p></fieldset>`:'';
const off=v.harnesses.length?'':'<p class="small warn">No harness is switched on in the business file\'s plugins.harness, so every launch refuses harness-off and a save that changes a harness refuses too. Switch one on under Harnesses.</p>';
return `<section class="panel routing-panel" aria-labelledby="routes-title"><span class="sr-only">${title}</span>${catalogueInfo}${providerControl}${harnessControl}${off}<form id="routes-form"><div class="table-wrap" tabindex="0" role="region" aria-label="Routes, scroll for all columns"><table id="routes-table"><thead><tr><th scope="col" rowspan="2">Agent</th><th scope="colgroup" colspan="3">Primary</th><th scope="colgroup" colspan="3">Fallback</th></tr><tr>${ROUTE_CELLS.map(([,l])=>`<th scope="col">${l.replace('Fallback ','')}</th>`).join('')}</tr></thead><tbody>${rows}</tbody></table></div><p class="small muted">${canSend || isTester?'Changes are checked and logged with your identity.':'Saving requires signed-in send mode.'}</p><div class="settings-actions route-actions${routesDraft?' has-draft':''}"><button type="submit"${disabled}>${routesBusy?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':'Save routes'}</button> <button type="button" id="routes-reload"${routesDraft?'':' hidden'}${routesBusy||!routesDraft?' disabled':''}>Discard draft</button><p role="status" id="routes-receipt" class="${routesReceipt.startsWith('Outcome unknown')?'banner ref':routesReceipt.includes('Draft kept')?'banner err':routesReceipt.includes('saved')?'settings-success':''}">${txt(routesReceipt)}</p></div>${routesApplyMarkup()}</form></section>`;
const off=v.harnesses.length?'':'<p class="small warn">No harness is switched on for this organization, so every launch is refused, and so is a save that changes a harness. Switch one on under Harnesses.</p>';
return `<section class="panel routing-panel" aria-labelledby="routes-title"><span class="sr-only">${title}</span>${catalogueInfo}${providerControl}${harnessControl}${off}<form id="routes-form"><div class="table-wrap" tabindex="0" role="region" aria-label="Routes, scroll for all columns"><table id="routes-table"><thead><tr><th scope="col" rowspan="2">Agent</th><th scope="colgroup" colspan="3">Primary</th><th scope="colgroup" colspan="3">Fallback</th></tr><tr>${ROUTE_CELLS.map(([,l])=>`<th scope="col">${l.replace('Fallback ','')}</th>`).join('')}</tr></thead><tbody>${rows}</tbody></table></div><p class="small muted">${canSend || isTester?'Changes are checked and logged with your identity.':'Saving requires signed-in send mode.'}</p><div class="settings-actions route-actions${routesDraft?' has-draft':''}"><button type="submit"${/ data-primary[ >]/.test(catalogueInfo)?' class="route-save-quiet"':''}${disabled}>${routesBusy?'<span class="settings-spinner" aria-hidden="true"></span> Saving…':'Save routes'}</button> <button type="button" id="routes-reload"${routesDraft?'':' hidden'}${routesBusy||!routesDraft?' disabled':''}>Discard draft</button><p role="status" id="routes-receipt" class="${routesReceipt.startsWith('Outcome unknown')?'banner ref':routesReceipt.includes('Draft kept')?'banner err':routesReceipt.includes('saved')?'settings-success':''}">${txt(routesReceipt)}</p></div>${routesApplyMarkup()}</form></section>`;
}
function routesFields(form){const draft=Object.fromEntries(Object.keys(routesView.instances).map(name=>[name,routeCells(routesView.instances[name])]));for(const el of form.querySelectorAll('[data-route]')){const [name,key]=JSON.parse(el.dataset.route);if(draft[name])draft[name][key]=el.value;}return draft;}
// The changed rows only. A fallback with all three cells empty is cleared; one with some set goes
@@ -1357,13 +1401,13 @@
// A viewer without the switch is sent to the owner.
function catalogueStep(code,routes){
if(!['model-catalogue-unavailable','model-provider-unavailable'].includes(code))return '';
if(!canSend||isTester)return ' Ask the organization\'s owner to set up the model proxy, or to disable the model proxy catalogue when the change needs no proxy.';
if(!canSend||isTester)return ' Ask the organization\'s owner to set up the model service, or to stop using it when the change does not need it.';
const names=Array.isArray(harnessSettings?.plugins?.['model-provider'])?harnessSettings.plugins['model-provider']:[];
if(!names.includes('cliproxy'))return '';
const moved=Object.entries(routes).flatMap(([name,r])=>{const was=routesView?.instances?.[name]??{};
return [[r.harness,r.model,was.harness,was.model],[r.fallback?.harness,r.fallback?.model,was.fallback?.harness,was.fallback?.model]].filter(([h,m,wh,wm])=>m&&(h!==wh||m!==wm)).map(([,m])=>m);});
const module=key=>routesView?.providerModels?.[key]?.module;
return moved.length&&moved.every(key=>module(key)&&module(key)!=='cliproxy'&&names.includes(module(key)))?' This change needs no model proxy: press Disable model proxy catalogue, then save again.':'';
return moved.length&&moved.every(key=>module(key)&&module(key)!=='cliproxy'&&names.includes(module(key)))?' This change does not need the model service: press Stop using the model service, then save again.':'';
}
const routesAnswer=r=>/^[a-f0-9]{64}$/.test(r?.revision??'')&&Array.isArray(r.harnesses)&&Array.isArray(r.models)&&[r.levels,r.instances].every(o=>o&&typeof o==='object'&&!Array.isArray(o));
for(const kind of ['input','change'])document.addEventListener(kind,e=>{const form=e.target?.closest?.('#routes-form');if(!form||!routesView)return;routesDraft=routesFields(form);routesEditVersion++;markSettingsDraft('routing',true);form.querySelector('.settings-actions')?.classList.add('has-draft');const discard=$('routes-reload');if(discard){discard.hidden=false;discard.disabled=false;}
@@ -1388,7 +1432,7 @@
try {const read=await fetch('/api/proxy/plugins',{cache:'no-store'});const settings=await read.json();if(epoch!==orgEpoch)return;if(!read.ok||!/^[a-f0-9]{64}$/.test(settings.revision??''))throw Error('Could not read provider settings.');
const names=Array.isArray(settings.plugins?.['model-provider'])?settings.plugins['model-provider']:[];
// The fresh read decides: a stale label never turns the proxy module on when it meant off.
const on=names.includes('cliproxy');if(String(on)!==button.dataset.enabled){button.dataset.enabled=String(on);button.textContent=`${on?'Disable':'Enable'} model proxy catalogue`;button.disabled=false;status.textContent='The switch now shows the current setting. Press it again to change it.';return;}
const on=names.includes('cliproxy');if(String(on)!==button.dataset.enabled){button.dataset.enabled=String(on);button.textContent=on?'Stop using the model service':'Use your models';button.disabled=false;status.textContent='The switch now shows the current setting. Press it again to change it.';return;}
const next=on?names.filter(n=>n!=='cliproxy'):[...names,'cliproxy'];
const response=await fetch('/api/proxy/plugins/set',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({revision:settings.revision,plugins:{'model-provider':next}}),cache:'no-store',redirect:'manual'});
if(epoch!==orgEpoch)return;if(!response.ok)throw Error('Provider setting was refused.');harnessSettings=null;routesView=null;last.delete('routes');render(true);
@@ -1431,13 +1475,13 @@
});
});
// Organizations is writable when the server allows org setup, which it does in organization mode where send is off.
const readonlyPage = page => !['appearance','business','console'].includes(page) && !(page === 'organizations' && orgSetup) && !canSend && !isTester;
const settingsPages = [['appearance','Appearance'],['business',window.MosaicOrg ? 'Organization' : 'Business'],['limits','Launch limits'],['organizations','Organizations'],['routing','Routing'],['agents','Agents'],['assistant','Assistant'],['tokens','Token use'],['model-proxy','Model proxy'],['console','Console'],['about','About']];
const readonlyPage = page => !['appearance','business','console','triage'].includes(page) && !(page === 'organizations' && orgSetup) && !canSend && !isTester;
const settingsPages = [['appearance','Appearance'],['business',window.MosaicOrg ? 'Organization' : 'Business'],['limits','Launch limits'],['organizations','Organizations'],['routing','Routing'],['agents','Agents'],['assistant','Assistant'],['tokens','Token use'],['model-proxy','Model setup'],['triage','Triage'],['console','Console'],['about','About']];
function markSettingsDraft(page,dirty){const link=document.querySelector(`#settings-nav a[href="#/settings/${page}"]`), dot='<span class="settings-dot"><span class="sr-only">unsaved changes</span></span>';if(link && dirty && !link.querySelector('.settings-dot'))link.insertAdjacentHTML('beforeend',dot);const button=$('settings-disclosure');if(dirty && link?.getAttribute('aria-current')==='page' && button && !button.querySelector('.settings-dot'))button.querySelector('strong').insertAdjacentHTML('beforeend',dot);}
function settingsShell(page, body, helper='') {
const pages=isTester ? [['appearance','Appearance'],['business','Business'],['routing','Routing'],['agents','Agents'],['names','Seat names']] : settingsPages;
const pages=isTester ? [['appearance','Appearance'],['business','Business'],['routing','Routing'],['agents','Agents'],['names','Seat names']] : settingsPages.filter(([id])=>id!=='triage'||triageOwner);
const label=pages.find(([id])=>id===page)?.[1] || 'Appearance';
const isDirty=id=>(id==='routing'&&routesDraft)||(id==='limits'&&settingsInputs)||(id==='assistant'&&(Object.keys(assistantDrafts).length||Object.keys(nameDrafts).length))||(id==='agents'&&(instanceDrafts.add||instanceDrafts.change||window.MosaicAgentLevels?.hasDraft()));
const isDirty=id=>(id==='routing'&&routesDraft)||(id==='limits'&&settingsInputs)||(id==='assistant'&&(Object.keys(assistantDrafts).length||Object.keys(nameDrafts).length))||(id==='agents'&&(instanceDrafts.add||instanceDrafts.change||window.MosaicAgentLevels?.hasDraft()))||(id==='triage'&&window.MosaicTriageRoute?.hasDraft());
const dot='<span class="settings-dot"><span class="sr-only">unsaved changes</span></span>';
const links=pages.map(([id,name],i)=>`${i===0?'<div class="settings-group">Your browser</div>':i===1?'<div class="settings-group">This instance</div>':''}<a href="#/settings/${id}"${id===page?' aria-current="page"':''}>${name}${isDirty(id)?dot:''}</a>`).join('') + (!isTester ? '<div class="settings-group">Members and invites <span class="muted">not built</span></div>' : '');
return `${head('Settings','Your browser and this instance.')}<div class="settings-layout"><div><button type="button" id="settings-disclosure" aria-expanded="false" aria-controls="settings-nav"><small>Section</small><strong>${label}${isDirty(page)?dot:''}</strong><span aria-hidden="true">⌄</span></button><nav id="settings-nav" aria-label="Settings sections">${links}</nav></div><div class="settings-content settings-${page}${readonlyPage(page)?' readonly':''}"><h2 id="settings-page-title" tabindex="-1">${label}</h2><p class="settings-helper">${helper}</p>${readonlyPage(page)?'<p class="settings-readonly">Read only. Saving requires signed-in send mode.</p>':''}${body}</div></div>`;
@@ -1446,7 +1490,9 @@
if (page==='business') return businessView(get);
if (page==='appearance') return settingsShell(page,appearance(),'These choices apply in this browser only.');
if (page==='organizations') { await configRead; return settingsShell(page,window.MosaicOrgCreate.markup,'Create an organization from the template, edit it, and finish its setup. Each step names the command it equals.'); }
if (page==='model-proxy') { await configRead; return settingsShell(page,window.MosaicProxy.markup,'Accounts used by this instance, their priority, and the client keys assigned to agents.'); }
if (page==='model-proxy') { await configRead; return settingsShell(page,window.MosaicProxy.markup,'Your model service, the accounts it uses and their priority, and the keys agents use to reach it.'); }
// #1873 triage-settings: Settings > Triage (triage-settings.js), the instance owner's only; anyone else gets no page.
if (page==='triage') { await configRead; if (!triageOwner || !window.MosaicTriageRoute) return notFound(); return settingsShell(page,await window.MosaicTriageRoute.section(),'The model Triage uses, what runs it, and its daily token limit. Only the instance owner sees this page.'); }
// F3: Settings > Console (console-restart.js). The server checks the owner, Origin and trail.
if (page==='console') { await configRead; await window.MosaicConsole?.ready; return settingsShell(page,window.MosaicConsole?.settingsMarkup()??'<section class="panel"><p class="small warn">The Console controls did not load. Reload the page to try again.</p></section>','Restart this Console on the same address and configuration.'); }
const s = await get.api('settings'), n = s.notifier || {};
@@ -1457,11 +1503,11 @@
// #1873 A2: the root and project agent levels (agents.js MosaicAgentLevels), the owner's only.
let agentLevels='';
if (page==='agents' && window.MosaicOrg && window.MosaicAgentLevels && !isTester) agentLevels = await window.MosaicAgentLevels.section().catch(()=>'');
if (page==='routing') { try { [routes] = await get('routes'); } catch (err) { if (err.status === 403 || err.code === 'signed-out') throw err; } }
if (page==='routing') { await window.MosaicConsole?.ready; try { [routes] = await get('routes'); } catch (err) { if (err.status === 403 || err.code === 'signed-out') throw err; } }
if (page==='tokens' && s.launch && !s.launch.refused) takeSnapshot(s.launch);
const notify = typeof n.binding==='string' ? `<code>${txt(n.binding)}</code>` : n.refused ? `Could not be read: <code>${txt(n.refused)}</code>` : '<span class="muted">None set</span>';
const contents={limits:()=>launchForm(s.launch),routing:()=>routesSection(routes,instances),agents:()=>agentsSection(instances)+agentLevels,assistant:()=>assistantSection(s.launch,names),tokens:()=>tokenLimits(limitRows,limitsRefused)+tokenUsage(usage),names:()=>testerNames(names,instances),about:()=>`<section class="panel"><dl class="kv"><dt>Address</dt><dd><code>${txt(s.address)||'unknown'}</code></dd><dt>Release</dt><dd>${txt(s.release)||'unknown'}</dd><dt>Business</dt><dd>${txt(s.business)||none}</dd><dt>Board</dt><dd><code>${txt(s.board)||'unknown'}</code></dd><dt>Notifier binding</dt><dd>${notify}</dd></dl></section>`, 'model-proxy':()=>'<section class="panel"><a href="#/settings/model-proxy">Open model proxy settings</a></section>'};
const helpers={limits:'Leave a limit blank for no limit. Zero stops new launches. Running sessions keep running when limits or models change.',routing:"Each agent’s harness, model and thinking, and the fallback a launch takes when the primary harness fails its preflight. A fallback sets all three or none. Running sessions keep their route. The next launch reads the change.",agents:'Each agent with its definition, launch membership and runs. A launch refuses until the agent has a route in Routing.',assistant:'The definition stays an assistant one. Holder and credentials stay hand edits.',tokens:'Token limits the bus checks, and token use read from session transcripts.'};
const contents={limits:()=>launchForm(s.launch),routing:()=>routesSection(routes,instances),agents:()=>agentsSection(instances)+agentLevels,assistant:()=>assistantSection(s.launch,names),tokens:()=>tokenLimits(limitRows,limitsRefused)+tokenUsage(usage),names:()=>testerNames(names,instances),about:()=>`<section class="panel"><dl class="kv"><dt>Address</dt><dd><code>${txt(s.address)||'unknown'}</code></dd><dt>Release</dt><dd>${txt(s.release)||'unknown'}</dd><dt>Business</dt><dd>${txt(s.business)||none}</dd><dt>Board</dt><dd><code>${txt(s.board)||'unknown'}</code></dd><dt>Notifier binding</dt><dd>${notify}</dd></dl></section>`, 'model-proxy':()=>'<section class="panel"><a href="#/settings/model-proxy">Open Model setup</a></section>'};
const helpers={limits:'Leave a limit blank for no limit. Zero stops new launches. Running sessions keep running when limits or models change.',routing:"Each agent’s harness, model and thinking, and the fallback a launch takes when the primary harness fails its preflight. A fallback sets all three or none. Running sessions keep their route. The next launch reads the change. A harness is the program that runs the model, such as Claude Code. Preflight is the check a launch makes before it starts.",agents:'Each agent with its definition, launch membership and runs. A launch refuses until the agent has a route in Routing.',assistant:'The definition stays an assistant one. Holder and credentials stay hand edits.',tokens:'Token limits the bus checks, and token use read from session transcripts.'};
return settingsShell(page,contents[page](),`${get.oldest()?`Read ${when(get.oldest())}.`: 'Reading…'} ${helpers[page]||''}`);
}
let settingsFocusDisclosure=false;
@@ -1672,7 +1718,27 @@
const refusal = err => err.status === 403 || ['not-configured', 'no-bus-host', 'queue-refused'].includes(err.code);
// After a refusal nothing read before is shown anywhere: not in a view, the palette or the Inbox count.
function forget() { window.MosaicChat?.forget(); last.clear(); inboxCount = null; messageCount = null; }
const failedView = (err, path) => `${head(path === '/queue' ? 'Queue' : failTitle(err))}<div class="banner ${refusal(err) ? 'ref' : 'err'}" role="alert"><p>${refusal(err) ? `<b>refused: <code>${txt(err.code)}</code>.</b> ` : ''}${why(err, err.code === 'queue-refused')} Console shows nothing rather than a guess. Nothing was written.</p>${retry}</div>${empty('Nothing to show.', refusal(err) ? 'The view stays empty until the problem above is fixed.' : err.module ? 'Read again.' : 'Read again, or come back when the bus answers.')}`;
// One shipped copy of the line every failed read ends with (failedView and settingsFailed).
const NO_GUESS = 'Console shows nothing rather than a guess. Nothing was written.';
const failedView = (err, path) => `${head(path === '/queue' ? 'Queue' : failTitle(err))}<div class="banner ${refusal(err) ? 'ref' : 'err'}" role="alert"><p>${refusal(err) ? `<b>refused: <code>${txt(err.code)}</code>.</b> ` : ''}${why(err, err.code === 'queue-refused')} ${NO_GUESS}</p>${retry}</div>${empty('Nothing to show.', refusal(err) ? 'The view stays empty until the problem above is fixed.' : err.module ? 'Read again.' : 'Read again, or come back when the bus answers.')}`;
// #1873 settings slice 1 (D7): an organization page under Settings that cannot be read keeps the
// Settings nav, so the instance pages (Appearance, Model setup, Triage, Console) stay one link
// away. When the organization's bus is down the page says so in plain words and offers Restart,
// whose refusal stays on screen (console-restart.js keeps it per organization); the header's own
// "Bus unavailable" banner steps aside on this page so there is one Restart, not two.
function settingsFailed(err, path) {
const page = path.split('/')[2] || 'appearance', id = window.MosaicOrg?.id, row = id ? window.MosaicOrg.row?.(id) : null;
const org = txt(window.MosaicOrg?.label || id || ''), name = settingsPages.find(([p]) => p === page)?.[1] || 'this page';
if (id && row?.busHealthy === false && !refusal(err)) {
const restart = window.MosaicConsole?.orgRestartButton?.(id, { name: window.MosaicOrg.label || id, primary: true }) || '';
const state = row.busStopped ? `${org} is stopped` : `${org} isn't running`;
// Why it is down, from the read the dashboard row uses (MosaicConsole.orgDownReason).
const label = window.MosaicOrg.label || id, whyText = v => !v ? '' : v.plain && v.plain !== `${label} did not start.` ? txt(v.plain) : `Why it stopped: ${txt(v.detail)}`;
const why = window.MosaicConsole?.orgDownReason?.(id, label, v => { const p = document.querySelector(`[data-org-down="${CSS.escape(id)}"] [data-org-down-why]`); if (p) { p.innerHTML = whyText(v); p.hidden = !p.innerHTML; } }) ?? null;
return settingsShell(page, `<section class="panel org-down" data-org-down="${txt(id)}"><div class="banner err" role="alert"><p><b>${state}, so ${txt(name)} can't be read.</b> Start it again to see and change this page. Nothing was written.</p><p data-org-down-why${why ? '' : ' hidden'}>${whyText(why)}</p>${restart ? `<p>${restart}</p>` : '<p class="small">Ask the instance owner to restart it.</p>'}</div><p class="small">This instance's own pages still work: <a href="#/settings/appearance">Appearance</a>, <a href="#/settings/model-proxy">Model setup</a>${triageOwner ? ', <a href="#/settings/triage">Triage</a>' : ''} and <a href="#/settings/console">Console</a>.</p></section>`);
}
return settingsShell(page, `<div class="banner ${refusal(err) ? 'ref' : 'err'}" role="alert"><p><b>${txt(failTitle(err))}.</b> ${refusal(err) ? `<code>${txt(err.code)}</code>. ` : ''}${why(err, err.code === 'queue-refused')} ${NO_GUESS}</p>${retry}</div>`);
}
const staleBanner = err => `<div class="banner err s1-stale" role="alert"><p><b>The last read failed.</b> ${why(err)} This is what was read before, ${when(readAt)}. Nothing was changed.</p>${retry}</div>`;
// Freshness line in the command bar for bus pages.
const stamp = iso => { const t = Date.parse(iso); return Number.isFinite(t) ? `${new Date(t).toISOString().slice(11, 19)} UTC` : 'unknown'; };
@@ -1910,13 +1976,14 @@
return;
}
if (path === '/settings/model-proxy' && shown === route && !navigated) return;
if (path === '/settings/triage' && shown === route && !navigated) return;
if (path === '/settings/organizations' && shown?.split('?')[0] === path && !navigated) return;
if (($('agent-dialog')?.open || document.querySelector('.agent-more[aria-expanded=true]')) && !navigated) { schedule(); return; }
if (navigated || (shown !== route && !samePage)) { unmountEditor(); $('bus-view').innerHTML = loadingView(SOURCES[path.split('/')[1]]); }
let html, state = 'fresh';
const live = reader(true);
try {
if (path !== '/organization' && !wsPage(path) && !(path === '/agents' && window.MosaicOrg) && path !== '/messages' && !['/settings','/settings/appearance','/settings/model-proxy','/settings/organizations'].includes(path)) {
if (path !== '/organization' && !wsPage(path) && !(path === '/agents' && window.MosaicOrg) && path !== '/messages' && !['/settings','/settings/appearance','/settings/model-proxy','/settings/triage','/settings/organizations'].includes(path)) {
try { await live('messages'); }
catch (err) { messageCount = null; if (err.status === 403 || err.code === 'signed-out') throw err; }
}
@@ -1925,7 +1992,7 @@
if (err.code === 'signed-out') return;
const kept = reader(false);
try { if (refusal(err)) throw err; html = await view(kept, path, new URLSearchParams(query), opts, current); readAt = kept.oldest(); html = staleBanner(err) + html; state = 'stale'; }
catch { html = failedView(err, path) + (path === '/settings' ? appearance() : ''); state = refusal(err) ? 'refused' : 'failed'; }
catch { if (window.MosaicOrg && path.startsWith('/settings/')) { await window.MosaicConsole?.ready; html = settingsFailed(err, path); } else html = failedView(err, path) + (path === '/settings' ? appearance() : ''); state = refusal(err) ? 'refused' : 'failed'; }
if (refusal(err)) forget();
}
if (!current()) return;
@@ -1941,6 +2008,7 @@
syncAppearance(true);
if (path.startsWith('/docs/')) paintDoc();
if (path === '/organization') window.MosaicConsole?.attachBus(document.querySelector('[data-dashboard-bus]'));
if ($('bus-view').querySelector('[data-org-down]')) { const down = $('bus-down'); if (down) down.hidden = true; }
if (path === '/settings/model-proxy') proxyCleanup=window.MosaicProxy.mount();
if (path === '/settings/organizations') orgCleanup=window.MosaicOrgCreate.mount();
sections(path);
@@ -2113,6 +2181,8 @@
canMessage = !isTester && c?.send === true;
chatSend = !isTester && c?.chatSend === true;
orgSetup = !isTester && c?.orgSetup === true;
// #1873 triage-settings: /api/config says proxyAdmin to the instance owner only, the same owner /api/triage/route serves.
triageOwner = !isTester && c?.proxyAdmin === true;
window.MosaicOrgBusStopped = !!window.MosaicOrg && c?.devOwner === true && orgSetup && c?.chatSend === false;
// The header menu offers "New organization" to the owner of a Console with organizations; nobody else can create one.
if (orgSetup && !$('org-new-link')) { const a = document.createElement('a'); a.id = 'org-new-link'; a.href = NEW_ORG; a.setAttribute('role', 'menuitem'); a.textContent = 'New organization'; document.querySelector('#avatar-menu > a[href="#/settings"]')?.after(a); }
@@ -2159,6 +2229,7 @@
instanceView = null; instanceDrafts = { add: null, change: null }; instanceReceipt = ''; instanceReceiptOp = null; instanceReceipts = Object.create(null);
routesView = null; routesDraft = null; routesReceipt = ''; routesEditVersion++;
harnessSettings = null; harnessDraft = null; harnessReceipt = '';
serviceState = null; serviceLoading = false;
// A file draft is keyed by project and path only; the page reload that used to drop it is gone.
docKey = null; docStates.clear(); pkAll = []; pkShown = []; pkAt = 0;
configRead = switchRead = fetch('/api/config', { cache: 'no-store', redirect: 'manual' }).then(r => { if (r.type === 'opaqueredirect') { signOut(); return null; } return r.json(); }).then(c => applyConfig(c, { quiet: true })).catch(() => {});
@@ -2246,5 +2317,9 @@
window.addEventListener('hashchange', e => render(!agentOnly(e.oldURL, e.newURL)));
$('refresh').addEventListener('click', () => render(false));
$('pause').addEventListener('click', () => setTimeout(schedule)); // after app.js flips aria-pressed
render(false).then(() => { if (!$('bus-view').hidden) { const h1 = $('bus-view').querySelector('h1'); if (h1 && location.hash.startsWith('#/')) h1.focus(); } });
// #1873 triage-followups: the first render ends by focusing the page's heading. A drawer or dialog the
// reader opened before then keeps its focus: the Triage drawer, an agent drawer, the narrow-screen
// menu or any open dialog.
const holdsFocus = () => { const a = document.activeElement; return !!a && (!!a.closest('.ws-drawer:not([hidden]), [data-ws-drawer], dialog[open], [role="dialog"], [role="alertdialog"]') || (drawerOpen && nav.contains(a))); };
render(false).then(() => { if (!$('bus-view').hidden && !holdsFocus()) { const h1 = $('bus-view').querySelector('h1'); if (h1 && location.hash.startsWith('#/')) h1.focus(); } });
})();
+99 -1
View File
@@ -175,6 +175,8 @@
}
} catch (error) {
busReceipt = error instanceof SyntaxError || error?.name === 'TypeError' ? 'Outcome unknown. Check the bus with mosaic bus status before retrying.' : error.message;
// #1873 D7: the refusal follows the organization onto its Settings pages.
if (!(error instanceof SyntaxError || error?.name === 'TypeError')) orgReceipts.set(id, { ok: false, ...refusalLine(window.MosaicOrg?.label || id, error.message) });
} finally { busBusy = false; paintBus(); }
});
@@ -196,5 +198,101 @@
} finally { busBusy = false; paintBus(); }
}
window.MosaicConsole = Object.freeze({ ready, settingsMarkup, busButton, attachBus, get busRestart() { return busAllowed(); }, get config() { return config; } });
// #1873 settings slice 1 (D2, D3, D7): a Restart button for one named organization, for pages that
// list organizations by id (Routing, Model setup, a stopped organization's Settings). Each
// organization keeps its own receipt, so a refusal stays on screen across repaints until the next
// press. It calls the same POST /api/orgs/<id>/restart/bus as the header's Restart bus.
const orgReceipts = new Map(), orgBusy = new Set();
const orgAllowed = () => config?.orgSetup === true && config?.tester !== true && config?.user !== true;
// The refusal the bus host wrote, with one plain line in front when its code is known.
function refusalLine(name, message) {
const text = String(message || 'The restart was refused. Nothing was retried.');
if (/\bfixture-proxy-configured\b/.test(text)) return { plain: `${name} runs on test models, which can't share this machine with your model service. It did not start.`, detail: text };
return { plain: `${name} did not start.`, detail: text };
}
// #1873 review P1-1, P2-2: the cause a running bus gives for a catalogue it cannot read
// (runtime.mjs pickProxy), as one plain line. `restart` says whether a restart can fix it: the
// lock and the organization binding load again at a fresh start; with the dev fixture or a key
// or settings file that does not load, the start is refused too or reads the same file. `fix`
// names the page that fixes it. The bus's own words stay in `detail`; an unknown cause has no
// plain line, so the page shows the bus's words.
function catalogueCause(name, notices, reason) {
// Two different models that slug to one key: the catalogue names it in `reason`, with no notice.
if (reason === 'model-key-collision') return { code: reason, plain: `Two of your models get the same short name, so ${name} can't tell them apart. A restart won't change that.`, restart: false, fix: 'service', detail: reason };
const list = (Array.isArray(notices) ? notices : []).filter(n => typeof n === 'string' && n);
if (!list.length) return null;
const detail = list.join(' '), code = /\(([a-z][a-z-]*)\)/.exec(detail)?.[1] ?? (/has not been set up/.test(detail) ? 'proxy-not-set-up' : null);
const known = {
// No existing endpoint removes the fixture provider, so the line names no step to take here.
'fixture-proxy-configured': [`${name} runs on test models, which can't share this machine with your model service. This can't be changed from Console yet.`, false, null],
'proxy-lock-invalid': [`${name} can't open the model service's shared lock. A restart opens it again.`, true, null],
'invalid-host-request': [`${name} isn't linked to this instance's model service. A restart links it again.`, true, null],
'proxy-management-key-invalid': [`${name} can't load the model service's key, so it can't reach the model service.`, false, 'service'],
'proxy-down': [`${name} couldn't check the model service just now. Check again in a moment.`, false, null],
'proxy-not-set-up': ['Your model service isn\'t set up yet.', false, 'service'],
}[code] ?? (/^proxy-/.test(code ?? '') ? [`${name} can't load the model service's settings.`, false, 'service'] : null);
return known ? { code, plain: known[0], restart: known[1], fix: known[2], detail } : { code, plain: null, restart: false, fix: null, detail };
}
function orgRestartButton(id, { name = id, label = `Restart ${name}`, primary = false } = {}) {
if (!orgAllowed() || typeof id !== 'string' || !id) return '';
const busy = orgBusy.has(id), r = orgReceipts.get(id);
const receipt = !r ? '' : r.ok ? esc(r.text) : `<strong>${esc(r.plain)}</strong> <span class="small muted" data-org-restart-detail>${esc(r.detail)}</span>`;
return `<span class="org-restart" data-org-restart-box="${esc(id)}"><button type="button" class="btn${primary ? ' primary' : ''}" data-org-restart="${esc(id)}" data-org-name="${esc(name)}" data-label="${esc(label)}"${primary ? ' data-primary' : ''}${busy ? ' disabled' : ''}>${esc(busy ? 'Restarting…' : label)}</button> <span role="status" data-org-restart-receipt class="${r && !r.ok ? 'org-restart-refused' : ''}">${receipt}</span></span>`;
}
const paintOrg = id => document.querySelectorAll(`[data-org-restart-box="${CSS.escape(id)}"]`).forEach(el => {
const b = el.querySelector('[data-org-restart]');
el.outerHTML = orgRestartButton(id, { name: b?.dataset.orgName || id, label: b?.dataset.label, primary: b?.hasAttribute('data-primary') });
});
async function restartOrg(id, name) {
if (orgBusy.has(id) || !orgAllowed()) return null;
orgBusy.add(id); orgReceipts.delete(id); paintOrg(id);
let result;
try {
const response = await nativeFetch(`/api/orgs/${encodeURIComponent(id)}/restart/bus`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}', cache: 'no-store', redirect: 'manual' });
if (response.type === 'opaqueredirect') throw new Error('Sign in again, then retry.');
const body = await response.json();
if (!response.ok || body.outcome !== 'done' || body.step !== 'bus-restart') throw new Error(body.message || 'The restart was refused. Nothing was retried.');
result = { ok: true, healthy: body.healthy === true, text: `${name} ${body.restarted ? 'restarted' : 'started'} at ${clock()}. ${body.healthy ? 'It answers.' : `It has not answered yet. Check it with mosaic bus status ${id}.`}` };
} catch (error) {
result = error instanceof SyntaxError || error?.name === 'TypeError'
? { ok: false, plain: 'Outcome unknown.', detail: `Check it with mosaic bus status ${id} before you press Restart again.` }
: { ok: false, ...refusalLine(name, error.message) };
}
orgBusy.delete(id); orgReceipts.set(id, result); paintOrg(id);
if (id === window.MosaicOrg?.id) { busReceipt = result.ok ? result.text : `${result.plain} ${result.detail}`; paintBus(); }
await Promise.resolve(window.MosaicOrg?.refreshList?.()).catch(() => {});
document.dispatchEvent(new CustomEvent('mosaic-org-restarted', { detail: { id, ok: result.ok, healthy: result.healthy === true } }));
return result;
}
document.addEventListener('click', e => {
const button = e.target.closest?.('[data-org-restart]');
if (!button || button.disabled) return;
restartOrg(button.dataset.orgRestart, button.dataset.orgName || button.dataset.orgRestart);
});
// #1873 review 2 P2-D: why a stopped organization is down. GET /api/workspace carries each
// organization's state and, for a refused start, "the bus refused to start: <message>"
// (workspace-read.mjs). It is the reason the dashboard row shows. One read per organization at a
// time, kept for 15 seconds; until it lands this returns what was read before, or null. A reason
// that only restates "not running" is not a reason.
const downReasons = new Map();
function orgDownReason(id, name = id, onRead = null) {
if (typeof id !== 'string' || !id) return null;
const got = downReasons.get(id);
if (got && (got.pending || Date.now() - got.at < 15000)) return got.value ?? null;
downReasons.set(id, { at: got?.at ?? 0, value: got?.value ?? null, pending: true });
nativeFetch(`/api/workspace?${new URLSearchParams({ org: id, sections: 'tasks' })}`, { cache: 'no-store', redirect: 'manual' })
.then(r => (r.ok ? r.json() : null))
.then(body => {
const row = (Array.isArray(body?.orgs) ? body.orgs : []).find(o => o?.org === id);
const reason = row && row.state !== 'ok' && typeof row.reason === 'string' ? row.reason.trim() : '';
if (!reason || /^the bus is not (running|answering)\.?$/i.test(reason)) return null;
const refused = /^the bus refused to start: ([\s\S]+)$/.exec(reason);
return refused ? refusalLine(name, refused[1]) : { plain: null, detail: reason };
})
.catch(() => null)
.then(value => { downReasons.set(id, { at: Date.now(), value, pending: false }); onRead?.(value); });
return got?.value ?? null;
}
window.MosaicConsole = Object.freeze({ ready, settingsMarkup, busButton, attachBus, orgRestartButton, restartOrg, catalogueCause, orgDownReason, orgRefusal: id => orgReceipts.get(id) ?? null, get busRestart() { return busAllowed(); }, get config() { return config; } });
})();
+316 -63
View File
@@ -13,7 +13,15 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
const clean = (value, max = 8000) => (typeof value === 'string' ? value : value === null || value === undefined ? '' : String(value)).replace(/\r\n?/g, '\n').replace(HIDDEN, '').slice(0, max);
const when = value => window.MosaicLocalTime(clean(value, 64));
const el = (tag, cls, text) => { const n = document.createElement(tag); if (cls) n.className = cls; if (text !== undefined) n.textContent = clean(text); return n; };
const NO_ROUTE = 'No model route is set for Triage, so Triage will not start. The instance owner sets the route first.';
const NO_ROUTE = 'Triage has no model chosen yet, so it will not start.';
// #1873 settings slice 1 (section 5): a fix link goes only to a Settings page that exists for this viewer.
// Settings > Triage exists only where /api/config says proxyAdmin (bus.js triageOwner); Model setup always does.
const TRIAGE_FIX = { href: '#/settings/triage', label: 'Open Triage settings' };
const SERVICE_FIX = { href: '#/settings/model-proxy', label: 'Open Model setup' };
const pageExists = fix => fix !== TRIAGE_FIX || config?.proxyAdmin === true;
const fixLink = fix => { const a = el('a', 'triage-fix', fix.label); a.href = fix.href; a.addEventListener('click', () => close()); return a; };
// An organization's name from the Console's own list, or its id when the list does not hold it.
const orgName = id => { const name = window.MosaicOrg?.row?.(id)?.label; return typeof name === 'string' && name ? clean(name, 200) : clean(id) || 'unnamed'; };
let config = null, entry = null, drawer = null, parts = null, timer = null, gen = 0, sending = false, lastTranscript = '', lastHealth = '', shown = [];
const read = () => systemFetch('/api/config', { cache: 'no-store', redirect: 'manual' }).then(r => (r.ok ? r.json() : null)).catch(() => null);
@@ -43,6 +51,8 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
x.addEventListener('click', close);
hd.append(title, x);
const state = el('p', 'triage-state'); state.id = 'triage-state'; state.setAttribute('role', 'status');
const stateFix = el('p', 'triage-state-fix'); stateFix.id = 'triage-state-fix'; stateFix.hidden = true;
const usage = el('p', 'note triage-usage'); usage.id = 'triage-usage'; usage.hidden = true;
const healthSec = el('details', 'triage-health-sec'); healthSec.open = true;
const healthSum = el('summary', '', 'Health');
const health = el('ul', 'triage-health'); health.id = 'triage-health';
@@ -51,10 +61,10 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
const transcript = el('ol', 'triage-transcript'); transcript.id = 'triage-transcript'; transcript.tabIndex = 0;
transcript.setAttribute('aria-label', 'Triage conversation');
const compose = el('div', 'triage-compose');
drawer.append(hd, state, healthSec, convo, transcript, compose);
drawer.append(hd, state, stateFix, usage, healthSec, convo, transcript, compose);
drawer.addEventListener('keydown', e => { if (e.key === 'Escape') { e.preventDefault(); close(); } });
document.body.append(drawer);
parts = { title, state, health, transcript, compose, box: null, send: null, status: null, off: null };
parts = { title, state, stateFix, usage, health, transcript, compose, box: null, send: null, status: null, off: null };
}
// The message box is built once and never rewritten or removed by a read, so a draft survives every
@@ -89,16 +99,17 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
if (!canSend) { parts.off.textContent = READ_ONLY; parts.box.disabled = parts.send.disabled = true; return; }
// A route that is not set, or a session over its cap, turns the box off and says why.
const until = typeof view.overCapUntil === 'string' && view.overCapUntil ? view.overCapUntil : null;
const reason = view.route !== 'set' ? 'Sending is off: no model route is set for Triage.'
: until ? `Sending is off: Triage is over its daily token cap until ${when(until)}.` : '';
const reason = view.route !== 'set' ? 'Sending is off: Triage has no model chosen yet.'
: until ? `Sending is off: Triage used its daily token limit. It takes messages again at ${when(until)}.` : '';
parts.off.textContent = reason;
parts.box.disabled = !!reason;
parts.send.disabled = !!reason || sending;
}
const stateLine = view => {
if (view.route !== 'set') return clean(view.routeMessage) || NO_ROUTE;
if (view.overCapUntil) return clean(view.capMessage) ? `${clean(view.capMessage)} Local time: ${when(view.overCapUntil)}.` : `Triage is over its daily token cap. It takes messages again at ${when(view.overCapUntil)}.`;
// The page's own plain line (section 5), with the fix link under it; the read's routeMessage is the older wording.
if (view.route !== 'set') return NO_ROUTE;
if (view.overCapUntil) return `Triage used its daily token limit. It takes messages again at ${when(view.overCapUntil)}.`;
if (view.running === true) return 'Running.';
const x = view.lastExit;
if (x && typeof x === 'object') {
@@ -109,12 +120,32 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
};
const notRead = v => v === 'not read' || v === null || v === undefined || typeof v !== 'object';
// #1873 triage-cap: one line, today's count against the stored cap and the next reset. Only what the
// read holds: a field the read says is not set or not read is said so, never filled in.
const usageLine = view => {
if (!Object.hasOwn(view, 'usageToday')) return '';
const u = view.usageToday, c = view.cap;
if (u === 'not set' || c === 'not set') return 'Daily token limit: not set.';
if (notRead(u) || notRead(c)) return "Today's token usage: not read.";
const n = v => (Number.isSafeInteger(v) ? v.toLocaleString() : 'not read');
const reset = typeof view.resetsAt === 'string' && Number.isFinite(Date.parse(view.resetsAt)) ? ` Resets at ${when(view.resetsAt)}.` : '';
const k = Number.isSafeInteger(u.unknownTurns) && u.unknownTurns > 0 ? u.unknownTurns : 0;
const unknown = k ? ` ${k} ${k === 1 ? 'turn has' : 'turns have'} no usage reading.` : '';
return `Today: ${n(u.count)} of ${n(c.limit)} tokens.${reset}${unknown}`;
};
const configWords = c => (notRead(c) ? 'not read' : c.valid === true ? 'valid' : `not valid${c.code ? ` (${clean(c.code)})` : ''}`);
let healthSnapshot = null;
function paintHealth() {
if (!parts) return;
const lines = healthLines(healthSnapshot);
const healthKey = JSON.stringify(lines);
if (healthKey !== lastHealth) { lastHealth = healthKey; parts.health.replaceChildren(...lines.map(l => el('li', l.endsWith('not read') ? 'not-read' : '', l))); }
}
function healthLines(s) {
if (notRead(s)) return ['Health: not read'];
const lines = [];
lines.push(notRead(s.console) ? 'Console: not read' : `Console: ${clean(s.console.state) || 'not read'}, ${when(s.console.at)}`);
if (notRead(s.proxy)) lines.push('Proxy: not read');
if (notRead(s.proxy)) lines.push('Model service: not read');
else {
const p = s.proxy;
const words = [p.healthy === true ? 'healthy' : p.healthy === false ? 'not healthy' : 'health not read'];
@@ -122,7 +153,7 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
if (p.installed === false) words.push('not installed');
if (typeof p.active === 'string' && p.active) words.push(`unit ${clean(p.active)}`);
if (p.fence === true) words.push('fence set');
lines.push(`Proxy: ${words.join(', ')}`);
lines.push(`Model service: ${words.join(', ')}`);
}
lines.push(`System config: ${configWords(s.systemConfig)}`);
const orgs = s.organizations;
@@ -130,9 +161,17 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
else if (!orgs.list.length) lines.push('Organizations: none');
else for (const o of orgs.list) {
if (!o || typeof o !== 'object') continue;
const bus = notRead(o.bus) ? 'bus not read' : `bus ${clean(o.bus.state) || 'not read'}${o.bus.lastStart && o.bus.lastStart.ok === false ? `, last start failed ${when(o.bus.lastStart.at)}` : ''}`;
// #1873 settings slice 1 (D7): a refused last start reads as not running, never as running. The
// snapshot carries the time only (lastStart {ok, at}); the reason comes from GET /api/workspace,
// the read the dashboard row uses (MosaicConsole.orgDownReason). Until it is read, or when it
// gives none, the line says where the reason is shown.
const refused = !notRead(o.bus) && o.bus.lastStart && o.bus.lastStart.ok === false;
const why = refused ? window.MosaicConsole?.orgDownReason?.(o.id, orgName(o.id), () => paintHealth()) ?? null : null;
const bus = notRead(o.bus) ? 'bus not read' : refused ? `not running: its last start failed at ${when(o.bus.lastStart.at)} (bus ${clean(o.bus.state) || 'not read'})${why ? '' : '. Restart it on the dashboard to see why'}` : `bus ${clean(o.bus.state) || 'not read'}`;
const proc = notRead(o.processing) ? 'processing not read' : o.processing.invalid === true ? 'processing state not valid' : o.processing.halted === true ? 'processing stopped' : 'processing on';
lines.push(`${clean(o.id) || 'unnamed'}: ${bus}, ${proc}, config ${configWords(o.config)}`);
// A known refusal reads as its plain line; any other shows the bus's words.
const reason = !why ? '' : why.plain && why.plain !== `${orgName(o.id)} did not start.` ? ` ${why.plain}` : ` Why it stopped: ${clean(why.detail).replace(/\.$/, '')}.`;
lines.push(`${orgName(o.id)}: ${bus}, ${proc}, config ${configWords(o.config)}${reason ? `.${reason}` : ''}`);
}
return lines;
}
@@ -173,9 +212,15 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
const t = parts.transcript, atBottom = t.scrollHeight - t.scrollTop - t.clientHeight < 24, top = t.scrollTop;
parts.state.textContent = stateLine(view);
parts.state.dataset.kind = view.route !== 'set' ? 'off' : view.overCapUntil ? 'cap' : view.running === true ? 'running' : 'stopped';
const lines = healthLines(view.snapshot);
const healthKey = JSON.stringify(lines);
if (healthKey !== lastHealth) { lastHealth = healthKey; parts.health.replaceChildren(...lines.map(l => el('li', l.endsWith('not read') ? 'not-read' : '', l))); }
// The fix link exists only while the route is not set and its page exists, so no link sits hidden in the drawer.
const fixable = view.route !== 'set' && pageExists(TRIAGE_FIX);
parts.stateFix.hidden = !fixable;
if (!fixable) parts.stateFix.replaceChildren();
else if (!parts.stateFix.firstChild) parts.stateFix.append(fixLink(TRIAGE_FIX));
const usage = usageLine(view);
parts.usage.textContent = usage;
parts.usage.hidden = !usage;
healthSnapshot = view.snapshot; paintHealth();
// The box first: it sets the conversation's height, which the scroll position below depends on.
composer(view);
const list = Array.isArray(view.transcript) ? view.transcript.filter(m => m && typeof m === 'object') : [];
@@ -243,6 +288,18 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
entry.focus();
}
const harnessRefused = h => h
? `Not sent. The model Triage uses doesn't run with ${h}, the program its route says runs it. Choose a model that runs with ${h}, or another program, in Triage settings.`
: 'Not sent. The model Triage uses doesn\'t run with the program its route says runs it. Choose a model and a program that run together in Triage settings.';
// The route read (Settings > Triage's own read) names the harness; any failure keeps the line without it.
async function routeHarness() {
try {
const r = await systemFetch('/api/triage/route', { cache: 'no-store', redirect: 'manual' });
const h = r.ok ? (await r.json())?.route?.harness : null;
return typeof h === 'string' && h ? clean(h, 64) : null;
} catch { return null; }
}
// Plain words for each answer. A refused send keeps the draft; an unknown outcome is never resent.
function answer(status, body) {
const code = body && typeof body.error === 'string' ? body.error : '';
@@ -251,11 +308,22 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
if (code === 'triage-route-invalid' || code === 'triage-start-failed') return { text: `Not delivered: ${code === 'triage-start-failed' ? 'the Triage session did not start' : 'Triage did not start because the model route\'s answer is not usable'}. The message is in the conversation with the Console's note; it was not sent again.` };
// This one can come before or after the message is written.
if (code === 'triage-dir-unsafe') return { text: 'Not delivered: a Triage directory is not safe to use. It was not sent again: check the conversation before you send it again.' };
if (status === 409) return { text: code === 'triage-no-route' ? 'Not sent: no model route is set for Triage. The instance owner sets the route first.' : code === 'triage-route-refused' ? 'Not sent: the model route refused to start Triage.' : 'Not sent: the model route\'s answer is not usable.' };
// #1873 settings slice 1 (section 5): a route refusal reads as what is missing, with the page that fixes it.
// Slice 1 has no way to issue a Triage key, so that line ends at what is missing.
if (status === 409 && code === 'triage-key-missing') return { text: 'Not sent. Triage isn\'t turned on yet: it needs a Triage key, and none is issued on this instance.' };
if (status === 409 && code === 'triage-proxy-down') return { text: 'Not sent. The model service isn\'t running, so Triage can\'t start.', link: SERVICE_FIX };
// The harness is named as its module declares it, from the route read in send(); no list of names lives here.
if (status === 409 && code === 'triage-harness-incompatible') return { text: harnessRefused(null), harnessRefused: true, link: TRIAGE_FIX };
if (status === 409 && code === 'triage-model-not-offered') return { text: 'Not sent. The model Triage uses is no longer offered. Choose another model in Triage settings.', link: TRIAGE_FIX };
if (status === 409 && code === 'triage-catalogue-unavailable') return { text: 'Not sent. The model service can\'t confirm Triage\'s model right now, so Triage can\'t start.', link: SERVICE_FIX };
// Any other route refusal (an unsafe key file, ...) carries its own plain line.
if (status === 409 && /^triage-(key|proxy|model|catalogue|harness)-/.test(code) && typeof body.message === 'string') return { text: `Not sent. ${clean(body.message)}` };
if (status === 409 && code === 'triage-no-route') return { text: 'Not sent. Triage has no model chosen yet.', link: TRIAGE_FIX };
if (status === 409) return { text: code === 'triage-route-refused' ? 'Not sent: the model route refused to start Triage.' : 'Not sent: the model route\'s answer is not usable.' };
if (status === 429) {
if (code === 'triage-over-cap') {
const until = typeof body.until === 'string' ? clean(body.until) : '';
return { text: until ? `Not sent: Triage is over its daily token cap. It takes messages again at ${when(until)} (${until}).` : 'Not sent: Triage is over its daily token cap.' };
return { text: until ? `Not sent: Triage used its daily token limit. It takes messages again at ${when(until)} (${until}).` : 'Not sent: Triage used its daily token limit.', link: TRIAGE_FIX };
}
return { text: 'Not sent: Triage has too many messages waiting. Try again in a moment.' };
}
@@ -276,6 +344,7 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
try {
const r = await systemFetch('/api/triage/message', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ text }), cache: 'no-store', redirect: 'manual' });
result = answer(r.status, await r.json().catch(() => null));
if (result.harnessRefused) { const h = await routeHarness(); if (h) result.text = harnessRefused(h); }
} catch {
result = { unknown: true, text: 'The Console did not answer. The message may or may not have arrived. It was not sent again: check the conversation before you send it again.' };
}
@@ -284,6 +353,7 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
// The status line can grow the composer; a reader at the bottom of the transcript stays there.
const t = parts.transcript, atBottom = t.scrollHeight - t.scrollTop - t.clientHeight < 24;
parts.status.textContent = result.text;
if (result.link && pageExists(result.link)) parts.status.append(' ', fixLink(result.link));
parts.status.dataset.kind = result.sent ? 'ok' : result.unknown ? 'unknown' : 'refused';
// Only a 202 clears the box, and only when the reader has not typed more since.
if (result.sent && parts.box.value === text) parts.box.value = '';
@@ -328,7 +398,7 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
return orgOf(hash) || !seg || system(hash) ? hash : `#/orgs/${seg}${path}`;
};
// /api/workspace reads and writes across organizations (U1, U4b), so it keeps its own path.
const unscoped = /^\/api\/(?:workspace(?:\/|\?|$)|orgs(?:\/|$)|themes(?:\?|$)|org-template(?:\?|$)|org-presets(?:\?|$)|org-admin(?:\?|$)|org-validate(?:\?|$)|agents\/(?:levels|root)(?:\?|$))/;
const unscoped = /^\/api\/(?:workspace(?:\/|\?|$)|orgs(?:\/|$)|themes(?:\?|$)|org-template(?:\?|$)|org-presets(?:\?|$)|org-admin(?:\?|$)|org-validate(?:\?|$)|agents\/(?:levels|root)(?:\?|$)|triage\/route(?:\?|$))/;
window.fetch = (input, init) => {
if (typeof input !== 'string' || !input.startsWith('/api/') || unscoped.test(input)) return nativeFetch(input, init);
const send = () => nativeFetch(current ? `/api/orgs/${current}/${input.slice('/api/'.length)}` : input, init);
@@ -355,7 +425,7 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
const banner = document.getElementById('bus-down');
if (!banner) return;
const org = rowsSeen.find(row => current && row.id === decodeURIComponent(current) && !row.invalid), path = route().split('?')[0];
if (system(location.hash) || (path === '/organization' && org?.busHealthy === false) || (banner.dataset.orgBus && org?.busHealthy !== false)) { banner.hidden = true; delete banner.dataset.orgBus; return; }
if (system(location.hash) || ((path === '/organization' || document.querySelector('#bus-view [data-org-down]')) && org?.busHealthy === false) || (banner.dataset.orgBus && org?.busHealthy !== false)) { banner.hidden = true; delete banner.dataset.orgBus; return; }
if (org?.busHealthy === false) { banner.textContent = 'Bus unavailable'; banner.hidden = false; banner.dataset.orgBus = '1'; window.MosaicConsole?.attachBus(banner, 'Restart the bus'); }
};
// Idempotent: each read replaces the banner, and removes it on recovery.
@@ -461,6 +531,9 @@ window.MosaicLocalTime = value => Number.isFinite(Date.parse(value)) ? new Date(
// The open organization's name as the last list read gave it, for the breadcrumb.
get label() { const id = current ? decodeURIComponent(current) : null, row = id && rowsSeen.find(r => r.id === id); return id ? (typeof row?.label === 'string' && row.label ? row.label : id) : null; },
ready, route, get list() { return list; }, readList, refreshList,
// #1873 settings slice 1: an organization's row as the last list read gave it (name and bus state), or null.
row: id => { const r = rowsSeen.find(x => x.id === id && !x.invalid); return r ? Object.freeze({ id: r.id, label: typeof r.label === 'string' && r.label ? r.label : r.id, busHealthy: r.busHealthy, busStopped: r.busStopped === true }) : null; },
rows: () => rowsSeen.filter(x => !x.invalid).map(r => Object.freeze({ id: r.id, label: typeof r.label === 'string' && r.label ? r.label : r.id, busHealthy: r.busHealthy, busStopped: r.busStopped === true })),
// SP3: whether this address is a system page (no organization's), for the shell's theme scope.
system: () => system(location.hash),
switchTo: next => { const path = route().split('?')[0]; location.hash = `#/orgs/${encodeURIComponent(next)}${path === '/dashboard' || path === '/' ? '/organization' : route()}`; },
@@ -488,13 +561,20 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
(() => {
'use strict';
// #1873: setup from nothing to a working proxy. Shown only to the instance owner (config.proxyAdmin).
const setupMarkup = '<section id="proxy-setup" class="panel" aria-labelledby="proxy-setup-title" hidden><h2 id="proxy-setup-title">Proxy setup</h2>'
+ '<p>Each step is checked on the host. Files are named by label; keys are never shown.</p>'
+ '<dl id="proxy-setup-state" class="proxy-setup-state"></dl>'
// #1873 settings slice 1 (D3, D4): the next step and its one button come first, then the kept list
// of organizations that need a restart and the Ride all box (ride-default). Done steps, the service controls, the fence, the init lock,
// the organization table and the receipts sit under Technical details.
const setupMarkup = '<section id="proxy-setup" class="panel" aria-labelledby="proxy-setup-title" hidden><h2 id="proxy-setup-title">Set up the model service</h2>'
+ '<p>The model service lets your organizations use your own model accounts. Each step is checked on this machine. Keys are never shown.</p>'
+ '<div id="proxy-setup-next" class="proxy-setup-next" role="status" aria-live="polite"></div>'
+ '<p id="proxy-setup-message" role="status" aria-live="polite"></p>'
+ '<p id="proxy-setup-bus"></p>'
+ '<details id="proxy-setup-init-box"><summary>Initialize the proxy</summary><form id="proxy-setup-init"><fieldset data-setup-write disabled><legend>Management key</legend>'
+ '<div id="proxy-setup-restart" class="proxy-setup-restart" hidden><h3 id="proxy-setup-restart-title">Organizations that can\'t see your models</h3>'
+ '<p class="small muted">An organization connects to the model service the next time it reads its models. These still can\'t see your models, or are not running. Each one says why. Where a restart helps, it has a Restart button: the organization stops for a moment and starts again.</p>'
+ '<ul id="proxy-setup-restart-list" class="proxy-setup-restart-list" aria-labelledby="proxy-setup-restart-title"></ul></div>'
+ '<div id="proxy-ride" class="proxy-ride" hidden><h3>Use your models in every organization</h3><p id="proxy-ride-text"></p>'
+ '<button type="button" id="proxy-ride-go" class="btn">Ride all</button><p id="proxy-ride-message" role="status" aria-live="polite"></p>'
+ '<ul id="proxy-ride-skips" class="proxy-ride-list"></ul><ul id="proxy-ride-fixtures" class="proxy-ride-list"></ul></div>'
+ '<details id="proxy-setup-init-box"><summary>Initialize the model service</summary><form id="proxy-setup-init"><fieldset data-setup-write disabled><legend>Management key</legend>'
+ '<label><input type="radio" name="keySource" value="generate" checked> Generate a key on the host (recommended). It is stored where init stores keys and never shown.</label>'
+ '<label id="proxy-setup-paste-choice" hidden><input type="radio" name="keySource" value="paste"> Use my own key</label>'
+ '<p id="proxy-setup-paste-note" class="muted" hidden>Your own key can be pasted only over HTTPS or on this machine (loopback). This page uses the generated key.</p>'
@@ -505,13 +585,15 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
+ '<label>Key rotation grace (minutes) <input name="rotateGraceMinutes" type="number" min="1" max="1440" step="1" inputmode="numeric"></label>'
+ '<label>First output timeout (seconds) <input name="firstOutputSeconds" type="number" min="1" max="3600" step="1" inputmode="numeric"></label>'
+ '</div><button type="submit">Initialize</button></fieldset></form></details>'
+ '<div class="proxy-setup-unit"><h3>Proxy service</h3><p class="muted">Install renders the unit the same way as <code>mosaic proxy unit install</code>.</p>'
+ '<details id="proxy-setup-tech" class="proxy-setup-tech"><summary>Technical details</summary>'
+ '<dl id="proxy-setup-state" class="proxy-setup-state"></dl>'
+ '<div class="proxy-setup-unit"><h3>Service controls</h3><p class="muted">Install renders the unit the same way as <code>mosaic proxy unit install</code>.</p>'
+ '<div class="proxy-setup-buttons"><button type="button" data-unit="install" data-setup-write disabled>Install</button><button type="button" data-unit="start" data-setup-write disabled>Start</button><button type="button" data-unit="restart" data-setup-write disabled>Restart</button><button type="button" data-unit="stop" data-setup-write disabled>Stop</button><button type="button" id="proxy-setup-render">Show unit file</button></div>'
+ '<pre id="proxy-setup-unit-file" hidden></pre></div>'
+ '<div class="proxy-setup-orgs"><h3>Organizations</h3><div class="table-wrap" tabindex="0" role="region" aria-label="Organizations using the proxy"><table><thead><tr><th>Organization</th><th>Proxy</th><th>Catalogue</th><th>Models</th></tr></thead><tbody id="proxy-setup-orgs"></tbody></table></div>'
+ '<div class="proxy-setup-orgs"><h3>Organizations</h3><div class="table-wrap" tabindex="0" role="region" aria-label="Organizations using the model service"><table><thead><tr><th>Organization</th><th>Proxy</th><th>Catalogue</th><th>Models</th></tr></thead><tbody id="proxy-setup-orgs"></tbody></table></div>'
+ '<p id="proxy-setup-own" class="muted"></p></div>'
+ '<div class="proxy-setup-receipts"><h3>Receipts</h3><ol id="proxy-setup-receipts"><li class="muted">No setup actions on this page yet.</li></ol></div></section>\n';
const markup = setupMarkup + '<button id="proxy-refresh" type="button">Refresh</button><p id="proxy-message" role="status" aria-live="polite">Reading accounts…</p>\n<p id="proxy-readonly" class="muted" hidden>This Console is read-only. Sign-in and account changes are unavailable.</p>\n<section class="panel" aria-labelledby="proxy-accounts-title"><h2 id="proxy-accounts-title">Accounts</h2>\n<p>Higher priority is used first. Account names are stable identifiers; credential values are never displayed.</p>\n<div class="table-wrap" tabindex="0" role="region" aria-label="Accounts"><table><thead><tr><th>Account</th><th>Provider</th><th>Status</th><th>Priority</th><th>Models</th></tr></thead><tbody id="proxy-accounts"></tbody></table></div></section>\n<section class="panel" aria-labelledby="proxy-signin-title"><h2 id="proxy-signin-title">Sign in to an account</h2>\n<form id="proxy-login-start"><fieldset data-write disabled><legend>Subscription account</legend><label>Provider <select name="provider"><option value="claude">Claude</option><option value="codex">Codex</option></select></label><button type="submit">Start sign-in</button></fieldset></form>\n<p id="proxy-login-message" role="status" aria-live="polite"></p>\n<p><a id="proxy-authorize" target="_blank" rel="noopener noreferrer" hidden>Open account sign-in in a new tab</a></p>\n<form id="proxy-login-submit"><fieldset data-write disabled><legend>Finish sign-in</legend><p>If the sign-in tab does not return, copy its full address and paste it here.</p><label>Callback address <input name="redirect_url" type="url" autocomplete="off" spellcheck="false" maxlength="8192" required></label><button type="submit">Submit address</button><button id="proxy-login-cancel" type="button">Cancel sign-in</button></fieldset></form></section>\n<section class="panel" aria-labelledby="proxy-apikey-title"><h2 id="proxy-apikey-title">Add an API key</h2>\n<form id="proxy-apikey"><fieldset data-write disabled><legend>z.ai</legend><label>API key <input name="key" type="password" autocomplete="off" spellcheck="false" maxlength="4096" required></label><p>The key is sent once and cleared from this field. It will never be shown again.</p><button type="submit">Add key</button></fieldset><p id="proxy-apikey-message" role="status"></p></form></section>\n<section class="panel" aria-labelledby="proxy-keys-title"><h2 id="proxy-keys-title">Client keys</h2><p>Only key IDs are shown. Hire and fire manage agent keys.</p>\n<div class="table-wrap" tabindex="0" role="region" aria-label="Client keys"><table><thead><tr><th>Key ID</th><th>Managed by</th><th>Agent</th><th>Issued</th><th>State</th></tr></thead><tbody id="proxy-keys"></tbody></table></div></section>\n';
+ '<div class="proxy-setup-receipts"><h3>Receipts</h3><ol id="proxy-setup-receipts"><li class="muted">No setup actions on this page yet.</li></ol></div></details></section>\n';
const markup = setupMarkup + '<button id="proxy-refresh" type="button">Refresh</button><p id="proxy-message" role="status" aria-live="polite">Reading accounts…</p>\n<p id="proxy-readonly" class="muted" hidden>This Console is read-only. Sign-in and account changes are unavailable.</p>\n<section class="panel" aria-labelledby="proxy-accounts-title"><h2 id="proxy-accounts-title">Accounts</h2>\n<p>Higher priority is used first. Account names are stable identifiers; credential values are never displayed.</p>\n<div class="table-wrap" tabindex="0" role="region" aria-label="Accounts"><table><thead><tr><th>Account</th><th>Provider</th><th>Status</th><th>Priority</th><th>Models</th></tr></thead><tbody id="proxy-accounts"></tbody></table></div></section>\n<section class="panel" aria-labelledby="proxy-signin-title"><h2 id="proxy-signin-title">Sign in to an account</h2>\n<form id="proxy-login-start"><fieldset data-write disabled><legend>Subscription account</legend><label>Provider <select name="provider"><option value="claude">Claude</option><option value="codex">Codex</option></select></label><button type="submit">Start sign-in</button></fieldset></form>\n<p id="proxy-login-message" role="status" aria-live="polite"></p>\n<p><a id="proxy-authorize" target="_blank" rel="noopener noreferrer" hidden>Open account sign-in in a new tab</a></p>\n<form id="proxy-login-submit"><fieldset data-write disabled><legend>Finish sign-in</legend><p>If the sign-in tab does not return, copy its full address and paste it here.</p><label>Address from the sign-in tab <input name="redirect_url" type="url" autocomplete="off" spellcheck="false" maxlength="8192" required></label><button type="submit">Submit address</button><button id="proxy-login-cancel" type="button">Cancel sign-in</button></fieldset></form></section>\n<section class="panel" aria-labelledby="proxy-apikey-title"><h2 id="proxy-apikey-title">Add an API key</h2>\n<form id="proxy-apikey"><fieldset data-write disabled><legend>z.ai</legend><label>API key <input name="key" type="password" autocomplete="off" spellcheck="false" maxlength="4096" required></label><p>The key is sent once and cleared from this field. It will never be shown again.</p><button type="submit">Add key</button></fieldset><p id="proxy-apikey-message" role="status"></p></form></section>\n<section class="panel" aria-labelledby="proxy-keys-title"><h2 id="proxy-keys-title">Client keys</h2><p>Only key IDs are shown. Hire and fire manage agent keys.</p>\n<div class="table-wrap" tabindex="0" role="region" aria-label="Client keys"><table><thead><tr><th>Key ID</th><th>Managed by</th><th>Agent</th><th>Issued</th><th>State</th></tr></thead><tbody id="proxy-keys"></tbody></table></div></section>\n';
function mount() {
const $ = id => document.getElementById(id);
let canWrite = false, login = null, poll = null;
@@ -528,8 +610,8 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
const value = await response.json();
if (!response.ok) {
if (response.status === 401) throw new Error('Sign in to the Console again.');
if (value.error === 'not-configured') throw new Error('The model proxy is not configured for this instance.');
if (value.error === 'proxy-down') throw Object.assign(new Error('The model proxy is not answering.'), { code: 'proxy-down' });
if (value.error === 'not-configured') throw new Error(typeof value.reason === 'string' && value.reason ? value.reason : 'The model service is not set up on this instance.');
if (value.error === 'proxy-down') throw Object.assign(new Error('The model service is not answering.'), { code: 'proxy-down' });
if (value.error === 'login-state-unknown') throw new Error('This sign-in has ended. Start a new sign-in.');
if (value.error === 'apikey-invalid') throw new Error('Enter a nonempty API key, with no spaces or line breaks.');
throw new Error('The operation could not be confirmed. Nothing was retried. Refresh before trying again.');
@@ -549,12 +631,15 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
if (active !== login) return;
if (result.status === 'wait') { message('Waiting for account sign-in…', true); poll = setTimeout(status, 2000); return; }
endLogin();
if (result.status === 'ok') { message('Account signed in.', true); await refresh(); }
else message(result.reason === 'login-timeout' ? 'Sign-in timed out. Start again.' : 'Account sign-in failed. Start again.', true);
// #1873 settings slice 1 (D1): a sign-in can be the step that finishes setup, so the page
// reads the whole setup status again, not only the accounts.
if (result.status === 'ok') { message('Account signed in.', true); await refresh(); await setup.reread(); }
else message(result.reason === 'login-timeout' ? 'Sign-in took too long. Try again.' : 'Account sign-in failed. Try again.', true);
} catch (error) { if (active === login) { endLogin(); message(error.message, true); } }
}
async function refresh() {
const [accounts, keys] = await Promise.all([call('accounts'), call('keys')]);
setup.accounts(Array.isArray(accounts?.accounts) ? accounts.accounts.length : null);
const rows = accounts.accounts.map(account => {
const row = document.createElement('tr');
row.append(cell(account.displayName), cell(account.provider), cell(account.status));
@@ -627,7 +712,7 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
event.preventDefault(); const form=event.currentTarget;if (!canWrite || busy.has('apikey')) return;
const input = event.currentTarget.elements.key, key = input.value; input.value = '';
busy.add('apikey');receipt('proxy-apikey-message','','');formBusy(form,true);
try { await call('apikey/add', { provider: 'z.ai', key }); message('API key added.');receipt('proxy-apikey-message','API key added.','success');await refresh(); }
try { await call('apikey/add', { provider: 'z.ai', key }); message('API key added.');receipt('proxy-apikey-message','API key added.','success');await refresh();await setup.reread(); }
catch (error) { message(error.message);receipt('proxy-apikey-message',error.message,'error'); }
finally { busy.delete('apikey');formBusy(form,false); }
});
@@ -637,10 +722,15 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
const setup = (() => {
const box = $('proxy-setup'), form = $('proxy-setup-init');
let state = null, timer = null, enabled = false, sendOk = false, seenFetch = null, loading = false;
// #1873 settings slice 1 (D1): the steps after "accounts" come from what this page reads itself:
// the account count (refresh), the organizations in the status, and the Triage route.
let accountCount = null, triageSet = null;
const listed = new Set();
const esc = v => String(v).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
const pasteAllowed = location.protocol === 'https:' || ['localhost', '[::1]'].includes(location.hostname) || /^127\./.test(location.hostname);
const STEPS = { start: 'Starting', 'download-archive': 'Downloading the release archive', 'verify-archive': 'Checking the archive hash', 'download-panel': 'Downloading the panel', 'verify-panel': 'Checking the panel hash', 'extract-binary': 'Extracting the executable', 'verify-binary': 'Checking the executable hash', install: 'Installing', done: 'Done' };
const REASONS = {
'human-required': 'Only the instance owner can set up the proxy.',
'human-required': 'Only the instance owner can set up the model service.',
'read-only': 'This Console is read-only.',
'proxy-admin-busy': 'Another setup action is running. Wait for it to finish.',
'proxy-key-transport': 'A pasted key travels only over HTTPS or loopback. Use the generated key.',
@@ -649,20 +739,20 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
'proxy-config-invalid': 'The port must be 1024 to 65535 and not 8317.',
'proxy-rotate-grace-invalid': 'Key rotation grace must be 1 to 1440 minutes.',
'proxy-first-output-invalid': 'First output timeout must be 1 to 3600 seconds.',
'proxy-already-initialized': 'The proxy is already initialized. Init never overwrites it.',
'proxy-already-initialized': 'The model service is already initialized. Init never overwrites it.',
'proxy-port-in-use': 'That port is in use. Choose another or leave it empty.',
'proxy-init-busy': 'An init lock is held. See Init lock above.',
'proxy-install-missing': 'The pinned release is not fetched yet.',
'proxy-install-invalid': 'The fetched release failed its hash check. Fetch again.',
'proxy-restart-required': 'Restart the proxy from this page first.',
'proxy-restart-required': 'Restart the model service from this page first.',
'proxy-restart-unconfirmed': 'The restart could not be confirmed on the host. Restart again.',
'proxy-init-lock-held': 'The init lock cannot be cleared yet.',
'proxy-init-lock-absent': 'There is no init lock.',
'proxy-unit-exists': 'A different proxy unit file is installed. Check it with mosaic proxy unit render.',
'proxy-unit-missing': 'The proxy service is not installed.',
'proxy-unit-unhealthy': 'The proxy service started but does not answer on its port.',
'proxy-unit-missing': 'The model service is not installed.',
'proxy-unit-unhealthy': 'The model service started but does not answer on its port.',
'proxy-unit-failed': 'systemd refused the action.',
'not-configured': 'Proxy setup is not available on this Console.',
'not-configured': 'Model service setup is not available on this Console.',
'outcome-unknown': 'The outcome is unknown. Check the status before retrying.',
};
const explain = code => `${REASONS[code] ?? 'The action was refused.'} (${code})`;
@@ -698,31 +788,118 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
row(dl, 'Initialized', init.initialized ? `Yes, port ${init.settings?.port ?? '—'}` : init.partial ? `Partly (${init.problem ?? 'incomplete'}). Present: ${files}` : init.problem ? `No (${init.problem})` : 'No');
row(dl, 'Service', `${unit.unit}: ${unit.installed ? 'installed' : 'not installed'}, ${unit.active}${unit.pid ? `, pid ${unit.pid}` : ''}${unit.port ? `, port ${unit.port} ${unit.listening ? 'answering' : 'not answering'}` : ''}${unit.error ? ` (${unit.error})` : ''}`);
row(dl, 'Fence', !fence.set ? 'Clear' : fence.invalid ? 'Set (unreadable fence file)' : `Set after ${fence.op ?? 'a key write'}${fence.org ? ` for ${fence.org}` : ''}${fence.time ? ` at ${window.MosaicLocalTime(fence.time)}` : ''}`);
row(dl, 'Init lock', !initLock.present ? 'None' : initLock.clearable ? 'Stale: the bus is stopped and no proxy files exist' : `Held: ${initLock.blockers.join('; ')}`);
row(dl, 'Init lock', !initLock.present ? 'None' : initLock.clearable ? 'Stale: the bus is stopped and no model service files exist' : `Held: ${initLock.blockers.join('; ')}`);
if (state.restart?.confirmed) row(dl, 'Last restart', `Confirmed at ${window.MosaicLocalTime(state.restart.observedAt)}, new pid ${state.restart.pid}`);
}
function paintNext() {
const next = state.next?.[0], box = $('proxy-setup-next');
const steps = {
fetch: ['Fetch the pinned release', `Next: fetch CLIProxyAPI ${state.release.version}. Every file is checked against its pinned SHA-256 before it is installed.`, fetchRelease],
'init-lock-clear': ['Clear the stale init lock', 'Next: an init lock is left from an init that did not finish. The bus is stopped and no proxy files exist, so it can be cleared.', clearLock],
'init-lock-clear': ['Clear the stale init lock', 'Next: an init lock is left from an init that did not finish. The bus is stopped and no model service files exist, so it can be cleared.', clearLock],
'init-lock-wait': ['Check again', `An init lock is held and cannot be cleared: ${state.initLock.blockers.join('; ')}. Stop the bus and remove partial state as the model-proxy README says, then check again.`, load],
'init-repair': ['Check again', 'Setup is partly done. Init never overwrites existing proxy files; resolve them as the model-proxy README says, then check again.', load],
init: ['Initialize the proxy', 'Next: initialize. The bus generates the management key unless you paste your own.', () => { $('proxy-setup-init-box').open = true; form.elements.port.focus(); }],
'unit-install': ['Install the proxy service', `Next: install ${state.unit.unit}.`, () => unitAction('install')],
'unit-start': ['Start the proxy service', `Next: start ${state.unit.unit}.`, () => unitAction('start')],
'unit-restart': ['Restart the proxy service', state.fence.set ? (fence => fence.invalid || !fence.time ? 'A key write had an uncertain outcome, so key writes are fenced. The fence file has no readable time, so a restart from this page cannot be proven against it: restart the proxy service, confirm it answers, then run mosaic proxy fence clear --proxy-restarted.' : 'A key write had an uncertain outcome, so key writes are fenced. Restart the proxy; after this page confirms the new process, clear the fence.')(state.fence) : 'The service is running but does not answer on its port. Restart it.', () => unitAction('restart')],
'fence-clear': ['Clear the fence', 'The proxy was restarted from this page and the new process answers on its port. Clear the fence with that evidence.', clearFence],
accounts: ['Add an account', 'The proxy is running. Sign in to an account or add an API key below.', () => $('proxy-signin-title')?.scrollIntoView({ block: 'start' })],
'init-repair': ['Check again', 'Setup is partly done. Init never overwrites existing model service files; resolve them as the model-proxy README says, then check again.', load],
init: ['Initialize the model service', 'Next: initialize. The bus generates the management key unless you paste your own.', () => { $('proxy-setup-init-box').open = true; form.elements.port.focus(); }],
'unit-install': ['Install the model service', `Next: install ${state.unit.unit}.`, () => unitAction('install')],
'unit-start': ['Start the model service', `Next: start ${state.unit.unit}.`, () => unitAction('start')],
'unit-restart': ['Restart the model service', state.fence.set ? (fence => fence.invalid || !fence.time ? 'A key write had an uncertain outcome, so key writes are fenced. The fence file has no readable time, so a restart from this page cannot be proven against it: restart the model service, confirm it answers, then clear the fence.' : 'A key write had an uncertain outcome, so key writes are fenced. Restart the model service; after this page confirms the new process, clear the fence.')(state.fence) : 'The service is running but does not answer on its port. Restart it.', () => unitAction('restart'),
state.fence.set && (state.fence.invalid || !state.fence.time) ? 'mosaic proxy fence clear --proxy-restarted' : null],
'fence-clear': ['Clear the fence', 'The model service was restarted from this page and the new process answers on its port. Clear the fence with that evidence.', clearFence],
accounts: ['Add an account', state.next?.includes('ride-all') ? 'The model service is running. Sign in to a model account or add an API key below. Then use Ride all below.' : 'The model service is running. Sign in to a model account or add an API key below.', () => $('proxy-signin-title')?.scrollIntoView({ block: 'start' })],
'triage-route': ['Open Triage settings', 'Next: choose the model Triage uses. Triage is the assistant that answers questions about this instance.', () => { location.hash = '#/settings/triage'; }],
'ride-all': ['Ride all', 'Next: let your organizations use your models. See Ride all below.', () => $('proxy-ride')?.scrollIntoView({ block: 'start' })],
};
const [label, text, action] = steps[next] ?? ['Check again', 'Status read.', load];
const step = next === 'accounts' ? afterAccounts() : next;
if (['restart-orgs', 'checking-orgs', 'orgs-blocked', 'done'].includes(step)) {
const names = needRestart().filter(restartHelps).map(o => nameOf(o.id));
const p = document.createElement('p'); p.dataset.next = step;
p.textContent = step === 'done' ? 'The model service is set up and every organization can see your models.'
: step === 'checking-orgs' ? 'Checking why each organization can\'t see your models.'
: step === 'orgs-blocked' ? 'The model service is set up. Some organizations still can\'t see your models. Each one says why under Organizations that can\'t see your models.'
: `Next: restart ${names.length === 1 ? names[0] : `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`}. ${names.length === 1 ? 'It' : 'Each'} has a Restart button under Organizations that can't see your models.`;
box.replaceChildren(p); return;
}
const [label, text, action, command] = steps[step] ?? ['Check again', 'Status read.', load];
const p = document.createElement('p'); p.textContent = text;
const button = document.createElement('button'); button.type = 'button'; button.className = 'btn primary'; button.id = 'proxy-setup-go'; button.dataset.next = next ?? '';
// A step only a terminal can finish keeps its exact command under Technical details.
const cli = command ? Object.assign(document.createElement('details'), { className: 'proxy-setup-cli' }) : null;
if (cli) { const s = document.createElement('summary'), q = document.createElement('p'), c = document.createElement('code'); s.textContent = 'Technical details'; q.className = 'small muted'; q.textContent = 'Run this in a terminal on this machine: '; c.textContent = command; q.append(c); cli.append(s, q); }
const button = document.createElement('button'); button.type = 'button'; button.className = 'btn primary'; button.id = 'proxy-setup-go'; button.dataset.next = step ?? '';
button.textContent = state.busy ? 'Working…' : label;
const write = !['init-lock-wait', 'init-repair', 'accounts', 'init'].includes(next);
const write = !['init-lock-wait', 'init-repair', 'accounts', 'init', 'ride-all', 'triage-route'].includes(step);
button.disabled = Boolean(state.busy) || (write && !sendOk);
button.addEventListener('click', () => { if (!button.disabled) action(); });
box.replaceChildren(p, button);
box.replaceChildren(...(cli ? [p, cli, button] : [p, button]));
}
// #1873 settings slice 1 (D1, D3): steps after "accounts", and the kept restart list.
const nameOf = id => window.MosaicOrg?.row?.(id)?.label || id;
const running = () => state?.next?.[0] === 'accounts';
// An organization that cannot see the models while the service runs. "disabled" is left out: that
// organization does not use the model service, and a restart would not change it.
const needRestart = () => (running() && Array.isArray(state.organizations) ? state.organizations : []).filter(o => ['unavailable', 'bus-unavailable'].includes(o.catalogue?.status));
// #1873 review P1-1: why each listed organization can't see the models, from its own routes
// read (GET /api/orgs/<id>/bus/routes, the read Routing uses). The status read carries only a
// status and a count. A Restart shows only when the bus names no cause or one a fresh start
// clears (MosaicConsole.catalogueCause); with the dev fixture the restart is refused and the
// organization stops. Each status read asks again; the last answer shows meanwhile. Only an
// organization a restart can help holds the next step; one that is not running is listed with
// its Restart and its refusal (D7), and does not hold it.
const causes = new Map(); let causeRound = 0;
function readCause(id) {
const round = causeRound;
causes.set(id, { ...causes.get(id), round });
fetch(`/api/orgs/${encodeURIComponent(id)}/bus/routes`, { cache: 'no-store', redirect: 'manual' })
.then(async r => { const c = r.ok ? (await r.json())?.rows?.[0]?.catalogue : null; if (!c || typeof c !== 'object') throw Error(); return { known: true, ready: c.status === 'ready', cause: window.MosaicConsole?.catalogueCause?.(nameOf(id), c.notices, c.reason) ?? null }; })
.catch(() => ({ known: false }))
.then(got => { if (causes.get(id)?.round !== round) return; causes.set(id, { round, ...got }); if (enabled && state) { paintNext(); paintRestart(); } });
}
const unread = o => o.catalogue?.status === 'unavailable' && !('known' in (causes.get(o.id) ?? {}));
const restartHelps = o => { const c = causes.get(o.id); return o.catalogue?.status === 'unavailable' && c?.known === true && !c.ready && (!c.cause || c.cause.restart); };
const seenReady = o => o.catalogue?.status === 'ready' || causes.get(o.id)?.ready === true;
function afterAccounts() {
if (!accountCount) return 'accounts';
// ride-default: Ride all is next while an organization can ride now. Stand-in organizations alone
// do not hold the step: their Move buttons are optional and Ride all would be disabled.
if (state.next?.includes('ride-all') && Array.isArray(state.ride) && state.ride.some(r => r.state === 'ready')) return 'ride-all';
const waiting = needRestart().filter(o => !seenReady(o));
if (waiting.some(unread)) return 'checking-orgs';
if (waiting.some(restartHelps)) return 'restart-orgs';
if (triageSet === false) return 'triage-route';
return waiting.length ? 'orgs-blocked' : 'done';
}
async function readTriage() {
try { const r = await fetch('/api/triage/route', { cache: 'no-store', redirect: 'manual' }); const v = r.ok ? await r.json() : null; triageSet = v && typeof v === 'object' ? !!v.route : null; }
catch { triageSet = null; }
}
function paintRestart() {
const box = $('proxy-setup-restart'), list = $('proxy-setup-restart-list');
for (const o of needRestart()) listed.add(o.id);
const orgs = Array.isArray(state?.organizations) ? state.organizations.filter(o => listed.has(o.id)) : [];
box.hidden = !running() || !orgs.length;
if (box.hidden) { list.replaceChildren(); return; }
for (const o of orgs) if (o.catalogue?.status === 'unavailable' && causes.get(o.id)?.round !== causeRound) readCause(o.id);
const cfg = window.MosaicConsole?.config;
const noRestart = cfg?.tester === true || cfg?.user === true ? 'Only the instance owner can restart it.' : 'Restart from here needs organization setup on this Console.';
list.innerHTML = orgs.map(o => {
const status = o.catalogue?.status, name = nameOf(o.id), c = causes.get(o.id);
const routing = `<a href="#/orgs/${encodeURIComponent(o.id)}/settings/routing">Open ${esc(name)}'s Routing</a>`;
let badge, word, why, restart = true, fix = '', detail = '';
if (seenReady(o)) [badge, word, why, restart] = ['badge-ok', 'Ready', `${name} can see your models now.`, false];
else if (status === 'bus-unavailable') [badge, word, why] = ['badge-danger', 'Not running', `${name} is not running.`];
else if (status !== 'unavailable') [badge, word, why] = ['badge-muted', 'Unknown', `${name}'s models could not be read.`];
else {
[badge, word] = ['badge-attn', 'Can\'t see models'];
if (!c || !('known' in c)) [why, restart] = [`Checking why ${name} can't see your models.`, false];
else if (!c.known) [why, restart, fix] = [`${name} can't see your models, and its reason could not be read.`, false, routing];
else if (!c.cause) why = `${name} can't read your models from the model service yet. A restart connects it.`;
else {
why = c.cause.plain ?? `${name} says why it can't see your models:`; restart = c.cause.restart;
fix = c.cause.fix === 'routing' ? routing : '';
detail = c.cause.plain ? `<details class="proxy-setup-cause"><summary>Technical details</summary><span class="small muted">${esc(c.cause.detail)}</span></details>` : `<span class="small warn">${esc(c.cause.detail)}</span>`;
}
}
const button = restart ? (window.MosaicConsole?.orgRestartButton?.(o.id, { name }) || `<span class="small muted">${noRestart}</span>`) : '';
return `<li data-restart-org="${esc(o.id)}"${restart ? '' : ' data-no-restart'}><span class="proxy-setup-restart-name"><strong>${esc(name)}</strong> <span class="badge ${badge}">${word}</span></span><span class="small">${esc(why)}${fix ? ` ${fix}` : ''}</span>${detail}${button}</li>`;
}).join('');
}
function paintControls() {
const { release, init, unit, initLock, busy } = state;
@@ -735,12 +912,80 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
if (!Array.isArray(state.organizations)) orgs.replaceChildren(Object.assign(document.createElement('tr'), { innerHTML: '<td colspan="4">Organizations could not be read.</td>' }));
else if (!state.organizations.length) orgs.replaceChildren(Object.assign(document.createElement('tr'), { innerHTML: '<td colspan="4">No organizations.</td>' }));
else orgs.replaceChildren(...state.organizations.map(org => { const tr = document.createElement('tr'); tr.append(cell(org.id), cell(org.proxy === 'shared' ? 'Shared (this instance)' : org.proxy), cell(org.catalogue?.status ?? org.error ?? 'unknown'), cell(Number.isInteger(org.catalogue?.models) ? String(org.catalogue.models) : '—')); return tr; }));
$('proxy-setup-own').textContent = state.ownProxy?.available ? 'An organization can run its own proxy.' : `Own proxy per organization: ${state.ownProxy?.state ?? 'not built'}. ${state.ownProxy?.reason ?? ''}`;
paintRide();
$('proxy-setup-own').textContent = state.ownProxy?.available ? 'An organization can use its own model service.' : 'Use its own model service: coming later. It is planned and not built yet, so an organization can\'t choose it today.';
}
// #1873 ride-default: Ride all and the fixture move. The server decides each organization again;
// this code only words the answer. Every write asks first, in plain words, what changes.
const RIDE_REASONS = {
removed: 'The model proxy was on it, or Ride all may have added it, and it is off now. Ride all leaves it off. Add it on its Settings page to use it.',
'not-recorded': 'The proxy could not record the change first, so it was not made.',
'bus-down': 'Its bus is not running. Start it, then ride again.',
'no-proxy-client': 'Its bus started before the proxy was set up. Restart its bus, then ride again.',
'proxy-check-failed': 'Its bus could not check the proxy. Check the proxy, then ride again.',
unreadable: 'Its organization file, its change log or the proxy\'s receipts could not be read. A damaged line in the proxy\'s receipts must be repaired by hand before Ride all adds again.',
failed: 'Its bus refused the change.',
'bus-running': 'Its bus is running, or its state could not be read. Stop or recover its bus, then move it.',
'no-proxy': 'Set up the model proxy first.',
'no-riding-bus': 'No organization uses the proxy yet, so no model list was read. Ride all first.',
'no-model': 'The proxy lists no model for the harness its agents use.',
invalid: 'The moved organization file did not pass its check. Nothing was written.',
'revision-conflict': 'The organization changed while it was being moved. Try again.',
'org-forbidden': 'Moving organizations is not available on this Console yet. It works on a local development Console.',
unknown: 'It is not an active organization.',
'not-available': 'Moving is not available on this Console.',
fixture: 'It uses stand-in models.',
};
const rideReason = code => RIDE_REASONS[code] ?? `The change was refused (${code}).`;
let rideResult = null;
const li = text => { const el = document.createElement('li'); el.textContent = text; return el; };
function paintRide() {
const box = $('proxy-ride'), ride = Array.isArray(state.ride) ? state.ride : null;
box.hidden = !ride || !state.init?.initialized;
if (box.hidden) return;
const ready = ride.filter(r => r.state === 'ready').length, fixtures = ride.filter(r => r.state === 'fixture');
$('proxy-ride-text').textContent = 'Ride all adds this proxy to each organization that does not use it yet. '
+ 'Admission gets stricter there: every launch route is checked, direct Anthropic routes too, and while the proxy is down or fenced every launch in that organization is refused. '
+ (ready ? `${ready} ${ready === 1 ? 'organization can' : 'organizations can'} ride now.` : 'No organization is waiting to ride.');
const go = $('proxy-ride-go'); go.disabled = !sendOk || Boolean(state.busy) || !ready;
const skips = (rideResult?.skipped ?? ride.filter(r => !['ready', 'already', 'fixture'].includes(r.state)).map(r => ({ id: r.id, reason: r.state })));
$('proxy-ride-skips').replaceChildren(...skips.map(s => li(`Skipped ${s.id}: ${rideReason(s.reason)}`)));
const listed = rideResult?.fixtures ?? fixtures.map(f => ({ id: f.id }));
$('proxy-ride-fixtures').replaceChildren(...listed.map(f => {
const item = li(`${f.id} uses stand-in models, can be moved to the owner's models.${f.running ? ' Its bus is running: stop it first.' : ''} `);
const move = document.createElement('button'); move.type = 'button'; move.className = 'btn'; move.textContent = `Move ${f.id}`;
move.dataset.rideMove = f.id; move.disabled = !sendOk || Boolean(state.busy);
move.addEventListener('click', () => { if (!move.disabled) rideMove(f.id); });
item.append(move); return item;
}));
}
const rideSay = (text, kind) => receipt('proxy-ride-message', text, kind);
const rideAll = () => {
if (!window.confirm('Ride all adds this model proxy to each organization that can take it. Admission gets stricter there: every launch route is checked, direct Anthropic routes too, and while the proxy is down or fenced every launch in that organization is refused. Continue?')) return;
return act('ride-all', async () => {
const result = await admin('ride-all', {}); addReceipt(result.receipt); rideResult = result;
const parts = [`Added to ${result.added.length}`, `already using it ${result.already.length}`, `skipped ${result.skipped.length}`];
if (result.fixtures.length) parts.push(`stand-in models ${result.fixtures.length}`);
rideSay(parts.join(', ') + '.', result.skipped.length ? 'error' : 'success'); say('Ride all finished.', 'success');
});
};
const rideMove = id => {
if (!window.confirm(`Move ${id} to your models? Its stand-in models are replaced by a model your proxy lists. After this, its agents spend real tokens on your account. Its bus stays stopped: start it when you are ready.`)) return;
return act('ride-move', async () => {
const result = await admin('ride-move', { org: id });
if (!result.moved) { rideSay(`${id} was not moved. ${rideReason(result.reason)}`, 'error'); return; }
addReceipt(result.receipt);
if (rideResult) rideResult = { ...rideResult, fixtures: rideResult.fixtures.filter(f => f.id !== id) };
rideSay(`${id} now uses ${result.model}. Start its bus when you are ready. It spends real tokens from now on.`, 'success');
});
};
$('proxy-ride-go').addEventListener('click', () => { if (!$('proxy-ride-go').disabled) rideAll(); });
function paint() {
paintState(); paintNext(); paintControls(); paintReceipts();
paintState(); paintNext(); paintControls(); paintReceipts(); paintRestart();
// An initialized proxy keeps the init form folded after a reload too.
if (state.init.initialized) $('proxy-setup-init-box').open = false;
// #1873 settings slice 1 (D4): the init form shows only while init is the next step.
$('proxy-setup-init-box').hidden = state.next?.[0] !== 'init';
const job = state.fetch;
if (job.state === 'running') say(`Fetching: ${STEPS[job.step] ?? job.step ?? 'starting'}…`);
else if (job.state === 'failed' && seenFetch !== 'failed') { say(`Fetch failed. ${explain(job.error)}`, 'error'); seenFetch = 'failed'; }
@@ -750,21 +995,23 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
}
async function load() {
if (!enabled || loading) return; loading = true;
try { state = await admin('status'); paint(); if (state.init.initialized) await accountsReady(); }
try { state = await admin('status'); causeRound++; if (state.next?.[0] === 'accounts' && triageSet === null) await readTriage(); paint(); if (state.init.initialized) await accountsReady(); }
catch (error) { say(error.message, 'error'); }
finally { loading = false; }
}
async function act(label, action) {
if (!sendOk || state?.busy) return;
state = { ...state, busy: label }; paintNext(); paintControls(); say('Working…');
try { await action(); } catch (error) { say(error.message, 'error'); } finally { if (state) state = { ...state, busy: null }; await load(); }
// A load still waiting on accounts makes the load below return at once, so the answer is
// painted here first from the state already read.
try { await action(); } catch (error) { say(error.message, 'error'); } finally { if (state) { state = { ...state, busy: null }; paint(); } await load(); }
}
const fetchRelease = () => act('fetch', async () => { await admin('fetch', {}); seenFetch = null; say('Fetch started.'); });
const clearLock = () => act('init-lock-clear', async () => { const result = await admin('init-lock/clear', {}); addReceipt(result.receipt); say('Stale init lock cleared.', 'success'); });
const unitAction = op => act(`unit-${op}`, async () => {
const result = await admin(`unit/${op}`, {}); addReceipt(result.receipt);
if (op === 'restart' && result.evidence?.confirmed !== true) say('The service restarted but the new process could not be confirmed. The fence stays set.', 'error');
else say({ install: 'Proxy service installed.', start: 'Proxy service started and answering.', stop: 'Proxy service stopped.', restart: 'Proxy service restarted; the new process answers.' }[op], 'success');
else say({ install: 'Model service installed.', start: 'Model service started and answering.', stop: 'Model service stopped.', restart: 'Model service restarted; the new process answers.' }[op], 'success');
});
const clearFence = () => act('fence-clear', async () => { const result = await admin('fence/clear', {}); addReceipt(result.receipt); say(result.cleared ? 'Fence cleared.' : 'The fence was not set.', 'success'); });
form.elements.keySource.forEach?.(radio => radio.addEventListener('change', () => { $('proxy-setup-paste').hidden = form.elements.keySource.value !== 'paste'; }));
@@ -783,8 +1030,8 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
act('init', async () => {
const result = await admin('init', args); addReceipt(result.receipt);
$('proxy-setup-init-box').open = false;
say(`Initialized on port ${result.settings.port}${args.generate ? ' with a generated key' : ''}. Install and start the service next. Other organizations' buses read the proxy settings when they start: restart a bus before its agents use the proxy.`, 'success');
window.MosaicConsole?.attachBus?.($('proxy-setup-bus'), 'Restart this organization\'s bus');
// #1873 settings slice 1 (D3): which organizations need a restart is a list on this page once the service runs.
say(`Initialized on port ${result.settings.port}${args.generate ? ' with a generated key' : ''}. Install and start the service next.`, 'success');
});
});
$('proxy-setup-render').addEventListener('click', async () => {
@@ -795,6 +1042,9 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
box.querySelectorAll('[data-unit]').forEach(button => button.addEventListener('click', () => { if (!button.disabled) unitAction(button.dataset.unit); }));
return {
start(config) { enabled = true; sendOk = config.proxyAdminSend === true; box.hidden = false; return load(); },
accounts(n) { accountCount = n; if (state) { paintNext(); paintRestart(); } },
// 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(); },
stop() { enabled = false; clearTimeout(timer); timer = null; const f = form.elements; f.key.value = ''; f.confirm.value = ''; },
};
})();
@@ -809,7 +1059,10 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
$('proxy-readonly').hidden = canWrite;
message('Accounts and client keys loaded.');
}
const cleanup = () => { setup.stop(); clearTimeout(poll); login = null; const redirect=$('proxy-login-submit')?.elements.redirect_url, key=$('proxy-apikey')?.elements.key; if(redirect)redirect.value='';if(key)key.value=''; };
// #1873 settings slice 1 (D3): a restart from this page's list reads the status again.
const onRestarted = () => { setup.reread(); };
document.addEventListener('mosaic-org-restarted', onRestarted);
const cleanup = () => { document.removeEventListener('mosaic-org-restarted', onRestarted); setup.stop(); clearTimeout(poll); login = null; const redirect=$('proxy-login-submit')?.elements.redirect_url, key=$('proxy-apikey')?.elements.key; if(redirect)redirect.value='';if(key)key.value=''; };
window.addEventListener('pagehide', cleanup, {once:true});
let devOwner = false, proxyAdmin = false;
fetch('/api/config', { cache: 'no-store' }).then(r => r.json()).then(config => {
@@ -827,15 +1080,15 @@ if (document.documentElement.hasAttribute('data-settings-proxy-document') && !lo
// and the setup load brings them back once the service answers.
// Any failed read hides them, not only proxy-down: a proxy that is initialized but not yet answering
// can fail with another code, and a stale error over an empty table would stay after Start.
if (proxyAdmin && error.message !== 'The model proxy is not configured for this instance.') { accountsShown = false; $('proxy-message').classList.add('empty'); $('proxy-readonly').hidden=true; document.querySelectorAll('.settings-model-proxy .panel:not(#proxy-setup), #proxy-refresh').forEach(el=>el.hidden=true); message(error.code === 'proxy-down' ? 'The model proxy is not running yet. Follow the next step under Proxy setup.' : `Accounts could not be read${error.code ? ` (${error.code})` : ''}. Follow the next step under Proxy setup; the account panels return once the proxy answers.`); return; }
if(error.message==='The model proxy is not configured for this instance.') { accountsShown = false; $('proxy-message').classList.add('empty'); $('proxy-readonly').hidden=true; document.querySelectorAll('.settings-model-proxy .panel:not(#proxy-setup), #proxy-refresh').forEach(el=>el.hidden=true);
if (proxyAdmin && error.message !== 'The model service is not set up on this instance.') { accountsShown = false; $('proxy-message').classList.add('empty'); $('proxy-readonly').hidden=true; document.querySelectorAll('.settings-model-proxy .panel:not(#proxy-setup), #proxy-refresh').forEach(el=>el.hidden=true); message(error.code === 'proxy-down' ? 'The model service is not running yet. Follow the next step under Set up the model service.' : `Accounts could not be read${error.code ? ` (${error.code})` : ''}. Follow the next step under Set up the model service; the account panels return once the service answers.`); return; }
if(error.message==='The model service is not set up on this instance.') { accountsShown = false; $('proxy-message').classList.add('empty'); $('proxy-readonly').hidden=true; document.querySelectorAll('.settings-model-proxy .panel:not(#proxy-setup), #proxy-refresh').forEach(el=>el.hidden=true);
// #1873: the owner sets the proxy up on this page (Proxy setup above); no terminal note.
if (proxyAdmin) { message('The model proxy is not set up yet. Follow the next step under Proxy setup.'); return; }
if (proxyAdmin) { message('The model service is not set up yet. Follow the next step under Set up the model service.'); return; }
// F3: on a dev instance, say plainly why this page cannot set the proxy up and what does.
// Setup takes a management key typed twice at a terminal and writes the proxy's credentials;
// this page never handles that key. Account sign-in (a provider's own OAuth) then runs here.
if (devOwner) { const org = window.MosaicOrg?.id, note = document.createElement('div'); note.id = 'proxy-dev-setup'; note.className = 'panel';
note.innerHTML = '<h2>Set up the model proxy</h2><p>Nothing else on this dev Console asks for a sign-in. The proxy is the exception: its setup asks for a management key, typed twice, and writes the proxy\'s credentials. This page never handles that key, so setup runs once in a terminal on this machine:</p><pre><code></code></pre><p>Then refresh this page. Signing in to a Claude or Codex account is the provider\'s own sign-in, which cannot be skipped. It runs here, under Sign in to an account, with one button.</p>';
note.innerHTML = '<h2>Set up the model service</h2><p>Nothing else on this dev Console asks for a sign-in. The model service is the exception: its setup asks for a management key, typed twice, and writes its credentials. This page never handles that key, so setup runs once in a terminal on this machine:</p><pre><code></code></pre><p>Then refresh this page. Signing in to a Claude or Codex account is the provider\'s own sign-in, which cannot be skipped. It runs here, under Sign in to an account, with one button.</p>';
note.querySelector('code').textContent = `mosaic proxy fetch\nmosaic proxy init${org ? ` --org ${org}` : ''}`;
$('proxy-message').after(note); } } });
return cleanup;
+1 -1
View File
@@ -7,7 +7,7 @@
<link rel="stylesheet" href="/processing.css"><script src="/processing.js" defer></script>
<link rel="stylesheet" href="/org-create.css"><script src="/org-create.js" defer></script>
<link rel="stylesheet" href="/onboarding.css"><script src="/onboarding.js" defer></script><link rel="stylesheet" href="/assistant.css">
<script src="/workspace-data.js" defer></script><script src="/workspace.js" defer></script><script src="/tasks-board.js" defer></script><script src="/console-restart.js" defer></script><script src="/display.js" defer></script><script src="/inbox.js" defer></script><script src="/files.js" defer></script><script src="/project-remote.js" defer></script><link rel="stylesheet" href="/autonomy.css"><script src="/autonomy.js" defer></script><link rel="stylesheet" href="/packs.css"><script src="/packs.js" defer></script><link rel="stylesheet" href="/workflows.css"><script src="/workflows.js" defer></script><script src="/federation.js" defer></script><script src="/brand.js" defer></script><script src="/app.js" defer></script><script src="/markdown-preview.js" defer></script><script src="/projects.js" defer></script><script src="/chat.js" defer></script><script src="/project-archive.js" defer></script><script src="/agents.js" defer></script><script src="/assistant.js" defer></script><script src="/bus.js" defer></script><script src="/requests.js" defer></script></head>
<script src="/workspace-data.js" defer></script><script src="/workspace.js" defer></script><script src="/tasks-board.js" defer></script><script src="/console-restart.js" defer></script><script src="/triage-settings.js" defer></script><script src="/display.js" defer></script><script src="/inbox.js" defer></script><script src="/files.js" defer></script><script src="/project-remote.js" defer></script><link rel="stylesheet" href="/autonomy.css"><script src="/autonomy.js" defer></script><link rel="stylesheet" href="/packs.css"><script src="/packs.js" defer></script><link rel="stylesheet" href="/workflows.css"><script src="/workflows.js" defer></script><script src="/federation.js" defer></script><script src="/brand.js" defer></script><script src="/app.js" defer></script><script src="/markdown-preview.js" defer></script><script src="/projects.js" defer></script><script src="/chat.js" defer></script><script src="/project-archive.js" defer></script><script src="/agents.js" defer></script><script src="/assistant.js" defer></script><script src="/bus.js" defer></script><script src="/requests.js" defer></script></head>
<body>
<div hidden aria-hidden="true"><select id="palette"></select><select id="mode"><option value="system">system</option><option value="light">light</option><option value="dim">dim</option><option value="dark">dark</option></select></div>
<a class="skip" href="#main">Skip to content</a>
+1 -1
View File
@@ -1,4 +1,4 @@
[data-packs],[data-workflows]{margin-top:16px}
[data-packs]{margin-top:16px}
.pack-list,.pack-hires{list-style:none;margin:8px 0;padding:0}
.pack-row,.pack-hire{border-top:1px solid var(--border);padding:12px 0;overflow-wrap:anywhere}
.pack-preview{border:1px solid var(--border);border-radius:var(--r);padding:12px;margin:12px 0;overflow-wrap:anywhere}
+1 -1
View File
@@ -14,7 +14,7 @@
const value = await response.json();
if (!response.ok) {
if (response.status === 401) throw new Error('Sign in to the Console again.');
if (value.error === 'not-configured') throw new Error('The model proxy is not configured for this instance.');
if (value.error === 'not-configured') throw new Error(typeof value.reason === 'string' && value.reason ? value.reason : 'The model service is not set up on this instance.');
if (value.error === 'login-state-unknown') throw new Error('This sign-in has ended. Start a new sign-in.');
if (value.error === 'apikey-invalid') throw new Error('Enter a nonempty API key, with no spaces or line breaks.');
throw new Error('The operation could not be confirmed. Nothing was retried. Refresh before trying again.');
+41
View File
@@ -98,6 +98,17 @@ table.s1-table td code{font-size:12.5px;white-space:nowrap}
.console-reconnect>span{flex:1 1 220px;min-width:0;overflow-wrap:anywhere}
.bus-restart{display:inline-flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0}
.bus-restart [role=status]:empty{display:none}
/* #1873 settings slice 1: a Restart for one named organization (console-restart.js orgRestartButton). */
.org-restart{display:inline-flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0;max-width:100%}
.org-restart [data-org-restart]{min-height:var(--action-target);white-space:normal;text-align:left}
.org-restart [role=status]{min-width:0;overflow-wrap:anywhere}
.org-restart [role=status]:empty{display:none}
.org-restart .org-restart-refused strong,.org-restart-refused strong{color:var(--strong)}
.org-restart [data-org-restart-detail]{display:block}
.routes-catalogue{flex-direction:column;align-items:stretch}
.routes-catalogue>p{flex:none}
.settings-content .org-down .banner p{margin:0 0 8px}
.settings-content .org-down .banner p:last-child{margin-bottom:0}
.routes-apply{margin:12px 0 0;padding-left:18px;display:grid;gap:8px}
.routes-apply li{overflow-wrap:anywhere}
.agent-restart{display:inline-flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0}
@@ -109,6 +120,22 @@ table.s1-table td code{font-size:12.5px;white-space:nowrap}
.proxy-setup-buttons{display:flex;flex-wrap:wrap;gap:8px}.proxy-setup-buttons button{min-height:44px}
#proxy-setup pre{overflow-x:auto;max-width:100%;font-size:12px}#proxy-setup h3{margin:16px 0 4px}#proxy-setup details{margin:0 0 12px}#proxy-setup summary{min-height:44px;display:flex;align-items:center;cursor:pointer}
#proxy-setup-receipts{padding-left:20px;overflow-wrap:anywhere;font-size:13px}
/* #1873 settings slice 1 (D3, D4): the kept restart list and Technical details. */
.proxy-setup-restart{margin:0 0 12px}
.proxy-setup-restart-list{list-style:none;margin:8px 0 0;padding:0;display:grid;gap:8px}
.proxy-setup-restart-list li{display:flex;flex-wrap:wrap;align-items:center;gap:6px 12px;padding:10px 12px;border:1px solid var(--line);border-radius:var(--r);min-width:0}
.proxy-setup-restart-list li>.small{flex:1 1 220px;min-width:0;overflow-wrap:anywhere}
.proxy-setup-restart-name{display:inline-flex;flex-wrap:wrap;align-items:center;gap:6px;min-width:0}
.proxy-setup-restart-list li>details{flex:1 1 100%;min-width:0;overflow-wrap:anywhere}
.routes-cause-detail,.proxy-setup-cause{margin:6px 0 0}
.routes-cause-detail summary,.proxy-setup-cause summary{cursor:pointer}
.settings-content button[type=submit].route-save-quiet{background:var(--surface);color:var(--text);border-color:var(--border)}
.proxy-setup-tech>summary{font-weight:600}
#triage-route-harness-help{display:block;margin-top:4px;max-width:36ch}
#triage-route select{max-width:100%}
.triage-state-fix{margin:0 0 8px}.triage-fix{white-space:normal}
/* #1873 settings slice 1: at phone width a model select takes the whole row, so a long model name is not cut. */
@media(max-width:759px){.routing-panel #routes-table td:nth-of-type(2),.routing-panel #routes-table td:nth-of-type(5){grid-column:1/-1}.routing-panel #routes-table select{width:100%;max-width:100%}}
@media(max-width:479px){.proxy-setup-state{grid-template-columns:1fr}.proxy-setup-state dd{margin-bottom:6px}}
/* Stream S4: which organization this is, in words. Colour (the theme) is never the only cue; the strip appears whenever the theme is not the built-in one. */
.org-cue{margin:0 0 12px;padding:6px 10px;border:1px solid var(--line);border-left:4px solid var(--action);border-radius:var(--r-table);background:var(--raised);color:var(--text);font-size:13px;overflow-wrap:anywhere}.skel-rows{display:grid;gap:10px;padding:14px 12px;border:1px solid var(--line);border-radius:var(--r-table);background:var(--surface)}
@@ -631,6 +658,14 @@ html[data-organizations] .ws-orgcard .at{grid-column:3;grid-row:1;font:500 11.5p
html[data-organizations] .ws-orgcard .why{grid-column:1/-1;font-size:12px;color:var(--muted)}
html[data-organizations] .ws-orgcard.off a{border-style:dashed}
html[data-organizations] .ws-home-split{margin-top:4px}
/* SP18: the Dashboard's columns line up with its tile row. Three equal tracks with the tiles' gap, the left
column spanning two, end on a tile edge whether the row holds six tiles (after the fourth) or three
(after the second). Below 760 px the split is one column. */
html[data-organizations] .ws-home>.ws-tiles{gap:var(--gap)}
@media (min-width:760px){
html[data-organizations] .ws-home-split{grid-template-columns:repeat(3,minmax(0,1fr));gap:var(--gap)}
html[data-organizations] .ws-home-split>:first-child{grid-column:span 2}
}
html[data-organizations] .ws-trail{list-style:none;margin:0;padding:0;border:1px solid var(--line);border-radius:8px;background:var(--surface)}
html[data-organizations] .ws-trail li{display:grid;grid-template-columns:48px 20px minmax(0,1fr);gap:10px;padding:7px 12px;border-bottom:1px solid color-mix(in srgb,var(--line) 60%,transparent);font-size:13px;align-items:center}
html[data-organizations] .ws-trail li:last-child{border-bottom:0}
@@ -770,6 +805,11 @@ html[data-organizations] .ws-drawer-acts .note{flex-basis:100%}
@media (min-width:1200px){html[data-organizations] body:has(.ws-drawer) .content{padding-right:calc(420px + 22px)}}
@media (max-width:700px){
html[data-organizations] .ws-drawer{top:0;left:0;right:0;width:auto;border-left:0;box-shadow:none}
/* SP18: the sheet covers the screen, so the page under it is held to one screen and does not scroll; it
kept its own height before, and the sheet showed over a long blank area. workspace.js puts the page's
place back on Close. */
html[data-organizations]:has(#bus-view .ws-drawer){overflow:hidden}
html[data-organizations]:has(#bus-view .ws-drawer) body{height:100dvh;overflow:hidden}
}
@media (max-width:1100px){
html[data-organizations] .ws-tiles.six{grid-template-columns:repeat(3,minmax(0,1fr))}
@@ -819,6 +859,7 @@ html[data-organizations] .ws-drawer-acts .note{flex-basis:100%}
#triage-drawer h2:focus{outline:none}
#triage-drawer .x{margin-left:auto;flex:none;width:32px;height:32px;border:1px solid var(--line);border-radius:6px;background:var(--canvas);color:var(--strong);font-size:20px;line-height:1;cursor:pointer}
#triage-drawer .triage-state{margin:0;padding:10px 14px;flex:none;font-size:14px;font-weight:600;color:var(--strong);border-bottom:1px solid var(--line);overflow-wrap:anywhere}
#triage-drawer .triage-usage{margin:0;padding:6px 14px;flex:none;font-size:13px;color:var(--muted);border-bottom:1px solid var(--line);overflow-wrap:anywhere}
#triage-drawer .triage-state[data-kind=off],#triage-drawer .triage-state[data-kind=cap]{color:var(--warning);background:color-mix(in srgb,var(--warning) 9%,var(--surface))}
#triage-drawer .triage-state[data-kind=running]::before{content:"";display:inline-block;width:8px;height:8px;margin-right:7px;border-radius:50%;background:var(--success);vertical-align:1px}
#triage-drawer .triage-health-sec{flex:none;padding:8px 14px;border-bottom:1px solid var(--line)}
@@ -0,0 +1,134 @@
/* #1873 triage-settings: Settings > Triage, the instance owner's Triage model route. It reads and
writes /api/triage/route (triage-route-http.mjs); the server checks the owner, the Origin and Fetch
Metadata, the catalogue and the time zone, and the store keeps the revision and the receipt. This
file only asks and reports. bus.js offers the page only when /api/config says proxyAdmin, which is
the same owner the route serves. The fields live here, so a repaint keeps what the owner typed. */
(() => {
'use strict';
const $ = id => document.getElementById(id);
const esc = s => String(s).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
const PATH = '/api/triage/route';
// The time zones this browser knows, offered as suggestions only; the server decides.
const zones = (() => { try { return Intl.supportedValuesOf('timeZone'); } catch { return []; } })();
// 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;
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 ?? '' });
async function read() {
readLine = '';
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 { 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; }
// 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));
data = a;
if (untouched) { draft = fromRoute(a.route); base = Number.isSafeInteger(a.revision) ? a.revision : 0; }
}
const models = () => (Array.isArray(data?.choices?.models) ? data.choices.models : []);
const harnessesOf = key => models().find(m => m.key === key)?.harnesses ?? [];
const savedAt = v => (Number.isFinite(Date.parse(v)) ? window.MosaicLocalTime(v) : 'at an unknown time');
function stored() {
const r = data?.route;
if (!r) return `<p id="triage-route-stored" data-revision="0"><strong>Not set.</strong> Triage has no model chosen yet, so it will not start.</p>`;
return `<p id="triage-route-stored" data-revision="${esc(r.revision)}">Saved route: <strong>${esc(r.model)}</strong>, runs with <strong>${esc(r.harness)}</strong>. Daily token limit ${esc(Number(r.cap).toLocaleString('en-US'))}, resets at ${esc(r.reset)} ${esc(r.timeZone)}. Saved ${esc(savedAt(r.updatedAt))}.</p>`;
}
function form() {
const d = draft ?? fromRoute(null);
const send = data?.send === true;
const off = busy || !send ? ' disabled' : '';
const list = models();
const offered = list.some(m => m.key === d.model);
const modelOptions = `<option value=""${d.model === '' ? ' selected' : ''}>Choose a model</option>`
+ (d.model && !offered ? `<option value="${esc(d.model)}" selected>${esc(d.model)} (not offered now)</option>` : '')
+ list.map(m => `<option value="${esc(m.key)}"${m.key === d.model ? ' selected' : ''}${m.available ? '' : ' disabled'}>${esc(m.label && m.label !== m.key ? `${m.label} (${m.key})` : m.key)}${m.available ? '' : ' (unavailable)'}</option>`).join('');
const hs = harnessesOf(d.model);
const harnessOptions = `<option value=""${d.harness === '' ? ' selected' : ''}>${d.model ? 'Choose what runs it' : 'Choose a model first'}</option>`
+ (d.harness && !hs.includes(d.harness) ? `<option value="${esc(d.harness)}" selected>${esc(d.harness)} (not offered for this model)</option>` : '')
+ hs.map(h => `<option value="${esc(h)}"${h === d.harness ? ' selected' : ''}>${esc(h)}</option>`).join('');
const status = data?.choices?.status;
const catalogue = status === 'ready' ? '' : `<p class="small warn" id="triage-route-catalogue" data-status="${esc(status ?? 'unknown')}">No organization can show your models right now, so no route can be saved. <a href="#/settings/model-proxy">Open Model setup</a> to see why each organization can't see your models.</p>`;
const conflictButton = conflict ? ' <button type="button" class="btn" id="triage-route-reload">Reload route</button>' : '';
return `${catalogue}<form id="triage-route-form" novalidate><div class="filters">`
+ `<label>Model <select id="triage-route-model"${off}>${modelOptions}</select></label>`
+ `<label>Runs with <select id="triage-route-harness" aria-describedby="triage-route-harness-help"${off}>${harnessOptions}</select><span class="small muted" id="triage-route-harness-help">The program that runs the model, named as its module is installed. The list shows only the programs this model runs with.</span></label>`
+ `<label>Daily token limit <input id="triage-route-cap" type="number" min="1" step="1" inputmode="numeric" value="${esc(d.cap)}"${off}></label>`
+ `<label>Reset <input id="triage-route-reset" value="00:00" readonly aria-readonly="true"></label>`
+ `<label>Time zone <input id="triage-route-zone" list="triage-route-zones" autocomplete="off" spellcheck="false" placeholder="Region/City" value="${esc(d.timeZone)}"${off}></label>`
+ `</div><datalist id="triage-route-zones">${zones.map(z => `<option value="${esc(z)}"></option>`).join('')}</datalist>`
+ `<div class="settings-actions"><button type="submit" id="triage-route-save"${off}>${busy ? 'Saving…' : 'Save'}</button>${conflictButton} <span role="status" id="triage-route-line" tabindex="-1">${esc(line)}</span></div>`
+ `</form>${send ? '' : '<p class="small muted" id="triage-route-readonly">This Console is read-only, so the route cannot be saved here.</p>'}`;
}
function markup() {
const body = data === null
? `<p class="small warn">${esc(readLine || 'The Triage route could not be read.')}</p><p role="status" id="triage-route-line" tabindex="-1">${esc(line)}</p>`
: `${stored()}${form()}<p class="small muted" id="triage-route-note">${esc(data.note ?? 'Saving a route does not start Triage. Triage also needs its key.')}</p>`;
return `<section class="panel" id="triage-route" aria-labelledby="triage-route-title"><h3 id="triage-route-title">Triage model route</h3>${body}</section>`;
}
const repaint = () => { const panel = $('triage-route'); if (panel) panel.outerHTML = markup(); };
// Called by bus.js when the page draws: a fresh read each time, the typed fields kept.
async function section() { await read(); return markup(); }
async function save() {
if (busy || data?.send !== true) return;
const d = draft ?? fromRoute(null);
const cap = /^\d+$/.test(d.cap.trim()) ? Number(d.cap.trim()) : d.cap.trim() === '' ? null : Number.NaN;
const body = { model: d.model, harness: d.harness, cap: Number.isFinite(cap) ? cap : d.cap, timeZone: d.timeZone.trim(), revision: base };
busy = true; conflict = false; line = 'Saving…'; repaint();
let r, a = null;
try { r = await call({ method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) }); }
catch { busy = false; line = 'Outcome unknown. Reload the route to see whether it was saved.'; conflict = true; repaint(); return; }
try { a = await r.json(); } catch { /* refused below */ }
busy = false;
if (r.ok && a?.route) {
data = { ...data, route: a.route, revision: a.revision, routeMessage: undefined };
draft = fromRoute(a.route); base = a.revision;
line = `Saved ${savedAt(a.route.updatedAt)}.`;
repaint();
$('triage-route-line')?.focus?.();
return;
}
if (r.type === 'opaqueredirect') line = 'Sign in again, then retry.';
else line = typeof a?.message === 'string' ? a.message : 'The route was refused. Nothing was saved.';
if (r.status === 409 && a?.error === 'triage-route-stale') conflict = true;
repaint();
$(conflict ? 'triage-route-reload' : 'triage-route-save')?.focus();
}
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.' : '';
repaint();
}
const field = { 'triage-route-model': 'model', 'triage-route-harness': 'harness', 'triage-route-cap': 'cap', 'triage-route-zone': 'timeZone' };
document.addEventListener('input', e => {
const k = field[e.target?.id]; if (!k || !$('triage-route')) return;
draft = { ...(draft ?? fromRoute(null)), [k]: e.target.value };
});
document.addEventListener('change', e => {
if (e.target?.id !== 'triage-route-model') return;
// A new model narrows the harness list; a harness the model does not take is cleared.
const d = draft = { ...(draft ?? fromRoute(null)), model: e.target.value };
const hs = harnessesOf(d.model);
if (!hs.includes(d.harness)) d.harness = hs.length === 1 ? hs[0] : '';
repaint(); $('triage-route-model')?.focus();
});
document.addEventListener('submit', e => { if (e.target?.id !== 'triage-route-form') return; e.preventDefault(); save(); });
document.addEventListener('click', e => { if (e.target?.id === 'triage-route-reload') reload(); });
const hasDraft = () => !!(draft && data && JSON.stringify(draft) !== JSON.stringify(fromRoute(data.route)));
window.MosaicTriageRoute = { section, hasDraft };
})();
+3 -5
View File
@@ -40,8 +40,8 @@
return value;
}
const plain = v => v !== null && typeof v === 'object' && !Array.isArray(v);
// #1873: the templates no organization may hold (organization vocabulary SYSTEM_ONLY). The read may still
// list them; a step role never resolves to one and the picker never offers one.
// #1873: the templates no organization may hold (organization vocabulary SYSTEM_ONLY). The server leaves
// them out of the read; this filter stays so a step role never resolves to one and the picker never offers one.
const SYSTEM_ONLY = ['triage'];
const offered = list => (list || []).filter(r => !SYSTEM_ONLY.includes(r));
async function read(org, s) {
@@ -823,7 +823,5 @@
window.matchMedia(NARROW).addEventListener('change', () => {
if (document.querySelector('[data-wfg-graph]')) document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
});
// section(): the organization page's old form editor is gone (SP17); workspace.js still asks for it.
const section = () => '';
window.MosaicWorkflows = { load, section, page, card, hasDraft, forget, landed };
window.MosaicWorkflows = { load, page, card, hasDraft, forget, landed };
})();
+164 -42
View File
@@ -200,7 +200,7 @@
['ledger', 'Launch limits', !s ? unread : s.launch?.refused ? unread : Number.isFinite(total) ? `${plural(total, 'session')} at once` : 'No session limit', 'org file', 'limits'],
['talk', 'Assistant', 'The assistant agent and its seat names', 'org file', 'assistant'],
['ledger', 'Token use', 'Usage and limits per provider and model', 'system', 'tokens'],
['term', 'Model proxy', 'Accounts, priority and client keys', 'system', 'model-proxy'],
['term', 'Model setup', 'Your model service and its accounts', 'system', 'model-proxy'],
['restart', 'Console', 'Console restart', 'system', 'console'],
['business', 'Organizations', orgCount === null ? unread : plural(orgCount, 'organization'), 'system', 'organizations'],
['flag', 'About', typeof s?.release === 'string' ? `Release ${s.release}` : 'Address, release and notifier', 'system', 'about'],
@@ -367,21 +367,20 @@
${orgTiles}
${docrow}
<div class="ws-split">
<section aria-label="Sessions and workflows">
<section aria-label="Sessions, workflows, autonomy and starter packs">
${secH('Active agent sessions', live ? (noRuns ? 'running not read' : live.length ? `${live.length} running${tileAgents ? `, ${liveWorking} working` : ', working not read'}` : 'none running') : '', `<a href="#/agents?${oq}" data-focus-key="agents-all">This organization's agents</a>`)}
${sessions}
${window.MosaicWorkflows?.card?.(id, { stopped, label: label(org) }) ?? ''}
<div class="ws-wide">
${stopped ? stoppedPanel('data-autonomy', 'Autonomy') : window.MosaicAutonomy?.section(id) ?? ''}
${stopped ? stoppedPanel('data-packs', 'Starter packs') : window.MosaicPacks?.section(id) ?? ''}
</div>
</section>
<section aria-label="Settings">
${secH('Settings', 'every setting, with where its value comes from')}
${settingsList(org, { business, settings, instances, noRuns, orgCount: list ? list.length : null })}
</section>
</div>
<div class="ws-wide">
${stopped ? stoppedPanel('data-autonomy', 'Autonomy') : window.MosaicAutonomy?.section(id) ?? ''}
${stopped ? stoppedPanel('data-packs', 'Starter packs') : window.MosaicPacks?.section(id) ?? ''}
${stopped ? stoppedPanel('data-workflows', 'Workflows') : window.MosaicWorkflows?.section(id) ?? ''}
</div>
${await drawerRead}
</article>`;
}
@@ -1118,9 +1117,22 @@
};
const DRAWER_LIMIT = 5, STOP_REASON = 'Stopped from the agent drawer.';
const STOP_UNKNOWN = 'Outcome unknown. Read the agents again before trying; nothing was retried.';
// The Stop state of the drawer's agent survives repaints: `confirm` while it asks, `busy` while the
// request is open, then the result in words beside the button.
let stopState = null; // { id, confirm, busy, text }
// SP20: an organization that refuses a Stop or a Restart, in the same line for both.
const orgRefusal = (e, orgName) => e === 'org-archived' ? `${orgName} is archived, so its agents are not changed. Nothing changed.`
: e === 'org-unavailable' ? `${orgName} is not available to this Console. Nothing changed.` : '';
// Each drawer agent's question and Stop survive repaints: `confirm` while it asks, `busy` while the
// request is open, then the result in words beside the button. SP19: `kind` says whether Stop or
// Restart asks (no kind is Stop). While either asks or runs, both buttons wait. SP20: kept per agent,
// as restarts are, so two Stops in two drawers each keep their line. An entry goes when the drawer
// closes after it finished, when its question is cancelled, or when its Restart starts.
const stops = new Map(); // id -> { kind, confirm, busy, text }
// SP19: each drawer agent's restart, kept per agent so several can run at once and none loses its
// line when another drawer asks or stops: `busy` while it runs, then its outcome in words. An entry
// goes when a new question starts on that agent, or when the drawer closes after it finished.
const restarts = new Map(); // id -> { busy, text }
// The state a drawer draws: its own question or Stop first, else its restart.
const actState = id => stops.has(id) ? { id, ...stops.get(id) } : restarts.has(id) ? { id, kind: 'restart', ...restarts.get(id) } : null;
const RESTART_REASON = 'restart from the agent drawer';
let drawerFocus = false, drawerShown = null;
// The drawer holds at most one history entry. A row opened from the page without a drawer pushes one
// entry marked in history.state; switching rows replaces it. Close goes Back only from that marked
@@ -1133,11 +1145,16 @@
const sansAgent = () => { const n = queryOf(); n.delete('agent'); const s = n.toString(); return `${/^#\/orgs\/[^/?]+/.exec(location.hash)?.[0] ?? '#'}${pathOf()}${s ? `?${s}` : ''}`; };
// The row's name as a link that opens the drawer: a native link, so Tab reaches it and Enter opens it.
const drawerLink = (q, a) => `<a class="ws-drawer-open" href="${esc(drawerHref(q, `${a.org}:${a.key}`))}" data-ws-drawer-open="${esc(`${a.org}:${a.key}`)}" data-focus-key="${esc(`agent:${a.org}:${a.key}`)}">${esc(a.name)}</a>`;
const stopConfirm = (name, who) => `<span class="ws-drawer-confirm" data-drawer-stop-confirm>Stop ${esc(who)}? <button type="button" class="ws-btn danger" data-drawer-stop-yes data-focus-key="drawer-stop-yes">Stop ${esc(name)}</button> <button type="button" class="ws-btn" data-drawer-stop-no data-focus-key="drawer-stop-no">Cancel</button></span>`;
function stopActions(pick, a, orgName) {
const st = stopState?.id === pick.id ? stopState : null;
const who = `${a.name} in ${orgName}`;
return `<button type="button" class="ws-btn" data-drawer-stop data-focus-key="drawer-stop"${st?.busy || st?.confirm ? ' disabled' : ''}>${st?.busy ? 'Stopping…' : 'Stop'}<span class="ws-sr"> ${esc(who)}</span></button>${st?.confirm ? stopConfirm(a.name, who) : ''}`;
// SP19: Stop and Restart ask in the same confirm step, each under its own data attributes.
const actConfirm = (kind, name, question) => `<span class="ws-drawer-confirm" data-drawer-${kind}-confirm>${esc(question)} <button type="button" class="ws-btn danger" data-drawer-${kind}-yes data-focus-key="drawer-${kind}-yes">${kind === 'stop' ? 'Stop' : 'Restart'} ${esc(name)}</button> <button type="button" class="ws-btn" data-drawer-${kind}-no data-focus-key="drawer-${kind}-no">Cancel</button></span>`;
const stopConfirm = (name, who) => actConfirm('stop', name, `Stop ${who}?`);
const restartConfirm = (name, who, thread) => actConfirm('restart', name, `Restart ${who}? ${thread ? 'It ends its session; its next message starts it again.' : 'It ends its session and launches it again.'}`);
function stopActions(pick, a, orgName, thread) {
const st = actState(pick.id), kind = st?.kind || 'stop';
const who = `${a.name} in ${orgName}`, hold = st?.busy || st?.confirm ? ' disabled' : '';
const stop = `<button type="button" class="ws-btn" data-drawer-stop data-focus-key="drawer-stop"${hold}>${st?.busy && kind === 'stop' ? 'Stopping…' : 'Stop'}<span class="ws-sr"> ${esc(who)}</span></button>${st?.confirm && kind === 'stop' ? stopConfirm(a.name, who) : ''}`;
if (!window.MosaicAgents?.restart) return stop;
return `${stop} <button type="button" class="ws-btn" data-drawer-restart data-drawer-thread="${thread ? 'yes' : 'no'}" data-focus-key="drawer-restart"${hold}>${st?.busy && kind === 'restart' ? 'Restarting…' : 'Restart'}<span class="ws-sr"> ${esc(who)}</span></button>${st?.confirm && kind === 'restart' ? restartConfirm(a.name, who, thread) : ''}`;
}
// SP13 (#1873): the drawer's instances read gives the agent's state. The drawer does not hold the
// page for it: once the page's own reads have answered (`opts.page`), a drawer whose instances read
@@ -1336,7 +1353,8 @@
: a.level !== 'org' ? 'No Message: a copy is not messaged from here.'
: 'No Message: this Console messages only conversation agents, such as the Assistant.'}</p>`);
else if (change) acts.push(`<p class="note" data-drawer-nomessage>No Message: this Console does not send chat in ${esc(orgName)}.</p>`);
if (change && a.level === 'org' && !a.keep && running(item) > 0) acts.push(stopActions(pick, a, orgName));
// SP19: a restart that is running keeps its buttons even when a repaint reads no run between its end and its launch.
if (change && a.level === 'org' && !a.keep && (running(item) > 0 || restarts.get(id)?.busy)) acts.push(stopActions(pick, a, orgName, !!window.MosaicAgents?.isThread?.(def)));
// Why Stop is not offered, in words, where this Console could otherwise change the organization's agents.
// SP13: "not running" is a reason only once the instances read has given the agent's runs.
else if (change) acts.push(`<p class="note" data-drawer-nostop>${reading ? 'Its state is being read. Stop is offered once it is read and the agent is running.'
@@ -1344,10 +1362,25 @@
: a.level !== 'org' ? 'A copy is not stopped from here.'
: a.keep ? `${esc(a.name)} is one of ${esc(orgName)}’s protected agents, so it is not stopped from here.`
: 'It is not running, so there is nothing to stop.'}</p>`);
const st = stopState?.id === id ? stopState : null;
const st = actState(id);
const actions = chat || change
? `<div class="ws-drawer-acts" data-drawer-actions>${acts.join(' ')}<p class="ws-drawer-status" id="ws-drawer-status" role="status" data-drawer-status>${esc(st?.text || '')}</p></div>`
: `<p class="note" data-drawer-readonly>This Console only reads ${esc(orgName)}. It can not message or stop its agents.</p>`;
// SP18: the agents read lists only roles a run holds now, and thread.claims only conversations a run
// holds now; each row carries that run and when it took the role or the conversation. A claim counts
// only when the instances read lists its run as running, so a claim left by a run that ended does not
// date a stopped agent. Last activity is the latest such time. No read keeps when a run ended or when
// the agent last sent a message (a thread's messages read pages from the oldest message), so neither is shown.
const runs = !unknown && runsRead(item) ? item.running : null;
const claims = [a.s ? { ...a.s, what: 'the role' } : null, ...arr(body?.sessions).filter(x => x?.kind === 'thread' && x.org === org && x.instance === key).map(x => ({ ...x, what: 'the conversation' }))]
.filter(c => c && msOf(c.claimedAt) !== null && (!runs || runs.includes(c.run))).sort((x, y) => msOf(y.claimedAt) - msOf(x.claimedAt));
const last = claims[0], claimWhy = notRead(['agents', 'claims']);
// With the runs not read, nothing checked the claim against a live run, so the line says "a run".
const activity = last ? `${!runs ? 'a run' : runs.length > 1 ? `one of its ${runs.length} runs` : 'its run'} took ${last.what} <time datetime="${esc(last.claimedAt)}" title="${esc(new Date(msOf(last.claimedAt)).toLocaleString())}">${esc(ago(last.claimedAt))}</time>`
: `<span class="muted">${claimWhy ? `not read: ${esc(claimWhy)}`
: runs?.length ? `not recorded: ${runs.length > 1 ? 'its runs hold' : 'its run holds'} no role or conversation yet`
: !runs ? 'not recorded: the agents and claims reads show no run holding its role or a conversation, and its runs were not read'
: 'not recorded: no run holds it now, and no read keeps when its last run ended'}</span>`;
const fields = [
field('org', 'Organization', orgChip(o, org)),
// A pack hire's pack is named once, in Hired from; the Role row says only that it was hired.
@@ -1358,11 +1391,7 @@
model ? field('model', 'Model', `<span class="mono">${esc(model)}</span>`) : '',
project ? field('project', 'Project', `<a href="${esc(`${orgHref(org)}/projects/${enc(project.id)}`)}">${esc(project.name || project.key || project.id)}</a>${project.from ? ` <span class="t2">${project.from}</span>` : ''}`) : '',
task ? field('task', 'Task', `<a href="${esc(taskHref(task.ref))}">${esc(task.title || task.ref)}</a>${task.title ? ` <span class="t2 mono">${esc(task.ref)}</span>` : ''}`) : '',
// SP16: no read the Console makes carries the time of a role agent's last message or run. The agents
// read's time is when it took the role and `since` is when its present state began, so neither is shown.
// An agent holding a conversation has its messages in that thread's messages read, but that read pages
// from the oldest message, so its last message is a walk of every page away; the drawer does not make it.
field('activity', 'Last activity', `<span class="muted">${thread?.thread ? 'not shown: reading it means reading the whole conversation' : 'not recorded'}</span>`),
field('activity', 'Last activity', activity),
].join('');
return shell(a.name, `<dl class="ws-drawer-fields">${fields}</dl>
<section class="ws-drawer-sec" data-drawer-tasks aria-label="Open tasks assigned to ${esc(a.name)}"><h3>Open tasks</h3>${tasksBody}${tasksAll}</section>
@@ -1372,11 +1401,22 @@
// Closing goes Back when a row link on this page pushed the current entry; otherwise it drops
// `agent` from the address in place. Either way the page repaints without it and focus returns to the row.
function closeDrawer() {
if (!stopState?.busy) stopState = null;
for (const [k, st] of stops) if (!st.busy) stops.delete(k);
for (const [k, r] of restarts) if (!r.busy) restarts.delete(k);
if (stateOf()?.[DRAWER_MARK] && queryOf().has('agent')) { history.back(); return; }
history.replaceState(unmarked(), '', sansAgent());
document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
}
// SP18: below 701 px the open drawer is a sheet and shell.css holds the page under it to one screen, which
// scrolls the page to the top. The page's place is kept while no drawer is open, with the page the sheet
// opened over. It is put back only when the drawer closes onto that same page (Close, Escape or Back); a
// link in the sheet goes to another page, which starts at its top, and the kept place is dropped. Some
// pages a link opens (a project, the Assistant) are drawn without afterPaint, so the place is dropped as
// soon as the address leaves the page under the sheet.
const SHEET = window.matchMedia('(max-width:700px)');
let pageY = 0, sheetOver = null;
window.addEventListener('scroll', () => { if (!document.querySelector('#bus-view [data-ws-drawer]')) pageY = window.scrollY; }, { passive: true });
window.addEventListener('hashchange', () => { if (sheetOver !== null && sansAgent() !== sheetOver) { sheetOver = null; pageY = 0; } });
// bus.js calls this after each paint: focus moves into a drawer a row opened, and back to the row
// when the drawer has closed and focus was left nowhere.
function afterPaint() {
@@ -1384,8 +1424,13 @@
const view = document.getElementById('bus-view'), d = view?.querySelector('[data-ws-drawer]');
const now = d?.dataset.wsDrawer || null, was = drawerShown;
drawerShown = now;
if (now) sheetOver = sansAgent();
if (d && drawerFocus) { drawerFocus = false; d.querySelector('h2')?.focus({ preventScroll: true }); return; }
drawerFocus = false;
if (!now && sheetOver !== null) {
if (SHEET.matches && pageY && sheetOver === sansAgent()) window.scrollTo(0, pageY);
sheetOver = null; pageY = window.scrollY;
}
if (!now && was) {
const a = document.activeElement;
if (!a || a === document.body || !view?.contains(a)) view?.querySelector(`[data-focus-key="${CSS.escape(`agent:${was}`)}"]`)?.focus({ preventScroll: true });
@@ -1393,10 +1438,11 @@
}
async function stopAgent(d) {
const id = d.dataset.wsDrawer, org = d.dataset.drawerOrgId, name = id.slice(org.length + 1), orgName = d.dataset.drawerOrgName;
stopState = { id, busy: true, text: `Stopping ${name}…` };
stops.set(id, { busy: true, text: `Stopping ${name}…` });
const repaint = () => document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
const paint = () => { const now = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"]`); if (!now) return; const s = now.querySelector('[data-drawer-status]'); if (s) s.textContent = stopState.text; const b = now.querySelector('[data-drawer-stop]'); if (b) { b.disabled = !!stopState.busy; b.firstChild.textContent = stopState.busy ? 'Stopping…' : 'Stop'; } now.querySelector('[data-drawer-stop-confirm]')?.remove(); };
const finish = text => { stopState = { id, text }; paint(); const b = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"] [data-drawer-stop]`); b?.focus({ preventScroll: true }); };
// Paint this agent's drawer in place, when it is on screen.
const paint = () => { const now = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"]`), st = stops.get(id); if (!now || !st) return; const s = now.querySelector('[data-drawer-status]'); if (s) s.textContent = st.text; const b = now.querySelector('[data-drawer-stop]'); if (b) { b.disabled = !!st.busy; b.firstChild.textContent = st.busy ? 'Stopping…' : 'Stop'; } const rb = now.querySelector('[data-drawer-restart]'); if (rb) rb.disabled = !!st.busy; now.querySelector('[data-drawer-stop-confirm]')?.remove(); };
const finish = text => { stops.set(id, { text }); paint(); const b = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"] [data-drawer-stop]`); b?.focus({ preventScroll: true }); };
paint();
let res, body = null;
try { res = await fetch(`/api/orgs/${enc(org)}/agent/terminate`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ instance: name, reason: STOP_REASON }), cache: 'no-store', redirect: 'manual' }); }
@@ -1404,6 +1450,8 @@
if (res.type === 'opaqueredirect' || res.status === 401) return finish('Not stopped: sign in again, then read the agents.');
try { body = await res.json(); } catch { body = null; }
if (!res.ok || body?.sent !== true && !body?.request) {
const orgWhy = orgRefusal(body?.error, orgName);
if (orgWhy) return finish(`Not stopped: ${orgWhy}`);
if (body?.sent === false && typeof body.message === 'string' && body.message) return finish(`Not stopped: ${body.message}`);
if (res.status === 403 && body?.error === 'read-only') return finish(`Not stopped: this Console only reads agents in ${orgName} (read-only).`);
if (body?.sent === false && typeof body.error === 'string') return finish(`Not stopped: the bus refused (${body.error}).`);
@@ -1411,18 +1459,84 @@
}
const request = typeof body?.request === 'string' ? body.request : '';
if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(request)) return finish(STOP_UNKNOWN);
stopState = { id, busy: true, text: `Stop asked: request ${request} is open.` }; paint();
stops.set(id, { busy: true, text: `Stop asked: request ${request} is open.` }); paint();
for (let tries = 0; tries < 90; tries++) {
await new Promise(r => setTimeout(r, 2000));
let r = null;
try { const got = await fetch(`/api/orgs/${enc(org)}/agent/request?id=${enc(request)}`, { cache: 'no-store', redirect: 'manual' }); if (got.type === 'opaqueredirect') return finish('Sign in again, then read the agents.'); r = got.ok ? await got.json() : null; } catch { continue; }
if (r?.request === request && r.state === 'closed') {
if (r.reason) return finish(`Not stopped: ${r.reason}.`);
stopState = { id, text: `Stopped ${name}.` }; repaint(); return;
stops.set(id, { text: `Stopped ${name}.` }); repaint(); return;
}
}
finish(`Request ${request} is still open. Read the agents again later.`);
}
// SP19: the drawer's Restart. The agents.js chain ends the agent through its own organization's routes
// (the drawer's, which on #/agents is not the page's), waits for the request to close and its runs to
// reach 0, then launches it; a conversation agent is not launched. It never regenerates. Each step is
// painted in place; a refusal before the end leaves both buttons usable and focus on Restart.
const refusedWhy = (d, orgName) => {
const e = d?.result?.error, m = d?.result?.message;
if (d?.status === 403 && e === 'read-only') return `this Console only reads agents in ${orgName} (read-only).`;
if (d?.status === 403 && (e === 'unavailable' || e === 'owner-only')) return `this Console is not the owner of ${orgName}, so it does not restart its agents.`;
if (e === 'no-bus-host') return `the bus of ${orgName} is not running. Nothing changed.`;
const orgWhy = orgRefusal(e, orgName);
if (orgWhy) return orgWhy;
if (d?.result?.sent === false && typeof m === 'string' && m) return m;
if (d?.result?.sent === false && typeof e === 'string') return `the bus refused (${e}).`;
return STOP_UNKNOWN;
};
const restartWords = (name, orgName) => (step, d) => ({
ending: `Restarting ${name}: asking it to end…`,
signedOut: 'Not restarted: sign in again, then read the agents.',
endUnknown: `Not restarted: ${STOP_UNKNOWN}`,
endRefused: `Not restarted: ${refusedWhy(d, orgName)}`,
endOpen: `Not restarted: ${d?.stop}`,
endClosed: `Not restarted: ${name} was not ended (${d?.reason}).`,
ended: `${name} was asked to end. Waiting for its session to end…`,
stillRunning: `Not restarted: ${name} was asked to end, but its session is still running. Read the agents again before trying.`,
threadEnded: `Ended ${name} at ${d?.time}. Its next message starts it.`,
launching: `${name} has ended. Launching it…`,
launchSignedOut: `${name} was ended and not launched: sign in again, then read the agents.`,
launchUnknown: `${name} was ended. The launch outcome is unknown; read the agents again before trying. Nothing was retried.`,
launchRefused: `${name} was ended and not launched: ${refusedWhy(d, orgName)}`,
launchOpen: `${name} was ended. ${d?.stop}`,
launchClosed: `${name} was ended and not launched: ${d?.reason}.`,
restarted: `Restarted ${name}${d?.run ? ` (run ${d.run})` : ''}.`,
})[step];
async function restartAgent(d) {
const id = d.dataset.wsDrawer, org = d.dataset.drawerOrgId, name = id.slice(org.length + 1), orgName = d.dataset.drawerOrgName;
const thread = d.querySelector('[data-drawer-restart]')?.dataset.drawerThread === 'yes';
if (restarts.get(id)?.busy) return;
// The question is answered: from now on this agent's drawer draws its restart.
stops.delete(id);
restarts.set(id, { busy: true, text: '' });
// Paint this agent's drawer in place, when it is on screen and no question of its own holds it.
const paint = () => {
const now = document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"]`), r = restarts.get(id); if (!now || !r || stops.has(id)) return;
const s = now.querySelector('[data-drawer-status]'); if (s) s.textContent = r.text;
const rb = now.querySelector('[data-drawer-restart]'), sb = now.querySelector('[data-drawer-stop]');
if (rb) { rb.disabled = r.busy; rb.firstChild.textContent = r.busy ? 'Restarting…' : 'Restart'; }
if (sb) sb.disabled = r.busy;
now.querySelector('.ws-drawer-confirm')?.remove();
};
// The finished line stays in the entry. A refusal before the end changed nothing, so focus goes back
// to Restart. Once the agent was ended its runs changed: the repaint reads the instances again, so the
// buttons follow them (after a refused launch it has none, so Stop and Restart go), and focus goes to
// the drawer's heading, which every repaint keeps.
const after = new Set(['restarted', 'threadEnded', 'launchSignedOut', 'launchUnknown', 'launchRefused', 'launchOpen', 'launchClosed']);
const done = step => {
document.querySelector(`[data-ws-drawer="${CSS.escape(id)}"]`)?.querySelector(after.has(step) ? '[data-focus-key="drawer-h"]' : '[data-drawer-restart]')?.focus({ preventScroll: true });
if (after.has(step)) document.dispatchEvent(new CustomEvent('mosaic-workspace-render'));
};
const onStatus = ({ step, busy, text }) => {
restarts.set(id, { busy: !!busy, text });
paint();
if (!busy) done(step);
};
try { await window.MosaicAgents.restart(name, thread, { org, reason: RESTART_REASON, text: restartWords(name, orgName), onStatus }); }
catch { restarts.set(id, { busy: false, text: `Not restarted: ${STOP_UNKNOWN}` }); paint(); done('endUnknown'); }
}
document.addEventListener('click', e => {
const link = e.target.closest?.('[data-ws-drawer-open]');
if (link) {
@@ -1441,33 +1555,41 @@
if (!d) return;
if (e.target.closest('[data-drawer-close]')) { closeDrawer(); return; }
const id = d.dataset.wsDrawer;
if (e.target.closest('[data-drawer-stop]') && !(stopState?.id === id && stopState.busy)) {
const b = d.querySelector('[data-drawer-stop]'), name = d.dataset.drawerName;
stopState = { id, confirm: true, text: '' };
d.querySelector('[data-drawer-stop-confirm]')?.remove();
b.insertAdjacentHTML('afterend', stopConfirm(name, `${name} in ${d.dataset.drawerOrgName}`));
b.disabled = true;
// SP19: nothing starts while this agent's Stop or Restart runs.
const held = !!stops.get(id)?.busy || !!restarts.get(id)?.busy;
const ask = e.target.closest('[data-drawer-stop]') ? 'stop' : e.target.closest('[data-drawer-restart]') ? 'restart' : null;
if (ask && !held) {
const b = d.querySelector(`[data-drawer-${ask}]`), name = d.dataset.drawerName, who = `${name} in ${d.dataset.drawerOrgName}`;
stops.set(id, { kind: ask, confirm: true, text: '' }); restarts.delete(id);
d.querySelector('.ws-drawer-confirm')?.remove();
b.insertAdjacentHTML('afterend', ask === 'stop' ? stopConfirm(name, who) : restartConfirm(name, who, b.dataset.drawerThread === 'yes'));
for (const x of d.querySelectorAll('[data-drawer-stop], [data-drawer-restart]')) x.disabled = true;
const s = d.querySelector('[data-drawer-status]'); if (s) s.textContent = '';
d.querySelector('[data-drawer-stop-no]')?.focus({ preventScroll: true });
d.querySelector(`[data-drawer-${ask}-no]`)?.focus({ preventScroll: true });
return;
}
if (e.target.closest('[data-drawer-stop-no]')) { cancelStop(d); return; }
if (ask) return;
if (e.target.closest('[data-drawer-stop-no], [data-drawer-restart-no]')) { cancelStop(d); return; }
if (held) return;
if (e.target.closest('[data-drawer-stop-yes]')) stopAgent(d);
else if (e.target.closest('[data-drawer-restart-yes]')) restartAgent(d);
});
// Cancel the Stop question: nothing sent, Stop enabled again and focused.
// Cancel the Stop or Restart question: nothing sent, both buttons enabled again, focus on the one that asked.
function cancelStop(d) {
stopState = null;
d.querySelector('[data-drawer-stop-confirm]')?.remove();
const b = d.querySelector('[data-drawer-stop]'); if (b) { b.disabled = false; b.focus({ preventScroll: true }); }
const kind = d.querySelector('[data-drawer-restart-confirm]') ? 'restart' : 'stop';
stops.delete(d.dataset.wsDrawer);
d.querySelector('.ws-drawer-confirm')?.remove();
for (const x of d.querySelectorAll('[data-drawer-stop], [data-drawer-restart]')) x.disabled = false;
d.querySelector(`[data-drawer-${kind}]`)?.focus({ preventScroll: true });
}
// Escape cancels the Stop question while it asks, else closes the drawer, unless a dialog is open
// Escape cancels the Stop or Restart question while it asks, else closes the drawer, unless a dialog is open
// or something else took the key.
document.addEventListener('keydown', e => {
if (e.key !== 'Escape' || e.defaultPrevented || document.querySelector('dialog[open]')) return;
const d = document.querySelector('#bus-view [data-ws-drawer]');
if (!d) return;
e.preventDefault();
if (d.querySelector('[data-drawer-stop-confirm]')) cancelStop(d); else closeDrawer();
if (d.querySelector('.ws-drawer-confirm')) cancelStop(d); else closeDrawer();
});
// ---- controls: filters write the hash query and repaint in place ----
+5 -4
View File
@@ -66,7 +66,7 @@ const files = new Map([
['/', ['index.html', 'text/html; charset=utf-8']],
['/proxy.js', ['proxy.js', 'text/javascript; charset=utf-8']],
['/project-remote.js', ['project-remote.js', 'text/javascript; charset=utf-8']],
...['app.js', 'brand.js', 'bus.js', 'markdown-preview.js', 'chat.js', 'project-archive.js', 'processing.js', 'agents.js', 'federation.js', 'requests.js', 'org-create.js', 'console-restart.js', 'onboarding.js', 'workspace-data.js', 'workspace.js', 'tasks-board.js', 'assistant.js'].map(f => ['/' + f, [f, 'text/javascript; charset=utf-8']]),
...['app.js', 'brand.js', 'bus.js', 'markdown-preview.js', 'chat.js', 'project-archive.js', 'processing.js', 'agents.js', 'federation.js', 'requests.js', 'org-create.js', 'console-restart.js', 'onboarding.js', 'workspace-data.js', 'workspace.js', 'tasks-board.js', 'assistant.js', 'triage-settings.js'].map(f => ['/' + f, [f, 'text/javascript; charset=utf-8']]),
['/files.js', ['files.js', 'text/javascript; charset=utf-8']],
['/projects.js', ['projects.js', 'text/javascript; charset=utf-8']],
['/projects.css', ['projects.css', 'text/css; charset=utf-8']],
@@ -812,7 +812,7 @@ async function libraryStatusRead(res, read, search) {
// `log` takes one line per send attempt that got past sign-in; never the body. `fieldsFile` is for
// tests; the field table is otherwise the committed packages/tasks/fields.json.
// `agentWrite` (row 194, D7) is `(verb, args) => Promise` for the Agents section's verbs and instance.request.
export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, sso = null, tester = false, testerSocket = null, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, libraryStatus = null, libraryRevert = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, agentWrite = null, proxyCall = null, proxyAdmin = null, triage = null, processing = null, decisionWrite = null, requestRead = null, requestWrite = null, userOptions = null, federation = null, organizations = null, preselect = null, routes = [], orgAdmin = null, devAllowHosts = [], log = line => console.log(line), fieldsFile = undefined, restart = null, trail = null, boot = randomUUID(), workspaceTimeoutMs = undefined, agentLevels = null } = {}) {
export async function startServer({ host = '127.0.0.1', port = 7330, board = DEFAULT_BOARD, timeout = 20000, bus = null, reads = null, preview = null, sso = null, tester = false, testerSocket = null, testerAuthHeader = null, proof = null, testerProofHeader = null, send = null, settingsWrite = null, projectFiles = null, projectFile = null, projectSave = null, libraryStatus = null, libraryRevert = null, chat = null, nameWrite = null, assistantStop = null, instancesWrite = null, routesWrite = null, agentWrite = null, proxyCall = null, proxyAdmin = null, triage = null, processing = null, decisionWrite = null, requestRead = null, requestWrite = null, userOptions = null, federation = null, organizations = null, preselect = null, routes = [], orgAdmin = null, ownerModels = null, rideRemoved = null, devAllowHosts = [], log = line => console.log(line), fieldsFile = undefined, restart = null, trail = null, boot = randomUUID(), workspaceTimeoutMs = undefined, agentLevels = null } = {}) {
// org-lan-bind: the dev owner on the LAN is an explicit opt-in. `devAllowHosts` names the Host
// names (without a port) a remote browser may use; only the dev owner takes them, and only with
// them may it bind a non-loopback IPv4 address. SSO, preview and tester listeners stay loopback.
@@ -842,7 +842,7 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
const registered = routeTable();
for (const registerRoutes of routes) registerRoutes(registered);
registered.add('GET', '/api/themes', (req, res) => themesHTTP(req, res, { log }), { publicRead: true });
const adminRoute = (req, res, context) => orgAdminHTTP(req, res, { ...context, admin: orgAdmin ??= defaultOrgAdmin(), log, trail });
const adminRoute = (req, res, context) => orgAdminHTTP(req, res, { ...context, admin: orgAdmin ??= defaultOrgAdmin(process.env, { ownerModels, rideRemoved }), log, trail });
for (const path of ['/api/org-template', '/api/org-presets', '/api/org-validate', '/api/org-admin', /^\/api\/orgs\/[^/]+\/(?:admin|setup|repo|delete|archive|restore|restart|stop)(?:\/(?:queue|bus|project\/[^/]+|records\/[^/]+))?$/]) {
for (const method of ['GET', 'POST']) registered.add(method, path, adminRoute);
}
@@ -1048,7 +1048,8 @@ export async function startServer({ host = '127.0.0.1', port = 7330, board = DEF
// the selected bus; only the instance owner's own session reaches them, never an org owner.
if (path.startsWith('/api/proxy/admin/')) return proxyAdminHTTP(req, res, { path, admin: proxyAdmin, call: proxyCall, named, tester, granted,
owner: !tester && !granted && named && sso !== null && currentSession?.rootOwner === true, send: owner.send !== null,
origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, log });
origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user,
principal: currentSession ? { provider: currentSession.provider, iss: currentSession.iss, sub: currentSession.sub } : null, log });
if (path.startsWith('/api/proxy/')) return proxyHTTP(req, res, { path, call: proxyCall, named, tester, granted,
send, origin: sso ? (localOrigin ?? sso.publicOrigin) : `https://${preview.host}`, user: signer?.user, log });
}
+576 -39
View File
@@ -22,18 +22,60 @@
// state says so. The route's answer names the harness: adapter, its mounts, harnessEnv, turnEnd,
// model and provider, and the proxy variables for the spawn. Over the cap the route refuses until
// the next day, and the message is refused with its code.
//
// #1873 triage-fences: the host checks a copy of the route's answer before it writes anything, and
// uses only that copy. harnessEnv names must be in the harness module's envNames and pass
// refusedHarnessName; values are clean strings. env holds only ROUTE_ENV_ALLOW names, with
// ANTHROPIC_BASE_URL loopback http on a port (the host's proxyPort when it names one) and the
// token matching the host's tokenPattern when it names one. The adapter and the mounts pass
// checkHostedRoute (sandbox.mjs) against the module's installRoots and the data root, the config
// directory and HOME (HOME not counted against the stack's own code), here and again in
// hostedBinds. A refused answer reaches no spawn, answers triage-route-invalid, and writes
// ROUTE_REFUSED to the transcript; a refusal at the binds also removes what the start wrote.
//
// #1873 triage-wiring: the host sets the harness's MOSAIC_ names itself. At each start it calls the
// module's bundle() into the run's bundle/ (Claude Code: settings.json with the tool gate hook and
// mcp.json with the typed tools' server) and its env(), and keeps the MOSAIC_ names the
// module declares, with clean string values, never a name the runner sets. Every other name is the
// route's, under the fence above, so no name has two sources. The thinking
// level is the module's "low", or its first level. These join the route's fenced harnessEnv in
// session.json. The key is never among them: #1873 harness-matrix gives bundle() and env() the
// real proxy (pi takes it through models.json), and a MOSAIC_ value or any file under the run's
// bundle/, home/, work/ or tmp/ that holds the key, raw or JSON-decoded, refuses the start, as
// does a URL other than the proxy's in a file the module wrote there, or a change the module made
// to the rest of the run directory (session/). MOSAIC_CLAUDE_BIN, the pinned binary's absolute path, passes from the
// Console's environment as it does for a bus session. An answer the agent sends has the key, and
// anything shaped like it, replaced before it reaches the transcript.
//
// #1873 triage-cap: the relay counts each turn. usage.begin takes a baseline of the harness's
// transcript with the transcript usage-source the bus uses; usage.end takes the delta (the bus's
// own rules, triage-usage.mjs) and appends one line to <dataRoot>/triage/usage.jsonl. When a cap is
// stored (triage-route-store.mjs), the daily-quota plugin decides over the lines in that file: before
// a start (admit), before the runner takes queued messages (message.receive) and before each
// message's turn (the runner's state read outside a turn). Over the cap, or with the store or the
// file unreadable, the turn in flight finishes, every message still queued gets a host line and
// leaves the queue, and the runner is told its session is gone. Nothing is held in memory: each
// check reads the file again, so a restart counts what the file holds. With no cap stored, nothing
// is refused for usage and the lines are still written.
import { spawn } from "node:child_process";
import { randomBytes, timingSafeEqual } from "node:crypto";
import { appendFileSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, chmodSync, writeFileSync } from "node:fs";
import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
import { appendFileSync, closeSync, existsSync, lstatSync, mkdirSync, readdirSync, openSync, readFileSync, rmSync, chmodSync, writeFileSync } from "node:fs";
import { createServer } from "node:net";
import { homedir } from "node:os";
import { dirname, join } from "node:path";
import { BWRAP, REPO, RUNNER_FILES, hostedArgv, hostedBinds } from "../../seat/src/sandbox.mjs";
import { pathToFileURL } from "node:url";
import { BWRAP, REPO, RUNNER_FILES, checkHostedRoute, hostedArgv, hostedBinds } from "../../seat/src/sandbox.mjs";
import { isProviderVariable } from "../../seat/src/session.mjs";
import { configDir as systemConfigDir } from "../../organization/src/organization-config.mjs";
import { typedTools } from "../../harness/src/tools.mjs";
import { builtinTools } from "../../harness/src/bundle.mjs";
import { builtinTools, checkedTransport } from "../../harness/src/bundle.mjs";
import { FOUNDER_ENV } from "../../harness/src/runner.mjs";
import { extractCards, plainText } from "./triage-cards.mjs";
import { SNAPSHOT_FILE, writeSnapshot } from "./triage-snapshot.mjs";
import { readRoute } from "./triage-route-store.mjs";
import { ID as USAGE_ID, appendUsage, capState, delta, nextReset, readUsage, snapshot, usagePath } from "./triage-usage.mjs";
import { readTurn } from "../../plugins/usage-source/transcript/index.mjs";
export const RUNNER = RUNNER_FILES[0];
export const RELAY_REFUSED = "triage-refused";
@@ -43,6 +85,31 @@ export const QUEUE_MAX = 20;
export const UNANSWERED = "Triage stopped before it answered this message. Send it again.";
export const NOT_STARTED = "Triage did not start, so this message was not delivered.";
export const NOT_TAKEN = "Triage stopped before it read this message. Send it again.";
export const ROUTE_REFUSED = "Triage did not start: the model route's answer did not pass the host's checks, so this message was not delivered.";
export const overCapNotTaken = (until) => `Triage reached its daily token cap before it took this message. Send it again after ${until}.`;
export const USAGE_NOT_READ = "Triage could not read its token usage or its cap, so it did not take this message.";
// #1873 triage-wiring: two turns in a row whose usage reads unknown end the session (cap fail closed).
export const UNKNOWN_TURNS_MAX = 2;
export const USAGE_UNKNOWN_ENDED = "Triage ended this session: the token usage of two turns in a row could not be read, so the daily cap could not be kept. The next message starts a new session.";
// #1873 triage-wiring: the route's refusals (triage-route.mjs), each with the one plain line the
// drawer shows. None carries a path, a key or an env value.
export const ROUTE_REFUSALS = Object.freeze({
"triage-key-missing": "No Triage key is issued, so Triage will not start. The instance owner issues one first.",
"triage-key-unsafe": "The Triage key file is not safe to use, so Triage will not start.",
"triage-proxy-down": "The model proxy is not running, so Triage will not start.",
"triage-model-not-offered": "The model in the Triage route is no longer offered, so Triage will not start.",
"triage-catalogue-unavailable": "No model catalogue can confirm the Triage model now, so Triage will not start.",
"triage-harness-incompatible": "The harness in the Triage route cannot run its model, so Triage will not start.",
});
// The host's own words for each code message() throws.
const ADMIT_MESSAGES = Object.freeze({
"triage-over-cap": "Triage is over its daily cap",
"triage-no-route": "no model route is set for Triage",
"triage-usage-unreadable": "Triage's token usage could not be read",
"triage-route-unreadable": "the model route could not be read",
"triage-dir-unsafe": "a Triage directory is not a real directory",
...ROUTE_REFUSALS,
});
// An over-cap answer is held for at most this long; a later time is not taken.
export const CAP_HOLD_MAX_MS = 48 * 3600 * 1000;
const ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
@@ -54,13 +121,66 @@ const CAP = /^[0-9a-f]{64}$/;
// The spawn's environment: these names from the Console's own environment, PATH fixed, and the
// route's proxy variables. bwrap sets HOME and TMPDIR inside.
export const SPAWN_ENV_ALLOW = Object.freeze(["PATH", "LANG", "LC_ALL", "TZ", "TERM"]);
export const ROUTE_ENV_ALLOW = Object.freeze(["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN"]);
// Passed only as an absolute path: the pinned harness binary (packages/seat/src/session.mjs ENV_ALLOW).
export const SPAWN_PATH_ALLOW = Object.freeze(["MOSAIC_CLAUDE_BIN"]);
// The names the runner sets for every harness (runner.mjs adapterEnv); the host's own names never replace them.
const RUNNER_NAMES = new Set(["MOSAIC_SYSTEM_PROMPT_FILE", "MOSAIC_WORKSPACE", "MOSAIC_SESSION_DIR", "MOSAIC_POLICY_FILE", "MOSAIC_TOOLS_FILE",
"MOSAIC_TOOL_SOCKET", "MOSAIC_TURN_MARKER", "MOSAIC_PROVIDER", "MOSAIC_MODEL", "MOSAIC_MODEL_ACTIVITY_DIR", "MOSAIC_UNSLOP_LOG",
"MOSAIC_MODEL_EVENT_MONITOR", "MOSAIC_FIRST_OUTPUT_DIR", "MOSAIC_REQUEST"]);
// What a key the agent sends becomes in the transcript.
export const KEY_REMOVED = "[key removed]";
// The marker, under host/ (never mounted), that the next start gets a fresh session/.
const FRESH_MARKER = "fresh-session";
// #1873 harness-matrix: the names a harness may take the Triage key through. claude-code takes it as
// ANTHROPIC_AUTH_TOKEN; pi as ANTHROPIC_API_KEY, which its models.json names. A route's env holds
// exactly one of them.
export const ROUTE_KEY_NAMES = Object.freeze(["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_API_KEY"]);
export const ROUTE_ENV_ALLOW = Object.freeze(["ANTHROPIC_BASE_URL", ...ROUTE_KEY_NAMES]);
// The one key name a route env holds and its value, or null when it holds none or more than one.
export const routeKey = (routeEnv) => {
const held = ROUTE_KEY_NAMES.filter((k) => routeEnv?.[k] !== undefined);
if (held.length !== 1 || typeof routeEnv[held[0]] !== "string" || !routeEnv[held[0]]) return null;
return { name: held[0], value: routeEnv[held[0]] };
};
const ENV_NAME = /^[A-Z][A-Z0-9_]{0,63}$/;
const deniedHarnessName = (k) => !ENV_NAME.test(k) || k === "MOSAIC_CONFIG" || k.startsWith("MOSAIC_BUS_") || FOUNDER_ENV.includes(k) || k === "SSH_AUTH_SOCK";
const ENV_VALUE_MAX = 4096;
const HARNESS_ENV_MAX = 64;
// Refused in harnessEnv even when the harness module declares them: the runner's own MOSAIC_*
// values, loader, libc and interpreter hooks, the shell's start files, a tool's config directory
// and the founder's, an askpass program, a CA bundle or a base URL, Lua's start code, curl's config
// home and a TLS key log. A provider name (every ANTHROPIC_* among them) goes through route env or nowhere.
const REFUSED_PREFIX = /^(MOSAIC_|NODE_|LD_|DYLD_|PYTHON|BASH_|GIT_|MALLOC_|NPM_CONFIG_|XDG_)/;
const REFUSED_SUFFIX = /_(DIR|CONF|CONFIG|ASKPASS|CA_BUNDLE|BASE_URL)$/;
const REFUSED_NAMES = new Set([
"PATH", "HOME", "TMPDIR", "BASH_ENV", "ENV", "SSH_AUTH_SOCK", "SHELL", "SHELLOPTS", "BASHOPTS", "PS4", "IFS", "CDPATH",
"GLOBIGNORE", "PROMPT_COMMAND", "ZDOTDIR", "PERL5OPT", "PERL5LIB", "RUBYOPT", "RUBYLIB", "PERLLIB", "LESSOPEN", "LESSCLOSE", "HOSTALIASES", "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY",
"GCONV_PATH", "GLIBC_TUNABLES", "LOCPATH", "OPENSSL_CONF", "OPENSSL_ENGINES", "OPENSSL_MODULES", "SSL_CERT_FILE", "SSL_CERT_DIR",
"JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "JDK_JAVA_OPTIONS", "LUA_INIT", "CURL_HOME", "SSLKEYLOGFILE",
...FOUNDER_ENV,
]);
export const refusedHarnessName = (k) => typeof k !== "string" || !ENV_NAME.test(k) || REFUSED_PREFIX.test(k) || REFUSED_SUFFIX.test(k) || REFUSED_NAMES.has(k) || isProviderVariable(k);
// No control character of any kind (C0, DEL, C1) and no line or paragraph separator.
const cleanValue = (v) => typeof v === "string" && v.length <= ENV_VALUE_MAX && !/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(v);
const plainObject = (o) => o !== null && typeof o === "object" && !Array.isArray(o) && [Object.prototype, null].includes(Object.getPrototypeOf(o));
// The proxy is on this machine: http, 127.0.0.1, a port, nothing after it.
const LOOPBACK_URL = /^http:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/;
const HARNESS_NAME = /^[a-z][a-z0-9-]{0,31}$/;
// The harness module a route names, from the repository's own tree; null when there is none.
async function repoHarnessModule(name) {
if (!HARNESS_NAME.test(name)) return null;
const file = join(REPO, "packages", "plugins", "harness", name, "index.mjs");
try { if (!lstatSync(file).isFile()) return null; } catch { return null; }
return import(pathToFileURL(file).href);
}
export function triageEnv(source, routeEnv = {}, { node = process.execPath } = {}) {
const env = { PATH: `${dirname(node)}:/usr/bin:/bin` };
// #1873 harness-matrix: the repository's node_modules/.bin comes first, as a bus session's PATH has
// it (session.mjs sessionEnv): a harness whose adapter runs its binary from there finds it. It is in
// the sandbox only when the harness's own mounts bind node_modules.
const env = { PATH: `${join(REPO, "node_modules", ".bin")}:${dirname(node)}:/usr/bin:/bin` };
for (const k of SPAWN_ENV_ALLOW) if (k !== "PATH" && typeof source?.[k] === "string" && source[k].length <= 256) env[k] = source[k];
for (const k of SPAWN_PATH_ALLOW) if (typeof source?.[k] === "string" && source[k].startsWith("/") && source[k].length <= 256 && cleanValue(source[k])) env[k] = source[k];
for (const k of ROUTE_ENV_ALLOW) if (typeof routeEnv?.[k] === "string" && routeEnv[k].length <= 4096) env[k] = routeEnv[k];
return env;
}
@@ -132,9 +252,13 @@ function sameCap(a, b) {
return timingSafeEqual(Buffer.from(a), Buffer.from(b));
}
// The relay server. `onSend(body)` keeps a human-bound send; `take()` returns the queued owner
// messages; `read(id)` drops one that was answered.
export function createRelay({ socket, cap, take, read, onSend, log = () => {} }) {
// The relay server. `onSend({ body, in_reply_to, result })` keeps a human-bound send, `result` true
// only for class RESULT, the class the runner gives its answer to a turn; `take()` returns the
// queued owner messages; `read(id)` drops one that was answered.
// #1873 triage-cap: `usage(phase, turn)` (a promise) counts the turn; the relay answers usage.begin
// and usage.end only once it settles. `stopped(verb)` is asked before state and message.receive;
// true answers "not-holder", which ends the runner's loop after the turn in flight.
export function createRelay({ socket, cap, take, read, onSend, usage = null, stopped = () => false, log = () => {} }) {
const answer = (conn, value) => { try { conn.end(JSON.stringify(value) + "\n"); } catch {} };
const refuse = (conn) => answer(conn, { ok: false, error: RELAY_REFUSED, reason: "the Triage host answers only a message to the person" });
const server = createServer((conn) => {
@@ -155,12 +279,19 @@ export function createRelay({ socket, cap, take, read, onSend, log = () => {} })
const args = req.args && typeof req.args === "object" && !Array.isArray(req.args) ? req.args : {};
const verb = req.verb;
try {
if (usage && (verb === "usage.begin" || verb === "usage.end")) {
return void Promise.resolve()
.then(() => usage(verb === "usage.begin" ? "begin" : "end", args.turn))
.catch((e) => log(`triage relay: ${verb} not counted: ${e?.code ?? "error"}`))
.then(() => answer(conn, { ok: true, result: {} }));
}
if ((verb === "state" || verb === "message.receive") && stopped(verb)) return answer(conn, { ok: false, error: "not-holder" });
if (Object.hasOwn(LIFECYCLE, verb)) return answer(conn, { ok: true, result: LIFECYCLE[verb]() });
if (verb === "message.receive") return answer(conn, { ok: true, result: take() });
if (verb === "message.read") { read(args.id); return answer(conn, { ok: true, result: {} }); }
if (verb === "message.send" && args.to === "human" && typeof args.body === "string" && args.body.length <= 32768) {
// Only an id the host issued is kept. The model writes this field, and the transcript serves it.
onSend({ body: args.body, in_reply_to: typeof args.in_reply_to === "string" && OWNER_ID.test(args.in_reply_to) ? args.in_reply_to : null });
onSend({ body: args.body, in_reply_to: typeof args.in_reply_to === "string" && OWNER_ID.test(args.in_reply_to) ? args.in_reply_to : null, result: args.class === "RESULT" });
return answer(conn, { ok: true, result: { id: `triage-${randomBytes(6).toString("hex")}` } });
}
} catch (e) {
@@ -185,8 +316,26 @@ export function createRelay({ socket, cap, take, read, onSend, log = () => {} })
// provider, env } | { ok: false, code, until? } } or null for no route
// readSnapshot async () -> the snapshot (triage-snapshot.mjs composeSnapshot), written to health/
// pollInterval the runner's receive interval in ms, for tests; the runner's default otherwise
export function createTriageHost({ dataRoot, route = null, readSnapshot = async () => null, env = process.env, node = process.execPath, bwrap = BWRAP, now = () => new Date(), devOwner = false, log = () => {}, roleDir = join(REPO, "roles"), readOnly = [], pollInterval = null }) {
// proxyPort the port ANTHROPIC_BASE_URL must name, or null for any port; or a function that
// answers it, called at each admit (null from it refuses: no proxy is configured)
// tokenPattern a RegExp the whole ANTHROPIC_AUTH_TOKEN must match, or null for no shape check
// harnessModule async (name) -> the harness module (envNames, installRoots) or null; the
// repository's packages/plugins/harness/<name> by default
// home HOME, which no mount may reach outside the stack's own code; the Console user's by default
// usageSource { readTurn({ harness, root }) } the transcript usage-source; the repository's own by default
export function createTriageHost({ dataRoot, route = null, readSnapshot = async () => null, env = process.env, node = process.execPath, bwrap = BWRAP, now = () => new Date(), devOwner = false, log = () => {}, roleDir = join(REPO, "roles"), readOnly = [], pollInterval = null, proxyPort = null, tokenPattern = null, harnessModule = repoHarnessModule, home = homedir(), usageSource = { readTurn } }) {
if (typeof dataRoot !== "string" || !dataRoot.startsWith("/")) throw new TriageError("triage-no-data-root", "no data root");
const validPort = (p) => Number.isInteger(p) && p > 0 && p <= 65535;
if (proxyPort !== null && typeof proxyPort !== "function" && !validPort(proxyPort)) throw new TypeError("proxyPort must be a port number, null or a function");
if (tokenPattern !== null && !(tokenPattern instanceof RegExp)) throw new TypeError("tokenPattern must be a RegExp or null");
if (typeof harnessModule !== "function") throw new TypeError("harnessModule must be a function");
if (typeof usageSource?.readTurn !== "function") throw new TypeError("usageSource must have readTurn");
const tokenShape = tokenPattern && new RegExp(`^(?:${tokenPattern.source})$`, tokenPattern.flags.replace(/[gmy]/g, ""));
const tokenAnywhere = tokenPattern && new RegExp(tokenPattern.source, tokenPattern.flags.replace(/[gmy]/g, "") + "g");
// What no mount source may lie in or around, besides the run directory and the fixed list. HOME
// does not refuse the stack's own code when the stack runs from under it (a copy or a worktree).
const protectedPaths = [dataRoot, systemConfigDir(env), home];
const codeRoot = REPO;
const paths = triagePaths(dataRoot);
const role = JSON.parse(readFileSync(join(roleDir, "triage.json"), "utf8"));
const contract = readFileSync(join(roleDir, role.contract), "utf8");
@@ -199,6 +348,13 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
let cap = null;
let overCapUntil = null; // the route's over-cap answer, held until its time passes
const queue = [];
let usage = null; // this run's counting: { run, root, harness, baselines, ended, inTurn }
let usageChain = Promise.resolve(); // usage calls and exit records, one at a time
let usageLost = false; // a turn's line could not be written: the count is short, so a stored cap refuses
// The last session ended on unknown usage: the next start gets a new session/. Kept as a file under
// host/ too, so a Console restart between the end and the next message keeps it.
let freshSession = false;
const badSeen = new Set();
const ensureDirs = () => {
mkdirSync(dataRoot, { recursive: true, mode: 0o700 });
@@ -243,7 +399,161 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
return last;
})().finally(() => { refreshing = null; });
const writeBundle = (admitted) => {
// #1873 triage-wiring: the module's bundle files and its MOSAIC_ names, which the host sets itself.
const hostHarnessEnv = (mod, { admitted, bundleDir, files, policy, tools, toolSocket }) => {
if (typeof mod?.bundle !== "function" || typeof mod?.env !== "function") return { env: {}, files: [] };
// #1873 harness-matrix: the module gets the real proxy and the route's transport, as a bus
// session's bundle does, so a harness that takes the proxy through its own files (pi's
// models.json) writes them here. Claude Code's bundle() takes no proxy. No file it writes, in
// bundle/ or outside it, may hold the key or anything shaped like it.
const routed = routeKey(admitted.env);
const key = routed?.value;
if (!key) throw new Error("no key");
const holdsKey = (v) => typeof v === "string" && (v.includes(key) || Boolean(tokenAnywhere && v.match(tokenAnywhere)));
// A file's text, and when it parses as JSON every key and string in it, decoded: an escaped key
// or URL ("\u0061...", "http:\/\/...") is seen as the harness that parses the file sees it. A
// harness can parse more loosely than JSON.parse (pi takes a byte order mark, comments and
// trailing commas), so a file that does not parse may hold no backslash: its escapes would be
// decoded by the harness and not here.
const decoded = (text) => {
const out = [text];
let doc;
try { doc = JSON.parse(text); } catch {
if (text.includes("\\")) throw new Error("bundle file holds an escape it does not parse");
return out;
}
const stack = [doc];
while (stack.length) {
const v = stack.pop();
if (typeof v === "string") out.push(v);
else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) { out.push(k); stack.push(x); }
}
return out;
};
const write = (name, text) => {
if (typeof name !== "string" || !/^[a-z][a-z0-9.-]{0,63}$/.test(name) || typeof text !== "string") throw new Error("bundle file refused");
if (decoded(text).some(holdsKey)) throw new Error("bundle file holds the key");
writeFileSync(join(bundleDir, name), text, { mode: 0o600, flag: "wx" });
return [name, createHash("sha256").update(text).digest("hex")];
};
const quote = (p) => {
if (typeof p !== "string" || p.includes("'")) throw new Error("path can't hold a single quote");
return `'${p}'`;
};
let levels = [];
try { levels = typeof mod.levels === "function" ? mod.levels() : []; } catch { levels = []; }
const thinking = Array.isArray(levels) && levels.includes("low") ? "low" : Array.isArray(levels) && typeof levels[0] === "string" ? levels[0] : "";
const proxy = { baseUrl: admitted.env.ANTHROPIC_BASE_URL, key };
const session = { model: admitted.model, provider: admitted.provider ?? "", thinking, toolSocket, ...(admitted.transport ? { proxyTransport: { ...admitted.transport } } : {}) };
const models = { triage: { provider: admitted.provider ?? "", model: admitted.model } };
const transports = admitted.transport ? { triage: { ...admitted.transport } } : {};
// The rest of the run directory (session/, kept across starts) is the module's to leave alone:
// what it holds before bundle() must be what it holds after env(). ctime is in the record
// because no user process can set it back, as it can mtime.
const scanned = new Set(["bundle", "home", "work", "tmp"]);
const kept = () => {
const seen = new Map();
for (const name of readdirSync(paths.agent, { recursive: true })) {
const rel = String(name);
if (scanned.has(rel.split("/")[0])) continue;
const st = lstatSync(join(paths.agent, rel));
seen.set(rel, `${st.mode}:${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.nlink}`);
}
return seen;
};
const before = kept();
// The host's own bundle files (prompt, policy, tools) must be as the host wrote them.
const hostFiles = new Map(Object.values(files).map((f) => [f, readFileSync(f, "utf8")]));
const own = mod.bundle({ dir: bundleDir, files: { ...files }, session: { ...session }, write, quote, models, proxy: { ...proxy }, transports });
const ownFiles = plainObject(own?.files) ? own.files : {};
const given = mod.env({ files: { ...ownFiles }, policy, tools, session: { ...session }, models, proxy: { ...proxy } });
if (!plainObject(given)) throw new Error("env refused");
const after = kept();
const changed = [...after].filter(([k, v]) => before.get(k) !== v).map(([k]) => k);
if (changed.length || after.size !== before.size) {
// What the module added or changed goes, and the next start takes a fresh session.
for (const k of changed) rmSync(join(paths.agent, k), { recursive: true, force: true });
freshSession = true;
throw new Error("bundle changed the run directory");
}
// Each host bundle file is still there, a regular file with one link and the same bytes,
// whether or not the scan below reaches it.
for (const [f, text] of hostFiles) {
const st = lstatSync(f, { throwIfNoEntry: false });
if (!st?.isFile() || st.nlink !== 1 || readFileSync(f, "utf8") !== text) throw new Error("bundle changed a host file");
}
// A module can write by its own means too, and name only some of its files. writeBundle makes
// bundle/, home/, work/ and tmp/ fresh just before, so every file in them came from this start:
// each is read again, and each must be a regular file with no key in it, raw or decoded, and,
// past the host's own bundle files, no URL but the proxy's (its root or /v1): a harness reads
// files from its HOME and workspace that it does not declare (pi's ~/.pi/agent/models.json).
// No string in them may be a pi command value: pi runs a config value that starts with "!" as a
// shell command, so no decoded string starts with "!" and no text holds a string that does ('"!').
// These fences see what the module left when env() returns, in the run directory only. They do not stop a module that
// hides the key (base64, split across files) or writes after: harness modules are reviewed
// repo code, and the fences catch their mistakes, not their intent.
const proxyUrl = (u) => u === proxy.baseUrl || u === proxy.baseUrl + "/v1";
const SPECIAL = new Set(["http:", "https:", "ws:", "wss:", "ftp:", "file:"]);
// Every URL a string names, as written ("http://", "http:host", "http:\\host") or as a URL
// parser reads the whole string (it drops tabs and newlines anywhere and controls at the ends).
const urlsIn = (text) => {
const out = [...text.matchAll(/[a-z][a-z0-9+.-]*:\/\/[^\s"'<>\\]*/gi), ...text.matchAll(/\b(?:https?|wss?|ftp|file):[^\s"'<>]*/gi)].map(([u]) => u);
if (URL.canParse(text) && SPECIAL.has(new URL(text).protocol)) out.push(text);
return out;
};
const strings = new Map();
for (const d of ["bundle", "home", "work", "tmp"]) {
const root = join(paths.agent, d);
for (const name of readdirSync(root, { recursive: true })) {
const f = join(root, String(name));
const st = lstatSync(f);
if (st.isDirectory()) continue;
if (!st.isFile()) throw new Error("bundle file is not a regular file");
const text = readFileSync(f, "utf8");
if (hostFiles.has(f)) { if (text !== hostFiles.get(f)) throw new Error("bundle changed a host file"); continue; }
const all = decoded(text);
if (all.some(holdsKey)) throw new Error("bundle file holds the key");
if (all.some((t) => urlsIn(t).some((u) => !proxyUrl(u)))) throw new Error("bundle file names another URL");
if (all.some((t) => t.startsWith("!") || t.includes('"!'))) throw new Error("bundle file holds a command value");
strings.set(f, all);
}
}
// The key goes only into the one key name the route answered, as the key itself; the URL, when
// env() names one, is the route's.
for (const [k, v] of Object.entries(given)) {
if (k === routed.name) continue;
if (holdsKey(v)) throw new Error("env holds the key");
if (k === "ANTHROPIC_BASE_URL" && v !== proxy.baseUrl) throw new Error("env names another proxy");
}
if (given[routed.name] !== key) throw new Error("env does not take the key as it is");
// Files the module wrote outside bundle/ (pi's models.json): each a regular file the session's
// HOME holds, read above, with no URL but the proxy's (its root or /v1), raw or decoded, bound read-only
// over the run directory. A harness whose env() names no URL must take it from one of them.
const homeDir = join(paths.agent, "home");
const harnessFiles = [];
let urlInFile = false;
for (const f of Object.values(ownFiles)) {
if (typeof f !== "string" || f.startsWith(bundleDir + "/")) continue;
if (!f.startsWith(homeDir + "/") || f.split("/").includes("..")) throw new Error("bundle file outside the session's HOME");
const st = lstatSync(f);
if (!st.isFile() || st.nlink !== 1) throw new Error("bundle file is not a regular file");
const all = strings.get(f);
if (!all) throw new Error("bundle file was not read");
if (all.some((t) => urlsIn(t).length > 0)) urlInFile = true;
harnessFiles.push(f);
}
if (given.ANTHROPIC_BASE_URL === undefined && !urlInFile) throw new Error("harness takes no proxy URL");
// A name the route's harnessEnv holds that env() also answers must have env()'s value.
for (const [k, v] of Object.entries(admitted.harnessEnv ?? {})) if (Object.hasOwn(given, k) && given[k] !== v) throw new Error("harness env differs");
const out = {};
for (const [k, v] of Object.entries(given)) {
if (!k.startsWith("MOSAIC_") || !mod.envNames.includes(k) || !ENV_NAME.test(k) || RUNNER_NAMES.has(k) || !cleanValue(v)) continue;
out[k] = v;
}
return { env: out, files: harnessFiles };
};
const writeBundle = (admitted, mod) => {
const a = paths.agent;
for (const d of ["bundle", "tmp", "work", "home"]) freshDir(join(a, d));
mkdirSync(join(a, "work", "health"), { mode: 0o700 });
@@ -251,8 +561,11 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
// turns/ left by the last run stops the next one at its first turn.
for (const f of ["session.json", "relay.sock", "tools.sock", "turn.done", "turns"]) rmSync(join(a, f), { recursive: true, force: true });
// The session's history stays across starts, unless the session put something other than a
// real directory there.
try { realDir(join(a, "session")); } catch { freshDir(join(a, "session")); }
// real directory there, or the last session ended because its usage could not be read: then the
// next one starts with a fresh session and transcript, so its turns count from a known baseline.
const marker = join(paths.host, FRESH_MARKER);
if (freshSession || existsSync(marker)) { freshDir(join(a, "session")); freshSession = false; rmSync(marker, { force: true }); }
else { try { realDir(join(a, "session")); } catch { freshDir(join(a, "session")); } }
const resolved = { limits: { authority: role.authority, tools: role.tools }, definition: "triage", pluginTools: [] };
const tools = typedTools({ resolved }).filter((t) => t.name === "send_message");
const workspace = join(a, "work");
@@ -262,29 +575,208 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
writeFileSync(bundle.prompt, hostPrompt(contract, { snapshotPath: join(workspace, "health", SNAPSHOT_FILE), steps }), { mode: 0o600, flag: "wx" });
writeFileSync(bundle.policy, JSON.stringify(policy, null, 2) + "\n", { mode: 0o600, flag: "wx" });
writeFileSync(bundle.tools, JSON.stringify(tools, null, 2) + "\n", { mode: 0o600, flag: "wx" });
let hostEnv, harnessFiles;
try { ({ env: hostEnv, files: harnessFiles } = hostHarnessEnv(mod, { admitted, bundleDir: join(a, "bundle"), files: bundle, policy, tools, toolSocket: join(a, "tools.sock") })); }
catch {
log("triage host: route refused: harness-bundle");
for (const d of ["bundle", "home", "work", "tmp"]) rmSync(join(a, d), { recursive: true, force: true });
throw new TriageError("triage-route-invalid", "the model route's answer is not usable");
}
const run = `triage-${now().toISOString().replace(/[^0-9]/g, "").slice(0, 14)}`;
const session = {
bundle, adapter: admitted.adapter, harness: admitted.harness, harnessEnv: admitted.harnessEnv, turnEnd: admitted.turnEnd,
bundle, adapter: admitted.adapter, harness: admitted.harness, harnessEnv: { ...admitted.harnessEnv, ...hostEnv }, turnEnd: admitted.turnEnd,
workspace, sessionDir: join(a, "session"), toolSocket: join(a, "tools.sock"), turnMarker: join(a, "turn.done"),
brokerSocket: join(a, "relay.sock"), business: "system", instance: "triage", run: `triage-${now().toISOString().replace(/[^0-9]/g, "").slice(0, 14)}`,
brokerSocket: join(a, "relay.sock"), business: "system", instance: "triage", run,
model: admitted.model, provider: admitted.provider ?? "",
...(Number.isInteger(pollInterval) && pollInterval >= 100 ? { pollInterval } : {}),
};
writeFileSync(join(a, "session.json"), JSON.stringify(session, null, 2) + "\n", { mode: 0o600, flag: "wx" });
return { run, harnessFiles };
};
const checkAdmitted = (a) => {
if (!a || typeof a !== "object" || typeof a.adapter !== "string" || !a.adapter.startsWith("/")
|| !["marker", "exit"].includes(a.turnEnd) || typeof a.model !== "string" || !a.model
|| typeof a.harness !== "string" || !/^[a-z][a-z0-9-]{0,31}$/.test(a.harness)
|| !a.harnessEnv || typeof a.harnessEnv !== "object" || Array.isArray(a.harnessEnv)
|| Object.entries(a.harnessEnv).some(([k, v]) => typeof v !== "string" || deniedHarnessName(k))
|| !Array.isArray(a.harnessMounts ?? [])) throw new TriageError("triage-route-invalid", "the model route's answer is not usable");
// The route's answer, checked. It returns a copy taken once, so a getter or a later change to
// the route's object cannot hand the bundle or the binds anything the checks did not see, and
// the module's install roots, for hostedBinds. The log names the fence, never a value.
const checkAdmitted = async (answer) => {
const refuse = (fence) => {
log(`triage host: route refused: ${fence}`);
throw new TriageError("triage-route-invalid", "the model route's answer is not usable");
};
let a;
try { a = structuredClone(answer); } catch { refuse("shape"); }
if (!plainObject(a) || typeof a.adapter !== "string" || !["marker", "exit"].includes(a.turnEnd)
|| typeof a.model !== "string" || !a.model || typeof a.harness !== "string" || !HARNESS_NAME.test(a.harness)
|| (a.provider !== undefined && typeof a.provider !== "string")) refuse("shape");
let mod = null;
try { mod = await harnessModule(a.harness); } catch { mod = null; }
const declared = mod?.envNames;
if (!Array.isArray(declared) || typeof mod.installRoots !== "function") refuse("module");
const he = a.harnessEnv;
if (!plainObject(he) || Object.keys(he).length > HARNESS_ENV_MAX) refuse("harness-env");
for (const [k, v] of Object.entries(he)) if (refusedHarnessName(k) || !declared.includes(k) || !cleanValue(v)) refuse("harness-env");
const re = a.env ?? {};
if (!plainObject(re) || Object.entries(re).some(([k, v]) => !ROUTE_ENV_ALLOW.includes(k) || !cleanValue(v))) refuse("route-env");
// #1873 harness-matrix: exactly one key name, and no harnessEnv value holds the key.
const routed = routeKey(re);
if (!routed) refuse("route-env");
for (const v of Object.values(he)) if (v.includes(routed.value) || (tokenAnywhere && v.match(tokenAnywhere))) refuse("harness-env");
const url = LOOPBACK_URL.exec(re.ANTHROPIC_BASE_URL ?? "");
let port = proxyPort;
if (typeof proxyPort === "function") {
try { port = await proxyPort(); } catch { port = undefined; }
if (!validPort(port)) refuse("route-env");
}
if (!url || Number(url[1]) > 65535 || (port !== null && Number(url[1]) !== port)) refuse("route-env");
if (tokenShape && !tokenShape.test(routed.value)) refuse("route-env");
// The route's transport, when it gives one, held to the bus's own transport check. This checks its
// shape only: the harness rule ran at the route's admit, through the provider module's route().
if (a.transport !== undefined) {
try { checkedTransport({ provider: a.provider ?? "", model: a.model }, a.harness, () => ({ ...(plainObject(a.transport) ? a.transport : {}), provider: a.provider ?? "", model: a.model })); }
catch { refuse("transport"); }
}
let installRoots;
try { installRoots = structuredClone(mod.installRoots({ env })); } catch { refuse("module"); }
try {
checkHostedRoute({ adapter: a.adapter, harnessMounts: a.harnessMounts ?? [], installRoots, protectedPaths, codeRoot, codeHolder: home, runDir: paths.agent, node });
} catch (e) {
if (e?.code === "hosted-binds-refused") refuse(e.fence);
throw e;
}
// Where the harness keeps its session files, as the bus binds it (the module's transcript()).
// Only a path inside the run directory is read; anything else reads as no transcript.
let transcriptRoot = null;
try {
const r = typeof mod.transcript === "function" ? mod.transcript({ runDir: paths.agent }) : null;
if (typeof r === "string" && r.startsWith(paths.agent + "/") && !r.split("/").includes("..")) transcriptRoot = r;
} catch { transcriptRoot = null; }
return { admitted: a, installRoots, transcriptRoot, mod };
};
const start = async (admitted) => {
checkAdmitted(admitted);
// #1873 triage-cap. A baseline or a reading of the transcript, with the bus's codes.
const sample = async (u) => {
if (u.root === null) return { status: "unknown", code: "no-transcript" };
try { return snapshot(await usageSource.readTurn({ harness: u.harness, root: u.root })); }
catch { return { status: "unknown", code: "source-failed" }; }
};
// A turn id the runner names, or "unnamed". The first begin for a turn wins, as on the bus.
const turnKey = (turn) => (typeof turn === "string" && USAGE_ID.test(turn) ? turn : null);
const usageBegin = (u, turn) => {
const named = turnKey(turn);
if (!named) log("triage host: usage.begin without a usable turn id");
const k = named ?? "unnamed";
u.inTurn = true;
if (!u.baselines.has(k)) u.baselines.set(k, sample(u));
};
// One line per turn: the delta since its baseline, known or unknown.
const finishTurn = async (u, k) => {
const base = u.baselines.has(k) ? await u.baselines.get(k) : null;
u.baselines.delete(k);
const result = delta(base, await sample(u));
const known = result.status === "known";
if (!known) log(`triage host: turn usage unknown: ${result.code}`);
u.unknownInRow = known ? 0 : u.unknownInRow + 1;
const line = { at: now().toISOString(), run: u.run, turn: k, status: result.status,
input: known ? result.input : null, output: known ? result.output : null, cacheRead: known ? result.cacheRead : null, cacheWrite: known ? result.cacheWrite : null };
try {
appendUsage(usagePath(dataRoot), line);
} catch (e) {
usageLost = true;
log(`triage host: usage line not written: ${e?.code ?? "error"}`);
}
if (u.unknownInRow >= UNKNOWN_TURNS_MAX && !u.halted) endUnknown(u);
};
// #1873 triage-wiring: the cap cannot be kept on turns it cannot count, so the second unknown turn
// in a row ends the session: a host line says why, the runner is told its session is gone at its
// next state or receive, and the process group gets SIGTERM, then SIGKILL. The next message starts
// a new run with a fresh session directory.
const endUnknown = (u) => {
u.halted = true;
freshSession = true;
try { writeFileSync(join(paths.host, FRESH_MARKER), "", { mode: 0o600 }); }
catch { log("triage host: fresh-session marker not written"); }
log("triage host: ending the session: two turns in a row with unknown usage");
try { append({ at: now().toISOString(), from: "host", text: USAGE_UNKNOWN_ENDED }); }
catch { log("triage host: transcript write failed"); }
const c = u.child;
if (!c || child !== c) return;
try { process.kill(-c.pid, "SIGTERM"); } catch {}
const t = setTimeout(() => { if (child === c) { try { process.kill(-c.pid, "SIGKILL"); } catch {} } }, 5000);
t.unref?.();
};
const usageEnd = async (u, turn) => {
u.inTurn = false;
const named = turnKey(turn);
if (!named) log("triage host: usage.end without a usable turn id");
if (named && u.ended.has(named)) { log("triage host: usage.end repeated for a turn; not counted twice"); return; }
if (named) u.ended.add(named);
await finishTurn(u, named ?? "unnamed");
};
const chainUsage = (fn) => (usageChain = usageChain.then(fn).catch((e) => log(`triage host: usage failed: ${e?.code ?? "error"}`)));
// The stored cap's state, read from the store and the usage file each time.
// { state: "not set" } no cap stored
// { state: "route-unreadable" } | { state: "usage-unreadable", cap, resetsAt? } refused
// { state: "under" | "over", cap, usageToday, resetsAt }
const capNow = () => {
let stored;
try { stored = readRoute(dataRoot); } catch { return { state: "route-unreadable" }; }
if (!stored) return { state: "not set" };
const at = now().getTime();
let resetsAt;
try { resetsAt = new Date(nextReset(stored.cap, at)).toISOString(); } catch { return { state: "usage-unreadable", cap: stored.cap }; }
if (usageLost) return { state: "usage-unreadable", cap: stored.cap, resetsAt };
let read;
try { read = readUsage(usagePath(dataRoot)); } catch { return { state: "usage-unreadable", cap: stored.cap, resetsAt }; }
for (const b of read.bad) {
const key = `${read.ino}:${b.line}`;
if (badSeen.has(key)) continue;
badSeen.add(key);
log(`triage host: usage.jsonl line ${b.line} is not a usage line; it counts as an unknown turn`);
}
try {
const s = capState({ cap: stored.cap, records: read.records, now: at });
return { state: s.allow ? "under" : "over", cap: stored.cap, usageToday: s.usageToday, resetsAt: s.resetsAt };
} catch { return { state: "usage-unreadable", cap: stored.cap, resetsAt }; }
};
const unsafeRoot = () => {
let st;
try { st = lstatSync(paths.root); } catch { return false; }
return st.isSymbolicLink() || !st.isDirectory() || (typeof process.getuid === "function" && st.uid !== process.getuid());
};
const refusedByCap = (c) => c.state === "over" || c.state === "usage-unreadable" || c.state === "route-unreadable";
// Before the runner takes messages or starts a message's turn: over the cap, every message still
// queued gets a host line and leaves the queue, and the runner's loop ends. That holds with nothing
// queued too: an idle session over the cap ends at its next receive, and the next message is
// refused by admit. A state read inside a turn (a continuation) is not stopped: the turn finishes.
const capStop = (verb) => {
const u = usage;
if (u?.halted) return true;
if (verb === "state" && u?.inTurn) return false;
const c = capNow();
if (!refusedByCap(c)) return false;
log(`triage host: stopping the session at ${verb}: ${c.state === "over" ? "over the daily token cap" : "usage or cap not read"}`);
// A message whose turn began and was never answered says so; one never begun says why not.
const begun = (id) => Boolean(u && (u.baselines.has(id) || u.ended.has(id)));
for (const m of queue.splice(0)) {
const text = begun(m.id) ? UNANSWERED : c.state === "over" ? overCapNotTaken(c.resetsAt) : USAGE_NOT_READ;
try { append({ at: now().toISOString(), from: "host", in_reply_to: m.id, text }); }
catch { log("triage host: transcript write failed"); }
}
return true;
};
const start = async ({ admitted, installRoots, transcriptRoot, mod }) => {
ensureDirs();
writeBundle(admitted);
const { run, harnessFiles } = writeBundle(admitted, mod);
// The key this session holds, and anything shaped like a key, never reaches the transcript.
const key = routeKey(admitted.env)?.value ?? null;
const scrub = (body) => {
let t = typeof body === "string" ? body : "";
if (key) t = t.split(key).join(KEY_REMOVED);
return tokenAnywhere ? t.replace(tokenAnywhere, KEY_REMOVED) : t;
};
const u = { run, root: transcriptRoot, harness: admitted.harness, baselines: new Map(), ended: new Set(), inTurn: false, unknownInRow: 0, halted: false, child: null };
usage = u;
cap = randomBytes(32).toString("hex");
relay = await createRelay({
socket: join(paths.agent, "relay.sock"), cap,
@@ -297,17 +789,33 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
const i = queue.findIndex((m) => m.id === id);
if (i >= 0) queue.splice(i, 1);
},
// A reply that names a queued message answers it: the message leaves the queue here, so a
// session that ends before its message.read leaves no "unanswered" line under an answer.
onSend: ({ body, in_reply_to }) => {
const { text, cards, dropped } = extractCards(body, orgIds(), { devOwner: devOwner === true });
// An answer (class RESULT) that names a queued message answers it: the message leaves the queue
// here, so a session that ends before its message.read leaves no "unanswered" line under an
// answer. A note in any other class stays in the transcript but leaves the message queued, so
// a session that ends after a progress note still gets the "unanswered" line. The model's tool
// can also pick class RESULT; such a note settles the message as the runner's answer would.
onSend: ({ body, in_reply_to, result }) => {
const { text, cards, dropped } = extractCards(scrub(body), orgIds(), { devOwner: devOwner === true });
append({ at: now().toISOString(), from: "triage", text, cards, dropped, ...(in_reply_to ? { in_reply_to } : {}) });
const i = in_reply_to ? queue.findIndex((m) => m.id === in_reply_to) : -1;
const i = in_reply_to && result === true ? queue.findIndex((m) => m.id === in_reply_to) : -1;
if (i >= 0) queue.splice(i, 1);
},
usage: (phase, turn) => chainUsage(() => (phase === "begin" ? usageBegin(u, turn) : usageEnd(u, turn))),
stopped: capStop,
log,
});
const list = hostedBinds({ runDir: paths.agent, healthDir: paths.health, adapter: admitted.adapter, harnessMounts: admitted.harnessMounts ?? [], relaySocket: join(paths.agent, "relay.sock"), node, readOnly });
let list;
try {
list = hostedBinds({ runDir: paths.agent, healthDir: paths.health, adapter: admitted.adapter, harnessMounts: admitted.harnessMounts ?? [], installRoots, protectedPaths, codeRoot, codeHolder: home, relaySocket: join(paths.agent, "relay.sock"), node, readOnly, harnessFiles });
} catch (e) {
if (e?.code !== "hosted-binds-refused") throw e;
log(`triage host: route refused at the binds: ${e.fence}`);
// Nothing of the refused start stays: the relay, its socket, the bundle and session.json go.
relay?.close();
relay = null;
for (const f of ["relay.sock", "session.json", "bundle", "home", "work", "tmp"]) rmSync(join(paths.agent, f), { recursive: true, force: true });
throw new TriageError("triage-route-invalid", "the model route's answer is not usable");
}
const argv = hostedArgv(list, paths.agent, [node, RUNNER, paths.agent], { bwrap });
const out = openSync(paths.log, "a", 0o600);
try {
@@ -316,6 +824,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
closeSync(out);
}
const mine = child;
u.child = mine;
const closeRelay = () => {
relay?.close();
relay = null;
@@ -328,6 +837,9 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
if (child !== mine) return;
lastExit = { code: Number.isInteger(code) ? code : null, signal: signal ?? null, at: now().toISOString() };
child = null;
// A turn the session began and never ended (killed, crashed) still spent tokens: it gets its line.
// The open turns are read when this runs, after any usage.end already in the chain.
chainUsage(async () => { for (const k of [...u.baselines.keys()]) await finishTurn(u, k); });
// Every message still queued leaves it, so none holds a slot with no session to answer it, and
// the transcript says which: one the session took and never answered, or one it never read.
for (const m of queue.splice(0)) {
@@ -357,10 +869,19 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
if (!route || typeof route.admit !== "function") return { ok: false, code: "triage-no-route" };
const held = capUntil();
if (held !== null) return { ok: false, code: "triage-over-cap", until: held };
// A turn still being counted (a session that just ended mid-turn, or a usage.end in flight) is in
// the file before the count is read.
await usageChain;
const c = capNow();
// The store sits in the Triage directory: one that is a link or not the Console user's is the
// unsafe directory start would refuse, not an unreadable route.
if (c.state === "route-unreadable") return { ok: false, code: unsafeRoot() ? "triage-dir-unsafe" : "triage-route-unreadable" };
if (c.state === "usage-unreadable") return { ok: false, code: "triage-usage-unreadable" };
if (c.state === "over") return { ok: false, code: "triage-over-cap", until: c.resetsAt };
let a;
try { a = await route.admit(); } catch { return { ok: false, code: "triage-route-unreadable" }; }
if (a?.ok === true) return a;
const code = ["triage-no-route", "triage-over-cap"].includes(a?.code) ? a.code : "triage-route-refused";
const code = ["triage-no-route", "triage-over-cap", "triage-route-unreadable"].includes(a?.code) || Object.hasOwn(ROUTE_REFUSALS, a?.code ?? "") ? a.code : "triage-route-refused";
if (code !== "triage-over-cap") return { ok: false, code };
const until = typeof a.until === "string" && ISO_TIME.test(a.until) ? Date.parse(a.until) : NaN;
const ahead = until - now().getTime();
@@ -373,11 +894,18 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
paths,
get running() { return child !== null; },
get pid() { return child?.pid ?? null; },
routeSet: () => Boolean(route && typeof route.admit === "function"),
// A route that can say whether one is stored (triage-route.mjs isSet) answers for the store.
routeSet: () => Boolean(route && typeof route.admit === "function" && (typeof route.isSet !== "function" || route.isSet() === true)),
async state() {
const c = capNow();
const unset = c.state === "not set";
return {
route: this.routeSet() ? "set" : "not set",
overCapUntil: capUntil(),
overCapUntil: c.state === "over" ? c.resetsAt : capUntil(),
// #1873 triage-cap: today's count against the stored cap. Names and numbers only.
usageToday: unset ? "not set" : c.usageToday ?? "not read",
cap: unset ? "not set" : c.cap ? { limit: c.cap.limit, reset: c.cap.reset, timeZone: c.cap.timeZone } : "not read",
resetsAt: unset ? "not set" : c.resetsAt ?? "not read",
running: child !== null,
lastExit,
snapshot: last,
@@ -394,19 +922,27 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
if (text.length > MESSAGE_MAX) throw new TriageError("triage-message-too-long", `a message holds at most ${MESSAGE_MAX} characters`);
if (queue.length >= QUEUE_MAX) throw new TriageError("triage-busy", "Triage has too many messages waiting");
const admitted = await admit();
if (!admitted.ok) throw Object.assign(new TriageError(admitted.code, admitted.code === "triage-over-cap" ? "Triage is over its daily cap" : admitted.code === "triage-no-route" ? "no model route is set for Triage" : "the model route refused"), admitted.until ? { until: admitted.until } : {});
if (!admitted.ok) throw Object.assign(new TriageError(admitted.code, ADMIT_MESSAGES[admitted.code] ?? "the model route refused"), admitted.until ? { until: admitted.until } : {});
await refresh();
const at = now().toISOString();
const id = `owner-${randomBytes(6).toString("hex")}`;
append({ at, from: "owner", id, text });
// #1873 triage-wiring: every admitted answer passes the fences, a running session or not. One
// that fails launches nothing and the message is not queued.
let checked;
try { checked = await checkAdmitted(admitted); }
catch (e) {
try { append({ at: now().toISOString(), from: "host", in_reply_to: id, text: e?.code === "triage-route-invalid" ? ROUTE_REFUSED : NOT_STARTED }); } catch {}
throw e instanceof TriageError ? e : new TriageError("triage-route-invalid", "the model route's answer is not usable");
}
queue.push({ id, body: text, at, delivered: false });
if (!child) {
starting ??= start(admitted).finally(() => { starting = null; });
starting ??= start(checked).finally(() => { starting = null; });
try { await starting; }
catch (e) {
const i = queue.findIndex((m) => m.id === id);
if (i >= 0) queue.splice(i, 1);
try { append({ at: now().toISOString(), from: "host", in_reply_to: id, text: NOT_STARTED }); } catch {}
try { append({ at: now().toISOString(), from: "host", in_reply_to: id, text: e?.code === "triage-route-invalid" ? ROUTE_REFUSED : NOT_STARTED }); } catch {}
relay?.close();
relay = null;
log(`triage host: start failed: ${e.code ?? "error"}`);
@@ -426,6 +962,7 @@ export function createTriageHost({ dataRoot, route = null, readSnapshot = async
}
relay?.close();
relay = null;
await usageChain;
},
};
}
+8
View File
@@ -5,6 +5,8 @@
// needs --send and the same-origin checks the org admin routes use. No body, path, token or
// exception text reaches a response or a log line.
import { ROUTE_REFUSALS } from "./triage-host.mjs";
export const TRIAGE_PATHS = Object.freeze(["/api/triage", "/api/triage/message"]);
export const BODY_MAX = 16384;
// A read refreshes the snapshot when the one it holds is older than this.
@@ -21,6 +23,8 @@ const STATUS = Object.freeze({
"triage-route-invalid": 409,
"triage-over-cap": 429,
"triage-busy": 429,
// #1873 triage-wiring: the route's refusals. Each launches nothing; the drawer shows its line.
...Object.fromEntries(Object.keys(ROUTE_REFUSALS).map((code) => [code, 409])),
});
// Fixed words for each code; the host's own messages are fixed too, but the route never forwards text.
const MESSAGES = Object.freeze({
@@ -31,11 +35,13 @@ const MESSAGES = Object.freeze({
"triage-route-refused": "the model route refused to start Triage",
"triage-route-invalid": "the model route's answer is not usable",
"triage-route-unreadable": "the model route could not be read",
"triage-usage-unreadable": "Triage's token usage could not be read, so it takes no message",
"triage-over-cap": "Triage is over its daily token cap and starts again after the time shown",
"triage-busy": "Triage has too many messages waiting",
"triage-dir-unsafe": "a Triage directory is not safe to use",
"triage-start-failed": "the Triage session did not start",
"outcome-unknown": "Triage did not answer",
...ROUTE_REFUSALS,
});
const json = (res, status, value) => {
@@ -69,6 +75,8 @@ export async function triageView(triage, { send, now = Date.now } = {}) {
...(s.route === "set" ? {} : { routeMessage: NO_ROUTE_MESSAGE }),
overCapUntil: s.overCapUntil ?? null,
...(s.overCapUntil ? { capMessage: capMessage(s.overCapUntil) } : {}),
// #1873 triage-cap: today's count, the stored cap and the next reset, or "not set" / "not read".
...(Object.hasOwn(s, "usageToday") ? { usageToday: s.usageToday, cap: s.cap, resetsAt: s.resetsAt } : {}),
running: s.running,
lastExit: s.lastExit,
snapshot: s.snapshot,
+263
View File
@@ -0,0 +1,263 @@
// #1873 triage-settings: the owner's read and write of the Triage model route, for Settings > Triage.
// GET and POST /api/triage/route register through serve.mjs's route table, so the server's session
// and Origin checks run first; this module then takes the proxy-admin gate (the instance owner's own
// session on the public name, never a tester or a granted user) and the same-origin checks again.
// A write goes through the route store (triage-route-store.mjs), so the lock, the revision compare
// and the receipt are the store's. Before it, the model and harness are checked the way an
// organization's route change is (checkRoutes in packages/organization/src/launch-settings.mjs):
// offered by the catalogue, available, and compatible with the harness.
//
// The catalogue lives in each organization's bus (the trusted bus boot builds it; nothing outside
// a bus holds the proxy client), so the Console reads it through each active organization's
// `routes` verb, as the proxy setup page does, and merges the answers (mergeCatalogues).
//
// Saving a route starts nothing: the Triage host is not wired to the store in this slice.
// No key, path, env value or exception text reaches a response or a log line.
import { readdirSync, lstatSync } from 'node:fs';
import { join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { checkRoutes } from '../../organization/src/launch-settings.mjs';
import { isDailyModelQuota } from '../../plugins/src/model-quota.mjs';
import { readRoute, writeRoute } from './triage-route-store.mjs';
export const TRIAGE_ROUTE_PATH = '/api/triage/route';
export const BODY_MAX = 16384;
export const POST_KEYS = Object.freeze(['model', 'harness', 'cap', 'timeZone', 'revision']);
export const NOT_SET_MESSAGE = 'No Triage route is set.';
export const NOT_STARTED_NOTE = 'Saving a route does not start Triage. Triage also needs its key.';
const HARNESS_ROOT = fileURLToPath(new URL('../../plugins/harness/', import.meta.url));
// The same shapes the store holds (triage-route-store.mjs).
const MODEL_KEY = /^[a-z0-9][a-z0-9._-]{0,63}$/;
const HARNESS_NAME = /^[a-z][a-z0-9-]{0,31}$/;
const ACTOR = /^[a-z][a-z0-9-]{0,31}$/;
// The store's zone rule (its knownZone): isDailyModelQuota's zone shape, then Intl.
const knownZone = zone => typeof zone === 'string' && zone !== ''
&& isDailyModelQuota('000000000000', { limit: 0, since: '2000-01-01T00:00:00.000Z', reset: '00:00', timeZone: zone });
// The zone as Intl names it, so "america/chicago" is kept as "America/Chicago". A known zone that
// Intl renames to something the store would not take is kept as typed.
export function canonicalZone(zone) {
try {
const named = new Intl.DateTimeFormat('en-US', { timeZone: zone }).resolvedOptions().timeZone;
return knownZone(named) ? named : zone;
} catch { return zone; }
}
const STATUS = Object.freeze({
'human-required': 403,
'read-only': 403,
'cross-origin': 403,
'cross-site': 403,
'method-not-allowed': 405,
'invalid-request': 400,
'triage-cap-invalid': 400,
'triage-zone-required': 400,
'triage-zone-unknown': 400,
'unknown-model': 400,
'model-harness-incompatible': 400,
'harness-off': 400,
'triage-route-invalid': 400,
'triage-route-stale': 409,
'triage-route-busy': 409,
'model-provider-unavailable': 503,
'triage-route-unreadable': 503,
'triage-route-unrecorded': 500,
'outcome-unknown': 503,
});
// Fixed words for each code. The store's own messages name lock files, so none is forwarded.
const MESSAGES = Object.freeze({
'human-required': 'Only the instance owner can read or set the Triage route.',
'read-only': 'This Console was started without writes, so the route cannot be saved.',
'cross-origin': 'The request did not come from this Console page.',
'cross-site': 'The request did not come from this Console page.',
'method-not-allowed': 'This address takes GET and POST only.',
'invalid-request': 'The request is not a Triage route. It takes model, harness, cap, timeZone and revision.',
'triage-cap-invalid': 'The cap must be a whole number of tokens, 1 or more.',
'triage-zone-required': 'A time zone is required. There is no default.',
'triage-zone-unknown': 'That time zone is not known. Use a name like Europe/Berlin or America/Chicago.',
'unknown-model': 'The model catalogue does not offer that model.',
'model-harness-incompatible': 'That harness cannot run that model.',
'harness-off': 'No harness module of that name is installed.',
'triage-route-invalid': 'The route was refused as invalid.',
'triage-route-stale': 'The route changed since this page read it. Reload the route before saving again.',
'triage-route-busy': 'Another save of the route is in progress. Try again.',
'model-provider-unavailable': 'The model catalogue cannot confirm that model now, so the route was not saved.',
'triage-route-unreadable': 'The stored route could not be read.',
'triage-route-unrecorded': 'The route was saved, but its receipt line was not written.',
'outcome-unknown': 'The route service did not answer.',
});
const json = (res, status, value) => {
res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
res.end(JSON.stringify(value));
};
const one = (req, name) => (req.headersDistinct[name]?.length === 1 ? req.headersDistinct[name][0] : null);
const plain = v => v !== null && typeof v === 'object' && !Array.isArray(v);
const identity = m => JSON.stringify([m.provider, m.model, m.module, m.upstream]);
// The installed harness modules: a directory under packages/plugins/harness with an index.mjs.
export function installedHarnesses(root = HARNESS_ROOT) {
try {
return readdirSync(root).filter(name => HARNESS_NAME.test(name) && (() => {
try { return lstatSync(join(root, name, 'index.mjs')).isFile(); } catch { return false; }
})()).sort();
} catch { return []; }
}
// Each active organization's catalogue, merged into the one the Triage route is checked against.
// Only ready answers count. A key is offered when a ready catalogue lists it, and dropped when two
// catalogues disagree on what it is (provider, model, module, upstream). It is available only when
// every catalogue listing it says so, and its harnesses are those every listing names that are
// installed here. Status is ready when one catalogue is; otherwise the first status seen.
export function mergeCatalogues(list, harnesses) {
const ready = (Array.isArray(list) ? list : []).filter(c => c?.status === 'ready' && Array.isArray(c.models));
if (!ready.length) {
const first = (Array.isArray(list) ? list : []).find(c => typeof c?.status === 'string')?.status;
return { status: first && first !== 'ready' ? first : 'unavailable', models: [] };
}
const merged = new Map(), dropped = new Set();
for (const catalogue of ready) {
for (const m of catalogue.models) {
if (!plain(m) || typeof m.key !== 'string' || !MODEL_KEY.test(m.key) || dropped.has(m.key)) continue;
const names = Array.isArray(m.harnesses) ? m.harnesses.filter(h => typeof h === 'string') : [];
const held = merged.get(m.key);
if (!held) {
merged.set(m.key, { key: m.key, label: typeof m.label === 'string' && m.label ? m.label : m.key, provider: m.provider, model: m.model, module: m.module, upstream: m.upstream, available: m.available === true, harnesses: names });
continue;
}
if (identity(held) !== identity(m)) { merged.delete(m.key); dropped.add(m.key); continue; }
held.available = held.available && m.available === true;
held.harnesses = held.harnesses.filter(h => names.includes(h));
}
}
const installed = new Set(harnesses);
const models = [...merged.values()].map(m => ({ ...m, harnesses: m.harnesses.filter(h => installed.has(h)) })).sort((a, b) => a.key.localeCompare(b.key));
return { status: 'ready', models };
}
// The organization route check, called as it is for an organization's change: one role whose
// vars name the harness and model, launch.models holding the catalogue's own entry for that key
// (none when it is not offered), plugins.harness the installed harness modules, and
// plugins.model-provider the entry's module. It throws unknown-model, model-provider-unavailable,
// model-harness-incompatible or harness-off.
export function checkTriageRoute({ model, harness, catalogue, harnesses }) {
if (catalogue?.status !== 'ready') {
const error = new Error('model-provider-unavailable'); error.code = 'model-provider-unavailable'; throw error;
}
const offered = catalogue.models.find(m => m.key === model) ?? null;
const entry = offered ? { provider: offered.provider, model: offered.model, module: offered.module, upstream: offered.upstream } : null;
checkRoutes({
proposed: {
roles: { triage: { vars: { harness, model } } },
launch: { models: entry ? { [model]: entry } : {} },
plugins: { harness: [...harnesses], 'model-provider': entry ? [entry.module] : [] },
},
old: null,
levels: () => null,
catalogue,
});
}
// What the signed-in owner is recorded as: their account id, or the dev local owner's subject.
export function ownerActor(session) {
if (typeof session?.account === 'string' && ACTOR.test(session.account)) return session.account;
if (session?.provider === 'local-dev' && typeof session.sub === 'string' && ACTOR.test(session.sub)) return session.sub;
return null;
}
const view = doc => doc ? {
model: doc.model, harness: doc.harness, cap: doc.cap.limit, reset: doc.cap.reset, timeZone: doc.cap.timeZone,
revision: doc.revision, updatedAt: doc.updatedAt,
} : null;
// The panel's choices: no provider, upstream or module, only what a select shows.
const choices = catalogue => ({
status: catalogue.status,
models: catalogue.models.map(m => ({ key: m.key, label: m.label, available: m.available, harnesses: [...m.harnesses] })),
});
async function readBody(req) {
if ((req.headers['content-type'] ?? '').split(';')[0].trim().toLowerCase() !== 'application/json') throw Error();
const chunks = [];
let size = 0;
for await (const chunk of req) {
size += chunk.length;
if (size > BODY_MAX) throw Error();
chunks.push(chunk);
}
const value = JSON.parse(Buffer.concat(chunks));
if (!plain(value) || Object.keys(value).some(k => !POST_KEYS.includes(k))) throw Error();
return value;
}
// Registers both routes. `catalogues` returns each active organization's `routes` catalogue (or a
// status when its bus did not answer); `harnesses` lists the installed harness modules.
export function triageRouteRoutes({ dataRoot, catalogues, harnesses = installedHarnesses, log = () => {} }) {
async function catalogue() {
let list;
try { list = await catalogues(); } catch { list = []; }
return mergeCatalogues(list, harnesses());
}
async function handle(req, res, context) {
const done = (status, value) => {
// Method, path and status only.
log(`${new Date().toISOString()} ${req.method} ${TRIAGE_ROUTE_PATH} ${status}`);
return json(res, status, value);
};
const refuse = (code, extra = {}) => done(STATUS[code] ?? 503, { error: code, message: MESSAGES[code] ?? MESSAGES['outcome-unknown'], ...extra });
if (req.method !== 'GET' && req.method !== 'POST') return refuse('method-not-allowed');
// The proxy-admin gate: the instance owner's own session, never a tester or a granted user.
if (context.owner !== true || !context.session) return refuse('human-required');
// A write needs this Console's Origin and same-origin Fetch Metadata, exactly once each. A read
// refuses another site's Origin or Fetch Metadata and lets their absence through, as the packs and
// request reads do: a browser sends no Origin on a same-origin GET, and Chromium sends no
// Fetch Metadata to a LAN http origin (serve.mjs marks only a LAN write).
if (req.method === 'POST') {
if (one(req, 'origin') !== context.origin) return refuse('cross-origin');
if (one(req, 'sec-fetch-site') !== 'same-origin') return refuse('cross-site');
} else {
if (req.headersDistinct.origin && one(req, 'origin') !== context.origin) return refuse('cross-origin');
if (req.headersDistinct['sec-fetch-site'] && !['same-origin', 'none'].includes(one(req, 'sec-fetch-site'))) return refuse('cross-site');
}
if (req.method === 'GET') {
let doc;
try { doc = readRoute(dataRoot); } catch (error) { return refuse(error?.code === 'triage-route-unreadable' ? 'triage-route-unreadable' : 'outcome-unknown'); }
const route = view(doc);
return done(200, {
route, ...(route ? {} : { routeMessage: NOT_SET_MESSAGE }), revision: route ? route.revision : 0,
choices: choices(await catalogue()), send: context.send === true, note: NOT_STARTED_NOTE,
});
}
if (context.send !== true) return refuse('read-only');
let body;
try { body = await readBody(req); } catch { return refuse('invalid-request'); }
const { model, harness, cap, timeZone, revision } = body;
if (typeof model !== 'string' || !MODEL_KEY.test(model)) return refuse('unknown-model');
if (typeof harness !== 'string' || !HARNESS_NAME.test(harness)) return refuse('harness-off');
if (!Number.isSafeInteger(cap) || cap < 1) return refuse('triage-cap-invalid');
if (timeZone === undefined || timeZone === null || timeZone === '') return refuse('triage-zone-required');
if (!knownZone(timeZone)) return refuse('triage-zone-unknown');
const zone = canonicalZone(timeZone);
if (!Number.isSafeInteger(revision) || revision < 0) return refuse('invalid-request');
try { checkTriageRoute({ model, harness, catalogue: await catalogue(), harnesses: harnesses() }); }
catch (error) {
const code = ['unknown-model', 'model-provider-unavailable', 'model-harness-incompatible', 'harness-off'].includes(error?.code) ? error.code : 'outcome-unknown';
return refuse(code);
}
const by = ownerActor(context.session);
if (by === null) return refuse('human-required');
try {
const doc = writeRoute(dataRoot, { model, harness, limit: cap, timeZone: zone, by, revision });
return done(200, { route: view(doc), revision: doc.revision, note: NOT_STARTED_NOTE });
} catch (error) {
const code = typeof error?.code === 'string' && Object.hasOwn(MESSAGES, error.code) && error.code.startsWith('triage-route-') ? error.code : 'outcome-unknown';
if (code !== 'triage-route-stale') return refuse(code);
let stored = null;
try { stored = view(readRoute(dataRoot)); } catch { /* the conflict still stands */ }
return refuse(code, { revision: stored ? stored.revision : 0 });
}
}
return registered => {
registered.add('GET', TRIAGE_ROUTE_PATH, handle);
registered.add('POST', TRIAGE_ROUTE_PATH, handle);
};
}
+271
View File
@@ -0,0 +1,271 @@
// #1873 triage-route-store: the owner-only file that holds Triage's model route and daily cap,
// <dataRoot>/triage/route.json (design report reports/triage-route-design.md section 1, option C).
//
// { version, revision, model, harness, cap: { limit, since, reset, timeZone }, updatedAt, updatedBy }
//
// Names only: a catalogue model key and a harness name. No env value and no key ever enter this
// file; the host derives env, mounts and the adapter itself (a later slice). Nothing here is wired
// into the Triage host or the Console yet: the Console keeps `route: null`.
//
// Fail closed. The triage directory is 0700 and route.json 0600, both owned by the running user;
// a link, a hard link, a non-file, a wrong mode or owner, an unknown field or an unknown time zone
// refuses. A write is compare-and-set on `revision` under an exclusive lock file, atomic (a 0600
// temp file in the same directory, fsync, rename, fsync of the directory), and appends one line
// to route-receipts.jsonl. Files and the directory the store makes get their modes set on the open
// descriptor, so the owner's umask cannot leave them unreadable. A writer that dies leaves its lock; the next write refuses and names
// it, and the person removes it by hand, as with the organization lifecycle fence.
//
// Choices Jason may still reverse each live in one place: the file location (routePaths), the
// field names (ROUTE_FIELDS, CAP_FIELDS) and the reset rule (capFor).
import { closeSync, constants, fchmodSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeSync } from "node:fs";
import { randomBytes } from "node:crypto";
import { join } from "node:path";
import { isDailyModelQuota } from "../../plugins/src/model-quota.mjs";
import { processState } from "../../seat/src/process-state.mjs";
export const ROUTE_VERSION = 1;
export const ROUTE_FIELDS = Object.freeze(["version", "revision", "model", "harness", "cap", "updatedAt", "updatedBy"]);
export const CAP_FIELDS = Object.freeze(["limit", "since", "reset", "timeZone"]);
// The catalogue's model key shape (packages/bus/src/model-catalogue.mjs validId) and the Triage
// host's harness name shape (packages/webui/src/triage-host.mjs HARNESS_NAME).
const MODEL_KEY = /^[a-z0-9][a-z0-9._-]{0,63}$/;
const HARNESS_NAME = /^[a-z][a-z0-9-]{0,31}$/;
const ACTOR = /^[a-z][a-z0-9-]{0,31}$/;
const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
// isDailyModelQuota checks one leaf under a twelve-hex key; the Triage cap has no key of its own.
const LEAF_KEY = "000000000000";
const MAX_BYTES = 64 * 1024;
const INPUT_FIELDS = Object.freeze(["model", "harness", "limit", "timeZone", "by", "revision"]);
export class RouteStoreError extends Error {
constructor(code, message) {
super(message);
this.name = "RouteStoreError";
this.code = code;
}
}
const unreadable = (why) => new RouteStoreError("triage-route-unreadable", `the Triage route store is unreadable: ${why}`);
const invalid = (why) => new RouteStoreError("triage-route-invalid", `the Triage route is invalid: ${why}`);
// The file location, in one place.
export function routePaths(dataRoot) {
const dir = join(dataRoot, "triage");
return { dir, file: join(dir, "route.json"), receipts: join(dir, "route-receipts.jsonl"), lock: join(dir, "route.lock") };
}
// The reset rule, in one place: the day resets at 00:00 in the owner's zone, which has no default.
// A first cap counts from now; a changed cap keeps its stored `since`, as an organization's token
// limits do (packages/organization/src/launch-settings.mjs stamp), so lowering the cap never drops
// the tokens already spent today. Only a reset would move it, and this slice has no reset verb.
export function capFor({ limit, timeZone, previous, now }) {
return { limit, since: previous ? previous.since : now, reset: "00:00", timeZone };
}
const plain = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
const exactKeys = (v, keys) => plain(v) && Object.keys(v).length === keys.length && keys.every((k) => Object.hasOwn(v, k));
const canonicalTime = (s) => typeof s === "string" && ISO.test(s) && !Number.isNaN(Date.parse(s)) && new Date(s).toISOString() === s;
// The same zone rule the stored cap is held to (isDailyModelQuota: its zone shape, then Intl).
const knownZone = (zone) => typeof zone === "string"
&& isDailyModelQuota(LEAF_KEY, { limit: 0, since: "2000-01-01T00:00:00.000Z", reset: "00:00", timeZone: zone });
export function validRoute(doc) {
return exactKeys(doc, ROUTE_FIELDS)
&& doc.version === ROUTE_VERSION
&& Number.isSafeInteger(doc.revision) && doc.revision >= 1
&& typeof doc.model === "string" && MODEL_KEY.test(doc.model)
&& typeof doc.harness === "string" && HARNESS_NAME.test(doc.harness)
// isDailyModelQuota also checks that the zone is one Intl knows.
&& exactKeys(doc.cap, CAP_FIELDS) && isDailyModelQuota(LEAF_KEY, doc.cap)
&& canonicalTime(doc.updatedAt)
&& typeof doc.updatedBy === "string" && ACTOR.test(doc.updatedBy);
}
const uidOf = (opts) => opts.uid ?? process.getuid();
// The owner the files are held to: the same user, unless a test checks the file owner alone.
const fileUidOf = (opts) => opts.fileUid ?? uidOf(opts);
// The triage directory: a real directory, the running user's, mode 0700. Returns false when it is
// missing and `create` is off; with `create` it makes it (never the data root above it).
function checkDir(dir, uid, { create }) {
let st;
try { st = lstatSync(dir); }
catch (e) {
if (e.code !== "ENOENT") throw unreadable("the triage directory cannot be read");
if (!create) return false;
try { mkdirSync(dir, { mode: 0o700 }); } catch { throw unreadable("the triage directory cannot be made"); }
// The umask may have narrowed the mode; set it on the directory just made, never through a link.
try {
const fd = openSync(dir, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
try { fchmodSync(fd, 0o700); } finally { closeSync(fd); }
} catch { throw unreadable("the triage directory cannot be made"); }
st = lstatSync(dir);
}
if (st.isSymbolicLink()) throw unreadable("the triage directory is a link");
if (!st.isDirectory()) throw unreadable("the triage directory is not a directory");
if (st.uid !== uid) throw unreadable("the triage directory is not owned by this user");
if ((st.mode & 0o777) !== 0o700) throw unreadable("the triage directory mode is not 0700");
return true;
}
// An opened file's own checks: a regular file, one link, the running user's, mode 0600.
function checkFile(fd, uid, what) {
const st = fstatSync(fd);
if (!st.isFile()) throw unreadable(`${what} is not a regular file`);
if (st.nlink !== 1) throw unreadable(`${what} has more than one link`);
if (st.uid !== uid) throw unreadable(`${what} is not owned by this user`);
if ((st.mode & 0o777) !== 0o600) throw unreadable(`${what} mode is not 0600`);
return st;
}
function readFile(file, uid) {
let fd;
try { fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
catch (e) {
if (e.code === "ENOENT") return null;
if (e.code === "ELOOP") throw unreadable("route.json is a link");
throw unreadable("route.json cannot be opened");
}
try {
const st = checkFile(fd, uid, "route.json");
if (st.size > MAX_BYTES) throw unreadable("route.json is too large");
let doc;
try { doc = JSON.parse(readFileSync(fd, "utf8")); } catch { throw unreadable("route.json is not JSON"); }
if (!validRoute(doc)) throw unreadable("route.json does not match the route shape");
return doc;
} finally { closeSync(fd); }
}
// The stored route, or null when none is set. Throws triage-route-unreadable on anything unsafe.
export function readRoute(dataRoot, opts = {}) {
const { dir, file } = routePaths(dataRoot);
if (!checkDir(dir, uidOf(opts), { create: false })) return null;
return readFile(file, fileUidOf(opts));
}
function checkInput(input) {
if (!plain(input)) throw invalid("the input is not an object");
for (const k of Object.keys(input)) if (!INPUT_FIELDS.includes(k)) throw invalid(`unknown field ${k}`);
if (typeof input.model !== "string" || !MODEL_KEY.test(input.model)) throw invalid("model must be a catalogue model key");
if (typeof input.harness !== "string" || !HARNESS_NAME.test(input.harness)) throw invalid("harness must be a harness name");
if (!Number.isSafeInteger(input.limit) || input.limit < 0) throw invalid("the cap must be a whole number of tokens, 0 or more");
if (input.timeZone === undefined) throw invalid("a time zone is required");
if (!knownZone(input.timeZone)) throw invalid("the time zone is unknown");
if (typeof input.by !== "string" || !ACTOR.test(input.by)) throw invalid("the actor name is invalid");
if (input.revision !== undefined && (!Number.isSafeInteger(input.revision) || input.revision < 0)) throw invalid("revision must be a whole number, 0 or more");
}
function holderLine(lock) {
let holder = null;
try {
const fd = openSync(lock, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
try { holder = JSON.parse(readFileSync(fd, "utf8")); } finally { closeSync(fd); }
} catch { holder = null; }
if (!Number.isSafeInteger(holder?.pid) || holder.pid <= 0) return `another write holds ${lock}, or a writer left it; remove it by hand once no write is running`;
let alive;
try { alive = processState(holder.pid).alive; } catch { alive = null; }
if (alive === false) return `a writer that is not running (pid ${holder.pid}) left ${lock}; remove it by hand`;
return `another write (pid ${holder.pid}) holds ${lock}; try again when it ends`;
}
function takeLock(lock) {
let fd;
try { fd = openSync(lock, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600); }
catch (e) {
if (e.code === "EEXIST") throw new RouteStoreError("triage-route-busy", `the Triage route is busy: ${holderLine(lock)}`);
throw unreadable("the lock cannot be made");
}
try {
writeSync(fd, `${JSON.stringify({ pid: process.pid, at: new Date().toISOString() })}\n`);
return { fd, st: fstatSync(fd) };
} catch (e) {
closeSync(fd);
try { unlinkSync(lock); } catch {}
throw unreadable("the lock cannot be written");
}
}
function dropLock(lock, held) {
try {
const now = lstatSync(lock);
if (now.dev === held.st.dev && now.ino === held.st.ino) unlinkSync(lock);
} catch {}
closeSync(held.fd);
}
// The receipts file, opened for append before the route changes, so a bad one refuses first. An
// existing file is held to its checks as it is; only a file made here gets its mode set.
function openReceipts(receipts, uid) {
const flags = constants.O_WRONLY | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK;
let fd;
try { fd = openSync(receipts, flags); }
catch (e) {
if (e.code === "ELOOP") throw unreadable("route-receipts.jsonl is a link");
if (e.code !== "ENOENT") throw unreadable("route-receipts.jsonl cannot be opened");
try { fd = openSync(receipts, flags | constants.O_CREAT | constants.O_EXCL, 0o600); }
catch { throw unreadable("route-receipts.jsonl cannot be made"); }
try { fchmodSync(fd, 0o600); } catch { closeSync(fd); throw unreadable("route-receipts.jsonl cannot be made"); }
}
try { checkFile(fd, uid, "route-receipts.jsonl"); } catch (e) { closeSync(fd); throw e; }
return fd;
}
const summary = (doc) => (doc ? { model: doc.model, harness: doc.harness, cap: doc.cap } : null);
// Set the route. input: { model, harness, limit, timeZone, by, revision? }. With `revision` the
// write happens only if the stored revision equals it (0: only when no route is set yet); without
// it, the revision read under the lock. Returns the new route.
// opts.now, opts.uid and opts.fileUid are for tests; opts.hook(stage) is a test seam at "write"
// (inside the temp write), "crash" (after the temp file is written), "before-rename" and
// "after-rename" (before the receipt line). A failure after the rename refuses as
// triage-route-unrecorded: the route did change, and its receipt line is missing.
export function writeRoute(dataRoot, input, opts = {}) {
checkInput(input);
const { dir, file, receipts, lock } = routePaths(dataRoot);
const uid = uidOf(opts);
const fileUid = fileUidOf(opts);
const now = (opts.now ?? (() => new Date()))().toISOString();
const hook = opts.hook ?? (() => {});
checkDir(dir, uid, { create: true });
const held = takeLock(lock);
try {
const current = readFile(file, fileUid);
const stored = current?.revision ?? 0;
if (input.revision !== undefined && input.revision !== stored) {
throw new RouteStoreError("triage-route-stale", `the Triage route changed: the stored revision is ${stored}, not ${input.revision}`);
}
const next = {
version: ROUTE_VERSION, revision: stored + 1, model: input.model, harness: input.harness,
cap: capFor({ limit: input.limit, timeZone: input.timeZone, previous: current?.cap ?? null, now }),
updatedAt: now, updatedBy: input.by,
};
if (!validRoute(next)) throw invalid("the new route does not match the route shape");
const receiptFd = openReceipts(receipts, fileUid);
try {
const temp = join(dir, `.route.json.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
let tfd;
try { tfd = openSync(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600); }
catch { throw unreadable("route.json cannot be written"); }
try {
try {
fchmodSync(tfd, 0o600);
hook("write");
writeSync(tfd, `${JSON.stringify(next, null, 2)}\n`);
fsyncSync(tfd);
} finally { closeSync(tfd); }
} catch { try { unlinkSync(temp); } catch {} throw unreadable("route.json cannot be written"); }
hook("crash");
hook("before-rename");
try { renameSync(temp, file); } catch (e) { try { unlinkSync(temp); } catch {} throw unreadable("route.json cannot be replaced"); }
try {
hook("after-rename");
const dfd = openSync(dir, constants.O_RDONLY | constants.O_DIRECTORY);
try { fsyncSync(dfd); } finally { closeSync(dfd); }
writeSync(receiptFd, `${JSON.stringify({ at: now, by: input.by, revision: next.revision, from: summary(current), to: summary(next) })}\n`);
fsyncSync(receiptFd);
} catch {
throw new RouteStoreError("triage-route-unrecorded", `the Triage route changed to revision ${next.revision}, but its receipt line was not written`);
}
} finally { closeSync(receiptFd); }
return next;
} finally { dropLock(lock, held); }
}
+245
View File
@@ -0,0 +1,245 @@
// #1873 triage-wiring: the Triage host's model route, resolved again at each admit (design report
// reports/triage-route-design.md slice 5). Four sources, each read fresh:
// the route store harness name, model key and cap (triage-route-store.mjs)
// the key file <configDir>/secrets/triage/model (packages/cli/src/triage-key-file.mjs, the
// key verbs' own reader and checks; never the module that holds the proxy client)
// the model catalogue model and provider for the key, read from each active organization's bus
// `routes` verb and merged (mergeCatalogues), then held to checkRoutes, the
// check an organization's route change runs: offered, available, compatible
// the harness module adapter, turnEnd, mounts and harnessEnv (packages/plugins/harness/<name>)
// proxy.json the proxy's port, read at each admit (proxyPort may be a function)
// the provider module the route's transport for this harness (packages/plugins/model-provider/
// <module>, route()), the check a bus launch runs: a model the provider holds
// off the harness (an OAuth Claude model on pi) is triage-harness-incompatible
// The answer's env holds ANTHROPIC_BASE_URL (the instance proxy on 127.0.0.1) and the Triage key
// under the one name the harness takes it by (ROUTE_KEY_NAMES: claude-code's ANTHROPIC_AUTH_TOKEN,
// pi's ANTHROPIC_API_KEY). harnessEnv holds only the module's own names that the host's fence takes
// (refusedHarnessName): no MOSAIC_* name, which the host sets itself from the module's bundle() and
// env() (triage-host.mjs). #1873 harness-matrix: a harness runs Triage when it has bundle() and env()
// and meets one contract, with no list of harness names: env() given a stand-in proxy puts the
// stand-in's key, unchanged, in exactly one ROUTE_KEY_NAMES name and nowhere else, and names the
// stand-in's URL only as ANTHROPIC_BASE_URL, if at all. A harness that takes the URL through its own
// file (pi's models.json) is held to that at the host, which checks the file bundle() writes. The
// host runs its fences on every answer (triage-host.mjs checkAdmitted), so nothing here is trusted
// on its own.
//
// Each refusal is a code from ROUTE_REFUSALS (triage-host.mjs) with a fixed plain line. No code or line carries a path,
// a key or an env value. Whether the key is in the proxy's list cannot be known without the proxy
// management client, which the Console never loads, so that is not checked here: a key the proxy does
// not hold fails at the model call.
import { connect } from "node:net";
import { lstatSync, readdirSync } from "node:fs";
import { join } from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
import { checkRoutes } from "../../organization/src/launch-settings.mjs";
import { SECRET, keyPrefix, readKey } from "../../cli/src/triage-key-file.mjs";
import { readRoute } from "./triage-route-store.mjs";
import { ROUTE_KEY_NAMES, ROUTE_REFUSALS, refusedHarnessName } from "./triage-host.mjs";
import { checkedTransport } from "../../harness/src/bundle.mjs";
export { ROUTE_REFUSALS };
const HARNESS_ROOT = fileURLToPath(new URL("../../plugins/harness/", import.meta.url));
const PROVIDER_ROOT = fileURLToPath(new URL("../../plugins/model-provider/", import.meta.url));
const HARNESS_NAME = /^[a-z][a-z0-9-]{0,31}$/;
const MODEL_KEY = /^[a-z0-9][a-z0-9._-]{0,63}$/;
export const PROBE_TIMEOUT_MS = 1000;
const refuse = (code) => ({ ok: false, code });
// The stand-in proxy env() is asked about. Neither value is a real URL or key.
const PROXY_PROBE = Object.freeze({ baseUrl: "http://127.0.0.1:9", key: "triage-route-probe-key" });
// The name env(), given the stand-in proxy, takes the key by, or null. The key goes unchanged into
// exactly one ROUTE_KEY_NAMES name and is in no other value; the URL is in no value but
// ANTHROPIC_BASE_URL, which, when present, is the stand-in's URL.
export const routeKeyName = (given) => {
if (!plain(given)) return null;
const holders = Object.entries(given).filter(([, v]) => String(v).includes(PROXY_PROBE.key));
if (holders.length !== 1 || !ROUTE_KEY_NAMES.includes(holders[0][0]) || holders[0][1] !== PROXY_PROBE.key) return null;
if (given.ANTHROPIC_BASE_URL !== undefined && given.ANTHROPIC_BASE_URL !== PROXY_PROBE.baseUrl) return null;
if (Object.entries(given).some(([k, v]) => k !== "ANTHROPIC_BASE_URL" && String(v).includes(PROXY_PROBE.baseUrl))) return null;
return holders[0][0];
};
const validPort = (p) => Number.isInteger(p) && p > 0 && p <= 65535;
const plain = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
const identity = (m) => JSON.stringify([m.provider, m.model, m.module, m.upstream]);
// The whole shape of this instance's Triage key, for the host's tokenPattern fence.
export const triageTokenPattern = (configDir) => new RegExp(keyPrefix(configDir).replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + SECRET.source.replace(/^\^|\$$/g, ""));
// The installed harness modules: a directory under packages/plugins/harness with an index.mjs.
export function installedHarnesses(root = HARNESS_ROOT) {
try {
return readdirSync(root).filter((name) => HARNESS_NAME.test(name) && (() => {
try { return lstatSync(join(root, name, "index.mjs")).isFile(); } catch { return false; }
})()).sort();
} catch { return []; }
}
// The repository's harness module of that name, or null.
export async function repoHarnessModule(name, root = HARNESS_ROOT) {
if (!HARNESS_NAME.test(name)) return null;
const file = join(root, name, "index.mjs");
try { if (!lstatSync(file).isFile()) return null; } catch { return null; }
return import(pathToFileURL(file).href);
}
// The repository's model-provider module of that name, or null.
export async function repoProviderModule(name, root = PROVIDER_ROOT) {
if (!HARNESS_NAME.test(name ?? "")) return null;
const file = join(root, name, "index.mjs");
try { if (!lstatSync(file).isFile()) return null; } catch { return null; }
return import(pathToFileURL(file).href);
}
// Each active organization's catalogue, merged into one. Only ready answers count. A key is offered
// when a ready catalogue lists it, and dropped when two disagree on what it is (provider, model,
// module, upstream). It is available only when every catalogue listing it says so, and its harnesses
// are those every listing names that are installed here. Status is ready when one catalogue is;
// otherwise the first status seen. The triage-settings lane's Settings check merges the same way.
export function mergeCatalogues(list, harnesses) {
const all = Array.isArray(list) ? list : [];
const ready = all.filter((c) => c?.status === "ready" && Array.isArray(c.models));
if (!ready.length) {
const first = all.find((c) => typeof c?.status === "string")?.status;
return { status: first && first !== "ready" ? first : "unavailable", models: [] };
}
const merged = new Map();
const dropped = new Set();
for (const catalogue of ready) {
for (const m of catalogue.models) {
if (!plain(m) || typeof m.key !== "string" || !MODEL_KEY.test(m.key) || dropped.has(m.key)) continue;
const names = Array.isArray(m.harnesses) ? m.harnesses.filter((h) => typeof h === "string") : [];
const held = merged.get(m.key);
if (!held) {
merged.set(m.key, { key: m.key, provider: m.provider, model: m.model, module: m.module, upstream: m.upstream, available: m.available === true, harnesses: names });
continue;
}
if (identity(held) !== identity(m)) { merged.delete(m.key); dropped.add(m.key); continue; }
held.available = held.available && m.available === true;
held.harnesses = held.harnesses.filter((h) => names.includes(h));
}
}
const installed = new Set(harnesses);
const models = [...merged.values()].map((m) => ({ ...m, harnesses: m.harnesses.filter((h) => installed.has(h)) }));
return { status: "ready", models };
}
// Does something accept a connection on 127.0.0.1:port within the timeout? Nothing is sent.
export function probePort(port, { timeoutMs = PROBE_TIMEOUT_MS } = {}) {
return new Promise((resolve) => {
const sock = connect({ host: "127.0.0.1", port });
const done = (ok) => { sock.destroy(); resolve(ok); };
sock.setTimeout(timeoutMs, () => done(false));
sock.once("connect", () => done(true));
sock.once("error", () => done(false));
});
}
// The organization route check for the stored route against the merged catalogue: null when it
// passes, else the refusal code.
export function checkModel({ model, harness, catalogue, harnesses }) {
// No ready catalogue: whether the model is offered is not known, which is its own refusal.
if (catalogue.status !== "ready") return "triage-catalogue-unavailable";
const offered = catalogue.models.find((m) => m.key === model);
const entry = offered && typeof offered.module === "string" && offered.module
? { provider: offered.provider, model: offered.model, module: offered.module, upstream: offered.upstream } : null;
if (!entry) return "triage-model-not-offered";
const proposed = {
roles: { triage: { vars: { harness, model } } },
launch: { models: { [model]: entry } },
plugins: { harness: [...harnesses], "model-provider": [entry.module] },
};
try {
checkRoutes({ proposed, old: null, levels: () => null, catalogue });
return null;
} catch (e) {
// unknown-model, model-provider-unavailable, an unavailable model, or anything else: not offered.
if (e?.code === "model-harness-incompatible" || e?.code === "harness-off") return "triage-harness-incompatible";
return "triage-model-not-offered";
}
}
// createTriageRoute({ dataRoot, configDir, proxyPort, catalogues, harnessModule, providerModule, probe, env, installed })
// proxyPort the instance proxy's port (proxy.json), or null when none is configured; or a
// function that answers it, called at each admit
// catalogues async () -> [catalogue] each active organization's `routes` catalogue
// harnessModule async (name) -> the harness module or null; the repository's by default
// providerModule async (name) -> the model-provider module or null; the repository's by default
// probe async (port) -> true when the proxy accepts a connection
// env the Console's environment, for the module's mounts (MOSAIC_CLAUDE_BIN)
// installed () -> the installed harness names
// Returns { isSet(), admit() }. isSet answers whether a route is stored (an unreadable store counts
// as set, so the read does not hide it; admit refuses it).
export function createTriageRoute({ dataRoot, configDir, proxyPort = null, catalogues = async () => [], harnessModule = repoHarnessModule, providerModule = repoProviderModule, probe = probePort, env = process.env, installed = installedHarnesses, keyOptions = {} }) {
if (typeof dataRoot !== "string" || !dataRoot.startsWith("/")) throw new TypeError("dataRoot must be an absolute path");
if (typeof configDir !== "string" || !configDir.startsWith("/")) throw new TypeError("configDir must be an absolute path");
if (proxyPort !== null && typeof proxyPort !== "function" && !validPort(proxyPort)) throw new TypeError("proxyPort must be a port number, null or a function");
return {
isSet() {
try { return readRoute(dataRoot) !== null; } catch { return true; }
},
async admit() {
// 1. The stored route. Unreadable is the host's own code (it also checks the store first).
let stored;
try { stored = readRoute(dataRoot); } catch { return refuse("triage-route-unreadable"); }
if (!stored) return refuse("triage-no-route");
// 2. The key, with the key verbs' checks: a regular file, one link, this user's, 0600, both
// directories 0700, no link, no FIFO (O_NONBLOCK, then the regular-file check).
let record;
try { record = readKey(configDir, keyOptions); } catch { return refuse("triage-key-unsafe"); }
if (!record) return refuse("triage-key-missing");
// 3. The proxy, on this machine, at the port proxy.json names now.
let port = null;
try { port = typeof proxyPort === "function" ? await proxyPort() : proxyPort; } catch { port = null; }
if (!validPort(port)) return refuse("triage-proxy-down");
let up = false;
try { up = await probe(port); } catch { up = false; }
if (up !== true) return refuse("triage-proxy-down");
// 4. The model: offered, available, and runnable on the harness.
const harnesses = installed();
let list = [];
try { list = await catalogues(); } catch { list = []; }
const catalogue = mergeCatalogues(list, harnesses);
const failed = checkModel({ model: stored.model, harness: stored.harness, catalogue, harnesses });
if (failed) return refuse(failed);
const offered = catalogue.models.find((m) => m.key === stored.model);
// #1873 harness-matrix: the provider's own route for this harness, as a bus launch asks it, so
// a stale catalogue row that names a harness the provider now holds the model off is refused.
// A provider with no route() gives no transport; a harness that needs one then fails below.
let transport = null;
let provider = null;
try { provider = await providerModule(offered.module); } catch { provider = null; }
if (typeof provider?.route === "function") {
const entry = { provider: offered.provider, model: offered.model, module: offered.module, upstream: offered.upstream };
try { transport = checkedTransport(entry, stored.harness, provider.route); }
catch (e) { return refuse(e?.code === "model-harness-incompatible" ? "triage-harness-incompatible" : "triage-model-not-offered"); }
}
// 5. The harness module's own answers.
let mod = null;
try { mod = await harnessModule(stored.harness); } catch { mod = null; }
if (!mod || typeof mod.adapter !== "function" || typeof mod.turnEnd !== "function" || !Array.isArray(mod.envNames)
|| typeof mod.bundle !== "function" || typeof mod.env !== "function") return refuse("triage-harness-incompatible");
let adapter, turnEnd, harnessMounts, harnessEnv, keyName;
try {
adapter = mod.adapter();
turnEnd = mod.turnEnd();
harnessMounts = typeof mod.mounts === "function" ? mod.mounts({ env }) : [];
// The module's env() for this model and the stand-in proxy, held to the contract, less every
// name the host's fence refuses (MOSAIC_* and ANTHROPIC_* among them: the host sets those)
// and every name the module does not declare.
const session = { model: offered.model, provider: offered.provider ?? "", ...(transport ? { proxyTransport: { ...transport } } : {}) };
const given = mod.env({ files: {}, policy: { tools: [] }, tools: [], session, models: {}, proxy: { ...PROXY_PROBE } });
keyName = routeKeyName(given);
if (!keyName) return refuse("triage-harness-incompatible");
harnessEnv = Object.fromEntries(Object.entries(given)
.filter(([k, v]) => mod.envNames.includes(k) && !refusedHarnessName(k) && typeof v === "string"));
} catch { return refuse("triage-harness-incompatible"); }
return {
ok: true, harness: stored.harness, adapter, turnEnd, harnessMounts, harnessEnv,
model: offered.model, provider: offered.provider ?? "",
...(transport ? { transport } : {}),
env: { ANTHROPIC_BASE_URL: `http://127.0.0.1:${port}`, [keyName]: record.key },
};
},
};
}
+25 -17
View File
@@ -39,7 +39,7 @@ export const BUS_STATES = Object.freeze(["running", "not-answering", "stopped",
const UNIT_ACTIVE = Object.freeze(["active", "inactive", "failed", "activating", "deactivating", "reloading", "unknown"]);
export const READ_TIMEOUT_MS = 5000;
export const MAX_ORGS = 200;
// At most this many organizations are read at once; each read can start a node child for its config check.
// At most this many organizations' config checks run at once; each starts a node child.
export const ORG_READS_AT_ONCE = 4;
// What a failed system config check may say. Each refusal code the validator prints as its first
@@ -190,8 +190,11 @@ async function mapLimit(items, limit, fn) {
}
// The organization stage runs under one deadline, `timeoutMs` from its start, however many
// organizations there are: an organization whose reads have not finished by then is "not read", and
// one not yet begun is not read at all. A whole snapshot takes at most about two timeouts.
// organizations there are: a read that has not finished by then is "not read", and one not yet
// begun is not read at all. The bus and processing reads are socket reads and begin for every
// organization at once. Only the config checks, a node child each, wait for one of
// ORG_READS_AT_ONCE slots, so a hung check holds back other checks but never another
// organization's socket reads. A whole snapshot takes at most about two timeouts.
export async function composeSnapshot(readers = {}, { now = () => new Date(), timeoutMs = READ_TIMEOUT_MS, clock = Date.now } = {}) {
const at = now().toISOString();
const read = (name, ...args) => (typeof readers[name] === "function" ? bounded(() => readers[name](...args), timeoutMs) : Promise.resolve(NOT_READ));
@@ -200,21 +203,26 @@ export async function composeSnapshot(readers = {}, { now = () => new Date(), ti
if (Array.isArray(orgsRaw)) {
const active = orgsRaw.filter((o) => o && typeof o === "object" && o.state === "active" && typeof o.id === "string" && ID_PATTERN.test(o.id)).slice(0, MAX_ORGS);
const deadline = clock() + timeoutMs;
const list = await mapLimit(active, ORG_READS_AT_ONCE, async ({ id }) => {
// fn bounded by what is left of the deadline, or NOT_READ once nothing is.
const inTime = (fn) => {
const left = deadline - clock();
if (left <= 0) return { id, bus: NOT_READ, processing: NOT_READ, config: NOT_READ };
const readOrg = (name) => (typeof readers[name] === "function" ? bounded(() => readers[name](id), left) : NOT_READ);
const [bus, processing, config] = await Promise.all([
typeof readers.busStatus === "function"
? bounded(async () => {
try { return busFields(await readers.busStatus(id)); }
catch (e) { return e?.name === "CliError" || e?.dead === true ? busFields(null, true) : NOT_READ; }
}, left)
: NOT_READ,
readOrg("processing"),
readOrg("orgConfig"),
]);
return { id, bus: bus === NOT_READ ? NOT_READ : bus, processing: processingFields(processing), config: configFields(config, ORG_CONFIG_CODES) };
return left > 0 ? bounded(fn, left) : Promise.resolve(NOT_READ);
};
const readOrg = (name, id) => (typeof readers[name] === "function" ? inTime(() => readers[name](id)) : Promise.resolve(NOT_READ));
const sockets = Promise.all(active.map(({ id }) => Promise.all([
typeof readers.busStatus === "function"
? inTime(async () => {
try { return busFields(await readers.busStatus(id)); }
catch (e) { return e?.name === "CliError" || e?.dead === true ? busFields(null, true) : NOT_READ; }
})
: NOT_READ,
readOrg("processing", id),
])));
const configs = await mapLimit(active, ORG_READS_AT_ONCE, ({ id }) => readOrg("orgConfig", id));
const socketReads = await sockets;
const list = active.map(({ id }, i) => {
const [bus, processing] = socketReads[i];
return { id, bus: bus === NOT_READ ? NOT_READ : bus, processing: processingFields(processing), config: configFields(configs[i], ORG_CONFIG_CODES) };
});
organizations = { count: list.length, list };
}
+220
View File
@@ -0,0 +1,220 @@
// #1873 triage-cap: Triage's token usage and its daily cap.
//
// The Triage host appends one line per turn to <dataRoot>/triage/usage.jsonl:
// { at, run, turn, status, input, output, cacheRead, cacheWrite }
// A known turn carries four non-negative safe integers; an unknown turn carries four nulls. The file
// sits outside the run directory, so a new start never clears it. It is held to the route store's
// file checks: a regular file, one link, the running user's, mode 0600. A link, a non-file, a wrong
// mode or owner refuses the read and the append alike, and the append leaves the file as it was.
// Lines are only ever appended. Nothing here prunes the file.
//
// The cap is the daily-quota plugin's own rule (packages/plugins/limit-check/daily-quota), called
// with the organization limits shape and the stored cap as its one leaf, for one account named
// "triage". No counting rule lives here: the count, the window, the DST handling and the hit all
// come from mayLaunch and report. nextReset only asks report when the window turns over.
import { closeSync, constants, fchmodSync, fstatSync, fsyncSync, openSync, readSync, writeSync } from "node:fs";
import { join } from "node:path";
import { mayLaunch, report } from "../../plugins/limit-check/daily-quota/index.mjs";
export const USAGE_ACCOUNT = "triage";
export const USAGE_FIELDS = Object.freeze(["at", "run", "turn", "status", "input", "output", "cacheRead", "cacheWrite"]);
const KINDS = ["input", "output", "cacheWrite", "cacheRead"];
const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
// A run id is the host's own triage-<14 digits>; a turn id is the runner's message id, maybe with
// ":retry". Both are held to one short, plain shape so a line never carries free text.
export const ID = /^[A-Za-z0-9:._-]{1,80}$/;
// 32 MiB holds well over a hundred thousand lines; a larger file refuses rather than stalls a read.
export const USAGE_MAX_BYTES = 32 * 1024 * 1024;
const HOUR = 3600000;
export class UsageError extends Error {
constructor(why) {
super(`the Triage usage file is unreadable: ${why}`);
this.name = "UsageError";
this.code = "triage-usage-unreadable";
}
}
const unreadable = (why) => new UsageError(why);
export const usagePath = (dataRoot) => join(dataRoot, "triage", "usage.jsonl");
const plain = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
const canonicalTime = (s) => typeof s === "string" && ISO.test(s) && !Number.isNaN(Date.parse(s)) && new Date(s).toISOString() === s;
const count = (n) => Number.isSafeInteger(n) && n >= 0;
// One line's shape, exactly.
export function validLine(v) {
if (!plain(v) || Object.keys(v).length !== USAGE_FIELDS.length || !USAGE_FIELDS.every((k) => Object.hasOwn(v, k))) return false;
if (!canonicalTime(v.at) || typeof v.run !== "string" || !ID.test(v.run) || typeof v.turn !== "string" || !ID.test(v.turn)) return false;
if (v.status === "known") return KINDS.every((k) => count(v[k]));
if (v.status === "unknown") return KINDS.every((k) => v[k] === null);
return false;
}
// An opened file's checks, as the route store holds route.json to.
function checkFile(fd, uid) {
const st = fstatSync(fd);
if (!st.isFile()) throw unreadable("usage.jsonl is not a regular file");
if (st.nlink !== 1) throw unreadable("usage.jsonl has more than one link");
if (st.uid !== uid) throw unreadable("usage.jsonl is not owned by this user");
if ((st.mode & 0o777) !== 0o600) throw unreadable("usage.jsonl mode is not 0600");
return st;
}
const uidOf = (opts) => opts.uid ?? process.getuid();
// Append one line. A torn last line (a write that died) is closed off with a newline first, so the
// new line always stands alone and the torn one stays one bad line.
export function appendUsage(file, line, opts = {}) {
if (!validLine(line)) throw unreadable("the line does not match the usage shape");
const text = JSON.stringify(Object.fromEntries(USAGE_FIELDS.map((k) => [k, line[k]]))) + "\n";
const flags = constants.O_RDWR | constants.O_APPEND | constants.O_NOFOLLOW | constants.O_NONBLOCK;
let fd;
try { fd = openSync(file, flags); }
catch (e) {
if (e.code === "ELOOP") throw unreadable("usage.jsonl is a link");
if (e.code !== "ENOENT") throw unreadable("usage.jsonl cannot be opened");
try { fd = openSync(file, flags | constants.O_CREAT | constants.O_EXCL, 0o600); }
catch { throw unreadable("usage.jsonl cannot be made"); }
// The umask may have narrowed the mode; set it on the descriptor just made.
try { fchmodSync(fd, 0o600); } catch { closeSync(fd); throw unreadable("usage.jsonl cannot be made"); }
}
try {
const st = checkFile(fd, uidOf(opts));
let lead = "";
if (st.size > 0) {
const last = Buffer.alloc(1);
if (readSync(fd, last, 0, 1, st.size - 1) !== 1) throw unreadable("usage.jsonl cannot be read");
if (last[0] !== 0x0a) lead = "\n";
}
try {
writeSync(fd, lead + text);
fsyncSync(fd);
} catch { throw unreadable("usage.jsonl cannot be written"); }
} finally { closeSync(fd); }
}
const nulls = { input: null, output: null, cacheRead: null, cacheWrite: null };
// Every line as a daily-quota record for the triage account. A line that does not parse or does
// not match the shape (a torn last line, an edit by hand) is refused: it becomes one unknown turn,
// keyed by its line number, dated by the next good line (or the file's change time when none
// follows), and is listed in `bad` so the host can log it. No file reads as no turns.
export function readUsage(file, opts = {}) {
const maxBytes = opts.maxBytes ?? USAGE_MAX_BYTES;
let fd;
try { fd = openSync(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK); }
catch (e) {
if (e.code === "ENOENT") return { records: [], bad: [] };
if (e.code === "ELOOP") throw unreadable("usage.jsonl is a link");
throw unreadable("usage.jsonl cannot be opened");
}
let st;
let buf;
try {
st = checkFile(fd, uidOf(opts));
if (st.size > maxBytes) throw unreadable("usage.jsonl is too large");
buf = Buffer.alloc(st.size);
let got = 0;
while (got < st.size) {
const n = readSync(fd, buf, got, st.size - got, got);
if (n === 0) break;
got += n;
}
buf = buf.subarray(0, got);
} finally { closeSync(fd); }
const lines = buf.toString("utf8").split("\n");
if (lines.at(-1) === "") lines.pop();
const parsed = lines.map((text) => {
try {
const v = JSON.parse(text);
return validLine(v) ? v : null;
} catch { return null; }
});
const records = new Array(parsed.length);
const bad = [];
let nextAt = st.mtime.toISOString();
for (let i = parsed.length - 1; i >= 0; i--) {
const v = parsed[i];
if (v) {
records[i] = { account: USAGE_ACCOUNT, ...v };
nextAt = v.at;
} else {
records[i] = { account: USAGE_ACCOUNT, at: nextAt, run: null, turn: `line-${i + 1}`, status: "unknown", ...nulls };
bad.unshift({ line: i + 1 });
}
}
return { records, bad, ino: st.ino };
}
// The organization limits shape with the stored cap as its one leaf.
export const limitsFor = (cap) => ({ tokens: { daily: { [USAGE_ACCOUNT]: cap } } });
const SUBJECT = Object.freeze({ account: USAGE_ACCOUNT });
const iso = (ms) => new Date(ms).toISOString();
// The next reset after nowMs, or after the cap's `since` when that is later. A probe record at that
// instant counts while the window holding t still starts at or before it; the reset is the first
// millisecond at which report stops counting it. A day is at most 25 hours, so 49 hours always
// holds the next one.
export function nextReset(cap, nowMs) {
const from = Math.max(nowMs, Date.parse(cap.since));
const limits = limitsFor(cap);
const probe = [{ account: USAGE_ACCOUNT, at: iso(from), run: "probe", turn: "probe", status: "known", input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }];
const counts = (t) => report({ limits, records: probe, now: iso(t) })[0].count > 0;
let lo = from;
let hi = from + 49 * HOUR;
if (counts(hi)) throw unreadable("the cap has no reset in the next two days");
while (hi - lo > 1) {
const mid = Math.floor((lo + hi) / 2);
if (counts(mid)) lo = mid; else hi = mid;
}
return hi;
}
// Today's count, the decision and the next reset for the stored cap.
export function capState({ cap, records, now }) {
const at = iso(now);
const limits = limitsFor(cap);
const decision = mayLaunch({ limits, subject: SUBJECT, records, now: at });
const [r] = report({ limits, records, now: at });
return {
allow: decision.allow,
hit: decision.allow ? null : decision.hit,
usageToday: { count: r.count, ...r.kinds, unknownTurns: r.unknownTurns },
resetsAt: iso(nextReset(cap, now)),
};
}
// The turn delta, copied from packages/bus/src/usage.mjs (snapshot, delta; not exported there and
// that package is not this lane's to change). Same codes, same rules: the turn's usage is the sum
// of the transcript entries that are new since the turn began; a changed or missing earlier entry
// is "transcript-rewritten", and no new entry is "no-new-usage".
const unknown = (code) => ({ status: "unknown", code });
export function snapshot(value) {
if (value?.status === "unknown") return unknown(/^transcript-(path|size|line|entries|records|changed|parse|usage|harness)$/.test(value.code) ? value.code : "source-unknown");
if (value?.status !== "known" || !value.entries || typeof value.entries !== "object" || Array.isArray(value.entries)) return unknown("source-invalid");
const entries = Object.entries(value.entries);
if (entries.length > 20000) return unknown("source-invalid");
for (const [id, v] of entries) {
if (id.length > 512 || !v || Object.keys(v).length !== 4 || KINDS.some((k) => !Number.isSafeInteger(v[k]) || v[k] < 0)) return unknown("source-invalid");
}
return { status: "known", entries: value.entries };
}
export function delta(before, after) {
if (!before || before.status !== "known") return unknown("baseline-unknown");
if (after.status !== "known") return after;
for (const [id, v] of Object.entries(before.entries)) {
if (!Object.hasOwn(after.entries, id) || KINDS.some((k) => after.entries[id][k] !== v[k])) return unknown("transcript-rewritten");
}
const sum = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
let added = false;
for (const [id, v] of Object.entries(after.entries)) {
if (Object.hasOwn(before.entries, id)) continue;
added = true;
for (const k of KINDS) {
sum[k] += v[k];
if (!Number.isSafeInteger(sum[k])) return unknown("usage-overflow");
}
}
return added ? { status: "known", ...sum } : unknown("no-new-usage");
}
@@ -18,7 +18,7 @@ const at = minutesAgo => new Date(Date.now() - minutesAgo * 60000).toISOString()
const HIRE = '0f3c1a2b-4d5e-4f60-8a7b-9c0d1e2f3a4b';
const THREAD = '7b1e2c3d-4f50-4a61-8b72-9c83d4e5f6a7';
function fixture() {
function fixture(tweak) {
const LIST = [
{ id: 'acme', label: 'Acme Studio', theme: 'cobalt' },
{ id: 'beta', label: 'Beta Works', theme: 'grove' },
@@ -52,6 +52,7 @@ function fixture() {
model: {},
},
};
tweak?.(DATA);
const value = (id, name) => Promise.resolve(DATA[id]?.[name] ?? (['usage', 'limits'].includes(name) ? {} : []));
const opts = id => ({
bus: { inbox: () => value(id, 'inbox'), agents: () => value(id, 'agents'), 'thread.claims': () => value(id, 'claims'), tasks: () => value(id, 'tasks'), usage: () => value(id, 'usage'), limits: () => value(id, 'limits'), decisions: () => value(id, 'decisions') },
@@ -107,16 +108,26 @@ const STUB = `(() => {
if (window.__packsBody) return new Response(window.__packsBody, { status: 200, headers: { 'content-type': 'text/html' } });
return answer(200, { writable: false, applied: [{ id: 'coding', origin: 'shipped', project: null, hired: ['research-2'], open: [] }], packs: packs[1] === 'beta' ? [{ id: 'coding', origin: 'shipped', pack: { id: 'coding', label: 'Coding', version: 2, hires: [{ name: 'research-2', definition: 'researcher', reason: 'Research.' }], definitions: { researcher: { template: 'researcher', sha256: '${'a'.repeat(64)}' } } } }] : [] });
}
// SP19: a test may set __runs[org][name] to the runs the instances read lists for that agent.
const inst = u.match(/^\\/api\\/orgs\\/([^/]+)\\/bus\\/instances$/);
if (inst && window.__runs?.[inst[1]]) {
const got = await real(url, init), v = await got.json();
for (const [n, runs] of Object.entries(window.__runs[inst[1]])) if (v?.rows?.[0]?.instances?.[n]) v.rows[0].instances[n].running = runs;
return answer(got.status, v);
}
if (!/\\/agent\\//.test(u) || (init.method || 'GET') === 'GET' && !u.includes('/agent/request')) return real(url, init);
window.__posts.push({ url: u, method: init.method || 'GET', body: init.body ?? null });
const a = window.__answers.shift();
if (!a) throw new TypeError('no answer queued');
// SP19: an answer may wait on a promise (\`hold\`) and run a step once it is given (\`then\`).
if (a.hold) await a.hold;
a.then?.();
return answer(a.status ?? 200, a.body);
};
})();`;
async function setup(t, { viewport = [1440, 900], hash = '#/agents', stub = true, scripts = [] } = {}) {
const server = await startServer({ port: 0, sso: createDevOwner(), organizations: fixture(), log: () => {} });
async function setup(t, { viewport = [1440, 900], hash = '#/agents', stub = true, scripts = [], data } = {}) {
const server = await startServer({ port: 0, sso: createDevOwner(), organizations: fixture(data), log: () => {} });
t.after(() => close(server));
const b = await browser({ machine: false }); t.after(() => b.close());
await b.viewport(...viewport);
@@ -185,9 +196,12 @@ test('the drawer shows each field from its read: name, organization, role and so
// Decisions waiting on a human that it raised, each into the Inbox. Chief's is not its own.
const decisions = await b.evaluate(`[...document.querySelectorAll('${d} [data-drawer-decisions] li a')].map(a => [a.textContent.trim(), a.getAttribute("href")])`);
assert.deepEqual(decisions, [['Ship the hero copy?', '#/inbox?d=acme%3Adec-1']]);
// SP16: no read gives the time of an agent's last activity. The agents read's time (when it took the
// role) and `since` (when its present state began) are not that, so the drawer says not recorded.
assert.equal(await text(`${d} [data-drawer-activity]`), 'not recorded');
// SP18: the agents read lists only roles a run holds now, and its time is when that run took the role,
// so Last activity is when coder's running run took the role, 40 minutes before the read, with the time itself.
assert.match(await text(`${d} [data-drawer-activity]`), /^its run took the role 4[01] min ago$/);
const started = await attr(`${d} [data-drawer-activity] time`, 'datetime');
assert.ok(Math.abs(Date.now() - Date.parse(started) - 40 * 60000) < 90000, started);
assert.match(await attr(`${d} [data-drawer-activity] time`, 'title'), /\d/);
assert.equal(await b.evaluate(`document.querySelector('${d} [data-drawer-activity]').closest('.ws-drawer-f').querySelector('dt').textContent`), 'Last activity');
// Not a pack hire: no packs read, and no Hired from line.
assert.equal(await has(`${d} [data-drawer-hired]`), false);
@@ -209,6 +223,53 @@ test('a hired agent shows where its role came from; a not-running agent says not
assert.match(await text(`${d} [data-drawer-source]`), new RegExp(`hire decision ${HIRE}`));
assert.match(await text(`${d} [data-drawer-state]`), /(^|\s)not running$/);
assert.equal(await has(`${d} [data-drawer-model]`), false);
// SP18: no run holds it, and no read keeps the time of a run that ended: one plain line, no time.
assert.equal(await text(`${d} [data-drawer-activity]`), 'not recorded: no run holds it now, and no read keeps when its last run ended');
assert.equal(await has(`${d} [data-drawer-activity] time`), false);
});
// SP18 review: a claim dates the agent only when the instances read lists its run as running.
test('SP18 review: Last activity counts only a claim whose run is running', async t => {
// Coder runs run-2, but the role is still held by run-1, whose process ended: nothing dates run-2 yet.
{
const { wait, text, has } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', data: d => { d.acme.instances.coder.running = ['run-2']; } });
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && /running$/.test(document.querySelector('${d} [data-drawer-state]')?.textContent ?? '')`);
assert.equal(await text(`${d} [data-drawer-activity]`), 'not recorded: its run holds no role or conversation yet');
assert.equal(await has(`${d} [data-drawer-activity] time`), false);
}
// Coder runs nothing, and a claim from three days ago is left: not running, and no time from that claim.
{
const { wait, text, has } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', data: d => { d.acme.instances.coder.running = []; d.acme.agents[0].at = at(3 * 24 * 60); d.acme.agents[0].working = null; } });
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && /not running$/.test(document.querySelector('${d} [data-drawer-state]')?.textContent ?? '')`);
assert.equal(await text(`${d} [data-drawer-activity]`), 'not recorded: no run holds it now, and no read keeps when its last run ended');
assert.equal(await has(`${d} [data-drawer-activity] time`), false);
}
// Two runs, one holding the role: no read says which run is newer, so the line says one of them.
{
const { wait, text } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', data: d => { d.acme.instances.coder.running = ['run-1', 'run-2']; } });
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && !!document.querySelector('${d} [data-drawer-activity] time')`);
assert.match(await text(`${d} [data-drawer-activity]`), /^one of its 2 runs took the role 4[01] min ago$/);
}
// The instances read fails: nothing checked the claim against a live run, so the line says "a run".
{
const fail = `(() => { const f = window.fetch; window.fetch = (u, i) => /\\/api\\/orgs\\/acme\\/bus\\/instances$/.test(String(u)) ? Promise.resolve(new Response('{}', { status: 503 })) : f(u, i); })();`;
const { wait, text } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', scripts: [fail] });
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && /^State not read/.test(document.querySelector('${d} [data-drawer-state]')?.textContent ?? '')`);
assert.match(await text(`${d} [data-drawer-activity]`), /^a run took the role 4[01] min ago$/);
}
// The same failed read for chief, which holds no role and no conversation: the line names both gaps.
{
const fail = `(() => { const f = window.fetch; window.fetch = (u, i) => /\\/api\\/orgs\\/acme\\/bus\\/instances$/.test(String(u)) ? Promise.resolve(new Response('{}', { status: 503 })) : f(u, i); })();`;
const { wait, text, has } = await setup(t, { hash: '#/agents?agent=acme%3Achief', scripts: [fail] });
const d = '[data-ws-drawer="acme:chief"]';
await wait(`${open('acme:chief')} && /^State not read/.test(document.querySelector('${d} [data-drawer-state]')?.textContent ?? '')`);
assert.equal(await text(`${d} [data-drawer-activity]`), 'not recorded: the agents and claims reads show no run holding its role or a conversation, and its runs were not read');
assert.equal(await has(`${d} [data-drawer-activity] time`), false);
}
});
test('SP16: a pack hire names its pack and the template the packs read gives; a refused read says so', async t => {
@@ -501,8 +562,8 @@ test('Message opens the agent\'s thread in an Assistant pane; Stop asks first an
assert.equal(await attr('[data-ws-drawer="acme:assistant"] [data-drawer-message]', 'href'), `#/assistant?add=acme%3A${THREAD}`);
// SP16: Message is offered, so no line says why it is not.
assert.equal(await has('[data-ws-drawer="acme:assistant"] [data-drawer-nomessage]'), false);
// It holds a conversation, whose messages read pages from the oldest message: the drawer says it does not read it.
assert.equal(await text('[data-ws-drawer="acme:assistant"] [data-drawer-activity]'), 'not shown: reading it means reading the whole conversation');
// SP18: a conversation agent's run took its conversation 5 minutes before the read (thread.claims' time).
assert.match(await text('[data-ws-drawer="acme:assistant"] [data-drawer-activity]'), /^its run took the conversation [56] min ago$/);
// A role agent holds no thread to open, so it has no Message; it can still be stopped.
await b.evaluate('location.hash = "#/agents?agent=acme%3Acoder"');
await wait(`${open('acme:coder')} && document.querySelector('[data-ws-drawer="acme:coder"] [data-drawer-stop]')`);
@@ -577,3 +638,396 @@ test('at 390 wide the drawer is a full-width sheet', async t => {
assert.equal(box[1], box[2]);
assert.ok(box[3] <= box[2], `no horizontal page scroll: ${box[3]} > ${box[2]}`);
});
// SP18: the sheet is fixed to the screen, but the page under it kept its own height, so the page still
// scrolled behind the sheet and a full-page shot showed the sheet stretched down a long blank area. With the
// sheet open the page is one screen tall; Close puts the page back where the reader left it.
test('SP18: at 390 wide the open sheet is the whole screen, the page under it does not scroll, and Close keeps the place', async t => {
const { b, wait } = await setup(t, { viewport: [390, 844], hash: '#/orgs/acme/organization' });
const link = JSON.stringify(sessionLink('acme:coder'));
await wait(`document.querySelector(${link}) && document.querySelectorAll("[data-org-settings] [data-org-setting]").length > 10`);
await b.evaluate(`document.querySelector(${link}).scrollIntoView({ block: 'center' })`);
const at = await b.evaluate('Math.round(scrollY)');
assert.ok(at > 100, `the row is down the page: ${at}`);
await b.evaluate(`document.querySelector(${link}).click()`);
await wait(open('acme:coder'));
await b.evaluate('new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))');
const m = await b.evaluate(`(() => { const r = ${drawer('acme:coder')}.getBoundingClientRect(), e = document.documentElement; return { top: Math.round(r.top), bottom: Math.round(r.bottom), left: Math.round(r.left), width: Math.round(r.width), vh: innerHeight, vw: e.clientWidth, docH: e.scrollHeight, bodyH: Math.round(document.body.getBoundingClientRect().height), sw: e.scrollWidth }; })()`);
assert.equal(m.top, 0, JSON.stringify(m));
assert.equal(m.bottom, m.vh, `the sheet ends at the screen's foot: ${JSON.stringify(m)}`);
assert.equal(m.left, 0); assert.equal(m.width, m.vw);
assert.ok(m.docH <= m.vh && m.bodyH <= m.vh, `the page under the sheet is one screen tall, nothing below to scroll to: ${JSON.stringify(m)}`);
assert.ok(m.sw <= m.vw, 'no sideways scroll');
// A scroll on the page does nothing while the sheet is open.
await b.evaluate('window.scrollTo(0, 2000)');
assert.equal(await b.evaluate('Math.round(scrollY)'), 0);
await b.evaluate(`${drawer('acme:coder')}.querySelector("[data-drawer-close]").click()`);
await wait(noDrawer);
await b.evaluate('new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))');
assert.ok(Math.abs(await b.evaluate('Math.round(scrollY)') - at) <= 1, `Close puts the page back at ${at}: ${await b.evaluate('Math.round(scrollY)')}`);
assert.ok(await b.evaluate('document.documentElement.scrollHeight') > 844, 'the page is its full height again');
// At 1440 the drawer is a side panel: the page keeps its height and scrolls.
await b.viewport(1440, 900);
await b.evaluate(`document.querySelector(${link}).click()`);
await wait(open('acme:coder'));
assert.ok(await b.evaluate('document.documentElement.scrollHeight') > 900, 'at 1440 the page beside the drawer keeps its height');
});
// SP18 review: only Close (or Back to the same page) puts the page back. A link in the sheet goes to a new
// page, which starts at its top, and the place kept for the page under the sheet is not used later either.
// The Task page is drawn through afterPaint; a project address is drawn by bus.js's chat branch without it
// (this fixture has no chat backend, so that page is the Projects list saying the route is invalid).
for (const [label, sel, hashStart, ready] of [
['Task', '[data-drawer-task] a', '#/orgs/acme/tasks?task=', 'document.querySelector("[data-tasks-board]")'],
['Project', '[data-drawer-project] a', '#/orgs/acme/projects/p-site', 'document.querySelector("#bus-view h1")?.textContent.trim() === "Projects"'],
]) test(`SP18 review: at 390 the sheet's ${label} link opens its page at the top, and a later page does not jump`, async t => {
const { b, wait } = await setup(t, { viewport: [390, 844], hash: '#/orgs/acme/organization' });
const link = JSON.stringify(sessionLink('acme:coder'));
await wait(`document.querySelector(${link}) && document.querySelectorAll("[data-org-settings] [data-org-setting]").length > 10`);
// Every page is long, so a jump to the kept place would show wherever it lands.
await b.evaluate('document.head.insertAdjacentHTML("beforeend", "<style>#bus-view{padding-bottom:4000px}</style>")');
await b.evaluate(`document.querySelector(${link}).scrollIntoView({ block: 'center' })`);
const at = await b.evaluate('Math.round(scrollY)');
assert.ok(at > 100, `the row is down the page: ${at}`);
await b.evaluate(`document.querySelector(${link}).click()`);
await wait(open('acme:coder'));
await b.evaluate(`${drawer('acme:coder')}.querySelector(${JSON.stringify(sel)}).click()`);
await wait(`${noDrawer} && location.hash.startsWith(${JSON.stringify(hashStart)}) && ${ready}`);
await b.evaluate('new Promise(r => setTimeout(r, 500))');
const y = await b.evaluate('Math.round(scrollY)');
assert.ok(y <= 1, `the ${label} page is at its top, not at ${at}: ${y}`);
// The next page with no drawer does not take the kept place either.
await b.evaluate('location.hash = "#/orgs/acme/organization"');
await wait('document.querySelectorAll("[data-org-settings] [data-org-setting]").length > 10');
await b.evaluate('new Promise(r => setTimeout(r, 500))');
const later = await b.evaluate('Math.round(scrollY)');
assert.ok(later <= 1, `the organization page opens at its top: ${later}`);
});
// #1873 triage-followups: the page focuses its heading when its first render ends. On load the page
// starts a second render that reads GET /api/workspace again, so when the first render's read is slow
// the second draws the rows first and a reader can open a drawer before the first render ends. Its late
// end must not take the drawer's focus. The page holds the first GET /api/workspace until __go.
const HOLD_FIRST = `(() => { const f = window.fetch; let first = true; window.__firstDone = false; window.fetch = (u, o) => { if (first && String(u?.url ?? u).includes('/api/workspace')) { first = false; return new Promise(r => { const t = setInterval(() => { if (window.__go) { clearInterval(t); r(f(u, o).finally(() => setTimeout(() => { window.__firstDone = true; }, 0))); } }, 20); }); } return f(u, o); }; })()`;
test('triage-followups: a drawer opened before the first render ends keeps focus when that render ends', async t => {
const { b, wait } = await setup(t, { scripts: [HOLD_FIRST] });
await wait(`document.querySelector(${JSON.stringify(rowLink('acme:coder'))})`);
assert.notEqual(await b.evaluate('document.activeElement?.tagName'), 'H1', 'the first render has not ended');
await b.evaluate(`document.querySelector(${JSON.stringify(rowLink('acme:coder'))}).click()`);
await wait(`${open('acme:coder')} && ${drawer('acme:coder')}.contains(document.activeElement)`);
await b.evaluate('window.__go = true');
await wait('window.__firstDone');
await new Promise(r => setTimeout(r, 400));
assert.equal(await b.evaluate(`${drawer('acme:coder')}.contains(document.activeElement)`), true, `focus stays in the drawer, not on ${await b.evaluate('document.activeElement?.tagName')}`);
});
// SP19 (#1873): Restart in the drawer, offered only where Stop is. It reuses Stop's confirm step and
// status line, ends the agent through its own organization's /agent/terminate, waits for the request to
// close and for its runs to reach 0, then launches it through /agent/launch. It never regenerates. A
// conversation agent is ended and not launched. The page's 2 s poll steps run every 20 ms here.
const FAST = `(() => { const st = window.setTimeout.bind(window); window.setTimeout = (f, ms, ...a) => st(f, ms === 2000 ? 20 : ms, ...a); })()`;
const END = '5e000000-0000-4000-8000-0000000000e1', LAUNCH = '5e000000-0000-4000-8000-0000000000a1';
const closed = (request, action, extra = {}) => ({ request, instance: 'coder', action, state: 'closed', done: { run: null, transaction: null, refusal: null }, cancelled: null, ...extra });
// Every distinct state of the drawer's actions, from now on: [status, Restart's label, Restart disabled, Stop disabled].
const WATCH = id => `(() => { window.__seen = []; const snap = () => { const d = document.querySelector('[data-ws-drawer="${id}"]'); if (!d) return; const r = d.querySelector('[data-drawer-restart]'), s = d.querySelector('[data-drawer-stop]'); const v = [d.querySelector('[data-drawer-status]')?.textContent ?? '', r ? r.firstChild.textContent : null, !!r?.disabled, !!s?.disabled]; const l = window.__seen.at(-1); if (!l || l.join('|') !== v.join('|')) window.__seen.push(v); }; snap(); new MutationObserver(snap).observe(document.getElementById('bus-view'), { subtree: true, childList: true, characterData: true, attributes: true }); return true; })()`;
const status = d => `(document.querySelector('${d} [data-drawer-status]')?.textContent ?? "")`;
const usable = d => `document.querySelector('${d} [data-drawer-restart]')?.disabled === false && document.querySelector('${d} [data-drawer-stop]')?.disabled === false && !document.querySelector('${d} .ws-drawer-confirm')`;
test('SP19: Restart asks first, then ends and launches the agent in its own organization, and never regenerates', async t => {
// The reader was last on Beta Works, so the Console's chosen organization is beta. #/agents shows every
// organization's agents; the drawer's own organization is used, not the chosen one.
const { b, wait, text } = await setup(t, { hash: '#/orgs/beta/organization', scripts: [FAST] });
await wait(`window.MosaicOrg?.id === 'beta' && document.querySelectorAll("[data-org-settings] [data-org-setting]").length > 0`);
await b.evaluate('location.hash = "#/agents?agent=acme%3Acoder"');
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-restart]')`);
assert.equal(await b.evaluate('window.MosaicOrg?.id ?? null'), 'beta');
// Beside Stop, in the same action group as the status line.
assert.equal(await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').closest('[data-drawer-actions]') === document.querySelector('${d} [data-drawer-stop]').closest('[data-drawer-actions]')`), true);
assert.equal(await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').textContent`), 'Restart coder in Acme Studio');
// It asks first, in Stop's confirm step. Cancel sends nothing and puts focus back on Restart.
await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').click()`);
await wait(`document.querySelector('${d} [data-drawer-restart-yes]')`);
assert.match(await text(`${d} [data-drawer-restart-confirm]`), /^Restart coder in Acme Studio\? It ends its session and launches it again\. Restart coder Cancel$/);
assert.equal(await b.evaluate(`document.querySelector('${d} [data-drawer-restart-confirm]').classList.contains('ws-drawer-confirm')`), true);
assert.deepEqual(await b.evaluate(`[document.querySelector('${d} [data-drawer-restart]').disabled, document.querySelector('${d} [data-drawer-stop]').disabled]`), [true, true]);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart-no]').click()`);
await wait(`document.activeElement === document.querySelector('${d} [data-drawer-restart]') && ${usable(d)}`);
// Escape cancels the question too, and the drawer stays.
await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').click()`);
await wait(`document.querySelector('${d} [data-drawer-restart-no]') === document.activeElement`);
await b.key('Escape');
await wait(`document.activeElement === document.querySelector('${d} [data-drawer-restart]') && ${usable(d)}`);
assert.equal(await b.evaluate(agentParam), 'acme:coder');
assert.deepEqual(await b.evaluate('window.__posts'), []);
// Yes: one terminate, its request followed until it closes, the runs read until none is left, one launch.
await b.evaluate(`window.__answers.push(
{ body: { request: '${END}', runs: ['run-1'], cancelled: [], taken: [] }, then: () => { window.__runs = { acme: { coder: [] } }; } },
{ body: ${JSON.stringify(closed(END, 'end'))} },
{ body: { request: '${LAUNCH}' }, then: () => { window.__runs = { acme: { coder: ['run-2'] } }; } },
{ body: ${JSON.stringify(closed(LAUNCH, 'launch', { done: { run: 'run-2', transaction: null, refusal: null } }))} })`);
await b.evaluate(WATCH('acme:coder'));
await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').click()`);
await wait(`document.querySelector('${d} [data-drawer-restart-yes]')`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart-yes]').click()`);
await wait(`/^Restarted coder \\(run run-2\\)\\.$/.test(${status(d)}) && ${usable(d)}`);
const posts = await b.evaluate('window.__posts');
assert.deepEqual(posts.map(p => [p.url, p.method]), [
['/api/orgs/acme/agent/terminate', 'POST'], [`/api/orgs/acme/agent/request?id=${END}`, 'GET'],
['/api/orgs/acme/agent/launch', 'POST'], [`/api/orgs/acme/agent/request?id=${LAUNCH}`, 'GET'],
]);
assert.deepEqual(JSON.parse(posts[0].body), { instance: 'coder', reason: 'restart from the agent drawer' });
assert.deepEqual(JSON.parse(posts[2].body), { instance: 'coder' });
assert.equal(posts.some(p => /regenerate/.test(p.url)), false, 'Restart never regenerates');
// The status line names each step; while it runs, Restart reads Restarting… and both buttons wait.
const seen = await b.evaluate('window.__seen');
const steps = seen.map(s => s[0]).filter((s, i, all) => s && s !== all[i - 1]);
assert.deepEqual(steps, ['Restarting coder: asking it to end…', 'coder was asked to end. Waiting for its session to end…', 'coder has ended. Launching it…', 'Restarted coder (run run-2).']);
for (const [s, label, rd, sd] of seen.filter(s => steps.slice(0, 3).includes(s[0]))) assert.deepEqual([label, rd, sd], ['Restarting…', true, true], s);
assert.equal(await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').firstChild.textContent`), 'Restart');
});
// The Assistant is a protected agent, so it has no Stop and no Restart; ideas is a conversation agent that is not.
test('SP19: a conversation agent is ended and not launched; its next message starts it', async t => {
const data = D => { D.acme.instances.ideas = { definition: 'ideas', running: ['run-4'] }; };
const { b, wait } = await setup(t, { hash: '#/agents?agent=acme%3Aideas', scripts: [FAST], data });
const d = '[data-ws-drawer="acme:ideas"]';
await wait(`${open('acme:ideas')} && document.querySelector('${d} [data-drawer-restart]')`);
assert.equal(await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').dataset.drawerThread`), 'yes');
await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').click()`);
await wait(`document.querySelector('${d} [data-drawer-restart-yes]')`);
assert.match(await b.evaluate(`document.querySelector('${d} [data-drawer-restart-confirm]').textContent`), /^Restart ideas in Acme Studio\? It ends its session; its next message starts it again\./);
await b.evaluate(`window.__answers.push(
{ body: { request: '${END}', runs: ['run-4'], cancelled: [], taken: [] }, then: () => { window.__runs = { acme: { ideas: [] } }; } },
{ body: ${JSON.stringify({ ...closed(END, 'end'), instance: 'ideas' })} })`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart-yes]').click()`);
await wait(`/^Ended ideas at .+\\. Its next message starts it\\.$/.test(${status(d)})`);
const posts = await b.evaluate('window.__posts');
assert.deepEqual(posts.map(p => [p.url, p.method]), [['/api/orgs/acme/agent/terminate', 'POST'], [`/api/orgs/acme/agent/request?id=${END}`, 'GET']]);
assert.deepEqual(JSON.parse(posts[0].body), { instance: 'ideas', reason: 'restart from the agent drawer' });
});
test('SP19: a second click while a restart runs does nothing', async t => {
const { b, wait } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', scripts: [FAST] });
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-restart]')`);
// The terminate's answer is held, so the restart is still running while the page is clicked again.
await b.evaluate(`window.__answers.push({ hold: new Promise(r => { window.__release = r; }), status: 403, body: { error: 'unavailable', sent: false } })`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').click()`);
await wait(`document.querySelector('${d} [data-drawer-restart-yes]')`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart-yes]').click()`);
await wait(`window.__posts.length === 1 && document.querySelector('${d} [data-drawer-restart]').disabled`);
// Even a Restart button made clickable again starts nothing: no second question, no second request.
await b.evaluate(`(() => { const r = document.querySelector('${d} [data-drawer-restart]'), s = document.querySelector('${d} [data-drawer-stop]'); r.disabled = false; s.disabled = false; r.click(); s.click(); return true; })()`);
await b.evaluate('new Promise(r => setTimeout(r, 300))');
assert.equal(await b.evaluate(`!!document.querySelector('${d} .ws-drawer-confirm')`), false);
assert.equal(await b.evaluate('window.__posts.length'), 1);
await b.evaluate('window.__release()');
await wait(`/^Not restarted:/.test(${status(d)}) && ${usable(d)}`);
assert.equal(await b.evaluate('window.__posts.length'), 1);
});
// SP19 review: a restart keeps its own state, so another drawer's question or Stop does not lose its
// line, and its drawer still shows it running when the reader comes back.
test('SP19: a restart keeps its line and its running state across another drawer\'s Stop', async t => {
const data = D => { D.acme.instances.ideas = { definition: 'ideas', running: ['run-4'] }; };
const { b, wait } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', scripts: [FAST], data });
const d = '[data-ws-drawer="acme:coder"]', i = '[data-ws-drawer="acme:ideas"]';
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-restart]')`);
await b.evaluate(`window.__answers.push({ hold: new Promise(r => { window.__release = r; }), status: 403, body: { error: 'unavailable', sent: false } })`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').click()`);
await wait(`document.querySelector('${d} [data-drawer-restart-yes]')`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart-yes]').click()`);
await wait(`window.__posts.length === 1`);
// Ideas asks to stop and is cancelled; back on coder, its restart still shows as running.
await b.evaluate('location.hash = "#/agents?agent=acme%3Aideas"');
await wait(`${open('acme:ideas')} && document.querySelector('${i} [data-drawer-stop]')`);
await b.evaluate(`document.querySelector('${i} [data-drawer-stop]').click()`);
await wait(`document.querySelector('${i} [data-drawer-stop-no]')`);
await b.evaluate(`document.querySelector('${i} [data-drawer-stop-no]').click()`);
await b.evaluate('location.hash = "#/agents?agent=acme%3Acoder"');
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-restart]')`);
assert.deepEqual(await b.evaluate(`[${status(d)}, document.querySelector('${d} [data-drawer-restart]').firstChild.textContent, document.querySelector('${d} [data-drawer-restart]').disabled, document.querySelector('${d} [data-drawer-stop]').disabled]`),
['Restarting coder: asking it to end…', 'Restarting…', true, true]);
// Ideas' Stop question is open when coder's restart is refused; coder's drawer still says so after.
await b.evaluate('location.hash = "#/agents?agent=acme%3Aideas"');
await wait(`${open('acme:ideas')} && document.querySelector('${i} [data-drawer-stop]')`);
await b.evaluate(`document.querySelector('${i} [data-drawer-stop]').click()`);
await wait(`document.querySelector('${i} [data-drawer-stop-no]')`);
await b.evaluate('window.__release()');
await b.evaluate('new Promise(r => setTimeout(r, 300))');
assert.equal(await b.evaluate(`!!document.querySelector('${i} [data-drawer-stop-confirm]')`), true, 'the other drawer keeps its question');
await b.evaluate(`document.querySelector('${i} [data-drawer-stop-no]').click()`);
await b.evaluate('location.hash = "#/agents?agent=acme%3Acoder"');
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-restart]')`);
await wait(`${status(d)} === 'Not restarted: this Console is not the owner of Acme Studio, so it does not restart its agents.' && ${usable(d)}`);
assert.equal(await b.evaluate('window.__posts.length'), 1);
});
// Each refusal the two routes can give says so in one plain line. Where the agent still runs, both
// buttons are usable again and focus is on Restart; after a refused launch it has no run, so the
// repaint drops Stop and Restart, keeps the line and puts focus on the drawer's heading.
const ENDED = [{ body: { request: END, runs: ['run-1'], cancelled: [], taken: [] }, runs: [] }, { body: closed(END, 'end') }];
for (const [label, answers, line] of [
['not the owner', [{ status: 403, body: { error: 'unavailable', sent: false } }],
/^Not restarted: this Console is not the owner of Acme Studio, so it does not restart its agents\.$/],
['the organization is archived', [{ status: 409, body: { error: 'org-archived', message: 'organization is archived' } }],
/^Not restarted: Acme Studio is archived, so its agents are not changed\. Nothing changed\.$/],
['the bus is stopped', [{ status: 503, body: { error: 'no-bus-host', message: 'no-bus-host: no-bus-host. Nothing changed.', sent: false } }],
/^Not restarted: the bus of Acme Studio is not running\. Nothing changed\.$/],
['the end is refused', [{ body: { request: END, runs: ['run-1'], cancelled: [], taken: [] } }, { body: { ...closed(END, 'end', { done: { run: null, transaction: null, refusal: 'instance-kept' } }), reason: 'the instance is kept; unkeep it first' } }],
/^Not restarted: coder was not ended \(the instance is kept; unkeep it first\)\.$/],
['the launch is refused', [...ENDED, { status: 409, body: { error: 'capacity-full', message: 'capacity-full: a launch limit is reached. Nothing changed.', sent: false } }],
/^coder was ended and not launched: capacity-full: a launch limit is reached\. Nothing changed\.$/],
['the launch request closes refused', [...ENDED, { body: { request: LAUNCH } }, { body: { ...closed(LAUNCH, 'launch', { done: { run: null, transaction: null, refusal: 'no-route' } }), reason: 'the instance has no harness, model and thinking yet; set its route first' } }],
/^coder was ended and not launched: the instance has no harness, model and thinking yet; set its route first\.$/],
['its runs never reach 0', [{ body: { request: END, runs: ['run-1'], cancelled: [], taken: [] } }, { body: closed(END, 'end') }],
/^Not restarted: coder was asked to end, but its session is still running\. Read the agents again before trying\.$/],
]) test(`SP19: a refusal says so in the drawer: ${label}`, async t => {
const { b, wait } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', scripts: [FAST] });
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-restart]')`);
const queued = JSON.stringify(answers);
await b.evaluate(`window.__answers.push(...${queued}.map(a => a.runs ? { ...a, then: () => { window.__runs = { acme: { coder: a.runs } }; } } : a))`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart]').click()`);
await wait(`document.querySelector('${d} [data-drawer-restart-yes]')`);
await b.evaluate(`document.querySelector('${d} [data-drawer-restart-yes]').click()`);
const launched = label.startsWith('the launch');
await wait(launched ? `/ was ended and not launched: /.test(${status(d)}) && !document.querySelector('${d} [data-drawer-restart]')`
: `/^Not restarted: /.test(${status(d)}) && document.querySelector('${d} [data-drawer-restart]')?.disabled === false`);
await b.evaluate('new Promise(r => setTimeout(r, 300))');
assert.match(await b.evaluate(status(d)), line);
if (launched) {
assert.deepEqual(await b.evaluate(`[!!document.querySelector('${d} [data-drawer-stop]'), document.querySelector('${d} [data-drawer-nostop]')?.textContent]`), [false, 'It is not running, so there is nothing to stop.']);
assert.equal(await b.evaluate(`document.activeElement === document.querySelector('${d} h2')`), true, `focus is on the drawer heading, not ${await b.evaluate('document.activeElement?.outerHTML.slice(0, 80)')}`);
} else {
assert.equal(await b.evaluate(usable(d)), true, 'both buttons are usable again');
assert.equal(await b.evaluate(`document.activeElement === document.querySelector('${d} [data-drawer-restart]')`), true, 'focus is back on Restart');
}
const posts = await b.evaluate('window.__posts');
assert.equal(posts.some(p => /regenerate/.test(p.url)), false);
assert.equal(posts.filter(p => p.url.endsWith('/agent/launch')).length, launched ? 1 : 0);
assert.equal(await b.evaluate('window.__answers.length'), 0, 'every queued answer was asked for');
});
// SP20 (#1873): an organization refusal of Stop says so in one plain line, the line Restart gives.
for (const [label, answer, line] of [
['the organization is archived', { status: 409, body: { error: 'org-archived', message: 'organization is archived' } },
/^Not stopped: Acme Studio is archived, so its agents are not changed\. Nothing changed\.$/],
['the organization is not available', { status: 404, body: { error: 'org-unavailable' } },
/^Not stopped: Acme Studio is not available to this Console\. Nothing changed\.$/],
]) test(`SP20: a Stop refusal says so in the drawer: ${label}`, async t => {
const { b, wait } = await setup(t, { hash: '#/agents?agent=acme%3Acoder' });
const d = '[data-ws-drawer="acme:coder"]';
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-stop]')`);
await b.evaluate(`window.__answers.push(${JSON.stringify(answer)})`);
await b.evaluate(`document.querySelector('${d} [data-drawer-stop]').click()`);
await wait(`document.querySelector('${d} [data-drawer-stop-yes]')`);
await b.evaluate(`document.querySelector('${d} [data-drawer-stop-yes]').click()`);
await wait(`/^Not stopped: /.test(${status(d)}) && ${usable(d)}`);
assert.match(await b.evaluate(status(d)), line);
assert.equal(await b.evaluate(`document.activeElement === document.querySelector('${d} [data-drawer-stop]')`), true, 'focus is back on Stop');
assert.deepEqual((await b.evaluate('window.__posts')).map(p => [p.url, p.method]), [['/api/orgs/acme/agent/terminate', 'POST']]);
});
// SP20: each Stop keeps its own state, as each restart does. Another drawer's question or Stop does not
// lose a running Stop's line or its running state, and a Stop that ends does not drop another drawer's question.
test('SP20: two Stops in two drawers each keep their own line and running state', async t => {
const data = D => { D.acme.instances.ideas = { definition: 'ideas', running: ['run-4'] }; };
const { b, wait } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', data });
const d = '[data-ws-drawer="acme:coder"]', i = '[data-ws-drawer="acme:ideas"]';
const refused = who => ({ status: 409, body: { error: 'instance-protected', message: `instance-protected: ${who} is protected from ending. Nothing changed.`, sent: false } });
const state = x => `[${status(x)}, document.querySelector('${x} [data-drawer-stop]')?.firstChild.textContent, document.querySelector('${x} [data-drawer-stop]')?.disabled, document.querySelector('${x} [data-drawer-restart]')?.disabled]`;
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-stop]')`);
// Coder's Stop runs: its terminate is held.
await b.evaluate(`window.__answers.push({ hold: new Promise(r => { window.__release = r; }), ...${JSON.stringify(refused('coder'))} })`);
await b.evaluate(`document.querySelector('${d} [data-drawer-stop]').click()`);
await wait(`document.querySelector('${d} [data-drawer-stop-yes]')`);
await b.evaluate(`document.querySelector('${d} [data-drawer-stop-yes]').click()`);
await wait(`window.__posts.length === 1`);
// Ideas asks to stop and is cancelled; back on coder, its Stop still shows as running.
await b.evaluate('location.hash = "#/agents?agent=acme%3Aideas"');
await wait(`${open('acme:ideas')} && document.querySelector('${i} [data-drawer-stop]')`);
await b.evaluate(`document.querySelector('${i} [data-drawer-stop]').click()`);
await wait(`document.querySelector('${i} [data-drawer-stop-no]')`);
await b.evaluate(`document.querySelector('${i} [data-drawer-stop-no]').click()`);
await b.evaluate('location.hash = "#/agents?agent=acme%3Acoder"');
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-stop]')`);
assert.deepEqual(await b.evaluate(state(d)), ['Stopping coder…', 'Stopping…', true, true]);
// Ideas' Stop question is open when coder's Stop is refused; each drawer keeps its own.
await b.evaluate('location.hash = "#/agents?agent=acme%3Aideas"');
await wait(`${open('acme:ideas')} && document.querySelector('${i} [data-drawer-stop]')`);
await b.evaluate(`document.querySelector('${i} [data-drawer-stop]').click()`);
await wait(`document.querySelector('${i} [data-drawer-stop-no]')`);
await b.evaluate('window.__release()');
await b.evaluate('new Promise(r => setTimeout(r, 300))');
await b.evaluate('location.hash = "#/agents?agent=acme%3Acoder"');
await wait(`${open('acme:coder')} && /^Not stopped: /.test(${status(d)}) && ${usable(d)}`);
assert.equal(await b.evaluate(status(d)), 'Not stopped: instance-protected: coder is protected from ending. Nothing changed.');
await b.evaluate('location.hash = "#/agents?agent=acme%3Aideas"');
await wait(`${open('acme:ideas')} && document.querySelector('${i} [data-drawer-stop]')`);
assert.equal(await b.evaluate(`!!document.querySelector('${i} [data-drawer-stop-yes]')`), true, 'ideas keeps its question');
// Ideas' Stop runs and is refused; coder's line is still there after, and ideas' is too.
await b.evaluate(`window.__answers.push(${JSON.stringify(refused('ideas'))})`);
await b.evaluate(`document.querySelector('${i} [data-drawer-stop-yes]').click()`);
await wait(`/^Not stopped: /.test(${status(i)}) && ${usable(i)}`);
await b.evaluate('location.hash = "#/agents?agent=acme%3Acoder"');
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-stop]')`);
assert.deepEqual(await b.evaluate(state(d)), ['Not stopped: instance-protected: coder is protected from ending. Nothing changed.', 'Stop', false, false]);
await b.evaluate('location.hash = "#/agents?agent=acme%3Aideas"');
await wait(`${open('acme:ideas')} && document.querySelector('${i} [data-drawer-stop]')`);
assert.deepEqual(await b.evaluate(state(i)), ['Not stopped: instance-protected: ideas is protected from ending. Nothing changed.', 'Stop', false, false]);
assert.deepEqual((await b.evaluate('window.__posts')).map(p => JSON.parse(p.body).instance), ['coder', 'ideas']);
});
// SP20 review: two Stops run at once. One that ends, here the one the bus takes, which repaints the page,
// does not end the other's running state or line, and each drawer keeps its own line after.
test('SP20: two Stops running at once in two drawers each keep their own state', async t => {
const data = D => { D.acme.instances.ideas = { definition: 'ideas', running: ['run-4'] }; };
const { b, wait } = await setup(t, { hash: '#/agents?agent=acme%3Acoder', scripts: [FAST], data });
const d = '[data-ws-drawer="acme:coder"]', i = '[data-ws-drawer="acme:ideas"]';
const REQ = '0f0e0d0c-0b0a-4908-8706-050403020101';
const state = x => `[${status(x)}, document.querySelector('${x} [data-drawer-stop]')?.firstChild.textContent, document.querySelector('${x} [data-drawer-stop]')?.disabled, document.querySelector('${x} [data-drawer-restart]')?.disabled]`;
const ask = async x => {
await b.evaluate(`document.querySelector('${x} [data-drawer-stop]').click()`);
await wait(`document.querySelector('${x} [data-drawer-stop-yes]')`);
await b.evaluate(`document.querySelector('${x} [data-drawer-stop-yes]').click()`);
};
const show = async (agent, x) => {
await b.evaluate(`location.hash = "#/agents?agent=acme%3A${agent}"`);
await wait(`${open(`acme:${agent}`)} && document.querySelector('${x} [data-drawer-stop]')`);
};
// Both terminates are held: coder's the bus takes, ideas' it refuses.
await b.evaluate(`window.__answers.push(
{ hold: new Promise(r => { window.__releaseCoder = r; }), status: 200, body: { sent: true, request: '${REQ}' } },
{ hold: new Promise(r => { window.__releaseIdeas = r; }), status: 409, body: { error: 'instance-protected', message: 'instance-protected: ideas is protected from ending. Nothing changed.', sent: false } },
{ status: 200, body: { request: '${REQ}', state: 'closed' } })`);
await wait(`${open('acme:coder')} && document.querySelector('${d} [data-drawer-stop]')`);
await ask(d);
await wait('window.__posts.length === 1');
await show('ideas', i);
await ask(i);
await wait('window.__posts.length === 2');
assert.deepEqual(await b.evaluate(state(i)), ['Stopping ideas…', 'Stopping…', true, true]);
// Coder's Stop ends while ideas' drawer is on screen; ideas' Stop still runs.
await b.evaluate('window.__releaseCoder()');
await wait('window.__posts.length === 3');
await b.evaluate('new Promise(r => setTimeout(r, 300))');
await wait(`${open('acme:ideas')} && document.querySelector('${i} [data-drawer-stop]')`);
assert.deepEqual(await b.evaluate(state(i)), ['Stopping ideas…', 'Stopping…', true, true]);
await show('coder', d);
assert.deepEqual(await b.evaluate(state(d)), ['Stopped coder.', 'Stop', false, false]);
// Ideas' Stop is refused; each drawer keeps its own line.
await show('ideas', i);
assert.deepEqual(await b.evaluate(state(i)), ['Stopping ideas…', 'Stopping…', true, true]);
await b.evaluate('window.__releaseIdeas()');
await wait(`/^Not stopped: /.test(${status(i)}) && ${usable(i)}`);
assert.deepEqual(await b.evaluate(state(i)), ['Not stopped: instance-protected: ideas is protected from ending. Nothing changed.', 'Stop', false, false]);
await show('coder', d);
assert.deepEqual(await b.evaluate(state(d)), ['Stopped coder.', 'Stop', false, false]);
assert.deepEqual((await b.evaluate('window.__posts')).map(p => [p.url, p.method]), [
['/api/orgs/acme/agent/terminate', 'POST'], ['/api/orgs/acme/agent/terminate', 'POST'], [`/api/orgs/acme/agent/request?id=${REQ}`, 'GET']]);
assert.deepEqual((await b.evaluate('window.__posts')).slice(0, 2).map(p => JSON.parse(p.body).instance), ['coder', 'ideas']);
assert.equal(await b.evaluate('window.__answers.length'), 0, 'every queued answer was asked for');
});
+3 -2
View File
@@ -218,8 +218,9 @@ test('row 194 N5: agents.js is served as JavaScript and index.html loads it once
const s = await setup(t);
const js = await get(s, '/agents.js');
assert.equal(js.status, 200); assert.match(js.type, /^text\/javascript/);
// F3 adds the agent restart receipt and the thread test that Settings > Routing uses.
assert.match(js.text, /window\.MosaicAgents = Object\.freeze\(\{ section, restartMarkup, isThread: definition => threadDefinitions\.has\(definition\) \}\)/);
// F3 adds the agent restart receipt and the thread test that Settings > Routing uses; SP19 the
// restart chain the agent drawer calls.
assert.match(js.text, /window\.MosaicAgents = Object\.freeze\(\{ section, restartMarkup, restart: restartAgent, isThread: definition => threadDefinitions\.has\(definition\) \}\)/);
assert.match(js.text, /Agent actions are unavailable here\. Use mosaic org instance from the instance CLI\./);
const html = await get(s, '/');
assert.equal(html.text.match(/<script src="\/agents\.js" defer><\/script>/g)?.length, 1);
+2 -2
View File
@@ -18,8 +18,8 @@ test('served Console browser: real board fixtures, keyboard, drafts, receipts, t
assert.equal(await b.evaluate('document.querySelector("#session-count").textContent'), '3 of 4');
await b.evaluate('document.querySelector("#hide-offline").click()');
assert.equal(await b.evaluate('document.querySelectorAll("table.sessions tbody tr").length'), 4);
// Rows 129, 154, 191, 194 and 294: chat.js, editor.js, processing.js, agents.js and federation.js are the scripts added, and #1839 adds requests.js (the intake panel under an owner's chat message), all same origin; the list is the pin, so another script is a visible change. #797 adds project-archive.js immediately after chat.js. F2 adds onboarding.js after org-create.js, and F3 adds console-restart.js after it. U2 (#1873) adds workspace-data.js and workspace.js before console-restart.js, and U4b adds tasks-board.js after workspace.js. U5 (#1873) added panes.js (Side by side) just before bus.js; SP6 replaces it with assistant.js (the Assistant page), which bus.js mounts.
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("script")].map(s => s.getAttribute("src"))'), ['/editor.js', '/processing.js', '/org-create.js', '/onboarding.js', '/workspace-data.js', '/workspace.js', '/tasks-board.js', '/console-restart.js', '/display.js', '/inbox.js', '/files.js', '/project-remote.js', '/autonomy.js', '/packs.js', '/workflows.js', '/federation.js', '/brand.js', '/app.js', '/markdown-preview.js', '/projects.js', '/chat.js', '/project-archive.js', '/agents.js', '/assistant.js', '/bus.js', '/requests.js']);
// Rows 129, 154, 191, 194 and 294: chat.js, editor.js, processing.js, agents.js and federation.js are the scripts added, and #1839 adds requests.js (the intake panel under an owner's chat message), all same origin; the list is the pin, so another script is a visible change. #797 adds project-archive.js immediately after chat.js. F2 adds onboarding.js after org-create.js, and F3 adds console-restart.js after it. U2 (#1873) adds workspace-data.js and workspace.js before console-restart.js, and U4b adds tasks-board.js after workspace.js. triage-settings (#1873) adds triage-settings.js after console-restart.js. U5 (#1873) added panes.js (Side by side) just before bus.js; SP6 replaces it with assistant.js (the Assistant page), which bus.js mounts.
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("script")].map(s => s.getAttribute("src"))'), ['/editor.js', '/processing.js', '/org-create.js', '/onboarding.js', '/workspace-data.js', '/workspace.js', '/tasks-board.js', '/console-restart.js', '/triage-settings.js', '/display.js', '/inbox.js', '/files.js', '/project-remote.js', '/autonomy.js', '/packs.js', '/workflows.js', '/federation.js', '/brand.js', '/app.js', '/markdown-preview.js', '/projects.js', '/chat.js', '/project-archive.js', '/agents.js', '/assistant.js', '/bus.js', '/requests.js']);
assert.equal(await b.evaluate(`document.querySelectorAll('script[src="/processing.js"]').length`), 1);
assert.equal(await b.evaluate(`document.querySelectorAll('script[src="/chat.js"]').length`), 1);
assert.equal(await b.evaluate('!!window.injected'), false);
+3 -3
View File
@@ -303,12 +303,12 @@ const startWith=async err=>{
assert.equal(s.calls.length,1,'one bus call, never retried');
return {r,s};
};
test('D4 hire start: model-provider-unavailable keeps its code and names Settings > Model proxy',async()=>{
test('D4 hire start: model-provider-unavailable keeps its code and names Settings > Model setup',async()=>{
const {r,s}=await startWith(new BusReadError('model-provider-unavailable'));
assert.equal(r.status,409,r.text);
const body=r.json();
assert.equal(body.error,'model-provider-unavailable');
assert.match(body.message,/Settings > Model proxy/);
assert.match(body.message,/Settings > Model setup/);
assert.match(body.message,/Nothing was applied/);
assert.equal(r.headers['cache-control'],'no-store');
assert.match(s.lines.at(-1),/step=start error=model-provider-unavailable$/);
@@ -373,7 +373,7 @@ test('E2E6 hire start: an apply-phase decision-stale on a fire does not say noth
});
test('E2E6 hire start: invalid-request from the bus says the values, not the shape, were refused',async()=>{
const {r}=await startWith(new BusReadError('invalid-request'));
assert.equal(r.status,400);assert.equal(r.json().error,'invalid-request');assert.match(r.json().message,/Settings > Model proxy/);
assert.equal(r.status,400);assert.equal(r.json().error,'invalid-request');assert.match(r.json().message,/Settings > Routing/);
});
test('E2E6 hire start: the bus server request codes and organization-uncertain stay outcome-unknown',async()=>{
for(const code of ['revision-conflict-revoked','request-timeout','invalid-envelope','incomplete-request','organization-uncertain'])
+29 -3
View File
@@ -6,9 +6,17 @@
// CARDS answer a reply with a cards fence: one valid card, one unknown step
// TOOL <to> call send_message to <to> through the tool socket and answer the raw reply
// SLEEP hang until killed
// REPLY-SLEEP send the person an answer to this message through the tool socket, then hang until killed
// REPLY-SLEEP send the person an answer (class RESULT) to this message through the tool socket, then hang until killed
// NOTE-SLEEP send the person a progress note (class INFO) on this message through the tool socket, then hang until killed
// SPEND <n> add one usage entry of <n> input tokens to the session's spend file (session/spend.jsonl,
// which the host tests' usage source reads as the transcript), then answer "spent <n>"
// GATED-SPEND <n> write work/started, wait for work/gate, then spend <n> as SPEND does
// TOKEN answer the sha256 of ANTHROPIC_AUTH_TOKEN (never the token), or "no token"
// LEAK <s> answer the raw ANTHROPIC_AUTH_TOKEN and then <s>, as a model that prints its env would;
// the host must replace both before the transcript (the key scrub test)
// anything else answer "echo: <body>"
import { existsSync, readFileSync, writeFileSync } from "node:fs";
import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
import { createHash, randomBytes } from "node:crypto";
import { connect } from "node:net";
import { join } from "node:path";
@@ -57,8 +65,26 @@ if (body === "PROBE") {
process.stdout.write(await toolCall("send_message", { to: body.slice(5), body: "from the tool", class: "INFO" }));
} else if (body === "REPLY-SLEEP") {
const id = request.match(/^Message (\S+) from /m)?.[1];
await toolCall("send_message", { to: "human", body: "answered early", class: "INFO", in_reply_to: id });
await toolCall("send_message", { to: "human", body: "answered early", class: "RESULT", in_reply_to: id });
setInterval(() => {}, 1000);
} else if (body === "NOTE-SLEEP") {
const id = request.match(/^Message (\S+) from /m)?.[1];
await toolCall("send_message", { to: "human", body: "still looking", class: "INFO", in_reply_to: id });
setInterval(() => {}, 1000);
} else if (/^(GATED-)?SPEND \d{1,9}$/.test(body)) {
const n = Number(body.split(" ")[1]);
if (body.startsWith("GATED-")) {
writeFileSync(join(workspace, "started"), "x");
while (!existsSync(join(workspace, "gate"))) await new Promise((r) => setTimeout(r, 50));
}
mkdirSync(join(workspace, "..", "session"), { recursive: true });
appendFileSync(join(workspace, "..", "session", "spend.jsonl"), JSON.stringify({ id: randomBytes(6).toString("hex"), n }) + "\n");
process.stdout.write(`spent ${n}`);
} else if (body === "TOKEN") {
const token = process.env.ANTHROPIC_AUTH_TOKEN;
process.stdout.write(token ? `token sha256 ${createHash("sha256").update(token).digest("hex")}` : "no token");
} else if (body.startsWith("LEAK ")) {
process.stdout.write(`env: ANTHROPIC_AUTH_TOKEN=${process.env.ANTHROPIC_AUTH_TOKEN ?? ""} other=${body.slice(5)}`);
} else if (body === "SLEEP") {
setInterval(() => {}, 1000);
} else {
@@ -89,7 +89,7 @@ for (const [width, height] of [[1440, 900], [390, 844]]) test(`D4 the org-mode i
await b.evaluate('document.querySelector("#hire-start-form").requestSubmit()');
await wait('document.querySelector("#hire-start-status code")');
assert.equal(await text('#hire-start-status code'), 'model-provider-unavailable');
assert.match(await text('#hire-start-status'), /Settings > Model proxy/);
assert.match(await text('#hire-start-status'), /Settings > Model setup/);
assert.doesNotMatch(await text('#hire-start-status'), /may have reached the bus/);
const start = calls.filter(c => c.verb === 'hire.start.console');
assert.equal(start.length, 1, 'one start, never retried');
@@ -155,7 +155,7 @@ test('D4 a hire answer that arrives during a slow inbox read keeps its status af
release();
await wait('document.querySelector("[data-ws-inbox]") !== window.__marker && document.querySelector("#hire-start-form")');
assert.equal(await b.evaluate('document.querySelector("#hire-start-status code")?.textContent ?? null'), 'model-provider-unavailable');
assert.match(await b.evaluate('document.querySelector("#hire-start-status").innerText'), /Settings > Model proxy/);
assert.match(await b.evaluate('document.querySelector("#hire-start-status").innerText'), /Settings > Model setup/);
assert.equal(calls.filter(c => c.verb === 'hire.start.console').length, 1);
});
@@ -279,3 +279,24 @@ test('At 390 wide the tiles sit two to a row with no sideways scroll, on the Das
assert.equal(await cols('[data-org-tiles]'), 2);
assert.equal(await b.evaluate('document.documentElement.scrollWidth <= document.documentElement.clientWidth'), true, 'organization page');
});
test('SP18: at 1440 and 1024 the Dashboard\'s two columns line up with the tile row above them', async t => {
const { b, wait } = await setup(t, { viewport: [1440, 1000] });
await wait(homeReady);
// The left column ends where a tile ends and the right column starts where the next tile starts: the fourth
// and fifth of six at 1440, the second and third of three a row at 1024.
const edges = () => b.evaluate(`(() => {
const tiles = [...document.querySelectorAll('[data-ws-home] [data-ws-tile]')].map(e => e.getBoundingClientRect());
const cols = [...document.querySelectorAll('[data-ws-home] .ws-home-split>*')].map(e => e.getBoundingClientRect());
return { rights: tiles.map(r => Math.round(r.right)), lefts: tiles.map(r => Math.round(r.left)), left: cols[0] && [Math.round(cols[0].left), Math.round(cols[0].right)], right: cols[1] && [Math.round(cols[1].left), Math.round(cols[1].right)] };
})()`);
for (const [w, nth] of [[1440, 4], [1024, 2]]) {
await b.viewport(w, 1000);
await b.evaluate('new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))');
const e = await edges();
assert.ok(e.left && e.right && e.right[0] > e.left[1], `two columns side by side at ${w}: ${JSON.stringify(e)}`);
assert.ok(Math.abs(e.left[1] - e.rights[nth - 1]) <= 1, `at ${w} the left column ends with tile ${nth}: ${JSON.stringify(e)}`);
assert.ok(Math.abs(e.right[0] - e.lefts[nth]) <= 1, `at ${w} the right column starts with tile ${nth + 1}: ${JSON.stringify(e)}`);
assert.ok(Math.abs(e.right[1] - Math.max(...e.rights)) <= 1, `at ${w} the right column ends with the row`);
}
});
+143 -1
View File
@@ -8,7 +8,7 @@ import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { createOrgAdmin, orgAdminHTTP, browserProblems, pathFromMessage, toCanonical, forBrowser, plainMessage } from '../src/org-admin.mjs';
import { createOrgAdmin, defaultOrgAdmin, removalRecorder, orgAdminHTTP, browserProblems, pathFromMessage, toCanonical, forBrowser, plainMessage } from '../src/org-admin.mjs';
import { actionTrail } from '../src/action-trail.mjs';
import { close } from './fixture.mjs';
@@ -1074,3 +1074,145 @@ test('stop: an archived organization, or a Console whose bus control has no stop
assert.equal(c.calls.filter(x => ['busStop', 'busRestart'].includes(x[0])).length, 0);
assert.deepEqual(tr.lines(), []);
});
// #1873 ride-default slice 1: the cliproxy preset reads the owner's catalogue through the
// `ownerModels` seam and routes a new organization only to a model that catalogue lists.
test('the cliproxy preset uses the owner\'s catalogue and refuses a model it does not list', async t => {
const service = await import('../../organization/src/org-service.mjs');
const row = (over = {}) => ({ key: 'claude-claude-opus-5-5', module: 'cliproxy', upstream: 'claude', provider: 'anthropic', model: 'claude-opus-5-5', label: 'claude / claude-opus-5-5', available: true, reason: null, harnesses: ['claude-code', 'pi'], ...over });
let owner = { proxy: true, riding: true, models: [row({ key: 'zai-glm-5-3', upstream: 'zai', provider: 'zai', model: 'glm-5.3', harnesses: ['pi'] }), row(), row({ key: 'claude-claude-haiku-5-5', model: 'claude-haiku-5-5', available: false, reason: 'no-account' })] };
const admin = createOrgAdmin({ service, context: async () => ({ configDir: '/cfg', dataRoot: '/data', instance: 'test' }), ownerModels: async () => owner });
const c = await console_(t, { orgAdmin: admin });
const presetOf = async () => (await c.call('GET', '/api/org-presets')).body.presets.find(p => p.name === 'cliproxy');
assert.deepEqual((await presetOf()).available, { ok: true });
const picked = await c.call('GET', '/api/org-template?id=alpha&preset=cliproxy');
assert.equal(picked.status, 200, picked.raw);
assert.deepEqual(Object.keys(picked.body.doc.launch.models), ['claude-claude-opus-5-5'], 'claude comes first');
assert.equal(picked.body.doc.roles.assistant.vars.model, 'claude-claude-opus-5-5');
const named = await c.call('GET', '/api/org-template?id=alpha&preset=cliproxy&model=zai-glm-5-3');
assert.equal(named.status, 200, named.raw);
assert.deepEqual(named.body.doc.roles.assistant.vars, { harness: 'pi', model: 'zai-glm-5-3', thinking: 'low' });
for (const model of ['claude-claude-haiku-5-5', 'gpt-x', 'not%20a%20key']) {
const r = await c.call('GET', `/api/org-template?id=alpha&preset=cliproxy&model=${model}`);
assert.equal(r.status, 422, model); assert.equal(r.body.errors[0].path, '$.model', model);
}
assert.equal((await c.call('GET', '/api/org-template?id=alpha&preset=fixture&model=claude-claude-opus-5-5')).status, 422, 'model is for the cliproxy preset only');
owner = { ...owner, riding: false };
assert.match((await presetOf()).available.reason, /No organization uses the model proxy yet/);
const none = await c.call('GET', '/api/org-template?id=alpha&preset=cliproxy');
assert.equal(none.status, 422); assert.equal(none.body.errors[0].path, '$.model');
owner = null; admin.ownerModels = createOrgAdmin({ service, context: async () => ({}), ownerModels: async () => { throw new Error('bus down'); } }).ownerModels;
assert.match((await presetOf()).available.reason, /Set up the model proxy first/, 'a failing catalogue read is no proxy');
});
// #1873 ride-default round 3 (P1): a save on the admin page that drops cliproxy from the model
// providers leaves a ride-removed record first, so the next Ride all leaves the organization off.
test('a save that takes cliproxy off records the removal before it writes, and saves nothing when it cannot', async t => {
const removed = [];
let fail = null;
const f = fakes();
const admin = createOrgAdmin({ service: f.service, registry: await f.admin.registry(), bus: null, context: async () => ({ configDir: '/cfg', dataRoot: '/data', instance: 'test' }), rideRemoved: async id => { if (fail) throw fail; removed.push(id); } });
const c = await console_(t, { orgAdmin: admin });
const d = { call: c.call, orgs: f.orgs, calls: f.calls };
await d.call('POST', '/api/orgs', { id: 'acme', doc: browserDoc('acme') });
d.orgs.get('acme').doc.plugins = { 'model-provider': ['cliproxy', 'openai'] };
const save = async providers => {
const shown = await d.call('GET', '/api/orgs/acme/admin');
const doc = shown.body.doc; doc.plugins = { 'model-provider': providers };
return d.call('POST', '/api/orgs/acme/admin', { doc, ifRevision: shown.body.revision });
};
// Keeping cliproxy records nothing.
let r = await save(['cliproxy']);
assert.equal(r.status, 200, r.raw); assert.deepEqual(removed, []);
// The hook fails: nothing is saved.
fail = new Error('disk full /data/state/proxy-admin.jsonl');
r = await save(['openai']);
assert.equal(r.status, 500, r.raw); assert.equal(r.body.error, 'internal');
assert.doesNotMatch(r.raw, /proxy-admin\.jsonl|disk full/);
assert.deepEqual(d.orgs.get('acme').doc.plugins['model-provider'], ['cliproxy']);
fail = null;
const updates = d.calls.filter(x => x[0] === 'updateOrg').length;
r = await save(['openai']);
assert.equal(r.status, 200, r.raw); assert.deepEqual(removed, ['acme']);
assert.equal(d.calls.filter(x => x[0] === 'updateOrg').length, updates + 1);
assert.deepEqual(d.orgs.get('acme').doc.plugins['model-provider'], ['openai']);
// A Console wired without the record refuses that save.
const plain = await console_(t);
await plain.call('POST', '/api/orgs', { id: 'acme', doc: browserDoc('acme') });
plain.orgs.get('acme').doc.plugins = { 'model-provider': ['cliproxy'] };
const shown = await plain.call('GET', '/api/orgs/acme/admin');
const doc = shown.body.doc; doc.plugins = { 'model-provider': [] };
r = await plain.call('POST', '/api/orgs/acme/admin', { doc, ifRevision: shown.body.revision });
assert.equal(r.status, 503, r.raw); assert.equal(r.body.error, 'not-configured');
assert.deepEqual(plain.orgs.get('acme').doc.plugins['model-provider'], ['cliproxy']);
assert.equal(plain.calls.some(x => x[0] === 'updateOrg'), false);
});
// The reviewer's two P1 probes end to end: the real organization service, the admin page route,
// the real proxy admin and its receipts, and the organization file and change log as Ride all reads them.
test('against the real C2 service: an organization saved without cliproxy on its admin page is skipped by Ride all as removed', async t => {
const service = await import('../../organization/src/org-service.mjs');
const registry = await import('../../organization/src/org-registry.mjs');
const { organizationWriter } = await import('../../organization/src/organization.mjs');
const { createProxyAdmin } = await import('../../model-proxy/src/admin-control.mjs');
const { readRider } = await import('../../model-proxy/src/ride.mjs');
const { orgUsesFixture } = await import('../../cli/src/dev-fixture.mjs');
const { mkdtempSync, mkdirSync, readFileSync, rmSync } = await import('node:fs');
const { join, resolve, dirname } = await import('node:path'); const { tmpdir } = await import('node:os'); const { fileURLToPath } = await import('node:url');
const root = mkdtempSync(join(tmpdir(), 'oar')); const configDir = join(root, 'config'), dataRoot = join(root, 'data');
t.after(() => rmSync(root, { recursive: true, force: true }));
mkdirSync(configDir, { mode: 0o700 }); mkdirSync(dataRoot, { mode: 0o700 });
const rolesDir = resolve(dirname(fileURLToPath(import.meta.url)), '../../../roles');
const writes = [];
const busFor = id => async (verb, args) => {
if (verb === 'plugins') return { revision: 'r', plugins: { 'model-provider': organizationWriter({ dir: configDir, rolesDir }).read(id).document.plugins?.['model-provider'] ?? [] } };
if (verb === 'proxy.accounts') return { accounts: [] };
if (verb === 'plugins.set') { writes.push(id); return { revision: 'r2' }; }
throw new Error(`unexpected ${verb}`);
};
const riders = async () => ['made', 'settings'].map(id => {
const writer = organizationWriter({ dir: configDir, rolesDir });
return { ...readRider({ id, read: () => writer.read(id).document, readLog: () => readFileSync(writer.logFile(id), 'utf8'), isFixture: orgUsesFixture }), call: busFor(id) };
});
const proxy = createProxyAdmin({ dataRoot, configDir, unit: { unit: 'u', status: async () => ({}) }, buses: async () => ({ stopped: true, running: [] }), fetch: async () => ({}), riders });
const admin = createOrgAdmin({ service, registry, bus: null, context: async () => ({ configDir, dataRoot, instance: 'test' }), rideRemoved: id => proxy.rideRemoved(id) });
const c = await console_(t, { orgAdmin: admin });
const tpl = (await c.call('GET', '/api/org-template?id=made')).body.doc;
// Probe a: made on cliproxy (as the preset makes it), then saved without it on the admin page.
const made = await c.call('POST', '/api/orgs', { id: 'made', doc: { ...tpl, plugins: { 'model-provider': ['cliproxy'] } } });
assert.equal(made.status, 201, made.raw);
// Probe b: cliproxy added through the organization writer (as the Settings page's bus plugins.set writes it, with a change-log entry), then removed on the admin page.
const tpl2 = (await c.call('GET', '/api/org-template?id=settings')).body.doc;
assert.equal((await c.call('POST', '/api/orgs', { id: 'settings', doc: tpl2 })).status, 201);
const writer = organizationWriter({ dir: configDir, rolesDir });
const current = writer.read('settings');
writer.write('settings', { ...current.document, plugins: { ...(current.document.plugins ?? {}), 'model-provider': ['cliproxy'] } }, { revision: current.revision, actor: current.document.human });
assert.match(readFileSync(writer.logFile('settings'), 'utf8'), /cliproxy/);
for (const id of ['made', 'settings']) {
const shown = await c.call('GET', `/api/orgs/${id}/admin`);
assert.deepEqual(shown.body.doc.plugins['model-provider'], ['cliproxy'], id);
const doc = shown.body.doc; doc.plugins = { 'model-provider': [] };
const r = await c.call('POST', `/api/orgs/${id}/admin`, { doc, ifRevision: shown.body.revision });
assert.equal(r.status, 200, r.raw);
}
const result = await proxy.rideAll();
assert.deepEqual(result.added, []);
assert.deepEqual(result.skipped, [{ id: 'made', reason: 'removed' }, { id: 'settings', reason: 'removed' }]);
assert.deepEqual(writes, [], 'Ride all put cliproxy back on neither');
});
test('a Console without the proxy setup page records the removal in the instance\'s proxy receipts, and refuses with no data root', async t => {
const { riddenOrgs } = await import('../../model-proxy/src/ride.mjs');
const { receiptsText } = await import('../../model-proxy/src/admin.mjs');
const dataRoot = mkdtempSync(join(tmpdir(), 'oarr')); t.after(() => rmSync(dataRoot, { recursive: true, force: true }));
const record = await removalRecorder(async () => ({ dataRoot }))('acme');
assert.equal(record.op, 'ride-removed'); assert.equal(record.org, 'acme');
assert.deepEqual([...riddenOrgs(receiptsText(dataRoot))], ['acme']);
await assert.rejects(removalRecorder(async () => null)('acme'), /not-configured/);
});
test('the default Console wiring always has a removal recorder, and keeps the one it is given', () => {
assert.equal(typeof defaultOrgAdmin({}).rideRemoved, 'function');
const given = async () => ({ op: 'ride-removed' });
assert.equal(defaultOrgAdmin({}, { rideRemoved: given }).rideRemoved, given);
});
@@ -180,6 +180,20 @@ test('the Settings card fits at 1440 with the drawer open, at 735 and 390 withou
assert.deepEqual(cols[1].heads, ['Settings']);
const gap = await b.evaluate(`(() => { const left = document.querySelector('#bus-view .ws-dash>.ws-split>section'), card = left.querySelector('[data-wfg-card]'), above = card.previousElementSibling; return Math.round(card.getBoundingClientRect().top - above.getBoundingClientRect().bottom); })()`);
assert.ok(gap >= 0 && gap <= 40, `the Workflows card follows the sessions directly: ${gap}px`);
// SP18: Autonomy and Starter packs follow the Workflows card in the left column, so the left column is not
// empty beside the long Settings card and nothing runs full width below it.
const left = await b.evaluate(`(() => { const s = [...document.querySelectorAll('#bus-view .ws-dash>.ws-split>section')]; return { autonomy: !!s[0].querySelector('[data-autonomy]'), packs: !!s[0].querySelector('[data-packs]'), after: !!document.querySelector('#bus-view .ws-dash>.ws-split ~ :is(div,section):not([data-ws-drawer])'), ends: s.map(x => Math.round(x.getBoundingClientRect().bottom)) }; })()`);
assert.equal(left.autonomy && left.packs, true, `Autonomy and Starter packs are in the left column: ${JSON.stringify(left)}`);
assert.equal(left.after, false, 'no full-width block under the split');
// How near level the two end depends on the data: in this fixture Autonomy is a one-line refusal and no pack
// is installed, so the Settings card is still the taller. The left column ends with Starter packs.
assert.ok(await b.evaluate(`Math.abs(document.querySelector('#bus-view .ws-dash>.ws-split>section [data-packs]').getBoundingClientRect().bottom - document.querySelector('#bus-view .ws-dash>.ws-split>section').getBoundingClientRect().bottom) <= 1`), `the left column ends with Starter packs: ${JSON.stringify(left.ends)}`);
// At 390 the page is one column: sessions, Workflows, Autonomy, Starter packs, then Settings.
await b.viewport(390, 844);
await b.evaluate('new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)))');
const order = await b.evaluate(`[...document.querySelectorAll('#bus-view .ws-dash>.ws-split h2, #bus-view .ws-dash>.ws-split h3')].map(h => h.textContent.trim()).filter(x => ['Active agent sessions', 'Workflows', 'Autonomy', 'Starter packs', 'Settings'].includes(x))`);
assert.deepEqual(order, ['Active agent sessions', 'Workflows', 'Autonomy', 'Starter packs', 'Settings']);
assert.ok(await b.evaluate('document.documentElement.scrollWidth <= document.documentElement.clientWidth'), 'no sideways scroll at 390');
});
test('the bare organization address with a query is the organization page, query kept; ?agent= opens the drawer', async t => {
+5 -3
View File
@@ -262,8 +262,10 @@ test('SP6 GET /workflows returns the org and code-project workflows, the role na
assert.deepEqual(body.projects, Object.fromEntries(Object.entries(doc.projects).map(([id, p]) => [id, p.workflows ?? {}])));
assert.deepEqual(body.projects.stack, doc.projects.stack.workflows);
assert.deepEqual(body.roles.definitions, ['triage']);
assert.deepEqual(body.roles.templates, templateHashes(join(f.root, 'roles')).map(x => x.template).sort());
assert.ok(body.roles.templates.includes('coder') && !body.roles.templates.includes('ghost'));
// #1873 triage-followups: the shipped triage template is system-only, so the read leaves it out.
assert.ok(templateHashes(join(f.root, 'roles')).some(x => x.template === 'triage'), 'the fixture ships the triage template');
assert.deepEqual(body.roles.templates, templateHashes(join(f.root, 'roles')).map(x => x.template).filter(n => n !== 'triage').sort());
assert.ok(body.roles.templates.includes('coder') && !body.roles.templates.includes('ghost') && !body.roles.templates.includes('triage'));
assert.equal(body.revision, createHash('sha256').update(readFileSync(f.file)).digest('hex'), 'the revision is the writer\'s: the hash of the file bytes');
assert.equal(body.writable, true);
assert.equal(JSON.stringify(body).includes(f.root), false, 'no host path leaves');
@@ -283,7 +285,7 @@ test('SP6 GET /workflows returns the org and code-project workflows, the role na
test('SP6 GET /workflows leaves out a library project and answers outcome-unknown for a read it cannot trust', async t => {
const REV = 'a'.repeat(64);
const read = { document: { projects: { code: { workflows: { w: FLOW('W') } }, lib: { kind: 'library', workflows: { never: FLOW('N') } }, bare: {} } }, revision: REV, templates: ['coder', 7] };
const read = { document: { projects: { code: { workflows: { w: FLOW('W') } }, lib: { kind: 'library', workflows: { never: FLOW('N') } }, bare: {} } }, revision: REV, templates: ['coder', 7, 'triage'] };
const f = await fixture(t, { workflows: () => read });
const [status, body] = await call(f, `${ORG}/workflows`);
assert.equal(status, 200, JSON.stringify(body));
+33 -3
View File
@@ -18,6 +18,8 @@ const ROUTES = [
['status', 'GET'], ['unit/render', 'GET'], ['fetch', 'POST', {}], ['init', 'POST', { generate: true }],
['unit/install', 'POST', {}], ['unit/start', 'POST', {}], ['unit/stop', 'POST', {}], ['unit/restart', 'POST', {}],
['fence/clear', 'POST', {}], ['init-lock/clear', 'POST', {}],
// #1873 ride-default: Ride all, and the move of one stopped fixture organization.
['ride-all', 'POST', {}], ['ride-move', 'POST', { org: 'stand-in' }],
];
function fakeAdmin() {
@@ -26,7 +28,8 @@ function fakeAdmin() {
return {
calls,
unit: 'mosaic-proxy.service',
status: note('status'), render: note('render'), unitAction: note('unitAction'), initLockClear: note('initLockClear'),
status: note('status'), render: note('render'), unitAction: note('unitAction'), initLockClear: note('initLockClear'), rideAll: note('rideAll'),
rideMove: async args => { calls.push(['rideMove', args]); return { org: args.org, moved: false, reason: 'bus-running' }; },
fetchStart: () => { calls.push(['fetchStart']); return { state: 'running' }; },
init: async (call, args) => { calls.push(['init', args]); await call('proxy.init', args); return { settings: { port: 18432 }, receipt: { op: 'init' } }; },
fenceClear: async call => { calls.push(['fenceClear']); return call('proxy.fence.clear', { evidence: {} }); },
@@ -51,7 +54,7 @@ async function devServer(t, options = {}) {
}
const hit = (f, route, extra = {}) => send(f.port, `/api/proxy/admin/${route[0]}`, { method: route[1], headers: { ...f.headers(), ...extra }, body: route[2] });
test('the route table is exactly the brief: status, render, fetch, init, four unit verbs, fence clear, lock clear', () => {
test('the route table is exactly the brief: status, render, fetch, init, four unit verbs, fence clear, lock clear, ride all, ride move', () => {
assert.deepEqual(PROXY_ADMIN_PATHS, ROUTES.map(([p]) => `/api/proxy/admin/${p}`));
});
@@ -61,7 +64,7 @@ test('the dev local owner reaches every route; init and fence clear go to the bu
const r = await hit(f, route);
assert.equal(r.status, route[0] === 'fetch' ? 202 : 200, route[0]);
}
assert.deepEqual(f.admin.calls.map(c => c[0]), ['status', 'render', 'fetchStart', 'init', 'unitAction', 'unitAction', 'unitAction', 'unitAction', 'fenceClear', 'initLockClear']);
assert.deepEqual(f.admin.calls.map(c => c[0]), ['status', 'render', 'fetchStart', 'init', 'unitAction', 'unitAction', 'unitAction', 'unitAction', 'fenceClear', 'initLockClear', 'rideAll', 'rideMove']);
assert.deepEqual(f.admin.calls.filter(c => c[0] === 'unitAction').map(c => c[1]), ['install', 'start', 'stop', 'restart']);
assert.deepEqual(f.busCalls.map(c => c[0]), ['proxy.init', 'proxy.fence.clear']);
assert.deepEqual(f.busCalls[0][1], { generate: true });
@@ -203,3 +206,30 @@ test('an organization whose bus does not answer shows no model count, not a made
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'enabled', models: [{ id: 'a' }, { id: 'b' }] } })), { status: 'enabled', models: 2 });
assert.deepEqual(await orgCatalogue(async () => ({ catalogue: { status: 'enabled', models: [] } })), { status: 'enabled', models: 0 });
});
test('ride move takes one organization id and passes the signed-in owner as the principal', async t => {
const f = await devServer(t);
for (const body of [{}, { org: '' }, { org: '../x' }, { org: 'A' }, { org: 7 }, { org: 'x', extra: 1 }])
assert.deepEqual((await hit(f, ['ride-move', 'POST', body])).json, { error: 'invalid-request' }, JSON.stringify(body));
assert.deepEqual((await hit(f, ['ride-all', 'POST', { org: 'x' }])).json, { error: 'invalid-request' }, 'ride all takes no arguments');
assert.deepEqual(f.admin.calls, []);
const r = await hit(f, ['ride-move', 'POST', { org: 'stand-in' }]);
assert.deepEqual(r.json, { org: 'stand-in', moved: false, reason: 'bus-running' });
assert.deepEqual(f.admin.calls, [['rideMove', { org: 'stand-in', principal: { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner' } }]]);
f.admin.rideAll = async () => { throw Object.assign(new Error(`${SENTINEL} busy`), { code: 'proxy-admin-busy' }); };
const busy = await hit(f, ['ride-all', 'POST', {}]);
assert.deepEqual(busy.json, { error: 'proxy-admin-busy' });
assert.equal(busy.text.includes(SENTINEL), false);
});
test('a signed-in member who is not the instance owner gets human-required for ride all and ride move', async t => {
const organizations = { list: async () => [], resolve: async id => (id === 'x' ? { busHealthy: true } : null) };
const member = await devServer(t, { organizations, sso: { ...createDevOwner(), session: () => ({ name: 'Bob', provider: 'local-dev', iss: 'local-dev', sub: 'bob', rootOwner: false, instanceRole: 'member' }) } });
for (const route of ROUTES.filter(([p]) => p.startsWith('ride-'))) {
const inOrg = await send(member.port, `/api/orgs/x/proxy/admin/${route[0]}`, { method: route[1], headers: member.headers(), body: route[2] });
assert.equal(inOrg.status, 403, route[0]); assert.deepEqual(inOrg.json, { error: 'human-required' }, route[0]);
const plain = await hit(member, route);
assert.equal(plain.status >= 400 && plain.status < 500, true, `${route[0]} outside an organization is refused`);
}
assert.deepEqual(member.admin.calls, []);
});
+2 -2
View File
@@ -85,14 +85,14 @@ test('proxy browser read-only disables account changes', { timeout: 60000 }, asy
test('proxy read refusal is visible and never reported as loaded', { timeout: 60000 }, async t => {
const { b, wait } = await setup(t, false, '/accounts');
await wait('document.querySelector("#proxy-message").textContent.includes("not configured")');
await wait('document.querySelector("#proxy-message").textContent.includes("not set up")');
assert.equal(await b.evaluate('document.querySelector("#proxy-message").textContent.includes("loaded")'), false);
});
test('proxy write refusal never reports success or exposes the submitted key', { timeout: 60000 }, async t => {
const { b, wait } = await setup(t, false, '/apikey/add');
await b.evaluate('document.querySelector("#proxy-apikey input").value="refused-secret-canary";document.querySelector("#proxy-apikey").requestSubmit();true');
await wait('document.querySelector("#proxy-message").textContent.includes("not configured")');
await wait('document.querySelector("#proxy-message").textContent.includes("not set up")');
assert.equal(await b.evaluate('document.querySelector("#proxy-message").textContent.includes("added")'), false);
assert.equal(await b.evaluate('document.documentElement.outerHTML.includes("refused-secret-canary")'), false);
assert.equal(await b.evaluate('document.querySelector("#proxy-apikey input").value'), '');
+10
View File
@@ -180,6 +180,16 @@ test('proxy refuses route and body mismatch, unavailable transport, and bus refu
}
});
test('a not-configured refusal relays the bus\'s one cause line, bounded; no other code carries a reason', async t => {
const cause = 'The model proxy management key does not load (proxy-management-key-invalid). ';
const bus = await setup(t, { proxyCall: async () => { throw Object.assign(new Error('private'), { code: 'not-configured', reason: cause.repeat(5) }); } });
const r = await call(bus.s, '/api/proxy/accounts');
assert.equal(r.status, 503);
assert.deepEqual(JSON.parse(r.text), { error: 'not-configured', reason: cause.repeat(5).slice(0, 300) });
const other = await setup(t, { proxyCall: async () => { throw Object.assign(new Error('private'), { code: 'proxy-down', reason: cause }); } });
assert.deepEqual(JSON.parse((await call(other.s, '/api/proxy/accounts')).text), { error: 'proxy-down' });
});
test('ambiguous model mappings pass their named refusal to the owner', async t => {
const {s}=await setup(t,{proxyCall:async()=>{throw Object.assign(new Error('private'),{code:'models-ambiguous'});}});
const response=await call(s,'/api/proxy/group/models/set','POST',{accountId:'a'.repeat(12),models:['fixture']});
@@ -32,7 +32,7 @@ test('a fresh instance shows the fetch step as one button, the not-built own pro
assert.match(await b.evaluate('document.querySelector("#proxy-setup-next p").textContent'), /CLIProxyAPI 8\.0\.42/);
assert.match(await b.evaluate('document.querySelector("#proxy-setup-own").textContent'), /not built/);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-orgs td").textContent'), 'acme');
await wait('document.querySelector("#proxy-message")?.textContent.includes("Follow the next step under Proxy setup")');
await wait('document.querySelector("#proxy-message")?.textContent.includes("Follow the next step under Set up the model service")');
assert.equal(await b.evaluate('!!document.querySelector("#proxy-dev-setup")'), false, 'the page replaces the terminal note');
assert.equal(await b.evaluate('document.querySelectorAll("#proxy-setup-init [data-setup-write]:not([disabled])").length'), 0, 'init waits for a verified release');
await b.evaluate('document.querySelector("#proxy-setup-go").click()');
@@ -113,7 +113,7 @@ test('an initialized proxy whose accounts read fails with another code also hide
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(installed), ...failing, 'POST /api/proxy/admin/unit/start': { body: { receipt: { op: 'unit.start', time: T, pid: 4242 } } } } });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="unit-start"');
await wait('document.querySelector("#proxy-message").textContent.includes("the account panels return once the proxy answers")');
await wait('document.querySelector("#proxy-message").textContent.includes("the account panels return once the service answers")');
assert.equal(await b.evaluate('document.querySelector("[aria-labelledby=proxy-accounts-title]").hidden'), true);
await b.evaluate(`Object.assign(window.__scenario, {
'GET /api/proxy/accounts': { body: { accounts: [] } }, 'GET /api/proxy/keys': { body: { keys: [] } },
@@ -129,7 +129,13 @@ test('a fence with no readable time names the --proxy-restarted path instead of
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(timeless) });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="unit-restart"');
assert.match(await b.evaluate('document.querySelector("#proxy-setup-next p").textContent'), /no readable time.*mosaic proxy fence clear --proxy-restarted/);
const text = await b.evaluate('document.querySelector("#proxy-setup-next > p").textContent');
assert.match(text, /no readable time.*restart the model service, confirm it answers, then clear the fence\./);
assert.doesNotMatch(text, /proxy/i, 'owner text says model service');
// The exact command sits under Technical details, folded, with where to run it.
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-next details.proxy-setup-cli").open'), false);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-next details.proxy-setup-cli summary").textContent'), 'Technical details');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-next details.proxy-setup-cli p").textContent'), 'Run this in a terminal on this machine: mosaic proxy fence clear --proxy-restarted');
});
test('after a reload the receipts come from status, and an initialized proxy folds the init form', { timeout: 90000 }, async t => {
@@ -144,3 +150,210 @@ test('after a reload the receipts come from status, and an initialized proxy fol
await wait('window.__writes.some(w=>w.path==="/api/proxy/admin/unit/install")');
await wait('document.querySelector("#proxy-setup-init-box").open===false');
});
// #1873 ride-default: the Ride all box. The confirm names the stricter admission, the answer's
// skips and stand-in organizations are painted even while an earlier load still waits on the
// accounts read, and the move confirm says the organization spends real tokens after it.
test('Ride all confirms the stricter admission, paints skips and stand-in organizations while a load waits, and the move warns of real tokens', { timeout: 90000 }, async t => {
const running = { ...fenced, fence: { set: false }, restart: null, next: ['ride-all'],
ride: [{ id: 'north', state: 'ready' }, { id: 'south', state: 'ready' }, { id: 'west', state: 'fixture' }] };
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(running),
'POST /api/proxy/admin/ride-all': { body: { added: ['south'], already: [], skipped: [], fixtures: [{ id: 'west' }], receipt: { op: 'ride.all', time: T } } },
'POST /api/proxy/admin/ride-move': { body: { moved: false, reason: 'bus-running' } } } });
// The first accounts and keys reads answer not-configured; every later pair never answers, so a load stays in flight.
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: `(() => { const inner = window.fetch; let n = 0; window.__confirms = [];
window.confirm = text => { window.__confirms.push(text); return true; };
window.fetch = (input, init) => { const url = String(typeof input === 'string' ? input : input.url);
if (url.includes('/api/proxy/accounts') && n++ > 0) return new Promise(() => {});
if (url.includes('/api/proxy/keys') && n > 1) return new Promise(() => {});
return inner(input, init); }; })();` });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelector("#proxy-ride")?.hidden===false && document.querySelector("#proxy-setup-go")?.dataset.next==="ride-all"');
assert.match(await b.evaluate('document.querySelector("#proxy-ride-text").textContent'), /every launch route is checked, direct Anthropic routes too.*2 organizations can ride now/);
assert.match(await b.evaluate('document.querySelector("#proxy-ride-fixtures li").textContent'), /^west uses stand-in models, can be moved to the owner's models\./);
// The first Ride all's own reload paints, then waits on the accounts read for good.
await b.evaluate('document.querySelector("#proxy-ride-go").click()');
await wait('window.__writes.some(w=>w.path==="/api/proxy/admin/ride-all")');
assert.match(await b.evaluate('window.__confirms[0]'), /Admission gets stricter there: every launch route is checked, direct Anthropic routes too, and while the proxy is down or fenced every launch in that organization is refused/);
await wait('document.querySelector("#proxy-ride-message").textContent.includes("Added to 1")');
await wait('document.querySelector("#proxy-ride-go").disabled===false');
// The second answer lands while that load is still in flight.
await b.evaluate(`window.__scenario['POST /api/proxy/admin/ride-all'] = { body: ${JSON.stringify({ added: [], already: ['south'], skipped: [{ id: 'north', reason: 'no-proxy-client' }], fixtures: [{ id: 'west', running: true }], receipt: { op: 'ride.all', time: T } })} }`);
await b.evaluate('document.querySelector("#proxy-ride-go").click()');
await wait('window.__writes.filter(w=>w.path==="/api/proxy/admin/ride-all").length===2');
await wait('document.querySelector("#proxy-ride-message").textContent.includes("skipped 1")');
await wait('document.querySelectorAll("#proxy-ride-skips li").length===1');
assert.equal(await b.evaluate('document.querySelector("#proxy-ride-skips li").textContent'), 'Skipped north: Its bus started before the proxy was set up. Restart its bus, then ride again.');
assert.match(await b.evaluate('document.querySelector("#proxy-ride-fixtures li").textContent'), /Its bus is running: stop it first\./);
assert.equal(await b.evaluate('document.querySelector("#proxy-ride-go").disabled'), false, 'the box is not left busy');
await b.evaluate('document.querySelector("[data-ride-move=west]").click()');
await wait('window.__writes.some(w=>w.path==="/api/proxy/admin/ride-move")');
assert.match(await b.evaluate('window.__confirms[2]'), /^Move west to your models\?.*its agents spend real tokens on your account/);
assert.deepEqual(JSON.parse(await b.evaluate('window.__writes.find(w=>w.path==="/api/proxy/admin/ride-move").body')), { org: 'west' });
// Re-check 3 (P3-2): a running bus and a bus whose state cannot be read get the same refusal, in words that fit both.
await wait(`document.querySelector("#proxy-ride-message").textContent===${JSON.stringify('west was not moved. Its bus is running, or its state could not be read. Stop or recover its bus, then move it.')}`);
// Round 3 (P3): an SSO Console's org-forbidden in plain words, and the neutral fallback for a code the page does not know.
for (const [n, reason, text] of [[2, 'org-forbidden', 'west was not moved. Moving organizations is not available on this Console yet. It works on a local development Console.'],
[3, 'frobnicated', 'west was not moved. The change was refused (frobnicated).']]) {
await b.evaluate(`window.__scenario['POST /api/proxy/admin/ride-move'] = { body: ${JSON.stringify({ moved: false, reason })} }`);
await wait('document.querySelector("[data-ride-move=west]")?.disabled===false');
await b.evaluate('document.querySelector("[data-ride-move=west]").click()');
await wait(`window.__writes.filter(w=>w.path==="/api/proxy/admin/ride-move").length===${n}`);
await wait(`document.querySelector("#proxy-ride-message").textContent===${JSON.stringify(text)}`);
}
// Round 3: an organization the proxy was or may have been on, and an add the receipt could not record first.
await b.evaluate(`window.__scenario['POST /api/proxy/admin/ride-all'] = { body: ${JSON.stringify({ added: [], already: [], skipped: [{ id: 'north', reason: 'removed' }, { id: 'south', reason: 'not-recorded' }, { id: 'east', reason: 'unreadable' }], fixtures: [], receipt: { op: 'ride.all', time: T } })} }`);
await wait('document.querySelector("#proxy-ride-go").disabled===false');
await b.evaluate('document.querySelector("#proxy-ride-go").click()');
await wait('window.__writes.filter(w=>w.path==="/api/proxy/admin/ride-all").length===3');
await wait('document.querySelectorAll("#proxy-ride-skips li").length===3');
assert.deepEqual(JSON.parse(await b.evaluate('JSON.stringify([...document.querySelectorAll("#proxy-ride-skips li")].map(li=>li.textContent))')), [
'Skipped north: The model proxy was on it, or Ride all may have added it, and it is off now. Ride all leaves it off. Add it on its Settings page to use it.',
'Skipped south: The proxy could not record the change first, so it was not made.',
// Re-check 3 (P3-3): a damaged receipts line stops every add until someone repairs it.
'Skipped east: Its organization file, its change log or the proxy\'s receipts could not be read. A damaged line in the proxy\'s receipts must be repaired by hand before Ride all adds again.']);
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
});
// #1873 settings slice 1 (DESIGN.md sections 4 and 9, D1, D3, D4). The service runs ("accounts" is the
// server's next step); the steps after it come from what the page reads: accounts, organizations, Triage route.
const running = { ...base, release: fetched.release, init: { initialized: true, partial: false, settings: { port: 18432 }, files: [] },
unit: { unit: 'mosaic-proxy.service', installed: true, active: 'active', pid: 4242, port: 18432, listening: true }, next: ['accounts'] };
const account = { accountId: 'a1', displayName: 'Claude work', provider: 'claude', status: 'active', priority: 0 };
const answering = (n = 1) => ({ 'GET /api/proxy/accounts': { body: { accounts: Array.from({ length: n }, () => account) } }, 'GET /api/proxy/keys': { body: { keys: [] } } });
// An organization's own routes read, the one Routing uses: its catalogue and the bus's cause lines.
const routes = (notices = [], status = 'unavailable', reason) => ({ rows: [{ catalogue: { status, models: [], notices, ...(reason ? { reason } : {}) } }] });
const FIXTURE = 'This organization routes launches to the dev fixture, which the host refuses next to a model proxy (fixture-proxy-configured). Remove the fixture or stop using it here.';
const savedRoute = { route: { model: 'm', harness: 'claude-code', cap: 1000, reset: '00:00', timeZone: 'UTC', revision: 1, updatedAt: T } };
const restarted = { body: { outcome: 'done', step: 'bus-restart', restarted: true, healthy: true } };
const visible = sel => `[...document.querySelectorAll(${JSON.stringify(sel)})].filter(e=>e.checkVisibility())`;
test('settings-s1 B2: once the service runs, the organizations that cannot see the models stay listed, each with its own Restart', { timeout: 90000 }, async t => {
const orgs = [{ id: 'acme', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } }, { id: 'beta', proxy: 'shared', catalogue: { status: 'bus-unavailable' } },
{ id: 'gamma', proxy: 'shared', catalogue: { status: 'ready', models: 3 } }, { id: 'delta', proxy: 'shared', catalogue: { status: 'disabled' } }];
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario({ ...running, organizations: orgs }, { orgSetup: true }), ...answering(), '/api/triage/route': savedRoute, '/api/orgs/acme/bus/routes': routes(), 'POST /api/orgs/acme/restart/bus': restarted } });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelectorAll("#proxy-setup-restart-list li").length===2');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-restart").checkVisibility()'), true);
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#proxy-setup-restart-list li")].map(li=>[li.dataset.restartOrg, li.querySelector(".badge").className, li.querySelector(".badge").textContent, li.querySelector("[data-org-restart]")?.textContent ?? null])'),
[['acme', 'badge badge-attn', "Can't see models", 'Restart acme'], ['beta', 'badge badge-danger', 'Not running', 'Restart beta']]);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go")'), null, 'the next step is the list, so no second button');
// acme's bus names no cause, so a restart connects it. beta is not running: it keeps its Restart
// and its refusal, and does not hold the next step.
assert.match(await b.evaluate('document.querySelector("#proxy-setup-next").textContent'), /^Next: restart acme\. It has a Restart button under Organizations that can't see your models\./);
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-restart-title").textContent'), "Organizations that can't see your models");
// A restart reads the status again; the organization stays on the list, now ready, so the owner sees it worked.
await b.evaluate(`window.__scenario['/api/proxy/admin/status'] = ${JSON.stringify({ ...running, organizations: [{ ...orgs[0], catalogue: { status: 'ready', models: 3 } }, ...orgs.slice(1)] })}`);
await b.evaluate('document.querySelector("[data-org-restart=acme]").focus()');
assert.notEqual(await b.evaluate('getComputedStyle(document.activeElement).outlineStyle'), 'none', 'the focused Restart shows a focus ring');
await b.key('Enter', 'Enter');
await wait('document.querySelector("[data-restart-org=acme] .badge")?.textContent==="Ready"');
assert.deepEqual(await b.evaluate('window.__writes.map(w=>w.method+" "+w.path)'), ['POST /api/orgs/acme/restart/bus']);
assert.equal(await b.evaluate('document.querySelector("[data-restart-org=acme] [data-org-restart]")'), null, 'a ready organization has no Restart');
assert.equal(await b.evaluate('document.querySelector("[data-restart-org=acme] .badge").className'), 'badge badge-ok');
assert.match(await b.evaluate('document.querySelector("#proxy-setup-next").textContent'), /^The model service is set up\. Some organizations still can't see your models\./);
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
});
test('settings-s1 B2: Restart shows only where the organization\'s own cause allows it; the dev fixture and a model-key collision get their plain lines, and neither holds the next step', { timeout: 90000 }, async t => {
const orgs = [{ id: 'acme', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } }, { id: 'lab', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } },
{ id: 'lock', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } }, { id: 'odd', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } },
{ id: 'clash', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } }];
const lock = 'The shared proxy lock does not load (proxy-lock-invalid). Check the proxy state for this instance, then restart this bus.';
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario({ ...running, organizations: orgs }, { orgSetup: true }), ...answering(), '/api/triage/route': savedRoute,
'/api/orgs/acme/bus/routes': routes(), '/api/orgs/lab/bus/routes': routes([FIXTURE]), '/api/orgs/lock/bus/routes': routes([lock]), 'GET /api/orgs/odd/bus/routes': { status: 500, body: { error: 'x' } },
'/api/orgs/clash/bus/routes': routes([], 'unavailable', 'model-key-collision') } });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelectorAll("#proxy-setup-restart-list li").length===5 && !/Checking why/.test(document.querySelector("#proxy-setup-restart-list").textContent)');
const rows = await b.evaluate('Object.fromEntries([...document.querySelectorAll("#proxy-setup-restart-list li")].map(li=>[li.dataset.restartOrg, {badge: li.querySelector(".badge").className, why: li.querySelector(":scope > .small").textContent, restart: li.querySelector("[data-org-restart]")?.textContent ?? null, link: li.querySelector(":scope > .small a")?.getAttribute("href") ?? null, detail: li.querySelector("details summary")?.textContent ?? null}]))');
assert.deepEqual(rows.acme, { badge: 'badge badge-attn', why: "acme can't read your models from the model service yet. A restart connects it.", restart: 'Restart acme', link: null, detail: null });
// Saving routes does not remove the fixture provider, so lab gets no Routing link (review 2, P2-B).
assert.deepEqual(rows.lab, { badge: 'badge badge-attn', why: "lab runs on test models, which can't share this machine with your model service. This can't be changed from Console yet.", restart: null, link: null, detail: 'Technical details' });
assert.deepEqual(rows.lock, { badge: 'badge badge-attn', why: "lock can't open the model service's shared lock. A restart opens it again.", restart: 'Restart lock', link: null, detail: 'Technical details' });
// Two models that slug to one key: a restart reads the same catalogue again (review 2, P2-A).
assert.deepEqual(rows.clash, { badge: 'badge badge-attn', why: "Two of your models get the same short name, so clash can't tell them apart. A restart won't change that.", restart: null, link: null, detail: 'Technical details' });
assert.deepEqual(rows.odd, { badge: 'badge badge-attn', why: "odd can't see your models, and its reason could not be read. Open odd's Routing", restart: null, link: '#/orgs/odd/settings/routing', detail: null });
assert.equal(await b.evaluate('document.querySelector("[data-restart-org=lab] details").textContent.includes("fixture-proxy-configured")'), true, 'the bus line is kept under Technical details');
assert.match(await b.evaluate('document.querySelector("#proxy-setup-next").textContent'), /^Next: restart acme and lock\./);
assert.doesNotMatch(await b.evaluate('document.querySelector("#proxy-setup-restart-list").innerText'), /model proxy/i, 'the bus line shows only once Technical details is opened');
// Once acme and lock see the models, only the fixture, the collision and the unread one are left, and none holds a step.
await b.evaluate(`window.__scenario['/api/proxy/admin/status'] = ${JSON.stringify({ ...running, organizations: [{ ...orgs[0], catalogue: { status: 'ready', models: 2 } }, orgs[1], { ...orgs[2], catalogue: { status: 'ready', models: 2 } }, orgs[3], orgs[4]] })}`);
await b.evaluate('document.dispatchEvent(new CustomEvent("mosaic-org-restarted", { detail: { id: "acme" } })); true');
await wait('/^The model service is set up\\. Some organizations still/.test(document.querySelector("#proxy-setup-next").textContent)');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go")'), null);
assert.deepEqual(await b.evaluate('window.__writes.map(w=>w.method+" "+w.path)'), [], 'nothing restarts by itself');
});
test('settings-s1 B2: a refused restart keeps its reason on the list across the status read that follows', { timeout: 90000 }, async t => {
const orgs = [{ id: 'lab', proxy: 'shared', catalogue: { status: 'bus-unavailable' } }];
const refusal = { status: 409, body: { error: 'bus-start-refused', message: 'bus start refused: fixture-proxy-configured' } };
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario({ ...running, organizations: orgs }, { orgSetup: true }), ...answering(), '/api/triage/route': savedRoute, 'POST /api/orgs/lab/restart/bus': refusal } });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelector("[data-org-restart=lab]")');
await b.evaluate('document.querySelector("[data-org-restart=lab]").click()');
await wait('document.querySelector("[data-restart-org=lab] .org-restart-refused")');
await new Promise(r => setTimeout(r, 300));
assert.equal(await b.evaluate('document.querySelector("[data-restart-org=lab] [data-org-restart-receipt] strong").textContent'), "lab runs on test models, which can't share this machine with your model service. It did not start.");
assert.equal(await b.evaluate('document.querySelector("[data-restart-org=lab] .badge").className'), 'badge badge-danger', 'a refused organization is never green');
});
test('settings-s1 B3: a sign-in reads the whole status again and the next step follows accounts, organizations, then the Triage route', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario({ ...running, organizations: [{ id: 'acme', proxy: 'shared', catalogue: null }] }, { orgSetup: true }), ...answering(0), '/api/triage/route': { route: null }, '/api/orgs/acme/bus/routes': routes(),
'POST /api/proxy/login/status': { body: { status: 'error', reason: 'login-timeout' } } } });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="accounts"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").textContent'), 'Add an account');
await b.evaluate(`window.open = () => null; window.__scenario['POST /api/proxy/login/start'] = { body: { url: location.origin + '/signin-stub', state: 's1' } }`);
// A sign-in that runs out of time says so plainly.
await b.evaluate('document.querySelector("#proxy-login-start").requestSubmit()');
await wait('document.querySelector("#proxy-login-message").textContent==="Sign-in took too long. Try again."');
// The next sign-in finishes. The status read after it is the one that names acme, so the step proves the reread.
await b.evaluate(`Object.assign(window.__scenario, ${JSON.stringify({ ...answering(1), 'POST /api/proxy/login/status': { body: { status: 'ok' } }, '/api/proxy/admin/status': { ...running, organizations: [{ id: 'acme', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } }] } })})`);
await b.evaluate('document.querySelector("#proxy-login-start").requestSubmit()');
await wait('document.querySelector("#proxy-setup-next [data-next]")?.dataset.next==="restart-orgs"');
assert.match(await b.evaluate('document.querySelector("#proxy-setup-next").textContent'), /^Next: restart acme\./);
assert.equal(await b.evaluate('document.querySelector("#proxy-login-message").textContent'), 'Account signed in.');
// acme restarts and can see the models; the Triage route is not set, so that is the step after.
await b.evaluate(`Object.assign(window.__scenario, ${JSON.stringify({ 'POST /api/orgs/acme/restart/bus': restarted, '/api/proxy/admin/status': { ...running, organizations: [{ id: 'acme', proxy: 'shared', catalogue: { status: 'ready', models: 2 } }] } })})`);
await b.evaluate('document.querySelector("[data-org-restart=acme]").click()');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="triage-route"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").textContent'), 'Open Triage settings');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").disabled'), false);
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
});
// Rebase onto ride-default: with an account, Ride all is the step after accounts while an organization can
// ride now, and its box shows outside Technical details. Stand-in organizations alone do not hold the step.
test('settings-s1 B3 with ride-default: Ride all follows accounts while an organization can ride, and only then', { timeout: 90000 }, async t => {
const riding = { ...running, next: ['accounts', 'ride-all'], organizations: [{ id: 'acme', proxy: 'shared', catalogue: { status: 'ready', models: 2 } }],
ride: [{ id: 'north', state: 'ready' }, { id: 'west', state: 'fixture' }] };
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(riding), ...answering(1), '/api/triage/route': { route: null } } });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="ride-all"');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-go").textContent'), 'Ride all');
assert.equal(await b.evaluate('document.querySelector("#proxy-ride").checkVisibility()'), true, 'the Ride all box is not folded under Technical details');
assert.equal(await b.evaluate('document.querySelector("#proxy-ride-go").disabled'), false);
// Ride all adds north. Only a stand-in organization is left: the step moves on to the Triage route, and Move stays offered.
await b.evaluate(`window.confirm = () => true; Object.assign(window.__scenario, ${JSON.stringify({ '/api/proxy/admin/status': { ...riding, ride: [{ id: 'north', state: 'already' }, { id: 'west', state: 'fixture' }] },
'POST /api/proxy/admin/ride-all': { body: { added: ['north'], already: [], skipped: [], fixtures: [{ id: 'west' }], receipt: { op: 'ride.all', time: T } } } })})`);
await b.evaluate('document.querySelector("#proxy-ride-go").click()');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="triage-route"');
assert.equal(await b.evaluate('document.querySelector("[data-ride-move=west]").checkVisibility()'), true);
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
});
test('settings-s1 B4: only the next step has a button; done steps, Fence, Init lock and the service controls sit under Technical details', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: { ...scenario(running), ...answering(0), '/api/triage/route': savedRoute } });
await b.navigate(f.base + '/#/settings/model-proxy');
await wait('document.querySelector("#proxy-setup-go")?.dataset.next==="accounts"');
assert.deepEqual(await b.evaluate(`${visible('#proxy-setup button')}.map(e=>e.id||e.textContent)`), ['proxy-setup-go'], 'one visible button in the setup panel');
assert.equal(await b.evaluate('document.querySelector("#proxy-setup-init-box").checkVisibility()'), false, 'init is done, so its form is gone');
const tech = await b.evaluate('(()=>{const d=document.querySelector("#proxy-setup-tech");return {summary:d.querySelector("summary").textContent,open:d.open,terms:[...d.querySelectorAll("dt")].map(x=>x.textContent),units:d.querySelectorAll("[data-unit]").length,receipts:!!d.querySelector("#proxy-setup-receipts")}})()');
assert.deepEqual(tech, { summary: 'Technical details', open: false, terms: ['Release', 'Initialized', 'Service', 'Fence', 'Init lock'], units: 4, receipts: true });
assert.equal(await b.evaluate(`${visible('#proxy-setup dt, #proxy-setup [data-unit]')}.length`), 0, 'nothing technical shows until it is opened');
// Technical details opens by keyboard and shows the controls.
await b.evaluate('document.querySelector("#proxy-setup-tech summary").focus()');
await b.key('Enter', 'Enter');
await wait('document.querySelector("#proxy-setup-tech").open');
assert.equal(await b.evaluate(`${visible('#proxy-setup [data-unit]')}.length`), 4);
});
@@ -20,7 +20,8 @@ const END = '10000000-0000-4000-8000-0000000000e1', LAUNCH = '10000000-0000-4000
const DEV = { provider: 'local-dev', iss: 'local-dev', sub: 'local-dev-owner', name: 'Local operator' };
const route = thinking => ({ harness: 'claude', model: 'opus', thinking, fallback: null });
test('F3 Settings > Routing: a save lists how the change reaches each agent, and Restart now moves a running one', { timeout: 120000 }, async t => {
// A real server with the stub bus, on Settings > Routing. `refusal` closes coder's end request with that code.
async function stage(t, { refusal = null } = {}) {
const root = mkdtempSync(join(tmpdir(), 'f3r-')); t.after(() => rmSync(root, { recursive: true, force: true }));
const entry = (definition, extra) => ({ definition, vars: {}, launched: true, launcher: false, protected: false, kept: false, running: [], alive: [], ...extra });
const instances = {
@@ -52,7 +53,7 @@ test('F3 Settings > Routing: a save lists how the change reaches each agent, and
if (verb === 'instance.launch') { requests.set(LAUNCH, { instance: args.instance, action: 'launch' }); instances[args.instance].running = ['run-2']; return { request: LAUNCH }; }
if (verb === 'instance.request') {
const r = requests.get(args.request);
return { request: args.request, instance: r.instance, action: r.action, state: 'closed', done: { run: r.action === 'launch' ? 'run-2' : null, transaction: null, refusal: null }, cancelled: null };
return { request: args.request, instance: r.instance, action: r.action, state: 'closed', done: { run: r.action === 'launch' ? 'run-2' : null, transaction: null, refusal: r.action === 'end' && r.instance === 'coder' ? refusal : null }, cancelled: null };
}
throw Error(`unexpected ${verb}`);
};
@@ -72,6 +73,11 @@ test('F3 Settings > Routing: a save lists how the change reaches each agent, and
for (const name of ['chief', 'coder', 'assistant', 'reviewer']) await b.evaluate(`(()=>{const s=${cell(name, 'thinking')};s.value='low';s.dispatchEvent(new Event('change',{bubbles:true}));return true;})()`);
await b.evaluate(`document.getElementById('routes-form').requestSubmit();true`);
await wait(`document.querySelector('.routes-apply')`);
return { b, wait, asked, items, dir };
}
test('F3 Settings > Routing: a save lists how the change reaches each agent, and Restart now moves a running one', { timeout: 120000 }, async t => {
const { b, wait, asked, items, dir } = await stage(t);
assert.deepEqual(asked, [['routes.set', { revision: REV, routes: { chief: route('low'), coder: route('low'), assistant: route('low'), reviewer: route('low') } }]]);
assert.equal(await b.evaluate(`document.getElementById('routes-receipt').textContent`), 'Routes saved for chief, coder, assistant, reviewer. The next launch of each uses the new route.');
assert.deepEqual(await items(), [
@@ -103,3 +109,29 @@ test('F3 Settings > Routing: a save lists how the change reaches each agent, and
await b.viewport(390, 844);
assert.equal(await b.evaluate(`document.documentElement.scrollWidth<=390`), true, 'no sideways scroll at phone width');
});
// SP19 (#1873): the drawer's Restart shares this chain. The route-change flow keeps its reason, its
// unprefixed routes and every line it shows, step by step, and its refusal line.
const WATCH = name => `(()=>{window.__seen=[];const snap=()=>{const s=document.querySelector('[data-agent-restart-status="${name}"]')?.textContent??'';if(s&&s!==window.__seen.at(-1))window.__seen.push(s);};new MutationObserver(snap).observe(document.body,{subtree:true,childList:true,characterData:true});return true;})()`;
test('SP19: Restart now keeps its reason and its words', { timeout: 120000 }, async t => {
const { b, wait, asked } = await stage(t);
const posts = [];
await b.evaluate(`(()=>{const f=window.fetch;window.__urls=[];window.fetch=(u,o)=>{window.__urls.push(String(u));return f(u,o);};return true;})()`);
await b.evaluate(WATCH('coder'));
await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').click();true`);
await wait(`document.querySelector('[data-agent-restart-status="coder"]')?.textContent==='Restarted coder on the new route (run run-2).'`, 30000);
assert.deepEqual(await b.evaluate('window.__seen'), ['Terminating coder…', 'Terminated coder. Waiting for its session to end…', 'Launching coder…', 'Restarted coder on the new route (run run-2).']);
assert.deepEqual(asked.filter(([v]) => v === 'instance.end'), [['instance.end', { instance: 'coder', reason: 'route change' }]]);
posts.push(...(await b.evaluate('window.__urls')).filter(u => /\/api\/agent\/(terminate|launch|regenerate)/.test(u)));
assert.deepEqual(posts, ['/api/agent/terminate', '/api/agent/launch']);
assert.equal(await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').textContent`), 'Restart coder now');
});
test('SP19: Restart now says when the end is refused, in its own words', { timeout: 120000 }, async t => {
const { b, wait, asked } = await stage(t, { refusal: 'instance-kept' });
await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').click();true`);
await wait(`/It was not restarted/.test(document.querySelector('[data-agent-restart-status="coder"]')?.textContent??'')`, 30000);
assert.equal(await b.evaluate(`document.querySelector('[data-agent-restart-status="coder"]').textContent`), 'coder: the instance is kept; unkeep it first. It was not restarted.');
assert.equal(asked.filter(([v]) => v === 'instance.launch').length, 0);
assert.equal(await b.evaluate(`document.querySelector('[data-agent-restart="coder"]').disabled`), false);
});
+9 -6
View File
@@ -197,7 +197,7 @@ test('Routing switch writes the model-provider setting and keeps other modules',
await b.call('Page.addScriptToEvaluateOnNewDocument',{source:`const original=window.fetch;window.posts=[];window.fetch=async(url,options={})=>{if(url==='/api/config')return new Response(JSON.stringify({send:true}));if(url==='/api/proxy/plugins')return new Response(JSON.stringify(${JSON.stringify(settings)}));if(url==='/api/proxy/plugins/set'){posts.push(JSON.parse(options.body));return new Promise(r=>window.answer=(status,body)=>r(new Response(JSON.stringify(body),{status})));}return original(url,options);};`});
await b.navigate(`http://127.0.0.1:${web.address().port}/#/settings/routing`);
const wait=expr=>b.evaluate(`(async()=>{for(let n=0;n<200;n++){if(${expr})return true;await new Promise(r=>setTimeout(r,30));}throw Error('wait failed');})()`);
await wait('document.querySelector("#provider-switch")?.textContent.startsWith("Enable")');
await wait('document.querySelector("#provider-switch")?.textContent.startsWith("Use your models")');
await b.evaluate('document.querySelector("#provider-switch").click();true');
await wait('posts.length===1');const payload=await b.evaluate('posts[0]');
assert.deepEqual(payload.plugins,{'model-provider':['cliproxy']});
@@ -271,8 +271,8 @@ test('quick fallback edits survive the harness redraw', {timeout:60000}, async t
// organization's catalogue is ready with no proxy, and its switch reads Enable.
test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disable and removes cliproxy only; a fixture-only org reads Enable', {timeout:90000}, async t => {
for (const [providers, label, line, next] of [
[['fixture','cliproxy'], 'Disable', /Model catalogue unavailable\. A change to thinking alone still saves\. A new model needs the catalogue: set up the model proxy, or, when this organization has none, press Disable model proxy catalogue\./, ['fixture']],
[['fixture'], 'Enable', /^Model catalogue, observed /, ['fixture','cliproxy']],
[['fixture','cliproxy'], 'Stop using the model service', /can't see your models yet\. Your model service isn't set up yet\. A change to thinking alone still saves\. A new model needs the model service: ask the instance owner to set it up, or press Stop using the model service when this organization does not need it\./, ['fixture']],
[['fixture'], 'Use your models', /^Model catalogue, observed /, ['fixture','cliproxy']],
]) {
const root=tmp(t,'d3-switch-'), f=fixture(root,'acme',doc=>{doc.plugins['model-provider']=providers;return doc;});
const dir=join(root,'config'),file=join(dir,'businesses','acme.json');
@@ -288,8 +288,11 @@ test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disab
await b.navigate(`http://127.0.0.1:${web.address().port}/#/settings/routing`);
const wait=expr=>b.evaluate(`(async()=>{for(let n=0;n<200;n++){if(${expr})return true;await new Promise(r=>setTimeout(r,30));}throw Error('wait failed');})()`);
await wait(`document.querySelector("#provider-switch")?.textContent.startsWith(${JSON.stringify(label)})&&!!document.querySelector('[data-harness]')`);
const info=await b.evaluate('document.querySelector(".routing-panel > p.small")?.textContent');
const [info,...notices]=await b.evaluate('[document.querySelector(".routing-panel > p.small")?.textContent,...[...document.querySelectorAll(".routing-panel > p.small.warn")].slice(1).map(p=>p.textContent)]');
assert.match(info,line,providers.join(','));
// proxy-pickup (#1873): the bus's cause reads as a plain line; its own words sit under Technical details.
assert.deepEqual(notices,[],providers.join(','));
assert.deepEqual(await b.evaluate('[...document.querySelectorAll(".routing-panel > details.routes-cause-detail p")].map(p=>p.textContent)'),label==='Stop using the model service'?['The model proxy has not been set up for this instance yet. Set it up on the Model proxy page.']:[],providers.join(','));
await b.evaluate('document.querySelector("#provider-switch").click();true');
await wait('posts.length===1');const payload=await b.evaluate('posts[0]');
assert.deepEqual(payload.plugins,{'model-provider':next},providers.join(','));
@@ -306,10 +309,10 @@ test('D3 Routing: with cliproxy listed and no model proxy the switch reads Disab
test('D3 Routing: a catalogue refusal names Disable only when it can make the save apply, and sends a tester to the owner', {timeout:90000}, async t => {
const refusal=code=>({error:code,message:`${code}: the reason. Nothing changed.`,sent:false});
for (const [providers, tester, instance, code, expect] of [
[['fixture','cliproxy'], false, 'coder', 'model-catalogue-unavailable', /Nothing changed\. This change needs no model proxy: press Disable model proxy catalogue, then save again\. Draft kept\.$/],
[['fixture','cliproxy'], false, 'coder', 'model-catalogue-unavailable', /Nothing changed\. This change does not need the model service: press Stop using the model service, then save again\. Draft kept\.$/],
[['fixture','cliproxy'], false, 'reviewer', 'model-catalogue-unavailable', /Nothing changed\. Draft kept\.$/],
[['fixture'], false, 'reviewer', 'model-provider-unavailable', /Nothing changed\. Draft kept\.$/],
[['fixture','cliproxy'], true, 'coder', 'model-catalogue-unavailable', /Nothing changed\. Ask the organization's owner to set up the model proxy, or to disable the model proxy catalogue when the change needs no proxy\. Draft kept\.$/],
[['fixture','cliproxy'], true, 'coder', 'model-catalogue-unavailable', /Nothing changed\. Ask the organization's owner to set up the model service, or to stop using it when the change does not need it\. Draft kept\.$/],
]) {
const label=`${providers.join(',')} tester=${tester} ${instance}`;
const view={business:'acme',revision:'a'.repeat(64),harnesses:['pi','claude-code'],models:['fixture-deterministic','proxy-x'],
@@ -7,10 +7,10 @@ test('Settings proxy navigation keeps the root document through Settings and Das
await b.navigate(f.base+'/#/settings');
await wait('!!document.querySelector("#settings-nav")');
assert.equal(await b.evaluate('location.pathname'), '/');
await b.evaluate('[...document.querySelectorAll("#settings-nav a")].find(a=>a.textContent.includes("Model proxy")).click()');
await b.evaluate('[...document.querySelectorAll("#settings-nav a")].find(a=>a.textContent.includes("Model setup")).click()');
await new Promise(r=>setTimeout(r,500));
assert.equal(await b.evaluate('location.pathname'), '/');
await wait('document.querySelector("#settings-page-title")?.textContent==="Model proxy" && !!document.querySelector("#proxy-accounts")');
await wait('document.querySelector("#settings-page-title")?.textContent==="Model setup" && !!document.querySelector("#proxy-accounts")');
await b.evaluate('[...document.querySelectorAll("#settings-nav a")].find(a=>a.textContent.includes("Appearance")).click()');
await wait('document.querySelector("#settings-page-title")?.textContent==="Appearance" && !!document.querySelector(".settings-appearance")');
assert.equal(await b.evaluate('location.pathname'), '/');
@@ -58,7 +58,7 @@ test('server sections render and a routing draft can be discarded at phone width
const instances={revision,launch:true,instances:{chief:{definition:'chief',launcher:true,launched:false,kept:false,running:[]}},definitions:{chief:{accepted:true,services:[]}},noHire:[],retired:[]};
const {f,b,wait}=await w15Fixture(t,{scenario:{'/api/settings':{launch,notifier:{binding:null}},'/api/bus/routes':{rows:[routes]},'/api/bus/instances':{rows:[instances]},'/api/bus/names':{rows:[]},'/api/bus/limits':{rows:[]},'/api/bus/usage':{rows:[]}}});
await b.viewport(390,900);
for(const [path,title] of [['limits','Launch limits'],['routing','Routing'],['agents','Agents'],['assistant','Assistant'],['tokens','Token use'],['model-proxy','Model proxy'],['about','About']]) {
for(const [path,title] of [['limits','Launch limits'],['routing','Routing'],['agents','Agents'],['assistant','Assistant'],['tokens','Token use'],['model-proxy','Model setup'],['about','About']]) {
await b.navigate(f.base+'/#/settings/'+path); await wait(`document.querySelector('#settings-page-title')?.textContent===${JSON.stringify(title)}`);
assert.equal(await b.evaluate('document.documentElement.scrollWidth<=innerWidth'),true,path);
const undersized=await b.evaluate(`[...document.querySelectorAll('.settings-content button,.settings-content select,.settings-content input:not([type=checkbox]):not([type=radio]):not([type=hidden]),.settings-content summary')].filter(e=>e.getClientRects().length).filter(e=>{const r=e.getBoundingClientRect();return r.width<44||r.height<44}).map(e=>e.outerHTML.slice(0,150))`);
@@ -119,7 +119,7 @@ test('hiring switches lead names and launch settings inputs align in columns', {
test('an unconfigured proxy is one empty state without forms or a false read-only note', {timeout:90000}, async t => {
const {f,b,wait}=await w15Fixture(t,{scenario:{'/api/config':{send:true,devOwner:true},'GET /api/proxy/accounts':{status:503,body:{error:'not-configured'}},'GET /api/proxy/keys':{status:503,body:{error:'not-configured'}}}});
await b.navigate(f.base+'/#/settings/model-proxy');await wait('document.querySelector("#proxy-message")?.textContent.includes("not configured")');
await b.navigate(f.base+'/#/settings/model-proxy');await wait('document.querySelector("#proxy-message")?.textContent.includes("not set up")');
assert.equal(await b.evaluate('document.querySelector("#proxy-message").classList.contains("empty")'),true);
assert.equal(await b.evaluate('!!document.querySelector(".settings-readonly")'),false);
assert.equal(await b.evaluate('[...document.querySelectorAll(".settings-model-proxy .panel:not(#proxy-dev-setup)")].every(e=>e.hidden)'),true);
@@ -131,7 +131,7 @@ test('an unconfigured proxy is one empty state without forms or a false read-onl
test('an unconfigured proxy without the dev owner shows no setup note', {timeout:90000}, async t => {
const {f,b,wait}=await w15Fixture(t,{scenario:{'/api/config':{send:true},'GET /api/proxy/accounts':{status:503,body:{error:'not-configured'}},'GET /api/proxy/keys':{status:503,body:{error:'not-configured'}}}});
await b.navigate(f.base+'/#/settings/model-proxy');await wait('document.querySelector("#proxy-message")?.textContent.includes("not configured")');
await b.navigate(f.base+'/#/settings/model-proxy');await wait('document.querySelector("#proxy-message")?.textContent.includes("not set up")');
assert.equal(await b.evaluate('!!document.querySelector("#proxy-dev-setup")'),false);
assert.equal(await b.evaluate('[...document.querySelectorAll(".settings-model-proxy .panel")].every(e=>e.hidden)'),true);
});
@@ -11,7 +11,7 @@ async function page(t,section,width=1440,options={}) {
const x=await w15Fixture(t,{scenario}); const {b,f,wait}=x;
if(options.poll)await b.call('Page.addScriptToEvaluateOnNewDocument',{source:`(()=>{const original=setTimeout;window.setTimeout=(fn,ms,...args)=>{if(ms===10000)window.__pollRefresh=fn;return original(fn,ms,...args)}})()`});
await b.viewport(width,width===390?900:1000);await b.navigate(f.base+'/#/settings/'+section);
await wait(`document.querySelector('#settings-page-title')?.textContent===${JSON.stringify(({agents:'Agents',routing:'Routing',limits:'Launch limits',assistant:'Assistant',appearance:'Appearance','model-proxy':'Model proxy'})[section])}`);
await wait(`document.querySelector('#settings-page-title')?.textContent===${JSON.stringify(({agents:'Agents',routing:'Routing',limits:'Launch limits',assistant:'Assistant',appearance:'Appearance','model-proxy':'Model setup'})[section])}`);
if(section==='agents')await wait('!!document.querySelector(".agent-more")');
if(section==='routing')await wait('!!document.querySelector("[data-route]")');
if(section==='model-proxy')await wait('!!document.querySelector("#proxy-accounts form")');
@@ -0,0 +1,316 @@
// #1873 settings slice 1, bullets 1 and 6 (DESIGN.md sections 3.4, 5 and 9; DEFECTS D2 and D7).
// B1: Routing in an organization that lists the model service but cannot see its models says why,
// and offers Restart only when the model service runs and the bus names no cause. A running bus picks
// the service up at its next catalogue read (proxy-pickup); when it still cannot, its cause line shows
// with Check again, because a restart would not fix that cause. B6: a stopped organization's Settings page
// keeps a refused restart's reason on screen and keeps the instance pages one link away.
// Every bus is a fake: acme answers, gamma is stopped. The page's own reads of the routes, the
// plugin list and the model service state are answered by a fetch stub; the rest is the real server.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { fileURLToPath } from 'node:url';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { browser } from './browser.mjs';
import { close } from './fixture.mjs';
import { ReadError } from '../src/reads.mjs';
const at = minutesAgo => new Date(Date.now() - minutesAgo * 60000).toISOString();
const LIST = [
{ id: 'acme', label: 'Acme Studio', theme: 'cobalt', busHealthy: true },
{ id: 'gamma', label: 'Gamma Home', theme: 'rosewood', busHealthy: false, busStopped: true },
];
const ROLES = { acme: { chief: { definition: 'chief-of-staff' }, coder: { definition: 'coder' } }, gamma: { chief: { definition: 'chief-of-staff' } } };
// The routes acme's bus answers; a test swaps it to show a restart that brought the catalogue up.
const state = { view: null };
async function fixture() {
const { checkRootAgents } = await import('../../organization/src/index.mjs');
const rolesDir = fileURLToPath(new URL('../../../roles', import.meta.url));
const root = { state: 'ok', ...checkRootAgents({ agentsVersion: 1, agents: {} }, { rolesDir }) };
const empty = () => Promise.resolve([]);
const member = org => ({
id: org.id, doc: { appearance: { theme: org.theme }, roles: ROLES[org.id], projects: {} },
status: async () => (org.busHealthy ? { healthy: true, pid: 4242, boot: null } : { healthy: false, boot: { ok: false, at: at(90), lastGood: null, reason: 'stopped by the owner' } }),
options: () => ({ bus: { inbox: empty, agents: empty, 'thread.claims': empty, tasks: empty, usage: () => Promise.resolve({}), limits: () => Promise.resolve({}), decisions: empty }, chat: { threads: empty, projects: empty } }),
});
const organizations = {
list: async () => LIST,
members: async () => LIST.map(member),
resolve: async id => {
const org = LIST.find(o => o.id === id); if (!org) return null;
// As in production, a stopped organization keeps its reads; each one that needs the bus fails.
if (!org.busHealthy) return { busHealthy: false, reads: { settings: async () => { throw new ReadError('bus-unavailable'); } }, bus: {}, chat: { projects: empty, threads: empty } };
return {
busHealthy: true,
reads: { business: async () => ({ business: { id, human: 'jason', projects: [], appearance: { theme: org.theme } } }), settings: async () => ({ business: id, release: 'fixture', notifier: {} }), queue: async () => ({ rows: [] }), busStatus: async () => ({}) },
bus: { messages: async () => ({ messages: [], unread: 0 }), agents: empty, 'thread.claims': empty, inbox: empty, tasks: empty, usage: async () => ({}), routes: async () => state.view, instances: async () => ({ business: id, revision: 'a'.repeat(64), launch: true, noHire: [], retired: [], definitions: {}, instances: {} }) },
chat: { projects: empty, threads: empty },
};
},
};
return { organizations, agentLevels: { loadRoot: () => root, rolesDir, ctx: { configDir: '/cfg', dataRoot: '/data', instance: 'test' } } };
}
const VIEW = {
business: 'acme', revision: 'a'.repeat(64), harnesses: ['pi', 'claude-code'], models: ['fixture-deterministic'],
providerModels: { 'fixture-deterministic': { module: 'fixture', upstream: 'fixture', model: 'fixture-deterministic' } },
levels: { pi: ['off', 'low'], 'claude-code': ['off', 'low'] },
instances: { coder: { harness: 'pi', model: 'fixture-deterministic', thinking: 'off', fallback: null } },
catalogue: { status: 'unavailable', models: [], notices: [] },
};
const PLUGINS = { revision: 'b'.repeat(64), plugins: { harness: ['pi', 'claude-code'], 'model-provider': ['fixture', 'cliproxy'] }, available: { harness: ['pi', 'claude-code'] } };
const SERVICE = {
running: { init: { initialized: true }, unit: { active: 'active', healthy: true }, fence: { set: false } },
stopped: { init: { initialized: true }, unit: { active: 'inactive', healthy: false }, fence: { set: false } },
fresh: { init: { initialized: false }, unit: { active: 'inactive', healthy: false }, fence: { set: false } },
fenced: { init: { initialized: true }, unit: { active: 'active', healthy: true }, fence: { set: true } },
};
const DONE = { status: 200, body: { outcome: 'done', step: 'bus-restart', restarted: true, healthy: true } };
const REFUSED = { status: 409, body: { error: 'bus-start-refused', message: 'bus start refused: fixture-proxy-configured' } };
// The stub answers by path suffix, so it serves both the scoped reads (display.js scopes /api/x to
// /api/orgs/<id>/x) and console-restart.js, which binds fetch before that wrapper. The routes come
// from acme's fake bus. /api/config is the
// server's own answer with the instance owner's flags added; the dev owner is not a root owner here.
const stub = ({ service = SERVICE.running, restart = DONE, extra = {} } = {}) => `(() => {
const real = window.fetch.bind(window); window.__writes = [];
window.__s1 = ${JSON.stringify({ plugins: PLUGINS, service, restart, extra })};
const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
window.fetch = async (input, init = {}) => {
const url = new URL(typeof input === 'string' ? input : input.url, location.href), path = url.pathname, method = (init.method || 'GET').toUpperCase();
if (method === 'POST' && /^\\/api\\/orgs\\/[^/]+\\/restart\\/bus$/.test(path)) { __writes.push(path); return json(__s1.restart.body, __s1.restart.status); }
if (method !== 'GET') return real(input, init);
for (const [suffix, body] of Object.entries(__s1.extra)) if (path.endsWith(suffix)) return json(body);
if (/\\/api\\/(orgs\\/[^/]+\\/)?config$/.test(path)) { const c = await (await real(input, init)).json(); return json({ ...c, orgSetup: true, proxyAdmin: true, proxyAdminSend: true, ...(/\\/orgs\\//.test(path) ? { settingsSend: true } : {}) }); }
if (path.endsWith('/proxy/plugins')) return json(__s1.plugins);
if (path.endsWith('/proxy/admin/status')) return json(__s1.service);
return real(input, init);
};
})();`;
async function setup(t, { viewport = [1440, 900], path, init, triage = null, view = VIEW }) {
state.view = view;
const { organizations, agentLevels } = await fixture();
const server = await startServer({ port: 0, sso: createDevOwner(), organizations, agentLevels, triage, send: async () => ({}), log: () => {} });
t.after(() => close(server));
const b = await browser({ machine: false }); t.after(() => b.close());
await b.viewport(...viewport);
await b.call('Page.addScriptToEvaluateOnNewDocument', { source: init });
const base = `http://127.0.0.1:${server.address().port}`;
await b.navigate(`${base}${path}`);
const wait = expression => b.evaluate(`(async()=>{for(let i=0;i<200;i++){if(${expression})return true;await new Promise(r=>setTimeout(r,30))}throw Error("wait failed: "+${JSON.stringify(expression)}+" HASH "+location.hash+" BODY "+(document.querySelector("main")?.innerText??document.body.innerText).slice(0,600))})()`);
return { b, base, wait, text: sel => b.evaluate(`document.querySelector(${JSON.stringify(sel)})?.innerText ?? null`) };
}
test('settings-s1 B1: with the model service running and no cause from the bus, Routing offers the organization\'s Restart', { timeout: 90000 }, async t => {
const { b, wait, text } = await setup(t, { path: '/#/orgs/acme/settings/routing', init: stub() });
await wait('document.querySelector("#routes-catalogue [data-org-restart=acme]")');
const line = await text('#routes-catalogue');
assert.match(line, /^Acme Studio can't see your models yet\. Your model service is running, but Acme Studio can't read your models from it\. Restart Acme Studio to connect it again\./);
assert.doesNotMatch(line, /model proxy/i);
const button = await b.evaluate('(() => { const e = document.querySelector("#routes-catalogue [data-org-restart=acme]"); return { text: e.textContent, primary: e.classList.contains("primary") }; })()');
assert.deepEqual(button, { text: 'Restart Acme Studio', primary: true });
// One primary on the page: while the Restart is primary, Save routes is drawn as a plain button.
assert.equal(await b.evaluate('document.querySelector("#routes-save, .routing-panel button[type=submit]")?.classList.contains("route-save-quiet")'), true);
assert.notEqual(await b.evaluate('getComputedStyle(document.querySelector(".routing-panel button[type=submit]")).backgroundColor'), await b.evaluate('getComputedStyle(document.querySelector("#routes-catalogue [data-org-restart=acme]")).backgroundColor'));
// Keyboard: the button takes focus with a visible ring and Enter presses it.
await b.evaluate('document.querySelector("#routes-catalogue [data-org-restart=acme]").focus(); true');
assert.notEqual(await b.evaluate('getComputedStyle(document.activeElement).outlineStyle'), 'none');
state.view = { ...VIEW, catalogue: { status: 'ready', observedAt: new Date().toISOString(), models: [], notices: [] } };
await b.key('Enter', 'Enter');
await wait('window.__writes.length === 1');
assert.deepEqual(await b.evaluate('window.__writes'), ['/api/orgs/acme/restart/bus']);
// The page reads the routes again after the restart, and a ready catalogue has no Restart line.
await wait('!document.querySelector("#routes-catalogue") && /Model catalogue, observed/.test(document.querySelector(".routing-panel")?.textContent ?? "")');
});
test('settings-s1 B1: when the bus names why it cannot use the running model service, Routing says it in plain words with the bus\'s line under Technical details, and the lock cause offers Restart and Check again', { timeout: 90000 }, async t => {
const cause = 'The shared proxy lock does not load (proxy-lock-invalid). Check the proxy state for this instance, then restart this bus.';
const view = { ...VIEW, catalogue: { status: 'unavailable', reason: 'proxy-not-configured', models: [], notices: [cause] } };
const { b, wait, text } = await setup(t, { path: '/#/orgs/acme/settings/routing', init: stub(), view });
await wait('document.querySelector("#routes-catalogue #routes-recheck")');
const line = await text('#routes-catalogue');
assert.match(line, /^Acme Studio can't see your models yet\. Your model service is running\. Acme Studio can't open the model service's shared lock\. A restart opens it again\.\n+Restart Acme Studio to try again\./);
assert.doesNotMatch(line, /model proxy|proxy-lock-invalid/i, 'the bus line is folded away');
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue details.routes-cause-detail").open'), false);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue details.routes-cause-detail p").textContent'), cause);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue details summary").textContent'), 'Technical details');
// A fresh start clears the lock cause, so the Restart is the primary action, beside Check again.
assert.deepEqual(await b.evaluate('[...document.querySelectorAll("#routes-catalogue [data-org-restart]")].map(e => [e.textContent, e.classList.contains("primary")])'), [['Restart Acme Studio', true]]);
// Keyboard: Check again takes focus with a visible ring; Enter rereads, and the bus has the service now.
await b.evaluate('document.querySelector("#routes-recheck").focus(); true');
assert.notEqual(await b.evaluate('getComputedStyle(document.activeElement).outlineStyle'), 'none');
state.view = { ...VIEW, catalogue: { status: 'ready', observedAt: new Date().toISOString(), models: [], notices: [] } };
await b.key('Enter', 'Enter');
await wait('!document.querySelector("#routes-catalogue") && /Model catalogue, observed/.test(document.querySelector(".routing-panel")?.textContent ?? "")');
assert.deepEqual(await b.evaluate('window.__writes'), [], 'Check again writes nothing');
});
test('settings-s1 B1: a cause a restart cannot fix, such as the dev fixture, offers Check again and no Restart', { timeout: 90000 }, async t => {
const cause = 'This organization routes launches to the dev fixture, which the host refuses next to a model proxy (fixture-proxy-configured). Remove the fixture or stop using it here.';
const view = { ...VIEW, catalogue: { status: 'unavailable', reason: 'proxy-not-configured', models: [], notices: [cause] } };
const { b, wait, text } = await setup(t, { path: '/#/orgs/acme/settings/routing', init: stub(), view });
await wait('document.querySelector("#routes-catalogue #routes-recheck")');
const line = await text('#routes-catalogue');
// Saving routes does not remove the fixture provider and no endpoint does, so the line asks for nothing.
assert.match(line, /Your model service is running\. Acme Studio runs on test models, which can't share this machine with your model service\. This can't be changed from Console yet\./);
assert.doesNotMatch(line, /model proxy|Choose another model|check again once/i);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue details.routes-cause-detail p").textContent'), cause);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue [data-org-restart]")'), null, 'a restart would be refused and stop the organization');
assert.equal(await b.evaluate('document.querySelector(".routing-panel button[type=submit]")?.classList.contains("route-save-quiet")'), false, 'with no Restart, Save routes stays the primary');
});
test('settings-s1 B1: a model-key-collision catalogue says two models share a name, offers no Restart and links to Model setup', { timeout: 90000 }, async t => {
const view = { ...VIEW, catalogue: { status: 'unavailable', reason: 'model-key-collision', models: [], notices: [] } };
const { b, wait, text } = await setup(t, { path: '/#/orgs/acme/settings/routing', init: stub(), view });
await wait('document.querySelector("#routes-catalogue a")');
const line = await text('#routes-catalogue');
assert.match(line, /Two of your models get the same short name, so Acme Studio can't tell them apart\. A restart won't change that\./);
assert.doesNotMatch(line, /Restart Acme Studio|model proxy/i);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue [data-org-restart]")'), null, 'a restart comes back to the same state');
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue a[href=\'#/settings/model-proxy\']")?.textContent'), 'Open Model setup');
});
test('settings-s1 B1: a set fence reads as a restart to finish, not as a stopped service; a status read that fails offers Check again', { timeout: 90000 }, async t => {
{
const { b, wait, text } = await setup(t, { path: '/#/orgs/acme/settings/routing', init: stub({ service: SERVICE.fenced }) });
await wait('document.querySelector("#routes-catalogue a")');
const line = await text('#routes-catalogue');
assert.match(line, /Your model service is waiting for a restart to finish\. Open Model setup to finish it\./);
assert.doesNotMatch(line, /not running/);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue a").getAttribute("href")'), '#/settings/model-proxy');
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue [data-org-restart]")'), null);
await b.close();
}
const { b, wait, text } = await setup(t, { path: '/#/orgs/acme/settings/routing', init: stub({ service: null }) });
await wait('document.querySelector("#routes-catalogue #routes-recheck")');
assert.match(await text('#routes-catalogue'), /The model service's status could not be read\./);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue [data-org-restart]")'), null);
});
test('settings-s1 B1: with the model service not set up or not running, Routing links to its page and offers no Restart', { timeout: 90000 }, async t => {
for (const [service, expect, href] of [
[SERVICE.fresh, /Your model service isn't set up yet\. Set up the model service\./, '#/settings/model-proxy'],
[SERVICE.stopped, /The model service is not running\. Open Model setup\./, '#/settings/model-proxy'],
]) {
const { b, wait, text } = await setup(t, { path: '/#/orgs/acme/settings/routing', init: stub({ service }) });
await wait('document.querySelector("#routes-catalogue a")');
assert.match(await text('#routes-catalogue'), expect);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue [data-org-restart]")'), null);
assert.equal(await b.evaluate('document.querySelector("#routes-catalogue a").getAttribute("href")'), href);
await b.close();
}
});
test('settings-s1 B6: a stopped organization keeps its refused restart on screen and keeps the instance pages reachable', { timeout: 90000 }, async t => {
const { b, wait, text } = await setup(t, { path: '/#/orgs/gamma/settings/routing', init: stub({ restart: REFUSED }) });
await wait('document.querySelector("[data-org-down=gamma] [data-org-restart=gamma]")');
assert.match(await text('[data-org-down=gamma] .banner.err'), /^Gamma Home is stopped, so Routing can't be read\./);
// The reason the dashboard already reads (/api/workspace) shows before any restart is pressed.
await wait('document.querySelector("[data-org-down=gamma] [data-org-down-why]:not([hidden])")');
assert.equal(await text('[data-org-down=gamma] [data-org-down-why]'), 'Why it stopped: stopped by the owner');
// One Restart on the page: the header's bus banner steps aside.
assert.equal(await b.evaluate('[...document.querySelectorAll("[data-org-restart], #bus-restart")].filter(e => e.offsetParent).length'), 1);
await b.evaluate('document.querySelector("[data-org-down=gamma] [data-org-restart=gamma]").click(); true');
await wait('window.__writes.length === 1 && document.querySelector("[data-org-down=gamma] [data-org-restart-detail]")');
// The page renders again after the restart; the refusal stays, with its plain line first.
await new Promise(r => setTimeout(r, 500));
const receipt = await text('[data-org-down=gamma] [data-org-restart-receipt]');
assert.match(receipt, /^Gamma Home runs on test models, which can't share this machine with your model service\. It did not start\./);
assert.match(receipt, /bus start refused: fixture-proxy-configured/);
const links = await b.evaluate('[...document.querySelectorAll("[data-org-down=gamma] a")].map(a => [a.textContent, a.getAttribute("href")])');
assert.deepEqual(links, [['Appearance', '#/settings/appearance'], ['Model setup', '#/settings/model-proxy'], ['Triage', '#/settings/triage'], ['Console', '#/settings/console']]);
// A link from the stopped page opens an instance page.
await b.evaluate('document.querySelector("[data-org-down=gamma] a[href=\'#/settings/model-proxy\']").click(); true');
await wait('document.querySelector("#proxy-setup") || document.querySelector("h1")?.textContent === "Model setup"');
assert.notEqual(await text('h1'), 'Not found');
});
// Shots for the build report, current beside proposed: run with MOSAIC_UX_SHOTS=<dir>, on this tree and on
// the base tree with this file copied in. Each waits only for what both trees draw, then settles. At 390
// every visible select must show its chosen text in full, and no page scrolls sideways.
test('shots', { timeout: 600000, skip: !process.env.MOSAIC_UX_SHOTS }, async t => {
const { mkdir, writeFile } = await import('node:fs/promises');
const { join } = await import('node:path');
const { TriageError, ROUTE_REFUSALS } = await import('../src/triage-host.mjs');
const dir = process.env.MOSAIC_UX_SHOTS; await mkdir(dir, { recursive: true });
const settle = () => new Promise(r => setTimeout(r, 1500));
const T = new Date(Date.now() - 20 * 60000).toISOString();
const status = { release: { fetched: true, verified: true, version: '8.0.42', panelVersion: '1.26.7' },
init: { initialized: true, partial: false, settings: { port: 18432 }, files: [] },
unit: { unit: 'mosaic-proxy.service', installed: true, active: 'active', healthy: true, pid: 4242, port: 18432, listening: true },
fence: { set: false }, initLock: { present: false, clearable: false, blockers: [] }, fetch: { state: 'idle' }, restart: null, busy: null,
organizations: [{ id: 'acme', proxy: 'shared', catalogue: { status: 'unavailable', models: 0 } }, { id: 'gamma', proxy: 'shared', catalogue: { status: 'bus-unavailable' } }],
ownProxy: { available: false, state: 'not built', reason: 'The configuration has one proxy per instance.' }, next: ['accounts'] };
const triageRead = { route: { model: 'sonnet', harness: 'claude-code', cap: 200000, reset: '00:00', timeZone: 'Europe/Berlin', revision: 1, updatedAt: T }, revision: 1, send: true,
choices: { status: 'ready', models: [{ key: 'sonnet', label: 'Sonnet', available: true, harnesses: ['claude-code', 'pi'] }, { key: 'glm-flash', label: 'GLM Flash', available: true, harnesses: ['pi'] }] },
note: 'Saving a route does not start Triage. Triage also needs its key.' };
const extra = { '/proxy/accounts': { accounts: [{ accountId: 'a1', displayName: 'Claude work', provider: 'claude', status: 'active', priority: 0 }] }, '/proxy/keys': { keys: [] }, '/api/triage/route': triageRead };
const snapshot = { snapshotVersion: 1, at: T, console: { state: 'answering', at: T }, proxy: 'not read', systemConfig: { valid: true, exit: 0, code: null },
organizations: { count: 2, list: [{ id: 'acme', bus: { state: 'running', lastStart: { ok: true, at: T } }, processing: { halted: false, invalid: false }, config: { valid: true, exit: 0, code: null } },
{ id: 'gamma', bus: { state: 'stopped', lastStart: { ok: false, at: T } }, processing: 'not read', config: { valid: true, exit: 0, code: null } }] } };
const triage = { snapshotAt: () => Date.now(), refresh: async () => null,
state: async () => ({ route: 'set', running: false, lastExit: null, overCapUntil: null, snapshot, transcript: [] }),
message: async () => { throw new TriageError('triage-harness-incompatible', ROUTE_REFUSALS['triage-harness-incompatible']); } };
const PAGES = [
{ name: 'routing', path: '/#/orgs/acme/settings/routing', ready: 'document.querySelector(".routing-panel select")' },
// proxy-pickup: the bus names why it cannot use the running model service.
{ name: 'routing-cause', path: '/#/orgs/acme/settings/routing', ready: 'document.querySelector(".routing-panel select")',
view: { ...VIEW, catalogue: { status: 'unavailable', reason: 'proxy-not-configured', models: [], notices: ['The shared proxy lock does not load (proxy-lock-invalid). Check the proxy state for this instance, then restart this bus.'] } } },
{ name: 'model-service', path: '/#/orgs/acme/settings/model-proxy', ready: 'document.querySelector("#proxy-setup") && !document.querySelector("#proxy-setup").hidden' },
{ name: 'triage-settings', path: '/#/orgs/acme/settings/triage', ready: 'document.querySelector("#triage-route select")' },
// Both trees draw a Restart for the stopped organization; the shot waits for it, presses it, and shows
// what stays on screen after the refusal.
{ name: 'org-down', path: '/#/orgs/gamma/settings/routing', ready: 'document.querySelector("h1") && document.querySelector("[data-org-restart=gamma], [data-bus-restart]")', after: async (b, wait) => {
await b.evaluate('(document.querySelector("[data-org-restart=gamma]") ?? document.querySelector("[data-bus-restart]")).click(); true'); await wait('window.__writes.length > 0');
} },
{ name: 'triage-drawer', path: '/#/dashboard', viewportOnly: true, ready: 'document.querySelector("#triage-open")', after: async (b, wait) => {
await b.evaluate('document.querySelector("#triage-open").click(); true');
await wait('document.querySelector("#triage-text") && !document.querySelector("#triage-text").disabled');
await b.evaluate('document.querySelector("#triage-text").focus(); true'); await b.call('Input.insertText', { text: 'is gamma healthy?' });
await b.evaluate('document.querySelector("#triage-send").click(); true');
await wait('document.querySelector("#triage-send-status")?.textContent.trim()');
} },
];
const report = [];
for (const page of PAGES) {
const f = await setup(t, { path: '/', init: stub({ service: status, restart: REFUSED, extra }), triage, view: page.view ?? VIEW });
// A phone draws its scrollbar over the page; headless Chromium would take 15px of the 390 for it.
await f.b.call('Emulation.setScrollbarsHidden', { hidden: true });
for (const scheme of ['light', 'dark']) for (const width of [390, 1440]) {
await f.b.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: scheme }] });
await f.b.viewport(width, width === 390 ? 844 : 900);
await f.b.navigate(`${f.base}/?shot=${page.name}-${scheme}-${width}${page.path.slice(1)}`);
await f.wait(`(${page.ready}) && !!window.MosaicAppearance`);
await f.b.evaluate(`window.MosaicAppearance.ready.then(() => window.MosaicAppearance.set({ mode: ${JSON.stringify(scheme)} }))`);
if (page.after) await page.after(f.b, f.wait);
await settle();
const fit = await f.b.evaluate(`(() => {
const out = [], probe = document.createElement('span'); probe.style.cssText = 'position:absolute;visibility:hidden;white-space:nowrap'; document.body.append(probe);
for (const s of document.querySelectorAll('select')) { if (!s.checkVisibility()) continue; const cs = getComputedStyle(s), r = s.getBoundingClientRect();
probe.style.font = cs.font; probe.textContent = s.selectedOptions[0]?.textContent ?? '';
const room = s.clientWidth - parseFloat(cs.paddingLeft) - parseFloat(cs.paddingRight);
out.push({ label: s.getAttribute('aria-label') || s.id || s.name, text: probe.textContent, need: Math.ceil(probe.getBoundingClientRect().width), room: Math.floor(room), inside: r.left >= 0 && r.right <= innerWidth + 0.5 }); }
probe.remove(); return { selects: out, sideways: document.documentElement.scrollWidth > document.documentElement.clientWidth };
})()`);
const shot = `${page.name}-${width}-${scheme}.png`;
// The drawer is fixed to the window, so its shot is the window; every other page is shot whole.
if (page.viewportOnly) await f.b.screenshot(join(dir, shot));
else {
const metrics = await f.b.call('Page.getLayoutMetrics'), size = metrics.cssContentSize || metrics.contentSize;
const { data } = await f.b.call('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true, clip: { x: 0, y: 0, width: Math.ceil(size.width), height: Math.ceil(size.height), scale: 1 } });
await writeFile(join(dir, shot), Buffer.from(data, 'base64'));
}
report.push({ page: page.name, width, scheme, shot, ...fit });
}
await f.b.close();
}
await writeFile(join(dir, 'measure.json'), JSON.stringify(report, null, 1));
// Only the measurement is reported for the base tree; this tree must pass it.
if (!process.env.MOSAIC_UX_SHOTS_BASE) for (const r of report) {
assert.equal(r.sideways, false, `${r.shot} scrolls sideways`);
if (r.width === 390) for (const s of r.selects) { assert.ok(s.inside, `${r.shot}: ${s.label} runs off screen`); assert.ok(s.need <= s.room, `${r.shot}: ${s.label} cuts "${s.text}" (${s.need} > ${s.room})`); }
}
});
@@ -9,7 +9,6 @@ import { fileURLToPath } from 'node:url';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { TriageError, NOT_STARTED } from '../src/triage-host.mjs';
import { capMessage, NO_ROUTE_MESSAGE } from '../src/triage-http.mjs';
import { browser } from './browser.mjs';
import { close } from './fixture.mjs';
@@ -63,7 +62,7 @@ function fakeHost(over = {}) {
const triage = {
snapshotAt: () => Date.now(),
refresh: async () => null,
state: async () => { h.reads += 1; return { route: h.route, running: h.running, lastExit: h.lastExit, overCapUntil: h.overCapUntil, snapshot: h.snapshot, transcript: h.transcript }; },
state: async () => { h.reads += 1; return { route: h.route, running: h.running, lastExit: h.lastExit, overCapUntil: h.overCapUntil, snapshot: h.snapshot, transcript: h.transcript, ...(Object.hasOwn(h, 'usageToday') ? { usageToday: h.usageToday, cap: h.cap, resetsAt: h.resetsAt } : {}) }; },
message: async text => {
h.sent.push(text);
const e = h.next; h.next = null;
@@ -77,9 +76,10 @@ function fakeHost(over = {}) {
return { h, triage };
}
async function setup(t, { host = fakeHost(), triage = host.triage, send = true, sso = createDevOwner(), viewport = [1440, 900], path = '/#/dashboard', init = null } = {}) {
// proxyAdmin: a stand-in model service admin, so /api/config says proxyAdmin and Settings > Triage exists.
async function setup(t, { host = fakeHost(), triage = host.triage, send = true, sso = createDevOwner(), viewport = [1440, 900], path = '/#/dashboard', init = null, proxyAdmin = null } = {}) {
const { organizations, agentLevels } = await orgFixture();
const server = await startServer({ port: 0, sso, organizations, agentLevels, triage, send: send ? async () => ({}) : null, log: () => {} });
const server = await startServer({ port: 0, sso, organizations, agentLevels, triage, proxyAdmin, send: send ? async () => ({}) : null, log: () => {} });
t.after(() => close(server));
const b = await browser({ machine: false }); t.after(() => b.close());
await b.viewport(...viewport);
@@ -98,6 +98,9 @@ async function setup(t, { host = fakeHost(), triage = host.triage, send = true,
// The page focuses its heading when its first render ends (bus.js). Open after that, as a person would, or
// that late focus can land after the drawer's own.
// The Settings > Triage panel script (triage-settings, #1873) is a static file every page loads, like
// every other page module; it carries no data. These checks are about Triage traffic, so they skip it.
const SETTINGS_SCRIPT = 'GET /triage-settings.js';
const open = async f => { await f.wait('document.querySelector("#triage-open")'); await f.wait('document.activeElement?.tagName === "H1"', 100).catch(() => {}); await f.click('#triage-open'); await f.wait('["off", "cap", "running", "stopped"].includes(document.querySelector("#triage-drawer #triage-state")?.dataset.kind)'); };
const type = async (f, words) => { await f.b.evaluate('document.querySelector("#triage-text").focus()'); await f.b.call('Input.insertText', { text: words }); };
const sendAndWait = async (f, before) => { await f.click('#triage-send'); await f.wait(`document.querySelector("#triage-send-status").textContent.trim() && document.querySelector("#triage-send-status").textContent !== ${JSON.stringify(before)} && !document.querySelector("#triage-send").disabled`); return f.text('#triage-send-status'); };
@@ -109,7 +112,7 @@ test('item 1: a session that is not the instance owner gets no entry, no drawer
await f.wait('document.querySelector("#dashboard-kpis")');
await sleep(1500);
assert.equal(await f.b.evaluate('document.querySelector("#triage-open, #triage-drawer, [id^=triage]")'), null);
assert.deepEqual(f.requests.filter(r => /triage/i.test(r)), []);
assert.deepEqual(f.requests.filter(r => /triage/i.test(r) && r !== SETTINGS_SCRIPT), []);
}
// A Triage host, but a signed-in session that is not the root owner.
{
@@ -119,7 +122,7 @@ test('item 1: a session that is not the instance owner gets no entry, no drawer
await sleep(1500);
assert.equal(await f.b.evaluate('document.querySelector("[id^=triage]")'), null);
assert.equal(await f.b.evaluate('document.body.innerHTML.includes("Triage")'), false, 'no Triage words in the page');
assert.deepEqual(f.requests.filter(r => /triage/i.test(r)), []);
assert.deepEqual(f.requests.filter(r => /triage/i.test(r) && r !== SETTINGS_SCRIPT), []);
}
});
@@ -135,7 +138,7 @@ test('item 1: the owner gets one Triage entry in the top bar on the dashboard an
assert.equal(await f.b.evaluate('document.querySelector("#triage-open").getAttribute("aria-expanded")'), 'true');
// From inside an organization the read is still the system route, never the organization's.
assert.ok(f.triageReads() >= 1);
assert.deepEqual(f.requests.filter(r => /triage/.test(r) && r !== 'GET /api/triage'), []);
assert.deepEqual(f.requests.filter(r => /triage/.test(r) && r !== 'GET /api/triage' && r !== SETTINGS_SCRIPT), []);
assert.ok(f.requests.includes('GET /api/config'), 'the unscoped config read');
// The same entry on the system dashboard.
await f.b.evaluate('location.hash = "#/dashboard"');
@@ -154,12 +157,13 @@ test('item 1: at 390 wide the entry stays visible and one click opens the drawer
});
test('item 2 and 3: route not set says so, and the message box is off with the reason', async t => {
const f = await setup(t, { host: fakeHost({ route: 'not set' }) });
const f = await setup(t, { host: fakeHost({ route: 'not set' }), proxyAdmin: {} });
await open(f);
assert.match(await f.text('#triage-state'), new RegExp(NO_ROUTE_MESSAGE.slice(0, 40)));
assert.equal(await f.text('#triage-state'), 'Triage has no model chosen yet, so it will not start.');
assert.equal(await f.b.evaluate('document.querySelector("#triage-state-fix a")?.getAttribute("href")'), '#/settings/triage');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text")?.disabled'), true);
assert.equal(await f.b.evaluate('document.querySelector("#triage-send")?.disabled'), true);
assert.match(await f.text('#triage-send-off'), /no model route is set/i);
assert.match(await f.text('#triage-send-off'), /no model chosen yet/i);
});
test('item 2: over cap shows the cap message and the time it takes messages again', async t => {
@@ -167,10 +171,10 @@ test('item 2: over cap shows the cap message and the time it takes messages agai
const f = await setup(t, { host: fakeHost({ overCapUntil: until }) });
await open(f);
const state = await f.text('#triage-state');
assert.ok(state.includes(capMessage(until)), state);
const local = await f.b.evaluate(`window.MosaicLocalTime(${JSON.stringify(until)})`);
assert.ok(state.includes(`Local time: ${local}.`), state);
assert.match(await f.text('#triage-send-off'), /daily token cap/i);
assert.equal(state, `Triage used its daily token limit. It takes messages again at ${local}.`);
assert.equal(await f.b.evaluate('document.querySelector("#triage-state-fix").hidden'), true, 'a set route shows no fix link');
assert.match(await f.text('#triage-send-off'), /daily token limit/i);
});
test('item 2: running, last exit, and the health snapshot with "not read" shown as that', async t => {
@@ -180,9 +184,9 @@ test('item 2: running, last exit, and the health snapshot with "not read" shown
assert.match(await f.text('#triage-state'), /^Running/);
const health = await f.text('#triage-health');
assert.match(health, /Console: answering/);
assert.match(health, /Proxy: not read/);
assert.match(health, /Model service: not read/);
assert.match(health, /System config: valid/);
assert.match(health, /acme: bus running, processing on, config valid/);
assert.match(health, /Acme Studio: bus running, processing on, config valid/);
assert.match(health, /gamma: bus not read, processing not read, config not valid \(org-config-invalid\)/);
assert.doesNotMatch(health.split('\n').find(l => l.startsWith('gamma')), /healthy|running/);
// The next poll picks up a stopped session and its last exit, and a snapshot that read nothing.
@@ -191,7 +195,7 @@ test('item 2: running, last exit, and the health snapshot with "not read" shown
await f.wait('/Last exit/.test(document.querySelector("#triage-state").textContent)', 300);
assert.match(await f.text('#triage-state'), /Not running\. Last exit: code 1/);
const after = await f.text('#triage-health');
assert.match(after, /Proxy: healthy/);
assert.match(after, /Model service: healthy/);
assert.match(after, /System config: not read/);
assert.match(after, /Organizations: not read/);
// No snapshot at all.
@@ -237,8 +241,8 @@ test('item 3: each send answer has plain words, a refused send keeps the draft,
assert.equal(await draft(), 'is acme healthy?', `${label}: the draft stays`);
};
await type(f, 'is acme healthy?');
await refused(() => { host.h.next = new TriageError('triage-no-route', 'x'); }, /Not sent.*no model route is set/i, '409');
await refused(() => { const e = new TriageError('triage-over-cap', 'x'); e.until = until; host.h.next = e; }, new RegExp(`Not sent.*daily token cap.*${until.slice(0, 16)}`), '429');
await refused(() => { host.h.next = new TriageError('triage-no-route', 'x'); }, /Not sent.*no model chosen yet/i, '409');
await refused(() => { const e = new TriageError('triage-over-cap', 'x'); e.until = until; host.h.next = e; }, new RegExp(`Not sent.*daily token limit.*${until.slice(0, 16)}`), '429');
await refused(() => { host.h.next = new TriageError('triage-message-too-long', 'x'); }, /Not sent.*too long/i, '400');
await refused(() => f.b.evaluate('window.__force403 = true'), /Not sent.*read-only/i, '403');
await f.b.evaluate('window.__force403 = false');
@@ -409,3 +413,162 @@ test('item 5: markup and control characters in every field stay text: no element
await sleep(500);
assert.equal(await f.b.evaluate('window.__pwned ?? null'), null);
});
// #1873 triage-followups: the page focuses its heading when its first render ends. A reader who opened
// the drawer before then keeps focus in the drawer. The page holds GET /api/workspace, which the first
// render waits on, until the drawer has opened and taken focus.
const HOLD_WORKSPACE = `(() => { const f = window.fetch; window.__held = 0; window.fetch = (u, o) => { if (String(u?.url ?? u).includes('/api/workspace') && !window.__go) { window.__held += 1; return new Promise(r => { const t = setInterval(() => { if (window.__go) { clearInterval(t); r(f(u, o)); } }, 20); }); } return f(u, o); }; })()`;
test('triage-followups: a drawer opened before the first render ends keeps focus when the render ends', async t => {
const f = await setup(t, { init: HOLD_WORKSPACE });
await f.wait('document.querySelector("#triage-open") && window.__held > 0');
const heading = () => f.b.evaluate('document.querySelector("#bus-view h1")?.textContent ?? null');
await sleep(300);
assert.equal(await heading(), 'Reading…', 'the first render has not ended');
await f.click('#triage-open');
await f.wait('document.querySelector("#triage-drawer")?.contains(document.activeElement)');
await f.b.evaluate('window.__go = true');
await f.wait('document.querySelector("#bus-view h1")?.textContent === "Dashboard"');
await sleep(400);
assert.equal(await f.b.evaluate('document.querySelector("#triage-drawer").contains(document.activeElement)'), true, `focus stays in the drawer, not on ${await f.b.evaluate('document.activeElement?.tagName')}`);
// Escape still closes it and puts focus back on the entry.
await f.b.call('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Escape', code: 'Escape', windowsVirtualKeyCode: 27 });
await f.wait('document.querySelector("#triage-drawer").hidden');
assert.equal(await f.b.evaluate('document.activeElement?.id'), 'triage-open');
});
test('triage-followups: with no drawer open the first render still focuses the heading', async t => {
const f = await setup(t);
await f.wait('document.activeElement?.tagName === "H1"');
});
test('triage-cap: one usage line from the read: not set, the count against the cap with the reset, not read, and markup as text', async t => {
const f = await setup(t, { host: fakeHost({ usageToday: 'not set', cap: 'not set', resetsAt: 'not set' }) });
await open(f);
assert.equal(await f.text('#triage-usage'), 'Daily token limit: not set.');
assert.equal(await f.b.evaluate('document.querySelector("#triage-usage").hidden'), false);
const resetsAt = new Date(Date.now() + 5 * 3600000).toISOString();
const local = await f.b.evaluate(`window.MosaicLocalTime(${JSON.stringify(resetsAt)})`);
Object.assign(f.h, { usageToday: { count: 1234, input: 1200, output: 34, cacheWrite: 0, cacheRead: 0, unknownTurns: 2 }, cap: { limit: 200000, reset: '00:00', timeZone: 'UTC' }, resetsAt });
await f.wait('/^Today:/.test(document.querySelector("#triage-usage").textContent)', 400);
const line = await f.text('#triage-usage');
const [count, limit] = await f.b.evaluate('[(1234).toLocaleString(), (200000).toLocaleString()]');
assert.ok(line.startsWith(`Today: ${count} of ${limit} tokens. Resets at `), line);
assert.ok(line.includes(local), line);
assert.ok(line.endsWith(' 2 turns have no usage reading.'), line);
Object.assign(f.h, { usageToday: 'not read', cap: { limit: 200000, reset: '00:00', timeZone: 'UTC' }, resetsAt: 'not read' });
await f.wait('/not read/.test(document.querySelector("#triage-usage").textContent)', 400);
assert.equal(await f.text('#triage-usage'), "Today's token usage: not read.");
// A count that is not a whole number is not shown as one; markup stays text.
Object.assign(f.h, { usageToday: { count: '<img src=x onerror=alert(1)>', unknownTurns: 0 }, cap: { limit: 1.5 }, resetsAt: '<b>x</b>' });
await f.wait('/^Today: not read/.test(document.querySelector("#triage-usage").textContent)', 400);
assert.equal(await f.text('#triage-usage'), 'Today: not read of not read tokens.');
assert.equal(await f.b.evaluate('document.querySelector("#triage-usage").children.length'), 0);
});
test('triage-cap: a read without the usage fields shows no usage line', async t => {
const f = await setup(t);
await open(f);
assert.equal(await f.b.evaluate('document.querySelector("#triage-usage").hidden'), true);
});
// The Triage route read this test server does not mount: the route names its harness as the module is installed.
const ROUTE_READ = `(()=>{const prev=window.fetch;window.fetch=(i,init)=>{if(new URL(typeof i==="string"?i:i.url,location.href).pathname==="/api/triage/route")return Promise.resolve(new Response(JSON.stringify({route:{model:"sonnet",harness:"claude-code",cap:150000,reset:"00:00",timeZone:"UTC",revision:1,updatedAt:"2026-11-18T12:00:00.000Z"},revision:1,choices:{status:"ready",models:[]},send:true,note:""}),{status:200,headers:{"content-type":"application/json"}}));return prev(i,init);};})()`;
// #1873 settings slice 1, bullet 5 (DESIGN.md section 5): a route refusal is a plain line that says what is
// missing, with a link to the Settings page that fixes it. The harness refusal names the route's harness as
// its module declares it, read from the route; no harness name is written into the page. The key refusal has
// no fix page in slice 1, so it ends at what is missing and offers no link.
test('settings-s1 B5: route refusals read as plain lines with the fix link; the harness line names the route\'s harness', async t => {
const host = fakeHost({ running: false });
const f = await setup(t, { host, proxyAdmin: {}, init: ROUTE_READ });
await open(f);
await type(f, 'is acme healthy?');
const { ROUTE_REFUSALS } = await import('../src/triage-host.mjs');
const cases = [
['triage-harness-incompatible', /^Not sent\. The model Triage uses doesn't run with claude-code, the program its route says runs it\. Choose a model that runs with claude-code, or another program, in Triage settings\. Open Triage settings$/, '#/settings/triage'],
['triage-proxy-down', /^Not sent\. The model service isn't running, so Triage can't start\. Open Model setup$/, '#/settings/model-proxy'],
['triage-model-not-offered', /^Not sent\. The model Triage uses is no longer offered\./, '#/settings/triage'],
['triage-key-missing', /^Not sent\. Triage isn't turned on yet: it needs a Triage key, and none is issued on this instance\.$/, null],
];
let status = '';
for (const [code, pattern, href] of cases) {
host.h.next = new TriageError(code, ROUTE_REFUSALS[code]);
status = await sendAndWait(f, status);
assert.match(status, pattern, code);
assert.doesNotMatch(status, /harness|proxy/i, `${code}: no internal word`);
assert.equal(await f.b.evaluate('document.querySelector("#triage-send-status a")?.getAttribute("href") ?? null'), href, `${code}: fix link`);
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), 'is acme healthy?', `${code}: the draft stays`);
}
// The fix link is reachable by keyboard and goes to its page, closing the drawer.
host.h.next = new TriageError('triage-harness-incompatible', ROUTE_REFUSALS['triage-harness-incompatible']);
status = await sendAndWait(f, status);
await f.b.evaluate('document.querySelector("#triage-send-status a").focus()');
assert.equal(await f.b.evaluate('document.activeElement?.textContent'), 'Open Triage settings');
assert.notEqual(await f.b.evaluate('getComputedStyle(document.activeElement).outlineStyle'), 'none', 'the focused link shows a focus ring');
await f.b.key('Enter', 'Enter');
// The Settings pages live inside the open organization, so the shell scopes the address to it.
await f.wait('/^#(\\/orgs\\/acme)?\\/settings\\/triage$/.test(location.hash) && document.querySelector("#triage-drawer").hidden && document.querySelector("#triage-route")');
assert.notEqual(await f.text('h1'), 'Not found');
});
// When the route read gives no harness (here the server does not mount it), the line stays plain without a name.
test('settings-s1 B5: the harness refusal without a readable route keeps a plain line and its fix link', async t => {
const host = fakeHost({ running: false });
const f = await setup(t, { host, proxyAdmin: {} });
await open(f);
await type(f, 'is acme healthy?');
const { ROUTE_REFUSALS } = await import('../src/triage-host.mjs');
host.h.next = new TriageError('triage-harness-incompatible', ROUTE_REFUSALS['triage-harness-incompatible']);
const status = await sendAndWait(f, '');
assert.equal(status, "Not sent. The model Triage uses doesn't run with the program its route says runs it. Choose a model and a program that run together in Triage settings. Open Triage settings");
assert.equal(await f.b.evaluate('document.querySelector("#triage-send-status a")?.getAttribute("href") ?? null'), '#/settings/triage');
assert.equal(await f.b.evaluate('document.querySelector("#triage-text").value'), 'is acme healthy?', 'the draft stays');
});
// Settings > Triage exists only where /api/config says proxyAdmin, so without it no line links there.
test('settings-s1 B5: without the Triage settings page the refusal keeps its line and offers no link to it', async t => {
const host = fakeHost({ route: 'not set' });
const f = await setup(t, { host });
await open(f);
assert.equal(await f.text('#triage-state'), 'Triage has no model chosen yet, so it will not start.');
assert.equal(await f.b.evaluate('document.querySelector("#triage-state-fix").hidden && !document.querySelector("#triage-state-fix a")'), true);
assert.equal(await f.b.evaluate('document.querySelector("#triage-drawer a[href=\'#/settings/triage\']")'), null);
});
// #1873 settings slice 1, bullet 6 (D7): an organization whose last start was refused reads as not
// running in the Health list, never as running. The snapshot carries the time of the refused start but
// not its reason (triage-snapshot.mjs keeps lastStart {ok, at} only). The reason comes from the read the
// dashboard row uses (GET /api/workspace); when that read names none, the line says where to see why.
test('settings-s1 B6: a refused last start reads as not running in Health, with the time and where to see why', async t => {
const snapshot = SNAPSHOT();
const failedAt = at(30);
snapshot.organizations.list[0] = { id: 'acme', bus: { state: 'stopped', lastStart: { ok: false, at: failedAt } }, processing: { halted: false, invalid: false }, config: { valid: true, exit: 0, code: null } };
const f = await setup(t, { host: fakeHost({ running: true, snapshot }) });
await open(f);
const local = await f.b.evaluate(`window.MosaicLocalTime(${JSON.stringify(failedAt)})`);
const line = (await f.text('#triage-health')).split('\n').find(l => l.startsWith('Acme Studio'));
assert.equal(line, `Acme Studio: not running: its last start failed at ${local} (bus stopped). Restart it on the dashboard to see why, processing on, config valid`);
});
// Review 2, P2-D: the workspace read carries the refusal, so Health shows it, through the plain line
// for a known cause and word for word for any other.
const WORKSPACE_REASON = reason => `(() => { const f = window.fetch; window.fetch = (u, o) => String(u?.url ?? u).includes('/api/workspace?org=acme&sections=tasks')
? Promise.resolve(new Response(JSON.stringify({ orgs: [{ org: 'acme', state: 'down', reason: ${JSON.stringify(reason)} }] }), { headers: { 'content-type': 'application/json' } })) : f(u, o); })()`;
test('settings-s1 B6: a refused last start shows the reason the workspace read carries', async t => {
const failedAt = at(30);
for (const [reason, expect] of [
['the bus refused to start: bus start refused: fixture-proxy-configured', ' Acme Studio runs on test models, which can\'t share this machine with your model service. It did not start.'],
['the bus refused to start: stopped by the owner', ' Why it stopped: stopped by the owner.'],
]) {
const snapshot = SNAPSHOT();
snapshot.organizations.list[0] = { id: 'acme', bus: { state: 'stopped', lastStart: { ok: false, at: failedAt } }, processing: { halted: false, invalid: false }, config: { valid: true, exit: 0, code: null } };
const f = await setup(t, { host: fakeHost({ running: true, snapshot }), init: WORKSPACE_REASON(reason) });
await open(f);
const local = await f.b.evaluate(`window.MosaicLocalTime(${JSON.stringify(failedAt)})`);
await f.wait(`/Acme Studio: .*config valid\\./.test(document.querySelector('#triage-health')?.innerText ?? '')`);
const line = (await f.text('#triage-health')).split('\n').find(l => l.startsWith('Acme Studio'));
assert.equal(line, `Acme Studio: not running: its last start failed at ${local} (bus stopped), processing on, config valid.${expect}`);
await f.b.close();
}
});
File diff suppressed because it is too large. Load diff
+18 -1
View File
@@ -4,7 +4,7 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { request } from 'node:http';
import { mkdtempSync, existsSync, readFileSync } from 'node:fs';
import { mkdtempSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
import { join } from 'node:path';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
@@ -12,6 +12,8 @@ import { consoleAccess } from '../src/access.mjs';
import { createSsoSession } from './helpers/sso-session.mjs';
import { NO_ROUTE_MESSAGE, capMessage, triageView, triageHTTP, SNAPSHOT_MAX_AGE_MS } from '../src/triage-http.mjs';
import { createTriageHost, TriageError } from '../src/triage-host.mjs';
import { writeRoute } from '../src/triage-route-store.mjs';
import { appendUsage, usagePath } from '../src/triage-usage.mjs';
const LEAK = '/home/owner/.config/mosaic-dev/secret-token-0123456789';
@@ -239,6 +241,21 @@ test('with the real host and no route: the read says so in plain words, the writ
assert.equal(JSON.parse(readFileSync(join(host.paths.health, 'snapshot.json'), 'utf8')).snapshotVersion, 1, 'the read wrote the snapshot');
});
test('triage-cap: the read carries usageToday, cap and resetsAt from the real host, and no path, model or harness', async t => {
const dataRoot = join(mkdtempSync(join(process.env.TMPDIR, 'th-')), 'data');
mkdirSync(join(dataRoot, 'triage'), { recursive: true, mode: 0o700 });
writeRoute(dataRoot, { model: 'glm-5', harness: 'claude-code', limit: 1000, timeZone: 'UTC', by: 'owner' }, { now: () => new Date('2026-11-18T00:00:00.000Z') });
appendUsage(usagePath(dataRoot), { at: '2026-11-18T09:00:00.000Z', run: 'triage-20261118090000', turn: 'owner-0123456789ab', status: 'known', input: 30, output: 5, cacheRead: 2, cacheWrite: 1 });
const host = createTriageHost({ dataRoot, readSnapshot: async () => null, now: () => new Date('2026-11-18T10:00:00.000Z'), bwrap: '/nonexistent/bwrap' });
const f = await devServer(t, { triage: host });
const read = await send(f.port, '/api/triage', { headers: { host: f.headers.host } });
assert.equal(read.status, 200);
assert.deepEqual(read.json.usageToday, { count: 38, input: 30, output: 5, cacheWrite: 1, cacheRead: 2, unknownTurns: 0 });
assert.deepEqual(read.json.cap, { limit: 1000, reset: '00:00', timeZone: 'UTC' });
assert.equal(read.json.resetsAt, '2026-11-19T00:00:00.000Z');
for (const leak of [dataRoot, 'glm-5', 'claude-code', 'usage.jsonl', '"since"']) assert.equal(read.text.includes(leak), false, leak);
});
test('the route module keeps its own write checks when called alone: --send, one exact Origin, one same-origin Fetch Metadata', async () => {
const triage = fakeTriage();
const call = async (headers, { send = true } = {}) => {
@@ -0,0 +1,393 @@
// #1873 triage-settings: GET and POST /api/triage/route over the real HTTP boundary. Only the instance
// owner reaches them, a write is same-origin, the model and harness are checked as an organization's
// route change is, the store does the write (one receipt), and no key or path reaches a response.
import test from 'node:test';
import assert from 'node:assert/strict';
import { request } from 'node:http';
import { mkdtempSync, readFileSync, rmSync, writeFileSync, existsSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { startServer } from '../src/serve.mjs';
import { createDevOwner } from '../src/dev-owner.mjs';
import { consoleAccess } from '../src/access.mjs';
import { createSsoSession } from './helpers/sso-session.mjs';
import { routePaths, readRoute, writeRoute } from '../src/triage-route-store.mjs';
import { triageRouteRoutes, mergeCatalogues, installedHarnesses, ownerActor, TRIAGE_ROUTE_PATH, NOT_STARTED_NOTE } from '../src/triage-route-http.mjs';
const SECRET = 'sk-triage-route-sentinel-0123456789abcdef';
const T = '2026-11-18T12:00:00.000Z';
const model = (key, extra = {}) => ({ key, module: 'anthropic', upstream: 'cliproxy', provider: 'anthropic', model: `claude-${key}`, label: key.toUpperCase(), available: true, reason: null, harnesses: ['claude-code', 'pi'], ...extra });
// One catalogue as an organization's `routes` verb answers. A leaked field would carry the sentinel.
const READY = () => ({ status: 'ready', observedAt: T, notices: [`key ${SECRET} at /srv/proxy/keys.json`], models: [
model('sonnet', { reason: `${SECRET} /home/owner/.config/mosaic-dev/proxy.json` }),
model('glm-flash', { module: 'opencode', provider: 'zai', model: 'glm-5.3-flash', harnesses: ['pi'] }),
model('down', { available: false, reason: 'proxy says no' }),
] });
const BODY = { model: 'sonnet', harness: 'claude-code', cap: 200000, timeZone: 'Europe/Berlin', revision: 0 };
const send = (port, path, { method = 'GET', headers = {}, body } = {}) => new Promise((resolve, reject) => {
const req = request({ host: '127.0.0.1', port, path, method, headers }, res => {
let text = ''; res.on('data', c => { text += c; }); res.on('end', () => resolve({ status: res.statusCode, text, json: (() => { try { return JSON.parse(text); } catch { return null; } })() }));
});
req.on('error', reject); req.end(body === undefined ? undefined : typeof body === 'string' ? body : JSON.stringify(body));
});
const receipts = root => { const f = routePaths(root).receipts; return existsSync(f) ? readFileSync(f, 'utf8').split('\n').filter(Boolean).map(l => JSON.parse(l)) : []; };
async function devServer(t, { catalogues = async () => [READY()], harnesses = () => ['claude-code', 'pi'], ...options } = {}) {
const root = mkdtempSync(join(tmpdir(), 'tr-http-'));
t.after(() => rmSync(root, { recursive: true, force: true }));
const logs = [], routeLogs = [];
const s = await startServer({ port: 0, board: 'http://127.0.0.1:9', sso: createDevOwner(), send: async () => ({}), log: line => logs.push(line),
routes: [triageRouteRoutes({ dataRoot: root, catalogues, harnesses, log: line => routeLogs.push(line) })], ...options });
t.after(() => new Promise(r => s.close(r)));
const port = s.address().port;
const origin = `http://127.0.0.1:${port}`;
const read = { host: `127.0.0.1:${port}`, 'sec-fetch-site': 'same-origin' };
const write = { ...read, origin, 'content-type': 'application/json' };
const get = (headers = read) => send(port, TRIAGE_ROUTE_PATH, { headers });
const post = (body = BODY, headers = write) => send(port, TRIAGE_ROUTE_PATH, { method: 'POST', headers, body });
return { s, port, root, logs, routeLogs, read, write, get, post };
}
test('GET without a stored route says it is not set and offers the catalogue models with their harnesses', async t => {
const f = await devServer(t);
const r = await f.get();
assert.equal(r.status, 200);
assert.equal(r.json.route, null);
assert.equal(r.json.routeMessage, 'No Triage route is set.');
assert.equal(r.json.revision, 0);
assert.equal(r.json.send, true);
assert.equal(r.json.note, NOT_STARTED_NOTE);
assert.deepEqual(r.json.choices, { status: 'ready', models: [
{ key: 'down', label: 'DOWN', available: false, harnesses: ['claude-code', 'pi'] },
{ key: 'glm-flash', label: 'GLM-FLASH', available: true, harnesses: ['pi'] },
{ key: 'sonnet', label: 'SONNET', available: true, harnesses: ['claude-code', 'pi'] },
] });
assert.equal(r.text.includes(SECRET), false);
assert.equal(r.text.includes(f.root), false);
assert.equal(r.text.includes('/srv/') || r.text.includes('/home/'), false);
});
test('GET with a stored route returns its model, harness, cap, reset, zone, revision and time, and no path or actor detail', async t => {
const f = await devServer(t);
writeRoute(f.root, { model: 'sonnet', harness: 'pi', limit: 5000, timeZone: 'America/Chicago', by: 'local-dev-owner' }, { now: () => new Date(T) });
const r = await f.get();
assert.equal(r.status, 200);
assert.deepEqual(r.json.route, { model: 'sonnet', harness: 'pi', cap: 5000, reset: '00:00', timeZone: 'America/Chicago', revision: 1, updatedAt: T });
assert.equal(r.json.revision, 1);
assert.equal(Object.hasOwn(r.json, 'routeMessage'), false);
assert.equal(r.text.includes(f.root), false);
});
test('POST writes through the store: one receipt, the signed-in owner as updatedBy, the revision moves', async t => {
const f = await devServer(t);
const r = await f.post();
assert.equal(r.status, 200, r.text);
assert.equal(r.json.route.model, 'sonnet');
assert.equal(r.json.route.harness, 'claude-code');
assert.equal(r.json.route.cap, 200000);
assert.equal(r.json.route.timeZone, 'Europe/Berlin');
assert.equal(r.json.route.reset, '00:00');
assert.equal(r.json.revision, 1);
assert.equal(r.json.note, NOT_STARTED_NOTE);
const doc = readRoute(f.root);
assert.equal(doc.updatedBy, 'local-dev-owner');
assert.equal(doc.cap.limit, 200000);
const lines = receipts(f.root);
assert.equal(lines.length, 1);
assert.equal(lines[0].by, 'local-dev-owner');
assert.equal(lines[0].revision, 1);
const again = await f.post({ ...BODY, harness: 'pi', revision: 1 });
assert.equal(again.status, 200);
assert.equal(receipts(f.root).length, 2);
for (const line of f.routeLogs) assert.match(line, /^\S+ (GET|POST) \/api\/triage\/route \d{3}$/);
});
test('a stale revision answers 409 with the stored revision and writes nothing', async t => {
const f = await devServer(t);
assert.equal((await f.post()).status, 200);
const stale = await f.post({ ...BODY, cap: 9 });
assert.equal(stale.status, 409);
assert.equal(stale.json.error, 'triage-route-stale');
assert.equal(stale.json.revision, 1);
assert.match(stale.json.message, /changed since this page read it/);
assert.equal(readRoute(f.root).cap.limit, 200000);
assert.equal(receipts(f.root).length, 1);
});
test('a model the catalogue does not offer, or one it marks unavailable, is refused and nothing is written', async t => {
const f = await devServer(t);
const unknown = await f.post({ ...BODY, model: 'opus' });
assert.equal(unknown.status, 400);
assert.equal(unknown.json.error, 'unknown-model');
const down = await f.post({ ...BODY, model: 'down' });
assert.equal(down.status, 503);
assert.equal(down.json.error, 'model-provider-unavailable');
for (const bad of [7, ['sonnet'], { key: 'sonnet' }, 'BAD KEY', '']) {
const r = await f.post({ ...BODY, model: bad });
assert.equal(r.status, 400, JSON.stringify(bad));
assert.equal(r.json.error, 'unknown-model', JSON.stringify(bad));
}
assert.equal(readRoute(f.root), null);
assert.deepEqual(receipts(f.root), []);
});
test('a harness the model is not compatible with, or one not installed, is refused', async t => {
const f = await devServer(t);
const wrong = await f.post({ ...BODY, model: 'glm-flash', harness: 'claude-code' });
assert.equal(wrong.status, 400);
assert.equal(wrong.json.error, 'model-harness-incompatible');
// Installed here is only pi: the catalogue's claude-code is not offered and not accepted.
const g = await devServer(t, { harnesses: () => ['pi'] });
assert.deepEqual((await g.get()).json.choices.models.find(m => m.key === 'sonnet').harnesses, ['pi']);
const off = await g.post({ ...BODY, harness: 'claude-code' });
assert.equal(off.status, 400);
assert.ok(['model-harness-incompatible', 'harness-off'].includes(off.json.error), off.text);
const bad = await f.post({ ...BODY, harness: 'Not A Name' });
assert.equal(bad.json.error, 'harness-off');
assert.equal(readRoute(f.root), null);
assert.equal(readRoute(g.root), null);
});
test('the installed harness check is the organization one: a compatible harness no module provides is harness-off', async t => {
const catalogue = READY(); catalogue.models[0].harnesses = ['claude-code', 'pi', 'ghost'];
// harnesses() lists ghost so the merged catalogue keeps it; the check gets the installed list without it.
let calls = 0;
const f = await devServer(t, { catalogues: async () => [catalogue], harnesses: () => (++calls % 2 === 1 ? ['claude-code', 'pi', 'ghost'] : ['claude-code', 'pi']) });
const r = await f.post({ ...BODY, harness: 'ghost' });
assert.equal(r.json.error, 'harness-off', r.text);
});
test('a catalogue that is not ready, or no organization bus answering, refuses the write and shows no choices', async t => {
for (const catalogues of [async () => [{ status: 'starting', models: [] }], async () => [{ status: 'bus-unavailable' }], async () => [], async () => { throw new Error(SECRET); }]) {
const f = await devServer(t, { catalogues });
const r = await f.get();
assert.equal(r.status, 200);
assert.deepEqual(r.json.choices.models, []);
assert.notEqual(r.json.choices.status, 'ready');
const w = await f.post();
assert.equal(w.status, 503);
assert.equal(w.json.error, 'model-provider-unavailable');
assert.equal(w.text.includes(SECRET) || r.text.includes(SECRET), false);
assert.equal(readRoute(f.root), null);
}
});
test('a missing or unknown time zone is refused; there is no default', async t => {
const f = await devServer(t);
const { timeZone, ...noZone } = BODY;
for (const body of [noZone, { ...BODY, timeZone: '' }, { ...BODY, timeZone: null }]) {
const r = await f.post(body);
assert.equal(r.status, 400, JSON.stringify(body));
assert.equal(r.json.error, 'triage-zone-required', JSON.stringify(body));
}
for (const zone of ['Mars/Olympus', 'not a zone', 42]) {
const r = await f.post({ ...BODY, timeZone: zone });
assert.equal(r.status, 400, String(zone));
assert.equal(r.json.error, 'triage-zone-unknown', String(zone));
}
assert.equal(readRoute(f.root), null);
const lower = await f.post({ ...BODY, timeZone: 'america/chicago' });
assert.equal(lower.status, 200, JSON.stringify(lower.json));
assert.equal(readRoute(f.root).cap.timeZone, 'America/Chicago', 'a zone in another case is stored in its canonical spelling');
assert.equal(lower.json.route.timeZone, 'America/Chicago');
});
test('a cap that is not a positive whole number is refused', async t => {
const f = await devServer(t);
for (const cap of [0, -1, 1.5, '1000', null, undefined, Number.MAX_SAFE_INTEGER + 1, true]) {
const body = { ...BODY, cap }; if (cap === undefined) delete body.cap;
const r = await f.post(body);
assert.equal(r.status, 400, String(cap));
assert.equal(r.json.error, 'triage-cap-invalid', String(cap));
}
assert.equal((await f.post({ ...BODY, cap: 1 })).status, 200, 'one token is a cap');
});
test('a body with another key, a bad revision, a wrong type or too many bytes is invalid-request', async t => {
const f = await devServer(t);
for (const body of [{ ...BODY, by: 'mallory' }, { ...BODY, revision: -1 }, { ...BODY, revision: '0' }, [BODY], 'null', '{', JSON.stringify({ ...BODY, model: 'a'.repeat(17000) })]) {
const r = await f.post(body);
assert.equal(r.status, 400, typeof body === 'string' ? body.slice(0, 20) : JSON.stringify(body).slice(0, 60));
assert.equal(r.json.error, 'invalid-request');
}
const { revision, ...noRevision } = BODY;
assert.equal((await f.post(noRevision)).json.error, 'invalid-request', 'the revision is required');
const text = await f.post(BODY, { ...f.write, 'content-type': 'text/plain' });
assert.equal(text.json.error, 'invalid-request');
assert.equal(readRoute(f.root), null);
});
test('both routes refuse a cross-origin request; a read may omit the metadata; a write needs both checks exactly once', async t => {
const f = await devServer(t);
// Read: a foreign Origin or cross-site Fetch Metadata is refused. Missing metadata is the repo GET convention.
const evil = await f.get({ ...f.read, origin: 'http://evil.example' });
assert.equal(evil.status, 403);
assert.match(evil.json.error, /^cross-origin/, 'the serve gate or the handler refuses it');
const bare = await f.get({ host: f.read.host });
assert.equal(bare.status, 200, 'a read with no Origin and no Fetch Metadata is allowed');
assert.equal((await f.get({ ...f.read, 'sec-fetch-site': 'none' })).status, 200, 'a typed address is allowed');
const cross = await f.get({ ...f.read, 'sec-fetch-site': 'cross-site' });
assert.equal(cross.status, 403);
assert.equal(cross.json.error, 'cross-site');
assert.equal((await f.get({ host: f.read.host, 'sec-fetch-site': 'same-site' })).status, 403);
assert.equal((await f.get({ ...f.read, origin: `http://127.0.0.1:${f.port}` })).status, 200, 'a matching Origin on a read is fine');
// Write: missing Origin, foreign Origin, missing or cross-site Fetch Metadata.
const { origin, ...noOrigin } = f.write;
const missing = await f.post(BODY, noOrigin);
assert.equal(missing.status, 403);
assert.match(missing.json.error, /^cross-origin/, 'the serve gate or the handler refuses it');
assert.equal((await f.post(BODY, { ...f.write, origin: 'http://evil.example' })).status, 403);
const { 'sec-fetch-site': _, ...noSite } = f.write;
assert.equal((await f.post(BODY, noSite)).status, 403);
assert.equal((await f.post(BODY, { ...f.write, 'sec-fetch-site': 'same-site' })).status, 403);
assert.equal(readRoute(f.root), null);
assert.deepEqual(receipts(f.root), []);
});
test('a LAN dev host reads the route with no Fetch Metadata and writes with its own Origin', async t => {
const f = await devServer(t, { devAllowHosts: ['lanbox'] });
const host = `lanbox:${f.port}`;
const r = await f.get({ host });
assert.equal(r.status, 200);
assert.equal(r.json.route, null);
const w = await f.post(BODY, { host, origin: `http://${host}`, 'content-type': 'application/json' });
assert.equal(w.status, 200, JSON.stringify(w.json));
assert.equal(readRoute(f.root).model, BODY.model);
const foreign = await f.post(BODY, { host, origin: 'http://evil.example', 'content-type': 'application/json' });
assert.equal(foreign.status, 403);
assert.equal(readRoute(f.root).revision, 1);
});
test('the handler holds the same-origin line itself: a doubled Origin or Sec-Fetch-Site is refused', async t => {
const root = mkdtempSync(join(tmpdir(), 'tr-unit-'));
t.after(() => rmSync(root, { recursive: true, force: true }));
let handler;
triageRouteRoutes({ dataRoot: root, catalogues: async () => [READY()], harnesses: () => ['claude-code', 'pi'] })({ add: (method, path, fn) => { handler = fn; } });
const call = (method, headersDistinct, extra = {}) => new Promise(resolve => {
const res = { writeHead(status) { this.status = status; }, end(text) { resolve({ status: this.status, json: JSON.parse(text) }); } };
const req = { method, headersDistinct, headers: { 'content-type': 'application/json' }, async *[Symbol.asyncIterator]() { yield Buffer.from(JSON.stringify(BODY)); } };
handler(req, res, { owner: true, session: { provider: 'local-dev', sub: 'local-dev-owner' }, origin: 'https://console.example', send: true, ...extra });
});
const o = 'https://console.example';
for (const method of ['PUT', 'DELETE', 'PATCH']) assert.equal((await call(method, { origin: [o], 'sec-fetch-site': ['same-origin'] })).json.error, 'method-not-allowed', method);
assert.equal(readRoute(root), null);
assert.equal((await call('GET', { origin: [o, o], 'sec-fetch-site': ['same-origin'] })).json.error, 'cross-origin');
assert.equal((await call('GET', { 'sec-fetch-site': ['same-origin', 'same-origin'] })).json.error, 'cross-site');
assert.equal((await call('GET', { origin: ['https://evil.example'], 'sec-fetch-site': ['same-origin'] })).json.error, 'cross-origin');
assert.equal((await call('POST', { origin: [o, o], 'sec-fetch-site': ['same-origin'] })).json.error, 'cross-origin');
assert.equal((await call('POST', { origin: [o], 'sec-fetch-site': ['same-origin', 'same-origin'] })).json.error, 'cross-site');
assert.equal((await call('POST', { origin: [o], 'sec-fetch-site': ['same-origin'] }, { send: false })).json.error, 'read-only');
assert.equal((await call('GET', { 'sec-fetch-site': ['same-origin'] }, { owner: false })).json.error, 'human-required');
assert.equal((await call('POST', { origin: [o], 'sec-fetch-site': ['same-origin'] }, { owner: false })).json.error, 'human-required');
assert.equal((await call('POST', { origin: [o], 'sec-fetch-site': ['same-origin'] }, { session: { provider: 'oidc', sub: 'Owner Sub' } })).json.error, 'human-required', 'an owner with no recordable name is refused');
assert.equal(readRoute(root), null);
assert.equal((await call('POST', { origin: [o], 'sec-fetch-site': ['same-origin'] })).status, 200);
});
test('a read-only Console reads the route but refuses a write', async t => {
const f = await devServer(t, { send: null });
const r = await f.get();
assert.equal(r.status, 200);
assert.equal(r.json.send, false);
const w = await f.post();
assert.equal(w.status, 403);
assert.equal(w.json.error, 'read-only');
assert.equal(readRoute(f.root), null);
});
test('an SSO root owner reads and writes as their account; a granted user and a signed-out caller reach neither route', async t => {
const access = { accessVersion: 1, revision: 1,
users: [{ id: 'alice', home: 'local', subjects: [{ provider: 'writer', sub: 'alice-sub' }] }],
grants: [{ id: 'g-1', user: 'alice', business: 'demo', projects: ['*'], instances: ['*'], level: 'collaborator' }] };
const auth = await createSsoSession(t, { host: 'console.example', users: consoleAccess({ load: () => access, business: () => 'demo' }) });
const root = mkdtempSync(join(tmpdir(), 'tr-sso-'));
t.after(() => rmSync(root, { recursive: true, force: true }));
const s = await startServer({ port: 0, sso: auth.sso, send: async () => ({}), log: () => {},
routes: [triageRouteRoutes({ dataRoot: root, catalogues: async () => [READY()], harnesses: () => ['claude-code', 'pi'] })] });
t.after(() => new Promise(r => s.close(r)));
const port = s.address().port;
const owner = auth.writeHeaders(await auth.signIn(port));
assert.equal((await send(port, TRIAGE_ROUTE_PATH, { headers: owner })).status, 200);
const saved = await send(port, TRIAGE_ROUTE_PATH, { method: 'POST', headers: owner, body: BODY });
assert.equal(saved.status, 200, saved.text);
assert.match(readRoute(root).updatedBy, /^u-[0-9a-f]{12}$/);
const alice = auth.writeHeaders(await auth.signIn(port, { sub: 'alice-sub' }));
const aliceRead = await send(port, TRIAGE_ROUTE_PATH, { headers: alice });
assert.equal(aliceRead.status, 403);
assert.ok(['owner-only', 'human-required'].includes(aliceRead.json.error), aliceRead.text);
assert.equal(aliceRead.text.includes('sonnet'), false, 'a granted user sees no route');
const aliceWrite = await send(port, TRIAGE_ROUTE_PATH, { method: 'POST', headers: alice, body: { ...BODY, revision: 1, cap: 7 } });
assert.equal(aliceWrite.status, 403);
const nobody = await send(port, TRIAGE_ROUTE_PATH, { headers: { host: 'console.example', 'sec-fetch-site': 'same-origin' } });
assert.equal(nobody.status, 401);
const nobodyWrite = await send(port, TRIAGE_ROUTE_PATH, { method: 'POST', headers: { host: 'console.example', origin: 'https://console.example', 'sec-fetch-site': 'same-origin', 'content-type': 'application/json' }, body: { ...BODY, revision: 1 } });
assert.equal(nobodyWrite.status, 401);
// Cross-origin as the owner, on the public name.
assert.equal((await send(port, TRIAGE_ROUTE_PATH, { method: 'POST', headers: { ...owner, origin: 'https://evil.example' }, body: { ...BODY, revision: 1 } })).status, 403);
assert.equal((await send(port, TRIAGE_ROUTE_PATH, { headers: { ...owner, origin: 'https://evil.example' } })).status, 403);
assert.equal(readRoute(root).revision, 1);
assert.equal(readRoute(root).cap.limit, 200000);
assert.equal(receipts(root).length, 1);
});
test('the tester listener reaches neither route', async t => {
const { startTesterSocket } = await import('../src/tester-socket.mjs');
const { testerRequest } = await import('../../cli/src/tester-http.mjs');
const root = mkdtempSync(join(tmpdir(), 'tr-tester-'));
t.after(() => rmSync(root, { recursive: true, force: true }));
const s = await startTesterSocket({ dataRoot: root, log: () => {}, routes: [triageRouteRoutes({ dataRoot: root, catalogues: async () => [READY()], harnesses: () => ['claude-code', 'pi'] })] });
t.after(() => new Promise(r => s.close(r)));
for (const method of ['GET', 'POST']) {
const r = await testerRequest({ dataRoot: root, path: TRIAGE_ROUTE_PATH, method, body: method === 'POST' ? BODY : undefined });
assert.equal(r.status, 403, method);
}
assert.equal(readRoute(root), null);
});
test('a busy store and an unreadable store answer with fixed words and no path', async t => {
const f = await devServer(t);
assert.equal((await f.post()).status, 200);
const { lock, file } = routePaths(f.root);
writeFileSync(lock, JSON.stringify({ pid: process.pid, at: T }), { mode: 0o600 });
const busy = await f.post({ ...BODY, revision: 1 });
assert.equal(busy.status, 409);
assert.equal(busy.json.error, 'triage-route-busy');
assert.equal(busy.text.includes(f.root) || busy.text.includes('route.lock'), false);
rmSync(lock);
writeFileSync(file, '{not json', { mode: 0o600 });
const broken = await f.get();
assert.equal(broken.status, 503);
assert.equal(broken.json.error, 'triage-route-unreadable');
assert.equal(broken.text.includes(f.root) || broken.text.includes('route.json'), false);
const brokenWrite = await f.post({ ...BODY, revision: 1 });
assert.equal(brokenWrite.json.error, 'triage-route-unreadable');
assert.equal(brokenWrite.text.includes(f.root), false);
});
test('no response or log line carries the sentinel, the data root or a store path', async t => {
const f = await devServer(t);
const all = [await f.get(), await f.post(), await f.get(), await f.post({ ...BODY, cap: 0 }), await f.post({ ...BODY, model: 'opus' }), await f.post({ ...BODY, revision: 0 }), await f.post(BODY, { ...f.write, origin: 'http://evil.example' })];
const text = all.map(r => r.text).join('\n') + f.routeLogs.join('\n') + f.logs.join('\n');
for (const needle of [SECRET, f.root, 'route.json', 'route.lock', 'route-receipts', '/srv/', '/home/', 'cliproxy', 'anthropic']) assert.equal(text.includes(needle), false, needle);
});
test('mergeCatalogues: a key two catalogues disagree on is dropped; availability and harnesses must hold everywhere', () => {
const a = { status: 'ready', models: [model('sonnet'), model('glm', { harnesses: ['pi'] }), model('x', { available: false })] };
const b = { status: 'ready', models: [model('sonnet', { harnesses: ['pi'] }), model('glm', { upstream: 'other' }), model('x'), model('y', { available: false })] };
a.models.push(model('y'));
const merged = mergeCatalogues([a, b, { status: 'bus-unavailable' }], ['claude-code', 'pi']);
assert.equal(merged.status, 'ready');
assert.deepEqual(merged.models.map(m => [m.key, m.available, m.harnesses]), [['sonnet', true, ['pi']], ['x', false, ['claude-code', 'pi']], ['y', false, ['claude-code', 'pi']]]);
assert.deepEqual(mergeCatalogues([{ status: 'starting' }], ['pi']), { status: 'starting', models: [] });
assert.deepEqual(mergeCatalogues([], ['pi']), { status: 'unavailable', models: [] });
assert.deepEqual(mergeCatalogues([{ status: 'ready', models: [{ key: 'BAD KEY', harnesses: ['pi'] }, null] }], ['pi']).models, []);
});
test('installedHarnesses lists the harness modules on disk; ownerActor names the account or the dev owner', () => {
assert.deepEqual(installedHarnesses(), ['claude-code', 'pi']);
assert.equal(ownerActor({ account: 'u-0123456789ab', provider: 'writer', sub: 'x' }), 'u-0123456789ab');
assert.equal(ownerActor({ provider: 'local-dev', sub: 'local-dev-owner' }), 'local-dev-owner');
assert.equal(ownerActor({ provider: 'writer', sub: 'owner-sub' }), null);
assert.equal(ownerActor(null), null);
});
@@ -0,0 +1,424 @@
// #1873 triage-route-store: the owner-only file that holds Triage's model route and daily cap,
// <dataRoot>/triage/route.json (design report section 1, option C). Names only: no env value and
// no key. The directory is 0700 and the file 0600, both the running user's; a link, a non-file,
// a wrong mode or owner refuses. A write is compare-and-set on revision, atomic (temp file plus
// rename in the same directory), and appends one receipt line.
import { test } from "node:test";
import assert from "node:assert/strict";
import { spawn } from "node:child_process";
import { chmodSync, existsSync, linkSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import {
CAP_FIELDS, ROUTE_FIELDS, ROUTE_VERSION, RouteStoreError, capFor, readRoute, routePaths, validRoute, writeRoute,
} from "../src/triage-route-store.mjs";
const MODULE = new URL("../src/triage-route-store.mjs", import.meta.url).pathname;
const NOW = "2026-11-18T12:00:00.000Z";
const LATER = "2026-11-18T13:00:00.000Z";
const at = (iso) => () => new Date(iso);
const INPUT = { model: "glm-5", harness: "claude-code", limit: 200000, timeZone: "America/Chicago", by: "owner" };
function root(t) {
const dir = mkdtempSync(join(process.env.TMPDIR, "trs-"));
t.after(() => rmSync(dir, { recursive: true, force: true }));
return dir;
}
const code = (c) => (e) => e instanceof RouteStoreError && e.code === c;
// Unreadable with a given reason, so each check is shown to refuse on its own.
const unreadableFor = (re) => (e) => code("triage-route-unreadable")(e) && re.test(e.message);
const receipts = (dataRoot) => readFileSync(routePaths(dataRoot).receipts, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
const good = () => ({
version: 1, revision: 1, model: "glm-5", harness: "claude-code",
cap: { limit: 200000, since: NOW, reset: "00:00", timeZone: "America/Chicago" }, updatedAt: NOW, updatedBy: "owner",
});
// Write a doc straight to route.json at the right modes, to test the loader alone.
function plant(dataRoot, doc) {
const { dir, file } = routePaths(dataRoot);
mkdirSync(dir, { recursive: true, mode: 0o700 });
chmodSync(dir, 0o700);
writeFileSync(file, typeof doc === "string" ? doc : JSON.stringify(doc), { mode: 0o600 });
chmodSync(file, 0o600);
}
test("paths, field names and the reset rule each live in one place", () => {
const p = routePaths("/d");
assert.deepEqual(p, { dir: "/d/triage", file: "/d/triage/route.json", receipts: "/d/triage/route-receipts.jsonl", lock: "/d/triage/route.lock" });
assert.deepEqual([...ROUTE_FIELDS].sort(), ["cap", "harness", "model", "revision", "updatedAt", "updatedBy", "version"]);
assert.deepEqual([...CAP_FIELDS].sort(), ["limit", "reset", "since", "timeZone"]);
assert.equal(ROUTE_VERSION, 1);
// A new cap starts its count now and resets at 00:00 in the owner's zone.
assert.deepEqual(capFor({ limit: 5, timeZone: "UTC", previous: null, now: NOW }), { limit: 5, since: NOW, reset: "00:00", timeZone: "UTC" });
// A later cap keeps its since, changed or not, as an organization's token limits do: lowering
// the cap never drops the tokens already counted.
const prev = { limit: 5, since: NOW, reset: "00:00", timeZone: "UTC" };
assert.equal(capFor({ limit: 5, timeZone: "UTC", previous: prev, now: LATER }).since, NOW);
assert.equal(capFor({ limit: 2, timeZone: "UTC", previous: prev, now: LATER }).since, NOW);
assert.equal(capFor({ limit: 5, timeZone: "Europe/Berlin", previous: prev, now: LATER }).since, NOW);
});
test("no file reads as not set; a write then reads back the same route", (t) => {
const d = root(t);
assert.equal(readRoute(d), null);
const written = writeRoute(d, INPUT, { now: at(NOW) });
assert.deepEqual(written, good());
assert.deepEqual(readRoute(d), good());
const { dir, file } = routePaths(d);
assert.equal(lstatSync(dir).mode & 0o777, 0o700);
assert.equal(lstatSync(file).mode & 0o777, 0o600);
// The store holds names only: nothing shaped like an env value or a key.
const text = readFileSync(file, "utf8");
assert.doesNotMatch(text, /ANTHROPIC|_KEY|TOKEN|mst-|msk-|env/i);
// A second write bumps the revision and keeps the cap's since when the cap is the same.
const second = writeRoute(d, { ...INPUT, model: "glm-5.3-flash", revision: 1 }, { now: at(LATER) });
assert.equal(second.revision, 2);
assert.equal(second.model, "glm-5.3-flash");
assert.equal(second.cap.since, NOW);
assert.equal(second.updatedAt, LATER);
assert.deepEqual(readRoute(d), second);
// No temp file or lock is left behind.
assert.deepEqual(readdirSync(dir).sort(), ["route-receipts.jsonl", "route.json"]);
});
test("each write appends one receipt line with the old and the new value", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
writeRoute(d, { ...INPUT, limit: 1000 }, { now: at(LATER) });
const lines = receipts(d);
assert.equal(lines.length, 2);
assert.deepEqual(lines[0], { at: NOW, by: "owner", revision: 1, from: null, to: { model: "glm-5", harness: "claude-code", cap: good().cap } });
assert.equal(lines[1].revision, 2);
assert.deepEqual(lines[1].from, { model: "glm-5", harness: "claude-code", cap: good().cap });
assert.equal(lines[1].to.cap.limit, 1000);
assert.equal(lines[1].to.cap.since, NOW);
assert.equal(lstatSync(routePaths(d).receipts).mode & 0o777, 0o600);
// A refused write appends nothing.
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-stale"));
assert.equal(receipts(d).length, 2);
});
test("a stale revision refuses and leaves the file alone", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
writeRoute(d, { ...INPUT, limit: 7, revision: 1 }, { now: at(NOW) });
const before = readFileSync(routePaths(d).file, "utf8");
assert.throws(() => writeRoute(d, { ...INPUT, limit: 9, revision: 1 }, { now: at(LATER) }), code("triage-route-stale"));
assert.throws(() => writeRoute(d, { ...INPUT, limit: 9, revision: 3 }, { now: at(LATER) }), code("triage-route-stale"));
assert.equal(readFileSync(routePaths(d).file, "utf8"), before);
// Revision 0 means "only if there is no route yet".
assert.throws(() => writeRoute(d, { ...INPUT, revision: 0 }, { now: at(LATER) }), code("triage-route-stale"));
const e = root(t);
assert.equal(writeRoute(e, { ...INPUT, revision: 0 }, { now: at(NOW) }).revision, 1);
});
test("refused input shapes on a write", (t) => {
const d = root(t);
// Each input check refuses with its own message, so none rests only on the final shape check.
const bad = [
[{ ...INPUT, model: "" }, /model must be/], [{ ...INPUT, model: "Has Space" }, /model must be/],
[{ ...INPUT, model: "x".repeat(65) }, /model must be/], [{ ...INPUT, model: 5 }, /model must be/],
[{ ...INPUT, harness: "" }, /harness must be/], [{ ...INPUT, harness: "Claude" }, /harness must be/],
[{ ...INPUT, harness: "../pi" }, /harness must be/], [{ ...INPUT, harness: "x".repeat(33) }, /harness must be/],
[{ ...INPUT, limit: -1 }, /the cap must be/], [{ ...INPUT, limit: 1.5 }, /the cap must be/],
[{ ...INPUT, limit: "100" }, /the cap must be/], [{ ...INPUT, limit: 2 ** 53 }, /the cap must be/],
[{ ...INPUT, timeZone: undefined }, /a time zone is required/], [{ ...INPUT, timeZone: "" }, /time zone is unknown/],
[{ ...INPUT, timeZone: "Mars/Olympus_Mons" }, /time zone is unknown/], [{ ...INPUT, timeZone: "../etc" }, /time zone is unknown/],
[{ ...INPUT, timeZone: "+05:00" }, /time zone is unknown/],
[{ ...INPUT, by: "" }, /actor name/], [{ ...INPUT, by: "Owner Person" }, /actor name/],
[{ ...INPUT, revision: -1 }, /revision must be/], [{ ...INPUT, revision: "1" }, /revision must be/], [{ ...INPUT, revision: 1.5 }, /revision must be/],
[{ ...INPUT, env: { A: "b" } }, /unknown field env/], [{ ...INPUT, key: "mst-x" }, /unknown field key/],
[null, /not an object/], [[INPUT], /not an object/],
];
for (const [input, message] of bad) {
assert.throws(() => writeRoute(d, input, { now: at(NOW) }), (e) => code("triage-route-invalid")(e) && message.test(e.message), JSON.stringify(input));
}
// No time zone default: leaving it out refuses.
const { timeZone, ...noZone } = INPUT;
assert.throws(() => writeRoute(d, noZone, { now: at(NOW) }), (e) => code("triage-route-invalid")(e) && /a time zone is required/.test(e.message));
assert.equal(readRoute(d), null);
});
test("an unknown time zone refuses on write and on read", (t) => {
const d = root(t);
assert.throws(() => writeRoute(d, { ...INPUT, timeZone: "Atlantis/Lost" }, { now: at(NOW) }), code("triage-route-invalid"));
plant(d, { ...good(), cap: { ...good().cap, timeZone: "Atlantis/Lost" } });
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
});
test("each refused stored shape reads as unreadable", (t) => {
const g = good();
const shapes = {
"not json": "{",
"an array": [g],
"null": null,
"unknown field": { ...g, env: {} },
"unknown cap field": { ...g, cap: { ...g.cap, perTurn: 5 } },
"missing version": (({ version, ...r }) => r)(g),
"missing revision": (({ revision, ...r }) => r)(g),
"missing model": (({ model, ...r }) => r)(g),
"missing harness": (({ harness, ...r }) => r)(g),
"missing cap": (({ cap, ...r }) => r)(g),
"missing updatedAt": (({ updatedAt, ...r }) => r)(g),
"missing updatedBy": (({ updatedBy, ...r }) => r)(g),
"missing cap.limit": { ...g, cap: (({ limit, ...r }) => r)(g.cap) },
"missing cap.since": { ...g, cap: (({ since, ...r }) => r)(g.cap) },
"missing cap.reset": { ...g, cap: (({ reset, ...r }) => r)(g.cap) },
"missing cap.timeZone": { ...g, cap: (({ timeZone, ...r }) => r)(g.cap) },
"version 2": { ...g, version: 2 },
"revision 0": { ...g, revision: 0 },
"revision text": { ...g, revision: "1" },
"bad model": { ...g, model: "A B" },
"bad harness": { ...g, harness: "A/B" },
"cap an array": { ...g, cap: [1] },
"negative limit": { ...g, cap: { ...g.cap, limit: -1 } },
"bad reset": { ...g, cap: { ...g.cap, reset: "24:00" } },
"bad since": { ...g, cap: { ...g.cap, since: "2026-11-18" } },
"bad updatedAt": { ...g, updatedAt: "yesterday" },
"bad updatedBy": { ...g, updatedBy: "A B" },
};
for (const [name, doc] of Object.entries(shapes)) {
const d = root(t);
plant(d, doc);
assert.throws(() => readRoute(d), code("triage-route-unreadable"), name);
if (typeof doc !== "string") assert.equal(validRoute(doc), false, name);
}
assert.equal(validRoute(g), true);
// A write over an unreadable file refuses too; it never replaces what it could not read.
const d = root(t);
plant(d, { ...g, env: {} });
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), code("triage-route-unreadable"));
});
test("an oversized file is refused before it is parsed", (t) => {
const d = root(t);
plant(d, JSON.stringify(good()) + " ".repeat(70000));
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
});
test("a wrong mode on the directory or the file refuses", (t) => {
for (const mode of [0o755, 0o750, 0o711, 0o500]) {
const d = root(t);
plant(d, good());
chmodSync(routePaths(d).dir, mode);
assert.throws(() => readRoute(d), code("triage-route-unreadable"), `dir ${mode.toString(8)}`);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"), `dir ${mode.toString(8)}`);
chmodSync(routePaths(d).dir, 0o700);
}
for (const mode of [0o644, 0o640, 0o604, 0o400, 0o700]) {
const d = root(t);
plant(d, good());
chmodSync(routePaths(d).file, mode);
assert.throws(() => readRoute(d), code("triage-route-unreadable"), `file ${mode.toString(8)}`);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"), `file ${mode.toString(8)}`);
}
// A receipts file with the wrong mode refuses the write before the route changes.
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
chmodSync(routePaths(d).receipts, 0o644);
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER) }), code("triage-route-unreadable"));
assert.equal(readRoute(d).revision, 1);
});
test("a wrong owner refuses on the directory and the file", (t) => {
const d = root(t);
plant(d, good());
// Pretend to be another user: the store compares with the uid it is given.
const other = process.getuid() + 1;
// The files alone owned by someone else: route.json on read and write, the receipts on write.
assert.throws(() => readRoute(d, { fileUid: other }), unreadableFor(/route\.json is not owned by this user/));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW), fileUid: other }), unreadableFor(/route\.json is not owned by this user/));
const e = root(t);
writeRoute(e, INPUT, { now: at(NOW) });
unlinkSync(routePaths(e).file);
assert.throws(() => writeRoute(e, INPUT, { now: at(NOW), fileUid: other }), unreadableFor(/route-receipts\.jsonl is not owned by this user/));
assert.equal(existsSync(routePaths(e).file), false);
assert.throws(() => readRoute(d, { uid: other }), unreadableFor(/the triage directory is not owned by this user/));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW), uid: other }), unreadableFor(/the triage directory is not owned by this user/));
assert.equal(readRoute(d, { uid: process.getuid() }).revision, 1);
});
test("a link at the file, the directory or the receipts refuses; so does a non-file", (t) => {
// Symlink at route.json, to a valid route elsewhere.
let d = root(t);
plant(d, good());
const elsewhere = join(d, "elsewhere.json");
renameSync(routePaths(d).file, elsewhere);
symlinkSync(elsewhere, routePaths(d).file);
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(NOW) }), code("triage-route-unreadable"));
// A hard link at route.json.
d = root(t);
plant(d, good());
linkSync(routePaths(d).file, join(d, "hard.json"));
assert.throws(() => readRoute(d), code("triage-route-unreadable"));
// Symlink at the triage directory, to a real 0700 directory holding a valid route.
d = root(t);
const real = join(d, "real");
mkdirSync(real, { mode: 0o700 });
writeFileSync(join(real, "route.json"), JSON.stringify(good()), { mode: 0o600 });
symlinkSync(real, routePaths(d).dir);
assert.throws(() => readRoute(d), unreadableFor(/the triage directory is a link/));
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), unreadableFor(/the triage directory is a link/));
// A directory where route.json should be.
d = root(t);
mkdirSync(routePaths(d).file, { recursive: true, mode: 0o700 });
chmodSync(routePaths(d).dir, 0o700);
assert.throws(() => readRoute(d), unreadableFor(/route\.json is not a regular file/));
// A file where the triage directory should be, at 0700 so only the directory check refuses it.
d = root(t);
writeFileSync(routePaths(d).dir, "x", { mode: 0o700 });
chmodSync(routePaths(d).dir, 0o700);
assert.throws(() => readRoute(d), unreadableFor(/the triage directory is not a directory/));
assert.throws(() => writeRoute(d, INPUT, { now: at(NOW) }), unreadableFor(/the triage directory is not a directory/));
// A symlink at the receipts file refuses the write and never follows it.
d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
const target = join(d, "target.jsonl");
writeFileSync(target, "", { mode: 0o600 });
unlinkSync(routePaths(d).receipts);
symlinkSync(target, routePaths(d).receipts);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-unreadable"));
assert.equal(readFileSync(target, "utf8"), "");
assert.equal(readRoute(d).revision, 1);
// A symlink at the lock path is not followed: the write refuses as busy.
d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
symlinkSync(join(d, "nowhere"), routePaths(d).lock);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), code("triage-route-busy"));
assert.equal(existsSync(join(d, "nowhere")), false);
});
test("a write under a narrow umask still leaves 0700 and 0600, so the next read works", (t) => {
const d = root(t);
const old = process.umask(0o277);
let written;
try { written = writeRoute(d, INPUT, { now: at(NOW) }); } finally { process.umask(old); }
const { dir, file, receipts: r } = routePaths(d);
assert.equal(lstatSync(dir).mode & 0o777, 0o700);
assert.equal(lstatSync(file).mode & 0o777, 0o600);
assert.equal(lstatSync(r).mode & 0o777, 0o600);
assert.deepEqual(readRoute(d), written);
// An existing receipts file is never repaired: a wrong mode still refuses.
chmodSync(r, 0o644);
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), unreadableFor(/route-receipts\.jsonl mode is not 0600/));
});
test("a failed temp write refuses and leaves the route; a failed receipt after the rename says so", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
const before = readFileSync(routePaths(d).file, "utf8");
const fail = (stage) => (s) => { if (s === stage) throw Object.assign(new Error("no space"), { code: "ENOSPC" }); };
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER), hook: fail("write") }), unreadableFor(/route\.json cannot be written/));
assert.equal(readFileSync(routePaths(d).file, "utf8"), before);
assert.deepEqual(readdirSync(routePaths(d).dir).sort(), ["route-receipts.jsonl", "route.json"]);
assert.equal(receipts(d).length, 1);
// After the rename the route has changed; the refusal names the new revision and the missing line.
assert.throws(() => writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, { now: at(LATER), hook: fail("after-rename") }),
(e) => code("triage-route-unrecorded")(e) && /changed to revision 2, but its receipt line was not written/.test(e.message));
assert.equal(readRoute(d).revision, 2);
assert.equal(receipts(d).length, 1);
assert.deepEqual(readdirSync(routePaths(d).dir).sort(), ["route-receipts.jsonl", "route.json"]);
});
test("the store makes its directory 0700 but never the data root", (t) => {
const d = root(t);
assert.throws(() => writeRoute(join(d, "missing"), INPUT, { now: at(NOW) }), code("triage-route-unreadable"));
assert.equal(existsSync(join(d, "missing")), false);
});
test("two writers in one process: the second, while the first holds the lock, refuses busy", (t) => {
const d = root(t);
writeRoute(d, INPUT, { now: at(NOW) });
let inner = null;
const won = writeRoute(d, { ...INPUT, limit: 1, revision: 1 }, {
now: at(LATER),
hook: (stage) => {
if (stage !== "before-rename") return;
try { writeRoute(d, { ...INPUT, limit: 2, revision: 1 }, { now: at(LATER) }); } catch (e) { inner = e; }
},
});
assert.equal(won.cap.limit, 1);
assert.ok(code("triage-route-busy")(inner), String(inner));
assert.equal(readRoute(d).cap.limit, 1);
assert.equal(receipts(d).length, 2);
});
// A child process that loads the store and writes once; prints {ok, code}. `wait` makes it hold
// at the given stage until the file `go` appears, so two children overlap for real.
const CHILD = `
import { writeRoute } from ${JSON.stringify(MODULE)};
import { existsSync, writeFileSync } from "node:fs";
const [dataRoot, limit, revision, wait, go, ready] = process.argv.slice(1);
try {
const r = writeRoute(dataRoot, { model: "glm-5", harness: "claude-code", limit: Number(limit), timeZone: "UTC", by: "owner", revision: Number(revision) }, {
hook: (stage) => {
if (stage === "crash") { if (wait === "crash") process.kill(process.pid, "SIGKILL"); return; }
if (stage !== wait) return;
writeFileSync(ready, "");
const end = Date.now() + 20000;
while (!existsSync(go) && Date.now() < end) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
},
});
console.log(JSON.stringify({ ok: true, limit: r.cap.limit }));
} catch (e) { console.log(JSON.stringify({ ok: false, code: e.code ?? String(e) })); }
`;
function child(args) {
return new Promise((resolve, reject) => {
const p = spawn(process.execPath, ["--input-type=module", "-e", CHILD, ...args], { stdio: ["ignore", "pipe", "pipe"] });
let out = "", err = "";
p.stdout.setEncoding("utf8").on("data", (c) => { out += c; });
p.stderr.setEncoding("utf8").on("data", (c) => { err += c; });
p.on("error", reject);
p.on("close", (status, signal) => resolve({ status, signal, out: out.trim(), err }));
});
}
async function until(path) {
const end = Date.now() + 20000;
while (!existsSync(path)) {
if (Date.now() > end) throw new Error(`timed out waiting for ${path}`);
await new Promise((r) => setTimeout(r, 20));
}
}
test("two writer processes racing on one revision: one wins, one refuses", async (t) => {
const d = root(t);
writeRoute(d, { ...INPUT, timeZone: "UTC" }, { now: at(NOW) });
const go = join(d, "go"), ready = join(d, "ready");
// The first holds just before its rename; the second starts then, with the same revision.
const first = child([d, "11", "1", "before-rename", go, ready]);
await until(ready);
const second = await child([d, "22", "1", "none", join(d, "unused"), join(d, "unused-ready")]);
writeFileSync(go, "");
const a = JSON.parse((await first).out), b = JSON.parse(second.out);
assert.deepEqual(a, { ok: true, limit: 11 });
assert.equal(b.ok, false);
assert.equal(b.code, "triage-route-busy");
assert.equal(readRoute(d).cap.limit, 11);
assert.equal(readRoute(d).revision, 2);
// After the winner, the loser's revision is stale.
const again = JSON.parse((await child([d, "22", "1", "none", join(d, "u2"), join(d, "u3")])).out);
assert.deepEqual(again, { ok: false, code: "triage-route-stale" });
// Started together with no pause, exactly one of two wins.
const both = await Promise.all([child([d, "33", "2", "none", join(d, "u4"), join(d, "u5")]), child([d, "44", "2", "none", join(d, "u6"), join(d, "u7")])]);
const results = both.map((r) => JSON.parse(r.out));
assert.equal(results.filter((r) => r.ok).length, 1, JSON.stringify(results));
assert.ok(results.filter((r) => !r.ok).every((r) => ["triage-route-busy", "triage-route-stale"].includes(r.code)), JSON.stringify(results));
assert.equal(readRoute(d).revision, 3);
assert.equal(receipts(d).length, 3);
});
test("a crash between the temp write and the rename leaves the old file", async (t) => {
const d = root(t);
const old = writeRoute(d, { ...INPUT, timeZone: "UTC" }, { now: at(NOW) });
const r = await child([d, "99", "1", "crash", join(d, "go"), join(d, "ready")]);
assert.equal(r.signal, "SIGKILL", r.err);
assert.deepEqual(readRoute(d), old);
assert.equal(receipts(d).length, 1);
// The temp file is still there, and the dead writer's lock refuses the next write, naming it.
const { dir, lock } = routePaths(d);
assert.ok(readdirSync(dir).some((n) => n.endsWith(".tmp")), readdirSync(dir).join(","));
assert.throws(() => writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }), (e) => code("triage-route-busy")(e) && /not running/.test(e.message) && /route\.lock/.test(e.message));
// The person removes the lock by hand; the next write works and the read ignores the temp file.
unlinkSync(lock);
assert.equal(writeRoute(d, { ...INPUT, revision: 1 }, { now: at(LATER) }).revision, 2);
assert.equal(readRoute(d).revision, 2);
});
@@ -0,0 +1,267 @@
// #1873 triage-settings: Settings > Triage in a real browser. The owner sees "not set", picks a model,
// a harness from that model's list, a cap and a time zone, and saves in three clicks; a refusal is one
// line and keeps the fields; a stale revision offers a re-read; a second Save while one runs does
// nothing; anyone /api/config does not call the owner gets no Triage page and no route read.
import test from 'node:test';
import assert from 'node:assert/strict';
import { w15Fixture } from './w15-fixture.mjs';
const T = '2026-11-18T12:00:00.000Z';
const NOTE = 'Saving a route does not start Triage. Triage also needs its key.';
const choices = { status: 'ready', models: [
{ key: 'down', label: 'Down', available: false, harnesses: ['claude-code'] },
{ key: 'glm-flash', label: 'GLM Flash', available: true, harnesses: ['pi'] },
{ key: 'sonnet', label: 'Sonnet', available: true, harnesses: ['claude-code', 'pi'] },
] };
const unset = { route: null, routeMessage: 'No Triage route is set.', revision: 0, choices, send: true, note: NOTE };
const route = (over = {}) => ({ model: 'sonnet', harness: 'pi', cap: 200000, reset: '00:00', timeZone: 'Europe/Berlin', revision: 1, updatedAt: T, ...over });
const config = (over = {}) => ({ send: true, devOwner: true, sso: true, proxyAdmin: true, proxyAdminSend: true, ...over });
const scenario = (read = unset, extra = {}, cfg = {}) => ({ '/api/config': config(cfg), '/api/triage/route': read, ...extra });
const writes = b => b.evaluate('window.__writes.filter(w=>w.path==="/api/triage/route").map(w=>({method:w.method,body:JSON.parse(w.body)}))');
// The fixture answers in the page, so no resource timing exists: count the route reads in a wrapper.
const countReads = b => b.call('Page.addScriptToEvaluateOnNewDocument', { source: '(()=>{window.__routeReads=0;const prev=window.fetch;window.fetch=(i,init)=>{try{if(new URL(typeof i==="string"?i:i.url,location.href).pathname==="/api/triage/route"&&(init?.method??"GET")==="GET")window.__routeReads++;}catch{}return prev(i,init);};})()' });
const reads = b => b.evaluate('window.__routeReads');
const pick = (b, id, value) => b.evaluate(`(()=>{const el=document.getElementById(${JSON.stringify(id)});el.value=${JSON.stringify(value)};el.dispatchEvent(new Event('input',{bubbles:true}));el.dispatchEvent(new Event('change',{bubbles:true}));})()`);
const type = (b, id, value) => b.evaluate(`(()=>{const el=document.getElementById(${JSON.stringify(id)});el.value=${JSON.stringify(value)};el.dispatchEvent(new Event('input',{bubbles:true}));})()`);
const text = (b, id) => b.evaluate(`document.getElementById(${JSON.stringify(id)})?.textContent ?? null`);
const value = (b, id) => b.evaluate(`document.getElementById(${JSON.stringify(id)})?.value ?? null`);
const options = (b, id) => b.evaluate(`[...document.getElementById(${JSON.stringify(id)}).options].map(o=>[o.value,o.textContent,o.disabled])`);
async function fill(b, { model = 'sonnet', harness = 'claude-code', cap = '150000', zone = 'America/Chicago' } = {}) {
await pick(b, 'triage-route-model', model);
if (harness !== null) await pick(b, 'triage-route-harness', harness);
await type(b, 'triage-route-cap', cap);
await type(b, 'triage-route-zone', zone);
}
test('the owner sees Triage in Settings, "not set" before a first save, the catalogue choices and the note', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: scenario() });
await countReads(b);
await b.navigate(f.base + '/#/settings');
await wait('document.querySelector(\'#settings-nav a[href="#/settings/triage"]\')');
await b.evaluate('document.querySelector(\'#settings-nav a[href="#/settings/triage"]\').click()');
await wait('document.getElementById("triage-route-stored")');
assert.match(await text(b, 'triage-route-stored'), /^Not set\. Triage has no model chosen yet, so it will not start\.$/);
assert.ok(await reads(b) >= 1, 'the owner page reads the route (the counter works)');
assert.equal(await text(b, 'triage-route-note'), NOTE);
assert.equal(await text(b, 'settings-page-title'), 'Triage');
assert.deepEqual(await options(b, 'triage-route-model'), [['', 'Choose a model', false], ['down', 'Down (down) (unavailable)', true], ['glm-flash', 'GLM Flash (glm-flash)', false], ['sonnet', 'Sonnet (sonnet)', false]]);
assert.deepEqual(await options(b, 'triage-route-harness'), [['', 'Choose a model first', false]]);
// The help line names no harness: the list carries each harness's id as its module is installed.
assert.equal(await text(b, 'triage-route-harness-help'), 'The program that runs the model, named as its module is installed. The list shows only the programs this model runs with.');
assert.equal(await value(b, 'triage-route-cap'), '', 'no default cap');
assert.equal(await value(b, 'triage-route-zone'), '', 'no default time zone');
assert.equal(await value(b, 'triage-route-reset'), '00:00');
assert.equal(await b.evaluate('document.getElementById("triage-route-reset").readOnly'), true);
assert.equal(await b.evaluate('document.querySelector(".settings-readonly")'), null);
assert.equal(await b.evaluate('document.getElementById("triage-route-catalogue")'), null);
// The harness list follows the model; a model with one harness picks it.
await pick(b, 'triage-route-model', 'glm-flash');
assert.deepEqual(await options(b, 'triage-route-harness'), [['', 'Choose what runs it', false], ['pi', 'pi', false]]);
assert.equal(await value(b, 'triage-route-harness'), 'pi');
await pick(b, 'triage-route-model', 'sonnet');
assert.deepEqual((await options(b, 'triage-route-harness')).map(o => o[0]), ['', 'claude-code', 'pi']);
assert.equal(await value(b, 'triage-route-harness'), 'pi', 'a harness the new model takes is kept');
assert.deepEqual(await writes(b), []);
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
assert.deepEqual(await b.evaluate('window.__errors'), []);
});
test('Save posts the fields and the read revision once, then shows the stored route; three clicks from Settings', { timeout: 90000 }, async t => {
const saved = route({ harness: 'claude-code', cap: 150000, timeZone: 'America/Chicago' });
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(unset, { 'POST /api/triage/route': { body: { route: saved, revision: 1, note: NOTE } } }) });
await b.navigate(f.base + '/#/settings');
await wait('document.querySelector(\'#settings-nav a[href="#/settings/triage"]\')');
await b.evaluate('document.querySelector(\'#settings-nav a[href="#/settings/triage"]\').click()');
await wait('document.getElementById("triage-route-model")');
await fill(b, { zone: ' America/Chicago ' });
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==="1"');
assert.equal(await b.evaluate('document.activeElement?.id'), 'triage-route-line', 'focus lands on the saved line, not the page body');
assert.deepEqual(await writes(b), [{ method: 'POST', body: { model: 'sonnet', harness: 'claude-code', cap: 150000, timeZone: 'America/Chicago', revision: 0 } }]);
assert.match(await text(b, 'triage-route-stored'), /^Saved route: sonnet, runs with claude-code\. Daily token limit 150,000, resets at 00:00 America\/Chicago\. Saved .+\.$/);
assert.equal(await value(b, 'triage-route-cap'), '150000');
// The next save carries the new revision.
await type(b, 'triage-route-cap', '9000');
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))[1].body.revision, 1);
assert.deepEqual(await b.evaluate('window.__unexpected'), []);
});
test('a stored route fills the fields; each refusal is one plain line and keeps the fields', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: scenario({ ...unset, route: route(), routeMessage: undefined, revision: 1 }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-model")?.value==="sonnet"');
assert.equal(await value(b, 'triage-route-harness'), 'pi');
assert.equal(await value(b, 'triage-route-cap'), '200000');
assert.equal(await value(b, 'triage-route-zone'), 'Europe/Berlin');
assert.equal(await text(b, 'triage-route-stored'), `Saved route: sonnet, runs with pi. Daily token limit 200,000, resets at 00:00 Europe/Berlin. Saved ${await b.evaluate('window.MosaicLocalTime("2026-11-18T12:00:00.000Z")')}.`);
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '1');
for (const [error, message, status] of [['triage-zone-unknown', 'The time zone is not one this Console knows.', 400], ['model-harness-incompatible', 'That harness does not run this model.', 400], ['model-provider-unavailable', 'The model provider is not available now.', 503]]) {
await b.evaluate(`Object.assign(window.__scenario, {'POST /api/triage/route': {status: ${status}, body: {error: ${JSON.stringify(error)}, message: ${JSON.stringify(message)}}}})`);
await fill(b, { zone: 'Mars/Olympus', cap: '777' });
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait(`document.getElementById("triage-route-line")?.textContent===${JSON.stringify(message)}`);
assert.equal(await value(b, 'triage-route-model'), 'sonnet');
assert.equal(await value(b, 'triage-route-harness'), 'claude-code');
assert.equal(await value(b, 'triage-route-cap'), '777');
assert.equal(await value(b, 'triage-route-zone'), 'Mars/Olympus');
assert.equal(await b.evaluate('document.getElementById("triage-route-reload")'), null, 'only a conflict offers a re-read');
assert.equal(await b.evaluate('document.getElementById("triage-route-save").disabled'), false);
}
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '1', 'a refusal leaves the stored line alone');
// A refusal with no readable answer still says one line.
await b.evaluate(`Object.assign(window.__scenario, {'POST /api/triage/route': {status: 500, body: {}}})`);
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('document.getElementById("triage-route-line")?.textContent==="The route was refused. Nothing was saved."');
assert.equal(await value(b, 'triage-route-cap'), '777');
// Leaving the page and coming back reads the route again and keeps what was typed.
await b.evaluate('location.hash="#/settings/appearance"');
await wait('!document.getElementById("triage-route")');
await b.evaluate('location.hash="#/settings/triage"');
await wait('document.getElementById("triage-route-cap")');
assert.equal(await value(b, 'triage-route-cap'), '777');
assert.equal(await value(b, 'triage-route-zone'), 'Mars/Olympus');
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '1');
});
test('a stale revision says so, keeps the fields, and Reload route reads the stored route again', { 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(unset, { 'POST /api/triage/route': { status: 409, body: { error: 'triage-route-stale', message, revision: 2 } } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-model")');
await fill(b, { cap: '5000' });
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait(`document.getElementById("triage-route-line")?.textContent===${JSON.stringify(message)}`);
assert.equal(await value(b, 'triage-route-cap'), '5000');
assert.equal(await b.evaluate('document.activeElement?.id'), 'triage-route-reload');
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify({ ...unset, route: route({ revision: 2, model: 'glm-flash', cap: 42 }), routeMessage: undefined, revision: 2 })}`);
await b.evaluate('document.getElementById("triage-route-reload").click()');
await wait('document.getElementById("triage-route-model")?.value==="glm-flash"');
assert.equal(await value(b, 'triage-route-cap'), '42');
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '2');
assert.equal(await b.evaluate('document.getElementById("triage-route-reload")'), null);
await b.evaluate(`window.__scenario['POST /api/triage/route'] = {body: {route: ${JSON.stringify(route({ revision: 3, model: 'glm-flash', cap: 42 }))}, revision: 3, note: ${JSON.stringify(NOTE)}}}`);
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==="3"');
assert.equal((await writes(b)).at(-1).body.revision, 2, 'the save after a re-read carries the stored revision');
});
test('an untouched page follows the store; typed fields keep the revision they were read at, so a later save is stale', { timeout: 90000 }, async t => {
const stored = (over, revision) => ({ ...unset, route: route({ revision, ...over }), routeMessage: undefined, revision });
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(stored({}, 1), { 'POST /api/triage/route': { status: 409, body: { error: 'triage-route-stale', message, revision: 3 } } }) });
const away = async () => {
await b.evaluate('location.hash="#/settings/appearance"');
await wait('!document.getElementById("triage-route")');
await b.evaluate('location.hash="#/settings/triage"');
await wait('document.getElementById("triage-route-cap")');
};
const dot = 'document.querySelector(\'#settings-nav a[href="#/settings/triage"] .settings-dot\') !== null';
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-model")?.value==="sonnet"');
// Saved elsewhere while this page sat untouched: the page shows the new route, with no unsaved mark.
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify(stored({ model: 'glm-flash', cap: 42 }, 2))}`);
await away();
assert.equal(await value(b, 'triage-route-model'), 'glm-flash');
assert.equal(await value(b, 'triage-route-cap'), '42');
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '2');
assert.equal(await b.evaluate(dot), false);
// Typed at revision 2, then saved elsewhere again: the typed fields stay and the save sends revision 2.
await type(b, 'triage-route-cap', '9000');
await b.evaluate(`window.__scenario['/api/triage/route'] = ${JSON.stringify(stored({ model: 'sonnet', cap: 1 }, 3))}`);
await away();
assert.equal(await value(b, 'triage-route-model'), 'glm-flash');
assert.equal(await value(b, 'triage-route-cap'), '9000');
assert.equal(await b.evaluate('document.getElementById("triage-route-stored").dataset.revision'), '3');
assert.equal(await b.evaluate(dot), true, 'the typed fields are marked unsaved');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait(`document.getElementById("triage-route-line")?.textContent===${JSON.stringify(message)}`);
const last = (await writes(b)).at(-1).body;
assert.equal(last.revision, 2, 'the save carries the revision the typed fields were read at, not the newest read');
assert.equal(last.model, 'glm-flash');
assert.equal(last.cap, 9000);
});
test('a second Save while one runs does nothing', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(unset, { 'POST /api/triage/route': { body: { route: route(), revision: 1, note: NOTE } } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-model")');
// Hold the POST until the test lets it go.
await b.evaluate('(()=>{const prev=window.fetch;window.__posts=0;window.fetch=(input,init)=>init?.method==="POST"?(window.__posts++,new Promise(r=>{window.__release=()=>r(prev(input,init));})):prev(input,init);})()');
await fill(b);
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('typeof window.__release==="function"');
assert.equal(await text(b, 'triage-route-save'), 'Saving…');
assert.equal(await b.evaluate('document.getElementById("triage-route-save").disabled'), true);
// A click on the disabled button, a form submit (Enter) and a direct requestSubmit all do nothing.
await b.evaluate('document.getElementById("triage-route-save").click()');
await b.evaluate('document.getElementById("triage-route-form").requestSubmit()');
await b.evaluate('document.getElementById("triage-route-form").dispatchEvent(new Event("submit",{bubbles:true,cancelable:true}))');
assert.equal(await b.evaluate('window.__writes.filter(w=>w.path==="/api/triage/route").length'), 0, 'the held POST is not recorded yet');
assert.equal(await b.evaluate('window.__posts'), 1, 'no second POST left the page');
await b.evaluate('window.__release()');
await wait('/^Saved .+\\.$/.test(document.getElementById("triage-route-line")?.textContent) && document.getElementById("triage-route-stored")?.dataset.revision==="1"');
assert.equal((await writes(b)).length, 1);
});
test('a read-only Console shows the route with Save off and posts nothing', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: scenario({ ...unset, send: false }, {}, { send: false, proxyAdminSend: false }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-save")');
assert.equal(await b.evaluate('document.getElementById("triage-route-save").disabled'), true);
assert.match(await text(b, 'triage-route-readonly'), /read-only/);
assert.equal(await b.evaluate('document.querySelector(".settings-readonly")'), null, 'the panel says read-only once, from the route\'s own answer');
await b.evaluate('document.getElementById("triage-route-form").dispatchEvent(new Event("submit",{bubbles:true,cancelable:true}))');
assert.deepEqual(await writes(b), []);
});
test('a catalogue that is not ready says so and offers no model', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: scenario({ ...unset, choices: { status: 'bus-unavailable', models: [] } }) });
await b.navigate(f.base + '/#/settings/triage');
await wait('document.getElementById("triage-route-catalogue")');
assert.match(await text(b, 'triage-route-catalogue'), /No organization can show your models right now, so no route can be saved\. Open Model setup to see why each organization can.t see your models\./);
assert.equal(await b.evaluate('document.getElementById("triage-route-catalogue").dataset.status'), 'bus-unavailable');
assert.equal(await b.evaluate('document.querySelector("#triage-route-catalogue a").getAttribute("href")'), '#/settings/model-proxy');
assert.deepEqual(await options(b, 'triage-route-model'), [['', 'Choose a model', false]]);
});
test('a non-owner sees no Triage section and the page reads no route', { timeout: 90000 }, async t => {
const { f, b, wait } = await w15Fixture(t, { scenario: scenario(unset, {}, { proxyAdmin: undefined, proxyAdminSend: undefined, user: true }) });
await countReads(b);
await b.navigate(f.base + '/#/settings');
await wait('document.querySelector(\'#settings-nav a[href="#/settings/appearance"]\')');
assert.equal(await b.evaluate('document.querySelector(\'#settings-nav a[href="#/settings/triage"]\')'), null);
await b.navigate(f.base + '/#/settings/triage');
await wait('document.querySelector(".nf")');
assert.equal(await b.evaluate('document.getElementById("triage-route")'), null);
assert.equal(await reads(b), 0, 'no route read for a non-owner');
assert.deepEqual(await writes(b), []);
});
// Shots for the build report: run with MOSAIC_UX_SHOTS=<dir>. Not set, filled and one refusal, at 390
// and 1440, light and dark.
test('shots', { timeout: 300000, skip: !process.env.MOSAIC_UX_SHOTS }, async t => {
const { f, b, wait, capture } = await w15Fixture(t, { slice: 'triage', scenario: scenario(unset, { 'POST /api/triage/route': { status: 400, body: { error: 'triage-zone-unknown', message: 'The time zone is not one this Console knows.' } } }) });
const results = [];
for (const scheme of ['light', 'dark']) {
await b.call('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: scheme }] });
for (const width of [390, 1440]) {
await b.viewport(width, width === 390 ? 844 : 900);
// A fresh document each round, so the kept fields of the last round do not carry over.
await b.navigate(`${f.base}/?shot=${scheme}-${width}#/settings/triage`);
await wait('document.getElementById("triage-route-model") && !!window.MosaicAppearance');
await b.evaluate(`window.MosaicAppearance.ready.then(() => window.MosaicAppearance.set({ mode: ${JSON.stringify(scheme)} }))`);
// No sideways scroll at either width.
assert.equal(await b.evaluate('document.documentElement.scrollWidth <= document.documentElement.clientWidth'), true, `${scheme} ${width} scrolls sideways`);
results.push(await capture(`notset-${scheme}`, width, '#/settings/triage'));
await fill(b);
results.push(await capture(`filled-${scheme}`, width, '#/settings/triage'));
await type(b, 'triage-route-zone', 'Mars/Olympus');
await b.evaluate('document.getElementById("triage-route-save").click()');
await wait('document.getElementById("triage-route-line")?.textContent.includes("time zone")');
results.push(await capture(`refusal-${scheme}`, width, '#/settings/triage'));
}
}
for (const r of results) { assert.deepEqual(r.errors, [], r.full); assert.deepEqual(r.unexpected, [], r.full); }
});
+38 -10
View File
@@ -156,7 +156,7 @@ test("the snapshot file is one 0600 file, replaced whole", () => {
assert.equal(JSON.parse(readFileSync(file, "utf8")).n, 2);
});
test("organizations are read at most ORG_READS_AT_ONCE at a time and listed in registry order", async () => {
test("config checks run at most ORG_READS_AT_ONCE at a time and organizations are listed in registry order", async () => {
let live = 0, most = 0;
const ids = Array.from({ length: 10 }, (_, i) => `org${i}`);
const slow = async () => { live++; most = Math.max(most, live); await new Promise((r) => setTimeout(r, 5)); live--; return { valid: true, exit: 0, code: null }; };
@@ -167,15 +167,19 @@ test("organizations are read at most ORG_READS_AT_ONCE at a time and listed in r
assert.equal(snap.organizations.count, 10);
});
// The timing tests below assert what was read, which no load changes, and a time bound far
// above the one deadline they prove; the "begun late" test moves the deadline's clock by hand.
test("the organization reads share one deadline: forty hung organizations take one timeout, not ten", async () => {
let calls = 0;
const calls = { busStatus: 0, processing: 0, orgConfig: 0 };
const ids = Array.from({ length: 40 }, (_, i) => `org${i}`);
const hang = () => { calls++; return new Promise(() => {}); };
const hang = (name) => () => { calls[name]++; return new Promise(() => {}); };
const began = Date.now();
const snap = await composeSnapshot({ orgs: async () => ids.map((id) => ({ id, state: "active" })), busStatus: hang, processing: hang, orgConfig: hang }, { timeoutMs: 200 });
const snap = await composeSnapshot({ orgs: async () => ids.map((id) => ({ id, state: "active" })), busStatus: hang("busStatus"), processing: hang("processing"), orgConfig: hang("orgConfig") }, { timeoutMs: 200 });
const took = Date.now() - began;
assert.ok(took < 800, `took ${took} ms`);
assert.ok(calls < ids.length, `${calls} reads began`);
// Ten timeouts would be 2000 ms; one is 200.
assert.ok(took < 1500, `took ${took} ms`);
// The config checks behind the first four hang to the deadline, and no later one begins.
assert.ok(calls.orgConfig < ids.length, `${calls.orgConfig} config checks began`);
assert.equal(snap.organizations.count, 40);
assert.deepEqual(snap.organizations.list.map((o) => o.id), ids);
for (const o of snap.organizations.list) assert.deepEqual([o.bus, o.processing, o.config], [NOT_READ, NOT_READ, NOT_READ], o.id);
@@ -184,11 +188,35 @@ test("the organization reads share one deadline: forty hung organizations take o
test("an organization begun late gets only what is left of the deadline", async () => {
const ids = ["a0", "a1", "a2", "a3", "a4"];
const hang = () => new Promise(() => {});
// Three readers hang; a3 answers after 300 ms, and the worker that read it starts a4 with 100 ms left.
const orgConfig = (id) => (id === "a3" ? new Promise((r) => setTimeout(() => r({ valid: true, exit: 0, code: null }), 300)) : hang());
// The deadline's clock moves only by hand. Three readers hang; a3 answers at once and moves the
// clock 300 ms, so the worker that read it starts a4 with 100 ms left. a4 answers after 250 ms:
// inside a whole timeout, outside what is left.
let t = 0;
const answer = { valid: true, exit: 0, code: null };
const orgConfig = (id) => {
if (id === "a3") { t += 300; return answer; }
if (id === "a4") return new Promise((r) => setTimeout(() => r(answer), 250));
return hang();
};
const began = Date.now();
const snap = await composeSnapshot({ orgs: async () => ids.map((id) => ({ id, state: "active" })), orgConfig }, { timeoutMs: 400 });
const snap = await composeSnapshot({ orgs: async () => ids.map((id) => ({ id, state: "active" })), orgConfig }, { timeoutMs: 400, clock: () => t });
const took = Date.now() - began;
assert.ok(took < 600, `took ${took} ms`);
assert.ok(took < 1500, `took ${took} ms`);
assert.deepEqual(snap.organizations.list.map((o) => [o.id, o.config === NOT_READ ? "not read" : "read"]), [["a0", "not read"], ["a1", "not read"], ["a2", "not read"], ["a3", "read"], ["a4", "not read"]]);
});
test("the bus and processing reads are not held behind the config checks: every organization's sockets are read", async () => {
const ids = Array.from({ length: 10 }, (_, i) => `org${i}`);
const hang = () => new Promise(() => {});
// The first four config checks hang to the deadline and hold every config slot; the socket reads answer at once.
const orgConfig = (id) => (ids.indexOf(id) < ORG_READS_AT_ONCE ? hang() : { valid: true, exit: 0, code: null });
const snap = await composeSnapshot({
orgs: async () => ids.map((id) => ({ id, state: "active" })),
busStatus: async () => ({ healthy: true, pid: 1 }),
processing: async () => ({ halted: false, invalid: false }),
orgConfig,
}, { timeoutMs: 300 });
assert.deepEqual(snap.organizations.list.map((o) => o.id), ids);
for (const o of snap.organizations.list) assert.deepEqual([o.bus.state, o.processing], ["running", { halted: false, invalid: false }], o.id);
for (const o of snap.organizations.list.slice(0, ORG_READS_AT_ONCE)) assert.equal(o.config, NOT_READ, o.id);
});
+205
View File
@@ -0,0 +1,205 @@
// #1873 triage-cap: Triage's usage file and its daily cap. One line per turn in
// <dataRoot>/triage/usage.jsonl, held to the same file checks as the route store; the cap is the
// daily-quota plugin's own rule over those lines, with the stored cap as its one leaf.
import { test } from "node:test";
import assert from "node:assert/strict";
import { chmodSync, linkSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
import { execFileSync } from "node:child_process";
import { join } from "node:path";
import { mayLaunch, report } from "../../plugins/limit-check/daily-quota/index.mjs";
import {
USAGE_ACCOUNT, USAGE_FIELDS, appendUsage, capState, delta, limitsFor, nextReset, readUsage, snapshot, usagePath,
} from "../src/triage-usage.mjs";
const scratch = () => mkdtempSync(join(process.env.TMPDIR, "tu-"));
const fileIn = () => {
const dir = join(scratch(), "triage");
mkdirSync(dir, { mode: 0o700 });
return join(dir, "usage.jsonl");
};
const line = (over = {}) => ({ at: "2026-11-18T12:00:00.000Z", run: "triage-20261118120000", turn: "owner-0123456789ab", status: "known", input: 10, output: 5, cacheRead: 2, cacheWrite: 1, ...over });
const unknownLine = (over = {}) => line({ status: "unknown", input: null, output: null, cacheRead: null, cacheWrite: null, ...over });
const cap = (over = {}) => ({ limit: 100, since: "2026-10-01T00:00:00.000Z", reset: "00:00", timeZone: "UTC", ...over });
const ms = (s) => Date.parse(s);
test("the usage file is <dataRoot>/triage/usage.jsonl and a line holds exactly its eight fields", () => {
assert.equal(usagePath("/d"), "/d/triage/usage.jsonl");
assert.deepEqual(USAGE_FIELDS, ["at", "run", "turn", "status", "input", "output", "cacheRead", "cacheWrite"]);
assert.equal(USAGE_ACCOUNT, "triage");
});
test("each append writes one line, 0600, in field order; a torn last line is closed off before the next line", () => {
const file = fileIn();
appendUsage(file, line());
appendUsage(file, unknownLine({ turn: "owner-0123456789ac" }));
assert.equal(lstatSync(file).mode & 0o777, 0o600);
const text = readFileSync(file, "utf8");
assert.equal(text.split("\n").length, 3);
assert.deepEqual(Object.keys(JSON.parse(text.split("\n")[0])), USAGE_FIELDS);
// A crash in a write leaves a torn line. The next append starts on a line of its own.
writeFileSync(file, '{"at":"2026-11-18T12:0', { flag: "a" });
appendUsage(file, line({ turn: "owner-0123456789ad" }));
const lines = readFileSync(file, "utf8").split("\n");
assert.equal(lines.length, 5);
assert.equal(JSON.parse(lines[3]).turn, "owner-0123456789ad");
// A line that does not match its shape is never written.
for (const bad of [{ ...line(), extra: 1 }, line({ at: "yesterday" }), line({ input: -1 }), line({ status: "unknown" }), unknownLine({ input: 3 }), line({ turn: "a b" }), line({ run: "" })]) {
assert.throws(() => appendUsage(file, bad), (e) => e.code === "triage-usage-unreadable", JSON.stringify(bad));
}
assert.equal(readFileSync(file, "utf8").split("\n").length, 5);
});
test("a narrow umask still leaves a new usage file at 0600", () => {
const file = fileIn();
const old = process.umask(0o277);
try { appendUsage(file, line()); } finally { process.umask(old); }
assert.equal(lstatSync(file).mode & 0o777, 0o600);
});
// Each unsafe state refuses both the read and the append, and the append leaves the target alone.
function unsafe(make) {
const file = fileIn();
const opts = make(file) ?? {};
return { file, opts };
}
test("a wrong mode, a wrong owner, a symlink, a hard link or a non-file refuses the read and the append", () => {
const cases = {
"mode 0644": (f) => { appendUsage(f, line()); chmodSync(f, 0o644); },
"mode 0400": (f) => { appendUsage(f, line()); chmodSync(f, 0o400); },
"owner": (f) => { appendUsage(f, line()); return { uid: process.getuid() + 1 }; },
"symlink": (f) => { const real = join(f, "..", "real.jsonl"); writeFileSync(real, "", { mode: 0o600 }); symlinkSync(real, f); },
"dangling symlink": (f) => { symlinkSync(join(f, "..", "absent.jsonl"), f); },
"hard link": (f) => { appendUsage(f, line()); linkSync(f, join(f, "..", "other.jsonl")); },
"directory": (f) => { mkdirSync(f, { mode: 0o700 }); },
"fifo": (f) => { execFileSync("mkfifo", ["-m", "600", f]); },
};
for (const [label, make] of Object.entries(cases)) {
const { file, opts } = unsafe(make);
const before = lstatSync(file);
assert.throws(() => readUsage(file, opts), (e) => e.code === "triage-usage-unreadable", `read: ${label}`);
assert.throws(() => appendUsage(file, line(), opts), (e) => e.code === "triage-usage-unreadable", `append: ${label}`);
const after = lstatSync(file);
assert.deepEqual([after.size, after.mode, after.ino], [before.size, before.mode, before.ino], `untouched: ${label}`);
}
// The dangling link's target is not made.
const { file } = unsafe((f) => { symlinkSync(join(f, "..", "absent.jsonl"), f); });
try { appendUsage(file, line()); } catch {}
assert.throws(() => lstatSync(join(file, "..", "absent.jsonl")), (e) => e.code === "ENOENT");
});
test("a usage file over the size bound refuses before it is parsed", () => {
const file = fileIn();
appendUsage(file, line());
appendUsage(file, line({ turn: "owner-0123456789ac" }));
const size = lstatSync(file).size;
assert.equal(readUsage(file, { maxBytes: size }).records.length, 2);
assert.throws(() => readUsage(file, { maxBytes: size - 1 }), (e) => e.code === "triage-usage-unreadable");
});
test("no file reads as no turns; good lines read back as records for the triage account", () => {
const file = fileIn();
assert.deepEqual(readUsage(file), { records: [], bad: [] });
appendUsage(file, line());
appendUsage(file, unknownLine({ turn: "owner-0123456789ac" }));
const { records, bad } = readUsage(file);
assert.deepEqual(bad, []);
assert.deepEqual(records, [{ account: "triage", ...line() }, { account: "triage", ...unknownLine({ turn: "owner-0123456789ac" }) }]);
});
test("a torn last line is refused and counts as one unknown turn; a wrong-shaped line the same", () => {
const file = fileIn();
appendUsage(file, line());
writeFileSync(file, '{"at":"2026-11-18T13:00:00.000Z","run":"triage-2026', { flag: "a" });
const torn = readUsage(file);
assert.equal(torn.records.length, 2);
assert.deepEqual(torn.bad.map((b) => b.line), [2]);
const [, b] = torn.records;
assert.deepEqual([b.status, b.run, b.turn, b.input, b.output, b.cacheRead, b.cacheWrite], ["unknown", null, "line-2", null, null, null, null]);
assert.ok(!Number.isNaN(Date.parse(b.at)), "a torn last line takes the file's change time");
const [r] = report({ limits: limitsFor(cap()), records: torn.records, now: "2026-11-18T23:00:00.000Z" });
assert.deepEqual([r.count, r.unknownTurns], [18, 1]);
// Closed off by the next append, it stays one unknown turn, dated by the line after it.
appendUsage(file, line({ at: "2026-11-18T14:00:00.000Z", turn: "owner-0123456789ac", input: 1, output: 0, cacheRead: 0, cacheWrite: 0 }));
writeFileSync(file, JSON.stringify({ ...line(), input: "9" }) + "\n", { flag: "a" });
const later = readUsage(file);
assert.deepEqual(later.bad.map((x) => x.line), [2, 4]);
assert.equal(later.records[1].at, "2026-11-18T14:00:00.000Z");
const [again] = report({ limits: limitsFor(cap()), records: later.records, now: "2026-11-18T23:00:00.000Z" });
assert.deepEqual([again.count, again.unknownTurns], [19, 2]);
});
test("the limits copy the organization shape: one daily leaf for the triage account", () => {
assert.deepEqual(limitsFor(cap()), { tokens: { daily: { triage: cap() } } });
const records = [{ account: "triage", ...line({ input: 100, output: 0, cacheRead: 0, cacheWrite: 0 }) }];
assert.deepEqual(mayLaunch({ limits: limitsFor(cap()), subject: { account: "triage" }, records, now: "2026-11-18T13:00:00.000Z" }).allow, false);
});
test("the cap state: under, at and over the cap, unknown turns adding nothing, and the cap's since", () => {
const now = ms("2026-11-18T18:00:00.000Z");
const recs = (...counts) => counts.map((n, i) => ({ account: "triage", ...line({ turn: `owner-00000000000${i}`, input: n, output: 0, cacheRead: 0, cacheWrite: 0 }) }));
const under = capState({ cap: cap(), records: recs(40, 59), now });
assert.equal(under.allow, true);
assert.deepEqual(under.usageToday, { count: 99, input: 99, output: 0, cacheRead: 0, cacheWrite: 0, unknownTurns: 0 });
assert.equal(under.resetsAt, "2026-11-19T00:00:00.000Z");
const at = capState({ cap: cap(), records: recs(40, 60), now });
assert.equal(at.allow, false);
assert.equal(at.usageToday.count, 100);
const withUnknown = capState({ cap: cap(), records: [...recs(40), { account: "triage", ...unknownLine({ turn: "owner-00000000000f" }) }], now });
assert.deepEqual([withUnknown.allow, withUnknown.usageToday.count, withUnknown.usageToday.unknownTurns], [true, 40, 1]);
// Lines before the cap's since or before today's reset do not count.
const old = [{ account: "triage", ...line({ at: "2026-11-17T23:59:59.999Z", input: 500, output: 0, cacheRead: 0, cacheWrite: 0 }) }];
assert.equal(capState({ cap: cap(), records: old, now }).usageToday.count, 0);
const since = [{ account: "triage", ...line({ at: "2026-11-18T10:00:00.000Z", input: 500, output: 0, cacheRead: 0, cacheWrite: 0 }) }];
assert.equal(capState({ cap: cap({ since: "2026-11-18T11:00:00.000Z" }), records: since, now }).allow, true);
// A cap of 0 takes no turn, as the plugin's own rule says.
assert.equal(capState({ cap: cap({ limit: 0 }), records: [], now }).allow, false);
});
test("the reset is 00:00 in the stored zone: the next one is the time shown and the day turns over there", () => {
const z = (timeZone) => cap({ timeZone });
assert.equal(new Date(nextReset(z("UTC"), ms("2026-11-18T18:00:00.000Z"))).toISOString(), "2026-11-19T00:00:00.000Z");
assert.equal(new Date(nextReset(z("UTC"), ms("2026-11-18T00:00:00.000Z"))).toISOString(), "2026-11-19T00:00:00.000Z", "at the reset, the next is a day on");
assert.equal(new Date(nextReset(z("UTC"), ms("2026-11-18T23:59:59.999Z"))).toISOString(), "2026-11-19T00:00:00.000Z");
assert.equal(new Date(nextReset(z("Asia/Kolkata"), ms("2026-11-18T18:00:00.000Z"))).toISOString(), "2026-11-18T18:30:00.000Z");
// A since after now: the reset after it.
assert.equal(new Date(nextReset(cap({ since: "2026-11-19T06:00:00.000Z" }), ms("2026-11-18T18:00:00.000Z"))).toISOString(), "2026-11-20T00:00:00.000Z");
});
test("a DST day: America/Chicago falls back on 2026-11-01 (25 hours) and springs forward on 2026-03-08 (23 hours)", () => {
const chicago = cap({ timeZone: "America/Chicago", since: "2026-01-01T00:00:00.000Z", limit: 50 });
// Fall back: the day runs from 05:00Z (00:00 CDT) to 06:00Z next day (00:00 CST).
assert.equal(new Date(nextReset(chicago, ms("2026-11-01T12:00:00.000Z"))).toISOString(), "2026-11-02T06:00:00.000Z");
assert.equal(new Date(nextReset(chicago, ms("2026-11-01T05:30:00.000Z"))).toISOString(), "2026-11-02T06:00:00.000Z", "inside the repeated hour's day");
const fall = [
{ account: "triage", ...line({ at: "2026-11-01T04:59:59.999Z", turn: "owner-000000000001", input: 30, output: 0, cacheRead: 0, cacheWrite: 0 }) },
{ account: "triage", ...line({ at: "2026-11-01T05:00:00.000Z", turn: "owner-000000000002", input: 30, output: 0, cacheRead: 0, cacheWrite: 0 }) },
{ account: "triage", ...line({ at: "2026-11-02T05:30:00.000Z", turn: "owner-000000000003", input: 30, output: 0, cacheRead: 0, cacheWrite: 0 }) },
];
const lateFall = capState({ cap: chicago, records: fall, now: ms("2026-11-02T05:59:59.999Z") });
assert.deepEqual([lateFall.allow, lateFall.usageToday.count, lateFall.resetsAt], [false, 60, "2026-11-02T06:00:00.000Z"], "the 25th hour still counts the day");
const nextDay = capState({ cap: chicago, records: fall, now: ms("2026-11-02T06:00:00.000Z") });
assert.deepEqual([nextDay.allow, nextDay.usageToday.count, nextDay.resetsAt], [true, 0, "2026-11-03T06:00:00.000Z"]);
// Spring forward: the day runs from 06:00Z (00:00 CST) to 05:00Z next day (00:00 CDT).
assert.equal(new Date(nextReset(chicago, ms("2026-03-08T12:00:00.000Z"))).toISOString(), "2026-03-09T05:00:00.000Z");
const spring = [{ account: "triage", ...line({ at: "2026-03-08T06:00:00.000Z", input: 60, output: 0, cacheRead: 0, cacheWrite: 0 }) }];
assert.equal(capState({ cap: chicago, records: spring, now: ms("2026-03-09T04:59:59.999Z") }).allow, false);
assert.equal(capState({ cap: chicago, records: spring, now: ms("2026-03-09T05:00:00.000Z") }).allow, true);
});
test("the turn delta keeps the bus's rules: new entries summed, a rewritten or missing baseline unknown, no new usage unknown", () => {
const e = (input) => ({ input, output: 1, cacheWrite: 0, cacheRead: 0 });
const begin = snapshot({ status: "known", entries: { a: e(5) } });
assert.deepEqual(delta(begin, snapshot({ status: "known", entries: { a: e(5), b: e(7), c: e(1) } })), { status: "known", input: 8, output: 2, cacheWrite: 0, cacheRead: 0 });
assert.deepEqual(delta(begin, snapshot({ status: "known", entries: { a: e(5) } })), { status: "unknown", code: "no-new-usage" });
assert.deepEqual(delta(begin, snapshot({ status: "known", entries: { a: e(6), b: e(1) } })), { status: "unknown", code: "transcript-rewritten" });
assert.deepEqual(delta(begin, snapshot({ status: "known", entries: { b: e(1) } })), { status: "unknown", code: "transcript-rewritten" });
assert.deepEqual(delta(null, snapshot({ status: "known", entries: { b: e(1) } })), { status: "unknown", code: "baseline-unknown" });
assert.deepEqual(delta(snapshot({ status: "unknown", code: "transcript-size" }), snapshot({ status: "known", entries: {} })), { status: "unknown", code: "baseline-unknown" });
assert.deepEqual(delta(begin, snapshot({ status: "unknown", code: "transcript-parse" })), { status: "unknown", code: "transcript-parse" });
assert.deepEqual(snapshot({ status: "unknown", code: "anything" }), { status: "unknown", code: "source-unknown" });
assert.deepEqual(snapshot({ status: "known", entries: { a: { input: -1, output: 0, cacheWrite: 0, cacheRead: 0 } } }), { status: "unknown", code: "source-invalid" });
assert.deepEqual(snapshot({ status: "known", entries: { a: { ...e(1), extra: 0 } } }), { status: "unknown", code: "source-invalid" });
assert.deepEqual(snapshot(null), { status: "unknown", code: "source-invalid" });
const big = { status: "known", entries: { a: e(Number.MAX_SAFE_INTEGER), b: e(1) } };
assert.deepEqual(delta(snapshot({ status: "known", entries: {} }), snapshot(big)), { status: "unknown", code: "usage-overflow" });
});
File diff suppressed because it is too large. Load diff
@@ -56,7 +56,7 @@ function workspaceOrgs({ failThreads = false, seen = null, send = false, copies
}
// No bus or setup work runs in these tests: every restart below is refused before the admin is used.
const refusingAdmin = () => createOrgAdmin({ service: {}, context: async () => ({ configDir: '/cfg', dataRoot: '/data', instance: 'test' }) });
const SETTINGS = ['Identity', 'Appearance', 'Projects', 'Agents and roles', 'Models and routing', 'Arbiters', 'Task tracker', 'Channels', 'Launch limits', 'Assistant', 'Token use', 'Model proxy', 'Console', 'Organizations', 'About', 'Members and invites', 'Bus', 'Archive or delete'];
const SETTINGS = ['Identity', 'Appearance', 'Projects', 'Agents and roles', 'Models and routing', 'Arbiters', 'Task tracker', 'Channels', 'Launch limits', 'Assistant', 'Token use', 'Model setup', 'Console', 'Organizations', 'About', 'Members and invites', 'Bus', 'Archive or delete'];
const TAGS = ['org file', 'override', 'system', 'root', 'not built', 'danger'];
// Every page the Settings view has for the owner (bus.js settingsPages).
const SETTINGS_PAGES = ['appearance', 'business', 'limits', 'organizations', 'routing', 'agents', 'assistant', 'tokens', 'model-proxy', 'console', 'about'];
@@ -302,8 +302,9 @@ test('keyboard focus follows visual order and survives a data refresh', async t
await b.navigate(`http://127.0.0.1:${server.address().port}/#/orgs/ddigital/organization`);
await wait('document.querySelectorAll("[data-org-dashboard] .ws-doc").length > 0 && document.querySelectorAll("#workspace-nav .ws-proj").length === 3');
const wide = await tabStops(b, 'document.querySelector("#sections a")');
// The left column holds the sessions and, below them, the Workflows card (SP16); the right holds Settings.
const regions = ['nav', 'head', 'Sessions and workflows', 'Settings'];
// The left column holds the sessions and, below them, the Workflows card (SP16), then Autonomy and Starter
// packs (SP18); the right holds Settings.
const regions = ['nav', 'head', 'Sessions, workflows, autonomy and starter packs', 'Settings'];
assert.deepEqual([...new Set(wide.map(s => s.region))].filter(r => r !== 'other'), regions);
assertVisualOrder(wide.filter(s => s.region !== 'other'), regions, '1440');
const keys = wide.map(s => s.key);
@@ -312,6 +312,9 @@ test('a stopped organization is not read: the page and card say the bus is stopp
await wait(`document.querySelector('[data-org-dashboard] [data-wfg-card][data-bus-stopped]')`, 'stopped card');
assert.match(await b.evaluate(`document.querySelector('[data-wfg-card]').textContent`), /Not read: the bus is stopped\./);
assert.equal(await b.evaluate(`document.querySelector('[data-wfg-card] [data-wfg-none]')`), null);
// SP18: the card is the page's one Workflows block; the old stopped panel under it said the same thing twice.
assert.equal(await b.evaluate(`[...document.querySelectorAll('[data-org-dashboard] h2, [data-org-dashboard] h3')].filter(h => h.textContent.trim() === 'Workflows').length`), 1, 'one Workflows heading on a stopped organization page');
assert.equal(await b.evaluate(`document.querySelector('[data-workflows]')`), null);
assert.equal(reads.filter(id => id === 'gamma').length, 0, 'a stopped organization is not read');
});
Loaded 100 of 104 files, more files were not shown because too many files have changed in this diff. Show more