@runuai/host 0.9.14 → 0.9.42

package/lib/stopped-task-status-queue.ts

@@ -0,0 +1,44 @@
+/**
+ * Best-effort task.status frames have no acknowledgement, but they must at
+ * least survive bridge disconnects within this host process. The local task
+ * mirror remains the authority at flush time so a later Resume wins over an
+ * older queued stop.
+ */
+export class StoppedTaskStatusQueue {
+  private readonly pending = new Set<string>();
+
+  constructor(
+    private readonly statusForTask: (
+      taskId: string,
+    ) => string | null | undefined,
+  ) {}
+
+  enqueue(taskId: string): void {
+    this.pending.add(taskId);
+  }
+
+  /** A failed taskUp may have stopped a legacy runtime before recreation lost
+   * Docker. Queue the physical truth after the command result is published. */
+  enqueueStoppedTaskUp(command: string, args: readonly unknown[]): boolean {
+    if (command !== "taskUp") return false;
+    const input = args[0];
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+      return false;
+    }
+    const task = (input as { task?: unknown }).task;
+    if (!task || typeof task !== "object" || Array.isArray(task)) return false;
+    const taskId = (task as { id?: unknown }).id;
+    if (typeof taskId !== "string" || this.statusForTask(taskId) !== "stopped") {
+      return false;
+    }
+    this.enqueue(taskId);
+    return true;
+  }
+
+  flush(publish: (taskId: string) => void): void {
+    for (const taskId of [...this.pending]) {
+      if (this.statusForTask(taskId) === "stopped") publish(taskId);
+      this.pending.delete(taskId);
+    }
+  }
+}

package/lib/task-container-cli.ts

