grokbox 0.0.1 → 0.1.0-alpha.0

package/package.json

@@ -1,34 +1,67 @@
 {
   "name": "grokbox",
-  "version": "0.0.1",
-  "description": "Unofficial local CLI for inspecting and messaging a running Grok Bot host",
+  "version": "0.1.0-alpha.0",
+  "packageManager": "bun@1.3.14",
+  "description": "Unofficial CLI and control plane for Grok Bot cloud computers",
+  "license": "MIT",
+  "author": "grokbox contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yoyooyooo/grokbox.git"
+  },
+  "homepage": "https://github.com/yoyooyooo/grokbox#readme",
+  "bugs": {
+    "url": "https://github.com/yoyooyooo/grokbox/issues"
+  },
   "type": "module",
   "bin": {
-    "grok-bot": "bin/grok-bot"
+    "grokbox": "bin/grokbox",
+    "gbox": "bin/grokbox"
   },
   "files": [
     "bin",
+    "dist",
     "skills",
-    "src"
+    "LICENSE",
+    "THIRD_PARTY_NOTICES"
   ],
   "keywords": [
+    "grokbox",
     "grok-bot",
     "cli",
     "agents",
+    "cloud-computer",
     "automation"
   ],
   "engines": {
-    "bun": ">=1.3.0"
+    "node": ">=20.0.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
-    "grok-bot": "bun src/index.ts",
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node20 --format=esm --banner:js=\"import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);\" --outfile=dist/index.js",
+    "grokbox": "bun run src/index.ts",
+    "gbox": "bun run src/index.ts",
+    "shim:install": "bun run scripts/install-local-shim.mjs",
+    "shim:verify": "bun test test/local-shim.test.ts",
+    "prepack": "bun run build",
     "test": "bun test",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "verify:package": "bun test test/packaging.test.ts",
+    "release:check": "bun run typecheck && bun test && bun run verify:package",
+    "verify:external": "node scripts/verify-external.mjs",
+    "observe:sandbox": "node scripts/observe-sandbox.mjs",
+    "experiment:sandbox-ssh-activity": "node scripts/experiment-sandbox-ssh-activity.mjs",
+    "monitor:sandbox-ssh-activity": "node scripts/monitor-sandbox-ssh-activity.mjs"
   },
-  "dependencies": {
-    "commander": "^14.0.0"
+  "dependencies": {},
+  "devDependencies": {
+    "commander": "^14.0.0",
+    "@types/bun": "^1.2.21",
+    "@types/node": "^26.4.0",
+    "esbuild": "^0.28.2",
+    "typescript": "^5.9.2"
   }
 }

package/skills/core.md

@@ -1,81 +1,127 @@
-# grok-bot core
+# grokbox core
 
-Version-matched usage guide for the box-local Grok Bot CLI. Load this file from the installed
-binary (`grok-bot skills get core --full`) instead of copying command docs into an Agent skill
+Version-matched usage guide for the local/remote Grok Bot CLI and box daemon. Load this file from the installed
+binary (`grokbox skills get core --full`) instead of copying command docs into an Agent skill
 stub.
 
 ## What this CLI is
 
-`grok-bot` is an agent-first adapter, not a 151-method Gateway wrapper.
+`grokbox` is an agent-first adapter, not a raw Gateway wrapper. The published package requires Node.js 20+; both `grokbox` and `gbox` resolve to the same shim, which returns stable `runtime_unsupported` before loading the bundle on an older runtime. Bun is development tooling only.
 
 ```text
 Agent / Skill
-    -> grok-bot
-        -> /home/box/sand-data/gateway.json
-        -> loopback HTTP + Bearer (in-process only)
+    -> grokbox + selected Profile
+        -> local or remote daemon (finite Grok + governed host capabilities)
+            -> Gateway discovery + loopback HTTP
+            -> admitted named filesystem roots
+            -> executable policy + durable Jobs
+        -> direct Gateway discovery + loopback HTTP (Grok-only local compatibility fallback)
+        -> external Cursor Sandbox control plane
+            -> read-only run state
+            -> EnsureSandBox + brokered exec no-op
+        -> explicit Cursor web quota source
+            -> one fresh sanitized account-quota snapshot
+        -> daemon desktop classifier / idle prune
         -> Grok Bot host Gateway
 ```
 
