@wrongstack/plugins 0.308.6 → 0.309.0

package/dist/type-gate.js

@@ -1,312 +1,24 @@
-// src/type-gate/index.ts
-import { existsSync } from "node:fs";
-
-// src/runtime/index.ts
-import { execFile } from "node:child_process";
-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;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  cachePut(key, resolved);
-  return resolved === null ? null : { ...resolved, args: [resolved.entry, ...extraArgs] };
-}
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
-// src/runtime/handles.ts
-function releaseHandle(off) {
-  if (off) {
-    try {
-      off();
-    } catch {
-    }
-  }
-  return null;
-}
+// src/type-gate/index.ts
+import { existsSync } from "node:fs";
 
 // src/runtime/index.ts
-var META_CHARS = /["'`;&|<>\r\n]/;
-var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
-function hasLeadingDash(arg) {
-  return arg.length > 0 && arg.startsWith("-");
-}
-function safeSplit(command) {
-  const trimmed = command.trim();
-  if (!trimmed || META_CHARS.test(trimmed)) return null;
-  return trimmed.split(/\s+/).filter(Boolean);
-}
-function withinProjectPath(projectRoot, candidate) {
-  if (candidate.length === 0 || candidate.length > 4096) return false;
-  if (hasLeadingDash(candidate)) return false;
-  const resolved = isAbsolute2(candidate) ? resolve2(candidate) : resolve2(projectRoot, candidate);
-  const rel = relative2(projectRoot, resolved);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
-}
-function everyFlagAllowed(allowed, args) {
-  for (const arg of args) {
-    if (!hasLeadingDash(arg)) continue;
-    if (allowed === null) return false;
-    if (!allowed.has(arg)) return false;
-  }
-  return true;
-}
-function sanitizeRunnerPath(value, options = {}) {
-  if (!value || hasLeadingDash(value)) return null;
-  const projectRoot = resolve2(options.projectRoot ?? process.cwd());
-  if (!withinProjectPath(projectRoot, value)) return null;
-  return isAbsolute2(value) ? resolve2(value) : resolve2(projectRoot, value);
-}
-function resolveRunnerCommand(runtime, command, options = {}) {
-  const tokens = safeSplit(command);
-  if (!tokens || tokens.length === 0) return null;
-  const projectRoot = resolve2(options.projectRoot ?? process.cwd());
-  const launcher = runtime.packageManager;
-  const [head, second, ...rest] = tokens;
-  if (!head) return null;
-  const display = tokens.join(" ");
-  if (launcher !== "none" && tokens.length === 1 && head === launcher) {
-    return null;
-  }
-  if (head === runtime.executable) {
-    if (!everyFlagAllowed(runtime.allowedFlags, [second, ...rest].filter((v) => Boolean(v)))) {
-      return null;
-    }
-    return {
-      cmd: head,
-      args: [second, ...rest].filter((v) => Boolean(v)),
-      display
-    };
-  }
-  if (launcher !== "none" && head === launcher && runtime.subcommands.length === 0 && second === runtime.executable) {
-    if (!everyFlagAllowed(runtime.allowedFlags, rest)) return null;
-    return { cmd: head, args: [second, ...rest], display };
-  }
-  if (launcher !== "none" && head === launcher && runtime.subcommands.length > 0) {
-    const subcommand = runtime.subcommands[0];
-    const exe = rest[0];
-    if (second === subcommand && exe === runtime.executable) {
-      const tail = rest.slice(1);
-      if (!everyFlagAllowed(runtime.allowedFlags, tail)) return null;
-      return { cmd: head, args: [second, exe, ...tail], display };
-    }
-  }
-  if (isAbsolute2(head)) {
-    if (!withinProjectPath(projectRoot, head)) return null;
-    const base = basename(head);
-    if (base !== runtime.executable && base !== launcher) return null;
-    if (second !== runtime.executable) return null;
-    if (!everyFlagAllowed(runtime.allowedFlags, rest)) return null;
-    return { cmd: head, args: [second, ...rest], display };
-  }
-  return null;
-}
-function runRunnerCommand(argv, options) {
-  if (argv.length === 0) {
-    return Promise.resolve({
-      code: null,
-      stdout: "",
-      stderr: "runtime helper: empty argv",
-      timedOut: false,
-      spawnError: true
-    });
-  }
-  return new Promise((resolvePromise) => {
-    const projectRoot = resolve2(options.projectRoot ?? process.cwd());
-    const trimmedCwd = options.cwd.trim();
-    if (!withinProjectPath(projectRoot, trimmedCwd)) {
-      resolvePromise({
-        code: null,
-        stdout: "",
-        stderr: "runtime helper: cwd outside project",
-        timedOut: false,
-        spawnError: true
-      });
-      return;
-    }
-    let timedOut = false;
-    let spawnErrored = false;
-    const start = Date.now();
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
-    const onAbort = () => {
-      timedOut = true;
-    };
-    let invocation;
-    try {
-      invocation = resolveExecInvocation(argv[0], argv.slice(1));
-    } catch (err) {
-      resolvePromise({
-        code: null,
-        stdout: "",
-        stderr: `runtime helper: ${err instanceof Error ? err.message : String(err)}`,
-        timedOut: false,
-        spawnError: true
-      });
-      return;
-    }
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    const child = execFile(
-      invocation.cmd,
-      invocation.args,
-      {
-        cwd: trimmedCwd,
-        timeout: options.timeoutMs,
-        signal: options.signal,
-        maxBuffer: MAX_BUFFER_BYTES,
-        // execFile defaults `encoding` to 'utf8', which makes the
-        // stdout/stderr `data` events emit *strings*. The chunk arrays
-        // below are typed Buffer[] and every consumer runs them through
-        // Buffer.concat(...).toString('utf8'), which throws
-        // ERR_INVALID_ARG_TYPE on any non-empty string output. Pin the
-        // streams to buffers so the declared contract holds (regression:
-        // runRunnerCommand crashed on any child that actually wrote
-        // output; only the maxBuffer fixture exercised this path).
-        encoding: "buffer",
-        windowsHide: true,
-        shell: false,
-        ...invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
-      },
-      (err) => {
-        options.signal?.removeEventListener("abort", onAbort);
-        if (timedOut) {
-          resolvePromise({
-            code: null,
-            stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-            stderr: Buffer.concat(stderrChunks).toString("utf8"),
-            timedOut: true,
-            spawnError: false
-          });
-          return;
-        }
-        if (spawnErrored) {
-          resolvePromise({
-            code: 127,
-            stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-            stderr: Buffer.concat(stderrChunks).toString("utf8"),
-            timedOut: false,
-            spawnError: true
-          });
-          return;
-        }
-        if (err) {
-          const anyErr = err;
-          if ((anyErr.killed === true || anyErr.signal === "SIGTERM") && // maxBuffer overflow must NOT be misreported as a timeout
-          // — it's a real failure (the child wrote too much) and
-          // downstream callers (type-gate/index.ts:227) return
-          // null on timedOut=true, which would silently swallow
-          // maxBuffer overflow into a confusing empty-output
-          // result. Skip the timeout resolve when the err shape
-          // names maxBuffer explicitly.
-          !/maxBuffer length exceeded/i.test(anyErr.message ?? "") && // And only count it as a timeout if the wall clock has
-          // actually elapsed past the budget. External SIGTERMs and
-          // races against the exit handler don't satisfy this.
-          Date.now() - start >= options.timeoutMs) {
-            resolvePromise({
-              code: null,
-              stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-              stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-              timedOut: true,
-              spawnError: false
-            });
-            return;
-          }
-          const code = typeof anyErr.code === "number" ? anyErr.code : 1;
-          resolvePromise({
-            code,
-            stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-            stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-            timedOut: false,
-            spawnError: false
-          });
-          return;
-        }
-        resolvePromise({
-          code: 0,
-          stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf8"),
-          timedOut: false,
-          spawnError: false
-        });
-      }
-    );
-    child.on("exit", (_code, signal) => {
-      if (signal !== null && Date.now() - start >= options.timeoutMs) {
-        timedOut = true;
-      }
-    });
-    child.stdout?.on("data", (chunk) => {
-      stdoutBytes += chunk.length;
-      if (stdoutBytes <= MAX_BUFFER_BYTES) stdoutChunks.push(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderrBytes += chunk.length;
-      if (stderrBytes <= MAX_BUFFER_BYTES) stderrChunks.push(chunk);
-    });
-    child.on("error", (err) => {
-      if (err.code === "ENOENT" || err.code === "EPERM" || err.code === "EACCES") {
-        spawnErrored = true;
-      }
-    });
-  });
-}
-function withinProject(p) {
-  const cwd = process.cwd();
-  return withinProjectPath(cwd, p) || relative2(cwd, p) === ".";
-}
+var runtime_exports = {};
+__reExport(runtime_exports, runtime_star);
+import * as runtime_star from "@wrongstack/plugin-sdk/runtime";
 
 // src/type-gate/index.ts
 var API_VERSION = "^0.1.10";
@@ -365,7 +77,7 @@ var TSC_RUNTIME = {
   defaultCommand: "pnpm exec tsc --noEmit"
 };
 function validateTsConfigPath(p) {
-  const sanitized = sanitizeRunnerPath(p);
+  const sanitized = (0, runtime_exports.sanitizeRunnerPath)(p);
   return sanitized;
 }
 async function runTypeCheck(cfg) {
@@ -378,12 +90,12 @@ async function runTypeCheck(cfg) {
   const tsConfig = validTsConfig ?? (rawTsConfig || "tsconfig.json");
   let argv;
   if (cfg.command) {
-    const resolved = resolveRunnerCommand(TSC_RUNTIME, cfg.command);
+    const resolved = (0, runtime_exports.resolveRunnerCommand)(TSC_RUNTIME, cfg.command);
     if (!resolved) return null;
     argv = [resolved.cmd, ...resolved.args];
   } else {
     const tscFlags = ["--noEmit", "--incremental"];
-    const localTsc = resolveNodeBin("typescript", "tsc", process.cwd(), tscFlags);
+    const localTsc = (0, runtime_exports.resolveNodeBin)("typescript", "tsc", process.cwd(), tscFlags);
     argv = localTsc ? [localTsc.cmd, ...localTsc.args] : ["npx", "tsc", ...tscFlags];
     if (tsConfig && tsConfig !== "tsconfig.json") {
       argv = [...argv, "-p", tsConfig];
@@ -392,7 +104,7 @@ async function runTypeCheck(cfg) {
   if (!cfg.command && tsConfig && !existsSync(tsConfig)) {
     return null;
   }
-  const result = await runRunnerCommand([argv[0], ...argv.slice(1)], {
+  const result = await (0, runtime_exports.runRunnerCommand)([argv[0], ...argv.slice(1)], {
     cwd: process.cwd(),
     timeoutMs: cfg.timeoutMs
   });
@@ -480,7 +192,7 @@ var plugin = {
     state.errorCount = 0;
     state.skippedCount = 0;
     state.lastResult = null;
-    state.hookUnregister = releaseHandle(state.hookUnregister);
+    state.hookUnregister = (0, runtime_exports.releaseHandle)(state.hookUnregister);
     const cfg = readConfig(api.config.extensions?.["type-gate"]);
     const hook = async (input) => {
       if (!cfg.enabled) return;
@@ -488,7 +200,7 @@ var plugin = {
       const inp = input.toolInput ?? {};
       const sourcePath = inp["path"];
       if (!sourcePath || typeof sourcePath !== "string") return;
-      if (!withinProject(sourcePath)) return;
+      if (!(0, runtime_exports.withinProject)(sourcePath)) return;
       const ext = sourcePath.includes(".") ? sourcePath.slice(sourcePath.lastIndexOf(".")).toLowerCase() : "";
       if (!runOnChangeSet.has(ext)) {
         state.skippedCount += 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/plugins",
-  "version": "0.308.6",
+  "version": "0.309.0",
   "description": "Official WrongStack collection of focused plugins for code quality, security, observability, planning, and agent coordination",
   "license": "MIT",
   "author": "ECOSTACK TECHNOLOGY OÜ",
@@ -303,8 +303,9 @@
     "vitest": "^4.1.10"
   },
   "dependencies": {
-    "@wrongstack/core": "0.308.6",
-    "@wrongstack/tools": "0.308.6"
+    "@wrongstack/plugin-sdk": "0.309.0",
+    "@wrongstack/core": "0.309.0",
+    "@wrongstack/tools": "0.309.0"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.mjs",