@pushpalsdev/cli 1.0.82 → 1.0.84

package/package.json

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

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

@@ -1763,6 +1763,16 @@ var NODE_BACKED_CLI_NAMES = new Set([
   "vitest",
   "webpack"
 ]);
+var BUN_OPTIONS_WITH_VALUE = new Set(["--cwd", "-C"]);
+var PACKAGE_MANAGER_OPTIONS_WITH_VALUE = new Set([
+  "--cwd",
+  "--dir",
+  "--filter",
+  "--prefix",
+  "--workspace",
+  "-C",
+  "-F"
+]);
 // packages/shared/src/session_event_visibility.ts
 var ALWAYS_VISIBLE_EVENT_TYPES = new Set(["question_asked"]);
 // packages/shared/src/localbuddy_runtime.ts

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

@@ -3,7 +3,8 @@
  * Used by both the host Worker (direct mode) and the Docker job runner.
  */
 
-import { existsSync, readFileSync, rmSync, unlinkSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
 import { resolve } from "path";
 import {
   deriveAutonomyComponentArea,
@@ -556,6 +557,7 @@ async function runValidationCommand(
   const startedAt = Date.now();
   const proc = Bun.spawn(argv, {
     cwd: repo,
+    env: buildValidationCommandEnv(repo),
     stdout: "pipe",
     stderr: "pipe",
   });
@@ -590,6 +592,38 @@ async function runValidationCommand(
   };
 }
 
+function buildValidationCommandEnv(repo: string): Record<string, string> {
+  const homeDir = resolve(tmpdir(), "pushpals-validation-home");
+  const cacheDir = resolve(tmpdir(), "pushpals-validation-cache");
+  const expoDir = resolve(tmpdir(), "pushpals-validation-expo");
+  for (const dir of [homeDir, cacheDir, expoDir]) {
+    try {
+      mkdirSync(dir, { recursive: true });
+    } catch {
+      // Keep validation best-effort; the command output will expose any real env blocker.
+    }
+  }
+  const env: Record<string, string> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  return {
+    ...env,
+    HOME: homeDir,
+    USERPROFILE: homeDir,
+    XDG_CACHE_HOME: cacheDir,
+    npm_config_cache: resolve(cacheDir, "npm"),
+    EXPO_HOME: expoDir,
+    EXPO_NO_TELEMETRY: process.env.EXPO_NO_TELEMETRY ?? "1",
+    EXPO_NO_INTERACTIVE: process.env.EXPO_NO_INTERACTIVE ?? "1",
+    CI: process.env.CI ?? "1",
+    BROWSER: process.env.BROWSER ?? "none",
+    EXPO_DEV_SERVER_PORT: process.env.EXPO_DEV_SERVER_PORT ?? "19006",
+    RCT_METRO_PORT: process.env.RCT_METRO_PORT ?? "19006",
+    PUSHPALS_VALIDATION_REPO: repo,
+  };
+}
+
 interface ToolAvailabilityResult {
   requirement: ToolRequirement;
   ok: boolean;

package/runtime/sandbox/packages/shared/src/toolchain.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
-import { join, normalize } from "path";
+import { isAbsolute, join, normalize, resolve } from "path";
 
 export type ToolchainEnvironmentSource =
   | "devcontainer"
@@ -27,6 +27,7 @@ export interface BuildToolchainPlanOptions {
   repoRoot: string;
   validationCommands: string[];
   maxNativeScanEntries?: number;
+  maxScriptScanChars?: number;
 }
 
 const SHELL_CONTROL_TOKENS = new Set(["|", "||", "&", "&&", ";", ">", ">>", "<", "<<"]);
@@ -92,6 +93,17 @@ const DIRECT_TOOL_CANDIDATES: Record<string, string[]> = {
   yarn: ["yarn"],
 };
 
+const BUN_OPTIONS_WITH_VALUE = new Set(["--cwd", "-C"]);
+const PACKAGE_MANAGER_OPTIONS_WITH_VALUE = new Set([
+  "--cwd",
+  "--dir",
+  "--filter",
+  "--prefix",
+  "--workspace",
+  "-C",
+  "-F",
+]);
+
 interface NativeSignals {
   hasC: boolean;
   hasCxx: boolean;
@@ -144,7 +156,14 @@ export function buildToolchainPlan(options: BuildToolchainPlanOptions): Toolchai
   const nativeSignals = detectNativeSignals(repoRoot, options.maxNativeScanEntries ?? 1_000);
   const requirements: ToolRequirement[] = [];
   for (const command of options.validationCommands) {
-    requirements.push(...inferToolRequirementsForValidationCommand(repoRoot, command, nativeSignals));
+    requirements.push(
+      ...inferToolRequirementsForValidationCommand(
+        repoRoot,
+        command,
+        nativeSignals,
+        options.maxScriptScanChars ?? 64_000,
+      ),
+    );
   }
   return {
     requirements: dedupeToolRequirements(requirements),
@@ -156,6 +175,7 @@ export function inferToolRequirementsForValidationCommand(
   repoRoot: string,
   command: string,
   nativeSignals: NativeSignals = detectNativeSignals(repoRoot),
+  maxScriptScanChars = 64_000,
 ): ToolRequirement[] {
   const tokens = tokenizeToolchainCommand(command);
   if (!tokens) return [];
@@ -177,7 +197,18 @@ export function inferToolRequirementsForValidationCommand(
 
   const script = resolvePackageScript(repoRoot, tokens);
   if (script) {
-    addScriptRequirements(requirements, script.script, script.detectedFrom, command);
+    addScriptRequirements(
+      requirements,
+      repoRoot,
+      script.scriptCwd,
+      script.script,
+      script.detectedFrom,
+      command,
+      {
+        maxScriptScanChars,
+        depth: 0,
+      },
+    );
   }
 
   if (usesNativeBuildCommand(tokens)) {
@@ -257,17 +288,34 @@ function addNodeBackedCliRequirement(
 
 function addScriptRequirements(
   requirements: ToolRequirement[],
+  repoRoot: string,
+  scriptCwd: string,
   script: string,
   detectedFrom: string,
   command: string,
+  options: { maxScriptScanChars: number; depth: number },
 ): void {
   const tokens = tokenizeToolchainCommand(script) ?? script.split(/\s+/).filter(Boolean);
   const first = normalizeToolToken(tokens[0] ?? "");
-  addDirectExecutableRequirement(requirements, first, command);
+  // Package-manager scripts resolve Node CLIs from local node_modules/.bin. Requiring a
+  // global expo/vite/tsc binary creates false environment blockers for normal JS repos.
+  if (!NODE_BACKED_CLI_NAMES.has(first)) {
+    addDirectExecutableRequirement(requirements, first, command);
+  }
   addNodeBackedCliRequirement(requirements, first, detectedFrom, command);
   for (const token of tokens) {
     addNodeBackedCliRequirement(requirements, normalizeToolToken(token), detectedFrom, command);
   }
+  for (const scriptPath of inferReferencedScriptPaths(repoRoot, scriptCwd, tokens)) {
+    const scanned = scanScriptFileForToolRequirements(
+      requirements,
+      repoRoot,
+      scriptPath,
+      command,
+      options,
+    );
+    if (scanned) continue;
+  }
   if (/\bnode\b/.test(script)) {
     requirements.push({
       tool: "node",
@@ -288,13 +336,58 @@ function addScriptRequirements(
   }
 }
 
+function scanScriptFileForToolRequirements(
+  requirements: ToolRequirement[],
+  repoRoot: string,
+  scriptPath: string,
+  command: string,
+  options: { maxScriptScanChars: number; depth: number },
+): boolean {
+  if (options.depth > 2 || !existsSync(scriptPath)) return false;
+  let text = "";
+  try {
+    const stats = statSync(scriptPath);
+    if (!stats.isFile() || stats.size > options.maxScriptScanChars) return false;
+    text = readFileSync(scriptPath, "utf8");
+  } catch {
+    return false;
+  }
+  const detectedFrom = `${repoRelativePath(repoRoot, scriptPath)} referenced by validation command "${command}"`;
+  for (const cliName of NODE_BACKED_CLI_NAMES) {
+    const pattern = new RegExp(`(?:^|[^A-Za-z0-9_-])${escapeRegExp(cliName)}(?:$|[^A-Za-z0-9_-])`);
+    if (pattern.test(text)) {
+      addNodeBackedCliRequirement(requirements, cliName, detectedFrom, command);
+    }
+  }
+  if (/\bnode\b/.test(text)) {
+    requirements.push({
+      tool: "node",
+      candidates: ["node"],
+      reason: "referenced validation script invokes node directly",
+      detectedFrom,
+      requiredFor: [command],
+    });
+  }
+  if (/\bbun\b/.test(text)) {
+    requirements.push({
+      tool: "bun",
+      candidates: ["bun"],
+      reason: "referenced validation script invokes bun",
+      detectedFrom,
+      requiredFor: [command],
+    });
+  }
+  return true;
+}
+
 function resolveBunSubcommand(tokens: string[]): { kind: "run" | "x"; value: string } | null {
   if (normalizeToolToken(tokens[0] ?? "") !== "bun") return null;
   let index = 1;
   while (index < tokens.length) {
     const token = tokens[index] ?? "";
-    if (token === "--cwd" || token === "-C") {
-      index += 2;
+    const bunOption = parseOptionWithValue(token, BUN_OPTIONS_WITH_VALUE, tokens[index + 1]);
+    if (bunOption) {
+      index += bunOption.consumed;
       continue;
     }
     if (token.startsWith("--")) {
@@ -313,7 +406,7 @@ function resolveBunSubcommand(tokens: string[]): { kind: "run" | "x"; value: str
 function resolvePackageScript(
   repoRoot: string,
   tokens: string[],
-): { script: string; detectedFrom: string } | null {
+): { script: string; scriptCwd: string; detectedFrom: string } | null {
   const first = normalizeToolToken(tokens[0] ?? "");
   let cwd = repoRoot;
   let scriptName = "";
@@ -321,9 +414,10 @@ function resolvePackageScript(
     let index = 1;
     while (index < tokens.length) {
       const token = tokens[index] ?? "";
-      if ((token === "--cwd" || token === "-C") && tokens[index + 1]) {
-        cwd = join(repoRoot, tokens[index + 1] ?? "");
-        index += 2;
+      const bunOption = parseOptionWithValue(token, BUN_OPTIONS_WITH_VALUE, tokens[index + 1]);
+      if (bunOption) {
+        cwd = resolveWorkspacePath(repoRoot, bunOption.value);
+        index += bunOption.consumed;
         continue;
       }
       if (token.startsWith("--")) {
@@ -345,17 +439,31 @@ function resolvePackageScript(
     while (index < tokens.length) {
       const token = tokens[index] ?? "";
       const normalized = normalizeToolToken(token);
-      if (
-        (token === "--prefix" ||
-          token === "--dir" ||
-          token === "--cwd" ||
-          token === "-C") &&
-        tokens[index + 1]
-      ) {
-        cwd = join(repoRoot, tokens[index + 1] ?? "");
-        index += 2;
+      const packageOption = parseOptionWithValue(
+        token,
+        packageManagerOptionsWithValue(first),
+        tokens[index + 1],
+      );
+      if (packageOption) {
+        if (packageOption.name !== "--filter" && packageOption.name !== "-F") {
+          const optionCwd = resolvePackageOptionCwd(
+            repoRoot,
+            packageOption.name,
+            packageOption.value,
+          );
+          if (!optionCwd && isWorkspacePackageOption(packageOption.name)) return null;
+          if (optionCwd) cwd = optionCwd;
+        }
+        index += packageOption.consumed;
         continue;
       }
+      if (first === "yarn" && normalized === "workspace" && tokens[index + 2]) {
+        const workspaceCwd = resolveWorkspacePackageCwd(repoRoot, tokens[index + 1] ?? "");
+        if (!workspaceCwd) return null;
+        cwd = workspaceCwd;
+        scriptName = tokens[index + 2] ?? "";
+        break;
+      }
       if (normalized === "run") {
         scriptName = tokens[index + 1] ?? "";
         break;
@@ -379,6 +487,7 @@ function resolvePackageScript(
     if (typeof script !== "string" || !script.trim()) return null;
     return {
       script,
+      scriptCwd: cwd,
       detectedFrom: `${repoRelativePath(repoRoot, packagePath)} script "${scriptName}"`,
     };
   } catch {
@@ -386,6 +495,198 @@ function resolvePackageScript(
   }
 }
 
+function inferReferencedScriptPaths(repoRoot: string, scriptCwd: string, tokens: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const token of tokens) {
+    const normalized = normalizeReferencedScriptToken(token);
+    if (!normalized) continue;
+    const resolved = isAbsolute(normalized) ? normalized : join(scriptCwd, normalized);
+    const key = normalize(resolved);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(resolved);
+  }
+  return out;
+}
+
+function resolveWorkspacePath(repoRoot: string, pathValue: string): string {
+  return isAbsolute(pathValue) ? normalize(pathValue) : resolve(repoRoot, pathValue);
+}
+
+function resolvePackageOptionCwd(
+  repoRoot: string,
+  optionName: string,
+  optionValue: string,
+): string | null {
+  if (isWorkspacePackageOption(optionName)) {
+    return resolveWorkspacePackageCwd(repoRoot, optionValue);
+  }
+  const optionCwd = resolveWorkspacePath(repoRoot, optionValue);
+  return existsSync(join(optionCwd, "package.json")) ? optionCwd : null;
+}
+
+function resolveWorkspacePackageCwd(repoRoot: string, workspaceRef: string): string | null {
+  const directCwd = resolveWorkspacePath(repoRoot, workspaceRef);
+  if (existsSync(join(directCwd, "package.json"))) return directCwd;
+  for (const candidate of expandWorkspacePackageDirs(repoRoot)) {
+    try {
+      const parsed = JSON.parse(readFileSync(join(candidate, "package.json"), "utf8")) as {
+        name?: unknown;
+      };
+      if (parsed.name === workspaceRef) return candidate;
+    } catch {
+      // Ignore malformed workspace packages; validation will report real repo failures.
+    }
+  }
+  return null;
+}
+
+function expandWorkspacePackageDirs(repoRoot: string, maxPackages = 200): string[] {
+  const packageJsonPath = join(repoRoot, "package.json");
+  if (!existsSync(packageJsonPath)) return [];
+  let patterns: string[] = [];
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+      workspaces?: unknown;
+    };
+    if (Array.isArray(parsed.workspaces)) {
+      patterns = parsed.workspaces.filter((entry): entry is string => typeof entry === "string");
+    } else if (
+      parsed.workspaces &&
+      typeof parsed.workspaces === "object" &&
+      Array.isArray((parsed.workspaces as { packages?: unknown }).packages)
+    ) {
+      patterns = (parsed.workspaces as { packages: unknown[] }).packages.filter(
+        (entry): entry is string => typeof entry === "string",
+      );
+    }
+  } catch {
+    return [];
+  }
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const pattern of patterns) {
+    if (out.length >= maxPackages) break;
+    for (const candidate of expandWorkspacePattern(repoRoot, pattern, maxPackages - out.length)) {
+      const key = normalize(candidate);
+      if (seen.has(key) || !existsSync(join(candidate, "package.json"))) continue;
+      seen.add(key);
+      out.push(candidate);
+      if (out.length >= maxPackages) break;
+    }
+  }
+  return out;
+}
+
+function expandWorkspacePattern(repoRoot: string, pattern: string, maxPackages: number): string[] {
+  const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!normalizedPattern || normalizedPattern.startsWith("!")) return [];
+  const segments = normalizedPattern.split("/").filter(Boolean);
+  let dirs = [repoRoot];
+  for (const segment of segments) {
+    const next: string[] = [];
+    for (const dir of dirs) {
+      if (next.length >= maxPackages) break;
+      if (segment === "**") {
+        next.push(...collectDescendantDirs(dir, Math.max(0, maxPackages - next.length), 3));
+        continue;
+      }
+      if (segment.includes("*")) {
+        const patternRegex = wildcardSegmentRegex(segment);
+        for (const entry of safeReadDir(dir)) {
+          if (next.length >= maxPackages) break;
+          if (!patternRegex.test(entry)) continue;
+          const candidate = join(dir, entry);
+          if (safeIsDirectory(candidate)) next.push(candidate);
+        }
+        continue;
+      }
+      const candidate = join(dir, segment);
+      if (safeIsDirectory(candidate)) next.push(candidate);
+    }
+    dirs = next;
+    if (dirs.length === 0) break;
+  }
+  return dirs;
+}
+
+function collectDescendantDirs(dir: string, limit: number, maxDepth: number): string[] {
+  const out: string[] = [];
+  const visit = (current: string, depth: number) => {
+    if (out.length >= limit || depth > maxDepth) return;
+    for (const entry of safeReadDir(current)) {
+      if (entry === "node_modules" || entry === ".git") continue;
+      const candidate = join(current, entry);
+      if (!safeIsDirectory(candidate)) continue;
+      out.push(candidate);
+      visit(candidate, depth + 1);
+      if (out.length >= limit) return;
+    }
+  };
+  visit(dir, 0);
+  return out;
+}
+
+function safeReadDir(dir: string): string[] {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+function safeIsDirectory(pathValue: string): boolean {
+  try {
+    return statSync(pathValue).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function wildcardSegmentRegex(segment: string): RegExp {
+  return new RegExp(`^${segment.split("*").map(escapeRegExp).join(".*")}$`);
+}
+
+function isWorkspacePackageOption(optionName: string): boolean {
+  return optionName === "--workspace" || optionName === "-w";
+}
+
+function parseOptionWithValue(
+  token: string,
+  optionsWithValue: Set<string>,
+  nextToken?: string,
+): { name: string; value: string; consumed: number } | null {
+  const equalsIndex = token.indexOf("=");
+  if (equalsIndex > 0) {
+    const name = token.slice(0, equalsIndex);
+    if (!optionsWithValue.has(name)) return null;
+    const value = token.slice(equalsIndex + 1);
+    return value ? { name, value, consumed: 1 } : null;
+  }
+  if (!optionsWithValue.has(token) || !nextToken) return null;
+  return { name: token, value: nextToken, consumed: 2 };
+}
+
+function packageManagerOptionsWithValue(packageManager: string): Set<string> {
+  if (packageManager === "npm") {
+    return new Set([...PACKAGE_MANAGER_OPTIONS_WITH_VALUE, "-w"]);
+  }
+  return PACKAGE_MANAGER_OPTIONS_WITH_VALUE;
+}
+
+function normalizeReferencedScriptToken(token: string): string | null {
+  let normalized = token.replace(/\\/g, "/");
+  if (normalized.startsWith("-")) {
+    const equalsIndex = normalized.indexOf("=");
+    if (equalsIndex === -1) return null;
+    normalized = normalized.slice(equalsIndex + 1);
+  }
+  if (!/\.(cjs|cts|js|jsx|mjs|mts|ts|tsx)$/i.test(normalized)) return null;
+  if (normalized.includes("://")) return null;
+  return normalized;
+}
+
 function detectToolchainEnvironmentSource(repoRoot: string): ToolchainEnvironmentSource {
   if (existsSync(join(repoRoot, ".devcontainer", "devcontainer.json"))) return "devcontainer";
   if (existsSync(join(repoRoot, "devcontainer.json"))) return "devcontainer";
@@ -501,6 +802,10 @@ function normalizeToolToken(token: string): string {
   return normalizedToken.toLowerCase().replace(/\.(cmd|exe|ps1)$/i, "");
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 function repoRelativePath(repoRoot: string, pathValue: string): string {
   const root = normalize(repoRoot).replace(/\\/g, "/").replace(/\/+$/, "");
   const path = normalize(pathValue).replace(/\\/g, "/");