-It does two jobs: read a narrow state surface, and append one Human message to a 1:1 agent or a
-product group. It does not impersonate peer delivery.
+The current source reads and manages a narrow product roster surface, appends one Human message to an ordinary agent or product group, reads explicitly admitted cloud-computer files, runs allowlisted structured processes as durable Jobs, queries an explicitly configured fresh account-quota source, and controls the optional Cursor Sandbox lifecycle from outside the box. In `auto` mode, finite Grok commands prefer the local daemon, then direct local Gateway, then a configured remote daemon. Filesystem and process/Job commands require their live daemon capabilities and never fall back to Gateway, SSH, or direct local host access.
 
 ## Start here
 
 ```bash
-grok-bot doctor
-grok-bot agents list --kind all --table
-grok-bot send --agent <id> --text "hello"
-grok-bot history tail <id> --limit 50
+grokbox init
+grokbox profile list --table
+grokbox daemon status
+grokbox doctor
+grokbox quota
+grokbox recover
+grokbox box status
+grokbox box wake
+grokbox box keepalive status
+grokbox agents list --table
+grokbox groups list --table
+grokbox send <target> --text "hello"
+grokbox history tail <target> --limit 50
+grokbox fs stat home:/artifact.txt
+grokbox fs download home:/artifact.bin ./artifact.bin
+grokbox fs write workspace:/status.txt --text "ready"
+grokbox fs upload ./artifact.bin workspace:/artifact.bin
+grokbox fs remove workspace:/obsolete.txt --yes
+grokbox exec run --cwd workspace:/ --detach -- node -e "console.log('ready')"
+grokbox jobs show <job-id>
+grokbox jobs logs <job-id> --follow
+grokbox jobs cancel <job-id>
+grokbox desktop status --table
+grokbox desktop keep add <agent>
+grokbox desktop prune run
+grokbox desktop prune enable
 ```
 
