@pushpalsdev/cli 1.1.29 → 1.1.31

package/bin/pushpals.cjs

@@ -2,13 +2,21 @@
 "use strict";
 
 const { spawn, spawnSync } = require("node:child_process");
-const { existsSync, readFileSync } = require("node:fs");
-const { resolve } = require("node:path");
+const { existsSync, mkdirSync, readFileSync, rmSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { dirname, join, resolve } = require("node:path");
 
 const bundledCliPath = resolve(__dirname, "..", "dist", "pushpals-cli.js");
 const packageJsonPath = resolve(__dirname, "..", "package.json");
 const releaseUrl = "https://github.com/PushPalsDev/pushpals/releases";
+const DEFAULT_BUN_PROBE_TIMEOUT_MS = 10_000;
+const DEFAULT_BOOTSTRAP_TIMEOUT_MS = 5 * 60 * 1000;
+const BUN_PROBE_TIMEOUT_ENV = "PUSHPALS_BUN_PROBE_TIMEOUT_MS";
+const BOOTSTRAP_TIMEOUT_ENV = "PUSHPALS_CLI_BOOTSTRAP_TIMEOUT_MS";
+const BOOTSTRAP_READY_MARKER_ENV = "PUSHPALS_CLI_READY_MARKER";
 let packageVersion = "";
+let readyMarkerPath = "";
+let resolvedBunCommand = "";
 if (existsSync(packageJsonPath)) {
   try {
     const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
@@ -25,6 +33,84 @@ function fail(lines) {
   process.exit(1);
 }
 
+function parseBoundedTimeoutMs(envName, defaultValue, maxValue) {
+  const raw = String(process.env[envName] ?? "").trim();
+  if (raw === "0") return 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) return defaultValue;
+  return Math.max(1_000, Math.min(maxValue, parsed));
+}
+
+function parseBunProbeTimeoutMs() {
+  return parseBoundedTimeoutMs(BUN_PROBE_TIMEOUT_ENV, DEFAULT_BUN_PROBE_TIMEOUT_MS, 60 * 1000);
+}
+
+function parseBootstrapTimeoutMs() {
+  return parseBoundedTimeoutMs(
+    BOOTSTRAP_TIMEOUT_ENV,
+    DEFAULT_BOOTSTRAP_TIMEOUT_MS,
+    30 * 60 * 1000,
+  );
+}
+
+function createReadyMarkerPath() {
+  const root = join(tmpdir(), "pushpals-cli-ready");
+  mkdirSync(root, { recursive: true });
+  return join(root, `ready-${process.pid}-${Date.now()}.txt`);
+}
+
+function killChildTree(child) {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  try {
+    if (process.platform === "win32" && typeof child.pid === "number" && child.pid > 0) {
+      spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+        stdio: "ignore",
+        timeout: 10_000,
+      });
+      return;
+    }
+    child.kill("SIGKILL");
+  } catch {
+    // best-effort watchdog cleanup only
+  }
+}
+
+function resolveWindowsBunCommand() {
+  try {
+    const where = spawnSync("where.exe", ["bun"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5_000,
+    });
+    if (where.status !== 0) return "bun";
+    const candidates = String(where.stdout ?? "")
+      .split(/\r?\n/g)
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    for (const candidate of candidates) {
+      const lower = candidate.toLowerCase();
+      if (lower.endsWith(".exe") && existsSync(candidate)) return candidate;
+
+      // Bun installed through npm/nvm on Windows commonly exposes shell shims:
+      //   <node-dir>\bun
+      //   <node-dir>\bun.cmd
+      // Those shims delegate to <node-dir>\node_modules\bun\bin\bun.exe.
+      const shimTarget = join(dirname(candidate), "node_modules", "bun", "bin", "bun.exe");
+      if (existsSync(shimTarget)) return shimTarget;
+    }
+  } catch {
+    // Fall back to PATH/shell command resolution below.
+  }
+  return "bun";
+}
+
+function resolveBunCommand() {
+  if (resolvedBunCommand) return resolvedBunCommand;
+  resolvedBunCommand = process.platform === "win32" ? resolveWindowsBunCommand() : "bun";
+  return resolvedBunCommand;
+}
+
 if (!existsSync(bundledCliPath)) {
   fail([
     "[pushpals] CLI bundle is missing in this package install.",
@@ -33,16 +119,26 @@ if (!existsSync(bundledCliPath)) {
   ]);
 }
 
-function hasBunRuntime() {
-  if (process.platform === "win32") {
-    const probe = spawnSync("bun --version", { shell: true, stdio: "ignore" });
-    return probe.status === 0;
-  }
-  const probe = spawnSync("bun", ["--version"], { stdio: "ignore" });
-  return probe.status === 0;
+function probeBunRuntime() {
+  const timeout = parseBunProbeTimeoutMs();
+  const options = { stdio: "ignore", timeout };
+  const result = spawnSync(resolveBunCommand(), ["--version"], options);
+  return {
+    ok: result.status === 0,
+    timedOut: Boolean(result.error && result.error.code === "ETIMEDOUT"),
+  };
 }
 
-if (!hasBunRuntime()) {
+const bunRuntime = probeBunRuntime();
+if (!bunRuntime.ok) {
+  if (bunRuntime.timedOut) {
+    fail([
+      `[pushpals] Bun runtime probe timed out after ${parseBunProbeTimeoutMs()}ms.`,
+      "[pushpals] This usually means the Bun process wedged during startup; the CLI refused to continue so it does not freeze the shell.",
+      `[pushpals] Set ${BUN_PROBE_TIMEOUT_ENV}=0 to disable this probe timeout, or use a direct binary release:`,
+      `[pushpals] ${releaseUrl}`,
+    ]);
+  }
   fail([
     "[pushpals] Bun runtime is required for the npm package entrypoint.",
     "[pushpals] Install Bun from https://bun.sh, or use a direct binary release:",
@@ -51,38 +147,105 @@ if (!hasBunRuntime()) {
 }
 
 function spawnBunCli() {
+  readyMarkerPath = process.env[BOOTSTRAP_READY_MARKER_ENV] || createReadyMarkerPath();
   const childEnv = {
     ...process.env,
     PUSHPALS_CLI_PACKAGE_VERSION: packageVersion || process.env.PUSHPALS_CLI_PACKAGE_VERSION || "",
+    [BOOTSTRAP_READY_MARKER_ENV]: readyMarkerPath,
   };
 
-  if (process.platform !== "win32") {
-    return spawn("bun", [bundledCliPath, ...process.argv.slice(2)], {
+  const bunCommand = resolveBunCommand();
+  if (process.platform === "win32" && bunCommand === "bun") {
+    const quoteWindows = (value) => `"${String(value).replace(/"/g, '\\"')}"`;
+    const commandLine = [
+      bunCommand,
+      quoteWindows(bundledCliPath),
+      ...process.argv.slice(2).map(quoteWindows),
+    ].join(" ");
+    return spawn(commandLine, {
+      shell: true,
       stdio: "inherit",
       env: childEnv,
     });
   }
-
-  const quoteWindows = (value) => `"${String(value).replace(/"/g, '\\"')}"`;
-  const commandLine = [
-    "bun",
-    quoteWindows(bundledCliPath),
-    ...process.argv.slice(2).map(quoteWindows),
-  ].join(" ");
-  return spawn(commandLine, {
-    shell: true,
+  return spawn(bunCommand, [bundledCliPath, ...process.argv.slice(2)], {
     stdio: "inherit",
     env: childEnv,
   });
 }
 
 const child = spawnBunCli();
+const bootstrapTimeoutMs = parseBootstrapTimeoutMs();
+let watchdogTimer = null;
+let markerPollTimer = null;
+let watchdogFired = false;
+let parentSignalExit = false;
+
+function cleanupReadyMarker() {
+  if (!readyMarkerPath) return;
+  try {
+    rmSync(readyMarkerPath, { force: true });
+  } catch {
+    // best-effort cleanup only
+  }
+}
+
+function clearBootstrapWatchdog() {
+  if (watchdogTimer) {
+    clearTimeout(watchdogTimer);
+    watchdogTimer = null;
+  }
+  if (markerPollTimer) {
+    clearInterval(markerPollTimer);
+    markerPollTimer = null;
+  }
+}
+
+if (bootstrapTimeoutMs > 0) {
+  markerPollTimer = setInterval(() => {
+    if (readyMarkerPath && existsSync(readyMarkerPath)) {
+      clearBootstrapWatchdog();
+    }
+  }, 1_000);
+  watchdogTimer = setTimeout(() => {
+    if (readyMarkerPath && existsSync(readyMarkerPath)) {
+      clearBootstrapWatchdog();
+      return;
+    }
+    watchdogFired = true;
+    process.stderr.write(
+      `[pushpals] Bun runtime did not finish CLI bootstrap within ${bootstrapTimeoutMs}ms; terminating Bun process tree. ` +
+        `Set ${BOOTSTRAP_TIMEOUT_ENV}=0 to disable this watchdog.\n`,
+    );
+    killChildTree(child);
+  }, bootstrapTimeoutMs);
+}
+
+function terminateChildAndExit(signal) {
+  if (parentSignalExit) return;
+  parentSignalExit = true;
+  clearBootstrapWatchdog();
+  killChildTree(child);
+  cleanupReadyMarker();
+  process.exit(signal === "SIGINT" ? 130 : 143);
+}
+
+process.once("SIGINT", () => terminateChildAndExit("SIGINT"));
+process.once("SIGTERM", () => terminateChildAndExit("SIGTERM"));
 
 child.on("error", (err) => {
+  clearBootstrapWatchdog();
+  cleanupReadyMarker();
   fail([`[pushpals] Failed to launch Bun runtime: ${String(err?.message ?? err)}`]);
 });
 
 child.on("exit", (code, signal) => {
+  clearBootstrapWatchdog();
+  cleanupReadyMarker();
+  if (watchdogFired) {
+    process.exit(124);
+    return;
+  }
   if (signal) {
     process.kill(process.pid, signal);
     return;

package/dist/pushpals-cli.js

@@ -1652,6 +1652,8 @@ var EMBEDDED_SERVICE_RESTART_MAX_ATTEMPTS = 4;
 var DEFAULT_WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS = 5000;
 var WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS_ENV = "PUSHPALS_WORKERPAL_STARTUP_READINESS_PROBE_MAX_MS";
 var BLOCKING_WORKERPAL_IMAGE_BUILD_ENV = "PUSHPALS_BLOCKING_WORKERPAL_IMAGE_BUILD";
+var WINDOWS_FRESH_RUNTIME_WORKERPAL_PREWARM_DELAY_MS_ENV = "PUSHPALS_WINDOWS_FRESH_RUNTIME_WORKERPAL_PREWARM_DELAY_MS";
+var DEFAULT_WINDOWS_FRESH_RUNTIME_WORKERPAL_PREWARM_DELAY_MS = 30000;
 var CLI_SESSION_JOB_LOG_MAX_CHARS = 700;
 var CLI_SESSION_SHOW_JOB_EVENTS_ENV = "PUSHPALS_CLI_SHOW_JOB_EVENTS";
 var EMBEDDED_RUNTIME_SAFETY_CAP_DISABLE_ENV = "PUSHPALS_DISABLE_EMBEDDED_SAFETY_CAPS";
@@ -3112,6 +3114,7 @@ async function ensureRuntimeBinaries(runtimeRoot, runtimeTag) {
     console.log(`[pushpals] Embedded runtime binaries downloaded: ${downloadedCount}.`);
   }
   console.log("[pushpals] Embedded runtime binaries are ready.");
+  runtimeBinaries.freshlyInstalled = downloadedCount > 0;
   return runtimeBinaries;
 }
 function buildServiceStopCommand(pid, platform = process.platform) {
@@ -3915,6 +3918,14 @@ function resolveWorkerpalStartupReadinessProbeMaxMs(env = process.env) {
 function resolveWorkerpalStartupReadinessProbeTimeoutMs(config) {
   return Math.max(1000, Math.min(resolveWorkerpalCapacityTimeoutMs(config), resolveWorkerpalStartupReadinessProbeMaxMs()));
 }
+function resolveWindowsFreshRuntimeWorkerpalPrewarmDelayMs(env = process.env, platform = process.platform) {
+  if (platform !== "win32")
+    return 0;
+  const raw = String(env[WINDOWS_FRESH_RUNTIME_WORKERPAL_PREWARM_DELAY_MS_ENV] ?? "").trim();
+  if (raw === "0")
+    return 0;
+  return clampPositiveInt(parsePositiveInt(raw, DEFAULT_WINDOWS_FRESH_RUNTIME_WORKERPAL_PREWARM_DELAY_MS), 0, 5 * 60000);
+}
 function shouldPrepareEmbeddedWorkerpalDockerImageBlocking(opts = {}) {
   const env = opts.env ?? process.env;
   const explicit = String(env[BLOCKING_WORKERPAL_IMAGE_BUILD_ENV] ?? "").trim();
@@ -4457,6 +4468,13 @@ async function autoStartRuntimeServices(opts) {
     runtimeTag
   });
   runtimeEnv.PUSHPALS_WORKERPALS_BIN = runtimeBinaries.workerpals;
+  if (runtimeBinaries.freshlyInstalled && process.platform === "win32" && runtimePreflight.config.remotebuddy.autoSpawnWorkerpals && !runtimeEnv.PUSHPALS_REMOTEBUDDY_WORKERPAL_PREWARM_DELAY_MS) {
+    const delayMs = resolveWindowsFreshRuntimeWorkerpalPrewarmDelayMs(runtimeEnv, process.platform);
+    if (delayMs > 0) {
+      runtimeEnv.PUSHPALS_REMOTEBUDDY_WORKERPAL_PREWARM_DELAY_MS = String(delayMs);
+      console.log(`[pushpals] Fresh Windows runtime binaries detected; delaying WorkerPal prewarm by ${delayMs}ms so security software can finish first-run binary checks. Set ${WINDOWS_FRESH_RUNTIME_WORKERPAL_PREWARM_DELAY_MS_ENV}=0 to disable.`);
+    }
+  }
   const preconfiguredRuntimeGitBinary = runtimeEnv.PUSHPALS_GIT_BIN_ABSOLUTE ?? runtimeEnv.PUSHPALS_GIT_BIN;
   if (preconfiguredRuntimeGitBinary) {
     applyResolvedGitBinaryToRuntimeEnv(runtimeEnv, preconfiguredRuntimeGitBinary);
@@ -4939,6 +4957,17 @@ function writeCliState(pathValue, state) {
   writeFileSync(pathValue, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
 }
+function markCliBootstrapReadyFromEnv(env = process.env) {
+  const markerPath = String(env.PUSHPALS_CLI_READY_MARKER ?? "").trim();
+  if (!markerPath)
+    return;
+  try {
+    mkdirSync(dirname(markerPath), { recursive: true });
+    writeFileSync(markerPath, `${process.pid}
+${new Date().toISOString()}
+`, "utf8");
+  } catch {}
+}
 function resolveCliStatePath(repoRoot) {
   return resolveGitStateFilePath(repoRoot, "pushpals-cli-state.json");
 }
@@ -5950,6 +5979,7 @@ async function main() {
   console.log(`[pushpals] cliStateFile=${statePath ?? "unavailable"}`);
   reportWorkerExecutionReadinessFromSnapshot(startupWorkerExecutionReadiness);
   reportEmbeddedRuntimeHealth();
+  markCliBootstrapReadyFromEnv();
   if (parsed.runtimeOnly) {
     console.log("[pushpals] runtimeOnly=true");
   } else {
@@ -6124,6 +6154,7 @@ export {
   resolveWorkerExecutionReadiness,
   resolveWindowsWhereExecutableCandidatesForEnv,
   resolveWindowsShellExecutableCandidatesForEnv,
+  resolveWindowsFreshRuntimeWorkerpalPrewarmDelayMs,
   resolveRuntimeGitExecutableCandidates,
   resolveRuntimeDockerExecutableCandidates,
   resolvePreferredRuntimeReleaseTag,

package/package.json

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

package/runtime/sandbox/.pushpals-remotebuddy-fallback.js

@@ -8396,6 +8396,12 @@ function parseEnabledFlag(raw, defaultValue) {
     return defaultValue;
   return !["0", "false", "no", "off"].includes(text);
 }
+function parseNonNegativeMs(raw, defaultValue = 0) {
+  const parsed = Number.parseInt(String(raw ?? "").trim(), 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return Math.max(0, defaultValue);
+  return Math.floor(parsed);
+}
 function isCodexUnavailableFailureSignal(message, detail) {
   const text = `${message}
 ${detail}`.toLowerCase();
@@ -8968,6 +8974,7 @@ class RemoteBuddyOrchestrator {
   workerSpawnCooldownUntil = 0;
   workerSpawnBackoffMs;
   workerAutoscalePollMs;
+  workerPrewarmDelayMs;
   lastWorkerAutoscaleAt = 0;
   comm;
   statusHeartbeatTimer = null;
@@ -9030,6 +9037,7 @@ class RemoteBuddyOrchestrator {
     this.workerpalsUnavailableReason = null;
     this.workerSpawnBackoffMs = Math.max(1000, Number.isFinite(remoteCfg.crashRestartBackoffMs) && remoteCfg.crashRestartBackoffMs > 0 ? remoteCfg.crashRestartBackoffMs : 3000);
     this.workerAutoscalePollMs = Math.max(1000, remoteCfg.pollMs);
+    this.workerPrewarmDelayMs = Math.min(5 * 60000, parseNonNegativeMs(process.env.PUSHPALS_REMOTEBUDDY_WORKERPAL_PREWARM_DELAY_MS, 0));
     this.statusHeartbeatMs = Math.max(0, remoteCfg.statusHeartbeatMs);
     this.fetchFailureLogsOnJobFailure = parseEnabledFlag(process.env.REMOTEBUDDY_FETCH_FAILURE_LOGS, true);
     this.executionBudgetInteractiveMs = Math.max(60000, remoteCfg.executionBudgetInteractiveMs);
@@ -9081,6 +9089,9 @@ class RemoteBuddyOrchestrator {
     this.autonomousEngine.setRuntimeEnabled(this.autonomyRuntimeEnabled);
     console.log(`[RemoteBuddy] Detected repo root: ${this.repo}`);
     console.log(`[RemoteBuddy] Worker scheduler: min=${this.minWorkers} max=${this.maxWorkers} autoSpawn=${this.autoSpawnWorkers ? "on" : "off"} wait=${this.waitForWorkerMs}ms`);
+    if (this.workerPrewarmDelayMs > 0) {
+      console.log(`[RemoteBuddy] WorkerPal startup prewarm delayed by ${this.workerPrewarmDelayMs}ms to reduce first-run binary scan contention.`);
+    }
     console.log(`[RemoteBuddy] Budgets: interactive=${this.executionBudgetInteractiveMs}ms normal=${this.executionBudgetNormalMs}ms background=${this.executionBudgetBackgroundMs}ms finalization=${this.finalizationBudgetMs}ms`);
     console.log(`[RemoteBuddy] Failure log fetch on job failures: ${this.fetchFailureLogsOnJobFailure ? "on" : "off"}`);
     console.log(`[RemoteBuddy] Persistent memory: ${this.memoryEnabled ? "on" : "off"} crossSession=${this.memoryIncludeCrossSession ? "on" : "off"} recallItems=${this.memoryMaxRecallItems} recallChars=${this.memoryMaxRecallChars} retentionDays=${this.memoryRetentionDays}`);
@@ -10039,6 +10050,12 @@ Please reply with the missing details and I will enqueue a follow-up request.` :
     }
   }
   async ensureWorkerCapacityOnStartup() {
+    if (this.workerPrewarmDelayMs > 0) {
+      console.log(`[RemoteBuddy] Waiting ${this.workerPrewarmDelayMs}ms before WorkerPal startup prewarm.`);
+      await Bun.sleep(this.workerPrewarmDelayMs);
+      if (this.disposed)
+        return;
+    }
     const workers = await this.fetchWorkers();
     if (this.pickIdleWorker(workers)) {
       return;