@moondeck/station 0.0.1 → 1.0.1

package/lib/cloud-state.ts

@@ -0,0 +1,56 @@
+/**
+ * In-memory cloud (WSS bridge) connection state for the local UI (ADR-028).
+ *
+ * The bridge client in `src/main.ts` is the single writer; the local
+ * `/api/cloud` handler is a reader. Module-level singleton — there is exactly
+ * one bridge connection per host process. Never persisted.
+ */
+
+export type CloudConnectionState =
+  | "connected"
+  | "reconnecting"
+  | "disconnected";
+
+export interface CloudState {
+  state: CloudConnectionState;
+  /** Epoch ms of the last successful connect, or null if never connected. */
+  lastConnectedAt: number | null;
+  /** Count of reconnect attempts since process start. */
+  reconnectCount: number;
+  /** Most recent connection error message, or null. */
+  lastError: string | null;
+}
+
+const state: CloudState = {
+  state: "disconnected",
+  lastConnectedAt: null,
+  reconnectCount: 0,
+  lastError: null,
+};
+
+/** Snapshot for `/api/cloud`. */
+export function getCloudState(): CloudState {
+  return { ...state };
+}
+
+export function markConnected(): void {
+  state.state = "connected";
+  state.lastConnectedAt = Date.now();
+}
+
+/** The socket dropped and we will retry. Increments the reconnect counter. */
+export function markReconnecting(error?: string | null): void {
+  state.state = "reconnecting";
+  state.reconnectCount += 1;
+  if (error !== undefined) state.lastError = error;
+}
+
+/** Stopped for good (shutdown or fatal auth failure) — no retry. */
+export function markDisconnected(error?: string | null): void {
+  state.state = "disconnected";
+  if (error !== undefined) state.lastError = error;
+}
+
+export function markCloudError(message: string): void {
+  state.lastError = message;
+}

package/lib/codex-auth.ts