-Get `<id>` from `agents list`. Do not pass a token, URL, host, or port flag. The CLI reads
-discovery itself.
-
-## 80% paths
-
-1. **Discover** — `doctor` proves loopback mapping and `GET /health`. Health does **not** prove
-   the discovery Bearer can call authenticated commands; `checks.authenticatedCommand` stays
-   `not-probed`.
-2. **Pick a target** — `agents list` (roster) or `agents show <id>`. `agents search` searches
-   transcript text, not bot names.
-3. **Speak as Human** — `send --agent` or `send --group`. Both map to one `sendPrompt`. Success
-   means accepted, not completed. There is no `--wait`.
-4. **Watch** — `events` (NDJSON) for incremental roster/transcript; `history tail` to reconcile
-   display entries; `is running <id>` for that row's roster projection. `isRunning=false` does
-   not prove a send finished.
-5. **Memory metadata** — `memory list --agent <id>` strips `content` unless you pass `--content`.
+Targets accept an exact ID first, then an unambiguous case-insensitive name/title. The built-in
+`default` Profile works without a file; use `grokbox init` for local onboarding and
+`grokbox profile ...` for explicit selection/configuration. Remote bootstrap preserves any existing filesystem policy; add `--admit-home-read` only when the user explicitly authorizes the peer home read/download root. Use `--expect-kind agent|group` on
+`send` when the caller needs a kind guard.
+
+## Common paths
+
+1. **Discover and recover**: `doctor` performs a read-only staged check of Profile/secret source, optional Sandbox state, tailnet path, exact Serve ownership, daemon HTTP/auth/capabilities, and Gateway health. The diagnostic returns exit 0 with `data.ok: false` when it successfully describes an unhealthy target; inspect each check's stable code/action. `daemon status` is only a local daemon handshake, not a second doctor. `recover` is the explicit mutating composition and may wake the configured Sandbox, wait for Tailscale/IPv4, restore only the bootstrap-recorded mapping, and start an installed daemon through declared BatchMode SSH before rerunning doctor. `daemon ensure` is narrower and never wakes or repairs Serve; `--bootstrap` is the separately confirmed install/replace and credential-rotation transition.
+2. **Manage the roster**: `agents list/show/create/update/delete` only own non-group agents.
+   `groups list/show/create/update/delete` only own product groups. Membership is only
+   `groups members list/add/remove/set`; every member must resolve to a non-group agent and a group
+   must retain 1-6 unique members.
+3. **Search/read transcript**: `history search <query>`, `history tail <target>`, and
+   `history thread <target> --root <entry-id>` own transcript access. Object `show` commands do
+   not add transcript side projections.
+4. **Speak as Human**: `send <target>` maps to one `sendPrompt`. Success means accepted, not
+   completed. There is no `--wait`.
+5. **Watch**: `events` emits unified NDJSON from `gateway`, `job`, and `daemon` sources. Daemon cursors resume a bounded journal; direct Gateway reconnects and all unobserved intervals emit explicit gaps. `is running <target>` reads the roster projection.
+6. **Read account quota**: `quota` requires a selected Profile with `quota.source:"cursor-web"` and its independent `quota.access_token_ref`. It performs one fixed bounded HTTPS request and returns only a fresh sanitized DTO. It has no cache, fallback, Gateway/daemon route, Sandbox lifecycle effect, or App-private credential discovery. Missing quota configuration fails closed before discovery/SSH/host/App side effects even when the CLI runs inside the box. Copying an external OAuth token onto the box is not the in-box quota path. Static `profile capabilities` reports `provider-authorization-dependent`; only a successful call proves quota authority.
+7. **Memory metadata**: `memory list <agent>` strips `content` unless `--content` is explicit.
+8. **Use governed files**: `fs stat/list/read` use `root:/relative/path`; `fs download` writes a new local destination only after size and SHA-256 verification. `fs write` accepts explicit `--text` or stdin and supports `--expected-sha256`; `fs upload` uses bounded verified chunks; `fs mkdir` creates one level; `fs remove` moves content to recoverable trash and requires confirmation. `--recursive` additionally requires elevated live root policy. JSON `read` returns UTF-8 or explicit base64 and never writes arbitrary binary to stdout.
+
+9. **Run governed processes**: `exec run -- <argv...>` resolves argv[0] only as a configured executable alias, preserves all remaining arguments literally, and returns a durable Job. `--run-timeout-ms` governs process lifetime while `--timeout-ms` bounds the client wait; `--detach` returns after admission. `jobs list/show/logs/cancel` require `host.process.manage`; logs are bounded base64 NDJSON and resumable by offset. Shell is separately privileged and normally unavailable. An admitted executable runs as the daemon user and is not sandboxed by cwd.
+10. **Control Sandbox lifecycle**: `box status` reads the Cursor run state without waking it. `box wake` performs one broker Ensure plus a bounded exec no-op. `box keepalive run` is an external foreground lease loop; `box keepalive status` reads its redacted protected state. These commands require an explicit `sandbox.access_token_ref` and do not depend on daemon, SSH, Tailscale, Gateway health, or an in-box process.
+11. **Idle desktop forks**: `desktop status` classifies seated forks and prints keep/floor ids. `desktop keep add|remove` persists Chrome keep ids on the box daemon config, not the client Profile. `desktop prune run` dry-runs by default; `--yes` and the daemon tick call official `stop-window`, which deletes `chrome-profile-N`. Keep must-keep agents before `prune enable`. Never edit the seating table or kill host/Xvfb. Display 1 is always kept.
 
 Sensitive or multiline prompts should go on stdin:
 
 ```bash
-printf '%s' "$prompt" | grok-bot send --agent <id>
+printf '%s' "$prompt" | grokbox send <target>
 ```
 
