@pushpalsdev/cli 1.0.39 → 1.0.41

package/dist/pushpals-cli.js

@@ -189,7 +189,7 @@ class ServiceManager {
             stderr: "ignore"
           });
         } else {
-          service.proc.kill();
+          service.proc.kill("SIGKILL");
         }
       } catch {}
     }
@@ -1701,6 +1701,7 @@ function printUsage() {
   console.log("  --no-auto-start        Disable runtime auto-start when the server is down");
   console.log("  --no-stream            Disable live session event stream");
   console.log("  --runtime-only         Start the local runtime and wait for shutdown without opening the interactive chat");
+  console.log("  --status-once          Print active endpoints once and exit");
   console.log("  --clear                Remove repo-local PushPals state and exit");
   console.log("  -h, --help             Show this help");
   console.log("");
@@ -1720,6 +1721,7 @@ function parseArgs(argv) {
     noAutoStart: false,
     noStream: false,
     runtimeOnly: false,
+    statusOnce: false,
     clear: false
   };
   for (let i = 0;i < argv.length; i++) {
@@ -1740,6 +1742,10 @@ function parseArgs(argv) {
       options.runtimeOnly = true;
       continue;
     }
+    if (arg === "--status-once") {
+      options.statusOnce = true;
+      continue;
+    }
     if (arg === "--clear") {
       options.clear = true;
       continue;
@@ -1812,7 +1818,7 @@ function parsePositiveInt(value, fallback) {
 function jsonHtmlBootstrap(value) {
   return JSON.stringify(value).replace(/</g, "\\u003c");
 }
-async function runCommandWithEnv(command, cwd, env) {
+async function runCommandWithEnv(command, cwd, env, timeoutMs) {
   try {
     const proc = Bun.spawn(command, {
       cwd,
@@ -1820,12 +1826,48 @@ async function runCommandWithEnv(command, cwd, env) {
       stdout: "pipe",
       stderr: "pipe"
     });
+    let timedOut = false;
+    let timer = null;
+    if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        try {
+          const stopCommand = buildServiceStopCommand(proc.pid, process.platform);
+          if (stopCommand) {
+            Bun.spawnSync(stopCommand, {
+              stdin: "ignore",
+              stdout: "ignore",
+              stderr: "ignore"
+            });
+          } else {
+            proc.kill("SIGKILL");
+          }
+        } catch {}
+      }, timeoutMs);
+    }
     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 };
+    if (timer)
+      clearTimeout(timer);
+    const normalizedStdout = stdout.trim();
+    const normalizedStderr = stderr.trim();
+    if (timedOut) {
+      return {
+        ok: false,
+        stdout: normalizedStdout,
+        stderr: `timed out after ${timeoutMs}ms${normalizedStderr ? ` | ${normalizedStderr}` : ""}`,
+        exitCode
+      };
+    }
+    return {
+      ok: exitCode === 0,
+      stdout: normalizedStdout,
+      stderr: normalizedStderr,
+      exitCode
+    };
   } catch (err) {
     return {
       ok: false,
@@ -2610,7 +2652,7 @@ function stopRuntimeServices(services) {
           stderr: "ignore"
         });
       } else {
-        service.proc.kill();
+        service.proc.kill("SIGKILL");
       }
     } catch {}
   }
@@ -2661,6 +2703,34 @@ async function stopRuntimeServicesGracefully(services, timeoutMs = 1e4) {
     stopRuntimeServices(remaining);
   }
 }
