@runuai/host 0.9.72 → 0.9.74

package/lib/agents/machine-durable.ts

@@ -171,14 +171,16 @@ export class MachineDurableProcess implements LineTransport {
         (result) => {
           const stderr = Buffer.from(result.stderr).toString("utf8");
           if (stderr) this.#stderrBuf = (this.#stderrBuf + stderr).slice(-8192);
-          if (result.exitCode !== 0) this.#finish(null);
+          if (result.exitCode !== 0) {
+            this.#finish(null, `launch exited ${result.exitCode}`);
+          }
         },
         (error: unknown) => {
           this.#stderrBuf = (
             this.#stderrBuf +
             (error instanceof Error ? error.message : String(error))
           ).slice(-8192);
-          this.#finish(null);
+          this.#finish(null, "launch threw");
         },
       );
     } else {
@@ -306,7 +308,10 @@ export class MachineDurableProcess implements LineTransport {
         this.#stderrBuf = meta.stderrTail.slice(-8192);
       }
       if (this.#debug) this.#log(`exit meta: code ${meta.code ?? null}`);
-      this.#finish(typeof meta.code === "number" ? meta.code : null);
+      this.#finish(
+        typeof meta.code === "number" ? meta.code : null,
+        "runner exit meta",
+      );
     }
   }
 