-If you retry the same send, reuse `--nonce <uuid>` and the same target/prompt. Do not mint a new
-nonce after `send_delivery_unknown`.
+An explicit `--text` is authoritative even in a non-TTY runner and suppresses stdin reads. If you
+retry the same send, reuse `--nonce <uuid>` and the same target/prompt.
 
 ## Safety
 
-- No `--token`, `--gateway-url`, `--host`, `--port`. No `SAND_GATEWAY_TOKEN` env fallback.
-- HTTP has no `Origin` header. Token never belongs on argv, URL, stdout, stderr, or logs.
-- `send` is Human `sendPrompt` only. There is no peer, broadcast, raw, delete, Memory write,
-  approval, secret, or prepare-upgrade command.
-- Default stdout redacts roster `path` / `avatarDataUrl` / `lastMessagePreview` and Memory
+- Agent/group deletion is permanent and removes that object's product data. In a headless runner,
+  pass `--yes`; in a TTY, review the confirmation prompt. Resolve and inspect the object first.
+- Interrupted management writes return `operation_outcome_unknown` with an operation ID and are not replayed automatically; inspect the roster before deciding whether to retry. If create succeeded before a later settings/projection failure, the error also names the created object ID and `post-create` phase.
+- `doctor` never wakes, starts, installs, changes Tailscale, or accepts a repair option. `profile doctor`, `daemon doctor`, and `doctor --repair` are not commands. `recover` refuses unresolved required credentials, unrecorded/drifted/occupied Serve handlers, missing installed runtime, and unavailable declared SSH rather than broadening authority. It never runs `tailscale serve reset`, `tailscale up`, Funnel, ACL/tag changes, or ordinary business RPC over SSH.
+- Local daemon access is gated by its `0600` Unix socket; remote daemon access uses the selected Profile credential. Handshake returns daemon generation, capability names, named filesystem roots/operations, and Gateway generation, never physical root paths, the Gateway token, or raw discovery JSON.
+- Filesystem paths must use a handshake-advertised named root. Parent traversal, symlink escape, pseudo-filesystems, daemon/Gateway state, and known credential/session paths fail closed. `read` is bounded to 1 MiB; `download` is bounded to 64 MiB in 256 KiB chunks and refuses to overwrite an existing local destination.
+- Job metadata excludes argv, environment values, and output content. Children receive a fixed minimal environment plus allowlisted additions, never daemon `process.env`; output is bounded and binary-safe. Transport timeout or a log follower disconnect never cancels the Job. Reconcile uncertain submission with its original Job ID and lifecycle through `jobs show`.
+- Event cursors are opaque and should be persisted only for reconnect. Daemon restart/eviction and Gateway disconnect emit explicit gap events. Event payloads are channel allowlists; Memory content requires both the memory channel and `--include-memory-content`. Prompt, transcript, filesystem/process, environment, and auth content are never general event fields.
+- Sandbox and quota access tokens must use separate explicit `env:`, protected absolute `file:`, or macOS `keychain:` Profile references. A `file:` ref must be a current-user-owned regular file with no group/other permissions; symbolic links and unverifiable ownership are rejected. A quota failure never falls back to the Sandbox ref, App Gateway descriptor, private App persistence, Gateway, daemon, SSH, or wake. There is no credential-sync command. Quota output excludes account identity, raw provider body, token, Machine ID, headers, and usage events.
+- App Gateway descriptors and private App persistence are not wake credentials. Brokered exec, network, Gateway, and VNC descriptors stay inside the Sandbox adapter. The keeper never calls `sendPrompt` or creates model turns; its local success does not prove the required App-closed 24-72-hour lease experiment.
+- No `--token`, `--gateway-url`, `--host`, `--port`, or raw API route.
+- Gateway HTTP has no `Origin` header. The quota adapter is the explicit exception: it sends only the fixed provider-required `Origin: https://cursor.com` to its fixed endpoint. Tokens never belong on argv, URL, stdout, stderr, or logs.
+- Default output redacts roster `path` / `avatarDataUrl` / `lastMessagePreview` and Memory
   `content`.