+async function shutdownEmbeddedServiceManagerGracefully(options) {
+  const {
+    serviceManager,
+    serverUrl,
+    repoRoot,
+    reason,
+    requestShutdown = requestLocalRuntimeShutdown,
+    shutdownAcceptedDelayMs = 1500,
+    onLog = (line) => console.log(line),
+    onWarn = (line) => console.warn(line),
+    cleanupTasks = []
+  } = options;
+  serviceManager.beginShutdown();
+  const services = serviceManager.getServices();
+  const shutdown = await requestShutdown(serverUrl, repoRoot, reason);
+  if (shutdown.attempted && shutdown.accepted) {
+    onLog("[pushpals] Local runtime shutdown accepted; waiting for services to exit...");
+    await Bun.sleep(Math.max(0, shutdownAcceptedDelayMs));
+  } else if (shutdown.attempted) {
+    onWarn(`[pushpals] Local runtime shutdown request was not accepted${shutdown.detail ? `: ${shutdown.detail}` : "."}`);
+  } else if (shutdown.detail) {
+    onWarn(`[pushpals] ${shutdown.detail}`);
+  }
+  await stopRuntimeServicesGracefully(services);
+  for (const task of cleanupTasks) {
+    await task();
+  }
+}
 function prependExecutableDirToPath(env, executablePath, platform = process.platform) {
   const resolvedPath = String(executablePath ?? "").trim();
   if (!resolvedPath)
@@ -2930,6 +3000,7 @@ function resolveConfiguredDockerExecutable(env, platform = process.platform) {
 }
 async function cleanupLingeringWorkerpalWarmContainers(opts) {
   const runCommandWithEnvFn = opts.runCommandWithEnvFn ?? runCommandWithEnv;
+  const commandTimeoutMs = typeof opts.commandTimeoutMs === "number" && Number.isFinite(opts.commandTimeoutMs) ? Math.max(1, Math.floor(opts.commandTimeoutMs)) : 5000;
   const dockerExecutable = resolveConfiguredDockerExecutable(opts.env, opts.platform ?? process.platform);
   const list = await runCommandWithEnvFn([
     dockerExecutable,
@@ -2939,7 +3010,7 @@ async function cleanupLingeringWorkerpalWarmContainers(opts) {
     `label=${WORKERPAL_WARM_COMPONENT_LABEL}`,
     "--filter",
     `label=pushpals.repo=${opts.repoRoot}`
-  ], opts.repoRoot, opts.env);
+  ], opts.repoRoot, opts.env, commandTimeoutMs);
   if (!list.ok) {
     const detail = list.stderr || list.stdout || `exit ${list.exitCode}`;
     return {
@@ -2956,7 +3027,7 @@ async function cleanupLingeringWorkerpalWarmContainers(opts) {
       removed: 0
     };
   }
-  const remove = await runCommandWithEnvFn([dockerExecutable, "rm", "-f", ...containerIds], opts.repoRoot, opts.env);
+  const remove = await runCommandWithEnvFn([dockerExecutable, "rm", "-f", ...containerIds], opts.repoRoot, opts.env, commandTimeoutMs);
   if (!remove.ok) {
     const detail = remove.stderr || remove.stdout || `exit ${remove.exitCode}`;
     return {
@@ -2974,7 +3045,8 @@ async function cleanupLingeringWorkerpalWarmContainers(opts) {
 async function cleanupLingeringPushPalsGitWorktrees(opts) {
   const runCommandWithEnvFn = opts.runCommandWithEnvFn ?? runCommandWithEnv;
   const forceDeleteWorktreePathFn = opts.forceDeleteWorktreePathFn ?? forceDeleteWorktreePath;
-  const list = await runCommandWithEnvFn(["git", "worktree", "list", "--porcelain"], opts.repoRoot, opts.env);
+  const commandTimeoutMs = typeof opts.commandTimeoutMs === "number" && Number.isFinite(opts.commandTimeoutMs) ? Math.max(1, Math.floor(opts.commandTimeoutMs)) : 5000;
+  const list = await runCommandWithEnvFn(["git", "worktree", "list", "--porcelain"], opts.repoRoot, opts.env, commandTimeoutMs);
   if (!list.ok) {
     const detail = list.stderr || list.stdout || `exit ${list.exitCode}`;
     return {
@@ -2996,7 +3068,7 @@ async function cleanupLingeringPushPalsGitWorktrees(opts) {
   let removed = 0;
   const failures = [];
   for (const entry of removable) {
-    const remove = await runCommandWithEnvFn(["git", "worktree", "remove", "--force", "--force", entry.path], opts.repoRoot, opts.env);
+    const remove = await runCommandWithEnvFn(["git", "worktree", "remove", "--force", "--force", entry.path], opts.repoRoot, opts.env, commandTimeoutMs);
     if (remove.ok) {
       removed += 1;
       continue;
@@ -3009,7 +3081,7 @@ async function cleanupLingeringPushPalsGitWorktrees(opts) {
     const removeDetail = remove.stderr || remove.stdout || `exit ${remove.exitCode}`;
     failures.push(`${entry.path}: ${removeDetail}${forced.lastError ? ` | fallback: ${forced.lastError}` : ""}`);
   }
-  const prune = await runCommandWithEnvFn(["git", "worktree", "prune"], opts.repoRoot, opts.env);
+  const prune = await runCommandWithEnvFn(["git", "worktree", "prune"], opts.repoRoot, opts.env, commandTimeoutMs);
   if (!prune.ok) {
     failures.push(`prune: ${prune.stderr || prune.stdout || `exit ${prune.exitCode}`}`);
   }
@@ -3018,13 +3090,13 @@ async function cleanupLingeringPushPalsGitWorktrees(opts) {
     "for-each-ref",
     "--format=%(refname:short)",
     `refs/heads/${SOURCE_CONTROL_MANAGER_TEMP_BRANCH_PREFIX}`
-  ], opts.repoRoot, opts.env);
+  ], opts.repoRoot, opts.env, commandTimeoutMs);
   if (!deleteTempBranches.ok) {
     failures.push(`list temp branches: ${deleteTempBranches.stderr || deleteTempBranches.stdout || `exit ${deleteTempBranches.exitCode}`}`);
   } else {
     const branches = deleteTempBranches.stdout.split(/\r?\n/g).map((value) => value.trim()).filter(Boolean);
     for (const branch of branches) {
-      const deleteResult = await runCommandWithEnvFn(["git", "branch", "-D", branch], opts.repoRoot, opts.env);
+      const deleteResult = await runCommandWithEnvFn(["git", "branch", "-D", branch], opts.repoRoot, opts.env, commandTimeoutMs);
       if (!deleteResult.ok) {
         failures.push(`${branch}: ${deleteResult.stderr || deleteResult.stdout || `exit ${deleteResult.exitCode}`}`);
       } else {
@@ -4799,21 +4871,16 @@ async function main() {
       return;
     const serviceManager = autoStartedServiceManager;
     autoStartedServiceManager = null;
-    serviceManager.beginShutdown();
-    const shutdown = await requestLocalRuntimeShutdown(serverUrl, repoRoot, reason);
-    if (shutdown.attempted && shutdown.accepted) {
-      console.log("[pushpals] Local runtime shutdown accepted; waiting for services to exit...");
-      await Bun.sleep(1500);
-    } else if (shutdown.attempted) {
-      console.warn(`[pushpals] Local runtime shutdown request was not accepted${shutdown.detail ? `: ${shutdown.detail}` : "."}`);
-    } else if (shutdown.detail) {
-      console.warn(`[pushpals] ${shutdown.detail}`);
-    }
-    serviceManager.stop();
-    const services = serviceManager.getServices();
-    await stopRuntimeServicesGracefully(services);
-    await cleanupWorkerpalWarmContainersIfNeeded("cli shutdown");
-    await cleanupPushPalsGitWorktreesIfNeeded("cli shutdown");
+    await shutdownEmbeddedServiceManagerGracefully({
+      serviceManager,
+      serverUrl,
+      repoRoot,
+      reason,
+      cleanupTasks: [
+        () => cleanupWorkerpalWarmContainersIfNeeded("cli shutdown"),
+        () => cleanupPushPalsGitWorktreesIfNeeded("cli shutdown")
+      ]
+    });
   };
   if (!serverHealthy && workerpalDockerPrecheck.status === "failed") {
     console.error(`[pushpals] Precheck failed: Docker-backed WorkerPal auto-spawn is required but Docker is unavailable (${workerpalDockerPrecheck.detail}).`);
@@ -5002,7 +5069,7 @@ ${line}
     }
     console.log(line);
   };
-  const streamTask = parsed.noStream ? Promise.resolve() : parsed.runtimeOnly ? Promise.resolve() : runSessionStream(serverUrl, activeSessionId, cliClient, printIncoming, streamAbort.signal);
+  const streamTask = parsed.noStream ? Promise.resolve() : parsed.runtimeOnly || parsed.statusOnce ? Promise.resolve() : runSessionStream(serverUrl, activeSessionId, cliClient, printIncoming, streamAbort.signal);
   let stopPromise = null;
   const requestStop = () => {
     if (stopPromise)
@@ -5066,10 +5133,25 @@ ${line}
     await Promise.race([streamTask, Bun.sleep(2000)]);
     return;
   }
+  const printStatusSnapshot = async () => {
+    console.log(`[pushpals] serverUrl=${serverUrl}`);
+    console.log(`[pushpals] sessionId=${activeSessionId}`);
+    console.log(`[pushpals] repoRoot=${repoRoot}`);
+    console.log(`[pushpals] pushpalsLog=${pushpalsLogPath ?? "unavailable"}`);
+    console.log(monitoringHubUrl ? `[pushpals] monitoringHubUrl=${monitoringHubUrl}` : "[pushpals] monitoringHubUrl=unavailable");
+    await reportWorkerExecutionReadiness();
+    reportEmbeddedRuntimeHealth();
+  };
+  if (parsed.statusOnce) {
+    await printStatusSnapshot();
+    await requestStop();
+    await Promise.race([streamTask, Bun.sleep(2000)]);
+    return;
+  }
   rl = createInterface({
     input: process.stdin,
     output: process.stdout,
-    terminal: true
+    terminal: Boolean(process.stdin.isTTY && process.stdout.isTTY)
   });
   rl.setPrompt("you> ");
   rl.prompt();
@@ -5089,13 +5171,7 @@ ${line}
       continue;
     }
     if (text === "/status") {
-      console.log(`[pushpals] serverUrl=${serverUrl}`);
-      console.log(`[pushpals] sessionId=${activeSessionId}`);
-      console.log(`[pushpals] repoRoot=${repoRoot}`);
-      console.log(`[pushpals] pushpalsLog=${pushpalsLogPath ?? "unavailable"}`);
-      console.log(monitoringHubUrl ? `[pushpals] monitoringHubUrl=${monitoringHubUrl}` : "[pushpals] monitoringHubUrl=unavailable");
-      await reportWorkerExecutionReadiness();
-      reportEmbeddedRuntimeHealth();
+      await printStatusSnapshot();
       rl.prompt();
       continue;
     }
@@ -5134,6 +5210,7 @@ if (import.meta.main) {
 export {
   waitForWorkerpalCapacity,
   startEmbeddedMonitoringHub,
+  shutdownEmbeddedServiceManagerGracefully,
   shouldRunEmbeddedRuntimeStartupPrechecks,
   shouldRestartEmbeddedService,
   resolveWorkerExecutionReadiness,

package/package.json

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

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

@@ -240,6 +240,7 @@ export class DockerExecutor {
   private lastLoggedExecutionConfig = "";
   private lastLoggedEndpointRewrite = "";
   private warmedBackends = new Set<string>();
+  private preparedMergeConflictJobs = new Set<string>();
   private mergeConflictRefreshPromise: Promise<void> | null = null;
   private readonly config: WorkerpalsRuntimeConfig;
 
@@ -318,7 +319,6 @@ export class DockerExecutor {
     const worktreePath = resolve(this.worktreeDir, worktreeName);
 
     try {
-      await this.ensureFreshImageForMergeConflictJob(job, onLog);
       const worktreeBaseRef = await this.resolveWorktreeBaseRefForJob(job, onLog);
       // Step 1: Create isolated git worktree
       await this.createWorktree(worktreePath, worktreeBaseRef);
@@ -398,6 +398,7 @@ export class DockerExecutor {
         stderr: `Retries exhausted after ${this.jobRetryMaxAttempts} attempts`,
       };
     } finally {
+      this.preparedMergeConflictJobs.delete(job.id);
       this.activeJobs = Math.max(0, this.activeJobs - 1);
       // Step 4: Clean up worktree (always cleanup)
       await this.removeWorktree(worktreePath).catch((err) => {
@@ -1690,6 +1691,22 @@ export class DockerExecutor {
     return resolutionType === "merge_conflict";
   }
 
+  shouldPrepareMergeConflictJobBeforeExecution(job: Job): boolean {
+    return this.isMergeConflictResolutionJob(job) && !this.preparedMergeConflictJobs.has(job.id);
+  }
+
+  async prepareMergeConflictJobEnvironment(
+    job: Job,
+    onLog?: (stream: "stdout" | "stderr", line: string) => void,
+  ): Promise<void> {
+    await this.ensureFreshImageForMergeConflictJob(job, onLog);
+    this.preparedMergeConflictJobs.add(job.id);
+  }
+
+  recommendedMergeConflictDeferMs(): number {
+    return Math.max(60_000, Math.min(this.options.timeoutMs, 5 * 60_000));
+  }
+
   private async ensureFreshImageForMergeConflictJob(
     job: Job,
     onLog?: (stream: "stdout" | "stderr", line: string) => void,

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

@@ -965,6 +965,40 @@ async function failActiveJobOnShutdown(
   }
 }
 
+async function deferClaimedJobForMaintenance(
+  opts: ReturnType<typeof parseArgs>,
+  headers: Record<string, string>,
+  jobId: string,
+  deferMs: number,
+): Promise<{ ok: boolean; availableAt?: string; message?: string }> {
+  try {
+    const response = await postJsonWithTimeout(`${opts.server}/jobs/${jobId}/defer`, headers, {
+      workerId: opts.workerId,
+      deferMs,
+    });
+    const payload = (await response.json().catch(() => ({}))) as {
+      ok?: boolean;
+      availableAt?: string;
+      message?: string;
+    };
+    if (!response.ok || !payload.ok) {
+      return {
+        ok: false,
+        message: payload.message || `HTTP ${response.status}`,
+      };
+    }
+    return {
+      ok: true,
+      availableAt: payload.availableAt,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 async function workerLoop(
   opts: ReturnType<typeof parseArgs>,
   dockerExecutor: DockerExecutor | null,
@@ -1034,6 +1068,83 @@ async function workerLoop(
         const job = data.job;
 
         if (job) {
+          if (
+            dockerExecutor &&
+            dockerExecutor.shouldPrepareMergeConflictJobBeforeExecution(job)
+          ) {
+            const deferMs = dockerExecutor.recommendedMergeConflictDeferMs();
+            const deferred = await deferClaimedJobForMaintenance(opts, headers, job.id, deferMs);
+            if (!deferred.ok) {
+              console.warn(
+                `[WorkerPals] Failed to defer merge-conflict job ${job.id} for image refresh; falling back to claimed execution path: ${
+                  deferred.message || "unknown error"
+                }`,
+              );
+            } else {
+              console.log(
+                `[WorkerPals] Deferred merge-conflict job ${job.id} until ${
+                  deferred.availableAt ?? "maintenance complete"
+                } while refreshing Docker image outside claimed-job lifetime.`,
+              );
+              const maintenanceHeartbeat = setInterval(() => {
+                void transport.sendHeartbeat({
+                  ...buildHeartbeatPayload("idle", null),
+                  details: {
+                    repo: opts.repo,
+                    baseRef: opts.worktreeBaseRef,
+                    dockerImage: opts.docker ? opts.dockerImage : null,
+                    dockerNetworkMode: opts.docker ? opts.dockerNetworkMode : null,
+                    maintenance: "merge_conflict_image_refresh",
+                    deferredJobId: job.id,
+                  },
+                });
+              }, heartbeatEveryMs);
+              try {
+                await maybeHeartbeat("idle", null, true);
+                await dockerExecutor.prepareMergeConflictJobEnvironment(job);
+              } catch (error) {
+                const detail = redactSensitiveText(
+                  error instanceof Error ? error.stack || error.message : String(error),
+                );
+                console.error(
+                  `[WorkerPals] Merge-conflict environment preparation failed for ${job.id}: ${detail}`,
+                );
+                try {
+                  const failResponse = await postJsonWithTimeout(
+                    `${opts.server}/jobs/${job.id}/fail-deferred`,
+                    headers,
+                    {
+                      workerId: opts.workerId,
+                      message: "Merge-conflict environment preparation failed",
+                      detail,
+                    },
+                  );
+                  const failPayload = (await failResponse.json().catch(() => ({}))) as {
+                    ok?: boolean;
+                    message?: string;
+                  };
+                  if (!failResponse.ok || !failPayload.ok) {
+                    console.error(
+                      `[WorkerPals] Failed to mark deferred job ${job.id} as failed: ${
+                        failPayload.message || `HTTP ${failResponse.status}`
+                      }`,
+                    );
+                  }
+                } catch (failErr) {
+                  console.error(
+                    `[WorkerPals] Failed to mark deferred job ${job.id} as failed: ${
+                      failErr instanceof Error ? failErr.message : String(failErr)
+                    }`,
+                  );
+                }
+              } finally {
+                clearInterval(maintenanceHeartbeat);
+              }
+              await maybeHeartbeat("idle", null, true);
+              continue;
+            }
+          }
+
           runtimeState.currentJobId = job.id;
           runtimeState.currentSessionId = job.sessionId ?? null;
           console.log(`[WorkerPals] Claimed job ${job.id} (${job.kind})`);