@dotobokuri/fleet-console 1.50.1 → 1.52.0

package/AGENTS.md

@@ -1,11 +1,12 @@
 # Fleet Console
 
-`runtime/fleet-console` is the standalone loopback host and React product. The Console product — core plus built-ins under `../fleet-plugins/` — is the sole owner of Console HTTP, streaming, PTY/provider/plugin runtime, durable state, and browser UI.
+`runtime/fleet-console` is the sole published host for Fleet Console and the `fleet` terminal launcher. The Console product — core plus built-ins under `../fleet-plugins/` — owns Console HTTP, streaming, PTY/provider/plugin runtime, durable state, and browser UI; `cli/` owns the thin Claude Code launcher and shared auth/update commands.
 
 ## Directory index
 
 | Directory | Responsibility |
 |---|---|
+| `cli/` | Dual-entry `fleet` launcher (auth/update/console/cli passthrough) and thin Claude gateway |
 | `core/host/` | Server lifecycle, security, durable state, and core APIs |
 | `core/client/` | React application, host chrome, and browser state |
 | `desktop-protocol/` | Shared Console-Desktop protocol contract |
@@ -21,12 +22,16 @@
 - A **Theater** is any registered project root. An **Operation** is a Console-managed unit inside a Theater. A Codex workspace is the subset of a Theater or selected path that contains Fleet Wiki knowledge.
 - Console owns Theater and Operation state, window chrome, path selection, security gates, and plugin registries. Plugins own their panel bodies and plugin-scoped runtime behavior.
 - Desktop may supervise and display Console only through the public desktop protocol; it must not duplicate server, PTY, provider, plugin, state, or React behavior.
-- Host code may consume public APIs from lower-layer Fleet packages, but must not import `fleet-cli` or any package's implementation paths. Browser code remains Node-free. SDK dependencies point from host, client, and plugins into SDK, never back into core or plugin implementations.
+- Host code may consume public APIs from lower-layer Fleet packages, but must not import any package's implementation paths. Browser code remains Node-free. SDK dependencies point from host, client, and plugins into SDK, never back into core or plugin implementations.
 - Built-ins are trusted static plugins. Installing an external plugin grants same-process Node and same-origin browser privileges; external plugins are not sandboxed.
 
 ## Security and state constraints
 
-- Core browser APIs do not use bearer, admin, MCP, or session tokens. Loopback is not authorization: preserve route-specific Host and Origin gates.
+- The loopback listener's core browser APIs do not use bearer, admin, MCP, or session tokens. Loopback is not authorization: preserve route-specific Host and Origin gates.
+- A remote listener is the opposite default: every request it accepts requires a session, decided once before routing, and the only exceptions are the join endpoint and the static notice that explains an access link. Sessions are bound to the listener that issued them and never cross between loopback and remote.
+- A session is an open connection; a pairing is the standing permission behind it, and the two never collapse into one. A single-use grant from an access link creates a pairing; after that the paired device reopens a session on its own, so ending a session — by reclaiming control, by idling out, or by restarting the console — never costs that device its way back. Unpairing and a new certificate do, and so does a device that stays away longer than the cookie carrying its secret: browsers cap that lifetime well below the certificate's, so each return renews it and only a dormant device ages out. Console stores a pairing's hash, never its secret, and the device carries the secret in a cookie the console sets.
+- A link publishes an address as much as a credential, and a device keeps only what the link told it. So the remote listener remembers the port it first opened on and reopens that one, rather than following the console's own port, which is free to move on every start; it never slides to another port on its own, because a device that cannot find the address it was given is unpaired in fact while the list still says otherwise. Releasing that port belongs with the acts that already void every pairing.
+- Console owns which other consoles this one can reach, and that list is reachable only from the loopback listener — a remote session must not enumerate or edit the addresses and certificate pins of third machines. A saved host stores where to go and what certificate to trust, never a credential; a link's single-use grant lives in memory until the shell takes it, and is handed over exactly once.
 - Terminal WebSocket is the sole ticketed browser transport: an Origin-authorized HTTP route issues a short-lived one-use ticket consumed by the upgrade. Do not generalize that ticket into browser bearer authentication.
 - Provider session identities, transcripts, and raw filesystem paths may remain in sensitive server-side state but must not enter ordinary core or built-in browser DTOs, browser-visible logs, streams, or static assets.
 - Local-channel environment diagnostics invoked only by an explicit user action may return the Console's own data-root and runtime-lock paths, and the Agent CLI executable paths a user configured together with the PATH entries searched to resolve them.
