@pushpalsdev/cli 1.0.33 → 1.0.35

package/package.json

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

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

@@ -236,6 +236,7 @@ export class DockerExecutor {
   private readonly jobRetryMaxAttempts: number;
   private readonly jobRetryBackoffMs: number;
   private readonly failureCooldownMs: number;
+  private readonly worktreeVisibilityTimeoutMs: number;
   private lastLoggedExecutionConfig = "";
   private lastLoggedEndpointRewrite = "";
   private warmedBackends = new Set<string>();
@@ -294,6 +295,7 @@ export class DockerExecutor {
       20_000,
       300_000,
     );
+    this.worktreeVisibilityTimeoutMs = process.platform === "win32" ? 15_000 : 5_000;
 
     // Ensure worktrees directory exists
     try {
@@ -416,7 +418,10 @@ export class DockerExecutor {
     try {
       await this.createWorktree(worktreePath, this.options.baseRef);
       await this.runGitSelfCheckContainer(worktreePath);
-      console.log(`[DockerExecutor] Startup self-check passed (git/worktree in container).`);
+      await this.ensureWorktreeAccessibleInWarmContainer(worktreePath);
+      console.log(
+        `[DockerExecutor] Startup self-check passed (git/worktree in container and warm container).`,
+      );
     } finally {
       await this.removeWorktree(worktreePath).catch(() => {
         // Ignore cleanup failures for startup self-check artifacts.
@@ -837,6 +842,41 @@ export class DockerExecutor {
     };
   }
 
+  private async runWarmWorktreeProbe(containerWorktreePath: string): Promise<{
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }> {
+    const proc = Bun.spawn(
+      [
+        resolveDockerExecutable(),
+        "exec",
+        "-w",
+        containerWorktreePath,
+        this.warmContainerName,
+        "/bin/sh",
+        "-lc",
+        "git rev-parse --is-inside-work-tree && git rev-parse --git-dir",
+      ],
+      {
+        stdout: "pipe",
+        stderr: "pipe",
+      },
+    );
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return {
+      ok: exitCode === 0,
+      stdout: stdout.trim(),
+      stderr: stderr.trim(),
+      exitCode,
+    };
+  }
+
   private async inspectWarmContainerState(): Promise<string> {
     const proc = Bun.spawn(
       [
@@ -1054,10 +1094,10 @@ export class DockerExecutor {
   ): Promise<DockerJobResult> {
     await this.ensureWarmRuntimeReady(job, onLog);
     const startedAtMs = Date.now();
-
-    const worktreeRelPath = relative(this.options.repo, worktreePath).replace(/\\/g, "/");
-    const containerWorktreePath = `/repo/${worktreeRelPath}`;
-    await this.waitForWorktreePathInWarmContainer(containerWorktreePath);
+    const containerWorktreePath = await this.ensureWorktreeAccessibleInWarmContainer(
+      worktreePath,
+      onLog,
+    );
 
     const args: string[] = [
       "exec",
@@ -1154,6 +1194,51 @@ export class DockerExecutor {
     );
   }
 
+  private async ensureWorktreeAccessibleInWarmContainer(
+    worktreePath: string,
+    onLog?: (stream: "stdout" | "stderr", line: string) => void,
+  ): Promise<string> {
+    const worktreeRelPath = relative(this.options.repo, worktreePath).replace(/\\/g, "/");
+    const containerWorktreePath = `/repo/${worktreeRelPath}`;
+    let lastError: unknown = null;
+
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        await this.ensureWarmContainer();
+        await this.waitForWorktreePathInWarmContainer(
+          containerWorktreePath,
+          this.worktreeVisibilityTimeoutMs,
+        );
+        const probe = await this.runWarmWorktreeProbe(containerWorktreePath);
+        if (probe.ok) {
+          return containerWorktreePath;
+        }
+        const detail = [probe.stderr, probe.stdout].filter(Boolean).join("\n").trim();
+        throw new Error(
+          `warm container git probe failed (exit ${probe.exitCode})${detail ? `: ${detail}` : ""}`,
+        );
+      } catch (err) {
+        lastError = err;
+        if (attempt >= 2) {
+          const diagnostics = await this.inspectWarmContainerState().catch(() => "");
+          throw new Error(
+            `worktree not accessible inside warm container after ${attempt} attempts: ${containerWorktreePath}${
+              lastError ? ` (${this.compactError(lastError)})` : ""
+            }${diagnostics ? ` | container=${diagnostics}` : ""}`,
+          );
+        }
+        const note =
+          `[DockerExecutor] Warm container could not access worktree ${containerWorktreePath}; ` +
+          `recycling container and retrying once (${this.compactError(err)}).`;
+        console.warn(note);
+        onLog?.("stderr", note);
+        await this.stopWarmContainer("worktree visibility retry", true);
+      }
+    }
+
+    return containerWorktreePath;
+  }
+
   private normalizeProvider(raw: string): string {
     const value = raw.trim().toLowerCase();
     if (!value) return "auto";

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

@@ -215,6 +215,14 @@ function isNoisyProgressLine(line: string): boolean {
   return /^(📦 Installing \[\d+\/\d+\]|🔍 Resolving\.\.\.|🔒 Saving lockfile\.\.\.)$/.test(line);
 }
 
+export function shouldEmitDirectSessionJobEvent(options: {
+  ok: boolean;
+  statusPersistedToServer: boolean;
+}): boolean {
+  if (options.ok) return true;
+  return !options.statusPersistedToServer;
+}
+
 function shouldRecycleWorkerForCodexUnavailableFailure(
   summary: string,
   stderr?: string | null,
@@ -950,13 +958,15 @@ async function failActiveJobOnShutdown(
 
   const message = "Worker process shutting down during claimed job";
   const detail = `worker=${opts.workerId}; signal=${signalName}; action=fail-claimed-job-on-shutdown`;
+  let statusPersistedToServer = false;
 
   try {
-    await fetch(`${opts.server}/jobs/${activeJobId}/fail`, {
+    const response = await fetch(`${opts.server}/jobs/${activeJobId}/fail`, {
       method: "POST",
       headers,
       body: JSON.stringify({ message, detail }),
     });
+    statusPersistedToServer = response.ok;
   } catch (err) {
     console.error(
       `[WorkerPals] Failed to mark active job ${activeJobId} as failed during shutdown:`,
@@ -964,7 +974,10 @@ async function failActiveJobOnShutdown(
     );
   }
 
-  if (runtimeState.currentSessionId) {
+  if (
+    runtimeState.currentSessionId &&
+    shouldEmitDirectSessionJobEvent({ ok: false, statusPersistedToServer })
+  ) {
     await sendCommand(opts.server, runtimeState.currentSessionId, headers, {
       type: "job_failed",
       payload: {
@@ -1242,6 +1255,7 @@ async function workerLoop(
               }
             }
 
+            let statusPersistedToServer = false;
             if (result.ok) {
               const reviewAgent =
                 parsedParams.reviewAgent && typeof parsedParams.reviewAgent === "object"
@@ -1253,7 +1267,7 @@ async function workerLoop(
                 reviewAgent.prUrl.trim().length > 0
                   ? reviewAgent.prUrl.trim()
                   : null;
-              await fetch(`${opts.server}/jobs/${job.id}/complete`, {
+              const response = await fetch(`${opts.server}/jobs/${job.id}/complete`, {
                 method: "POST",
                 headers,
                 body: JSON.stringify({
@@ -1266,11 +1280,12 @@ async function workerLoop(
                   ],
                 }),
               });
+              statusPersistedToServer = response.ok;
               console.log(
                 `[WorkerPals] Job ${job.id} completed in ${formatDurationMs(jobDurationMs)}: ${result.summary}`,
               );
             } else {
-              await fetch(`${opts.server}/jobs/${job.id}/fail`, {
+              const response = await fetch(`${opts.server}/jobs/${job.id}/fail`, {
                 method: "POST",
                 headers,
                 body: JSON.stringify({
@@ -1279,6 +1294,7 @@ async function workerLoop(
                   durationMs: jobDurationMs,
                 }),
               });
+              statusPersistedToServer = response.ok;
               console.log(
                 `[WorkerPals] Job ${job.id} failed in ${formatDurationMs(jobDurationMs)}: ${result.summary}`,
               );
@@ -1319,29 +1335,31 @@ async function workerLoop(
                 }
               }
 
-              const eventCmd = result.ok
-                ? {
-                    type: "job_completed" as const,
-                    payload: {
-                      jobId: job.id,
-                      summary: result.summary,
-                      artifacts: result.stdout
-                        ? [{ kind: "log" as const, text: result.stdout }]
-                        : undefined,
-                    },
-                    from: `worker:${opts.workerId}`,
-                  }
-                : {
-                    type: "job_failed" as const,
-                    payload: {
-                      jobId: job.id,
-                      message: result.summary,
-                      detail: redactSensitiveText(result.stderr ?? ""),
-                    },
-                    from: `worker:${opts.workerId}`,
-                  };
+              if (shouldEmitDirectSessionJobEvent({ ok: result.ok, statusPersistedToServer })) {
+                const eventCmd = result.ok
+                  ? {
+                      type: "job_completed" as const,
+                      payload: {
+                        jobId: job.id,
+                        summary: result.summary,
+                        artifacts: result.stdout
+                          ? [{ kind: "log" as const, text: result.stdout }]
+                          : undefined,
+                      },
+                      from: `worker:${opts.workerId}`,
+                    }
+                  : {
+                      type: "job_failed" as const,
+                      payload: {
+                        jobId: job.id,
+                        message: result.summary,
+                        detail: redactSensitiveText(result.stderr ?? ""),
+                      },
+                      from: `worker:${opts.workerId}`,
+                    };
 
-              await sendCommand(opts.server, job.sessionId, headers, eventCmd);
+                await sendCommand(opts.server, job.sessionId, headers, eventCmd);
+              }
             }
           } finally {
             clearInterval(busyHeartbeat);