@@ -0,0 +1,456 @@
+/**
+ * Codex credential re-injection — the symmetric partner to the GitHub reinject
+ * in {@link ./github-tokens} (ADR-027/033 → host 0.8.1).
+ *
+ * The host owner's `~/.codex` is docker-cp'd into each task container ONCE, at
+ * task-up (`scripts/agent/task-up.sh`). When the owner re-logs into Codex,
+ * `codex login` revokes and rewrites `~/.codex/auth.json` on the HOST —
+ * already-running containers keep their stale copy, so a re-login otherwise
+ * only helps NEW tasks. The live sweep refreshes the credential-bearing copy
+ * while deliberately preserving the container's `config.toml`: browser/MCP
+ * setup owns that live file and serializes its updates with agent spawning.
+ *
+ * That revoke-then-rewrite is CLIENT-SIDE and scoped to the LOCAL codex_home —
+ * not a server-side "one session per account" policy. `codex login` calls
+ * `clear_existing_auth_before_login` (openai/codex `cli/src/login.rs`), which
+ * revokes only whatever token `revocable_token()` (`login/src/auth/revoke.rs`)
+ * finds in THIS SAME codex_home's `auth.json` via `logout_with_revoke`
+ * (`login/src/auth/manager.rs`) — it never looks at, let alone reaches, another
+ * login's session. Separate logins are independent authorization_code+PKCE
+ * grants with independent refresh lineages (source analysis corroborated by a
+ * community-verified workaround, not an empirical run — full writeup:
+ * `docs/pricing-economics.md` R8/R10).
+ *
+ * What DOES matter for concurrency: refresh rotation is single-use, and a
+ * reused refresh token comes back `refresh_token_reused` — a TERMINAL
+ * `Exhausted` failure the client never retries. This file's docker-cp pattern
+ * already gives every task container its own independent filesystem copy of
+ * ONE lineage with nothing to reconcile them, so the instant any one
+ * container's own `codex` process refreshes, every sibling copy is a stale
+ * member of a now-rotated family and its next refresh is terminal, not
+ * self-healing — containers must never refresh this credential themselves.
+ *
+ * Three triggers, covering every path:
+ *   - {@link watchCodexAuth} — fs.watch on `~/.codex`, for `codex login` run
+ *     from a terminal while the host stays up.
+ *   - {@link reinjectCodexRunningTasks} at host start — for the desktop
+ *     "Connect Codex" flow, which writes `~/.codex` then restarts the host
+ *     (durable sessions reattach to containers that still hold the old creds).
+ *     Sequenced AFTER boot recovery (main.ts awaits recoveryComplete()).
+ *   - {@link injectCodexIntoContainer} — recovery calls it right after
+ *     `docker start` of an exited container, before agents can respawn.
+ *
+ * Copies go ONLY into containers docker confirms are RUNNING. A DB-active row
+ * can be a stopped container (boot, pre-recovery), and `docker cp` into a
+ * stopped container SUCCEEDS while the `docker exec … chown` that follows
+ * cannot run — stranding auth.json/config.toml mode 0600 owned by the host
+ * uid (macOS 501:20), unreadable to the container's `node` (1000:1000), and
+ * Codex dies at startup. Every docker step's exit status is checked; failures
+ * surface as actionable errors (never credential contents — only file NAMES
+ * and docker stderr are logged).
+ *
+ * Codex auth is host-wide (the operator's single `~/.codex`, not per-user), so
+ * this targets ALL running tasks — matching task-up, which copies it into every
+ * container regardless of roster.
+ */
+import { existsSync, mkdtempSync, readFileSync, rmSync, watch, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { isNull } from "drizzle-orm";
+
+import { onOwnCredentials, whileOnOwnCredentials } from "./cloud-credential-host";
+import { getDb, schema } from "./db";
+import { dockerCli } from "./docker-exec";
+import { brokeredFilesFor } from "./token-broker";
+import {
+  listRunningTaskAppContainerNames,
+  taskAppContainerName,
+  taskContainerCli,
+} from "./task-container-cli";
+import { runtimeAuthorityDockerExecArgs } from "./runtime-authority";
+
+/** The exact set task-up.sh copies into `/home/node/.codex`. */
+const CODEX_ITEMS = [
+  "auth.json",
+  "config.toml",
+  "AGENTS.md",
+  "version.json",
+  "installation_id",
+  "rules",
+] as const;
+/** Live auth refresh must not overwrite MCP configuration in a running task. */
+const LIVE_CODEX_ITEMS = CODEX_ITEMS.filter((item) => item !== "config.toml");
+const EXEC_TIMEOUT_MS = 15_000;
+
+/** Injectable seams (defaults hit the real DB / docker / fs) so the copy logic
+ *  is testable without either. */
+export interface CodexDeps {
+  exec?: (
+    args: string[],
+  ) => Promise<{ status: number | null; stdout: string; stderr: string }>;
+  /** DB-active task containers — may include stopped ones; docker decides. */
+  activeTaskContainers?: () => string[];
+  fileExists?: (path: string) => boolean;
+  /** Reads the host's auth.json for brokering (tests inject; never the real one). */
+  readFile?: (path: string) => string;
+}
+
+function ownerCodexDir(): string {
+  return join(process.env.UAI_OWNER_HOME?.trim() || homedir(), ".codex");
+}
+
+const defaultExec: NonNullable<CodexDeps["exec"]> = async (args) => {
+  const res = await taskContainerCli(args, { timeoutMs: EXEC_TIMEOUT_MS });
+  return { status: res.status, stdout: res.stdout, stderr: res.stderr };
+};
+
+function defaultActiveTaskContainers(): string[] {
+  return getDb()
+    .select({ taskId: schema.hostTasks.taskId })
+    .from(schema.hostTasks)
+    .where(isNull(schema.hostTasks.endedAt))
+    .all()
+    .map((r) => taskAppContainerName(r.taskId));
+}
+
+/**
+ * The containers docker reports as RUNNING right now, or null when docker
+ * itself didn't answer — the caller must then skip injection rather than
+ * docker-cp into containers of unknown state.
+ */
+async function dockerRunningNames(
+  exec: NonNullable<CodexDeps["exec"]>,
+): Promise<Set<string> | null> {
+  // The list verb differs per backend (docker ps vs apple container list);
+  // the shared helper owns that translation. The injected exec seam is kept
+  // for tests, which script docker-shaped ps answers.
+  if (exec === defaultExec) {
+    const names = await listRunningTaskAppContainerNames();
+    return names === null ? null : new Set(names);
+  }
+  const res = await exec(["ps", "--filter", "status=running", "--format", "{{.Names}}"]);
+  if (res.status !== 0) return null;
+  return new Set(
+    res.stdout
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean),
+  );
+}
+
+/**
+ * Re-copy `~/.codex/<items>` into one container — mirrors task-up.sh exactly:
+ * ensure the dir (root), cp each item that exists, chown back to node:node
+ * (docker cp preserves the HOST uid/gid, and 0600 files owned by macOS
+ * 501:20 are unreadable to the container's node). Any nonzero step throws
+ * with the step name and docker's stderr — never file contents.
+ */
+async function copyCodexInto(
+  container: string,
+  deps: CodexDeps,
+  items: readonly (typeof CODEX_ITEMS)[number][] = CODEX_ITEMS,
+): Promise<void> {
+  const exec = deps.exec ?? defaultExec;
+  const exists = deps.fileExists ?? existsSync;
+  const dir = ownerCodexDir();
+  const must = async (args: string[], step: string): Promise<void> => {
+    const res = await exec(args);
+    if (res.status !== 0) {
+      const detail = res.stderr.trim().slice(0, 200);
+      throw new Error(
+        `${step} failed (${res.status === null ? "docker timeout" : `exit ${res.status}`})` +
+          (detail ? `: ${detail}` : ""),
+      );
+    }
+  };
+  await must(
+    [
+      "exec",
+      "-u",
+      "root",
+      ...runtimeAuthorityDockerExecArgs(),
+      container,
+      "/bin/mkdir",
+      "-p",
+      "/home/node/.codex",
+    ],
+    "mkdir /home/node/.codex",
+  );
+  for (const item of items) {
+    const src = join(dir, item);
+    if (!exists(src)) continue;
+    // ADR-135: the task's copy never carries the rotating refresh token — N
+    // copies racing to refresh it revoke the whole family. cp needs a real
+    // file, so write the brokered variant to a private temp file and cp that.
+    if (item === "auth.json") {
+      let brokered: string | null = null;
+      try {
+        const raw = (deps.readFile ?? ((p: string) => readFileSync(p, "utf8")))(src);
+        const out = brokeredFilesFor(
+          { kind: "codex", authKind: "config-dir", id: "default", scope: "host" },
+          { "auth.json": raw },
+        );
+        brokered = out["auth.json"] !== raw ? out["auth.json"]! : null;
+      } catch {
+        brokered = null;
+      }
+      if (brokered !== null) {
+        const tmp = join(mkdtempSync(join(tmpdir(), "uai-codex-auth-")), "auth.json");
+        writeFileSync(tmp, brokered, { mode: 0o600 });
+        try {
+          await must(["cp", tmp, `${container}:/home/node/.codex/auth.json`], "docker cp auth.json (brokered)");
+        } finally {
+          rmSync(dirname(tmp), { recursive: true, force: true });
+        }
+        continue;
+      }
+    }
+    await must(["cp", src, `${container}:/home/node/.codex/`], `docker cp ${item}`);
+  }
+  await must(
+    [
+      "exec",
+      "-u",
+      "root",
+      ...runtimeAuthorityDockerExecArgs(),
+      container,
+      "/bin/chown",
+      "-R",
+      "node:node",
+      "/home/node/.codex",
+    ],
+    "chown -R node:node /home/node/.codex",
+  );
+}
+
+/**
+ * Inject the owner's `~/.codex` into ONE container known to be running.
+ * Recovery calls this immediately after `docker start`, BEFORE uai-init and
+ * any agent respawn, so a recovered container never runs Codex against
+ * host-uid-owned credentials. Returns false after logging an actionable
+ * error (no secrets) — recovery of the task itself must not fail over Codex.
+ */
+export async function injectCodexIntoContainer(
+  container: string,
+  deps: CodexDeps = {},
+): Promise<boolean> {
+  const exists = deps.fileExists ?? existsSync;
+  if (!exists(join(ownerCodexDir(), "auth.json"))) return true; // nothing to inject
+  try {
+    // ADR-154: no default slot once the runner begins leaving its own
+    // credentials; leaving waits for a copy under way.
+    await whileOnOwnCredentials(() => copyCodexInto(container, deps));
+    return true;
+  } catch (err) {
+    console.error(
+      `[codex] inject into ${container}: ${err instanceof Error ? err.message : err} — ` +
+        `Codex in this task will fail until fixed (run: docker exec -u root ${container} ` +
+        `chown -R node:node /home/node/.codex, or restart the host)`,
+    );
+    return false;
+  }
+}
+
+/**
+ * ADR-121: deliver the DEFAULT Codex slot into a MACHINE task over the
+ * environment transport. The legacy paths (task-up docker cp, recovery
+ * inject, the reinject sweep) all speak docker grammar, so a machine task's
+ * codex agent ran without auth.json and looped 'Reconnecting' (live
+ * 2026-08-27, first EC2 task). Files land as the ssh user (node), so no
+ * chown pass is needed. Returns true when there was nothing to inject.
+ */
+export async function injectCodexIntoMachine(
+  environment: {
+    exec(request: {
+      argv: readonly [string, ...string[]];
+      projectEnvProfile: "maintenance" | "task";
+      timeoutMs: number;
+      maxOutputBytes: number;
+    }): Promise<{ exitCode: number | null; stderr: Uint8Array }>;
+    copy(request: {
+      direction: "into";
+      source: string;
+      destination: string;
+    }): Promise<void>;
+  },
+  deps: CodexDeps = {},
+): Promise<boolean> {
+  // ADR-154: no default slot once the runner begins leaving its own
+  // credentials (a start on them holds its permit through this).
+  if (!onOwnCredentials()) return true;
+  const exists = deps.fileExists ?? existsSync;
+  const dir = ownerCodexDir();
+  if (!exists(join(dir, "auth.json"))) return true; // nothing to inject
+  try {
+    const made = await environment.exec({
+      projectEnvProfile: "maintenance",
+      argv: ["/bin/mkdir", "-p", "/home/node/.codex"],
+      timeoutMs: EXEC_TIMEOUT_MS,
+      maxOutputBytes: 64 * 1024,
+    });
+    if (made.exitCode !== 0) {
+      throw new Error(
+        `mkdir /home/node/.codex exited ${made.exitCode}: ${Buffer.from(made.stderr).toString("utf8").trim()}`,
+      );
+    }
+    for (const item of CODEX_ITEMS) {
+      const source = join(dir, item);
+      if (!exists(source)) continue;
+      await environment.copy({
+        direction: "into",
+        source,
+        destination: `/home/node/.codex/${item}`,
+      });
+    }
+    return true;
+  } catch (err) {
+    console.error(
+      `[codex] machine inject: ${err instanceof Error ? err.message : err} — Codex in this task will fail until the next ensure retries`,
+    );
+    return false;
+  }
+}
+
+/**
+ * Refresh the freshly (re)logged-in Codex files in every task container that
+ * is both DB-active AND confirmed running by docker. `config.toml` is excluded:
+ * copying the host's file over a live task races the orchestrator's managed MCP
+ * writer and can erase the browser definition after readiness was established.
+ * Recovery/start injection still uses the full item set above, before agents
+ * can spawn. No-op when there is no `~/.codex/auth.json` or no active tasks;
+ * skipped entirely (with a warning) when docker doesn't answer. Per-container
+ * failures are surfaced and don't stop the sweep.
+ */
+export async function reinjectCodexRunningTasks(deps: CodexDeps = {}): Promise<void> {
+  // ADR-154: no default slot once the runner begins leaving its own
+  // credentials. Leaving waits for a sweep under way, and no copy starts
+  // after it began.
+  await whileOnOwnCredentials(() => reinjectOwnCodex(deps));
+}
+
+async function reinjectOwnCodex(deps: CodexDeps): Promise<void> {
+  const exists = deps.fileExists ?? existsSync;
+  if (!exists(join(ownerCodexDir(), "auth.json"))) return;
+  const active = (deps.activeTaskContainers ?? defaultActiveTaskContainers)();
+  if (active.length === 0) return;
+  const running = await dockerRunningNames(deps.exec ?? defaultExec);
+  if (running === null) {
+    console.warn(
+      "[codex] reinject skipped — docker didn't answer `docker ps`; will retry on the next trigger",
+    );
+    return;
+  }
+  const targets = active.filter((c) => running.has(c));
+  const stopped = active.length - targets.length;
+  if (stopped > 0) {
+    console.log(
+      `[codex] ${stopped} active task(s) not running — skipped (recovery injects them at docker start)`,
+    );
+  }
+  if (targets.length === 0) return;
+  console.log(`[codex] refreshing auth in ${targets.length} running task(s)`);
+  for (const container of targets) {
+    if (!onOwnCredentials()) return;
+    try {
+      await copyCodexInto(container, deps, LIVE_CODEX_ITEMS);
+    } catch (err) {
+      console.error(
+        `[codex] reinject into ${container} failed: ${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
+}
+
+let watcher: ReturnType<typeof watch> | null = null;
+let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+
+/**
+ * Watch `~/.codex` for `auth.json` changes (a re-login) and re-inject into
+ * running tasks, debounced (a login writes several files). Idempotent; a
+ * missing `~/.codex` dir is a no-op — the host-start reinject already handles
+ * a first login that flips Codex available. UAI_CODEX_REINJECT=0 disables it.
+ */
+export function watchCodexAuth(canReinject: () => boolean = () => true): void {
+  if (watcher || process.env.UAI_CODEX_REINJECT === "0") return;
+  const dir = ownerCodexDir();
+  if (!existsSync(dir)) return;
+  try {
+    watcher = watch(dir, (_event, filename) => {
+      // filename is null on some platforms — then we can't tell, so proceed.
+      if (filename && filename !== "auth.json") return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        if (canReinject()) void reinjectCodexRunningTasks();
+      }, 2_000);
+      debounceTimer.unref?.();
+    });
+  } catch (err) {
+    console.warn(
+      `[codex] could not watch ${dir}: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}
+
+/** Test/teardown hook. */
+export function stopWatchingCodexAuth(): void {
+  watcher?.close();
+  watcher = null;
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+}
+
+/**
+ * ADR-135: re-push the host's default Grok sign-in (`~/.grok/auth.json`,
+ * brokered) into every running task, after the owned-host loop refreshed it.
+ * Same sweep shape as the Codex reinject; only auth.json travels.
+ */
+export async function reinjectGrokRunningTasks(deps: CodexDeps = {}): Promise<void> {
+  // ADR-154: as for Codex, only while the runner is on its own credentials.
+  await whileOnOwnCredentials(() => reinjectOwnGrok(deps));
+}
+
+async function reinjectOwnGrok(deps: CodexDeps): Promise<void> {
+  const exists = deps.fileExists ?? existsSync;
+  const src = join(process.env.UAI_OWNER_HOME?.trim() || homedir(), ".grok", "auth.json");
+  if (!exists(src)) return;
+  const active = (deps.activeTaskContainers ?? defaultActiveTaskContainers)();
+  if (active.length === 0) return;
+  const running = await dockerRunningNames(deps.exec ?? defaultExec);
+  if (running === null) return;
+  const exec = deps.exec ?? defaultExec;
+  let brokered: string;
+  try {
+    const raw = readFileSync(src, "utf8");
+    brokered = brokeredFilesFor(
+      { kind: "grok", authKind: "config-dir", id: "default", scope: "host" },
+      { "auth.json": raw },
+    )["auth.json"]!;
+  } catch {
+    return;
+  }
+  const dir = mkdtempSync(join(tmpdir(), "uai-grok-auth-"));
+  const tmp = join(dir, "auth.json");
+  try {
+    writeFileSync(tmp, brokered, { mode: 0o600 });
+    for (const container of active.filter((c) => running.has(c))) {
+      if (!onOwnCredentials()) break;
+      const steps: Array<[string[], string]> = [
+        [["exec", "-u", "root", ...runtimeAuthorityDockerExecArgs(), container, "/bin/mkdir", "-p", "/home/node/.grok"], "mkdir"],
+        [["cp", tmp, `${container}:/home/node/.grok/auth.json`], "docker cp auth.json (brokered)"],
+        [["exec", "-u", "root", ...runtimeAuthorityDockerExecArgs(), container, "/bin/chown", "-R", "node:node", "/home/node/.grok"], "chown"],
+      ];
+      for (const [args, step] of steps) {
+        const res = await exec(args);
+        if (res.status !== 0) {
+          console.error(`[grok] reinject into ${container}: ${step} failed (exit ${res.status ?? "none"})`);
+          break;
+        }
+      }
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}