@wrongstack/plugins 0.295.0 → 0.295.1

package/dist/format-on-save.js

@@ -1,9 +1,200 @@
 // src/format-on-save/index.ts
 import { execFile } from "node:child_process";
-import { access, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { access, readFile, stat } from "node:fs/promises";
+
+// src/runtime/index.ts
+import { basename, extname as extname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/runtime/local-bin.ts
+import { createRequire } from "node:module";
+import { delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+function resolveExecInvocation(command, args = []) {
+  const resolved = resolveWin32Command(command);
+  const normalizedResolved = resolved.toLowerCase();
+  const needsShell = process.platform === "win32" && (normalizedResolved.endsWith(".cmd") || normalizedResolved.endsWith(".bat"));
+  if (needsShell) {
+    const shim = buildWin32CmdShimInvocation(resolved, args);
+    return { cmd: shim.command, args: shim.args, windowsVerbatimArguments: true };
+  }
+  return { cmd: resolved, args: [...args], windowsVerbatimArguments: false };
+}
+function findOnPath(cmd) {
+  if (!cmd) return null;
+  const exists = (p) => {
+    try {
+      accessSync(p, constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    return exists(cmd) ? resolve(cmd) : null;
+  }
+  const suffixes = process.platform === "win32" && extname(cmd) === "" ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
+    if (!dir) continue;
+    const base = join(dir, cmd);
+    for (const suffix of suffixes) {
+      const candidate = `${base}${suffix}`;
+      if (exists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function isInside(parent, candidate) {
+  const rel = relative(parent, candidate);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+var binCache = /* @__PURE__ */ new Map();
+var BIN_CACHE_MAX = 64;
+var NEGATIVE_BIN_CACHE_TTL_MS = 5e3;
+function cachePut(key, value) {
+  while (binCache.size >= BIN_CACHE_MAX) {
+    const oldest = binCache.keys().next().value;
+    if (oldest === void 0) break;
+    binCache.delete(oldest);
+  }
+  binCache.set(key, { value, cachedAt: Date.now() });
+  return value;
+}
+function clearLocalBinCache() {
+  binCache.clear();
+}
+function resolveNodeBin(packageName, binName, cwd, extraArgs = []) {
+  const key = `${packageName}|${binName}|${cwd}`;
+  const cached = binCache.get(key);
+  if (cached !== void 0) {
+    if (cached.value !== null || Date.now() - cached.cachedAt < NEGATIVE_BIN_CACHE_TTL_MS) {
+      return cached.value === null ? null : { ...cached.value, args: [cached.value.entry, ...extraArgs] };
+    }
+    binCache.delete(key);
+  }
+  let resolved = null;
+  try {
+    const requireFromProject = createRequire(resolve(cwd, "package.json"));
+    const packagePath = requireFromProject.resolve(`${packageName}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    const relativeBin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.[binName] ?? Object.values(packageJson.bin ?? {})[0];
+    if (relativeBin && !isAbsolute(relativeBin)) {
+      const packageDir = dirname(packagePath);
+      const entry = resolve(packageDir, relativeBin);
+      if (isInside(packageDir, entry)) {
+        resolved = { cmd: process.execPath, args: [entry], entry };
+      }
+    }
+  } catch {
+    resolved = null;
+  }
+  cachePut(key, resolved);
+  return resolved === null ? null : { ...resolved, args: [resolved.entry, ...extraArgs] };
+}
+function resolveFirstNodeBin(candidates, cwd) {
+  for (const c of candidates) {
+    const hit = resolveNodeBin(c.packageName, c.binName, cwd, c.args ?? []);
+    if (hit) return { ...hit, packageName: c.packageName, binName: c.binName };
+  }
+  return null;
+}
+
+// src/runtime/bounded-map.ts
+var BoundedMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  ttlMs;
+  now;
+  /** Entries dropped to stay under `max`. Surfaced by plugin health(). */
+  evictions = 0;
+  constructor(options) {
+    const normalizedMax = Math.floor(options.max);
+    this.max = Number.isSafeInteger(normalizedMax) ? Math.max(1, normalizedMax) : 1;
+    this.ttlMs = options.ttlMs;
+    this.now = options.now ?? Date.now;
+  }
+  expired(entry) {
+    return this.ttlMs !== void 0 && this.now() - entry.storedAt > this.ttlMs;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return void 0;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  /**
+   * Read without promoting the key to most-recently-used. Use for
+   * diagnostics that must not perturb the eviction order.
+   */
+  peek(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0 || this.expired(entry)) return void 0;
+    return entry.value;
+  }
+  has(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return false;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return false;
+    }
+    return true;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, { value, storedAt: this.now() });
+    while (this.map.size > this.max) {
+      const coldest = this.map.keys().next().value;
+      if (coldest === void 0) break;
+      this.map.delete(coldest);
+      this.evictions += 1;
+    }
+    return this;
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+    this.evictions = 0;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** How many entries have been dropped to respect `max`, since the last clear. */
+  get evictionCount() {
+    return this.evictions;
+  }
+  /** Drop every expired entry. Cheap enough to call from a status tool. */
+  prune() {
+    if (this.ttlMs === void 0) return 0;
+    let removed = 0;
+    for (const [key, entry] of this.map) {
+      if (this.expired(entry)) {
+        this.map.delete(key);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  /** Live (non-expired) entries, coldest first. */
+  *entries() {
+    for (const [key, entry] of this.map) {
+      if (!this.expired(entry)) yield [key, entry.value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
 
 // src/runtime/index.ts
-import { basename, extname, isAbsolute, relative, resolve } from "node:path";
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
   return arg.length > 0 && arg.startsWith("-");
@@ -11,13 +202,13 @@ function hasLeadingDash(arg) {
 function withinProjectPath(projectRoot, candidate) {
   if (candidate.length === 0 || candidate.length > 4096) return false;
   if (hasLeadingDash(candidate)) return false;
-  const resolved = isAbsolute(candidate) ? resolve(candidate) : resolve(projectRoot, candidate);
-  const rel = relative(projectRoot, resolved);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  const resolved = isAbsolute2(candidate) ? resolve2(candidate) : resolve2(projectRoot, candidate);
+  const rel = relative2(projectRoot, resolved);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function withinProject(p) {
   const cwd = process.cwd();
-  return withinProjectPath(cwd, p) || relative(cwd, p) === ".";
+  return withinProjectPath(cwd, p) || relative2(cwd, p) === ".";
 }
 
 // src/format-on-save/index.ts
@@ -56,7 +247,7 @@ function readConfig(raw) {
     skipTtlMs: typeof r["skipTtlMs"] === "number" && r["skipTtlMs"] >= 0 ? r["skipTtlMs"] : DEFAULTS.skipTtlMs
   };
 }
-var recentlyCovered = /* @__PURE__ */ new Map();
+var recentlyCovered = new BoundedMap({ max: 256 });
 function clearRegistrations() {
   if (state.hookUnregister) {
     try {
@@ -79,6 +270,55 @@ function evictExpired(ttlMs) {
     if (ts < cutoff) recentlyCovered.delete(path);
   }
 }
+var FORMATTERS = [
+  {
+    packageName: "@biomejs/biome",
+    binName: "biome",
+    writeArgs: ["format", "--write"],
+    label: "biome"
+  },
+  { packageName: "prettier", binName: "prettier", writeArgs: ["--write"], label: "prettier" },
+  { packageName: "dprint", binName: "dprint", writeArgs: ["fmt"], label: "dprint" }
+];
+var activeFormatter;
+function resetFormatter() {
+  activeFormatter = void 0;
+  clearLocalBinCache();
+}
+function resolveFormatter() {
+  if (activeFormatter !== void 0) return activeFormatter;
+  const cwd = process.cwd();
+  for (const f of FORMATTERS) {
+    const local = resolveNodeBinFor(f, cwd);
+    if (local) {
+      activeFormatter = local;
+      return local;
+    }
+  }
+  for (const f of FORMATTERS) {
+    const onPath = findOnPath(f.binName);
+    if (!onPath) continue;
+    activeFormatter = { cmd: onPath, args: [...f.writeArgs], label: f.label };
+    return activeFormatter;
+  }
+  activeFormatter = null;
+  return null;
+}
+function resolveNodeBinFor(f, cwd) {
+  const hit = resolveFirstNodeBin([{ packageName: f.packageName, binName: f.binName }], cwd);
+  if (!hit) return null;
+  return { cmd: hit.cmd, args: [...hit.args, ...f.writeArgs], label: f.label };
+}
+function activeFormatterLabel() {
+  return activeFormatter?.label ?? null;
+}
+async function sha256File(filePath) {
+  try {
+    return createHash("sha256").update(await readFile(filePath)).digest("hex");
+  } catch {
+    return null;
+  }
+}
 async function formatFile(filePath, timeoutMs) {
   if (!withinProject(filePath)) return null;
   try {
@@ -86,30 +326,40 @@ async function formatFile(filePath, timeoutMs) {
   } catch {
     return null;
   }
+  const formatter = resolveFormatter();
+  if (!formatter) return null;
   let bytesBefore;
   try {
     bytesBefore = (await stat(filePath)).size;
   } catch {
     return null;
   }
+  const hashBefore = await sha256File(filePath);
+  let invocation;
+  try {
+    invocation = resolveExecInvocation(formatter.cmd, [...formatter.args, filePath]);
+  } catch {
+    return null;
+  }
   try {
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       execFile(
-        "npx",
-        ["biome", "format", "--write", filePath],
+        invocation.cmd,
+        invocation.args,
         {
           encoding: "utf-8",
           timeout: timeoutMs,
           cwd: process.cwd(),
           windowsHide: true,
-          maxBuffer: 16 * 1024 * 1024
+          maxBuffer: 16 * 1024 * 1024,
+          ...invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
         },
         (err) => {
           if (err) {
             const e = err;
             if (e.killed) return reject(err);
           }
-          resolve2();
+          resolve3();
         }
       );
     });
@@ -125,28 +375,11 @@ async function formatFile(filePath, timeoutMs) {
   if (bytesAfter !== bytesBefore) {
     return { changed: true, bytesBefore, bytesAfter };
   }
-  try {
-    await new Promise((resolve2, reject) => {
-      execFile(
-        "npx",
-        ["biome", "format", filePath],
-        {
-          encoding: "utf-8",
-          timeout: timeoutMs,
-          cwd: process.cwd(),
-          windowsHide: true,
-          maxBuffer: 16 * 1024 * 1024
-        },
-        (err) => {
-          if (err) return reject(err);
-          resolve2();
-        }
-      );
-    });
+  const hashAfter = await sha256File(filePath);
+  if (hashBefore === null || hashAfter === null) {
     return { changed: false, bytesBefore, bytesAfter };
-  } catch {
-    return { changed: true, bytesBefore, bytesAfter };
   }
+  return { changed: hashBefore !== hashAfter, bytesBefore, bytesAfter };
 }
 var plugin = {
   name: "format-on-save",
@@ -192,32 +425,18 @@ var plugin = {
     state.lastResult = null;
     recentlyCovered.clear();
     const cfg = readConfig(api.config.extensions?.["format-on-save"]);
-    let biomeAvailable = false;
-    try {
-      await new Promise((resolve2, reject) => {
-        execFile(
-          "npx",
-          ["biome", "--version"],
-          {
-            encoding: "utf-8",
-            timeout: 5e3,
-            cwd: process.cwd(),
-            windowsHide: true
-          },
-          (err) => {
-            if (err) reject(err);
-            else resolve2();
-          }
-        );
-      });
-      biomeAvailable = true;
-      api.log.info("format-on-save: biome detected");
-    } catch {
-      biomeAvailable = false;
-      api.log.warn("format-on-save: biome not found \u2014 hook will be a no-op");
+    resetFormatter();
+    const formatter = resolveFormatter();
+    const formatterAvailable = formatter !== null;
+    if (formatter) {
+      api.log.info(`format-on-save: ${formatter.label} detected`);
+    } else {
+      api.log.warn(
+        "format-on-save: no formatter found (biome, prettier, dprint) \u2014 hook will be a no-op"
+      );
     }
     const hook = async (input) => {
-      if (!cfg.enabled || !biomeAvailable) return;
+      if (!cfg.enabled || !formatterAvailable) return;
       if (input.toolResult?.isError) return;
       const toolName = input.toolName ?? "";
       const inp = input.toolInput ?? {};
@@ -278,7 +497,7 @@ var plugin = {
     );
     api.tools.register({
       name: "format_on_save_status",
-      description: "Reports format-on-save state: biome availability, and per-session formatted/clean/error/skipped counters.",
+      description: "Reports format-on-save state: which formatter is active, and per-session formatted/clean/error/skipped counters.",
       inputSchema: { type: "object", properties: {} },
       permission: "auto",
       category: "Code Quality",
@@ -287,7 +506,14 @@ var plugin = {
         return {
           ok: true,
           enabled: cfg.enabled,
-          biomeAvailable,
+          formatterAvailable,
+          formatter: activeFormatterLabel(),
+          /**
+           * Back-compat alias for the pre-multi-formatter status shape.
+           * Now accurate rather than assumed: true only when the resolved
+           * formatter really is biome.
+           */
+          biomeAvailable: activeFormatterLabel() === "biome",
           timeoutMs: cfg.timeoutMs,
           skipWhenCoveredBy: cfg.skipWhenCoveredBy,
           skipTtlMs: cfg.skipTtlMs,
@@ -305,11 +531,13 @@ var plugin = {
     api.log.info("format-on-save plugin loaded", {
       version: "0.1.0",
       enabled: cfg.enabled,
-      biomeAvailable
+      formatterAvailable,
+      formatter: activeFormatterLabel()
     });
   },
   teardown(api) {
     clearRegistrations();
+    resetFormatter();
     const final = {
       invocations: state.invocationCount,
       formatted: state.formattedCount,
@@ -343,5 +571,6 @@ var plugin = {
 };
 var format_on_save_default = plugin;
 export {
+  activeFormatterLabel,
   format_on_save_default as default
 };

package/dist/import-organizer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/import-organizer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAoRrD,QAAA,MAAM,MAAM,EAAE,MA8Nb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/import-organizer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAiXrD,QAAA,MAAM,MAAM,EAAE,MA8Nb,CAAC;eAEa,MAAM"}

package/dist/import-organizer.js

@@ -1,10 +1,72 @@
 // src/import-organizer/index.ts
 import { spawn } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
-import { basename as basename2, isAbsolute as isAbsolute2 } from "node:path";
+import { basename as basename2, isAbsolute as isAbsolute3 } from "node:path";
+
+// src/runtime/index.ts
+import { basename, extname as extname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/runtime/local-bin.ts
+import { createRequire } from "node:module";
+import { delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+function resolveExecInvocation(command, args = []) {
+  const resolved = resolveWin32Command(command);
+  const normalizedResolved = resolved.toLowerCase();
+  const needsShell = process.platform === "win32" && (normalizedResolved.endsWith(".cmd") || normalizedResolved.endsWith(".bat"));
+  if (needsShell) {
+    const shim = buildWin32CmdShimInvocation(resolved, args);
+    return { cmd: shim.command, args: shim.args, windowsVerbatimArguments: true };
+  }
+  return { cmd: resolved, args: [...args], windowsVerbatimArguments: false };
+}
+function isInside(parent, candidate) {
+  const rel = relative(parent, candidate);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+var binCache = /* @__PURE__ */ new Map();
+var BIN_CACHE_MAX = 64;
+var NEGATIVE_BIN_CACHE_TTL_MS = 5e3;
+function cachePut(key, value) {
+  while (binCache.size >= BIN_CACHE_MAX) {
+    const oldest = binCache.keys().next().value;
+    if (oldest === void 0) break;
+    binCache.delete(oldest);
+  }
+  binCache.set(key, { value, cachedAt: Date.now() });
+  return value;
+}
+function resolveNodeBin(packageName, binName, cwd, extraArgs = []) {
+  const key = `${packageName}|${binName}|${cwd}`;
+  const cached = binCache.get(key);
+  if (cached !== void 0) {
+    if (cached.value !== null || Date.now() - cached.cachedAt < NEGATIVE_BIN_CACHE_TTL_MS) {
+      return cached.value === null ? null : { ...cached.value, args: [cached.value.entry, ...extraArgs] };
+    }
+    binCache.delete(key);
+  }
+  let resolved = null;
+  try {
+    const requireFromProject = createRequire(resolve(cwd, "package.json"));
+    const packagePath = requireFromProject.resolve(`${packageName}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    const relativeBin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.[binName] ?? Object.values(packageJson.bin ?? {})[0];
+    if (relativeBin && !isAbsolute(relativeBin)) {
+      const packageDir = dirname(packagePath);
+      const entry = resolve(packageDir, relativeBin);
+      if (isInside(packageDir, entry)) {
+        resolved = { cmd: process.execPath, args: [entry], entry };
+      }
+    }
+  } catch {
+    resolved = null;
+  }
+  cachePut(key, resolved);
+  return resolved === null ? null : { ...resolved, args: [resolved.entry, ...extraArgs] };
+}
 
 // src/runtime/index.ts
-import { basename, extname, isAbsolute, relative, resolve } from "node:path";
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
   return arg.length > 0 && arg.startsWith("-");
@@ -12,13 +74,13 @@ function hasLeadingDash(arg) {
 function withinProjectPath(projectRoot, candidate) {
   if (candidate.length === 0 || candidate.length > 4096) return false;
   if (hasLeadingDash(candidate)) return false;
-  const resolved = isAbsolute(candidate) ? resolve(candidate) : resolve(projectRoot, candidate);
-  const rel = relative(projectRoot, resolved);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+  const resolved = isAbsolute2(candidate) ? resolve2(candidate) : resolve2(projectRoot, candidate);
+  const rel = relative2(projectRoot, resolved);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function withinProject(p) {
   const cwd = process.cwd();
-  return withinProjectPath(cwd, p) || relative(cwd, p) === ".";
+  return withinProjectPath(cwd, p) || relative2(cwd, p) === ".";
 }
 
 // src/import-organizer/index.ts
@@ -30,23 +92,51 @@ var ALLOWED_FIRST_TOKENS = /* @__PURE__ */ new Set([
   "biome",
   "@biomejs/biome",
   "eslint",
+  "oxlint",
   "node"
   // Recognise a fully-qualified project-local path like
   // "./node_modules/.bin/biome"; basename check kicks in below.
 ]);
+var PACKAGE_RUNNERS = /* @__PURE__ */ new Set(["npx", "pnpm", "npm", "yarn"]);
+var LOCAL_BIN_PACKAGES = {
+  biome: { packageName: "@biomejs/biome", binName: "biome" },
+  "@biomejs/biome": { packageName: "@biomejs/biome", binName: "biome" },
+  eslint: { packageName: "eslint", binName: "eslint" },
+  oxlint: { packageName: "oxlint", binName: "oxlint" }
+};
+function resolveLocalToolCommand(tokens) {
+  if (tokens.length === 0) return null;
+  let i = 0;
+  if (PACKAGE_RUNNERS.has(tokens[i])) {
+    i++;
+    while (i < tokens.length && (tokens[i] === "exec" || tokens[i] === "dlx" || tokens[i] === "run")) {
+      i++;
+    }
+  }
+  const toolToken = tokens[i];
+  if (!toolToken) return null;
+  const rest = tokens.slice(i + 1);
+  const pkg = LOCAL_BIN_PACKAGES[toolToken];
+  if (!pkg) return null;
+  const local = resolveNodeBin(pkg.packageName, pkg.binName, process.cwd(), rest);
+  if (!local) return null;
+  return { cmd: local.cmd, args: local.args };
+}
 function resolveAllowedCommand(command) {
   const tokens = command.split(/\s+/).filter(Boolean);
   if (tokens.length === 0) return null;
   const head = tokens[0];
+  const local = ALLOWED_FIRST_TOKENS.has(head) ? resolveLocalToolCommand(tokens) : null;
+  if (local) return local;
   if (ALLOWED_FIRST_TOKENS.has(head)) {
     return { cmd: head, args: tokens.slice(1) };
   }
-  if (isAbsolute2(head)) {
+  if (isAbsolute3(head)) {
     if (!withinProject(head)) return null;
     const base = basename2(head);
     if (ALLOWED_FIRST_TOKENS.has(base)) return { cmd: head, args: tokens.slice(1) };
   }
-  if (!isAbsolute2(head) && withinProject(head)) {
+  if (!isAbsolute3(head) && withinProject(head)) {
     const base = basename2(head);
     if (ALLOWED_FIRST_TOKENS.has(base)) return { cmd: head, args: tokens.slice(1) };
   }
@@ -81,40 +171,70 @@ function readConfig(raw) {
     notifyFormatOnSave: r["notifyFormatOnSave"] !== false
   };
 }
+var MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
 function runCommand(command, args, timeoutMs, cwd) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let timedOut = false;
+    let settled = false;
+    const settle = (r) => {
+      if (settled) return;
+      settled = true;
+      resolve3(r);
+    };
     const stdoutChunks = [];
     const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    const signal = AbortSignal.timeout(timeoutMs);
+    const onAbort = () => {
+      timedOut = true;
+      settle({ code: null, stdout: "", stderr: "", timedOut: true });
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
     let child;
+    let invocation;
     try {
-      child = spawn(command, args, {
+      invocation = resolveExecInvocation(command, args);
+    } catch {
+      signal.removeEventListener("abort", onAbort);
+      settle({ code: 127, stdout: "", stderr: "", timedOut: false });
+      return;
+    }
+    try {
+      child = spawn(invocation.cmd, invocation.args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
-        signal: AbortSignal.timeout(timeoutMs)
+        signal,
+        windowsHide: true,
+        ...invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
       });
     } catch {
-      resolve2({ code: 127, stdout: "", stderr: "", timedOut: false });
+      signal.removeEventListener("abort", onAbort);
+      settle({ code: 127, stdout: "", stderr: "", timedOut: false });
       return;
     }
-    child.stdout?.on("data", (c) => stdoutChunks.push(c));
-    child.stderr?.on("data", (c) => stderrChunks.push(c));
+    child.stdout?.on("data", (c) => {
+      stdoutBytes += c.length;
+      if (stdoutBytes <= MAX_CAPTURE_BYTES) stdoutChunks.push(c);
+    });
+    child.stderr?.on("data", (c) => {
+      stderrBytes += c.length;
+      if (stderrBytes <= MAX_CAPTURE_BYTES) stderrChunks.push(c);
+    });
     child.on("error", () => {
-      resolve2({ code: 127, stdout: "", stderr: "", timedOut: false });
+      signal.removeEventListener("abort", onAbort);
+      settle({ code: 127, stdout: "", stderr: "", timedOut: false });
     });
     child.on("close", (code) => {
+      signal.removeEventListener("abort", onAbort);
       if (timedOut) return;
-      resolve2({
+      settle({
         code,
         stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
         stderr: Buffer.concat(stderrChunks).toString("utf-8"),
         timedOut: false
       });
     });
-    child.on("abort", () => {
-      timedOut = true;
-      resolve2({ code: null, stdout: "", stderr: "", timedOut: true });
-    });
   });
 }
 async function organizeImports(filePath, cfg, cwd) {