@pushpalsdev/cli 1.0.2 → 1.0.3

package/README.md

@@ -32,7 +32,9 @@ Behavior:
 
 - If LocalBuddy is unavailable, CLI auto-start bootstraps embedded
   `server + localbuddy + remotebuddy + source_control_manager`.
-- Runtime clone path defaults to `~/.pushpals/runtime`.
+- Auto-start does not clone the PushPals repo; it downloads release-tagged runtime binaries
+  and prompt/config assets into `~/.pushpals/runtime`.
+- Override runtime tag with `pushpals --runtime-tag vX.Y.Z`.
 - Disable auto-start with `pushpals --no-auto-start`.
 
 ## No npm/Bun install

package/bin/pushpals.cjs

@@ -2,11 +2,21 @@
 "use strict";
 
 const { spawn, spawnSync } = require("node:child_process");
-const { existsSync } = require("node:fs");
+const { existsSync, readFileSync } = require("node:fs");
 const { 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";
+let packageVersion = "";
+if (existsSync(packageJsonPath)) {
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    packageVersion = String(parsed?.version ?? "").trim();
+  } catch {
+    packageVersion = "";
+  }
+}
 
 function fail(lines) {
   for (const line of lines) {
@@ -41,10 +51,15 @@ if (!hasBunRuntime()) {
 }
 
 function spawnBunCli() {
+  const childEnv = {
+    ...process.env,
+    PUSHPALS_CLI_PACKAGE_VERSION: packageVersion || process.env.PUSHPALS_CLI_PACKAGE_VERSION || "",
+  };
+
   if (process.platform !== "win32") {
     return spawn("bun", [bundledCliPath, ...process.argv.slice(2)], {
       stdio: "inherit",
-      env: process.env,
+      env: childEnv,
     });
   }
 
@@ -57,7 +72,7 @@ function spawnBunCli() {
   return spawn(commandLine, {
     shell: true,
     stdio: "inherit",
-    env: process.env,
+    env: childEnv,
   });
 }
 

package/dist/pushpals-cli.js

@@ -2,7 +2,7 @@
 // @bun
 
 // ../../scripts/pushpals-cli.ts
-import { copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { chmodSync, cpSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { dirname, join as join2, resolve as resolve2 } from "path";
 import { createInterface } from "readline";
 
@@ -250,10 +250,12 @@ function resolveLlmConfig(serviceNode, envPrefix, defaults, globalSessionId) {
   };
 }
 function loadPushPalsConfig(options = {}) {
-  const projectRoot = resolve(options.projectRoot ?? PROJECT_ROOT);
-  const configDir = resolveRuntimeConfigDir(projectRoot, options.configDir);
+  const projectRootOverride = firstNonEmpty(options.projectRoot, process.env.PUSHPALS_PROJECT_ROOT_OVERRIDE, PROJECT_ROOT);
+  const projectRoot = resolve(projectRootOverride);
+  const configDirOverride = firstNonEmpty(options.configDir, process.env.PUSHPALS_CONFIG_DIR_OVERRIDE, "");
+  const configDir = resolveRuntimeConfigDir(projectRoot, configDirOverride);
   const legacyConfigDir = resolvePathFromRoot(projectRoot, LEGACY_CONFIG_DIR);
-  const fallbackConfigDir = !options.configDir && configDir !== legacyConfigDir ? legacyConfigDir : "";
+  const fallbackConfigDir = !configDirOverride && configDir !== legacyConfigDir ? legacyConfigDir : "";
   const cacheKey = `${projectRoot}::${configDir}::${process.env.PUSHPALS_PROFILE ?? ""}`;
   if (!options.reload && cachedConfig && cachedConfigKey === cacheKey) {
     return cachedConfig;
@@ -745,7 +747,14 @@ 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 GITHUB_OWNER = "PushPalsDev";
+var GITHUB_REPO = "pushpals";
+var GITHUB_API_URL = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}`;
+var GITHUB_RELEASE_URL = `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/releases/download`;
+var GITHUB_HEADERS = {
+  Accept: "application/vnd.github+json",
+  "User-Agent": "pushpals-cli"
+};
 var stateVersion = 1;
 function printUsage() {
   console.log("PushPals CLI");
@@ -759,7 +768,7 @@ function printUsage() {
   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("  --runtime-tag <tag>    Override runtime release tag (e.g. v1.0.2)");
   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");
@@ -811,8 +820,8 @@ function parseArgs(argv) {
       options.runtimeRoot = argv[++i];
       continue;
     }
-    if (arg === "--runtime-repo") {
-      options.runtimeRepo = argv[++i];
+    if (arg === "--runtime-tag") {
+      options.runtimeTag = argv[++i];
       continue;
     }
     console.error(`[pushpals] Unknown argument: ${arg}`);
@@ -860,69 +869,157 @@ 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))
+function parseSemverFromPackageVersion(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw)
+    return "";
+  const match = raw.match(/^\d+\.\d+\.\d+(?:[-.][0-9A-Za-z.-]+)?$/);
+  return match ? raw : "";
+}
+function resolveRuntimePlatformKey() {
+  if (process.platform === "win32")
+    return "windows-x64";
+  if (process.platform === "linux")
+    return "linux-x64";
+  if (process.platform === "darwin") {
+    return process.arch === "arm64" ? "macos-arm64" : "macos-x64";
+  }
+  throw new Error(`Unsupported platform for embedded runtime binaries: ${process.platform}/${process.arch}`);
+}
+async function fetchLatestReleaseTag() {
+  const response = await fetchWithTimeout(`${GITHUB_API_URL}/releases/latest`, { headers: GITHUB_HEADERS }, 20000);
+  if (!response.ok) {
+    throw new Error(`Failed to resolve latest release tag (HTTP ${response.status})`);
+  }
+  const payload = await response.json();
+  const tagName = String(payload.tag_name ?? "").trim();
+  if (!tagName)
+    throw new Error("Latest release payload did not include tag_name");
+  return tagName;
+}
+async function resolveRuntimeReleaseTag(explicitTag) {
+  const fromArg = String(explicitTag ?? "").trim();
+  if (fromArg)
+    return fromArg;
+  const fromEnv = String(process.env.PUSHPALS_RUNTIME_TAG ?? "").trim();
+  if (fromEnv)
+    return fromEnv;
+  const packageVersion = parseSemverFromPackageVersion(process.env.PUSHPALS_CLI_PACKAGE_VERSION);
+  if (packageVersion)
+    return `v${packageVersion}`;
+  return await fetchLatestReleaseTag();
+}
+function writeTextFileIfMissing(pathValue, text) {
+  if (existsSync2(pathValue))
     return;
-  mkdirSync(dirname(toPath), { recursive: true });
-  copyFileSync(fromPath, toPath);
+  mkdirSync(dirname(pathValue), { recursive: true });
+  writeFileSync(pathValue, text, "utf8");
 }
-async function ensureRuntimeCheckout(runtimeRoot, runtimeRepo) {
-  if (existsSync2(join2(runtimeRoot, ".git")))
+function copyBundledRuntimeAssets(runtimeRoot) {
+  const bundledRoot = resolve2(import.meta.dir, "..", "runtime");
+  if (!existsSync2(bundledRoot))
     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"}`);
-  }
+  cpSync(bundledRoot, runtimeRoot, { recursive: true, force: true });
   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"}`);
+async function fetchTextFromUrl(url, timeoutMs = 20000) {
+  const response = await fetchWithTimeout(url, { headers: GITHUB_HEADERS }, timeoutMs);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} while fetching ${url}`);
+  }
+  return await response.text();
+}
+async function downloadRuntimeAssetsFromSourceTag(runtimeRoot, tag) {
+  const treeUrl = `${GITHUB_API_URL}/git/trees/${encodeURIComponent(tag)}?recursive=1`;
+  const treeResponse = await fetchWithTimeout(treeUrl, { headers: GITHUB_HEADERS }, 30000);
+  if (!treeResponse.ok) {
+    throw new Error(`Failed to fetch runtime source tree for ${tag} (HTTP ${treeResponse.status})`);
+  }
+  const treePayload = await treeResponse.json();
+  const paths = (treePayload.tree ?? []).filter((entry) => entry.type === "blob" && typeof entry.path === "string").map((entry) => String(entry.path)).filter((pathValue) => pathValue === ".env.example" || pathValue.startsWith("configs/") || pathValue.startsWith("prompts/"));
+  if (paths.length === 0) {
+    throw new Error(`Runtime source tree for ${tag} did not include prompts/config assets`);
+  }
+  const sorted = [...paths].sort((a, b) => a.localeCompare(b));
+  for (const pathValue of sorted) {
+    const rawUrl = `https://raw.githubusercontent.com/${GITHUB_OWNER}/${GITHUB_REPO}/${encodeURIComponent(tag)}/${pathValue}`;
+    const body = await fetchTextFromUrl(rawUrl, 20000);
+    const outPath = join2(runtimeRoot, pathValue);
+    mkdirSync(dirname(outPath), { recursive: true });
+    writeFileSync(outPath, body, "utf8");
+  }
+}
+async function ensureRuntimeAssets(runtimeRoot, runtimeTag) {
+  const markerPath = join2(runtimeRoot, ".runtime-assets-tag");
+  const currentTag = existsSync2(markerPath) ? readFileSync2(markerPath, "utf8").trim() : "";
+  const hasAssets = existsSync2(join2(runtimeRoot, ".env.example")) && existsSync2(join2(runtimeRoot, "configs", "default.toml")) && existsSync2(join2(runtimeRoot, "prompts"));
+  if (!hasAssets || currentTag !== runtimeTag) {
+    const copied = copyBundledRuntimeAssets(runtimeRoot);
+    if (!copied) {
+      await downloadRuntimeAssetsFromSourceTag(runtimeRoot, runtimeTag);
     }
+    writeFileSync(markerPath, `${runtimeTag}
+`, "utf8");
+  }
+  writeTextFileIfMissing(join2(runtimeRoot, ".env"), `# Local PushPals runtime environment
+`);
+  const localExamplePath = join2(runtimeRoot, "configs", "local.example.toml");
+  if (existsSync2(localExamplePath)) {
+    writeTextFileIfMissing(join2(runtimeRoot, "configs", "local.toml"), readFileSync2(localExamplePath, "utf8"));
+  } else {
+    writeTextFileIfMissing(join2(runtimeRoot, "configs", "local.toml"), `# Local PushPals runtime overrides
+`);
   }
-  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 runtimeBinaryFilename(serviceName, platformKey) {
+  const serviceToken = serviceName === "source_control_manager" ? "source-control-manager" : serviceName;
+  const extension = platformKey.startsWith("windows-") ? ".exe" : "";
+  return `pushpals-runtime-${serviceToken}-${platformKey}${extension}`;
+}
+async function downloadBinaryAsset(tag, assetName, outPath) {
+  const url = `${GITHUB_RELEASE_URL}/${encodeURIComponent(tag)}/${assetName}`;
+  const response = await fetchWithTimeout(url, { headers: GITHUB_HEADERS }, 60000);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${assetName} from ${tag} (HTTP ${response.status})`);
+  }
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  mkdirSync(dirname(outPath), { recursive: true });
+  await Bun.write(outPath, bytes);
+}
+async function ensureRuntimeBinaries(runtimeRoot, runtimeTag) {
+  const platformKey = resolveRuntimePlatformKey();
+  const binDir = join2(runtimeRoot, "bin", `${runtimeTag}-${platformKey}`);
+  mkdirSync(binDir, { recursive: true });
+  const runtimeBinaries = {
+    server: join2(binDir, runtimeBinaryFilename("server", platformKey)),
+    localbuddy: join2(binDir, runtimeBinaryFilename("localbuddy", platformKey)),
+    remotebuddy: join2(binDir, runtimeBinaryFilename("remotebuddy", platformKey)),
+    sourceControlManager: join2(binDir, runtimeBinaryFilename("source_control_manager", platformKey))
+  };
+  const requiredAssets = [
+    runtimeBinaries.server,
+    runtimeBinaries.localbuddy,
+    runtimeBinaries.remotebuddy,
+    runtimeBinaries.sourceControlManager
+  ];
+  for (const binaryPath of requiredAssets) {
+    if (existsSync2(binaryPath))
+      continue;
+    const assetName = binaryPath.split(/[\\/]/).pop() || "";
+    await downloadBinaryAsset(runtimeTag, assetName, binaryPath);
+  }
+  if (process.platform !== "win32") {
+    for (const binaryPath of requiredAssets) {
+      try {
+        chmodSync(binaryPath, 493);
+      } catch {}
     }
   }
+  return runtimeBinaries;
 }
 function spawnRuntimeService(name, command, cwd, env) {
   const proc = Bun.spawn(command, {
@@ -997,44 +1094,35 @@ async function probeLocalBuddy(localAgentUrl, authToken) {
 }
 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();
+  const runtimeTag = await resolveRuntimeReleaseTag(opts.runtimeTag);
+  const runtimeBinaries = await ensureRuntimeBinaries(runtimeRoot, runtimeTag);
+  await ensureRuntimeAssets(runtimeRoot, runtimeTag);
   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);
+  console.log(`[pushpals] runtimeTag=${runtimeTag}`);
   const runtimeEnv = {
     ...process.env,
     PUSHPALS_REPO_ROOT_OVERRIDE: opts.repoRoot,
+    PUSHPALS_PROJECT_ROOT_OVERRIDE: opts.repoRoot,
+    PUSHPALS_CONFIG_DIR_OVERRIDE: join2(runtimeRoot, "configs"),
     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));
+    services.push(spawnRuntimeService("server", [runtimeBinaries.server], opts.repoRoot, 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));
+  services.push(spawnRuntimeService("localbuddy", [runtimeBinaries.localbuddy], opts.repoRoot, runtimeEnv));
   console.log("[pushpals] Starting embedded RemoteBuddy...");
-  services.push(spawnRuntimeService("remotebuddy", ["bun", "--cwd", "apps/remotebuddy", "--env-file", "../../.env", "start"], runtimeRoot, runtimeEnv));
+  services.push(spawnRuntimeService("remotebuddy", [runtimeBinaries.remotebuddy], opts.repoRoot, 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));
+    services.push(spawnRuntimeService("source_control_manager", [runtimeBinaries.sourceControlManager, "--skip-clean-check"], opts.repoRoot, runtimeEnv));
   } else {
     console.log("[pushpals] SourceControlManager already healthy; skipping embedded start.");
   }
@@ -1340,7 +1428,7 @@ async function main() {
         sourceControlManagerPort: config.sourceControlManager.port,
         authToken,
         runtimeRoot: parsed.runtimeRoot,
-        runtimeRepo: parsed.runtimeRepo
+        runtimeTag: parsed.runtimeTag
       });
       health = await probeLocalBuddy(localAgentUrl, authToken);
     } catch (err) {

package/package.json

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