@runuai/host 0.8.23 → 0.8.25

package/lib/agent.ts

@@ -178,9 +178,13 @@ async function runAgent<T extends z.ZodTypeAny>(
     if (parsed) {
       const failure = FailureEnvelope.safeParse(parsed);
       if (failure.success) {
+        // Prefer the actual tool output over the bash envelope's generic
+        // "agent step failed" — the docker/git/apt error is what the operator
+        // needs, and it must reach the cloud, not just the host log.
+        const detail = toolStderrDetail(stderrBuf);
         throw new AgentError(
           failure.data.error.code,
-          failure.data.error.message,
+          detail || failure.data.error.message,
           {
             step: failure.data.error.step,
             exitCode: failure.data.error.exit_code ?? exitCode,
@@ -236,6 +240,28 @@ function tryParseLastJsonLine(buf: string): unknown {
   return null;
 }
 
+/**
+ * The FAILING TOOL's output from a script's stderr — the docker/git/apt lines
+ * that actually say WHY a step failed, dropping our own `[uai-agent] step:`
+ * breadcrumbs and the `{"ok":false,…}` envelope. The bash envelope's message
+ * is generic ("agent step failed"); this is what makes it specific so the
+ * reason reaches the cloud UI instead of only the host log — useless when the
+ * host is a remote user's machine (live 2026-07-22, "compose_up_failed" with
+ * no why). Bounded to the last few lines so a build log doesn't flood the UI.
+ */
+export function toolStderrDetail(stderr: string): string {
+  const lines = stderr
+    .split(/\r?\n/)
+    .map((l) => l.replace(/\s+$/, ""))
+    .filter((l) => l.trim().length > 0)
+    .filter((l) => !l.startsWith("[uai-agent"))
+    .filter((l) => !l.trimStart().startsWith('{"ok"'));
+  return lines
+    .slice(-6)
+    .map((l) => (l.length > 300 ? `${l.slice(0, 300)}…` : l))
+    .join("\n");
+}
+
 // ---------------------------------------------------------------------------
 // Public API. One function per agent command.
 // ---------------------------------------------------------------------------

package/lib/git-identity.ts

@@ -123,38 +123,86 @@ export async function injectSshIdentity(
   return true;
 }
 
+// One in-flight ensure per task. Channel-ensure fires on every reconnect/
+// nudge (seconds apart under load), and `docker cp` is unlink+create — two
+// concurrent injects interleave so one's `cp id_ed25519` lands AFTER the
+// other's chown, leaving the private key owned by the macOS uid and
+// UNREADABLE by node inside the container ("Load key: Permission denied",
+// live 2026-07-21). Serialize, and skip entirely when the key is already
+// good, so the steady state does zero docker work.
+const sshEnsureInFlight = new Set<string>();
+
+/** True when node can already read a correctly-owned key in the container. */
+async function sshKeyHealthy(
+  taskId: string,
+  exec: DockerExec,
+): Promise<boolean> {
+  const res = await exec([
+    "exec",
+    "-u",
+    "node",
+    `task-${taskId}-app-1`,
+    "test",
+    "-r",
+    "/home/node/.ssh/id_ed25519",
+  ]);
+  return res.status === 0;
+}
+
 /**
- * Materialize the task creator's SSH key (operator identity as fallback,
- * mirroring task-up.sh), inject it + its git config into the container, and
- * clean the on-disk private key back up. Safe to call on every channel
- * ensure; a task with no identity anywhere logs once and pushes stay HTTPS.
+ * Ensure the task container has a node-readable SSH push identity + git
+ * config. Idempotent and race-free: skips the copy when the key is already
+ * healthy (the common case), and never runs two injects for one task at
+ * once. Only (re)materializes + copies the key when it is missing or
+ * unreadable. Safe to call on every channel ensure.
  */
 export async function ensureTaskSshIdentity(
   taskId: string,
   ownerUserId: string | null | undefined,
   exec: DockerExec = defaultExec,
 ): Promise<boolean> {
-  let keyPath: string | null = null;
-  let perTask = false;
-  const dir = writeTaskIdentity(taskId, ownerUserId);
-  if (dir) {
-    keyPath = resolve(dir, "id_ed25519");
-    perTask = true;
-  } else {
-    const operatorKey = resolve(env.dataDir, "identity", "id_ed25519");
-    if (existsSync(operatorKey)) keyPath = operatorKey;
-  }
-  if (!keyPath) {
-    console.log(
-      `[ssh] task ${taskId}: no SSH identity for owner or operator — git pushes stay on HTTPS`,
-    );
-    return false;
-  }
+  if (sshEnsureInFlight.has(taskId)) return true; // another ensure owns it
+  sshEnsureInFlight.add(taskId);
   try {
-    return await injectSshIdentity(taskId, keyPath, exec);
+    // Fast path: key already good → re-assert only the (cheap, idempotent)
+    // git config and skip the docker cp churn that causes the ownership race.
+    if (await sshKeyHealthy(taskId, exec)) {
+      await exec([
+        "exec",
+        "-u",
+        "node",
+        `task-${taskId}-app-1`,
+        "sh",
+        "-c",
+        SSH_GIT_CONFIG,
+      ]);
+      return true;
+    }
+
+    let keyPath: string | null = null;
+    let perTask = false;
+    const dir = writeTaskIdentity(taskId, ownerUserId);
+    if (dir) {
+      keyPath = resolve(dir, "id_ed25519");
+      perTask = true;
+    } else {
+      const operatorKey = resolve(env.dataDir, "identity", "id_ed25519");
+      if (existsSync(operatorKey)) keyPath = operatorKey;
+    }
+    if (!keyPath) {
+      console.log(
+        `[ssh] task ${taskId}: no SSH identity for owner or operator — git pushes stay on HTTPS`,
+      );
+      return false;
+    }
+    try {
+      return await injectSshIdentity(taskId, keyPath, exec);
+    } finally {
+      // Host hygiene (same as task-up): the materialized private key never
+      // outlives the injection.
+      if (perTask) removeTaskIdentity(taskId);
+    }
   } finally {
-    // Host hygiene (same as task-up): the materialized private key never
-    // outlives the injection.
-    if (perTask) removeTaskIdentity(taskId);
+    sshEnsureInFlight.delete(taskId);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.23",
+  "version": "0.8.25",
   "description": "Uai host — runs ephemeral AI coding tasks in Docker on a machine you control.",
   "license": "MIT",
   "author": "Diogo Perillo <diogo.perillo@gmail.com>",