@wrongstack/plugins 0.307.0 → 0.308.0

package/dist/dependency-vulnerability-gate.js

@@ -18,9 +18,382 @@ function resolveExecInvocation(command, args = []) {
 // src/runtime/index.ts
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 
+// src/dep-guard/index.ts
+var state = {
+  invocations: 0,
+  installsSeen: 0,
+  blocks: 0,
+  warns: 0,
+  llmConfirmCount: 0,
+  llmConfirmErrors: 0,
+  lastBlock: null,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  mode: "block",
+  deny: [],
+  allow: [],
+  warnOnUnpinned: false,
+  typosquatCheck: true,
+  confirmTyposquatsWithLlm: false
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  const strings = (v) => Array.isArray(v) ? v.filter((s) => typeof s === "string" && s.length > 0) : [];
+  return {
+    enabled: r["enabled"] !== false,
+    mode: r["mode"] === "warn" ? "warn" : "block",
+    deny: strings(r["deny"]),
+    allow: strings(r["allow"]),
+    warnOnUnpinned: r["warnOnUnpinned"] === true,
+    typosquatCheck: r["typosquatCheck"] !== false,
+    confirmTyposquatsWithLlm: r["confirmTyposquatsWithLlm"] === true
+  };
+}
+var INSTALL_RE = /(?:^|[;&|]\s*)(npm|pnpm|yarn|bun)\s+(?:install|i|add)\s+([^;&|]+)|(?:^|[;&|]\s*)(pip3?|uv)\s+(?:pip\s+)?install\s+([^;&|]+)|(?:^|[;&|]\s*)(cargo)\s+add\s+([^;&|]+)/gi;
+function parseInstallCommands(command) {
+  const out = [];
+  INSTALL_RE.lastIndex = 0;
+  let m = INSTALL_RE.exec(command);
+  while (m !== null) {
+    const manager = (m[1] ?? m[3] ?? m[5] ?? "").toLowerCase();
+    const argString = m[2] ?? m[4] ?? m[6] ?? "";
+    const packages = [];
+    for (const token of argString.split(/\s+/)) {
+      if (!token || token.startsWith("-")) continue;
+      if (/^(\.|\/|file:|git\+|https?:)/i.test(token) || token.endsWith(".tgz")) continue;
+      const cleaned = token.replace(/^['"]|['"]$/g, "");
+      if (!cleaned) continue;
+      let name = cleaned;
+      let version = null;
+      const pipMatch = /^([A-Za-z0-9_.-]+(?:\[[^\]]+\])?)\s*(==|>=|<=|~=|!=|>|<)\s*(.+)$/.exec(cleaned);
+      if (pipMatch?.[1]) {
+        name = pipMatch[1];
+        const op = pipMatch[2] ?? "";
+        const ver = (pipMatch[3] ?? "").trim();
+        version = op === "==" || op === "" ? ver || null : `${op}${ver}`;
+      } else {
+        const at = cleaned.lastIndexOf("@");
+        if (at > 0) {
+          name = cleaned.slice(0, at);
+          version = cleaned.slice(at + 1) || null;
+        }
+      }
+      if (name) packages.push({ name, version });
+    }
+    out.push({ manager, packages });
+    m = INSTALL_RE.exec(command);
+  }
+  return out;
+}
+function matchesPattern(name, pattern) {
+  if (pattern.endsWith("*"))
+    return name.toLowerCase().startsWith(pattern.slice(0, -1).toLowerCase());
+  return name.toLowerCase() === pattern.toLowerCase();
+}
+var POPULAR_PACKAGES = [
+  "react",
+  "react-dom",
+  "express",
+  "lodash",
+  "axios",
+  "typescript",
+  "vite",
+  "vitest",
+  "next",
+  "vue",
+  "svelte",
+  "zod",
+  "prettier",
+  "eslint",
+  "jest",
+  "webpack",
+  "commander",
+  "chalk",
+  "dotenv",
+  "requests",
+  "numpy",
+  "pandas",
+  "flask",
+  "django",
+  "serde",
+  "tokio"
+];
+function editDistance(a, b) {
+  if (a === b) return 0;
+  if (Math.abs(a.length - b.length) > 2) return 3;
+  const d = Array.from({ length: a.length + 1 }, (_, i) => {
+    const row = new Array(b.length + 1).fill(0);
+    row[0] = i;
+    return row;
+  });
+  for (let j = 0; j <= b.length; j++) d[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      const row = d[i];
+      const prevRow = d[i - 1];
+      row[j] = Math.min(
+        prevRow[j] + 1,
+        row[j - 1] + 1,
+        prevRow[j - 1] + cost
+      );
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        row[j] = Math.min(row[j], d[i - 2][j - 2] + 1);
+      }
+    }
+  }
+  return d[a.length][b.length];
+}
+function typosquatOf(name) {
+  const lower = name.toLowerCase().replace(/^@[^/]+\//, "");
+  if (POPULAR_PACKAGES.includes(lower)) return null;
+  for (const popular of POPULAR_PACKAGES) {
+    if (editDistance(lower, popular) === 1) return popular;
+  }
+  return null;
+}
+var plugin = {
+  name: "dep-guard",
+  version: "0.1.0",
+  description: "Supervises dependency installs: blocks deny-listed packages, flags typosquat lookalikes, and optionally warns on unpinned versions",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true, hooks: true, llm: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      mode: {
+        type: "string",
+        enum: ["block", "warn"],
+        default: "block",
+        description: "How deny-list hits are handled."
+      },
+      deny: {
+        type: "array",
+        items: { type: "string" },
+        default: [],
+        description: 'Package names (exact) or prefix globs ("@evil/*") that must not be installed.'
+      },
+      allow: {
+        type: "array",
+        items: { type: "string" },
+        default: [],
+        description: "Exemptions that override deny."
+      },
+      warnOnUnpinned: {
+        type: "boolean",
+        default: false,
+        description: "Warn when a package is installed without an explicit version."
+      },
+      typosquatCheck: {
+        type: "boolean",
+        default: true,
+        description: "Warn when a package name is one edit away from a well-known package."
+      },
+      confirmTyposquatsWithLlm: {
+        type: "boolean",
+        default: false,
+        description: "Ask the risk-review Council to assess a flagged typosquat, with One Shot fallback. Appended to the warn context, never escalates to a block. Off by default."
+      }
+    }
+  },
+  setup(api) {
+    state.invocations = 0;
+    state.installsSeen = 0;
+    state.blocks = 0;
+    state.warns = 0;
+    state.llmConfirmCount = 0;
+    state.llmConfirmErrors = 0;
+    state.lastBlock = null;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["dep-guard"]);
+    const hook = async (input) => {
+      if (!cfg.enabled) return;
+      state.invocations += 1;
+      const ti = input.toolInput ?? {};
+      const command = typeof ti["command"] === "string" ? ti["command"] : "";
+      if (!command) return;
+      const installs = parseInstallCommands(command);
+      const packages = installs.flatMap((i) => i.packages);
+      if (packages.length === 0) return;
+      state.installsSeen += 1;
+      api.metrics.counter("installs_seen");
+      const notes = [];
+      for (const pkg of packages) {
+        const allowed = cfg.allow.some((p) => matchesPattern(pkg.name, p));
+        const denied = !allowed && cfg.deny.some((p) => matchesPattern(pkg.name, p));
+        if (denied) {
+          if (cfg.mode === "block") {
+            state.blocks += 1;
+            state.lastBlock = {
+              pkg: pkg.name,
+              command: command.slice(0, 200),
+              when: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            api.metrics.counter("blocks");
+            return {
+              decision: "block",
+              reason: `dep-guard: package "${pkg.name}" is on the deny list (config.extensions["dep-guard"].deny) \u2014 install refused. Ask the user before adding this dependency, or add an \`allow\` entry.`
+            };
+          }
+          notes.push(
+            `"${pkg.name}" is DENY-LISTED \u2014 do not add it without explicit user approval.`
+          );
+        }
+        if (cfg.typosquatCheck) {
+          const lookalike = typosquatOf(pkg.name);
+          if (lookalike) {
+            const baseNote = `"${pkg.name}" is one edit away from the well-known package "${lookalike}" \u2014 possible typosquat. Verify the name before installing.`;
+            if (cfg.confirmTyposquatsWithLlm && api.llm) {
+              try {
+                const question = `Classify whether npm package "${pkg.name}" is likely a typo or typosquat of "${lookalike}".`;
+                const council = api.llm.council ? await api.llm.council(question, {
+                  context: "The only supplied evidence is that the names have edit distance 1. Do not invent registry, download, ownership, or provenance facts.",
+                  profile: "risk-review",
+                  options: [
+                    { id: "typo", label: "Likely typo or typosquat" },
+                    { id: "real", label: "Likely distinct real package" },
+                    { id: "uncertain", label: "Insufficient evidence" }
+                  ]
+                }) : null;
+                const councilVerdict = council?.status === "decided" && council.optionId ? `${council.optionId.toUpperCase()}: ${council.reason ?? council.answer ?? "no rationale"}` : null;
+                const t = councilVerdict ? councilVerdict : (await api.llm.complete(
+                  `${question} Reply with ONE sentence starting with "TYPO:", "REAL:", or "UNCERTAIN:".`,
+                  {
+                    system: "You are a supply-chain security assistant. Use only supplied evidence and preserve uncertainty.",
+                    role: "security-reviewer",
+                    maxTokens: 100
+                  }
+                )).text.trim();
+                if (t) {
+                  state.llmConfirmCount += 1;
+                  api.metrics.counter("llm_confirm");
+                  notes.push(`${baseNote} LLM verdict: ${t.slice(0, 300)}`);
+                } else {
+                  notes.push(baseNote);
+                }
+              } catch {
+                state.llmConfirmErrors += 1;
+                notes.push(baseNote);
+              }
+            } else {
+              notes.push(baseNote);
+            }
+          }
+        }
+        if (cfg.warnOnUnpinned && pkg.version === null) {
+          notes.push(`"${pkg.name}" has no pinned version \u2014 consider "${pkg.name}@<version>".`);
+        }
+      }
+      if (notes.length > 0) {
+        state.warns += 1;
+        api.metrics.counter("warns");
+        return {
+          decision: "allow",
+          additionalContext: `dep-guard:
+${notes.map((n) => `  - ${n}`).join("\n")}`
+        };
+      }
+      return {
+        decision: "allow",
+        additionalContext: `dep-guard: this command adds ${packages.length} dependenc${packages.length === 1 ? "y" : "ies"}: ${packages.map((p) => p.name).join(", ")}. Confirm each is intentional.`
+      };
+    };
+    state.hookUnregister = api.registerHook("PreToolUse", "bash|exec", hook, {
+      name: "dep-guard",
+      stage: "validate",
+      failurePolicy: "closed",
+      policy: true
+    });
+    api.tools.register({
+      name: "dep_guard_status",
+      description: "Reports dep-guard state: deny/allow lists, mode, and counters (installs seen, blocks, warns).",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          mode: cfg.mode,
+          deny: cfg.deny,
+          allow: cfg.allow,
+          warnOnUnpinned: cfg.warnOnUnpinned,
+          typosquatCheck: cfg.typosquatCheck,
+          counters: {
+            invocations: state.invocations,
+            installsSeen: state.installsSeen,
+            llmConfirmCount: state.llmConfirmCount,
+            llmConfirmErrors: state.llmConfirmErrors,
+            blocks: state.blocks,
+            warns: state.warns
+          },
+          lastBlock: state.lastBlock
+        };
+      }
+    });
+    api.log.info("dep-guard plugin loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      mode: cfg.mode,
+      denyCount: cfg.deny.length
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocations,
+      installsSeen: state.installsSeen,
+      llmConfirmCount: state.llmConfirmCount,
+      llmConfirmErrors: state.llmConfirmErrors,
+      blocks: state.blocks,
+      warns: state.warns
+    };
+    state.invocations = 0;
+    state.installsSeen = 0;
+    state.blocks = 0;
+    state.warns = 0;
+    state.llmConfirmCount = 0;
+    state.llmConfirmErrors = 0;
+    state.lastBlock = null;
+    api.log.info("dep-guard: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastBlock === null ? `dep-guard: ${state.installsSeen} install command(s) seen, ${state.blocks} block(s), ${state.warns} warn(s)` : `dep-guard: last block on "${state.lastBlock.pkg}" at ${state.lastBlock.when}`,
+      counters: {
+        invocations: state.invocations,
+        installsSeen: state.installsSeen,
+        llmConfirmCount: state.llmConfirmCount,
+        llmConfirmErrors: state.llmConfirmErrors,
+        blocks: state.blocks,
+        warns: state.warns
+      }
+    };
+  }
+};
+
 // src/dependency-vulnerability-gate/index.ts
 var API_VERSION = "^0.1.10";
