@proagentstore/cli 0.4.114 → 0.4.115

package/dist/browser-runner/coding/engine-check.js

@@ -1,20 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { accessSync, constants, statSync } from "node:fs";
+import { statSync } from "node:fs";
 import { homedir } from "node:os";
-import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { join } from "node:path";
 import { handlerFor } from "./handlers.js";
 import { parseCommand } from "./headless.js";
-function defaultIsExecutable(p) {
-    try {
-        if (!statSync(p).isFile())
-            return false;
-        accessSync(p, constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+import { resolveEngineSpawn } from "./engine-spawn.js";
 function defaultExists(p) {
     try {
         statSync(p);
@@ -29,28 +19,6 @@ function defaultKeychainItemStatus(service) {
     const r = spawnSync("security", ["find-generic-password", "-s", service], { stdio: "ignore", timeout: 5_000 });
     return r.error ? null : r.status;
 }
-/** The same resolution `spawn(bin)` does: a path is taken as-is, a bare name is searched on PATH. */
-export function resolveBinary(bin, deps = {}) {
-    const isExec = deps.isExecutable ?? defaultIsExecutable;
-    if (!bin)
-        return null;
-    if (bin.includes("/") || isAbsolute(bin)) {
-        const p = resolve(bin);
-        return isExec(p) ? p : null;
-    }
-    const env = deps.env ?? process.env;
-    const exts = (deps.platform ?? process.platform) === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
-    for (const dir of (env.PATH || "").split(delimiter)) {
-        if (!dir)
-            continue;
-        for (const ext of exts) {
-            const p = join(dir, bin + ext);
-            if (isExec(p))
-                return p;
-        }
-    }
-    return null;
-}
 /** Does this engine have a stored interactive login on the machine? */
 export function detectEngineLogin(engine, deps = {}) {
     const env = deps.env ?? process.env;
@@ -100,14 +68,14 @@ export function checkEngine(input, deps = {}) {
     const engine = (["claude", "gemini", "codex", "grok", "generic"].includes(input.clientType ?? "") ? input.clientType : "claude");
     const parsed = parseCommand(input.command);
     const bin = parsed.bin || parseCommand(handlerFor(engine).cliCommand).bin || engine;
-    const binaryPath = resolveBinary(bin, deps);
+    const { binaryPath, via } = resolveEngineSpawn(bin, [], deps);
     const login = input.credentialInjected ? { login: "found", where: "platform" } : detectEngineLogin(engine, deps);
     return {
         checked: true,
         engine,
         bin,
         binaryFound: binaryPath !== null,
-        ...(binaryPath ? { binaryPath } : {}),
+        ...(binaryPath ? { binaryPath, binaryVia: via } : {}),
         login: login.login,
         ...(login.where ? { loginWhere: login.where } : {}),
     };

package/dist/browser-runner/coding/engine-spawn.js

@@ -0,0 +1,99 @@
+import { accessSync, constants, readFileSync, statSync } from "node:fs";
+import { posix, win32 } from "node:path";
+function defaultIsExecutable(p) {
+    try {
+        if (!statSync(p).isFile())
+            return false;
+        accessSync(p, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultReadText(p) {
+    try {
+        return readFileSync(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Windows env names are case-insensitive, but a copied env object is not (`Path`, `ComSpec`). */
+function envVar(env, name, windows) {
+    if (!windows)
+        return env[name];
+    const key = Object.keys(env).find((k) => k.toUpperCase() === name);
+    return key ? env[key] : undefined;
+}
+const isPathLike = (bin, windows) => bin.includes("/") || (windows ? bin.includes("\\") || win32.isAbsolute(bin) : posix.isAbsolute(bin));
+/** The same resolution `spawn(bin)` does: a path is taken as-is, a bare name is searched on PATH (with PATHEXT on Windows). */
+export function resolveBinary(bin, deps = {}) {
+    const isExec = deps.isExecutable ?? defaultIsExecutable;
+    if (!bin)
+        return null;
+    const windows = (deps.platform ?? process.platform) === "win32";
+    const path = windows ? win32 : posix;
+    if (isPathLike(bin, windows)) {
+        const p = path.resolve(bin);
+        return isExec(p) ? p : null;
+    }
+    const env = deps.env ?? process.env;
+    const exts = windows ? (envVar(env, "PATHEXT", true) || ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of (envVar(env, "PATH", windows) || "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const p = path.join(dir, bin + ext);
+            if (isExec(p))
+                return p;
+        }
+    }
+    return null;
+}
+/** The first `%dp0%\node_modules\…` target an npm (cmd-shim) `.cmd` launches, absolute. */
+export function shimTarget(shimPath, text) {
+    const m = /"%~?dp0%?\\(node_modules\\[^"]+)"/i.exec(text);
+    return m ? win32.join(win32.dirname(shimPath), m[1]) : null;
+}
+// cmd.exe metacharacters (cross-spawn's set). A caret makes the next one literal for one parse.
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+/**
+ * One argument for `cmd.exe /s /c "<shim> <args>"`: quoted for the CRT's argv parser, then
+ * caret-escaped twice — once for cmd's own parse, once more for the shim's `%*` re-parse.
+ */
+export function quoteCmdArg(arg) {
+    let a = arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1");
+    a = `"${a}"`;
+    return a.replace(CMD_META, "^$1").replace(CMD_META, "^$1");
+}
+export function resolveEngineSpawn(bin, args, deps = {}) {
+    const windows = (deps.platform ?? process.platform) === "win32";
+    if (!windows)
+        return { command: bin, args, binaryPath: resolveBinary(bin, deps), via: "direct" };
+    const env = deps.env ?? process.env;
+    // Real executables first: PATHEXT order would otherwise pick `.CMD` over a later `.EXE` in no order we chose.
+    const exe = resolveBinary(bin, { ...deps, env: { ...env, PATHEXT: ".exe;.com" } });
+    const found = exe ?? resolveBinary(bin, { ...deps, env: { ...env, PATHEXT: ".cmd;.bat" } });
+    if (!found)
+        return { command: bin, args, binaryPath: null, via: "direct" };
+    if (!/\.(cmd|bat)$/i.test(found))
+        return { command: found, args, binaryPath: found, via: "direct" };
+    const isExec = deps.isExecutable ?? defaultIsExecutable;
+    const text = (deps.readText ?? defaultReadText)(found);
+    const target = text ? shimTarget(found, text) : null;
+    if (target && isExec(target)) {
+        if (/\.(exe|com)$/i.test(target))
+            return { command: target, args, binaryPath: target, via: "direct" };
+        if (/\.[cm]?js$/i.test(target))
+            return { command: deps.nodePath ?? process.execPath, args: [target, ...args], binaryPath: target, via: "node" };
+    }
+    const line = [found.replace(CMD_META, "^$1"), ...args.map(quoteCmdArg)].join(" ");
+    return {
+        command: envVar(env, "COMSPEC", true) || "cmd.exe",
+        args: ["/d", "/s", "/c", `"${line}"`],
+        windowsVerbatimArguments: true,
+        binaryPath: found,
+        via: "cmd",
+    };
+}

package/dist/browser-runner/coding/headless.js

@@ -7,6 +7,7 @@ import { appendTurnTail, turnReportFromExit, turnReportFromResult } from "./engi
 import { renderToolResult, shortInput, stripAnsi } from "./transcript-lines.js";
 import { authoredTurn, authorTag } from "./turn-author.js";
 import { engineSpawnEnv, mergeEnv } from "./engine-env.js";
+import { resolveEngineSpawn } from "./engine-spawn.js";
 import { ghGuardStatus } from "./gh-guard.js";
 import { handlerFor } from "./handlers.js";
 import { resolveEngineAuth } from "./engine-auth.js";
@@ -426,10 +427,13 @@ export class HeadlessSession {
         this.inputs.newEngine();
         this.buf = "";
         const args = this.adapter.buildLaunchArgs(this.cmdArgs, this.claudeSessionId);
-        const proc = spawn(this.cmdBin, args, {
+        const env = this.spawnEnv;
+        const launch = resolveEngineSpawn(this.cmdBin, args, { env });
+        const proc = spawn(launch.command, launch.args, {
             cwd: this.config.workDir,
-            env: this.spawnEnv,
+            env,
             stdio: ["pipe", "pipe", "pipe"],
+            windowsVerbatimArguments: launch.windowsVerbatimArguments,
         });
         this.proc = proc;
         this.run = "idle";
@@ -582,10 +586,13 @@ export class HeadlessSession {
         const turnArgs = resumedCodexThreadId
             ? buildCodexResumeArgs(this.cmdArgs, resumedCodexThreadId, text)
             : this.adapter.buildTurnArgs(this.cmdArgs, text);
-        const proc = spawn(this.cmdBin, turnArgs, {
+        const env = this.spawnEnv;
+        const launch = resolveEngineSpawn(this.cmdBin, turnArgs, { env });
+        const proc = spawn(launch.command, launch.args, {
             cwd: this.config.workDir,
-            env: this.spawnEnv,
+            env,
             stdio: ["ignore", "pipe", "pipe"],
+            windowsVerbatimArguments: launch.windowsVerbatimArguments,
         });
         // A turn already running is aborted before its replacement starts: `input()` accepts a turn
         // at any time — a human typing in the console, a takeover, a Loop that stopped waiting —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.114",
+  "version": "0.4.115",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",