@runuai/host 0.8.35 → 0.8.36

package/lib/mcp-gateway.ts

@@ -270,21 +270,24 @@ export function startMcpGateway(): void {
 
 // --- task container wiring (ADR-057 task-up writers) -------------------------
 
-/** Idempotent node -e merge of entries (argv[2]) into an mcpServers file
- *  (argv[1]) — reused for Claude's /workspace/.mcp.json and Cursor's
- *  ~/.cursor/mcp.json. Creates the parent dir when missing. */
+/** Idempotent node -e merge of entries (argv[2]) into a JSON file (argv[1])
+ *  under a top-level object key (argv[3], default "mcpServers") — reused for
+ *  Claude's /workspace/.mcp.json + Cursor's ~/.cursor/mcp.json (mcpServers)
+ *  and OpenCode's ~/.config/opencode/opencode.json (mcp). Creates the parent
+ *  dir when missing. */
 const MERGE_MCP_JSON = `
 const fs = require("fs");
 const path = require("path");
 const p = process.argv[1];
+const key = process.argv[3] || "mcpServers";
 try { fs.mkdirSync(path.dirname(p), { recursive: true }); } catch {}
 let j = {};
 let existed = true;
 try { j = JSON.parse(fs.readFileSync(p, "utf8")); } catch { existed = false; }
-j.mcpServers = j.mcpServers || {};
+j[key] = j[key] || {};
 let changed = false;
 for (const [k, v] of Object.entries(JSON.parse(process.argv[2]))) {
-  if (JSON.stringify(j.mcpServers[k]) !== JSON.stringify(v)) { j.mcpServers[k] = v; changed = true; }
+  if (JSON.stringify(j[key][k]) !== JSON.stringify(v)) { j[key][k] = v; changed = true; }
 }
 if (changed || !existed) fs.writeFileSync(p, JSON.stringify(j, null, 2) + "\\n");
 `.trim();
@@ -302,6 +305,9 @@ function shellQuote(value: string): string {
  *   - Cursor — ~/.cursor/mcp.json ({ url } form; the adapter passes
  *     `--approve-mcps`).
  *   - Grok — `grok mcp add` writes ~/.grok/config.toml (idempotent per slug).
+ *   - OpenCode — ~/.config/opencode/opencode.json `mcp` block (type:"remote",
+ *     oauth:false so it treats the gateway URL as a plain server; the path
+ *     token is the auth). Written only when the task has connections.
  * Safe to re-run every ensure. `engineKinds` is the roster's agent kinds.
  */
 export async function setupMcpTaskConfig(
@@ -321,10 +327,20 @@ export async function setupMcpTaskConfig(
 
     const claudeEntries: Record<string, unknown> = {};
     const cursorEntries: Record<string, unknown> = {};
+    const opencodeEntries: Record<string, unknown> = {};
     for (const c of connections) {
       claudeEntries[c.slug] = { type: "http", url: urlFor(c.slug) };
       // Cursor's mcp.json wants a bare { url } for remote (http/sse) servers.
       cursorEntries[c.slug] = { url: urlFor(c.slug) };
+      // OpenCode: type:"remote" + oauth:false — the gateway needs no client
+      // auth (the path token is the secret), so suppress OpenCode's own OAuth
+      // flow that would otherwise fire on a gateway 401 and hang headless.
+      opencodeEntries[c.slug] = {
+        type: "remote",
+        url: urlFor(c.slug),
+        enabled: true,
+        oauth: false,
+      };
     }
     const steps = [
       "mkdir -p /workspace/.claude",
@@ -360,6 +376,15 @@ export async function setupMcpTaskConfig(
               )} -t http -s user >/dev/null 2>&1 || true`,
           )
         : []),
+      // OpenCode: global config `mcp` block (auto-discovered regardless of the
+      // exec cwd, and independent of any per-account OPENCODE_DATA_DIR).
+      ...(has("opencode") && connections.length > 0
+        ? [
+            `node -e ${shellQuote(MERGE_MCP_JSON)} /home/node/.config/opencode/opencode.json ${shellQuote(
+              JSON.stringify(opencodeEntries),
+            )} mcp`,
+          ]
+        : []),
     ].join(" && ");
     const result = await dockerCli(
       ["exec", containerName, "sh", "-lc", steps],

package/lib/orchestrator.ts

@@ -52,6 +52,13 @@ import {
 } from "./agent-cli";
 import { setupBrowserTesting } from "./browser-testing";
 import { injectCodexIntoContainer } from "./codex-auth";
+import {
+  cooldownEngineAccount,
+  noteEngineAccountUsed,
+  pickEngineAccount,
+  provisionEngineAccounts,
+  resolveEngineAccounts,
+} from "./engine-accounts";
 import { clearTaskGatewayAcl, setupMcpTaskConfig } from "./mcp-gateway";
 import { env } from "./env";
 import type {
@@ -112,10 +119,21 @@ interface Channel {
   /** Agents with a reconcile-spawn in flight (ADR-049 mid-task adds) — guards
    *  against a concurrent ensure double-spawning the same new agent. */
   spawning: Set<string>;
+  /** ADR-076: which engine account each agent's live session is bound to, so a
+   *  rate-limit can cool THAT account and rotate off it. */
+  accountByAgent: Map<string, string>;
+  /** ADR-076: the last prompt delivered to each agent, re-sent after an
+   *  account rotation so the interrupted turn resumes on the new account. */
+  lastPrompt: Map<string, string>;
+  /** ADR-076: per-agent account-rotation budget (reset on a successful turn) —
+   *  bounds a rate-limit storm across accounts, mirroring the respawn budget. */
+  rotations: Map<string, number>;
 }
 
 /** Hard cap on automatic respawns per agent per channel lifetime. */
 const MAX_RESPAWNS_PER_AGENT = 5;
+/** ADR-076: hard cap on account rotations per agent between successful turns. */
+const MAX_ROTATIONS_PER_AGENT = 6;
 /** A burned respawn budget resets after this quiet period (see reconcile). */
 const RESPAWN_COOLDOWN_MS = 10 * 60_000;
 
@@ -266,6 +284,9 @@ class Orchestrator {
       sharedFiles: spec.sharedFiles ?? "ro",
       mcpConnections: spec.mcpConnections ?? [],
       spawning: new Set(),
+      accountByAgent: new Map(),
+      lastPrompt: new Map(),
+      rotations: new Map(),
     };
     this.channels.set(taskId, channel);
     return channel;
@@ -410,18 +431,28 @@ class Orchestrator {
       const cliSecret = loadTaskCliSecret(channel.taskId);
       writeAgentCli(channel.taskId, channel.roster, apiUrl);
 
+      // ADR-076: extra config-dir accounts for the newly-spawning agents.
+      await provisionEngineAccounts(
+        channel.containerName,
+        missing.map((a) => a.kind),
+      );
+
       for (const agent of missing) {
         const session = await this.factory.create({
           taskId: channel.taskId,
           agent,
           containerName: channel.containerName,
           systemPreamble: channel.preambles.get(agent.id) ?? "",
-          agentEnv: agentCliEnv(
-            channel.taskId,
+          agentEnv: this.accountAgentEnv(
+            channel,
             agent,
-            task.ownerUserId,
-            apiUrl,
-            cliSecret,
+            agentCliEnv(
+              channel.taskId,
+              agent,
+              task.ownerUserId,
+              apiUrl,
+              cliSecret,
+            ),
           ),
         });
         channel.sessions.set(agent.id, session);
@@ -434,6 +465,28 @@ class Orchestrator {
     }
   }
 
+  /**
+   * ADR-076: per-agent exec env = the uai token base + the SELECTED engine
+   * account's env. Picks the least-recently-used, non-cooling account for the
+   * agent's kind and records it so a rate-limit can rotate off it. With zero
+   * configured accounts (unknown kind) this is a no-op — `base` passes through
+   * unchanged, so behavior is identical to before.
+   */
+  private accountAgentEnv(
+    channel: Channel,
+    agent: RosterAgent,
+    base: Record<string, string>,
+  ): Record<string, string> {
+    const account = pickEngineAccount(agent.kind);
+    if (!account) {
+      channel.accountByAgent.delete(agent.id);
+      return base;
+    }
+    channel.accountByAgent.set(agent.id, account.id);
+    noteEngineAccountUsed(account.id);
+    return { ...base, ...account.execEnv };
+  }
+
   private async startSessions(channel: Channel): Promise<boolean> {
     const task = getHostTask(channel.taskId);
     if (!task || task.statusMirror !== "running") return false;
@@ -490,13 +543,25 @@ class Orchestrator {
     const cliSecret = loadTaskCliSecret(channel.taskId);
     writeAgentCli(channel.taskId, channel.roster, apiUrl);
 
+    // ADR-076: copy EXTRA config-dir engine accounts into their per-account
+    // container dirs (chowned) before sessions spawn — the default account's
+    // dir is already handled by task-up.sh. Best-effort per account.
+    await provisionEngineAccounts(
+      channel.containerName,
+      channel.roster.map((a) => a.kind),
+    );
+
     for (const agent of channel.roster) {
       const session = await this.factory.create({
         taskId: channel.taskId,
         agent,
         containerName: channel.containerName,
         systemPreamble: channel.preambles.get(agent.id) ?? "",
-        agentEnv: agentCliEnv(channel.taskId, agent, task.ownerUserId, apiUrl, cliSecret),
+        agentEnv: this.accountAgentEnv(
+          channel,
+          agent,
+          agentCliEnv(channel.taskId, agent, task.ownerUserId, apiUrl, cliSecret),
+        ),
       });
       channel.sessions.set(agent.id, session);
       session.onEvent((event) => {
@@ -553,7 +618,11 @@ class Orchestrator {
     const session = channel.sessions.get(agentId);
     if (!session) return { ok: false, error: `no such agent: ${agentId}` };
 
-    void session.send(rewriteAttachmentRefs(text));
+    const prompt = rewriteAttachmentRefs(text);
+    // ADR-076: remember the in-flight prompt so an account rotation on a
+    // rate-limit can re-deliver it to the fresh session.
+    channel.lastPrompt.set(agentId, prompt);
+    void session.send(prompt);
     return { ok: true };
   }
 
@@ -674,6 +743,16 @@ class Orchestrator {
         // session so the user keeps working instead of staring at a dead
         // chat.
         const agent = channel.roster.find((a) => a.id === agentId);
+        // ADR-076: a rate-limit/usage-cap error fails over to another account
+        // for this kind (cool the current one, recreate the session on the
+        // next, re-deliver the in-flight prompt). No-op with <2 accounts.
+        if (
+          event.retryable === "rate_limit" &&
+          agent &&
+          (await this.rotateAccount(channel, agentId, agent))
+        ) {
+          break;
+        }
         const isClaude = agent?.kind === "claude";
         const configMissing = CLAUDE_CONFIG_MISSING_PATTERNS.some((re) =>
           re.test(event.message),
@@ -710,6 +789,9 @@ class Orchestrator {
         // the cloud discards the buffer instead of handing it to peers.
         const aborted = channel.interrupted.delete(agentId);
         channel.openTurns.delete(agentId);
+        // ADR-076: a turn that completed means the current account is healthy —
+        // reset its rotation budget so a LATER rate-limit gets a fresh failover.
+        channel.rotations.delete(agentId);
         this.emitHost({
           kind: "agent.turn_complete",
           taskId: channel.taskId,
@@ -793,6 +875,85 @@ class Orchestrator {
     });
   }
 
+  /**
+   * ADR-076: fail over an agent to another account for its kind after a
+   * rate-limit. Cools the current account, recreates the session bound to the
+   * next healthy account (provisioning its config-dir first), and re-delivers
+   * the in-flight prompt. Bounded by MAX_ROTATIONS_PER_AGENT. Returns true when
+   * it rotated (the error is handled); false to let normal error handling run
+   * (no second account, budget exhausted, or the container is gone).
+   */
+  private async rotateAccount(
+    channel: Channel,
+    agentId: string,
+    agent: RosterAgent,
+  ): Promise<boolean> {
+    if (resolveEngineAccounts(agent.kind).length < 2) return false;
+
+    const budget = (channel.rotations.get(agentId) ?? 0) + 1;
+    channel.rotations.set(agentId, budget);
+    if (budget > MAX_ROTATIONS_PER_AGENT) return false;
+
+    const current = channel.accountByAgent.get(agentId);
+    if (current) cooldownEngineAccount(current);
+    const next = pickEngineAccount(agent.kind, {
+      exclude: current ? new Set([current]) : undefined,
+    });
+    if (!next) return false;
+
+    const task = getHostTask(channel.taskId);
+    if (!task || task.statusMirror !== "running") return false;
+
+    // Tear the rate-limited session down (its `closed` flag suppresses its own
+    // exit, so no respawn-budget noise races this rotation).
+    const old = channel.sessions.get(agentId);
+    channel.sessions.delete(agentId);
+    if (old) {
+      try {
+        await old.close();
+      } catch {
+        /* already gone — close is idempotent for our adapters */
+      }
+    }
+
+    // Extra config-dir accounts need their dir copied in before use.
+    await provisionEngineAccounts(channel.containerName, [agent.kind]);
+
+    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, next.id);
+    noteEngineAccountUsed(next.id);
+
+    const session = await this.factory.create({
+      taskId: channel.taskId,
+      agent,
+      containerName: channel.containerName,
+      systemPreamble: channel.preambles.get(agentId) ?? "",
+      agentEnv: { ...base, ...next.execEnv },
+    });
+    channel.sessions.set(agentId, session);
+    session.onEvent((event) => {
+      void this.handleAgentEvent(channel, agentId, event);
+    });
+
+    this.emitSystemNote(
+      channel.taskId,
+      `${agentId}: hit a rate limit — switched to another ${agent.kind} account and retried.`,
+    );
+
+    // Re-deliver the in-flight prompt so the interrupted turn resumes.
+    const prompt = channel.lastPrompt.get(agentId);
+    if (prompt) void session.send(prompt);
+    return true;
+  }
+
   // -- permission resolution ------------------------------------------------
 
   async resolvePermission(

package/lib/standard-image.ts

@@ -81,11 +81,13 @@ export function configuredOptionalEngines(): {
   kimi: boolean;
   grok: boolean;
   cursor: boolean;
+  opencode: boolean;
 } {
   return {
     kimi: detectEngine("kimi"),
     grok: detectEngine("grok"),
     cursor: detectEngine("cursor"),
+    opencode: detectEngine("opencode"),
   };
 }
 
@@ -397,9 +399,11 @@ async function ensureStandardImageInner(): Promise<StandardImageResult> {
     `INSTALL_GROK=${engines.grok ? 1 : 0}`,
     "--build-arg",
     `INSTALL_CURSOR=${engines.cursor ? 1 : 0}`,
+    "--build-arg",
+    `INSTALL_OPENCODE=${engines.opencode ? 1 : 0}`,
   ];
   const contextHash = await hashBuildContext(
-    `kimi=${engines.kimi ? 1 : 0};grok=${engines.grok ? 1 : 0};cursor=${engines.cursor ? 1 : 0}`,
+    `kimi=${engines.kimi ? 1 : 0};grok=${engines.grok ? 1 : 0};cursor=${engines.cursor ? 1 : 0};opencode=${engines.opencode ? 1 : 0}`,
   );
   const inspect = await run("docker", [
     "image",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.35",
+  "version": "0.8.36",
   "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

@@ -554,6 +554,23 @@ done
 docker exec -u root "$app_container" \
   chown -R node:node /home/node/.grok >/dev/null 2>&1 || true
 
+# Copy OpenCode provider auth into a task-private /home/node/.local/share/opencode
+# (ADR-077), same per-task-writable-copy pattern as Codex. The Linux `opencode`
+# binary is baked into the image; here we copy the arch-independent auth+config.
+# ADR-076 EXTRA accounts (isolated dirs) are copied later from the host-agent
+# (provisionEngineAccounts) since they live in the sealed DB, not on disk here.
+docker exec -u root "$app_container" \
+  mkdir -p /home/node/.local/share/opencode >/dev/null 2>&1 || true
+for oc_item in auth.json config.json; do
+  if [ -e "$UAI_OWNER_HOME/.local/share/opencode/$oc_item" ]; then
+    docker cp "$UAI_OWNER_HOME/.local/share/opencode/$oc_item" \
+      "$app_container":/home/node/.local/share/opencode/ >/dev/null 2>&1 \
+      || log "warning: docker cp of opencode/$oc_item failed; opencode may need re-login"
+  fi
+done
+docker exec -u root "$app_container" \
+  chown -R node:node /home/node/.local/share/opencode >/dev/null 2>&1 || true
+
 # Copy the same resolved SSH identity (task creator's per-user key when present,
 # else the operator identity — see above) into the container, so the agent signs
 # + pushes with the key whose .pub the user registered on GitHub. ADR-027 drops

package/src/ui/server.ts

@@ -36,6 +36,11 @@ import {
   engineStatuses,
   isEngineKind,
 } from "../../lib/engines";
+import {
+  addEngineAccount,
+  listEngineAccounts,
+  removeEngineAccount,
+} from "../../lib/engine-accounts";
 import { ensureStandardImage } from "../../lib/standard-image";
 import {
   CloudResponse,
@@ -157,6 +162,10 @@ async function handle(
           return await handleEngineInstall(req, res);
         case "/api/engines/disconnect":
           return await handleEngineDisconnect(req, res, opts);
+        case "/api/engines/accounts/add":
+          return await handleEngineAccountAdd(req, res, opts);
+        case "/api/engines/accounts/remove":
+          return await handleEngineAccountRemove(req, res, opts);
         case "/api/tasks/stop":
           return await handleTaskStop(req, res, opts);
       }
@@ -198,11 +207,19 @@ async function handle(
 
 // --- engines ----------------------------------------------------------------
 
+/** Engine kinds that participate in the multi-account model (ADR-076). */
+const ACCOUNT_KINDS = ["claude", "codex", "opencode"] as const;
+
 async function enginesBody(): Promise<EnginesResponse> {
+  const accounts: Record<string, ReturnType<typeof listEngineAccounts>> = {};
+  for (const kind of ACCOUNT_KINDS) {
+    accounts[kind] = listEngineAccounts(kind);
+  }
   return {
     catalog: engineCatalog(),
     statuses: engineStatuses(),
     cli: await engineCliStatuses(),
+    accounts,
   };
 }
 
@@ -311,6 +328,54 @@ async function handleEngineDisconnect(
   return sendJson(res, EngineOpResponse, { ok: true });
 }
 
+/**
+ * POST /api/engines/accounts/add `{kind, label, apiKey?|token?}` → register an
+ * EXTRA account (ADR-076) by pasting a token / API key, then re-advertise (the
+ * kind may not have been available before) + rebuild the image if needed.
+ */
+async function handleEngineAccountAdd(
+  req: IncomingMessage,
+  res: ServerResponse,
+  opts: UiServerOptions,
+): Promise<void> {
+  const body = await readJsonBody(req);
+  const kind = body?.kind;
+  if (!isEngineKind(kind)) {
+    return sendError(res, 400, "unknown or missing engine kind");
+  }
+  const label = typeof body?.label === "string" ? body.label : "";
+  const apiKey = typeof body?.apiKey === "string" ? body.apiKey : undefined;
+  const token = typeof body?.token === "string" ? body.token : undefined;
+  const result = addEngineAccount(kind, label, { apiKey, token });
+  if (result.ok) {
+    opts.readvertise?.();
+    void ensureStandardImage();
+  }
+  return sendJson(res, EngineOpResponse, {
+    ok: result.ok,
+    message: result.message,
+  });
+}
+
+/** POST /api/engines/accounts/remove `{id}` → forget an EXTRA account. */
+async function handleEngineAccountRemove(
+  req: IncomingMessage,
+  res: ServerResponse,
+  opts: UiServerOptions,
+): Promise<void> {
+  const body = await readJsonBody(req);
+  const id = body?.id;
+  if (typeof id !== "string" || id.length === 0) {
+    return sendError(res, 400, "missing account id");
+  }
+  const result = removeEngineAccount(id);
+  if (result.ok) opts.readvertise?.();
+  return sendJson(res, EngineOpResponse, {
+    ok: result.ok,
+    message: result.message,
+  });
+}
+
 /** POST /api/tasks/stop `{taskId}` → compose-stop the task (resumable). */
 async function handleTaskStop(
   req: IncomingMessage,

package/src/ui/types.ts

@@ -76,9 +76,14 @@ export type UsersResponse = z.infer<typeof UsersResponse>;
 
 // GET /api/engines — the engine catalog + which are connected on this host.
 export const EngineCatalogEntry = z.object({
-  kind: z.enum(["claude", "codex", "kimi", "grok", "cursor"]),
+  kind: z.enum(["claude", "codex", "kimi", "grok", "cursor", "opencode"]),
   label: z.string(),
-  authMode: z.enum(["token-command", "login-command", "api-key"]),
+  authMode: z.enum([
+    "token-command",
+    "login-command",
+    "api-key",
+    "external-login",
+  ]),
   notes: z.string().nullable(),
   getKeyUrl: z.string().nullable(),
   // Pasted-API-key alternative to the login/token flow (null = not offered).
@@ -86,13 +91,28 @@ export const EngineCatalogEntry = z.object({
   apiKeyUrl: z.string().nullable(),
   // Install command shown when the CLI is missing (null = nothing to install).
   installHint: z.string().nullable(),
+  // external-login: the command the owner runs in their terminal (null else).
+  loginCmd: z.string().nullable(),
 });
 export type EngineCatalogEntry = z.infer<typeof EngineCatalogEntry>;
 
+// One engine account (ADR-076) — secret-free descriptor for the host UI.
+export const EngineAccountInfo = z.object({
+  id: z.string(),
+  kind: z.string(),
+  label: z.string(),
+  authKind: z.enum(["env", "config-dir"]),
+  isDefault: z.boolean(),
+});
+export type EngineAccountInfo = z.infer<typeof EngineAccountInfo>;
+
 export const EnginesResponse = z.object({
   catalog: z.array(EngineCatalogEntry),
   statuses: z.record(z.boolean()), // kind → connected
   cli: z.record(z.boolean()), // kind → CLI resolvable on this host
+  // kind → its accounts (default + extras), ADR-076. Kinds with no account
+  // model (kimi/grok/cursor) are absent.
+  accounts: z.record(z.array(EngineAccountInfo)),
 });
 export type EnginesResponse = z.infer<typeof EnginesResponse>;