@pushpalsdev/cli 1.0.1 → 1.0.2

package/README.md

@@ -25,10 +25,16 @@ pushpals
 The CLI hard-fails if:
 
 - current directory is not a git repository
-- LocalBuddy is unavailable
 - LocalBuddy is attached to a different repo root
 - Bun runtime is not installed (for npm-installed entrypoint execution)
 
+Behavior:
+
+- If LocalBuddy is unavailable, CLI auto-start bootstraps embedded
+  `server + localbuddy + remotebuddy + source_control_manager`.
+- Runtime clone path defaults to `~/.pushpals/runtime`.
+- Disable auto-start with `pushpals --no-auto-start`.
+
 ## No npm/Bun install
 
 Download native binaries from GitHub Releases:

package/dist/pushpals-cli.js

@@ -2,8 +2,8 @@
 // @bun
 
 // ../../scripts/pushpals-cli.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname, resolve as resolve2 } from "path";
+import { copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, join as join2, resolve as resolve2 } from "path";
 import { createInterface } from "readline";
 
 // ../shared/src/config.ts
@@ -743,6 +743,9 @@ var MONITOR_SCAN_PORTS = 32;
 var HTTP_TIMEOUT_MS = 2500;
 var LOCALBUDDY_TIMEOUT_MS = 4000;
 var SSE_RECONNECT_MS = 1500;
