@runuai/host 0.9.69 → 0.9.70

package/lib/machine-provider-local.ts

@@ -35,13 +35,23 @@ type Runner = (args: string[]) => Promise<DockerResult>;
 const defaultRunner: Runner = (args) => dockerCli(args, { timeoutMs: 60_000 });
 
 function machineAbsent(id: string, res: DockerResult): boolean {
+  // Daemons vary the casing of the not-found line — Docker Desktop answers
+  // "Error: No such object:", OrbStack "error: no such object:" (caught
+  // live in the first smoke run: the machine WAS gone and the proof
+  // refused it). The prefix is matched case-insensitively; the id itself
+  // stays exact — a not-found for "<id>-shadow" still proves nothing.
+  // OrbStack also answers with "[]" on stdout beside the error (Docker
+  // Desktop prints nothing) — an empty JSON array carries no confusable
+  // record, so both are admissible; anything else on stdout is not.
+  const stdout = res.stdout.trim();
   return (
     typeof res.status === "number" &&
     res.status !== 0 &&
-    res.stdout.trim() === "" &&
-    res.stderr
-      .split("\n")
-      .some((line) => line.trim() === `Error: No such object: ${id}`)
+    (stdout === "" || stdout === "[]") &&
+    res.stderr.split("\n").some((line) => {
+      const match = /^error: no such object: (.+)$/i.exec(line.trim());
+      return match !== null && match[1] === id;
+    })
   );
 }
 
@@ -66,6 +76,7 @@ interface InspectShape {
   taskLabel: string | null;
   state: MachineState;
   address: string | null;
+  sshPort: number | null;
 }
 
 /** Strict single-record parse. Exactly one record whose Name is the
@@ -94,12 +105,19 @@ function parseInspect(id: string, stdout: string): InspectShape | null {
     if (value !== undefined && typeof value !== "string") return null;
     taskLabel = typeof value === "string" ? value : null;
   }
-  const networks = (
+  const settings = (
     record as {
-      NetworkSettings?: { Networks?: Record<string, { IPAddress?: unknown }> };
+      NetworkSettings?: {
+        Networks?: Record<string, { IPAddress?: unknown }>;
+        Ports?: Record<
+          string,
+          Array<{ HostIp?: unknown; HostPort?: unknown }> | null
+        >;
+      };
     }
-  ).NetworkSettings?.Networks;
+  ).NetworkSettings;
   let address: string | null = null;
+  const networks = settings?.Networks;
   if (networks && typeof networks === "object") {
     for (const net of Object.values(networks)) {
       const ip = net?.IPAddress;
@@ -109,11 +127,29 @@ function parseInspect(id: string, stdout: string): InspectShape | null {
       }
     }
   }
+  // A published SSH port (macOS mode) supersedes the bridge IP: the bridge
+  // address exists but is unreachable from the Mac, and half-truthful
+  // reachability info is worse than none.
+  let sshPort: number | null = null;
+  const published = settings?.Ports?.["22/tcp"];
+  if (Array.isArray(published)) {
+    for (const binding of published) {
+      const port = Number(binding?.HostPort);
+      if (Number.isInteger(port) && port > 0) {
+        address = typeof binding?.HostIp === "string" && binding.HostIp.length > 0
+          ? binding.HostIp
+          : "127.0.0.1";
+        sshPort = port;
+        break;
+      }
+    }
+  }
   return {
     name,
     taskLabel,
     state: stateFromDocker(stateObj?.Status),
     address,
+    sshPort,
   };
 }
 
@@ -136,6 +172,9 @@ export function createLocalMachineProvider(
         taskLabel: record.taskLabel,
         state: record.state,
         address: record.state === "running" ? record.address : null,
+        ...(record.state === "running" && record.sshPort !== null
+          ? { sshPort: record.sshPort }
+          : {}),
       };
     }
     if (machineAbsent(id, res)) {
@@ -163,6 +202,15 @@ export function createLocalMachineProvider(
         String(spec.cpus),
         "--memory",
         `${spec.memoryMiB}m`,
+        // The image's entrypoint installs this for the ssh user before sshd
+        // starts — the local analog of cloud user-data key delivery.
+        ...(spec.authorizedPublicKey
+          ? ["-e", `UAI_AUTHORIZED_KEY=${spec.authorizedPublicKey}`]
+          : []),
+        // macOS: bridge IPs are not host-routable; SSH rides a
+        // loopback-published ephemeral port instead (never exposed beyond
+        // 127.0.0.1).
+        ...(spec.publishSsh ? ["-p", "127.0.0.1:0:22"] : []),
         spec.image,
         ...(spec.command ?? []),
       ];
@@ -275,6 +323,9 @@ export function createLocalMachineProvider(
           taskLabel: record.taskLabel,
           state: record.state,
           address: record.state === "running" ? record.address : null,
+          ...(record.state === "running" && record.sshPort !== null
+            ? { sshPort: record.sshPort }
+            : {}),
         });
       }
       return machines;

package/lib/machine-provider.ts

@@ -35,6 +35,14 @@ export interface MachineSpec {
   /** Optional long-running entrypoint override (the local backend's images
    * must keep the machine alive themselves — typically sshd). */
   command?: string[];