-- `history` and `agents search` return private product text. Do not copy them into ordinary logs.
-- `--table` is only valid on commands that declare it (`skills list`, `doctor`, `agents list`,
-  `is running`). `--content` / `--include-memory-content` cannot combine with `--table`.
+- Transcript and Memory content are private product data; do not copy them into ordinary logs.
+- Unsupported options are absent from each leaf command and fail before any network request.
 
 ## Output
 
-Finite commands write one JSON object plus a trailing newline (except `skills get`, which is
-Markdown unless `--json`). `events` writes NDJSON. On failure, stdout is empty and stderr is one
+Finite commands write one JSON object plus a trailing newline, except `skills get`, which is
+Markdown unless `--json`. `events`, `jobs logs`, and `box keepalive run` write NDJSON. On failure, stdout is empty and stderr is one
 JSON error object. `is running` returning false is still exit 0.
 
 ## External skill stub
 
-Harness-installed skills should not copy this file. They should only say:
+Harness-installed skills should only say:
 
 ```text
-Run `grok-bot skills get core --full` before first use in this session.
+Run `grokbox skills get core --full` before first use in this session.
 ```

package/bin/grok-bot

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import "../src/index.ts";

package/src/commands/agents.ts

@@ -1,110 +0,0 @@
-import type { CliDeps } from "../deps.ts";
-import { usage } from "../errors.ts";
-import { GatewayClient, gatewayMeta } from "../gateway.ts";
-import { formatTable, writeSuccess } from "../output.ts";
-import { ioFromOpts } from "../opts.ts";
-import { compactRosterRow, detailRosterRow, projectSearchHit } from "../redaction.ts";
-import { isRecord, parseInteger } from "../util.ts";
-import { findRosterRow } from "./roster.ts";
-
-export async function runAgentsList(
-  deps: CliDeps,
-  raw: {
-    json?: boolean;
-    table?: boolean;
-    timeoutMs?: string;
-    kind?: string;
-    includeHidden?: boolean;
-  },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  const kind = raw.kind ?? "all";
-  if (kind !== "all" && kind !== "agent" && kind !== "group") {
-    throw usage("--kind must be all, agent, or group.");
-  }
-  const client = new GatewayClient(deps);
-  const { agents, discovery } = await client.listAgents(io.timeoutMs);
-  const includeHidden = Boolean(raw.includeHidden);
-  const projected = agents
-    .filter(isRecord)
-    .map(compactRosterRow)
-    .filter((row) => (includeHidden ? true : !row.isHidden))
-    .filter((row) => (kind === "all" ? true : row.kind === kind));
-  const data = { count: projected.length, agents: projected };
-  if (io.table) {
-    deps.stdout.write(
-      formatTable(
-        projected.map((row) => ({
-          id: row.id,
-          name: row.name,
-          kind: row.kind,
-          running: String(row.isRunning),
-          unread: String(row.hasUnread),
-        })),
-      ),
-    );
-    return;
-  }
-  writeSuccess(deps.stdout, data, gatewayMeta(discovery));
-}
-
-export async function runAgentsSearch(
-  deps: CliDeps,
-  query: string,
-  raw: { json?: boolean; table?: boolean; timeoutMs?: string; limit?: string },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  if (io.table) throw usage("This command does not support --table.");
-  if (query.trim().length === 0) throw usage("Search query must not be blank.");
-  const limit = parseInteger(raw.limit, { name: "--limit", min: 1, max: 100, defaultValue: 20 });
-  const client = new GatewayClient(deps);
-  const { matches, discovery } = await client.searchAgents(query, limit, io.timeoutMs);
-  writeSuccess(
-    deps.stdout,
-    { matches: matches.map(projectSearchHit) },
-    gatewayMeta(discovery),
-  );
-}
-
-export async function runAgentsShow(
-  deps: CliDeps,
-  id: string,
-  raw: { json?: boolean; table?: boolean; timeoutMs?: string; history?: string },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  if (io.table) throw usage("This command does not support --table.");
-  const history = parseInteger(raw.history, {
-    name: "--history",
-    min: 0,
-    max: 100,
-    defaultValue: 20,
-  });
-  const client = new GatewayClient(deps);
-  const { agents, discovery } = await client.listAgents(io.timeoutMs);
-  const row = findRosterRow(agents, id);
-  let historyView = {
-    sampledEntries: 0,
-    hasEarlier: false,
-    nextBeforeSeq: null as number | null,
-  };
-  let meta = gatewayMeta(discovery);
-  if (history > 0) {
-    const tail = await client.getAgentTranscriptTail({ id, limit: history }, io.timeoutMs);
-    meta = gatewayMeta(tail.discovery);
-    const payload = isRecord(tail.result) ? tail.result : {};
-    const entries = Array.isArray(payload.entries) ? payload.entries : [];
-    historyView = {
-      sampledEntries: entries.length,
-      hasEarlier: payload.nextBeforeSeq !== undefined && payload.nextBeforeSeq !== null,
-      nextBeforeSeq: typeof payload.nextBeforeSeq === "number" ? payload.nextBeforeSeq : null,
-    };
-  }
-  writeSuccess(
-    deps.stdout,
-    {
-      agent: detailRosterRow(row),
-      history: historyView,
-    },
-    meta,
-  );
-}

