@runuai/host 0.8.6 → 0.8.8

package/lib/agents/cursor.ts

@@ -212,6 +212,7 @@ export class CursorSession implements AgentSession {
       "--stream-partial-output",
       "--force", // container is the sandbox — auto-run tools
       "--trust", // skip the workspace-trust prompt in headless
+      "--approve-mcps", // load the gateway MCP servers from ~/.cursor/mcp.json (ADR-057)
     );
     if (this.model && this.model !== "auto") args.push("-m", this.model);
     if (this.sessionId) args.push("--resume", this.sessionId);

package/lib/mcp-gateway.ts

@@ -270,16 +270,20 @@ export function startMcpGateway(): void {
 
 // --- task container wiring (ADR-057 task-up writers) -------------------------
 
-/** Idempotent node -e merge of entries into /workspace/.mcp.json. */
+/** 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. */
 const MERGE_MCP_JSON = `
 const fs = require("fs");
-const p = "/workspace/.mcp.json";
+const path = require("path");
+const p = process.argv[1];
+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 || {};
 let changed = false;
-for (const [k, v] of Object.entries(JSON.parse(process.argv[1]))) {
+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 (changed || !existed) fs.writeFileSync(p, JSON.stringify(j, null, 2) + "\\n");
@@ -290,16 +294,21 @@ function shellQuote(value: string): string {
 }
 
 /**
- * Write the task's MCP configs inside the container: gateway-URL entries per
- * connection for Claude (/workspace/.mcp.json, merged — coexists with the
- * ADR-053 browser server) and mcp-remote shims for Codex (config.toml,
- * append-once per slug). Safe to re-run every ensure.
+ * Write the task's MCP configs inside the container, one shape per engine on
+ * the roster — all pointing at the same host gateway URLs:
+ *   - Claude — /workspace/.mcp.json (merged; coexists with the ADR-053 browser
+ *     server). Written unconditionally: the adapter passes `--mcp-config`.
+ *   - Codex — mcp-remote shims appended once per slug to config.toml.
+ *   - Cursor — ~/.cursor/mcp.json ({ url } form; the adapter passes
+ *     `--approve-mcps`).
+ *   - Grok — `grok mcp add` writes ~/.grok/config.toml (idempotent per slug).
+ * Safe to re-run every ensure. `engineKinds` is the roster's agent kinds.
  */
 export async function setupMcpTaskConfig(
   taskId: string,
   containerName: string,
   connections: TaskMcpConnection[],
-  hasCodex: boolean,
+  engineKinds: string[],
 ): Promise<void> {
   // No early return on empty: the claude adapter passes
   // `--mcp-config /workspace/.mcp.json` unconditionally (ADR-057), so the
@@ -308,18 +317,25 @@ export async function setupMcpTaskConfig(
     const acl = ensureTaskGatewayAcl(taskId, connections);
     const urlFor = (slug: string): string =>
       `http://host.docker.internal:${MCP_GATEWAY_PORT}/t/${acl.token}/${slug}`;
+    const has = (kind: string): boolean => engineKinds.includes(kind);
 
     const claudeEntries: Record<string, unknown> = {};
+    const cursorEntries: 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) };
     }
     const steps = [
       "mkdir -p /workspace/.claude",
       `[ -f /workspace/.claude/settings.json ] || printf '%s\\n' ${shellQuote(
         JSON.stringify({ enableAllProjectMcpServers: true }, null, 2),
       )} > /workspace/.claude/settings.json`,
-      `node -e ${shellQuote(MERGE_MCP_JSON)} ${shellQuote(JSON.stringify(claudeEntries))}`,
-      ...(hasCodex
+      `node -e ${shellQuote(MERGE_MCP_JSON)} /workspace/.mcp.json ${shellQuote(
+        JSON.stringify(claudeEntries),
+      )}`,
+      // Codex: stdio-only, so each connection is an mcp-remote shim.
+      ...(has("codex")
         ? connections.map(
             (c) =>
               `grep -q "mcp_servers.${c.slug}]" /home/node/.codex/config.toml 2>/dev/null || printf '%s' ${shellQuote(
@@ -327,6 +343,23 @@ export async function setupMcpTaskConfig(
               )} >> /home/node/.codex/config.toml`,
           )
         : []),
+      // Cursor: reads ~/.cursor/mcp.json (the adapter passes --approve-mcps).
+      ...(has("cursor") && connections.length > 0
+        ? [
+            `node -e ${shellQuote(MERGE_MCP_JSON)} /home/node/.cursor/mcp.json ${shellQuote(
+              JSON.stringify(cursorEntries),
+            )}`,
+          ]
+        : []),
+      // Grok: `grok mcp add` writes ~/.grok/config.toml. Idempotent + tolerant.
+      ...(has("grok")
+        ? connections.map(
+            (c) =>
+              `/home/node/.local/bin/grok mcp add ${shellQuote(c.slug)} ${shellQuote(
+                urlFor(c.slug),
+              )} -t http -s user >/dev/null 2>&1 || true`,
+          )
+        : []),
     ].join(" && ");
     const result = await dockerCli(
       ["exec", containerName, "sh", "-lc", steps],

package/lib/orchestrator.ts

@@ -51,7 +51,7 @@ import {
   writeAgentCli,
 } from "./agent-cli";
 import { setupBrowserTesting } from "./browser-testing";
-import { setupMcpTaskConfig } from "./mcp-gateway";
+import { clearTaskGatewayAcl, setupMcpTaskConfig } from "./mcp-gateway";
 import { env } from "./env";
 import type {
   ChannelEnsureInput,
@@ -172,6 +172,14 @@ class Orchestrator {
   /** Fold a fresh channel spec into a live channel (ADR-049). */
   private refreshChannel(channel: Channel, spec: ChannelEnsureInput): void {
     const known = new Set(channel.roster.map((a) => a.id));
+    // Replace EXISTING agents' data with the fresh spec — a mid-task roster edit
+    // can change permissions, model, brief, role or skills, and without this the
+    // stale snapshot persists (e.g. granting `uai` CLI permissions mid-task never
+    // took effect: writeAgentCli kept seeing the old empty list). Swapping the
+    // object (not merging) also drops fields that were removed. The token/model a
+    // LIVE session already carries only changes on its next respawn.
+    const bySpecId = new Map(spec.agents.map((a) => [a.id, a]));
+    channel.roster = channel.roster.map((a) => bySpecId.get(a.id) ?? a);
     for (const agent of spec.agents) {
       if (!known.has(agent.id)) {
         channel.roster.push(agent);
@@ -321,7 +329,7 @@ class Orchestrator {
       channel.taskId,
       channel.containerName,
       channel.mcpConnections,
-      channel.roster.some((a) => a.kind === "codex"),
+      channel.roster.map((a) => a.kind),
     );
     // Agent CLIs read MCP servers once, at process start — and durable
     // sessions (ADR-061) make processes long-lived, so without this a
@@ -796,6 +804,42 @@ class Orchestrator {
     for (const session of ch.sessions.values()) await session.close();
     this.channels.delete(taskId);
   }
+
+  /**
+   * Stop a task's containers but KEEP its worktree + state — a resumable pause
+   * the host operator triggers from the local UI (ADR-028). Closes the channel
+   * (drops sessions) and stops every container in the compose project, then
+   * mirrors `stopped`. Unlike taskDown this destroys nothing, so the cloud
+   * reconciles it to `stopped` (worktree present) and it can be resumed. Since
+   * `stopped` is not an ACTIVE status, host recovery won't restart it.
+   */
+  async stopTask(taskId: string): Promise<{ ok: boolean; error?: string }> {
+    const task = getHostTask(taskId);
+    if (!task) return { ok: false, error: "unknown task" };
+    const project = task.composeProject;
+    if (!project) return { ok: false, error: "task has no running stack" };
+    // Close sessions first so nothing races to respawn them mid-stop.
+    await this.closeChannel(taskId);
+    const ps = await dockerCli([
+      "ps",
+      "-q",
+      "--filter",
+      `label=com.docker.compose.project=${project}`,
+    ]);
+    const ids = ps.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+    if (ids.length > 0) {
+      const stopped = await dockerCli(["stop", ...ids], { timeoutMs: 60_000 });
+      if (stopped.status !== 0) {
+        return {
+          ok: false,
+          error: stopped.stderr.trim().slice(0, 200) || "docker stop failed",
+        };
+      }
+    }
+    upsertHostTask(taskId, { statusMirror: "stopped" });
+    clearTaskGatewayAcl(taskId);
+    return { ok: true };
+  }
 }
 
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",
@@ -75,10 +75,10 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^8.59.4",
-    "@typescript-eslint/parser": "^8.59.4",
     "@types/node": "^22.9.0",
     "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.59.4",
+    "@typescript-eslint/parser": "^8.59.4",
     "eslint": "^9.14.0",
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"

package/src/main.ts

@@ -183,6 +183,16 @@ async function startLocalUi(): Promise<void> {
       // Engine connect/disconnect in the local UI re-advertises capabilities so
       // the cloud's task picker reflects a newly-configured engine promptly.
       readvertise: sendCapabilities,
+      // Local UI "Stop" — the operator can pause a task's containers (ADR-028).
+      // On success, push the status up so the cloud mirrors `stopped` (it has no
+      // auto-reconcile trigger); otherwise it would keep showing `running`.
+      stopTask: async (taskId) => {
+        const result = await getOrchestrator().stopTask(taskId);
+        if (result.ok && ws && ws.readyState === WebSocket.OPEN) {
+          send(ws, { kind: "task.status", taskId, status: "stopped" });
+        }
+        return result;
+      },
     });
     console.log(`[host-agent] local UI on http://127.0.0.1:${handle.port}`);
   } catch (err) {

package/src/protocol.ts

@@ -501,6 +501,9 @@ export type HostToCloud =
       result: HostCommandResult<unknown>;
     }
   | { kind: "event"; event: HostEvent }
+  // Host-pushed task lifecycle (ADR-028 local-UI Stop): the host operator paused
+  // a task's containers, so the cloud mirrors the status (currently "stopped").
+  | { kind: "task.status"; taskId: string; status: string }
   | { kind: "ping"; ts: number }
   | {
       kind: "tunnel.ack";

package/src/ui/server.ts

@@ -71,6 +71,12 @@ export interface UiServerOptions {
    * task picker promptly. Optional (tests omit it).
    */
   readvertise?: () => void;
+  /**
+   * Stop a task's containers (resumable) — wired from main.ts to the
+   * orchestrator. The host operator's "reclaim my machine" control (ADR-028).
+   * Optional (tests omit it).
+   */
+  stopTask?: (taskId: string) => Promise<{ ok: boolean; error?: string }>;
 }
 
 export interface UiServerHandle {
@@ -147,6 +153,8 @@ async function handle(
           return await handleEngineConnect(req, res, opts);
         case "/api/engines/disconnect":
           return await handleEngineDisconnect(req, res, opts);
+        case "/api/tasks/stop":
+          return await handleTaskStop(req, res, opts);
       }
       return sendError(res, 404, `no such endpoint: ${path}`);
     }
@@ -260,6 +268,27 @@ async function handleEngineDisconnect(
   return sendJson(res, EngineOpResponse, { ok: true });
 }
 
+/** POST /api/tasks/stop `{taskId}` → compose-stop the task (resumable). */
+async function handleTaskStop(
+  req: IncomingMessage,
+  res: ServerResponse,
+  opts: UiServerOptions,
+): Promise<void> {
+  const body = await readJsonBody(req);
+  const taskId = body?.taskId;
+  if (typeof taskId !== "string" || taskId.length === 0) {
+    return sendError(res, 400, "missing taskId");
+  }
+  if (!opts.stopTask) {
+    return sendError(res, 501, "stop not available on this host");
+  }
+  const result = await opts.stopTask(taskId);
+  return sendJson(res, EngineOpResponse, {
+    ok: result.ok,
+    message: result.error,
+  });
+}
+
 /** Read a request body and parse it as a JSON object; null on empty/invalid. */
 async function readJsonBody(
   req: IncomingMessage,
@@ -365,6 +394,8 @@ const STATIC_FILES: Record<string, string> = {
   "/index.html": "index.html",
   "/style.css": "style.css",
   "/app.js": "app.js",
+  "/uai-wheel.svg": "uai-wheel.svg",
+  "/uai-favicon.svg": "uai-favicon.svg",
   "/uai-logo-black.svg": "uai-logo-black.svg",
 };
 

package/ui/app.js

@@ -172,7 +172,30 @@ function taskNode(t, events) {
   chev.className = "chev";
   chev.textContent = "›";
 
-  head.append(main, chev);
+  head.append(main);
+  // Stop — pause a running task's containers (resumable). Owner-agnostic: the
+  // operator controls what runs on their machine (ADR-028).
+  if (t.status === "running" || t.status === "starting") {
+    const stop = document.createElement("button");
+    stop.className = "link-btn danger task-stop";
+    stop.type = "button";
+    stop.textContent = "Stop";
+    stop.addEventListener("click", async (ev) => {
+      ev.stopPropagation();
+      if (!confirm(`Stop this task?\n\n${t.taskId}\n\nContainers stop (freeing memory); the worktree is kept so it can be resumed.`)) return;
+      stop.disabled = true;
+      stop.textContent = "Stopping…";
+      try {
+        const r = await postJSON("/api/tasks/stop", { taskId: t.taskId });
+        if (!r.ok) alert(`Stop failed: ${r.message || "unknown error"}`);
+      } catch {
+        /* poll re-syncs truth */
+      }
+      await poll();
+    });
+    head.append(stop);
+  }
+  head.append(chev);
   node.append(head);
 
   if (open) {

package/ui/index.html

@@ -5,14 +5,14 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Uai host</title>
     <!-- Local monitor UI (ADR-028). Served from 127.0.0.1 by the host service. -->
-    <link rel="icon" type="image/svg+xml" href="/uai-logo-black.svg" />
+    <link rel="icon" type="image/svg+xml" href="/uai-favicon.svg" />
     <link rel="stylesheet" href="/style.css" />
   </head>
   <body>
     <main>
       <header class="topbar">
         <div class="brand">
-          <img class="logo" src="/uai-logo-black.svg" alt="Uai" />
+          <img class="logo" src="/uai-wheel.svg" alt="Uai" />
           <div class="brand-text">
             <div class="host-name" id="host-name">…</div>
             <div class="host-sub" id="host-sub">host monitor</div>

package/ui/style.css

@@ -280,6 +280,18 @@ code,
   color: var(--fg-muted);
 }
 
+.task-stop {
+  flex: none;
+  font-size: 0.85rem;
+  opacity: 0;
+  transition: opacity 0.12s ease;
+}
+/* Reveal Stop on row hover; keep it visible mid-action so it doesn't vanish. */
+.task-head:hover .task-stop,
+.task-stop:disabled {
+  opacity: 1;
+}
+
 .chev {
   color: var(--fg-muted);
   transition: transform 0.15s ease;

package/ui/uai-favicon.svg

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Layer_2" data-name="Layer 2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 341.02 341.02">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: #231f20;
+      }
+
+      .cls-2 {
+        fill: #fff;
+      }
+    </style>
+  </defs>
+  <g id="Layer_1-2" data-name="Layer 1">
+    <rect class="cls-1" x="0" width="341.02" height="341.02"/>
+    <g>
+      <path class="cls-2" d="M170.51,43.13c-70.35,0-127.37,57.03-127.37,127.37s57.03,127.37,127.37,127.37,127.37-57.03,127.37-127.37-57.03-127.37-127.37-127.37ZM170.51,269.54c-54.69,0-99.03-44.34-99.03-99.03s44.34-99.03,99.03-99.03,99.03,44.34,99.03,99.03-44.34,99.03-99.03,99.03Z"/>
+      <path class="cls-2" d="M170.59,99.55c-4.31,0-8.53.4-12.63,1.14l-53.93,95.15c3.15,8.33,7.81,15.91,13.65,22.41h105.8c5.74-6.39,10.34-13.82,13.48-21.98l-54.22-95.67c-3.96-.68-8.02-1.06-12.17-1.06ZM194.08,169.79c0,13.02-10.55,23.57-23.57,23.57s-23.57-10.55-23.57-23.57,10.55-23.57,23.57-23.57,23.57,10.55,23.57,23.57Z"/>
+    </g>
+  </g>
+</svg>

package/ui/uai-wheel.svg

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Uai "wheel" mark (brand 8a5db40). Dark fill on transparent bg so the
+     header's dark-mode `filter: invert(1)` renders it white on dark. -->
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 341.02 341.02">
+  <g fill="#231f20">
+    <path d="M170.51,43.13c-70.35,0-127.37,57.03-127.37,127.37s57.03,127.37,127.37,127.37,127.37-57.03,127.37-127.37-57.03-127.37-127.37-127.37ZM170.51,269.54c-54.69,0-99.03-44.34-99.03-99.03s44.34-99.03,99.03-99.03,99.03,44.34,99.03,99.03-44.34,99.03-99.03,99.03Z"/>
+    <path d="M170.59,99.55c-4.31,0-8.53.4-12.63,1.14l-53.93,95.15c3.15,8.33,7.81,15.91,13.65,22.41h105.8c5.74-6.39,10.34-13.82,13.48-21.98l-54.22-95.67c-3.96-.68-8.02-1.06-12.17-1.06ZM194.08,169.79c0,13.02-10.55,23.57-23.57,23.57s-23.57-10.55-23.57-23.57,10.55-23.57,23.57-23.57,23.57,10.55,23.57,23.57Z"/>
+  </g>
+</svg>