@@ -37,13 +42,13 @@
 
 ## Design invariants
 
-- Every color speaks on exactly one channel: signal tokens (`aurora`/`warn`/`coral`/`positive`) carry state only, `brass` carries location/focus/hover only, and user or carrier identity uses the `--id-*` tones painted exclusively through the spine+mark+wash grammar — borders stay state-owned and identity never repaints signal surfaces.
+- Every color speaks on exactly one channel: signal tokens (`aurora`/`warn`/`coral`/`positive`) carry state only, `brass` carries location/focus/hover only, and user or agent identity uses the `--id-*` tones painted exclusively through the spine+mark+wash grammar — borders stay state-owned and identity never repaints signal surfaces.
 - Core and built-in plugin CSS consume colors only as theme tokens via `var()`/`color-mix`; chromatic raw literals live solely in `theme.css` token definitions so all three themes retune together. Near-achromatic shadow, scrim, and sheen literals that carry depth rather than hue are the sanctioned exception.
 - `tests/instrument-design-contract.test.ts` pins the design grammar: a legitimate grammar change updates the contract together with the change, and intentional exceptions are recorded as doctrine comments beside the exempted CSS rule.
 
 ## Distribution constraints
 
-- Console serves its own web build; there is no second gateway or embedded web owner.
+- Console serves its own web build and owns both published bins (`fleet`, `fleet-console`); there is no second Console web/HTTP owner. The `fleet` entry may still run an ephemeral per-process AI Gateway for Claude Code passthrough.
 - Published Console artifacts are self-contained: workspace packages are bundled and must not survive as workspace-version dependencies.
 - The published `./desktop-protocol` subpath is a compatibility surface for shipped Desktop shells under always-latest Console installs; keep its export surface unchanged.
 - Host and built-in plugin bundles may load separate copies of a module. Never coordinate across that boundary through module-scoped singleton state.

package/README.md

@@ -1,15 +1,14 @@
 # Fleet Console
 
-Standalone loopback web console for observing carrier jobs, live output streams, and plugin-owned PTY terminal workspaces.
+Standalone loopback web console for observing live output streams and plugin-owned PTY terminal workspaces.
 
 ## What It Does
 
-Fleet Console owns its own local HTTP server. The Terminal plugin owns Shell and Agent PTY runtime, tickets, launch, and WebSocket transport; carrier events are streamed to the browser through the observer API.
+Fleet Console owns its own local HTTP server. The Terminal plugin owns Shell and Agent PTY runtime, tickets, launch, and WebSocket transport; session events are streamed to the browser through the observer API.
 
 - Plugin-owned terminal sessions and observed jobs in a navigable rail.
 - Workspace hub sessions created through an in-console directory browser — no OS-native dialog.
 - Terminal plugin-spawned Agent CLI PTYs with in-process observation.
-- Per-job carrier tracks with incremental output text, reasoning folds, and tool-call activity.
 - Codex/Fleet Wiki browsing under the shared Console GNB at `/console/codex`.
 - Codex Cowork lets you open a Wiki entry in a focused AI editing session: compare its immutable current version with a live draft, give the assistant selected text or annotations as context, and Apply once when ready. Your draft and conversation survive refresh or restart, while knowledge remains unchanged until that final Apply; Cowork has no terminal or PTY access and keeps provider details, workspace paths, and credentials out of the browser.
 - Browser observer snapshots and SSE streams backed by console-owned global observed ids.
@@ -51,18 +50,21 @@ Codex/Fleet Wiki routes preserve the migrated wiki security boundary: Host allow
 ## Usage
 
 ```bash
+fleet console
+fleet console status
+fleet console stop
+
+# transitional alias
 fleet-console
-fleet-console status
-fleet-console stop
 ```
 
