@wrongstack/tools 0.273.0 → 0.274.0

package/dist/index.js

@@ -7,11 +7,12 @@ import { spawn, execFileSync } from 'node:child_process';
 import * as os2 from 'node:os';
 import * as fs8 from 'node:fs';
 import { statSync, mkdirSync, createWriteStream } from 'node:fs';
+import { toErrorMessage as toErrorMessage$1 } from '@wrongstack/core/utils/error';
 import * as dns from 'node:dns/promises';
 import * as net from 'node:net';
 import { Agent } from 'undici';
 import TurndownService from 'turndown';
-import { toErrorMessage as toErrorMessage$1 } from '@wrongstack/core/utils';
+import { toErrorMessage as toErrorMessage$2 } from '@wrongstack/core/utils';
 import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
@@ -777,7 +778,27 @@ async function globNative(pattern, base, extraGlob) {
   await walk(base);
   return results;
 }
+
+// src/_concurrency.ts
+async function mapWithConcurrency(items, limit, fn) {
+  if (items.length === 0) return [];
+  const effectiveLimit = Math.max(1, Math.min(limit | 0, items.length));
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker2 = async () => {
+    while (true) {
+      const i = nextIndex++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: effectiveLimit }, worker2));
+  return results;
+}
+
+// src/glob.ts
 var DEFAULT_IGNORE2 = ["node_modules", ".git", "dist", "build", ".next", "coverage", ".turbo"];