+var DEFAULT_RUNTIME_BOOT_TIMEOUT_MS = 90000;
+var DEFAULT_RUNTIME_BOOT_POLL_MS = 1000;
+var DEFAULT_RUNTIME_REPO = "https://github.com/PushPalsDev/pushpals.git";
 var stateVersion = 1;
 function printUsage() {
   console.log("PushPals CLI");
@@ -755,6 +758,9 @@ function printUsage() {
   console.log("  --local-agent-url <url> Override LocalBuddy URL");
   console.log("  --session-id <id>      Override session ID");
   console.log("  --hub-url <url>        Override monitoring hub URL");
+  console.log("  --runtime-root <path>  Override embedded runtime directory for auto-start");
+  console.log("  --runtime-repo <url>   Override embedded runtime git clone URL");
+  console.log("  --no-auto-start        Disable runtime auto-start when LocalBuddy is down");
   console.log("  --no-stream            Disable live session event stream");
   console.log("  -h, --help             Show this help");
   console.log("");
@@ -766,10 +772,11 @@ function printUsage() {
   console.log("");
   console.log("Notes:");
   console.log("  - Must be run from inside a git repository.");
-  console.log("  - LocalBuddy must be running and attached to the same repo root.");
+  console.log("  - Auto-start can bootstrap server/localbuddy/remotebuddy/source_control_manager.");
+  console.log("  - LocalBuddy must be attached to the same repo root.");
 }
 function parseArgs(argv) {
-  const options = { noStream: false };
+  const options = { noAutoStart: false, noStream: false };
   for (let i = 0;i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "-h" || arg === "--help") {
@@ -780,6 +787,10 @@ function parseArgs(argv) {
       options.noStream = true;
       continue;
     }
+    if (arg === "--no-auto-start") {
+      options.noAutoStart = true;
+      continue;
+    }
     if (arg === "--server-url") {
       options.serverUrl = argv[++i];
       continue;
@@ -796,6 +807,14 @@ function parseArgs(argv) {
       options.monitoringHubUrl = argv[++i];
       continue;
     }
+    if (arg === "--runtime-root") {
+      options.runtimeRoot = argv[++i];
+      continue;
+    }
+    if (arg === "--runtime-repo") {
+      options.runtimeRepo = argv[++i];
+      continue;
+    }
     console.error(`[pushpals] Unknown argument: ${arg}`);
     printUsage();
     process.exit(2);
@@ -841,6 +860,114 @@ async function resolveCurrentGitRepoRoot(cwd) {
     return null;
   return resolve2(root.stdout);
 }
+async function runCommand(command, cwd, timeoutMs = 120000) {
+  const proc = Bun.spawn(command, {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const killTimer = setTimeout(() => {
+    try {
+      proc.kill();
+    } catch {}
+  }, timeoutMs);
+  try {
+    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
+    };
+  } finally {
+    clearTimeout(killTimer);
+  }
+}
+function resolveDefaultRuntimeRoot() {
+  const home = process.env.USERPROFILE || process.env.HOME || process.cwd();
+  return resolve2(home, ".pushpals", "runtime");
+}
+function copyFileIfMissing(fromPath, toPath) {
+  if (existsSync2(toPath) || !existsSync2(fromPath))
+    return;
+  mkdirSync(dirname(toPath), { recursive: true });
+  copyFileSync(fromPath, toPath);
+}
+async function ensureRuntimeCheckout(runtimeRoot, runtimeRepo) {
+  if (existsSync2(join2(runtimeRoot, ".git")))
+    return false;
+  mkdirSync(dirname(runtimeRoot), { recursive: true });
+  const clone = await runCommand(["git", "clone", "--depth", "1", runtimeRepo, runtimeRoot], dirname(runtimeRoot), 300000);
+  if (!clone.ok) {
+    throw new Error(`Failed to clone PushPals runtime from ${runtimeRepo} (exit ${clone.exitCode}): ${clone.stderr || clone.stdout || "unknown error"}`);
+  }
+  return true;
+}
+async function ensureRuntimePrepared(runtimeRoot) {
+  copyFileIfMissing(join2(runtimeRoot, ".env.example"), join2(runtimeRoot, ".env"));
+  copyFileIfMissing(join2(runtimeRoot, "configs", "local.example.toml"), join2(runtimeRoot, "configs", "local.toml"));
+  if (!existsSync2(join2(runtimeRoot, "node_modules"))) {
+    const install = await runCommand(["bun", "install"], runtimeRoot, 600000);
+    if (!install.ok) {
+      throw new Error(`Failed to install runtime dependencies (exit ${install.exitCode}): ${install.stderr || install.stdout || "unknown error"}`);
+    }
+  }
+  const protocolDist = join2(runtimeRoot, "packages", "protocol", "dist", "index.js");
+  if (!existsSync2(protocolDist)) {
+    const buildProtocol = await runCommand(["bun", "run", "--cwd", "packages/protocol", "build"], runtimeRoot, 300000);
+    if (!buildProtocol.ok) {
+      throw new Error(`Failed to build protocol package (exit ${buildProtocol.exitCode}): ${buildProtocol.stderr || buildProtocol.stdout || "unknown error"}`);
+    }
+  }
+}
+function spawnRuntimeService(name, command, cwd, env) {
+  const proc = Bun.spawn(command, {
+    cwd,
+    env,
+    stdout: "ignore",
+    stderr: "ignore"
+  });
+  const service = {
+    name,
+    proc,
+    exited: false,
+    exitCode: null
+  };
+  proc.exited.then((code) => {
+    service.exited = true;
+    service.exitCode = code;
+  });
+  return service;
+}
+function stopRuntimeServices(services) {
+  for (const service of services) {
+    try {
+      service.proc.kill();
+    } catch {}
+  }
+}
+async function probeServer(serverUrl) {
+  try {
+    const response = await fetchWithTimeout(`${serverUrl}/healthz`, {}, HTTP_TIMEOUT_MS);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function probeSourceControlManager(port) {
+  if (!Number.isFinite(port) || port <= 0)
+    return false;
+  try {
+    const response = await fetchWithTimeout(`http://127.0.0.1:${Math.floor(port)}/health`, {}, HTTP_TIMEOUT_MS);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
 async function fetchWithTimeout(url, init = {}, timeoutMs = HTTP_TIMEOUT_MS) {
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -868,6 +995,73 @@ function authHeaders(authToken) {
 async function probeLocalBuddy(localAgentUrl, authToken) {
   return await fetchJsonWithTimeout(`${localAgentUrl}/healthz`, { headers: authHeaders(authToken) }, LOCALBUDDY_TIMEOUT_MS);
 }
+async function autoStartRuntimeServices(opts) {
+  const runtimeRoot = resolve2(opts.runtimeRoot || process.env.PUSHPALS_RUNTIME_ROOT || resolveDefaultRuntimeRoot());
+  const runtimeRepo = String(opts.runtimeRepo || process.env.PUSHPALS_RUNTIME_REPO || DEFAULT_RUNTIME_REPO).trim();
+  console.log(`[pushpals] LocalBuddy unavailable. Auto-starting runtime for repo: ${opts.repoRoot}`);
+  console.log(`[pushpals] runtimeRoot=${runtimeRoot}`);
+  const cloned = await ensureRuntimeCheckout(runtimeRoot, runtimeRepo);
+  if (cloned) {
+    console.log(`[pushpals] Cloned runtime from ${runtimeRepo}`);
+  }
+  await ensureRuntimePrepared(runtimeRoot);
+  const runtimeEnv = {
+    ...process.env,
+    PUSHPALS_REPO_ROOT_OVERRIDE: opts.repoRoot,
+    PUSHPALS_PROMPTS_ROOT_OVERRIDE: runtimeRoot
+  };
+  const services = [];
+  const serverHealthy = await probeServer(opts.serverUrl);
+  if (!serverHealthy) {
+    console.log("[pushpals] Starting embedded server...");
+    services.push(spawnRuntimeService("server", ["bun", "--cwd", "apps/server", "--env-file", "../../.env", "dev"], runtimeRoot, runtimeEnv));
+  } else {
+    console.log("[pushpals] Server already healthy; skipping embedded server start.");
+  }
+  console.log("[pushpals] Starting embedded LocalBuddy...");
+  services.push(spawnRuntimeService("localbuddy", ["bun", "--cwd", "apps/localbuddy", "--env-file", "../../.env", "dev"], runtimeRoot, runtimeEnv));
+  console.log("[pushpals] Starting embedded RemoteBuddy...");
+  services.push(spawnRuntimeService("remotebuddy", ["bun", "--cwd", "apps/remotebuddy", "--env-file", "../../.env", "start"], runtimeRoot, runtimeEnv));
+  const scmHealthy = await probeSourceControlManager(opts.sourceControlManagerPort);
+  if (!scmHealthy) {
+    console.log("[pushpals] Starting embedded SourceControlManager...");
+    services.push(spawnRuntimeService("source_control_manager", [
+      "bun",
+      "--cwd",
+      "apps/source_control_manager",
+      "--env-file",
+      "../../.env",
+      "start",
+      "--",
+      "--skip-clean-check"
+    ], runtimeRoot, runtimeEnv));
+  } else {
+    console.log("[pushpals] SourceControlManager already healthy; skipping embedded start.");
+  }
+  const deadline = Date.now() + DEFAULT_RUNTIME_BOOT_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    for (let i = services.length - 1;i >= 0; i--) {
+      const service = services[i];
+      if (service.exited) {
+        if (service.name === "source_control_manager") {
+          console.warn(`[pushpals] Embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"}); continuing without SCM.`);
+          services.splice(i, 1);
+          continue;
+        }
+        stopRuntimeServices(services);
+        throw new Error(`Embedded ${service.name} exited during startup (code=${service.exitCode ?? "unknown"})`);
+      }
+    }
+    const health = await probeLocalBuddy(opts.localAgentUrl, opts.authToken);
+    if (health?.ok) {
+      console.log("[pushpals] Embedded runtime is ready.");
+      return services;
+    }
+    await Bun.sleep(DEFAULT_RUNTIME_BOOT_POLL_MS);
+  }
+  stopRuntimeServices(services);
+  throw new Error(`Timed out waiting for LocalBuddy at ${opts.localAgentUrl} after ${DEFAULT_RUNTIME_BOOT_TIMEOUT_MS}ms`);
+}
 function readCliState(pathValue) {
   if (!existsSync2(pathValue))
     return {};
@@ -1129,18 +1323,48 @@ async function main() {
   const localAgentUrl = normalizeUrl(parsed.localAgentUrl ?? process.env.EXPO_PUBLIC_LOCAL_AGENT_URL, config.client.localAgentUrl);
   const sessionId = String(parsed.sessionId ?? process.env.PUSHPALS_SESSION_ID ?? config.sessionId).trim();
   const authToken = config.authToken;
-  const health = await probeLocalBuddy(localAgentUrl, authToken);
+  let autoStartedServices = [];
+  const stopAutoStartedServices = () => {
+    if (autoStartedServices.length === 0)
+      return;
+    stopRuntimeServices(autoStartedServices);
+    autoStartedServices = [];
+  };
+  let health = await probeLocalBuddy(localAgentUrl, authToken);
+  if (!health?.ok && !parsed.noAutoStart) {
+    try {
+      autoStartedServices = await autoStartRuntimeServices({
+        repoRoot,
+        serverUrl,
+        localAgentUrl,
+        sourceControlManagerPort: config.sourceControlManager.port,
+        authToken,
+        runtimeRoot: parsed.runtimeRoot,
+        runtimeRepo: parsed.runtimeRepo
+      });
+      health = await probeLocalBuddy(localAgentUrl, authToken);
+    } catch (err) {
+      console.error(`[pushpals] Auto-start failed: ${String(err)}`);
+      stopAutoStartedServices();
+    }
+  }
   if (!health?.ok) {
     console.error(`[pushpals] LocalBuddy is unavailable at ${localAgentUrl}.`);
-    console.error("[pushpals] Start the stack first, then rerun `pushpals`.");
+    if (parsed.noAutoStart) {
+      console.error("[pushpals] Auto-start is disabled (--no-auto-start).");
+    } else {
+      console.error("[pushpals] Auto-start could not bring LocalBuddy online.");
+    }
     process.exit(1);
   }
   const localBuddyRepo = health.repo ? resolve2(health.repo) : "";
   if (!localBuddyRepo) {
+    stopAutoStartedServices();
     console.error("[pushpals] LocalBuddy health response did not include repo path.");
     process.exit(1);
   }
   if (normalizePath(localBuddyRepo) !== normalizePath(repoRoot)) {
+    stopAutoStartedServices();
     console.error("[pushpals] Repo mismatch detected.");
     console.error(`[pushpals] currentRepo=${repoRoot}`);
     console.error(`[pushpals] localBuddyRepo=${localBuddyRepo}`);
@@ -1194,6 +1418,7 @@ ${line}
     streamAbort.abort();
     if (rl)
       rl.close();
+    stopAutoStartedServices();
   };
   process.once("SIGINT", requestStop);
   process.once("SIGTERM", requestStop);

package/package.json

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