@runuai/host 0.8.0 → 0.8.2

package/lib/codex-auth.ts

@@ -0,0 +1,155 @@
+/**
+ * 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 —
+ * the refresh token gets revoked (a login elsewhere) and `codex login` rewrites
+ * `~/.codex/auth.json` — already-running containers keep their stale copy, so a
+ * re-login otherwise only helps NEW tasks. This re-copies the fresh `~/.codex`
+ * into the running task containers so live tasks self-heal.
+ *
+ * Two triggers, covering both re-login paths:
+ *   - {@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).
+ *
+ * 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, watch } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { isNull } from "drizzle-orm";
+
+import { getDb, schema } from "./db";
+import { dockerCli } from "./docker-exec";
+
+/** 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;
+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; stderr: string }>;
+  runningContainers?: () => string[];
+  fileExists?: (path: string) => boolean;
+}
+
+function ownerCodexDir(): string {
+  return join(process.env.UAI_OWNER_HOME?.trim() || homedir(), ".codex");
+}
+
+const defaultExec: NonNullable<CodexDeps["exec"]> = async (args) => {
+  const res = await dockerCli(args, { timeoutMs: EXEC_TIMEOUT_MS });
+  return { status: res.status, stderr: res.stderr };
+};
+
+function defaultRunningContainers(): string[] {
+  return getDb()
+    .select({ taskId: schema.hostTasks.taskId })
+    .from(schema.hostTasks)
+    .where(isNull(schema.hostTasks.endedAt))
+    .all()
+    .map((r) => `task-${r.taskId}-app-1`);
+}
+
+/**
+ * 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. Best
+ * effort; a stopped/removed container makes the exec fail and is caught by the
+ * caller.
+ */
+async function copyCodexInto(container: string, deps: CodexDeps): Promise<void> {
+  const exec = deps.exec ?? defaultExec;
+  const exists = deps.fileExists ?? existsSync;
+  const dir = ownerCodexDir();
+  await exec(["exec", "-u", "root", container, "mkdir", "-p", "/home/node/.codex"]);
+  for (const item of CODEX_ITEMS) {
+    const src = join(dir, item);
+    if (!exists(src)) continue;
+    await exec(["cp", src, `${container}:/home/node/.codex/`]);
+  }
+  await exec([
+    "exec",
+    "-u",
+    "root",
+    container,
+    "chown",
+    "-R",
+    "node:node",
+    "/home/node/.codex",
+  ]);
+}
+
+/**
+ * Re-copy the freshly (re)logged-in `~/.codex` into every running task
+ * container on this host. No-op when there is no `~/.codex/auth.json` (nothing
+ * to inject) or no running tasks. Best-effort per container.
+ */
+export async function reinjectCodexRunningTasks(deps: CodexDeps = {}): Promise<void> {
+  const exists = deps.fileExists ?? existsSync;
+  if (!exists(join(ownerCodexDir(), "auth.json"))) return;
+  const containers = (deps.runningContainers ?? defaultRunningContainers)();
+  if (containers.length === 0) return;
+  console.log(`[codex] re-copying ~/.codex into ${containers.length} running task(s)`);
+  for (const container of containers) {
+    try {
+      await copyCodexInto(container, deps);
+    } catch (err) {
+      console.warn(
+        `[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(): 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(() => 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;
+  }
+}

package/lib/github-tokens.ts

@@ -56,6 +56,11 @@ export function onConnectSet(frame: GhConnectSet): { ok: boolean; error?: string
       .onConflictDoUpdate({ target: schema.githubTokens.userId, set: fields })
       .run();
     notifyGithubChange();
+    // A reconnect must reach ALREADY-RUNNING containers, not just new tasks:
+    // each container's gh config is written once, at task setup, so a fresh
+    // grant otherwise sits unused until /retry-gh. Re-inject into the user's
+    // live tasks now. Fire-and-forget — never blocks the token store.
+    reinjectRunningTasks(frame.userId);
     return { ok: true };
   } catch (err) {
     return { ok: false, error: err instanceof Error ? err.message : "store failed" };
@@ -170,6 +175,20 @@ function activeTaskIdsForUser(userId: string): string[] {
     .map((r) => r.taskId);
 }
 
+/**
+ * Re-mint + inject a (re)connected token into the user's live tasks — so a
+ * reconnect on Account applies to running containers, not only new tasks. Clear
+ * any armed retry chain first (a fresh grant must not be swallowed by an outage
+ * backoff, and `setupTaskGithub`'s duplicate-chain guard would no-op it) then
+ * run setup fresh. Fire-and-forget per task; best-effort by construction.
+ */
+export function reinjectRunningTasks(userId: string): void {
+  for (const taskId of activeTaskIdsForUser(userId)) {
+    clearRefresh(taskId);
+    void setupTaskGithub(taskId, userId);
+  }
+}
+
 // --- access-token exchange --------------------------------------------------
 
 function cloudHttpBase(): string {
@@ -434,6 +453,37 @@ function isRevokedTokenError(reason: string): boolean {
   return /revoked|invalid_grant|bad_refresh/i.test(reason);
 }
 
+/**
+ * True when the failure names a genuinely bad credential — GitHub answered the
+ * validation with 401/403 ("Bad credentials"), so the token really is wrong and
+ * only a reconnect fixes it. Distinct from a 5xx blip (see below).
+ */
+function isBadCredentialError(reason: string): boolean {
+  return /validating token: HTTP 40[13]\b|Bad credentials|401 Unauthorized|403 Forbidden/i.test(
+    reason,
+  );
+}
+
+/**
+ * True when the failure is a GitHub-side / network blip that a retry will heal
+ * — the API returned 5xx (as happens when `gh auth login` validates the token
+ * against api.github.com during an outage), a rate-limit, or the fetch itself
+ * failed. Such a failure must NOT be surfaced as "authentication expired —
+ * reconnect": the token is fine, GitHub is briefly unavailable. A genuine bad
+ * credential (401/403) is explicitly excluded so it still routes to reconnect.
+ */
+export function isTransientGithubError(reason: string): boolean {
+  if (isBadCredentialError(reason)) return false;
+  return (
+    /HTTP 5\d\d|Service Unavailable|Bad Gateway|Gateway Time-?out|server error|rate limit|too many requests|secondary rate|unavailable|unreachable/i.test(
+      reason,
+    ) ||
+    /\bfetch failed\b|timeout|timed out|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ECONNABORTED|ENOTFOUND|EAI_AGAIN|socket hang up|\bnetwork\b/i.test(
+      reason,
+    )
+  );
+}
+
 async function runRefresh(taskId: string, userId: string): Promise<void> {
   try {
     const tok = await requestAccessToken(userId);
@@ -602,10 +652,16 @@ export async function setupTaskGithub(
       authExpiredHandler?.(taskId, userId, reason);
       return false;
     }
+    // A retry chain already armed for this task means a sibling entry point
+    // (task-up and channel-ensure both call setup) already reported this and
+    // owns recovery — don't post a duplicate note or start a competing chain.
+    // `/retry-gh` clears the chain first, so a manual retry is never swallowed.
+    if (attempt === 0 && retryTimers.has(taskId)) return false;
     // Transient: self-heal with bounded backoff. Post the chat note only on
     // the FIRST failure of a chain — each retry re-enters this catch, and six
     // "gh auth" notes for one outage is noise. Exhaustion posts its own note
-    // (in scheduleGithubRetry).
+    // (in scheduleGithubRetry). The handler classifies the reason (transient
+    // 5xx blip vs. genuine expiry) and words the note accordingly.
     if (attempt === 0) authExpiredHandler?.(taskId, userId, reason);
     scheduleGithubRetry(taskId, userId, attempt, deps);
     return false;

package/lib/orchestrator.ts

@@ -34,7 +34,7 @@ import {
 } from "./agents/types";
 import { ACTIVE_STATUSES } from "./task-status";
 import { getHostTask, upsertHostTask } from "./runtime-state";
-import { setupTaskGithub } from "./github-tokens";
+import { clearRefresh, setupTaskGithub } from "./github-tokens";
 import { setupTaskGitIdentity } from "./git-identity";
 import { dockerCli } from "./docker-exec";
 import {
@@ -571,6 +571,9 @@ class Orchestrator {
       return;
     }
     this.emitSystemNote(taskId, "gh: retrying authentication…");
+    // Cancel any armed auto-retry chain so this manual attempt runs fresh
+    // (setup's duplicate-chain guard would otherwise no-op it).
+    clearRefresh(taskId);
     const ok = await setupTaskGithub(taskId, owner);
     this.emitSystemNote(
       taskId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",

package/src/main.ts

@@ -26,11 +26,13 @@ import { getHostTask } from "../lib/runtime-state";
 import { getOrchestrator } from "../lib/orchestrator";
 import {
   connectedUserIds,
+  isTransientGithubError,
   onConnectClear,
   onConnectSet,
   onGithubChange,
   setAuthExpiredHandler,
 } from "../lib/github-tokens";
+import { reinjectCodexRunningTasks, watchCodexAuth } from "../lib/codex-auth";
 import {
   deleteKey as deleteSshKey,
   ensureKeyForUser as ensureSshKeyForUser,
@@ -135,18 +137,30 @@ interface PausableSource {
 
 console.log(`[host-agent] starting host ${hostId}`);
 migrateHostDb();
-// When a task's GitHub token can't be refreshed (revoked, disconnected,
-// expired), surface it in the task channel so the user can re-grant (ADR-027).
+// Surface a task's GitHub setup failure in its channel (ADR-027). Classify the
+// reason first: a GitHub-side 5xx / network blip (e.g. `gh auth login`
+// validating the token during a github.com outage) is transient and self-heals
+// on the bounded retry — telling the user their auth "expired" and to reconnect
+// would be wrong and alarming. Only a genuine expiry/revocation asks for a
+// reconnect. Both cases keep retrying in the background regardless.
 setAuthExpiredHandler((taskId, _userId, reason) => {
-  getOrchestrator().emitSystemNote(
-    taskId,
-    `gh authentication expired (reason: ${reason}). Reconnect GitHub on ` +
-      `Account, then run /retry-gh in this task to restore.`,
-  );
+  const note = isTransientGithubError(reason)
+    ? `GitHub is temporarily unavailable — ${reason}. Uai is retrying ` +
+      `automatically; no action needed unless this persists (then run ` +
+      `/retry-gh).`
+    : `gh authentication expired (reason: ${reason}). Reconnect GitHub on ` +
+      `Account, then run /retry-gh in this task to restore.`;
+  getOrchestrator().emitSystemNote(taskId, note);
 });
 // Best-effort: build the standard image + asdf volume if missing. Logs and
 // continues on failure (e.g. docker unavailable) so the host still boots.
 void ensureStandardImage();
+// Codex creds are docker-cp'd into containers at task-up. A re-login (revoked
+// token → `codex login`) otherwise reaches only NEW tasks — re-copy into
+// running tasks on start (covers the desktop "Connect Codex", which restarts
+// the host) and watch ~/.codex for future logins (a terminal `codex login`).
+void reinjectCodexRunningTasks();
+watchCodexAuth();
 connect();
 // Local browser UI (ADR-028) — same single process, alongside the WSS client.
 // Best-effort: a UI bind failure must not take the host service down.