@runuai/host 0.8.7 → 0.8.8

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,
@@ -804,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.7",
+  "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>",

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,

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/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;