-The launcher ensures the local console server is running and opens `/console/` directly without browser token fragments.
+Prefer `fleet console`. The transitional `fleet-console` bin still works. The launcher ensures the local console server is running and opens `/console/` directly without browser token fragments.
 
 ## Desktop coexistence
 
 Fleet Console Desktop is a thin Electron shell around this service, not a second Console implementation. Its packaged standard Node `22.23.1` sidecar runs this package's `dist/cli.mjs serve` outside Electron's asar and loads exactly `http://127.0.0.1:<verified-port>/console/`. The service remains the owner of HTTP/REST/SSE/WebSocket, PTY, provider policy, plugin runtime, durable JSON state, and the React UI.
 
-Published stable CLI/browser and Desktop-supervised Console share one canonical stable lock and `~/.fleet/console` durable-state namespace (unless the existing `FLEET_CONSOLE_DIR` override is deliberately set). Owner metadata remains provenance/lifecycle compatibility data; it does not alter Console channel, health, update, or CLI-control behavior. Desktop can pair with an already running Console by its token-free loopback pairing identity.
+Published stable CLI/browser and Desktop-supervised Console share one canonical stable lock and `~/.fleet/console` durable-state namespace (unless the `FLEET_CONSOLE_DATA_DIR` override — formerly `FLEET_CONSOLE_DIR`, still accepted — is deliberately set). Owner metadata remains provenance/lifecycle compatibility data; it does not alter Console channel, health, update, or CLI-control behavior. Desktop can pair with an already running Console by its token-free loopback pairing identity.
 
 Updates apply in-session only to ordinary global packages through the npm-global worker. A managed `console/latest` runtime is updated by Desktop's hardened entry-flow installer on relaunch; `POST /api/v1/updates/apply` refuses unsupported install layouts rather than mutating a live managed runtime. The pairing identity endpoint is discovery, not authentication: the user's exact `127.0.0.1:port` choice is the trust decision.
 
@@ -77,6 +79,6 @@ pnpm --filter @dotobokuri/fleet-console typecheck
 pnpm --filter @dotobokuri/fleet-console build
 ```
 
-`build` emits `dist/cli.mjs`, `dist/cli-bin.mjs`, `dist/client/`, and `dist/fleet-plugins/terminal/routes.mjs`. There is no external embed step.
+`build` emits `dist/fleet.mjs`, `dist/cli.mjs`, `dist/client/`, and `dist/fleet-plugins/terminal/routes.mjs`. There is no external embed step.
 
 See `AGENTS.md` for ownership, token-boundary, and streaming invariants.

package/dist/cli.d.ts

@@ -86,6 +86,8 @@ type ConsoleHookCommand = {
     readonly command: "turn-start";
 } | {
     readonly command: "turn-end";
+} | {
+    readonly command: "background-report";
 } | {
     readonly command: "background-spawn";
 } | {
@@ -126,6 +128,7 @@ declare function assertCliCanControlDaemon(payload: ConsoleLockPayload): void;
 declare function isLockProcessAlive(pid: number): boolean;
 declare function runConsoleRestart(deps?: ConsoleRestartDeps): Promise<OpenFleetConsoleResult>;
 declare function main(): Promise<void>;
+
 declare function isCliDirectRun(argv1: string | undefined, moduleUrl?: string): boolean;
 
 export { type BuildConsoleHelpTextOptions, type ConsoleCliMode, type ConsoleDaemonLifecycleDeps, type ConsoleHookCommand, type ConsoleRestartDeps, type ConsoleStatusDeps, type ConsoleStopDeps, type OpenFleetConsoleDeps, type OpenFleetConsoleResult, assertCliCanControlDaemon, buildConsoleHelpText, createConsoleDaemonLifecycle, isCliDirectRun, isLockProcessAlive, main, openFleetConsole, parseConsoleCliMode, parseConsoleHookCommand, runConsoleRestart, runConsoleStatus, runConsoleStop };