+  /** Public key the machine authorizes for the orchestrator's SSH access.
+   * Cloud backends deliver it via instance user-data; the local backend via
+   * an env var its image's entrypoint installs. */
+  authorizedPublicKey?: string;
+  /** Local backend on macOS only: container bridge IPs are not
+   * host-routable there, so SSH must ride a loopback-published port. The
+   * Linux guinea pig and cloud backends dial the address directly. */
+  publishSsh?: boolean;
 }
 
 export interface MachineInfo {
@@ -50,6 +58,8 @@ export interface MachineInfo {
    * reachable; container bridge IPs are NOT host-routable from macOS —
    * the local backend is for the Linux guinea pig, not Mac hosts. */
   address: string | null;
+  /** SSH port when it differs from 22 (local backend with `publishSsh`). */
+  sshPort?: number;
   /** Present only alongside `unknown` — what the backend actually said. */
   detail?: string;
 }

package/lib/task-environment/apple-container.ts

@@ -22,6 +22,10 @@ import { lstatSync } from "node:fs";
 import path from "node:path";
 
 import type { TaskDownResult } from "../agent";
+import {
+  hostWorkspaceRead,
+  hostWorkspaceWrite,
+} from "./workspace-files";
 import { assertSafeHostTaskId } from "../task-identity";
 import {
   capturedCliExec,
@@ -272,6 +276,23 @@ class AppleContainerTaskEnvironmentHandle
     };
   }
 
+  async readWorkspaceFile(filePath: string): Promise<Uint8Array | null> {
+    return hostWorkspaceRead(
+      this.descriptor,
+      path.join(this.#value.hostWorktreePath, "workspace"),
+      filePath,
+    );
+  }
+
+  async writeWorkspaceFile(filePath: string, bytes: Uint8Array): Promise<void> {
+    hostWorkspaceWrite(
+      this.descriptor,
+      path.join(this.#value.hostWorktreePath, "workspace"),
+      filePath,
+      bytes,
+    );
+  }
+
   exec(request: TaskEnvironmentExecRequest): Promise<TaskEnvironmentExecResult> {
     assertTaskEnvironmentProcessRequest(request);
     return capturedCliExec(

package/lib/task-environment/docker.ts

@@ -15,6 +15,10 @@ import {
   type TaskUpResult,
 } from "../agent";
 import { dockerCli, type DockerResult } from "../docker-exec";
+import {
+  hostWorkspaceRead,
+  hostWorkspaceWrite,
+} from "./workspace-files";
 import { taskDir } from "../env";
 import { PREVIEW_SIDECAR_TASK_LABEL } from "../preview-sidecar";
 import { assertSafeHostTaskId } from "../task-identity";
@@ -271,6 +275,23 @@ class DockerTaskEnvironmentHandle
     };
   }
 
+  async readWorkspaceFile(filePath: string): Promise<Uint8Array | null> {
+    return hostWorkspaceRead(
+      this.descriptor,
+      path.join(this.#value.hostWorktreePath, "workspace"),
+      filePath,
+    );
+  }
+
+  async writeWorkspaceFile(filePath: string, bytes: Uint8Array): Promise<void> {
+    hostWorkspaceWrite(
+      this.descriptor,
+      path.join(this.#value.hostWorktreePath, "workspace"),
+      filePath,
+      bytes,
+    );
+  }
+
   exec(request: TaskEnvironmentExecRequest): Promise<TaskEnvironmentExecResult> {
     assertTaskEnvironmentProcessRequest(request);
     return capturedCliExec(