@pushpalsdev/cli 1.0.47 → 1.0.49

package/dist/pushpals-cli.js

@@ -1523,6 +1523,9 @@ var MONITOR_POLL_MS = 2000;
 var HTTP_TIMEOUT_MS = 2500;
 var LOCALBUDDY_TIMEOUT_MS = 4000;
 var SSE_RECONNECT_MS = 1500;
+var DOCKER_VERSION_PROBE_TIMEOUT_MS = 1e4;
+var WORKERPAL_IMAGE_INSPECT_TIMEOUT_MS = 15000;
+var WORKERPAL_IMAGE_BUILD_TIMEOUT_MS = 10 * 60000;
 var DEFAULT_RUNTIME_BOOT_TIMEOUT_MS = 90000;
 var DEFAULT_RUNTIME_BOOT_POLL_MS = 1000;
 var DEFAULT_SERVER_BOOT_TIMEOUT_MS = 20000;
@@ -2948,7 +2951,7 @@ async function resolveWorkerpalDockerProbe(cwd, env, platform = process.platform
   const candidates = resolveRuntimeDockerExecutableCandidates(env, platform);
   const failures = [];
   for (const candidate of candidates) {
-    const result = await runCommandWithEnv([candidate, "version", "--format", "{{.Server.Version}}"], cwd, env);
+    const result = await runCommandWithEnv([candidate, "version", "--format", "{{.Server.Version}}"], cwd, env, DOCKER_VERSION_PROBE_TIMEOUT_MS);
     if (result.ok) {
       const version = result.stdout.trim();
       return {
@@ -3127,7 +3130,10 @@ async function cleanupLingeringPushPalsGitWorktrees(opts) {
     removed
   };
 }
-async function inspectDockerImageRuntimeTag(dockerExecutable, imageName, cwd, env) {
+function isMissingDockerImageDetail(detail) {
+  return /\b(no such object|no such image|not found)\b/i.test(String(detail ?? ""));
+}
+async function inspectDockerImageRuntimeTag(dockerExecutable, imageName, cwd, env, timeoutMs = WORKERPAL_IMAGE_INSPECT_TIMEOUT_MS) {
   const inspect = await runCommandWithEnv([
     dockerExecutable,
     "image",
@@ -3135,11 +3141,23 @@ async function inspectDockerImageRuntimeTag(dockerExecutable, imageName, cwd, en
     "--format",
     `{{ index .Config.Labels "${WORKERPAL_SANDBOX_RUNTIME_TAG_LABEL}" }}`,
     imageName
-  ], cwd, env);
-  if (!inspect.ok)
-    return "";
+  ], cwd, env, timeoutMs);
+  if (!inspect.ok) {
+    const detail = inspect.stderr || inspect.stdout || `exit ${inspect.exitCode}`;
+    if (isMissingDockerImageDetail(detail)) {
+      return { status: "missing", runtimeTag: "" };
+    }
+    return {
+      status: "failed",
+      runtimeTag: "",
+      detail: `failed to inspect local WorkerPal sandbox image ${imageName}: ${detail}`
+    };
+  }
   const value = inspect.stdout.trim();
-  return value === "<no value>" ? "" : value;
+  return {
+    status: "ok",
+    runtimeTag: value === "<no value>" ? "" : value
+  };
 }
 async function ensureWorkerpalDockerImageReady(opts) {
   const runtimeTag = String(opts.runtimeTag ?? "").trim();
@@ -3160,14 +3178,20 @@ async function ensureWorkerpalDockerImageReady(opts) {
   const dockerExecutable = resolveConfiguredDockerExecutable(opts.env, opts.platform ?? process.platform);
   const inspectImageRuntimeTagFn = opts.inspectImageRuntimeTagFn ?? inspectDockerImageRuntimeTag;
   const runCommandWithEnvFn = opts.runCommandWithEnvFn ?? runCommandWithEnv;
-  const existingRuntimeTag = await inspectImageRuntimeTagFn(dockerExecutable, opts.dockerImage, sandbox.root, opts.env);
-  if (existingRuntimeTag === runtimeTag) {
+  console.log(`[pushpals] Checking WorkerPal sandbox image ${opts.dockerImage} for runtimeTag=${runtimeTag}...`);
+  const inspection = await inspectImageRuntimeTagFn(dockerExecutable, opts.dockerImage, sandbox.root, opts.env);
+  const inspectFailureDetail = inspection.status === "failed" ? inspection.detail : "";
+  const existingRuntimeTag = inspection.status === "ok" ? inspection.runtimeTag : "";
+  if (inspection.status === "ok" && existingRuntimeTag === runtimeTag) {
     return {
       ok: true,
       detail: `WorkerPal sandbox image is ready locally (${opts.dockerImage}, runtimeTag=${runtimeTag})`
     };
   }
-  console.log(existingRuntimeTag ? `[pushpals] WorkerPal sandbox image ${opts.dockerImage} is stale (runtimeTag=${existingRuntimeTag}); rebuilding locally...` : `[pushpals] WorkerPal sandbox image ${opts.dockerImage} is missing; building locally...`);
+  if (inspectFailureDetail) {
+    console.warn(`[pushpals] ${inspectFailureDetail}`);
+  }
+  console.log(inspectFailureDetail ? `[pushpals] WorkerPal sandbox image ${opts.dockerImage} could not be inspected; attempting local rebuild...` : existingRuntimeTag ? `[pushpals] WorkerPal sandbox image ${opts.dockerImage} is stale (runtimeTag=${existingRuntimeTag}); rebuilding locally...` : `[pushpals] WorkerPal sandbox image ${opts.dockerImage} is missing; building locally...`);
   const build = await runCommandWithEnvFn([
     dockerExecutable,
     "build",
@@ -3180,17 +3204,17 @@ async function ensureWorkerpalDockerImageReady(opts) {
     "-t",
     opts.dockerImage,
     "."
-  ], sandbox.root, opts.env);
+  ], sandbox.root, opts.env, WORKERPAL_IMAGE_BUILD_TIMEOUT_MS);
   if (!build.ok) {
     const detail = build.stderr || build.stdout || `docker build exited ${build.exitCode}`;
     return {
       ok: false,
-      detail: `failed to build local WorkerPal sandbox image ${opts.dockerImage}: ${detail}`
+      detail: inspectFailureDetail ? `${inspectFailureDetail}; failed to build local WorkerPal sandbox image ${opts.dockerImage}: ${detail}` : `failed to build local WorkerPal sandbox image ${opts.dockerImage}: ${detail}`
     };
   }
   return {
     ok: true,
-    detail: `built local WorkerPal sandbox image ${opts.dockerImage} for runtimeTag=${runtimeTag}`
+    detail: inspectFailureDetail ? `rebuilt local WorkerPal sandbox image ${opts.dockerImage} for runtimeTag=${runtimeTag} after image inspection failed` : `built local WorkerPal sandbox image ${opts.dockerImage} for runtimeTag=${runtimeTag}`
   };
 }
 async function prepareEmbeddedWorkerpalDockerImageIfNeeded(opts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

package/runtime/sandbox/apps/workerpals/src/docker_executor.ts

@@ -40,6 +40,9 @@ const DEFAULT_CONFIG = loadPushPalsConfig();
 const SHARED_CONTAINER_VENV_PYTHON = "/workspace/.venv/bin/python";
 const WORKERPAL_SANDBOX_RUNTIME_TAG_LABEL = "pushpals.runtime_tag";
 const WORKERPAL_SANDBOX_COMPONENT_LABEL = "pushpals.component=workerpals-sandbox";
+const DOCKER_IMAGE_INSPECT_TIMEOUT_MS = 15_000;
+const DOCKER_IMAGE_BUILD_TIMEOUT_MS = 10 * 60_000;
+const DOCKER_IMAGE_PULL_TIMEOUT_MS = 10 * 60_000;
 
 function parseClampedInt(value: unknown, defaultValue: number, min: number, max: number): number {
   const parsed =
@@ -99,6 +102,10 @@ function dockerBuildFileArg(root: string, dockerfilePath: string): string {
   return relativePath || "apps/workerpals/Dockerfile.sandbox";
 }
 
+function isMissingDockerImageDetail(detail: string): boolean {
+  return /\b(no such object|no such image|not found)\b/i.test(String(detail ?? ""));
+}
+
 type ParsedWorktreeRecord = {
   path: string;
   detached: boolean;
@@ -1530,6 +1537,45 @@ export class DockerExecutor {
     await new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
   }
 
+  private async runDockerCommandCapture(
+    command: string[],
+    opts: { cwd?: string; timeoutMs?: number } = {},
+  ): Promise<{ stdout: string; stderr: string; exitCode: number; timedOut: boolean }> {
+    const proc = Bun.spawn(command, {
+      cwd: opts.cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    let timedOut = false;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    if (
+      typeof opts.timeoutMs === "number" &&
+      Number.isFinite(opts.timeoutMs) &&
+      opts.timeoutMs > 0
+    ) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        try {
+          proc.kill();
+        } catch {
+          // best-effort timeout termination only
+        }
+      }, opts.timeoutMs);
+    }
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    if (timer) clearTimeout(timer);
+    return {
+      stdout: stdout.trim(),
+      stderr: stderr.trim(),
+      exitCode,
+      timedOut,
+    };
+  }
+
   private compactError(err: unknown): string {
     const text = err instanceof Error ? err.message : String(err);
     const normalized = text.replace(/\s+/g, " ").trim();
@@ -1862,19 +1908,21 @@ export class DockerExecutor {
     console.log(
       `[DockerExecutor] Local image is unavailable or unsuitable. Pulling: ${this.options.imageName}`,
     );
-    const proc = Bun.spawn([resolveDockerExecutable(), "pull", this.options.imageName], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const exitCode = await proc.exited;
-    if (exitCode === 0) {
+    const pull = await this.runDockerCommandCapture(
+      [resolveDockerExecutable(), "pull", this.options.imageName],
+      { timeoutMs: DOCKER_IMAGE_PULL_TIMEOUT_MS },
+    );
+    if (!pull.timedOut && pull.exitCode === 0) {
       console.log(`[DockerExecutor] Image pulled successfully`);
       return true;
     }
 
-    const stderr = (await new Response(proc.stderr).text()).trim();
-    console.error(`[DockerExecutor] Failed to pull image: ${stderr}`);
+    const detail = pull.stderr || pull.stdout || `docker pull exited ${pull.exitCode}`;
+    console.error(
+      `[DockerExecutor] Failed to pull image: ${
+        pull.timedOut ? `timed out after ${DOCKER_IMAGE_PULL_TIMEOUT_MS}ms` : detail
+      }`,
+    );
 
     // Another process may have built/pulled the image while this pull was running.
     if (await this.imageExists()) {
@@ -1891,19 +1939,21 @@ export class DockerExecutor {
    * Check if the Docker image exists locally
    */
   private async imageExists(): Promise<boolean> {
-    const proc = Bun.spawn(
+    const result = await this.runDockerCommandCapture(
       [resolveDockerExecutable(), "image", "inspect", this.options.imageName],
-      {
-        stdout: "pipe",
-        stderr: "pipe",
-      },
+      { timeoutMs: DOCKER_IMAGE_INSPECT_TIMEOUT_MS },
     );
-    const exitCode = await proc.exited;
-    return exitCode === 0;
+    if (result.timedOut) {
+      console.warn(
+        `[DockerExecutor] Timed out checking local image ${this.options.imageName}; treating it as unavailable and attempting rebuild.`,
+      );
+      return false;
+    }
+    return result.exitCode === 0;
   }
 
   private async inspectImageRuntimeTag(): Promise<string> {
-    const proc = Bun.spawn(
+    const result = await this.runDockerCommandCapture(
       [
         resolveDockerExecutable(),
         "image",
@@ -1912,14 +1962,24 @@ export class DockerExecutor {
         `{{ index .Config.Labels "${WORKERPAL_SANDBOX_RUNTIME_TAG_LABEL}" }}`,
         this.options.imageName,
       ],
-      {
-        stdout: "pipe",
-        stderr: "pipe",
-      },
+      { timeoutMs: DOCKER_IMAGE_INSPECT_TIMEOUT_MS },
     );
-    const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
-    if (exitCode !== 0) return "";
-    const value = stdout.trim();
+    if (result.timedOut) {
+      console.warn(
+        `[DockerExecutor] Timed out inspecting runtime tag for ${this.options.imageName}; treating the local image as stale and attempting rebuild.`,
+      );
+      return "";
+    }
+    if (result.exitCode !== 0) {
+      const detail = result.stderr || result.stdout || `exit ${result.exitCode}`;
+      if (!isMissingDockerImageDetail(detail)) {
+        console.warn(
+          `[DockerExecutor] Failed to inspect runtime tag for ${this.options.imageName}: ${detail}`,
+        );
+      }
+      return "";
+    }
+    const value = result.stdout.trim();
     return value === "<no value>" ? "" : value;
   }
 
@@ -1947,21 +2007,19 @@ export class DockerExecutor {
       this.options.imageName,
       ".",
     ];
-    const proc = Bun.spawn(args, {
+    const build = await this.runDockerCommandCapture(args, {
       cwd: sandboxContext.root,
-      stdout: "pipe",
-      stderr: "pipe",
+      timeoutMs: DOCKER_IMAGE_BUILD_TIMEOUT_MS,
     });
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited,
-    ]);
-    if (exitCode === 0) {
+    if (!build.timedOut && build.exitCode === 0) {
       return true;
     }
-    const detail = stderr.trim() || stdout.trim() || `docker build exited ${exitCode}`;
-    console.error(`[DockerExecutor] Failed to build local image: ${detail}`);
+    const detail = build.stderr || build.stdout || `docker build exited ${build.exitCode}`;
+    console.error(
+      `[DockerExecutor] Failed to build local image: ${
+        build.timedOut ? `timed out after ${DOCKER_IMAGE_BUILD_TIMEOUT_MS}ms` : detail
+      }`,
+    );
     return false;
   }