-var state = {
+var state2 = {
   invocations: 0,
   installsSeen: 0,
   auditsRun: 0,
@@ -30,7 +403,7 @@ var state = {
   lastResult: null,
   hookUnregister: null
 };
-var DEFAULTS = {
+var DEFAULTS2 = {
   enabled: true,
   severityThreshold: "high",
   block: true,
@@ -43,15 +416,15 @@ var SEVERITY_RANK = {
   high: 3,
   critical: 4
 };
-function readConfig(raw) {
-  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+function readConfig2(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS2 };
   const r = raw;
-  const threshold = typeof r["severityThreshold"] === "string" && ["low", "moderate", "high", "critical"].includes(r["severityThreshold"]) ? r["severityThreshold"] : DEFAULTS.severityThreshold;
+  const threshold = typeof r["severityThreshold"] === "string" && ["low", "moderate", "high", "critical"].includes(r["severityThreshold"]) ? r["severityThreshold"] : DEFAULTS2.severityThreshold;
   return {
     enabled: r["enabled"] !== false,
     severityThreshold: threshold,
     block: r["block"] !== false,
-    timeoutMs: typeof r["timeoutMs"] === "number" && r["timeoutMs"] > 0 ? r["timeoutMs"] : DEFAULTS.timeoutMs
+    timeoutMs: typeof r["timeoutMs"] === "number" && r["timeoutMs"] > 0 ? r["timeoutMs"] : DEFAULTS2.timeoutMs
   };
 }
 function collectSeverities(out, severity) {
@@ -122,13 +495,12 @@ function exceedsThreshold(report, threshold) {
   if (thresholdRank == null || maxRank == null) return false;
   return maxRank >= thresholdRank;
 }
-var INSTALL_RE = /\b(?:npm\s+(?:install|i)|pnpm\s+add|yarn\s+add)\b/i;
 function isInstallCommand(input) {
   if (input.toolName === "install") return true;
   if (input.toolName !== "bash" && input.toolName !== "exec") return false;
   const ti = input.toolInput ?? {};
   const command = typeof ti["command"] === "string" ? ti["command"] : "";
-  return INSTALL_RE.test(command);
+  return parseInstallCommands(command).length > 0;
 }
 var LOCKFILE_MANAGERS = [
   { file: "pnpm-lock.yaml", manager: "pnpm" },
@@ -183,13 +555,13 @@ async function runAudit(cfg) {
   if (!report) return null;
   return { manager, report, durationMs: Date.now() - start };
 }
-var plugin = {
+var plugin2 = {
   name: "dependency-vulnerability-gate",
   version: "0.1.0",
   description: "PostToolUse hook that runs npm/pnpm audit after dependency installs and blocks or warns on vulnerabilities above a severity threshold",
   apiVersion: API_VERSION,
   capabilities: { tools: true, hooks: true },
-  defaultConfig: { ...DEFAULTS },
+  defaultConfig: { ...DEFAULTS2 },
   configSchema: {
     type: "object",
     properties: {
@@ -218,35 +590,35 @@ var plugin = {
     }
   },
   setup(api) {
-    state.invocations = 0;
-    state.installsSeen = 0;
-    state.auditsRun = 0;
-    state.blocks = 0;
-    state.warns = 0;
-    state.errors = 0;
-    state.lastResult = null;
-    if (state.hookUnregister) {
+    state2.invocations = 0;
+    state2.installsSeen = 0;
+    state2.auditsRun = 0;
+    state2.blocks = 0;
+    state2.warns = 0;
+    state2.errors = 0;
+    state2.lastResult = null;
+    if (state2.hookUnregister) {
       try {
-        state.hookUnregister();
+        state2.hookUnregister();
       } catch {
       }
-      state.hookUnregister = null;
+      state2.hookUnregister = null;
     }
-    const cfg = readConfig(api.config.extensions?.["dependency-vulnerability-gate"]);
+    const cfg = readConfig2(api.config.extensions?.["dependency-vulnerability-gate"]);
     const hook = async (input) => {
       if (!cfg.enabled) return;
-      state.invocations += 1;
+      state2.invocations += 1;
       if (input.toolResult?.isError) return;
       if (!isInstallCommand(input)) return;
-      state.installsSeen += 1;
+      state2.installsSeen += 1;
       api.metrics.counter("installs_seen");
       const result = await runAudit(cfg);
       if (!result) {
-        state.errors += 1;
+        state2.errors += 1;
         return;
       }
-      state.auditsRun += 1;
-      state.lastResult = {
+      state2.auditsRun += 1;
+      state2.lastResult = {
         manager: result.manager,
         exceeded: exceedsThreshold(result.report, cfg.severityThreshold),
         maxSeverity: result.report.maxSeverity,
@@ -264,18 +636,18 @@ var plugin = {
   Counts: ${countsText || "unknown"}
 Review the audit output or adjust the dependency choice.`;
       if (cfg.block) {
-        state.blocks += 1;
+        state2.blocks += 1;
         api.metrics.counter("blocks");
         return {
           decision: "block",
           reason: message
         };
       }
-      state.warns += 1;
+      state2.warns += 1;
       api.metrics.counter("warns");
       return { additionalContext: message };
     };
-    state.hookUnregister = api.registerHook("PostToolUse", "install|bash|exec", hook);
+    state2.hookUnregister = api.registerHook("PostToolUse", "install|bash|exec", hook);
     api.tools.register({
       name: "dependency_audit_status",
       description: "Reports dependency-vulnerability-gate state: threshold, block mode, and per-session counters.",
@@ -291,14 +663,14 @@ Review the audit output or adjust the dependency choice.`;
           block: cfg.block,
           timeoutMs: cfg.timeoutMs,
           counters: {
-            invocations: state.invocations,
-            installsSeen: state.installsSeen,
-            auditsRun: state.auditsRun,
-            blocks: state.blocks,
-            warns: state.warns,
-            errors: state.errors
+            invocations: state2.invocations,
+            installsSeen: state2.installsSeen,
+            auditsRun: state2.auditsRun,
+            blocks: state2.blocks,
+            warns: state2.warns,
+            errors: state2.errors
           },
-          lastResult: state.lastResult
+          lastResult: state2.lastResult
         };
       }
     });
@@ -309,47 +681,48 @@ Review the audit output or adjust the dependency choice.`;
     });
   },
   teardown(api) {
-    if (state.hookUnregister) {
+    if (state2.hookUnregister) {
       try {
-        state.hookUnregister();
+        state2.hookUnregister();
       } catch {
       }
-      state.hookUnregister = null;
+      state2.hookUnregister = null;
     }
     const final = {
-      invocations: state.invocations,
-      installsSeen: state.installsSeen,
-      auditsRun: state.auditsRun,
-      blocks: state.blocks,
-      warns: state.warns,
-      errors: state.errors
+      invocations: state2.invocations,
+      installsSeen: state2.installsSeen,
+      auditsRun: state2.auditsRun,
+      blocks: state2.blocks,
+      warns: state2.warns,
+      errors: state2.errors
     };
-    state.invocations = 0;
-    state.installsSeen = 0;
-    state.auditsRun = 0;
-    state.blocks = 0;
-    state.warns = 0;
-    state.errors = 0;
-    state.lastResult = null;
+    state2.invocations = 0;
+    state2.installsSeen = 0;
+    state2.auditsRun = 0;
+    state2.blocks = 0;
+    state2.warns = 0;
+    state2.errors = 0;
+    state2.lastResult = null;
     api.log.info("dependency-vulnerability-gate: teardown complete", { final });
   },
   async health() {
     return {
       ok: true,
-      message: state.lastResult ? `dependency-vulnerability-gate: ${state.auditsRun} audit(s), last ${state.lastResult.exceeded ? "EXCEEDED" : "clean"} (${state.lastResult.maxSeverity})` : `dependency-vulnerability-gate: ${state.installsSeen} install(s) seen, ${state.auditsRun} audit(s)`,
+      message: state2.lastResult ? `dependency-vulnerability-gate: ${state2.auditsRun} audit(s), last ${state2.lastResult.exceeded ? "EXCEEDED" : "clean"} (${state2.lastResult.maxSeverity})` : `dependency-vulnerability-gate: ${state2.installsSeen} install(s) seen, ${state2.auditsRun} audit(s)`,
       counters: {
-        invocations: state.invocations,
-        installsSeen: state.installsSeen,
-        auditsRun: state.auditsRun,
-        blocks: state.blocks,
-        warns: state.warns,
-        errors: state.errors
+        invocations: state2.invocations,
+        installsSeen: state2.installsSeen,
+        auditsRun: state2.auditsRun,
+        blocks: state2.blocks,
+        warns: state2.warns,
+        errors: state2.errors
       },
-      lastResult: state.lastResult
+      lastResult: state2.lastResult
     };
   }
 };
-var dependency_vulnerability_gate_default = plugin;
+var dependency_vulnerability_gate_default = plugin2;
 export {
-  dependency_vulnerability_gate_default as default
+  dependency_vulnerability_gate_default as default,
+  isInstallCommand
 };

package/dist/file-watcher.js

@@ -1,17 +1,32 @@
 // src/file-watcher/index.ts
 import { watch as fsWatch } from "node:fs";
-import { isAbsolute, join, relative, resolve } from "node:path";
-var API_VERSION = "^0.1.10";
+import { join } from "node:path";
+
+// src/runtime/index.ts
+import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/index.ts
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+function hasLeadingDash(arg) {
+  return arg.length > 0 && arg.startsWith("-");
+}
+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);
+}
 function withinProject(p) {
-  if (typeof p !== "string" || p.length === 0 || p.length > 4096) return false;
-  const root = process.cwd();
-  const resolved = isAbsolute(p) ? resolve(p) : resolve(root, p);
-  const rel = relative(root, resolved);
-  if (rel === "" || rel === ".") return true;
-  if (rel.startsWith("..")) return false;
-  if (isAbsolute(rel)) return false;
-  return true;
+  const cwd = process.cwd();
+  return withinProjectPath(cwd, p) || relative(cwd, p) === ".";
 }
+
+// src/file-watcher/index.ts
+var API_VERSION = "^0.1.10";
 var watch_idCounter = 0;
 function nextId() {
   return `watch_${++watch_idCounter}_${Date.now().toString(36)}`;