@runuai/host 0.9.3 → 0.9.5

package/images/standard/container/uai-init

@@ -207,14 +207,26 @@ fi
 editor_root="$WORKSPACE"
 [ -d "$editor_root" ] || editor_root="/home/node"
 
-# Seed the curated code-server defaults (slim chrome, telemetry off, trust
-# off) into the User settings dir when the task hasn't written its own yet.
-cs_user_dir="$HOME/.local/share/code-server/User"
+# Keep code-server on Uai's managed data path even when a project declares
+# XDG_DATA_HOME. Otherwise code-server starts with a fresh profile elsewhere,
+# which restores the light theme and Workspace Trust prompt.
+cs_data_dir="$HOME/.local/share/code-server"
+cs_user_dir="$cs_data_dir/User"
 cs_seed="/usr/local/share/uai/code-server-settings.json"
-if [ -f "$cs_seed" ] && [ ! -f "$cs_user_dir/settings.json" ]; then
-  mkdir -p "$cs_user_dir"
-  cp "$cs_seed" "$cs_user_dir/settings.json"
-  log "seeded code-server settings"
+# The source-tree sibling keeps direct smoke tests and development runs on the
+# same seed as the packaged image; the image always uses the root-owned path.
+cs_source_seed="$(dirname "${BASH_SOURCE[0]}")/code-server-settings.json"
+if [ ! -f "$cs_seed" ] && [ -f "$cs_source_seed" ]; then
+  cs_seed="$cs_source_seed"
+fi
+if [ ! -f "$cs_user_dir/settings.json" ]; then
+  if [ ! -f "$cs_seed" ]; then
+    log "warning: code-server settings seed missing at $cs_seed"
+  elif mkdir -p "$cs_user_dir" && cp "$cs_seed" "$cs_user_dir/settings.json"; then
+    log "seeded code-server settings"
+  else
+    log "warning: could not seed code-server settings at $cs_user_dir/settings.json"
+  fi
 fi
 
 if pgrep -f 'code-server.*--bind-addr' >/dev/null 2>&1; then
@@ -222,6 +234,8 @@ if pgrep -f 'code-server.*--bind-addr' >/dev/null 2>&1; then
 else
   log "launching code-server on 0.0.0.0:8080"
   nohup code-server \
+    --user-data-dir "$cs_data_dir" \
+    --disable-workspace-trust \
     --auth none \
     --disable-telemetry \
     --bind-addr 0.0.0.0:8080 \

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.3",
+  "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/scripts/agent/task-up.sh

@@ -1091,7 +1091,7 @@ fi
       GIT_CONFIG* | GIT_DIR | GIT_WORK_TREE | GIT_COMMON_DIR | \
       GIT_OBJECT_DIRECTORY | GIT_ALTERNATE_OBJECT_DIRECTORIES | \
       GIT_INDEX_FILE | GIT_EXEC_PATH | GIT_ASKPASS | SSH_ASKPASS | \
-      GIT_SSH | GIT_SSH_COMMAND | HOME | XDG_CONFIG_HOME | \
+      GIT_SSH | GIT_SSH_COMMAND | HOME | XDG_CONFIG_HOME | XDG_DATA_HOME | \
       BASH_ENV | ENV | UAI_GIT_TRANSPORT | \
       CLAUDE_CODE_OAUTH_TOKEN | ANTHROPIC_API_KEY | \
       ANTHROPIC_AUTH_TOKEN | XAI_API_KEY | PLAYWRIGHT_BROWSERS_PATH) continue ;;
@@ -1180,6 +1180,7 @@ compose_env_override=$(printf '%s' "$project_env_json" | jq -c \
         .GIT_SSH_COMMAND,
         .HOME,
         .XDG_CONFIG_HOME,
+        .XDG_DATA_HOME,
         .BASH_ENV,
         .ENV,
         .UAI_GIT_TRANSPORT,
@@ -1216,6 +1217,7 @@ managed_exec_env=(
   -e "GH_CONFIG_DIR=$managed_gh_config_dir"
   -e "PATH=/usr/bin:/bin"
   -e "XDG_CONFIG_HOME="
+  -e "XDG_DATA_HOME="
   -e "LD_PRELOAD="
   -e "LD_LIBRARY_PATH="
   -e "DYLD_INSERT_LIBRARIES="

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();