openmausbot 0.1.75 → 0.1.76

package/dist-server/server/env-path.js

@@ -207,8 +207,8 @@ function isFile(p) {
     }
 }
 /** PATHEXT-aware `which`. A path-ish cli is probed where it points. */
-function whichWin(cli) {
-    const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+function whichWin(cli, env) {
+    const exts = ((env ?? process.env).PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
     // an extensionless name is not runnable on Windows, so PATHEXT wins over
     // the bare file — npm installs both `claude` (a sh script) and `claude.cmd`
     const probe = (base) => {
@@ -217,7 +217,8 @@ function whichWin(cli) {
     };
     if (/[\\/]/.test(cli) || /^[a-zA-Z]:/.test(cli))
         return probe(cli);
-    for (const dir of augmentedPath().split(delimiter)) {
+    const path = env ? (env.PATH ?? env.Path ?? "") : augmentedPath();
+    for (const dir of path.split(delimiter)) {
         if (!dir)
             continue;
         const hit = probe(join(dir, cli));
@@ -229,20 +230,20 @@ function whichWin(cli) {
 /** node.exe to run a script with: the one npm's shim would pick, else PATH,
  * else this executable only when it really is Node. In a packaged app,
  * process.execPath is Electron and must never be mistaken for node.exe. */
-function nodeExe(near) {
+function nodeExe(near, env) {
     const local = join(near, "node.exe");
     if (isFile(local))
         return local;
     // Ask for the executable explicitly so a custom PATHEXT ordering cannot
     // make a stray node.cmd hide the real node.exe beside it.
-    const onPath = whichWin("node.exe");
+    const onPath = whichWin("node.exe", env);
     if (onPath && extname(onPath).toLowerCase() === ".exe")
         return onPath;
     return process.versions.electron ? null : process.execPath;
 }
 /** npm/pnpm .cmd shims all spell their target as "%dp0%\..." (or
  * "%~dp0\..."). Whatever of those exists on disk is what the shim runs. */
-function parseCmdShim(shim) {
+function parseCmdShim(shim, env) {
     let text;
     try {
         text = readFileSync(shim, "utf8");
@@ -256,7 +257,7 @@ function parseCmdShim(shim) {
         .filter((p) => isFile(p) && basename(p).toLowerCase() !== "node.exe");
     const script = targets.find((p) => /\.[cm]?js$/i.test(p));
     if (script) {
-        const node = nodeExe(dir);
+        const node = nodeExe(dir, env);
         if (node)
             return { command: node, args: [script] };
     }
@@ -265,7 +266,7 @@ function parseCmdShim(shim) {
 }
 /** `#!/usr/bin/env node` → `node <script>`. Only node: nothing else has a
  * meaningful Windows equivalent worth guessing at. */
-function parseNodeShebang(file) {
+function parseNodeShebang(file, env) {
     let head = "";
     let fd = null;
     try {
@@ -289,7 +290,7 @@ function parseNodeShebang(file) {
     }
     if (!/^#!.*\bnode(\.exe)?\b/.test(head))
         return null;
-    const node = nodeExe(dirname(file));
+    const node = nodeExe(dirname(file), env);
     return node ? { command: node, args: [file] } : null;
 }
 /**
@@ -297,31 +298,31 @@ function parseNodeShebang(file) {
  * everywhere but win32 — POSIX already resolves PATH and #! itself.
  */
 /** Resolve a single command word (no tokenizer) — the platform spawn rules. */
-function resolveWord(cli, args) {
+function resolveWord(cli, args, env) {
     if (process.platform !== "win32")
         return { command: cli, args };
-    const file = whichWin(cli);
+    const file = whichWin(cli, env);
     // not found: hand back the name so spawn reports its own ENOENT
     if (!file)
         return { command: cli, args };
     const ext = extname(file).toLowerCase();
     if (ext === ".cmd" || ext === ".bat") {
-        const direct = parseCmdShim(file);
+        const direct = parseCmdShim(file, env);
         return direct ? { command: direct.command, args: [...direct.args, ...args] } : { command: file, args };
     }
     if (ext === ".exe" || ext === ".com")
         return { command: file, args };
-    const viaNode = parseNodeShebang(file);
+    const viaNode = parseNodeShebang(file, env);
     return viaNode ? { command: viaNode.command, args: [...viaNode.args, ...args] } : { command: file, args };
 }
-export function resolveCliSpawn(cli, args) {
+export function resolveCliSpawn(cli, args, env) {
     // An EXISTING FILE wins over the tokenizer: paths with spaces come from
     // our own candidate list unquoted ("/Applications/My Tools/claude"), and
     // splitting those would shred them. Only a bare word (no spaces) or an
     // explicitly-quoted/wrapper string reaches the split below.
     const trimmed = cli.trim();
     if (trimmed.includes(" ") && existsSync(trimmed))
-        return resolveWord(trimmed, args);
+        return resolveWord(trimmed, args, env);
     // A `cli` value may carry fixed leading arguments — wrapper scripts like
     // `/usr/local/bin/ag claude agp` are one string in the Engines panel. ONE
     // tokenizer pass, then resolve the head directly (never re-tokenized: a
@@ -335,7 +336,7 @@ export function resolveCliSpawn(cli, args) {
         // empty input → hand the raw string to spawn so IT reports the ENOENT
         if (!head)
             return { command: cli, args };
-        return resolveWord(head, [...fixed, ...args]);
+        return resolveWord(head, [...fixed, ...args], env);
     }
-    return resolveWord(cli, args);
+    return resolveWord(cli, args, env);
 }