+var WALK_CONCURRENCY = 16;
 var globTool = {
   name: "glob",
   category: "Filesystem",
@@ -815,6 +836,22 @@ var globTool = {
     const re = compileGlob(input.pattern);
     const results = [];
     let truncated = false;
+    const pushResult = async (full) => {
+      if (truncated || results.length >= limit) {
+        truncated = true;
+        return;
+      }
+      try {
+        const st = await fs7.stat(full);
+        if (truncated || results.length >= limit) {
+          truncated = true;
+          return;
+        }
+        results.push({ rel: full, mtime: st.mtimeMs });
+        if (results.length >= limit) truncated = true;
+      } catch {
+      }
+    };
     const walk = async (dir, relPrefix) => {
       if (results.length >= limit) {
         truncated = true;
@@ -826,6 +863,8 @@ var globTool = {
       } catch {
         return;
       }
+      const subdirs = [];
+      const matchedFiles = [];
       for (const e of entries) {
         const name = e.name;
         if (DEFAULT_IGNORE2.includes(name)) continue;
@@ -833,22 +872,36 @@ var globTool = {
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
         const full = path.join(dir, name);
         if (e.isDirectory()) {
-          await walk(full, rel);
-          if (truncated) return;
+          subdirs.push({ full, rel });
         } else if (e.isFile()) {
-          if (re.test(rel) || re.test(name)) {
-            try {
-              const st = await fs7.stat(full);
-              results.push({ rel: full, mtime: st.mtimeMs });
-              if (results.length >= limit) {
-                truncated = true;
-                return;
-              }
-            } catch {
+          re.lastIndex = 0;
+          const relMatch = re.test(rel);
+          re.lastIndex = 0;
+          const nameMatch = re.test(name);
+          if (relMatch || nameMatch) {
+            matchedFiles.push(full);
+          }
+        } else if (e.isSymbolicLink()) {
+          try {
+            const st = await fs7.stat(full);
+            if (st.isDirectory()) {
+              subdirs.push({ full, rel });
+            } else if (st.isFile()) {
+              re.lastIndex = 0;
+              const relMatch = re.test(rel);
+              re.lastIndex = 0;
+              const nameMatch = re.test(name);
+              if (relMatch || nameMatch) matchedFiles.push(full);
             }
+          } catch {
           }
         }
+        if (truncated) return;
       }
+      await mapWithConcurrency(matchedFiles, WALK_CONCURRENCY, pushResult);
+      if (truncated) return;
+      const remainingSubdirs = truncated ? [] : subdirs;
+      await mapWithConcurrency(remainingSubdirs, WALK_CONCURRENCY, ({ full, rel }) => walk(full, rel));
     };
     await walk(base, "");
     results.sort((a, b) => b.mtime - a.mtime);
@@ -865,6 +918,8 @@ async function readGitignore(dir) {
 }
 var DEFAULT_IGNORE3 = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
 var NATIVE_SCAN_CONCURRENCY = 32;
+var NATIVE_READ_CHUNK_BYTES = 64 * 1024;
+var NATIVE_MAX_FILE_BYTES = 1e6;
 var grepTool = {
   name: "grep",
   category: "Search",
@@ -1089,7 +1144,8 @@ async function runNative(input, base, mode, limit, signal) {
   const re = compiled.regex;
   const globRe = input.glob ? compileGlob(input.glob) : null;
   const matches = [];
-  const fileMatches = /* @__PURE__ */ new Map();
+  const countOnlyFirstHit = mode === "count" && limit === 1;
+  const maxBytes = mode === "content" ? NATIVE_MAX_FILE_BYTES : Math.min(NATIVE_MAX_FILE_BYTES, 256 * 1024);
   let total = 0;
   let stopped = false;
   const scanFile = async (full, name) => {
@@ -1098,34 +1154,79 @@ async function runNative(input, base, mode, limit, signal) {
     if (globRe) globRe.lastIndex = 0;
     try {
       const stat11 = await fs7.stat(full);
-      if (stat11.size > 1e6 || stopped || signal.aborted) return;
-      const head = await fs7.readFile(full);
-      if (isBinaryBuffer(head) || stopped || signal.aborted) return;
-      const text = head.toString("utf8");
-      const lines = text.split(/\r?\n/);
-      let fileHits = 0;
-      for (let i = 0; i < lines.length; i++) {
-        if (stopped || signal.aborted) break;
-        const ln = capSubject(lines[i] ?? "");
-        re.lastIndex = 0;
-        if (re.test(ln)) {
-          fileHits++;
-          total++;
-          if (mode === "content" && matches.length < limit) {
-            matches.push(`${full}:${i + 1}:${ln}`);
+      if (!stat11.isFile() || stat11.size > maxBytes || stopped || signal.aborted) return;
+      const file = await fs7.open(full, "r");
+      try {
+        let bytesReadTotal = 0;
+        let lineNumber = 0;
+        let fileHits = 0;
+        let leftover = "";
+        let binaryChecked = false;
+        const buffer = Buffer.allocUnsafe(Math.min(NATIVE_READ_CHUNK_BYTES, maxBytes));
+        while (!stopped && !signal.aborted && bytesReadTotal < maxBytes) {
+          const remaining = maxBytes - bytesReadTotal;
+          const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, remaining), null);
+          if (bytesRead === 0) break;
+          const chunk = buffer.subarray(0, bytesRead);
+          if (!binaryChecked) {
+            binaryChecked = true;
+            if (isBinaryBuffer(chunk)) return;
+          }
+          bytesReadTotal += bytesRead;
+          const text = leftover + chunk.toString("utf8");
+          const lines = text.split(/\r?\n/);
+          leftover = lines.pop() ?? "";
+          for (const rawLine of lines) {
+            if (stopped || signal.aborted) break;
+            lineNumber++;
+            const ln = capSubject(rawLine);
+            re.lastIndex = 0;
+            if (!re.test(ln)) continue;
+            fileHits++;
+            total++;
+            if (mode === "content") {
+              if (matches.length < limit) matches.push(`${full}:${lineNumber}:${ln}`);
+            } else if (mode === "files_with_matches") {
+              if (fileHits === 1 && matches.length < limit) matches.push(full);
+              break;
+            } else if (fileHits === 1 && matches.length < limit) {
+              matches.push(`${full}:${countOnlyFirstHit ? 1 : 0}`);
+            }
+            if (countOnlyFirstHit || mode !== "content" && matches.length >= limit) {
+              stopped = true;
+              break;
+            }
           }
+          if (mode === "files_with_matches" && fileHits > 0) break;
         }
-      }
-      if (fileHits > 0) {
-        fileMatches.set(full, fileHits);
-        if (mode === "files_with_matches" && matches.length < limit) {
-          matches.push(full);
+        if (!stopped && !signal.aborted && leftover.length > 0) {
+          lineNumber++;
+          const ln = capSubject(leftover);
+          re.lastIndex = 0;
+          if (re.test(ln)) {
+            fileHits++;
+            total++;
+            if (mode === "content") {
+              if (matches.length < limit) matches.push(`${full}:${lineNumber}:${ln}`);
+            } else if (mode === "files_with_matches") {
+              if (matches.length < limit) matches.push(full);
+            } else if (matches.length < limit) {
+              matches.push(`${full}:${countOnlyFirstHit ? 1 : fileHits}`);
+            }
+          }
         }
-        if (mode === "count" && matches.length < limit) {
-          matches.push(`${full}:${fileHits}`);
+        if (fileHits > 0) {
+          if (mode === "count") {
+            const idx = matches.findIndex((entry) => entry.startsWith(`${full}:`));
+            if (idx !== -1) matches[idx] = `${full}:${fileHits}`;
+          }
+          if (mode === "files_with_matches" && matches.length >= limit) stopped = true;
         }
+        if (mode === "content" && matches.length >= limit) stopped = true;
+        if (mode === "count" && matches.length >= limit && (countOnlyFirstHit || mode !== "count")) stopped = true;
+      } finally {
+        await file.close();
       }
-      if (matches.length >= limit) stopped = true;
     } catch {
     }
   };
@@ -1138,18 +1239,20 @@ async function runNative(input, base, mode, limit, signal) {
       return;
     }
     const files = [];
+    const subdirs = [];
     for (const e of entries) {
       if (stopped) return;
       if (DEFAULT_IGNORE3.includes(e.name)) continue;
       if (e.isSymbolicLink()) continue;
       const full = path.join(dir, e.name);
       if (e.isDirectory()) {
-        await walk(full);
+        subdirs.push(full);
       } else if (e.isFile()) {
         files.push({ full, name: e.name });
       }
     }
     await mapWithConcurrency(files, NATIVE_SCAN_CONCURRENCY, ({ full, name }) => scanFile(full, name));
+    await mapWithConcurrency(subdirs, Math.min(16, NATIVE_SCAN_CONCURRENCY), walk);
   };
   await walk(base);
   return {
@@ -1159,20 +1262,6 @@ async function runNative(input, base, mode, limit, signal) {
     used: "native"
   };
 }
-async function mapWithConcurrency(items, concurrency, fn) {
-  if (items.length === 0) return;
-  let next = 0;
-  const workerCount = Math.min(Math.max(1, concurrency), items.length);
-  const workers = Array.from({ length: workerCount }, async () => {
-    for (; ; ) {
-      const idx = next++;
-      if (idx >= items.length) return;
-      const item = items[idx];
-      if (item !== void 0) await fn(item);
-    }
-  });
-  await Promise.all(workers);
-}
 var SPOOL_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
 var SPOOL_WRITE_HWM_BYTES = 4 * 1024 * 1024;
 var sweepStarted = false;
@@ -1214,7 +1303,7 @@ function createOutputSpool(opts) {
   let filePath = null;
   let failed = false;
   let finalized = false;
-  const open = () => {
+  const open2 = () => {
     if (stream || failed) return;
     try {
       const dir = toolOutputDir();
@@ -1247,7 +1336,7 @@ function createOutputSpool(opts) {
           return;
         }
         head += text;
-        open();
+        open2();
         head = "";
         return;
       }
@@ -2379,6 +2468,155 @@ async function checkAndBlockKillCommand(command) {
   }
   return { blocked: false };
 }
+function pickShell(platform4, command, env) {
+  const override = env.get("WRONGSTACK_SHELL")?.trim().toLowerCase();
+  if (override === "cmd" || override === "cmd.exe") return "cmd";
+  if (override === "powershell" || override === "powershell.exe") return "powershell";
+  if (override === "pwsh" || override === "pwsh.exe") return "pwsh";
+  if (looksLikePowerShell(command)) return "pwsh";
+  return "cmd";
+}
+function looksLikePowerShell(command) {
+  if (!command) return false;
+  const trimmed = command.trimStart();
+  if (/\.ps1\b/i.test(trimmed)) return true;
+  if (/^\s*#requires\s/i.test(trimmed)) return true;
+  if (/^\s*param\s*\(/i.test(trimmed)) return true;
+  if (/\$[\w:{]/i.test(trimmed)) return true;
+  if (/\$\(/.test(trimmed)) return true;
+  if (/@\s*['"]/.test(trimmed)) return true;
+  if (/&\s+\$/.test(trimmed)) return true;
+  if (/(^|\s)@\s*\(/.test(trimmed)) return true;
+  if (/(^|\s)@\{/.test(trimmed)) return true;
+  if (/(?:^|[\s\[\(\{,;])(?:-eq|-ne|-lt|-gt|-le|-ge|-like|-notlike|-match|-notmatch|-contains|-notcontains|-in|-notin|-and|-or|-not|-band|-bor|-bxor|-replace|-isplit|-csplit|-osplit|-join|-is|-as|-f)(?:$|[\s\]\)\},;])/i.test(trimmed)) {
+    return true;
+  }
+  if (PS_VERB_RE.test(trimmed)) return true;
+  if (/(?:^|[\s;&|])(gci|gi|gp|gcm|gps|sl|rm|cat|cp|mv)\b/i.test(trimmed)) {
+    return true;
+  }
+  if (looksLikePowerShellExtended(command)) return true;
+  return false;
+}
+function looksLikePowerShellExtended(command) {
+  if (!command) return false;
+  const trimmed = command.trimStart();
+  if (/(?:^|\s)[-/](?:WhatIf|Confirm|ErrorAction)(?::[^\s]+|\s|=|$)/i.test(trimmed)) {
+    return true;
+  }
+  if (/(?:^|[\s;&|])(Where-Object|ForEach-Object|Select-Object|Sort-Object|Group-Object|Measure-Object|Compare-Object|Tee-Object)(?:\s|$)/i.test(trimmed)) {
+    return true;
+  }
+  if (/\bWrite-(?:Host|Output|Error|Warning|Verbose|Debug|Information)(?:\s|$)/i.test(trimmed)) {
+    return true;
+  }
+  if (/HK(?:LM|CU|CR|U|CC|DD|PD):\\/i.test(trimmed)) return true;
+  if (/\[(?:string|int|bool|xml|double|float|decimal|char|byte|long|System\.)/i.test(trimmed)) {
+    return true;
+  }
+  if (/^\s*<#|#>\s*$/m.test(trimmed)) return true;
+  if (/(?:^|\s)[-/\/](?:AsPlainText|PipelineVariable|pv|FilterHashtable|OutVariable|ov)(?:\s|=|$)/i.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function wrapPowerShellScript(command) {
+  const bootstrap = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8;$ConfirmPreference='None';$WhatIfPreference=$false";
+  return "\uFEFF" + bootstrap + "\ntry {\n" + command + "\n} finally { exit $LASTEXITCODE }";
+}
+var PS_VERB_RE = new RegExp(
+  // Boundaries: start-of-string, whitespace, `;`, `&`, `|`, `(`, `{`, `,`.
+  "(?:^|[\\s;&|\\(\\{,])(?:Get|Set|New|Remove|Add|Clear|Copy|Move|Rename|Test|Update|Write|Read|Push|Pop|Invoke|Start|Stop|Wait|Out|Format|Group|Measure|Compare|Resolve|ConvertTo|ConvertFrom|Convert|Import|Export|Select|Where|ForEach|Sort|Tee|Split|Join|Limit|Skip|Step|Trace|Debug|Register|Unregister|Enable|Disable|Restart|Suspend|Resume|Save|Open|Close|Lock|Unlock|Mount|Dismount|Enter|Exit|Use|Show|Hide|Find|Search|Watch|Initialize|Optimize|Compress|Expand|Merge|Checkpoint|Undo|Redo|Approve|Deny|Block|Grant|Revoke|Assert|Confirm|Receive|Send|Connect|Disconnect|Reset|Backup|Restore|Publish|Unpublish|Install|Uninstall|Build|Rebuild|Deploy|Submit|Process|Complete|Approve|Revoke|Pay|Refund|Decline|Receive|Send)-[A-Za-z][A-Za-z0-9]+(?:[\\-\\+][A-Za-z][A-Za-z0-9]+)*(?:$|[\\s\\-\\;\\&\\|\\(\\)\\{\\},])",
+  "i"
+);
+function shellArgs(shell) {
+  if (shell === "powershell" || shell === "pwsh") {
+    return ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", "-"];
+  }
+  return ["/c"];
+}
+function diagnoseBashism(command, shell) {
+  if (!command) return void 0;
+  const isCmd = shell === "cmd";
+  const hints = [];
+  const add = (h) => {
+    if (!hints.includes(h)) hints.push(h);
+  };
+  if (/\/dev\/null/.test(command)) {
+    add(
+      isCmd ? "use `nul` instead of `/dev/null` (e.g. `2>nul`)" : "use `$null` instead of `/dev/null` (e.g. `2>$null`)"
+    );
+  }
+  if (/(^|[;&|]\s*)export\s+[A-Za-z_]\w*=/.test(command)) {
+    add(
+      isCmd ? "set env vars with `set NAME=value`, not `export`" : "set env vars with `$env:NAME = 'value'`, not `export`"
+    );
+  }
+  if (/<<-?\s*['"]?[A-Za-z_]\w*/.test(command)) {
+    add(
+      isCmd ? "cmd has no heredocs \u2014 write the content to a file or use multiple `echo` lines" : "PowerShell has no heredocs \u2014 use a single-quoted here-string `@'\u2026'@` (closing `'@` at column 0)"
+    );
+  }
+  if (shell === "powershell" && /(&&|\|\|)/.test(command)) {
+    add("Windows PowerShell 5.1 has no `&&`/`||` \u2014 separate commands with `;` (check `$LASTEXITCODE`)");
+  }
+  if (/\brm\s+-[A-Za-z]*[rf]/.test(command)) {
+    add(
+      isCmd ? "`rm` is not a cmd builtin \u2014 use `del` (files) or `rmdir /s /q` (dirs)" : "use `Remove-Item -Recurse -Force` \u2014 the `rm -rf` bash flags don't exist in PowerShell"
+    );
+  }
+  if (/\bwhich\s+\S/.test(command)) {
+    add(isCmd ? "use `where <cmd>` instead of `which`" : "use `Get-Command <cmd>` instead of `which`");
+  }
+  if (hints.length === 0) return void 0;
+  const label = isCmd ? "cmd.exe" : shell === "pwsh" ? "PowerShell 7" : "Windows PowerShell";
+  return `[wrongstack] This command failed and contains bash/POSIX syntax that ${label} does not accept \u2014 ${hints.join("; ")}. Rewrite it in ${isCmd ? "cmd" : "PowerShell"} syntax and retry.`;
+}
+function resolveWin32Command(cmd) {
+  if (process.platform !== "win32") return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || path.extname(cmd.replace(/\//g, "\\"))) {
+    return cmd;
+  }
+  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
+  const pathDirs = (process.env["PATH"] ?? "").split(path.delimiter);
+  for (const dir of pathDirs) {
+    const base = path.join(dir, cmd);
+    for (const ext of pathext) {
+      const full = `${base}${ext}`;
+      try {
+        fs8.accessSync(full, fs8.constants.X_OK);
+        return full;
+      } catch {
+      }
+    }
+  }
+  return cmd;
+}
+function resolvePowerShell(cmd) {
+  if (process.platform !== "win32") return cmd;
+  const lower = cmd.toLowerCase();
+  if (lower !== "pwsh" && lower !== "powershell" && lower !== "pwsh.exe" && lower !== "powershell.exe") {
+    return resolveWin32Command(cmd);
+  }
+  const primary = lower.startsWith("pwsh") ? "pwsh.exe" : "powershell.exe";
+  const fallback = lower.startsWith("pwsh") ? "powershell.exe" : "pwsh.exe";
+  const resolved = resolveWin32Command(primary);
+  if (resolved !== primary) {
+    const fb = resolveWin32Command(fallback);
+    return fb === fallback ? cmd : fb;
+  }
+  return resolved;
+}
+var WIN32_SHELL_META = /[&|<>\r\n\0]/;
+function assertSafeWin32ShellArgs(args) {
+  for (const a of args) {
+    if (typeof a === "string" && WIN32_SHELL_META.test(a)) {
+      throw new Error(
+        "win32 shell spawn: argument contains a shell metacharacter (one of & | < > or a newline) that could enable command injection through the .cmd/.bat wrapper \u2014 refusing to run. Offending argument: " + JSON.stringify(a)
+      );
+    }
+  }
+}
 
 // src/bash.ts
 var MAX_OUTPUT = 32768;
@@ -2475,18 +2713,36 @@ var bashTool = {
     }
     const timeoutMs = Math.max(1, Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT_MS, 6e5));
     const isWin3 = os2.platform() === "win32";
-    const shell = (() => {
-      const explicit = process.env[isWin3 ? "WRONGSTACK_COMSPEC" : "WRONGSTACK_SHELL"];
-      if (explicit) return explicit;
-      if (isWin3) return process.env["COMSPEC"] ?? "cmd.exe";
-      const fromEnv = process.env["SHELL"];
-      if (fromEnv) {
-        const name = fromEnv.split("/").pop() ?? "";
-        if (["bash", "zsh", "sh", "dash", "fish"].includes(name)) return fromEnv;
-      }
-      return "/bin/bash";
-    })();
-    const args = isWin3 ? ["/c", input.command] : ["-c", input.command];
+    let plan;
+    let winShellKind;
+    if (isWin3) {
+      const shell2 = pickShell("win32", input.command, {
+        get: (k) => process.env[k]
+      });
+      winShellKind = shell2;
+      const bin = shell2 === "powershell" ? resolvePowerShell("powershell.exe") : shell2 === "pwsh" ? resolvePowerShell("pwsh.exe") : process.env["COMSPEC"] ?? "cmd.exe";
+      plan = {
+        bin,
+        argv: shellArgs(shell2),
+        useStdin: shell2 === "powershell" || shell2 === "pwsh",
+        stdinBody: shell2 === "powershell" || shell2 === "pwsh" ? wrapPowerShellScript(input.command) : void 0
+      };
+    } else {
+      const explicit = process.env["WRONGSTACK_SHELL"];
+      let bin;
+      if (explicit) bin = explicit;
+      else {
+        const fromEnv = process.env["SHELL"];
+        if (fromEnv) {
+          const name = fromEnv.split("/").pop() ?? "";
+          if (["bash", "zsh", "sh", "dash", "fish"].includes(name)) bin = fromEnv;
+          else bin = "/bin/bash";
+        } else bin = "/bin/bash";
+      }
+      plan = { bin, argv: ["-c"], useStdin: false, stdinBody: void 0 };
+    }
+    const shell = plan.bin;
+    const args = plan.useStdin ? [...plan.argv] : [...plan.argv, input.command];
     const env = buildChildEnv(ctx.session?.id);
     const detached = !isWin3;
     const startedAt = Date.now();
@@ -2496,7 +2752,9 @@ var bashTool = {
       const child2 = spawn(shell, args, {
         cwd: ctx.projectRoot,
         env,
-        stdio: ["ignore", "pipe", "pipe"],
+        // PowerShell takes the script on stdin (no argv quoting); cmd.exe
+        // and POSIX shells ignore stdin when given the command inline.
+        stdio: [plan.useStdin ? "pipe" : "ignore", "pipe", "pipe"],
         // win32: CreateProcess IGNORES CREATE_NO_WINDOW (windowsHide) when
         // DETACHED_PROCESS (detached: true) is set, so the console-less
         // cmd.exe's grandchildren (node, dev servers) each allocate a fresh
@@ -2507,6 +2765,13 @@ var bashTool = {
         detached: !isWin3,
         windowsHide: true
       });
+      if (plan.useStdin) {
+        try {
+          child2.stdin?.write(plan.stdinBody ?? input.command);
+          child2.stdin?.end();
+        } catch {
+        }
+      }
       const pid2 = child2.pid;
       if (typeof pid2 === "number") {
         registry.register({
@@ -2561,11 +2826,20 @@ var bashTool = {
     const child = spawn(shell, args, {
       cwd: ctx.projectRoot,
       env,
-      stdio: ["ignore", "pipe", "pipe"],
+      // PowerShell takes the script on stdin (no argv quoting); cmd.exe
+      // and POSIX shells ignore stdin when given the command inline.
+      stdio: [plan.useStdin ? "pipe" : "ignore", "pipe", "pipe"],
       detached,
       windowsHide: true,
       ...isWin3 ? {} : { signal: opts.signal }
     });
+    if (plan.useStdin) {
+      try {
+        child.stdin?.write(plan.stdinBody ?? input.command);
+        child.stdin?.end();
+      } catch {
+      }
+    }
     const pid = child.pid;
     if (typeof pid === "number") {
       registry.register({
@@ -2716,10 +2990,13 @@ var bashTool = {
             yield { type: "partial_output", text: remainder };
           }
           const spooled = spool.finalize();
+          const hint = !timedOut && typeof c.code === "number" && c.code !== 0 && winShellKind ? diagnoseBashism(input.command, winShellKind) : void 0;
           yield {
             type: "final",
             output: {
-              output: normalizeCommandOutput(buf) + (spooled ? spoolNote(spooled) : ""),
+              output: normalizeCommandOutput(buf) + (spooled ? spoolNote(spooled) : "") + (hint ? `
+
+${hint}` : ""),
               exit_code: c.code,
               timed_out: timedOut
             }
@@ -2747,82 +3024,115 @@ var bashTool = {
     }
   }
 };
-function resolveWin32Command(cmd) {
-  if (process.platform !== "win32") return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || path.extname(cmd.replace(/\//g, "\\"))) {
-    return cmd;
-  }
-  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
-  const pathDirs = (process.env["PATH"] ?? "").split(path.delimiter);
-  for (const dir of pathDirs) {
-    const base = path.join(dir, cmd);
-    for (const ext of pathext) {
-      const full = `${base}${ext}`;
-      try {
-        fs8.accessSync(full, fs8.constants.X_OK);
-        return full;
-      } catch {
-      }
-    }
-  }
-  return cmd;
-}
-var WIN32_SHELL_META = /[&|<>\r\n\0]/;
-function assertSafeWin32ShellArgs(args) {
-  for (const a of args) {
-    if (typeof a === "string" && WIN32_SHELL_META.test(a)) {
-      throw new Error(
-        "win32 shell spawn: argument contains a shell metacharacter (one of & | < > or a newline) that could enable command injection through the .cmd/.bat wrapper \u2014 refusing to run. Offending argument: " + JSON.stringify(a)
-      );
-    }
-  }
-}
 
-// src/exec.ts
+// src/_session-shell.ts
+function normalizeShell(value) {
+  const v = value?.trim().toLowerCase();
+  if (v === "cmd" || v === "cmd.exe") return "cmd";
+  if (v === "powershell" || v === "powershell.exe") return "powershell";
+  if (v === "pwsh" || v === "pwsh.exe") return "pwsh";
+  return void 0;
+}
+function resolveSessionShell(platform4, env, deps = {}) {
+  if (platform4 !== "win32") return void 0;
+  const override = normalizeShell(env.get("WRONGSTACK_SHELL"));
+  if (override) return override;
+  const hasBinary = deps.hasBinary ?? ((bin) => resolveWin32Command(bin) !== bin);
+  if (hasBinary("pwsh.exe")) return "pwsh";
+  if (hasBinary("powershell.exe")) return "powershell";
+  return "cmd";
+}
+function ensureSessionShell(opts = {}) {
+  const env = opts.env ?? process.env;
+  const platform4 = opts.platform ?? process.platform;
+  if (platform4 !== "win32") return void 0;
+  const existing = normalizeShell(env["WRONGSTACK_SHELL"]);
+  if (existing) return existing;
+  const chosen = resolveSessionShell(platform4, { get: (k) => env[k] }, { hasBinary: opts.hasBinary }) ?? "cmd";
+  env["WRONGSTACK_SHELL"] = chosen;
+  return chosen;
+}
 var isWin = process.platform === "win32";
-var ALLOWED_COMMANDS = {
-  node: ["--version", "-r", "--input-type=module"],
-  npm: ["--version", "list", "pkg", "doctor", "view", "outdated", "audit"],
-  pnpm: ["--version", "remove", "list", "view", "outdated", "audit"],
-  npx: ["--version"],
-  git: [
-    "--version",
-    "status",
-    "log",
-    "diff",
-    "branch",
-    "checkout",
-    "stash",
-    "add",
-    "commit",
-    "push",
-    "pull"
-  ],
-  ls: ["-la", "-l", "-a"],
-  cat: [],
-  head: ["-n"],
-  tail: ["-n"],
-  wc: ["-l", "-w", "-c"],
-  grep: [],
-  find: [],
-  echo: [],
-  mkdir: ["-p"],
-  cp: ["-r"],
-  mv: [],
-  rm: ["-rf"],
-  touch: [],
-  bun: ["--version"],
-  tsc: ["--version", "--noEmit", "--project"],
-  vitest: ["--version", "run", "--coverage"],
-  biome: ["--version", "lint", "format", "check"],
-  cargo: ["--version", "build", "test", "check"],
-  rustc: ["--version"],
-  go: ["version", "run", "build", "test"],
-  python: ["--version"],
-  pip: ["--version", "list"],
-  docker: ["--version", "ps", "images"],
-  kubectl: ["version", "get", "describe", "logs"]
-};
+var DEFAULT_ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
+  // JS / TS toolchain
+  "node",
+  "npm",
+  "pnpm",
+  "yarn",
+  "npx",
+  "bun",
+  "deno",
+  "tsc",
+  "vitest",
+  "jest",
+  "biome",
+  "eslint",
+  "prettier",
+  // version control
+  "git",
+  // Rust
+  "cargo",
+  "rustc",
+  // Go
+  "go",
+  // Python
+  "python",
+  "python3",
+  "pip",
+  "pip3",
+  // Ruby
+  "ruby",
+  "gem",
+  "bundle",
+  // JVM
+  "java",
+  "javac",
+  "mvn",
+  "gradle",
+  "gradlew",
+  // .NET
+  "dotnet",
+  // C / C++ / native build
+  "make",
+  "cmake",
+  // containers / orchestration (read-only subcommands; see BLOCKED_ARG_PATTERNS)
+  "docker",
+  "kubectl",
+  // common POSIX file/text utilities
+  "ls",
+  "cat",
+  "head",
+  "tail",
+  "wc",
+  "grep",
+  "find",
+  "echo",
+  "mkdir",
+  "cp",
+  "mv",
+  "rm",
+  "touch"
+]);
+var allowedCommands = new Set(DEFAULT_ALLOWED_COMMANDS);
+var normalizeCmd = (c) => c.trim();
+function configureExecPolicy(opts = {}) {
+  const next = new Set(DEFAULT_ALLOWED_COMMANDS);
+  for (const c of opts.allow ?? []) {
+    const n = normalizeCmd(c);
+    if (n) next.add(n);
+  }
+  for (const c of opts.deny ?? []) next.delete(normalizeCmd(c));
+  allowedCommands = next;
+}
+function resetExecPolicy() {
+  allowedCommands = new Set(DEFAULT_ALLOWED_COMMANDS);
+}
+function isExecCommandAllowed(cmd) {
+  return allowedCommands.has(normalizeCmd(cmd));
+}
+function getExecAllowlist() {
+  return [...allowedCommands].sort();
+}
 var MAX_ARGS = 20;
 var MAX_OUTPUT2 = 2e5;
 var DEFAULT_TIMEOUT_MS2 = 3e4;
@@ -2884,7 +3194,7 @@ var execTool = {
   name: "exec",
   category: "Shell",
   description: "Execute a **whitelisted, restricted set of commands** with strict argument validation. This is the **preferred and safer** alternative to the `bash` tool for running development tools (node, npm, pnpm, tsc, git, tests, linters, etc.). It prevents arbitrary command injection and limits what the model can do.",
-  usageHint: "PREFERRED SHELL TOOL for most cases.\n\nUse this instead of `bash` whenever possible.\n- `command` must be one of the allowed commands (node, npm, pnpm, git, tsc, eslint, vitest, etc.).\n- Arguments are passed as a clean array (no shell interpretation).\n- `cwd` is validated to stay inside the project.\n- For anything that requires real shell features (pipes, complex redirection, arbitrary commands), fall back to `bash` (with strong justification).\nThis tool significantly reduces the risk compared to full shell access.",
+  usageHint: "PREFERRED SHELL TOOL for most cases.\n\nUse this instead of `bash` whenever possible.\n- `command` must be in the allowlist. Defaults cover JS (node/npm/pnpm/yarn/bun/deno/tsc/vitest/eslint/biome), Go (`go build`/`go test`), Rust (cargo), Python (python/pip), Ruby (gem/bundle), JVM (java/mvn/gradle), .NET (dotnet), native (make/cmake), and git. Users can extend it via `tools.exec.allow` in config.\n- Arguments are passed as a clean array (no shell interpretation).\n- `cwd` is validated to stay inside the project.\n- If a command is not allowlisted, the error explains how to add it; for one-off arbitrary commands, fall back to `bash` (with strong justification).\nThis tool significantly reduces the risk compared to full shell access.",
   permission: "confirm",
   mutating: true,
   riskTier: "standard",
@@ -2938,12 +3248,12 @@ var execTool = {
         truncated: false,
         allowed: false
       };
-    if (!(cmd in ALLOWED_COMMANDS)) {
+    if (!isExecCommandAllowed(cmd)) {
       return {
         command: cmd,
         args: input.args ?? [],
         stdout: "",
-        stderr: `Command "${cmd}" not in allowlist. Use the bash tool for arbitrary commands.`,
+        stderr: `Command "${cmd}" not in allowlist. Add it to your ~/.wrongstack/config.json under "tools": { "exec": { "allow": ["${cmd}"] } }, or use the bash tool for one-off arbitrary commands.`,
         exitCode: 1,
         truncated: false,
         allowed: false
@@ -2986,19 +3296,58 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
     let stdout = "";
     let stderr = "";
     let killed = false;
+    const resolvedOnce = { value: false };
+    const finish = (result) => {
+      if (resolvedOnce.value) return;
+      resolvedOnce.value = true;
+      resolve6(result);
+    };
     const startedAt = Date.now();
     const spool = createOutputSpool({ tool: `exec-${cmd}`, thresholdBytes: MAX_OUTPUT2 });
     const resolved = resolveWin32Command(cmd);
     const needsShell = isWin && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
     const spawnCmd = needsShell ? cmd : resolved;
     if (needsShell) assertSafeWin32ShellArgs(args);
-    const child = spawn(spawnCmd, args, {
-      cwd,
-      env: buildChildEnv(sessionId),
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true,
-      ...isWin ? {} : { signal },
-      ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {}
+    let child;
+    try {
+      child = spawn(spawnCmd, args, {
+        cwd,
+        env: buildChildEnv(sessionId),
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        ...isWin ? {} : { signal },
+        ...needsShell ? { shell: true, windowsVerbatimArguments: true } : {}
+      });
+    } catch (err) {
+      spool.finalize();
+      finish({
+        command: cmd,
+        args,
+        stdout: "",
+        stderr: `spawn failed: ${toErrorMessage$1(err)}`,
+        exitCode: 1,
+        truncated: false,
+        allowed: true
+      });
+      return;
+    }
+    child.on("error", (err) => {
+      const isAbort = err && err.code === "ABORT_ERR";
+      const stderrText = isAbort ? `Aborted: ${err.message}` : err.message;
+      clearTimeout(timer);
+      if (isWin) signal.removeEventListener("abort", onAbort);
+      if (typeof pid === "number") registry.unregister(pid);
+      registry.afterCall(Date.now() - startedAt, true);
+      spool.finalize();
+      finish({
+        command: cmd,
+        args,
+        stdout: normalizeCommandOutput(stdout),
+        stderr: stderrText,
+        exitCode: isAbort ? 124 : 1,
+        truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES,
+        allowed: true
+      });
     });
     const registry = getProcessRegistry();
     const pid = child.pid;
@@ -3038,7 +3387,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
       const exitCode = killed ? 124 : code ?? 1;
       registry.afterCall(durationMs, exitCode !== 0);
       const spooled = spool.finalize();
-      resolve6({
+      finish({
         command: cmd,
         args,
         stdout: normalizeCommandOutput(stdout) + (spooled ? spoolNote(spooled) : ""),
@@ -3048,22 +3397,6 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId) {
         allowed: true
       });
     });
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      if (isWin) signal.removeEventListener("abort", onAbort);
-      if (typeof pid === "number") registry.unregister(pid);
-      registry.afterCall(Date.now() - startedAt, true);
-      spool.finalize();
-      resolve6({
-        command: cmd,
-        args,
-        stdout: normalizeCommandOutput(stdout),
-        stderr: err.message,
-        exitCode: 1,
-        truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES,
-        allowed: true
-      });
-    });
   });
 }
 var TD = new TurndownService({
@@ -3428,7 +3761,7 @@ async function duckduckgoSearch(query2, num, signal) {
       truncated: results.length >= num
     };
   } catch (err) {
-    console.log(JSON.stringify({ level: "debug", event: "search_failed", query: query2, error: toErrorMessage$1(err) }));
+    console.log(JSON.stringify({ level: "debug", event: "search_failed", query: query2, error: toErrorMessage$2(err) }));
     return {
       query: query2,
       results: [{ title: "Search unavailable", url: "", snippet: "Could not reach DuckDuckGo" }],
@@ -3916,13 +4249,13 @@ ${formatTaskList(taskFile.tasks)}`
   }
 };
 function mkResult(plan, ok, message, todos) {
-  const open = plan.items.filter((i) => i.status !== "done").length;
+  const open2 = plan.items.filter((i) => i.status !== "done").length;
   const result = {
     ok,
     message,
     plan: formatPlan(plan),
     count: plan.items.length,
-    open
+    open: open2
   };
   if (todos !== void 0) result.todos = todos;
   return result;
@@ -7667,7 +8000,7 @@ function loadDatabaseSync() {
     DatabaseSyncCtor = req("node:sqlite").DatabaseSync;
   } catch (err) {
     throw new Error(
-      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${toErrorMessage$1(err)}`
+      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${toErrorMessage$2(err)}`
     );
   }
   return DatabaseSyncCtor;
@@ -7794,6 +8127,8 @@ var IndexStore = class {
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)");
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)");
     this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)");
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS refs (
         id INTEGER PRIMARY KEY,
@@ -8706,9 +9041,9 @@ async function syncGoParse(filePath, content, lang) {
   }
 }
 async function parseSymbols3(opts) {
-  const { file, lang } = opts;
+  const { file, content, lang } = opts;
   try {
-    return await syncPyParse(file, lang);
+    return await syncPyParse(file, content, lang);
   } catch {
     return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
@@ -8776,8 +9111,7 @@ syms = []
 errors = []
 
 try:
-    with open(sys.argv[1], "r", encoding="utf-8") as f:
-        source = f.read()
+    source = sys.stdin.read()
     tree = ast.parse(source, filename=sys.argv[1])
 except Exception as e:
     errors.append(str(e))
@@ -8917,16 +9251,21 @@ visitor.visit(tree)
 
 print(json.dumps([s.to_dict() for s in syms]))
 `;
-async function syncPyParse(filePath, lang) {
+var _cachedScriptPath = null;
+async function syncPyParse(filePath, content, lang) {
   try {
-    const tmpDir = path.join(os2.tmpdir(), "ws-py-parse");
-    await fs7.mkdir(tmpDir, { recursive: true });
-    const scriptPath = path.join(tmpDir, "parse.py");
-    await fs7.writeFile(scriptPath, PY_PARSE_SCRIPT, "utf8");
-    const proc = spawn("python", [scriptPath, filePath], {
+    if (!_cachedScriptPath) {
+      const tmpDir = path.join(os2.tmpdir(), "ws-py-parse");
+      await fs7.mkdir(tmpDir, { recursive: true });
+      _cachedScriptPath = path.join(tmpDir, "parse.py");
+      await fs7.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
+    }
+    const proc = spawn("python", [_cachedScriptPath, filePath], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
+    proc.stdin?.write(content);
+    proc.stdin?.end();
     let stdout = "";
     proc.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -9593,7 +9932,7 @@ async function parseFile(file, content, lang) {
     case "go":
       return parseSymbols2({ file, content, lang: "go" });
     case "py":
-      return parseSymbols3({ file, lang: "py" });
+      return parseSymbols3({ file, content, lang: "py" });
     case "rs":
       return parseSymbols4({ file, content, lang: "rs" });
     case "json":
@@ -9624,10 +9963,12 @@ async function runIndexerWithStore(store, opts) {
   let symbolsIndexed = 0;
   const isGitIgnored = await loadGitignoreMatcher(projectRoot);
   let files;
+  let discoveredFiles = null;
   if (opts.files && opts.files.length > 0) {
     files = opts.files.map((f) => path.resolve(projectRoot, f)).filter((f) => !isGitIgnored(path.relative(projectRoot, f).replace(/\\/g, "/"), false));
   } else {
     files = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
+    discoveredFiles = new Set(files);
   }
   if (langs && langs.length > 0) {
     const langSet = new Set(langs);
@@ -9745,11 +10086,11 @@ async function runIndexerWithStore(store, opts) {
       filesIndexed++;
     }
   }
-  for (const [file_] of existingMeta) {
-    try {
-      await fs7.stat(file_);
-    } catch {
-      store.deleteFile(file_);
+  if (discoveredFiles) {
+    for (const [file_] of existingMeta) {
+      if (!discoveredFiles.has(file_)) {
+        store.deleteFile(file_);
+      }
     }
   }
   const durationMs = Date.now() - startMs;
@@ -10358,7 +10699,7 @@ var setWorkingDirTool = {
     } catch (err) {
       return {
         current: ctx.workingDir,
-        error: toErrorMessage$1(err)
+        error: toErrorMessage$2(err)
       };
     }
     try {
@@ -11004,6 +11345,6 @@ var TOOL_ICON_CONFIG = {
 };
 var FALLBACK_ICON = "fallback";
 
-export { CircuitBreaker, CircuitOpenError, FALLBACK_ICON, IndexCircuitBreaker, IndexTimeoutError, OPTIONAL_TOOLS, TIER1_TOOLS, TIER2_TOOLS, TIER3_TOOLS, TOOL_ICON_CONFIG, TOOL_ICON_MAP, _resetProcessRegistry, auditTool, bashTool, batchToolUseTool, builtinTools, builtinToolsPack, cancelPendingReindexes, codebaseIndexStats, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, createGlobalPsSlashCommand, createModeTool, diffTool, documentTool, editTool, enqueueReindex, execTool, fetchTool, forgetTool, formatGlobalStatus, formatInstanceList, formatInstanceSummary, formatTool, getIndexState, getInstanceCount, getPersistentProcessRegistry, getProcessGuardian, getProcessRegistry, getToolIcon, gitTool, globTool, grepTool, indexCircuitBreaker, installTool, isIndexReady, isIndexableFile, isIndexing, jsonTool, lintTool, listInstances, logsTool, onIndexStateChange, outdatedTool, patchTool, planTool, readTool, relatedMemoryTool, rememberTool, replaceTool, resetIndexCircuitBreaker, resetPersistentProcessRegistry, runStartupIndex, scaffoldTool, searchCodebaseIndex, searchMemoryTool, searchTool, shutdownCodebaseIndexHost, startProcessGuardian, stopProcessGuardian, testTool, todoTool, toolHelpTool, toolSearchTool, toolUseTool, treeTool, typecheckTool, writeTool };
+export { CircuitBreaker, CircuitOpenError, FALLBACK_ICON, IndexCircuitBreaker, IndexTimeoutError, OPTIONAL_TOOLS, TIER1_TOOLS, TIER2_TOOLS, TIER3_TOOLS, TOOL_ICON_CONFIG, TOOL_ICON_MAP, _resetProcessRegistry, auditTool, bashTool, batchToolUseTool, builtinTools, builtinToolsPack, cancelPendingReindexes, codebaseIndexStats, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, configureExecPolicy, createGlobalPsSlashCommand, createModeTool, diffTool, documentTool, editTool, enqueueReindex, ensureSessionShell, execTool, fetchTool, forgetTool, formatGlobalStatus, formatInstanceList, formatInstanceSummary, formatTool, getExecAllowlist, getIndexState, getInstanceCount, getPersistentProcessRegistry, getProcessGuardian, getProcessRegistry, getToolIcon, gitTool, globTool, grepTool, indexCircuitBreaker, installTool, isExecCommandAllowed, isIndexReady, isIndexableFile, isIndexing, jsonTool, lintTool, listInstances, logsTool, normalizeShell, onIndexStateChange, outdatedTool, patchTool, planTool, readTool, relatedMemoryTool, rememberTool, replaceTool, resetExecPolicy, resetIndexCircuitBreaker, resetPersistentProcessRegistry, resolveSessionShell, runStartupIndex, scaffoldTool, searchCodebaseIndex, searchMemoryTool, searchTool, shutdownCodebaseIndexHost, startProcessGuardian, stopProcessGuardian, testTool, todoTool, toolHelpTool, toolSearchTool, toolUseTool, treeTool, typecheckTool, writeTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map