@@ -0,0 +1,269 @@
+/**
+ * Backend-aware CLI access to TASK app containers for the auxiliary
+ * subsystems that predate the TaskEnvironment provider (GitHub credential
+ * injection, git identity, Codex reinjection, skills). Found live 2026-08-16:
+ * these spawned the literal `docker` binary with Compose replica names, so on
+ * a Docker-free Apple host every agent session start died at the credential
+ * step with spawn ENOENT.
+ *
+ * The exec/cp verbs are flag-compatible across Docker and the bundled Apple
+ * CLI, so most callers only need the command + container-name translation
+ * here. Verbs that differ (ps/rm/inventory) get explicit helpers.
+ */
+
+import { spawn as nodeSpawn } from "node:child_process";
+
+import {
+  appleContainerRuntimeBinding,
+  pinnedContainerRuntimeProvider,
+} from "./container-runtime";
+import { dockerCli, type DockerResult } from "./docker-exec";
+import { assertSafeHostTaskId } from "./task-identity";
+
+export interface TaskContainerBackend {
+  command: string;
+  apple: boolean;
+}
+
+/** The pin, not the readiness-gated identity: session ensure and recovery
+ * both run while the public state can still be `checking`. */
+export function taskContainerBackend(): TaskContainerBackend {
+  if (pinnedContainerRuntimeProvider() === "apple-container") {
+    const binding = appleContainerRuntimeBinding();
+    if (binding !== null) {
+      return { command: binding.containerCliPath, apple: true };
+    }
+  }
+  return { command: "docker", apple: false };
+}
+
+/** The app container's name under the selected backend: Compose replica
+ * naming for Docker, the provider's fixed name for Apple (must match
+ * appleTaskContainerName in task-environment/apple-container.ts). */
+export function taskAppContainerName(taskId: string): string {
+  assertSafeHostTaskId(taskId);
+  const lowered = taskId.toLowerCase();
+  return taskContainerBackend().apple
+    ? `task-${lowered}-app`
+    : `task-${lowered}-app-1`;
+}
+
+/** dockerCli-compatible runner that targets the selected backend. Every kill
+ * (deadline or overflow) forces settlement within a bounded grace. */
+export function taskContainerCli(
+  args: string[],
+  opts: {
+    input?: string;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+  } = {},
+): Promise<DockerResult> {
+  const backend = taskContainerBackend();
+  if (!backend.apple) return dockerCli(args, opts);
+  return new Promise<DockerResult>((resolve) => {
+    const child = nodeSpawn(backend.command, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (status: number | null): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ status, stdout, stderr });
+    };
+    const killAndSettle = (): void => {
+      child.kill("SIGKILL");
+      const settle = setTimeout(() => finish(null), 5_000);
+      settle.unref?.();
+    };
+    const timer = setTimeout(killAndSettle, opts.timeoutMs ?? 30_000);
+    timer.unref?.();
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+      if (
+        opts.maxOutputBytes !== undefined &&
+        stdout.length + stderr.length > opts.maxOutputBytes
+      ) {
+        killAndSettle();
+      }
+    });
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+      if (
+        opts.maxOutputBytes !== undefined &&
+        stdout.length + stderr.length > opts.maxOutputBytes
+      ) {
+        killAndSettle();
+      }
+    });
+    child.stdin.on("error", () => {});
+    if (opts.input !== undefined) child.stdin.write(opts.input);
+    child.stdin.end();
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code));
+  });
+}
+
+export type TaskContainerState =
+  | { kind: "running" }
+  | { kind: "stopped"; state: string }
+  | { kind: "absent" }
+  | { kind: "unknown"; detail: string };
+
+/** Backend-aware state probe for one exact task app container. Absence is
+ * proven only by the complete not-found error naming the container (Apple)
+ * or an empty exact-name filter answer (Docker); anything else is unknown. */
+export async function taskAppContainerState(
+  containerName: string,
+  run: typeof taskContainerCli = taskContainerCli,
+): Promise<TaskContainerState> {
+  const backend = taskContainerBackend();
+  if (backend.apple) {
+    const inspected = await run(["inspect", containerName], {
+      timeoutMs: 30_000,
+      maxOutputBytes: 1024 * 1024,
+    });
+    if (inspected.status !== 0) {
+      if (
+        inspected.stdout.trim() === "" &&
+        inspected.stderr
+          .split("\n")
+          .some(
+            (line) =>
+              line.trim() === `Error: container not found: ${containerName}`,
+          )
+      ) {
+        return { kind: "absent" };
+      }
+      return {
+        kind: "unknown",
+        detail: inspected.stderr.trim().slice(0, 300) || "inspect failed",
+      };
+    }
+    try {
+      const parsed = JSON.parse(inspected.stdout) as Array<{
+        id?: unknown;
+        status?: { state?: unknown };
+      }>;
+      if (
+        !Array.isArray(parsed) ||
+        parsed.length !== 1 ||
+        parsed[0]?.id !== containerName
+      ) {
+        return { kind: "unknown", detail: "inspect shape is invalid" };
+      }
+      const state = parsed[0]?.status?.state;
+      if (typeof state !== "string") {
+        return { kind: "unknown", detail: "inspect state is missing" };
+      }
+      return state === "running"
+        ? { kind: "running" }
+        : { kind: "stopped", state };
+    } catch {
+      return { kind: "unknown", detail: "inspect output is not JSON" };
+    }
+  }
+  const listed = await run(
+    [
+      "ps",
+      "--all",
+      "--filter",
+      `name=^/${containerName}$`,
+      "--format",
+      "{{.State}}",
+    ],
+    { timeoutMs: 30_000, maxOutputBytes: 64 * 1024 },
+  );
+  if (listed.status !== 0) {
+    return {
+      kind: "unknown",
+      detail: listed.stderr.trim().slice(0, 300) || "docker ps failed",
+    };
+  }
+  const states = listed.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (states.length === 0) return { kind: "absent" };
+  if (states.length !== 1) {
+    return { kind: "unknown", detail: `${states.length} containers matched` };
+  }
+  return states[0] === "running"
+    ? { kind: "running" }
+    : { kind: "stopped", state: states[0]! };
+}
+
+/** Force-remove one exact task app container and prove its absence. */
+export async function removeTaskAppContainer(
+  containerName: string,
+  run: typeof taskContainerCli = taskContainerCli,
+): Promise<void> {
+  const backend = taskContainerBackend();
+  const removed = await run(
+    backend.apple
+      ? ["delete", "--force", containerName]
+      : ["rm", "--force", containerName],
+    { timeoutMs: 60_000, maxOutputBytes: 64 * 1024 },
+  );
+  if (removed.status !== 0 && backend.apple) {
+    // Deleting an already-absent container is success; anything else is not.
+    const state = await taskAppContainerState(containerName, run);
+    if (state.kind === "absent") return;
+    throw new Error(
+      `remove ${containerName} failed: ${removed.stderr.trim().slice(0, 300)}`,
+    );
+  }
+  const after = await taskAppContainerState(containerName, run);
+  if (after.kind !== "absent") {
+    throw new Error(`remove ${containerName} was not verified`);
+  }
+}
+
+/** Names of RUNNING task app containers under the selected backend. */
+export async function listRunningTaskAppContainerNames(
+  run: typeof taskContainerCli = taskContainerCli,
+): Promise<string[] | null> {
+  const backend = taskContainerBackend();
+  if (backend.apple) {
+    const listed = await run(["list", "--format", "json"], {
+      timeoutMs: 30_000,
+      maxOutputBytes: 8 * 1024 * 1024,
+    });
+    if (listed.status !== 0) return null;
+    try {
+      const parsed = JSON.parse(listed.stdout) as Array<{
+        configuration?: { id?: unknown };
+        status?: { state?: unknown };
+      }>;
+      if (!Array.isArray(parsed)) return null;
+      // `container list` without --all already returns running containers,
+      // but the state check keeps this honest against CLI behavior drift.
+      return parsed
+        .filter(
+          (item) =>
+            item?.status?.state === undefined ||
+            item?.status?.state === "running",
+        )
+        .map((item) => item?.configuration?.id)
+        .filter(
+          (id): id is string =>
+            typeof id === "string" && /^task-[a-z0-9][a-z0-9_-]*-app$/.test(id),
+        );
+    } catch {
+      return null;
+    }
+  }
+  const listed = await run(
+    ["ps", "--filter", "status=running", "--format", "{{.Names}}"],
+    { timeoutMs: 30_000, maxOutputBytes: 1024 * 1024 },
+  );
+  if (listed.status !== 0) return null;
+  return listed.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}

