@runuai/host 0.8.25 → 0.8.27

package/lib/standard-image.ts

@@ -305,13 +305,22 @@ async function upgradeVolumeAgentClis(): Promise<void> {
   }
 }
 
+/** Outcome of ensureStandardImage — `error` carries WHY when not ready, so
+ *  the taskUp path can surface a build failure to the cloud (not just the host
+ *  log). Callers that only fire-and-forget at boot ignore the return. */
+export interface StandardImageResult {
+  ok: boolean;
+  error?: string;
+}
+
 /**
  * Ensure the standard image and the shared asdf data volume exist, and that the
  * agent CLIs are present inside the volume. Builds the image only when `docker
- * image inspect` fails. Best-effort: logs and continues on any error so the
- * host keeps booting.
+ * image inspect` fails or the content hash is stale. Never throws — returns
+ * `{ ok, error? }` so the caller decides (boot: fire-and-forget; taskUp:
+ * surface the reason).
  */
-export async function ensureStandardImage(): Promise<void> {
+export async function ensureStandardImage(): Promise<StandardImageResult> {
   // 1. Shared asdf data volume — idempotent.
   const vol = await run("docker", ["volume", "create", ASDF_DATA_VOLUME]);
   if (vol.code !== 0) {
@@ -321,7 +330,9 @@ export async function ensureStandardImage(): Promise<void> {
     );
     // If docker itself is unavailable, the image step will also fail; bail
     // early so we don't double-log a confusing build error.
-    if (vol.code === null) return;
+    if (vol.code === null) {
+      return { ok: false, error: "Docker is not available on this host." };
+    }
   }
 
   // 2. Ensure the image is built AND current. "Present" is not enough — a
@@ -330,6 +341,7 @@ export async function ensureStandardImage(): Promise<void> {
   //    landed). The build context is content-hashed into an image label;
   //    a mismatch triggers a rebuild (layer cache keeps it cheap).
   let imageReady = false;
+  let buildError: string | null = null;
   // Install only the optional engines the operator has configured; the flags
   // are build args AND part of the content hash (so a new login rebuilds).
   const engines = configuredOptionalEngines();
@@ -356,7 +368,7 @@ export async function ensureStandardImage(): Promise<void> {
       "[host-agent] docker unavailable; skipping standard image build. " +
         "Tasks will fail until docker is running.",
     );
-    return;
+    return { ok: false, error: "Docker is not available on this host." };
   }
   const labeledHash = inspect.code === 0 ? inspect.stdout.trim() : null;
   if (inspect.code === 0 && contextHash !== null && labeledHash === contextHash) {
@@ -387,10 +399,13 @@ export async function ensureStandardImage(): Promise<void> {
       console.log(`[host-agent] built standard image ${STANDARD_IMAGE_TAG}`);
       imageReady = true;
     } else {
+      buildError =
+        build.stderr.trim() ||
+        `docker build exited ${build.code ?? "spawn error"}`;
       console.warn(
         `[host-agent] standard image build failed (exit ${build.code ?? "spawn"}); ` +
           "continuing. Tasks needing the image will surface this error.\n" +
-          build.stderr.trim(),
+          buildError,
       );
       // A stale-but-working image is better than none.
       imageReady = labeledHash !== null;
@@ -402,5 +417,12 @@ export async function ensureStandardImage(): Promise<void> {
   if (imageReady) {
     await ensureVolumeAgentClis();
     await upgradeVolumeAgentClis();
+    return { ok: true };
   }
+  return {
+    ok: false,
+    error:
+      buildError ??
+      "the standard base image (uai-standard:dev) is not built and no build error was captured.",
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runuai/host",
-  "version": "0.8.25",
+  "version": "0.8.27",
   "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/scripts/agent/task-up.sh

@@ -322,6 +322,11 @@ fi
     printf '    image: %s\n' "$DERIVED_IMAGE"
   else
     printf '    image: %s\n' "$STANDARD_IMAGE"
+    # Never pull: the standard image is built LOCALLY by the host, not hosted
+    # on any registry. Without this, an absent image makes compose attempt a
+    # doomed registry pull ("pull access denied for uai-standard") instead of
+    # failing clearly (live 2026-07-22, a fresh host mid standard-image build).
+    printf '    pull_policy: never\n'
   fi
   printf '    init: true\n'
   printf '    working_dir: /workspace\n'
@@ -441,6 +446,18 @@ fi
 docker volume create "$ASDF_VOLUME" >/dev/null 2>&1 || true
 docker volume create "$PW_VOLUME" >/dev/null 2>&1 || true
 
+# The standard base image is built by the host (ensureStandardImage), never
+# pulled from a registry — and derived tasks FROM it too. If it's absent (the
+# host started before Docker was ready, or the build failed) compose would try
+# a doomed registry pull; fail with an actionable message instead (the host
+# also (re)builds it on demand before task-up — this is the belt-and-suspenders
+# check for a still-in-progress or failed build). Live 2026-07-22.
+if ! docker image inspect "$STANDARD_IMAGE" >/dev/null 2>&1; then
+  emit_err "STANDARD_IMAGE_MISSING" \
+    "the host base image $STANDARD_IMAGE is not built yet — the host builds it at startup (a few minutes on first run, and after Docker Desktop finishes starting). Wait for the host log line 'built standard image', or restart the host, then retry. If it keeps failing the host log shows the build error (often Docker Desktop low on memory/disk)." \
+    "check standard image"
+fi
+
 step "COMPOSE_UP_FAILED" "docker compose up -d"
 if [ "$has_derived" = "1" ]; then
   docker compose -p "$compose_project" -f "$task_uai_dir/docker-compose.yml" up -d --build >/dev/null

package/src/index.ts

@@ -1,4 +1,5 @@
-import { agent, AgentError } from "../lib/agent";
+import { agent, AgentError, toolStderrDetail } from "../lib/agent";
+import { ensureStandardImage } from "../lib/standard-image";
 import { cloneRepo } from "../lib/repo-clone";
 import { handleFilesOp } from "../lib/shared-files";
 import { getOrchestrator } from "../lib/orchestrator";
@@ -119,7 +120,27 @@ export const hostCommands: HostCommands = {
       storeTaskCliSecret(input.task.id, input.task.cliSecret);
     }
     recordHostEvent(input.task.id, "task.created");
-    const result = await wrapAgent(ctx, "taskUp", () => agent.taskUp(input));
+    const result = await wrapAgent(ctx, "taskUp", async () => {
+      // Self-heal the standard base image before task-up needs it. The
+      // boot-time build is best-effort + one-shot: a host that started before
+      // Docker was ready (common on Docker Desktop) never built
+      // uai-standard:dev, so every task-up died on a doomed registry pull
+      // (live 2026-07-22). This is idempotent — a fast inspect when present,
+      // a real build only when missing/stale (Docker is definitely up now, a
+      // task just arrived). On a build FAILURE, surface WHY to the cloud (not
+      // just the host log — the operator can't read a remote user's machine).
+      const img = await ensureStandardImage();
+      if (!img.ok) {
+        throw new AgentError(
+          "STANDARD_IMAGE_UNAVAILABLE",
+          img.error
+            ? `could not prepare the host base image uai-standard:dev — the build failed. ${toolStderrDetail(img.error)}`
+            : "could not prepare the host base image uai-standard:dev — see the host log.",
+          {},
+        );
+      }
+      return agent.taskUp(input);
+    });
     if (result.ok) {
       recordTaskUpResult(input.task.id, result.value);
       recordHostEvent(input.task.id, "task.started");