@@ -317,7 +322,9 @@ export class MachineDurableProcess implements LineTransport {
     this.#probing = true;
     try {
       if (!this.#sawSpawnMeta) {
-        if (Date.now() - this.#startedAt > HEARTBEAT_STALE_MS) this.#finish(null);
+        if (Date.now() - this.#startedAt > HEARTBEAT_STALE_MS) {
+          this.#finish(null, "no spawn meta within grace");
+        }
         return;
       }
       const fresh = await machineHeartbeatFresh(
@@ -326,14 +333,19 @@ export class MachineDurableProcess implements LineTransport {
         HEARTBEAT_STALE_MS,
       );
       if (this.#closed || this.#detached) return;
-      if (!fresh) this.#finish(null);
+      if (!fresh) this.#finish(null, "heartbeat stale");
     } finally {
       this.#probing = false;
     }
   }
 
-  #finish(code: number | null): void {
+  #finish(code: number | null, reason = "unspecified"): void {
     if (this.#closed) return;
+    // Session deaths are load-bearing and were undiagnosable without this
+    // (live 2026-08-27: a 65s recycle loop with no trace). Always log.
+    console.warn(
+      `[machine-durable] session ${this.#sessionDir} finished (code ${code ?? "null"}): ${reason}`,
+    );
     this.#closed = true;
     this.#stopTimers();
     const tail = this.#tail;
@@ -421,7 +433,10 @@ export class MachineDurableProcess implements LineTransport {
     } catch {
       // Inbox unwritable — fall through to the grace timer.
     }
-    this.#closeTimer = setTimeout(() => this.#finish(null), CLOSE_GRACE_MS);
+    this.#closeTimer = setTimeout(
+      () => this.#finish(null, "close grace elapsed"),
+      CLOSE_GRACE_MS,
+    );
   }
 }
 

package/lib/machine-exec.ts

@@ -84,12 +84,20 @@ export function buildRemoteCommand(request: {
   const command = request.argv.map(shellQuote).join(" ");
   if (request.detached) {
     // Detached durable sessions manage their own transcript IO (runner.mjs);
-    // the launch just needs the process to survive this ssh connection:
-    // setsid detaches the controlling terminal, streams are severed, and the
-    // remote shell exits immediately with the launch verdict.
-    parts.push(`${envPrefix}setsid ${command} </dev/null >/dev/null 2>&1 &`);
-    parts.push("exit 0");
-    return parts.join(" ");
+    // the launch just needs the process to survive this ssh connection AND
+    // the connection to close immediately. The redirects must cover the
+    // WHOLE background job and the job must `exec` into the payload: with
+    // redirects on the inner command only, the waiting shell kept the ssh
+    // channel's stdout/stderr open until the runner died, so sshd never saw
+    // EOF and every launch rode its timeout into a false spawn failure
+    // (live 2026-08-27: a 65s session recycle loop on the second machine
+    // task; the first machine's stable session was an accident of its host
+    // dying seconds before the timeout could mark the row closed).
+    const body = [
+      ...(request.cwd ? [`cd ${shellQuote(request.cwd)} &&`] : []),
+      `exec ${envPrefix}setsid ${command}`,
+    ].join(" ");
+    return `{ ${body}; } </dev/null >/dev/null 2>&1 & exit 0`;
   }
   parts.push(`exec ${envPrefix}${command}`);
   return parts.join(" ");

package/lib/task-environment/machine-task-up.ts

@@ -15,12 +15,19 @@
  * directory that really does hold this task's host-side state — its machine
  * key). Consumers that need the workspace go through the environment handle.
  */
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
 import type {
   TaskDownResult,
   TaskLaunchInput,
   TaskUpCredentials,
   TaskUpResult,
 } from "../agent";
+import { sharedRoot } from "../shared-files";
 import {
   MACHINE_TASK_ENVIRONMENT_PROVIDER,
   parseMachineTaskEnvironmentLocator,
@@ -36,6 +43,9 @@ import type {
 
 /** In-machine clone budget per project. */
 const CLONE_TIMEOUT_MS = 10 * 60_000;
+/** The machine port code-server listens on (dialed directly by the editor
+ * tunnel via inspectRoute; never published). */
+export const MACHINE_CODE_SERVER_PORT = 8080;
 const GIT_STEP_TIMEOUT_MS = 60_000;
 const STEP_OUTPUT_BYTES = 256 * 1024;
 
@@ -223,6 +233,191 @@ async function cloneProject(
   return null;
 }
 
+/** The curated code-server defaults (slim chrome, telemetry off, trust
+ * off) — the SAME seed the standard image bakes; resolved from this package
+ * so machine and container editors can never diverge. Machines adjust two
+ * keys host-side: the task's ADR-091 theme, and bash for the terminal (the
+ * machine payload carries no zsh). */
+function editorSettingsSeed(editorTheme: string | undefined): string {
+  const seedPath = resolve(
+    dirname(fileURLToPath(import.meta.url)),
+    "..",
+    "..",
+    "images",
+    "standard",
+    "container",
+    "code-server-settings.json",
+  );
+  const seed = JSON.parse(readFileSync(seedPath, "utf8")) as Record<
+    string,
+    unknown
+  >;
+  if (editorTheme) seed["workbench.colorTheme"] = editorTheme;
+  seed["terminal.integrated.defaultProfile.linux"] = "bash";
+  return `${JSON.stringify(seed, null, 2)}\n`;
+}
+
+/** Seed the editor settings exactly once (an existing settings.json is the
+ * user's own state and is never touched — same contract as uai-init). */
+async function seedEditorSettings(
+  handle: TaskEnvironmentHandle<unknown>,
+  editorTheme: string | undefined,
+): Promise<void> {
+  const destination =
+    "/home/node/.local/share/code-server/User/settings.json";
+  await handle.exec({
+    argv: [
+      "/bin/sh",
+      "-c",
+      '[ -e "$1" ] && exit 0; mkdir -p "$(dirname "$1")" && cat > "$1"',
+      "seed",
+      destination,
+    ],
+    stdin: Buffer.from(editorSettingsSeed(editorTheme)),
+    timeoutMs: GIT_STEP_TIMEOUT_MS,
+    maxOutputBytes: STEP_OUTPUT_BYTES,
+  });
+}
+
+const execFileAsync = promisify(execFile);
+/** Shared-files snapshots are reference docs, not repos; a tree past this
+ * is skipped with a warning rather than ballooning host memory. */
+const SHARED_FILES_TAR_MAX_BYTES = 256 * 1024 * 1024;
+
+/**
+ * ADR-062 shared files on machines: containers get live bind mounts at
+ * /workspace/files/{org,me}; a machine shares no filesystem, so it gets a
+ * POINT-IN-TIME COPY at provision (tar streamed over the transport). The
+ * managed-hosting answer for live semantics is EFS (ADR-121); until then a
+ * snapshot with an honest note beats silently absent files.
+ * Returns a warning string when rw mode was requested (writes cannot sync
+ * back) or a scope was skipped; null when clean.
+ */
+async function copySharedFiles(
+  handle: TaskEnvironmentHandle<unknown>,
+  workspacePath: string,
+  task: { ownerOrgId?: string; ownerUserId: string; sharedFiles?: string },
+): Promise<string | null> {
+  const mode = task.sharedFiles ?? "ro";
+  if (mode === "off") return null;
+  const scopes: Array<{ host: string; destination: string }> = [];
+  if (task.ownerOrgId) {
+    scopes.push({
+      host: sharedRoot("org", task.ownerOrgId, task.ownerUserId),
+      destination: `${workspacePath}/files/org`,
+    });
+  }
+  scopes.push({
+    host: sharedRoot("me", task.ownerOrgId ?? "", task.ownerUserId),
+    destination: `${workspacePath}/files/me`,
+  });
+  const warnings: string[] = [];
+  let copiedAny = false;
+  for (const scope of scopes) {
+    if (!existsSync(scope.host) || readdirSync(scope.host).length === 0) {
+      continue;
+    }
+    try {
+      const tarball = await execFileAsync(
+        "tar",
+        ["-C", scope.host, "-cf", "-", "."],
+        { encoding: "buffer", maxBuffer: SHARED_FILES_TAR_MAX_BYTES },
+      );
+      const result = await handle.exec({
+        argv: [
+          "/bin/sh",
+          "-c",
+          'mkdir -p "$1" && tar -C "$1" -xf -',
+          "shared",
+          scope.destination,
+        ],
+        stdin: tarball.stdout,
+        timeoutMs: 5 * 60_000,
+        maxOutputBytes: STEP_OUTPUT_BYTES,
+      });
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `extract exited ${result.exitCode}: ${Buffer.from(result.stderr).toString("utf8").trim()}`,
+        );
+      }
+      copiedAny = true;
+    } catch (error) {
+      warnings.push(
+        `shared files: could not copy ${scope.destination}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  }
+  if (copiedAny || warnings.length === 0) {
+    // Marker gates the "## Shared files" preamble briefing, mirroring the
+    // container path's task-up marker.
+    await handle
+      .writeWorkspaceFile(`${workspacePath}/.uai/files-mounted`, Buffer.from(""))
+      .catch(() => {});
+  }
+  if (mode === "rw") {
+    warnings.push(
+      "shared files on this machine task are a point-in-time copy — " +
+        "changes under /workspace/files will NOT sync back to the host yet",
+    );
+  }
+  return warnings.length > 0 ? warnings.join("\n") : null;
+}
+
+/** Launch code-server for the Editor pane, exactly once. The pgrep guard
+ * makes re-provision and resume idempotent; the exec chain leaves only
+ * code-server holding the detached job. */
+async function ensureCodeServer(
+  handle: TaskEnvironmentHandle<unknown>,
+  workspacePath: string,
+  editorTheme: string | undefined,
+): Promise<void> {
+  // Settings before process: code-server reads them at startup. A failed
+  // seed still launches — a themed editor is worth less than one that starts.
+  await seedEditorSettings(handle, editorTheme).catch((error: unknown) => {
+    console.warn(
+      `[machine] editor settings seed failed: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  });
+  // The guard and the launch are SEPARATE execs on purpose: any guard that
+  // shares a cmdline with the launch text matches itself — the bracketed
+  // pattern alone did not save the first combined script, because the plain
+  // launch line later in the same argv still contained code-server +
+  // --bind-addr (live 2026-08-27, second silent skip).
+  const running = await handle.exec({
+    argv: [
+      "/bin/sh",
+      "-c",
+      'pgrep -f "[c]ode-server.*--bind-addr" >/dev/null 2>&1',
+    ],
+    timeoutMs: GIT_STEP_TIMEOUT_MS,
+    maxOutputBytes: STEP_OUTPUT_BYTES,
+  });
+  if (running.exitCode === 0) return;
+  const script =
+    "mkdir -p /home/node/.local/share/code-server && " +
+    "exec /home/node/.local/bin/code-server " +
+    "--user-data-dir /home/node/.local/share/code-server " +
+    "--disable-workspace-trust --auth none --disable-telemetry " +
+    `--disable-update-check --bind-addr 0.0.0.0:${MACHINE_CODE_SERVER_PORT} ` +
+    '"$1" >/tmp/code-server.log 2>&1';
+  const result = await handle.launchDetachedSession({
+    argv: ["/bin/sh", "-c", script, "code-server", workspacePath],
+    inheritEnv: [],
+    env: {},
+    launchTimeoutMs: 30_000,
+    maxOutputBytes: 64 * 1024,
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `code-server launch exited ${result.exitCode}: ${Buffer.from(result.stderr).toString("utf8").trim()}`,
+    );
+  }
+}
+
 /** Wrap the void-teardown machine handle so registry consumers get the
  * TaskDownResult contract the compose providers speak. */
 function withTaskDownResult(
@@ -249,6 +444,9 @@ function withTaskDownResult(
       await handle.teardown();
       return { status: "terminated" };
     },
+    ...(handle.inspectRoute
+      ? { inspectRoute: () => handle.inspectRoute!() }
+      : {}),
   };
 }
 
@@ -311,6 +509,36 @@ export function createMachineHostTaskEnvironmentProvider(
         throw error;
       }
 
+      // ADR-062 shared files: point-in-time copy (see copySharedFiles).
+      const sharedWarning = await copySharedFiles(handle, workspacePath, {
+        ...(input.task.ownerOrgId ? { ownerOrgId: input.task.ownerOrgId } : {}),
+        ownerUserId: input.task.ownerUserId,
+        ...(input.task.sharedFiles ? { sharedFiles: input.task.sharedFiles } : {}),
+      }).catch((error: unknown) => {
+        console.warn(
+          `[machine] task ${request.taskId}: shared files copy failed: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+        return null;
+      });
+      if (sharedWarning) warnings.push(sharedWarning);
+
+      // Editor pane: code-server on the machine (same flags as uai-init's
+      // container launch), idempotent across provision re-runs and resume.
+      // Best-effort — a missing binary degrades the Editor tab, never the task.
+      await ensureCodeServer(
+        handle,
+        workspacePath,
+        input.task.previewEnv?.UAI_EDITOR_THEME,
+      ).catch((error: unknown) => {
+        console.warn(
+          `[machine] task ${request.taskId}: code-server launch failed: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      });
+
       const machineId = parseMachineTaskEnvironmentLocator(
         handle.descriptor.locator,
       ).machineId;
@@ -319,6 +547,7 @@ export function createMachineHostTaskEnvironmentProvider(
         result: {
           composeProject: machineId,
           worktreePath: deps.taskControlDir(request.taskId),
+          codeServerPort: MACHINE_CODE_SERVER_PORT,
           ...(warnings.length > 0
             ? { initWarning: warnings.join("\n") }
             : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.9.72",
+  "version": "0.9.74",
   "description": "Uai host — runs ephemeral AI tasks in containers on a machine you control.",
   "license": "MIT",
   "author": "Uai Tech <team@runuai.com>",

package/src/index.ts

@@ -475,6 +475,7 @@ export const hostCommands: HostCommands = {
                 value: {
                   composeProject: existingTask.composeProject ?? "",
                   worktreePath: existingTask.worktreePath ?? "",
+                  codeServerPort: existingTask.codeServerPort ?? undefined,
                 },
               };
             }

package/src/main.ts

@@ -252,6 +252,12 @@ const bridgeUrl =
 let ws: WebSocket | null = null;
 let stopping = false;
 let fatal = false;
+/** Auth-rejected (4001) retry cadence. A genuinely revoked credential costs
+ * one connection attempt per interval; a transient rejection (the bridge's
+ * own DB down during a cloud restart, an auth frame lost on a slow link)
+ * heals without an operator visit — the 2026-08-27 outage stranded every
+ * connected host overnight because 4001 was treated as terminal. */
+const AUTH_REJECTED_RETRY_MS = 5 * 60_000;
 let reconnectAttempt = 0;
 let connectionRequestGeneration = 0;
 let inFlight = 0;
@@ -1642,12 +1648,16 @@ async function connect(): Promise<void> {
       return;
     }
     if (code === 4001) {
-      fatal = true;
       markDisconnected(text || "auth rejected by bridge");
       console.error(
-        `[host-agent] auth rejected by bridge${text ? `: ${text}` : ""}`,
+        `[host-agent] auth rejected by bridge${text ? `: ${text}` : ""} — retrying in ${Math.round(AUTH_REJECTED_RETRY_MS / 60_000)} minutes`,
       );
-      process.exitCode = 1;
+      addHostBreadcrumb("bridge", "auth-rejected", {
+        retryInMs: AUTH_REJECTED_RETRY_MS,
+      });
+      setTimeout(() => {
+        void connect();
+      }, AUTH_REJECTED_RETRY_MS);
       return;
     }
     const delay = reconnectDelay();
@@ -1966,6 +1976,26 @@ async function resolveTunnelTarget(
   // Persisted ports are meaningful only while the selected runtime is known
   // operational. After a daemon restart an unrelated local process could bind
   // a stale port before recovery refreshes the task's mappings.
+  const machineTask = getHostTask(frame.taskId);
+  if (machineTask?.environmentProvider === "machine") {
+    // ADR-121: a machine's address is orchestrator-routable (bridge IP on
+    // the Linux guinea pig, VPC-private on EC2) — editor and previews dial
+    // it straight via the handle's ownership-proven route, independent of
+    // the container runtime's health. macOS-local machines need a published
+    // fallback (bridge IPs are not host-routable there) — recorded ADR-121
+    // follow-up, not silently misrouted: the connect simply fails.
+    const environment = await reconstructPersistedTaskEnvironment(machineTask);
+    const route = environment?.inspectRoute
+      ? await environment.inspectRoute()
+      : null;
+    if (!route || route.kind !== "running") return null;
+    const port =
+      frame.target === "editor"
+        ? (machineTask.codeServerPort ?? null)
+        : (frame.containerPort ?? null);
+    if (!port) return null;
+    return { host: route.ipv4Address, port };
+  }
   if (containerRuntimeProblem()) return null;
   const task = getHostTask(frame.taskId);
   if (!task) return null;