package/src/commands/doctor.ts

@@ -1,50 +0,0 @@
-import type { CliDeps } from "../deps.ts";
-import { GatewayClient, gatewayMeta } from "../gateway.ts";
-import { flattenRows, formatTable, writeSuccess } from "../output.ts";
-import { ioFromOpts } from "../opts.ts";
-import { asBoolean, asNumber } from "../util.ts";
-
-export async function runDoctor(
-  deps: CliDeps,
-  raw: { json?: boolean; table?: boolean; timeoutMs?: string },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  const client = new GatewayClient(deps);
-  const discovery = await client.load();
-  const { health } = await client.health(io.timeoutMs);
-  const healthPid = asNumber(health.pid, Number.NaN);
-  const healthStarted = asNumber(health.startedAt, Number.NaN);
-  const healthView: Record<string, unknown> = {
-    ok: asBoolean(health.ok),
-    pid: health.pid ?? null,
-    isBusy: asBoolean(health.isBusy),
-    activeAgentId: health.activeAgentId ?? null,
-    startedAt: health.startedAt ?? null,
-    lastBusyAtMs: health.lastBusyAtMs ?? null,
-  };
-  if ("busyOnlyAwaitingApproval" in health) {
-    healthView.busyOnlyAwaitingApproval = health.busyOnlyAwaitingApproval;
-  }
-  const data = {
-    discovery: {
-      scheme: discovery.scheme,
-      bindHost: discovery.bindHost,
-      dialHost: discovery.dialHost,
-      port: discovery.port,
-      pid: discovery.pid,
-      startedAt: discovery.startedAt,
-      tokenPresent: discovery.tokenPresent,
-    },
-    health: healthView,
-    checks: {
-      loopbackTarget: discovery.dialHost === "127.0.0.1" || discovery.dialHost === "::1" || discovery.dialHost === "[::1]",
-      generationMatches: healthPid === discovery.pid && healthStarted === discovery.startedAt,
-      authenticatedCommand: "not-probed",
-    },
-  };
-  if (io.table) {
-    deps.stdout.write(formatTable(flattenRows(data as unknown as Record<string, unknown>)));
-    return;
-  }
-  writeSuccess(deps.stdout, data, gatewayMeta(discovery));
-}

