@runuai/host 0.9.4 → 0.9.5

package/lib/orchestrator.ts

@@ -63,6 +63,7 @@ import {
   pickEngineAccount,
   provisionEngineAccounts,
   resolveEngineAccounts,
+  type ResolvedEngineAccount,
 } from "./engine-accounts";
 import { clearTaskGatewayAcl, setupMcpTaskConfig } from "./mcp-gateway";
 import { stopPreviewSidecars } from "./preview-sidecar";
@@ -231,6 +232,33 @@ const CLAUDE_CONFIG_MISSING_PATTERNS = [
   /\/\.claude\.json/i,
 ];
 
+// A revoked/expired Claude credential. The token is injected as an ENV var at
+// runner-spawn (passEnv CLAUDE_CODE_OAUTH_TOKEN), so a reconnect only reaches a
+// running task after its agent is RE-SPAWNED. We recognise these to trigger
+// that re-spawn (refreshAgentToken) instead of leaving a dead chat.
+const CLAUDE_AUTH_REVOKED_PATTERNS = [
+  /token (was )?(revoked|expired)/i,
+  /(revoked|expired)[^.]*\btoken/i,
+  // Any "<access|oauth|bearer> token could not be refreshed" — a refresh
+  // failure is always an auth problem, so don't pin it to "oauth".
+  /token could not be refreshed/i,
+  /authentication_error/i,
+  /invalid (api key|bearer token|access token|oauth token)/i,
+  /(please )?run `?claude (login|setup-token)`?/i,
+];
+
+/**
+ * Best-effort: does an agent error message indicate a revoked/expired Claude
+ * credential? The token is injected as an ENV var at runner spawn, so a match
+ * routes to refreshAgentToken (re-spawn) — the only way an env token changes
+ * for a running task. Heuristic by nature; the DETERMINISTIC recovery is
+ * refreshEngineAccountAgents on reconnect, which needs no message match.
+ * Exported for tests.
+ */
+export function isClaudeAuthRevoked(message: string): boolean {
+  return CLAUDE_AUTH_REVOKED_PATTERNS.some((re) => re.test(message));
+}
+
 export class Orchestrator {
   private readonly channels = new Map<string, Channel>();
   private readonly channelSpecs = new Map<string, ChannelEnsureInput>();
@@ -1686,6 +1714,13 @@ export class Orchestrator {
           break;
         }
         const isClaude = agent?.kind === "claude";
+        if (isClaude && agent && isClaudeAuthRevoked(event.message)) {
+          // Token revoked/expired: the env-injected credential only changes on
+          // a fresh runner. Re-spawn on the re-resolved account (picks up a
+          // reconnected token); bounded so a still-bad token can't loop.
+          await this.refreshAgentToken(channel, agent);
+          break;
+        }
         const configMissing = CLAUDE_CONFIG_MISSING_PATTERNS.some((re) =>
           re.test(event.message),
         );
@@ -2010,6 +2045,180 @@ export class Orchestrator {
     return true;
   }
 
+  /**
+   * Tear an agent's session down and spawn a FRESH one bound to `account`,
+   * re-delivering the in-flight prompt. Sibling primitive to rotateAccount:
+   * closing the old session stops its runner, so the replacement is a fresh
+   * spawn — the ONLY way an env-injected credential (Claude's
+   * CLAUDE_CODE_OAUTH_TOKEN, passed via `docker exec -e` at spawn) changes for
+   * a RUNNING task. Returns true when handled (bound, or the channel/task went
+   * away). Kept separate from rotateAccount so the rate-limit path is untouched.
+   */
+  private async respawnAgentOnAccount(
+    channel: Channel,
+    agentId: string,
+    agent: RosterAgent,
+    account: ResolvedEngineAccount,
+    note: string,
+  ): Promise<boolean> {
+    const task = getHostTask(channel.taskId);
+    if (!task || task.statusMirror !== "running") return false;
+
+    let replacement: AgentSession | null = null;
+    channel.spawning.add(agentId);
+    try {
+      // Delete first so the old session's final adapter event is
+      // generation-stale, while `spawning` blocks a concurrent replacement.
+      const old = channel.sessions.get(agentId);
+      channel.sessions.delete(agentId);
+      channel.browserStaleSessions.delete(agentId);
+      channel.browserPendingStaleSessions.delete(agentId);
+      if (old) {
+        try {
+          await old.close();
+        } catch {
+          /* already gone — close is idempotent for our adapters */
+        }
+      }
+      if (!this.isActiveChannel(channel)) return true;
+
+      await this.ensureBrowserSetup(
+        channel,
+        channel.roster.some((candidate) => candidate.kind === "codex"),
+        true,
+      );
+      if (!this.isActiveChannel(channel)) return true;
+      await this.ensureMcpConfig(channel);
+      if (!this.isActiveChannel(channel)) return true;
+
+      const apiUrl = apiUrlFromCloudUrl(env.UAI_CLOUD_URL);
+      const cliSecret = loadTaskCliSecret(channel.taskId);
+      const base = agentCliEnv(
+        channel.taskId,
+        agent,
+        task.ownerUserId,
+        apiUrl,
+        cliSecret,
+      );
+      channel.accountByAgent.set(agentId, account.id);
+      noteEngineAccountUsed(account.id);
+
+      replacement = await this.createAndBindStableSession(channel, agentId, {
+        taskId: channel.taskId,
+        agent,
+        containerName: channel.containerName,
+        systemPreamble: channel.preambles.get(agentId) ?? "",
+        agentEnv: { ...base, ...account.execEnv },
+      });
+      if (!replacement) return true;
+
+      this.emitSystemNote(channel.taskId, note);
+
+      // Re-deliver the in-flight prompt so the interrupted turn resumes.
+      const prompt = channel.lastPrompt.get(agentId);
+      if (prompt) {
+        this.incrementActiveTurns(channel, agentId);
+        void replacement.send(prompt).catch((err: unknown) => {
+          if (channel.sessions.get(agentId) === replacement) {
+            this.decrementActiveTurns(channel, agentId);
+          }
+          console.warn(
+            `[orchestrator] ${channel.taskId}/${agentId}: respawn send failed: ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          );
+        });
+      }
+    } finally {
+      channel.spawning.delete(agentId);
+    }
+
+    if (
+      replacement &&
+      this.isActiveChannel(channel) &&
+      channel.browserStaleSessions.size > 0
+    ) {
+      void this.reconcileSessions(channel).catch((err: unknown) => {
+        console.warn(
+          `[orchestrator] ${channel.taskId}: post-respawn reconcile failed: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      });
+    }
+    return true;
+  }
+
+  /**
+   * Refresh ONE agent's credential by re-spawning it on its current
+   * (re-resolved) account — env accounts read process.env at spawn, so a
+   * reconnected token lands. Bounded by the respawn budget so a still-bad
+   * credential can't loop; on exhaustion, tell the user to reconnect.
+   */
+  private async refreshAgentToken(
+    channel: Channel,
+    agent: RosterAgent,
+  ): Promise<void> {
+    const agentId = agent.id;
+    if (!this.isActiveChannel(channel) || channel.spawning.has(agentId)) return;
+
+    const tries = (channel.respawns.get(agentId) ?? 0) + 1;
+    channel.respawns.set(agentId, tries);
+    channel.respawnLastAt.set(agentId, Date.now());
+    if (tries > MAX_RESPAWNS_PER_AGENT) {
+      this.emitHost({
+        kind: "agent.exit",
+        taskId: channel.taskId,
+        agentId,
+        reason:
+          `${agent.kind} auth keeps failing after ${tries - 1} restarts — ` +
+          `reconnect ${agent.kind} on Account, then message the agent to recover.`,
+      });
+      channel.sessions.delete(agentId);
+      return;
+    }
+
+    const accounts = resolveEngineAccounts(agent.kind);
+    const account =
+      accounts.find((a) => a.id === channel.accountByAgent.get(agentId)) ??
+      accounts[0];
+    if (!account) return;
+
+    await this.respawnAgentOnAccount(
+      channel,
+      agentId,
+      agent,
+      account,
+      `${agentId}: ${agent.kind} credential refreshed — restarted the agent.`,
+    );
+  }
+
+  /**
+   * Re-spawn every running agent of `kind` on its current account with a fresh
+   * runner — picking up a just-reconnected credential (env accounts re-read
+   * process.env at spawn). Call this when the host's credential for `kind`
+   * changes (a re-login). Resets each agent's respawn budget first so an agent
+   * that exhausted it during the outage gets a clean chance on the new token.
+   */
+  async refreshEngineAccountAgents(kind: string): Promise<void> {
+    for (const channel of this.channels.values()) {
+      if (!this.isActiveChannel(channel)) continue;
+      for (const agent of channel.roster) {
+        if (agent.kind !== kind || !channel.sessions.has(agent.id)) continue;
+        channel.respawns.set(agent.id, 0);
+        try {
+          await this.refreshAgentToken(channel, agent);
+        } catch (err) {
+          console.warn(
+            `[orchestrator] ${channel.taskId}/${agent.id}: token refresh failed: ${
+              err instanceof Error ? err.message : String(err)
+            }`,
+          );
+        }
+      }
+    }
+  }
+
   // -- permission resolution ------------------------------------------------
 
   async resolvePermission(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "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/ui/server.ts

@@ -25,6 +25,7 @@ import type { ZodType } from "zod";
 
 import { agentMode } from "../../lib/agents/mode";
 import { schema, type Db } from "../../lib/db";
+import { getOrchestrator } from "../../lib/orchestrator";
 import { parsePreviewPortRuntimes } from "../../lib/preview-ports";
 import { getCloudState } from "../../lib/cloud-state";
 import { dockerCli } from "../../lib/docker-exec";
@@ -311,6 +312,13 @@ async function handleEngineConnect(
     // an optional engine's CLI (kimi/grok/cursor) is installed. Best-effort.
     opts.readvertise?.();
     void ensureStandardImage();
+    // A re-login only reaches a RUNNING task once its agents re-spawn — the
+    // credential is injected at spawn (Claude's token via `docker exec -e`).
+    // Refresh running agents of this kind so a reconnect self-heals tasks stuck
+    // on a revoked/expired token, instead of needing a manual Stop/Resume.
+    void getOrchestrator()
+      .refreshEngineAccountAgents(kind)
+      .catch(() => {});
   }
   emit({ done: true, ok: result.ok, message: result.message });
   res.end();