@wrongstack/plugins 0.295.0 → 0.296.2

package/dist/import-organizer.js

@@ -1,10 +1,83 @@
 // 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/handles.ts
+function releaseHandle(off) {
+  if (off) {
+    try {
+      off();
+    } catch {
+    }
+  }
+  return null;
+}
 
 // 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 +85,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 +103,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 +182,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 {
+      invocation = resolveExecInvocation(command, args);
+    } catch {
+      signal.removeEventListener("abort", onAbort);
+      settle({ code: 127, stdout: "", stderr: "", timedOut: false });
+      return;
+    }
     try {
-      child = spawn(command, args, {
+      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) {
@@ -198,7 +329,7 @@ var plugin = {
     state.organizedCount = 0;
     state.cleanCount = 0;
     state.errorCount = 0;
-    state.hookUnregister = null;
+    state.hookUnregister = releaseHandle(state.hookUnregister);
     state.lastResult = null;
     state.probeComplete = false;
     state.linterAvailable = false;