package/lib/task-diff.ts

@@ -1,67 +1,89 @@
 import { existsSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { join } from "node:path";
+import { join, posix } from "node:path";
 
 import type { TaskDiffInput, TaskDiffResult } from "../src/protocol";
 import { taskWorkspaceDir } from "./env";
 import {
   parseGitDiff,
   runGitDiff,
-  runGitDiffInContainer,
+  runGitDiffInEnvironment,
   runGitDiffUntracked,
-  runGitDiffUntrackedInContainer,
+  runGitDiffUntrackedInEnvironment,
+  tryRunGitTextInEnvironment,
 } from "./git-diff";
-import { getHostTask } from "./runtime-state";
+import type { TaskEnvironmentHandle } from "./task-environment/types";
 
 // Cap how many untracked files we render as new-file patches. Each is a
-// separate (in-container) git spawn, so a pathological untracked dir that
+// separate in-environment Git execution, so a pathological untracked dir that
 // slips past .gitignore shouldn't turn the diff into thousands of execs.
 const MAX_UNTRACKED = 200;
 
+export type TaskDiffEnvironment = Pick<
+  TaskEnvironmentHandle,
+  "descriptor" | "exec"
+>;
+
 export async function buildTaskDiff(
   input: TaskDiffInput,
+  environment: TaskDiffEnvironment | null = null,
 ): Promise<TaskDiffResult> {
+  if (
+    environment !== null &&
+    environment.descriptor.taskId !== input.taskId
+  ) {
+    throw new Error("task diff environment belongs to a different task");
+  }
   const workspaceRoot = taskWorkspaceDir(input.taskId);
-  const runtime = getHostTask(input.taskId);
-  const containerName =
-    runtime?.statusMirror === "running" && runtime.composeProject
-      ? `${runtime.composeProject}-app-1`
-      : null;
   const out: TaskDiffResult["repos"] = [];
 
   for (const project of input.projects) {
     const cwd = join(workspaceRoot, project.slug);
-    const containerCwd = `/workspace/${project.slug}`;
-    if (!containerName && !existsSync(cwd)) continue;
+    const environmentCwd = environment
+      ? posix.join(environment.descriptor.workspacePath, project.slug)
+      : null;
+    if (!environment && !existsSync(cwd)) continue;
 
     // Base branch is the remote's default branch (where task branches are cut
     // from at task-up) — NOT the worktree's @{upstream}, which flips to
     // origin/<task-branch> once the branch is pushed and would then hide all
     // committed work (see resolveBase).
-    const base = resolveBase(containerName, cwd, containerCwd, project.slug);
+    const base = await resolveBase(environment, cwd, environmentCwd);
     // Diff the whole branch against base, including UNCOMMITTED work: compare
     // the merge-base (where the branch diverged) to the WORKING TREE, not HEAD.
     // The merge-base keeps base's own later commits from showing up reversed if
     // it advanced; falling back to `base` itself if merge-base can't resolve.
     const mergeBase =
-      runGitText(containerName, cwd, containerCwd, [
+      (await runGitText(environment, cwd, environmentCwd, [
         "merge-base",
         base,
         "HEAD",
-      ]) ?? base;
+      ])) ?? base;
     try {
       // Tracked changes (committed + staged + unstaged): a commit-ish vs the
       // working tree, so omitting `..HEAD` is the point.
-      let text = containerName
-        ? await runGitDiffInContainer(containerName, containerCwd, mergeBase)
+      let text = environment
+        ? await runGitDiffInEnvironment(
+            environment,
+            environmentCwd!,
+            mergeBase,
+          )
         : await runGitDiff(cwd, mergeBase);
 
       // Untracked files: `git diff <commit>` skips them, so list (honouring
       // .gitignore) and append each as a /dev/null new-file patch.
-      const untracked = listUntracked(containerName, cwd, containerCwd);
+      const untracked = await listUntracked(
+        environment,
+        cwd,
+        environmentCwd,
+      );
       for (const file of untracked) {
-        const patch = containerName
-          ? await runGitDiffUntrackedInContainer(containerName, containerCwd, file)
+        const patch = environment
+          ? await runGitDiffUntrackedInEnvironment(
+              environment,
+              environmentCwd!,
+              file,
+            )
           : await runGitDiffUntracked(cwd, file);
         if (patch.trim().length === 0) continue;
         if (text.length > 0 && !text.endsWith("\n")) text += "\n";
@@ -93,7 +115,7 @@ export async function buildTaskDiff(
 /**
  * Resolve the diff base for a worktree: the remote's default branch
  * (`origin/HEAD`, set at task-up via `remote set-head`), falling back to
- * `origin/main`. Runs git in-container when the task is live so credential
+ * `origin/main`. Runs Git in-environment when the task is live so credential
  * behavior stays inside the sandbox (see git-diff).
  *
  * We deliberately do NOT use the worktree's `@{upstream}`. At task-up it is
@@ -102,16 +124,15 @@ export async function buildTaskDiff(
  * `merge-base(upstream, HEAD) ≈ HEAD`, so the diff would show only uncommitted
  * work instead of the whole branch.
  */
-function resolveBase(
-  containerName: string | null,
+async function resolveBase(
+  environment: TaskDiffEnvironment | null,
   hostCwd: string,
-  containerCwd: string,
-  _slug: string,
-): string {
-  const head = runGitText(
-    containerName,
+  environmentCwd: string | null,
+): Promise<string> {
+  const head = await runGitText(
+    environment,
     hostCwd,
-    containerCwd,
+    environmentCwd,
     ["rev-parse", "--abbrev-ref", "origin/HEAD"],
   );
   if (head) return head;
@@ -127,12 +148,12 @@ function stripOriginPrefix(ref: string): string {
  * List untracked files in the worktree, honouring .gitignore
  * (`--exclude-standard`), capped at {@link MAX_UNTRACKED}. Empty on error.
  */
-function listUntracked(
-  containerName: string | null,
+async function listUntracked(
+  environment: TaskDiffEnvironment | null,
   hostCwd: string,
-  containerCwd: string,
-): string[] {
-  const raw = runGitText(containerName, hostCwd, containerCwd, [
+  environmentCwd: string | null,
+): Promise<string[]> {
+  const raw = await runGitText(environment, hostCwd, environmentCwd, [
     "ls-files",
     "--others",
     "--exclude-standard",
@@ -145,23 +166,22 @@ function listUntracked(
 }
 
 /**
- * Run a read-only git command (host or in-container) and return trimmed
+ * Run a read-only Git command (host or in-environment) and return trimmed
  * stdout, or null on any failure. Used for base-branch resolution where a
  * missing upstream is expected, not exceptional.
  */
-function runGitText(
-  containerName: string | null,
+async function runGitText(
+  environment: TaskDiffEnvironment | null,
   hostCwd: string,
-  containerCwd: string,
+  environmentCwd: string | null,
   args: string[],
-): string | null {
-  const result = containerName
-    ? spawnSync(
-        "docker",
-        ["exec", "-w", containerCwd, containerName, "git", ...args],
-        { encoding: "utf8" },
-      )
-    : spawnSync("git", ["-C", hostCwd, ...args], { encoding: "utf8" });
+): Promise<string | null> {
+  if (environment) {
+    return tryRunGitTextInEnvironment(environment, environmentCwd!, args);
+  }
+  const result = spawnSync("git", ["-C", hostCwd, ...args], {
+    encoding: "utf8",
+  });
   if (result.status !== 0) return null;
   const text = (result.stdout ?? "").trim();
   return text.length > 0 ? text : null;