package/src/commands/events.ts

@@ -1,123 +0,0 @@
-import type { CliDeps } from "../deps.ts";
-import { CliError, usage } from "../errors.ts";
-import { GatewayClient, parseSse } from "../gateway.ts";
-import { writeJsonLine } from "../output.ts";
-import { ioFromOpts } from "../opts.ts";
-import { redactEventPayload } from "../redaction.ts";
-import { ALLOWED_EVENT_CHANNELS, DEFAULT_EVENT_CHANNELS } from "../registry.ts";
-import { asString, isRecord } from "../util.ts";
-
-const ALLOWED = new Set<string>(ALLOWED_EVENT_CHANNELS);
-
-function parseChannels(csv: string | undefined): string[] {
-  if (csv === undefined || csv.trim().length === 0) return [...DEFAULT_EVENT_CHANNELS];
-  const channels = csv
-    .split(",")
-    .map((item) => item.trim())
-    .filter((item) => item.length > 0);
-  if (channels.length === 0) throw usage("--channels must list at least one channel.");
-  for (const channel of channels) {
-    if (!ALLOWED.has(channel)) {
-      throw usage(`Channel '${channel}' is not in the v1 allowlist.`);
-    }
-  }
-  return channels;
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function runEvents(
-  deps: CliDeps,
-  raw: {
-    json?: boolean;
-    table?: boolean;
-    timeoutMs?: string;
-    channels?: string;
-    once?: boolean;
-    includeMemoryContent?: boolean;
-  },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  if (io.table) throw usage("events does not support --table.");
-  const channels = parseChannels(raw.channels);
-  const includeMemoryContent = Boolean(raw.includeMemoryContent);
-  if (includeMemoryContent && !channels.includes("memory")) {
-    throw usage("--include-memory-content requires the memory channel.");
-  }
-  const once = Boolean(raw.once);
-  const client = new GatewayClient(deps);
-  const stop = deps.signal;
-  let emitted = false;
-  let first = true;
-
-  while (!stop?.aborted) {
-    let response: Response;
-    let discoveryPid: number;
-    let discoveryStarted: number;
-    try {
-      const opened = await client.openEventStream(channels, io.timeoutMs);
-      response = opened.response;
-      discoveryPid = opened.discovery.pid;
-      discoveryStarted = opened.discovery.startedAt;
-    } catch (error) {
-      if (stop?.aborted) return;
-      if (first) throw error;
-      deps.stderr.write("grok-bot: event stream reconnect failed; retrying\n");
-      await sleep(1000);
-      continue;
-    }
-    first = false;
-    if (!response.body) {
-      throw new CliError("gateway_unreachable", "Gateway event stream had no body.");
-    }
-
-    let lastChunk = deps.now();
-    const watchdog = setInterval(() => {
-      if (deps.now() - lastChunk > deps.idleWatchdogMs) {
-        void response.body?.cancel();
-      }
-    }, 1000);
-
-    try {
-      for await (const frame of parseSse(response.body, {
-        onChunk: () => {
-          lastChunk = deps.now();
-        },
-        signal: stop,
-      })) {
-        if (stop?.aborted) return;
-        const rec = isRecord(frame) ? frame : {};
-        const channel = asString(rec.channel);
-        if (!channels.includes(channel)) continue;
-        const payload = redactEventPayload(channel, rec.payload, includeMemoryContent);
-        writeJsonLine(deps.stdout, {
-          ok: true,
-          event: { channel, payload },
-          meta: {
-            observedAtMs: deps.now(),
-            gateway: { pid: discoveryPid, startedAt: discoveryStarted },
-          },
-        });
-        emitted = true;
-        if (once) return;
-      }
-    } finally {
-      clearInterval(watchdog);
-    }
-
-    if (stop?.aborted) return;
-    if (once) break;
-    deps.stderr.write("grok-bot: event stream disconnected; rereading discovery\n");
-    try {
-      await client.listAgents(io.timeoutMs);
-    } catch {
-      // reconciliation is best-effort; do not claim the gap was empty
-    }
-  }
-
-  if (once && !emitted) {
-    throw new CliError("gateway_unreachable", "Event stream ended before the first allowed event.");
-  }
-}

package/src/commands/history.ts

@@ -1,65 +0,0 @@
-import type { CliDeps } from "../deps.ts";
-import { usage } from "../errors.ts";
-import { GatewayClient, gatewayMeta } from "../gateway.ts";
-import { writeSuccess } from "../output.ts";
-import { ioFromOpts } from "../opts.ts";
-import { isRecord, parseInteger } from "../util.ts";
-
-export async function runHistoryTail(
-  deps: CliDeps,
-  id: string,
-  raw: {
-    json?: boolean;
-    table?: boolean;
-    timeoutMs?: string;
-    limit?: string;
-    beforeSeq?: string;
-  },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  if (io.table) throw usage("This command does not support --table.");
-  if (id.length === 0) throw usage("id is required.");
-  const limit = parseInteger(raw.limit, { name: "--limit", min: 1, max: 200, defaultValue: 50 });
-  const beforeSeq =
-    raw.beforeSeq === undefined
-      ? undefined
-      : parseInteger(raw.beforeSeq, { name: "--before-seq", min: 0, max: Number.MAX_SAFE_INTEGER });
-  const client = new GatewayClient(deps);
-  const { result, discovery } = await client.getAgentTranscriptTail(
-    beforeSeq === undefined ? { id, limit } : { id, limit, beforeSeq },
-    io.timeoutMs,
-  );
-  const payload = isRecord(result) ? result : {};
-  const data: Record<string, unknown> = {
-    id,
-    entries: Array.isArray(payload.entries) ? payload.entries : [],
-  };
-  if (payload.nextBeforeSeq !== undefined && payload.nextBeforeSeq !== null) {
-    data.nextBeforeSeq = payload.nextBeforeSeq;
-  }
-  writeSuccess(deps.stdout, data, gatewayMeta(discovery));
-}
-
-export async function runHistoryThread(
-  deps: CliDeps,
-  id: string,
-  raw: { json?: boolean; table?: boolean; timeoutMs?: string; root?: string },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  if (io.table) throw usage("This command does not support --table.");
-  if (id.length === 0) throw usage("id is required.");
-  const rootId = raw.root;
-  if (!rootId) throw usage("--root is required.");
-  const client = new GatewayClient(deps);
-  const { result, discovery } = await client.getAgentThread({ id, rootId }, io.timeoutMs);
-  const payload = isRecord(result) ? result : {};
-  writeSuccess(
-    deps.stdout,
-    {
-      id,
-      rootId,
-      entries: Array.isArray(payload.entries) ? payload.entries : [],
-    },
-    gatewayMeta(discovery),
-  );
-}

package/src/commands/is.ts

@@ -1,23 +0,0 @@
-import type { CliDeps } from "../deps.ts";
-import { GatewayClient, gatewayMeta } from "../gateway.ts";
-import { flattenRows, formatTable, writeSuccess } from "../output.ts";
-import { ioFromOpts } from "../opts.ts";
-import { runningProjection } from "../redaction.ts";
-import { findRosterRow } from "./roster.ts";
-
-export async function runIsRunning(
-  deps: CliDeps,
-  id: string,
-  raw: { json?: boolean; table?: boolean; timeoutMs?: string },
-): Promise<void> {
-  const io = ioFromOpts(raw);
-  const client = new GatewayClient(deps);
-  const { agents, discovery } = await client.listAgents(io.timeoutMs);
-  const row = findRosterRow(agents, id);
-  const data = runningProjection(row, deps.now());
-  if (io.table) {
-    deps.stdout.write(formatTable(flattenRows(data as unknown as Record<string, unknown>)));
-    return;
-  }
-  writeSuccess(deps.stdout, data, gatewayMeta(discovery));
-}