@node9/proxy 1.3.0 → 1.3.2

package/dist/index.mjs

@@ -155,8 +155,8 @@ function sanitizeConfig(raw) {
     }
   }
   const lines = result.error.issues.map((issue) => {
-    const path10 = issue.path.length > 0 ? issue.path.join(".") : "root";
-    return `  \u2022 ${path10}: ${issue.message}`;
+    const path13 = issue.path.length > 0 ? issue.path.join(".") : "root";
+    return `  \u2022 ${path13}: ${issue.message}`;
   });
   return {
     sanitized,
@@ -886,6 +886,7 @@ function getCompiledRegex(pattern, flags = "") {
 }
 
 // src/policy/index.ts
+import path7 from "path";
 import pm from "picomatch";
 import { parse } from "sh-syntax";
 
@@ -1031,8 +1032,416 @@ function scanArgs(args, depth = 0, fieldPath = "args") {
   return null;
 }
 
+// src/utils/provenance.ts
+import fs5 from "fs";
+import path5 from "path";
+import os4 from "os";
+var SYSTEM_PREFIXES = ["/usr/bin", "/usr/sbin", "/bin", "/sbin"];
+var MANAGED_PREFIXES = ["/usr/local/bin", "/opt/homebrew", "/home/linuxbrew", "/nix/store"];
+var USER_PREFIXES = [
+  path5.join(os4.homedir(), "bin"),
+  path5.join(os4.homedir(), ".local", "bin"),
+  path5.join(os4.homedir(), ".cargo", "bin"),
+  path5.join(os4.homedir(), ".npm-global", "bin"),
+  path5.join(os4.homedir(), ".volta", "bin")
+];
+var SUSPECT_PREFIXES = ["/tmp", "/var/tmp", "/dev/shm"];
+function findInPath(cmd) {
+  if (path5.posix.isAbsolute(cmd)) return cmd;
+  const pathEnv = process.env.PATH ?? "";
+  for (const dir of pathEnv.split(path5.delimiter)) {
+    if (!dir) continue;
+    const full = path5.join(dir, cmd);
+    try {
+      fs5.accessSync(full, fs5.constants.X_OK);
+      return full;
+    } catch {
+    }
+  }
+  return null;
+}
+function _classifyPath(resolved, cwd) {
+  if (cwd && resolved.startsWith(cwd + "/")) {
+    return { trustLevel: "user", reason: "binary in project directory" };
+  }
+  const osTmp = os4.tmpdir();
+  const allSuspect = osTmp ? [...SUSPECT_PREFIXES, osTmp] : SUSPECT_PREFIXES;
+  if (allSuspect.some((p) => resolved === p || resolved.startsWith(p + "/"))) {
+    return { trustLevel: "suspect", reason: `binary in temp directory: ${resolved}` };
+  }
+  if (SYSTEM_PREFIXES.some((p) => resolved === p || resolved.startsWith(p + "/"))) {
+    return { trustLevel: "system", reason: "" };
+  }
+  if (MANAGED_PREFIXES.some((p) => resolved === p || resolved.startsWith(p + "/"))) {
+    return { trustLevel: "managed", reason: "" };
+  }
+  if (USER_PREFIXES.some((p) => resolved === p || resolved.startsWith(p + "/"))) {
+    return { trustLevel: "user", reason: "" };
+  }
+  return { trustLevel: "unknown", reason: "binary in unrecognized location" };
+}
+function checkProvenance(cmd, cwd) {
+  const bare = cmd.startsWith("./") ? cmd.slice(2) : cmd;
+  if (path5.posix.isAbsolute(bare)) {
+    const early = _classifyPath(bare, cwd);
+    if (early.trustLevel === "suspect") {
+      return { resolvedPath: bare, ...early };
+    }
+  }
+  let resolved;
+  try {
+    const found = findInPath(bare);
+    if (!found) {
+      return {
+        resolvedPath: cmd,
+        trustLevel: "unknown",
+        reason: "binary not found in PATH"
+      };
+    }
+    resolved = fs5.realpathSync(found);
+  } catch {
+    return {
+      resolvedPath: cmd,
+      trustLevel: "unknown",
+      reason: "binary not found in PATH"
+    };
+  }
+  try {
+    const stat = fs5.statSync(resolved);
+    if (stat.mode & 2) {
+      return {
+        resolvedPath: resolved,
+        trustLevel: "suspect",
+        reason: "binary is world-writable"
+      };
+    }
+  } catch {
+    return {
+      resolvedPath: resolved,
+      trustLevel: "unknown",
+      reason: "could not stat binary"
+    };
+  }
+  const classify = _classifyPath(resolved, cwd);
+  return { resolvedPath: resolved, ...classify };
+}
+
+// src/policy/pipe-chain.ts
+var SOURCE_COMMANDS = /* @__PURE__ */ new Set([
+  "cat",
+  "head",
+  "tail",
+  "grep",
+  "awk",
+  "sed",
+  "cut",
+  "sort",
+  "tee",
+  "less",
+  "more",
+  "strings",
+  "xxd"
+]);
+var SINK_COMMANDS = /* @__PURE__ */ new Set([
+  "curl",
+  "wget",
+  "nc",
+  "ncat",
+  "netcat",
+  "ssh",
+  "scp",
+  "rsync",
+  "socat",
+  "ftp",
+  "sftp",
+  "telnet"
+]);
+var OBFUSCATORS = /* @__PURE__ */ new Set([
+  "base64",
+  "gzip",
+  "gunzip",
+  "bzip2",
+  "xz",
+  "zstd",
+  "openssl",
+  "gpg",
+  "python",
+  "python3",
+  "perl",
+  "ruby",
+  "node"
+]);
+var SENSITIVE_PATTERNS = [
+  /(?:^|\/)\.env(?:\.|$)/i,
+  // .env, .env.local, .env.production
+  /id_rsa|id_ed25519|id_ecdsa|id_dsa/i,
+  // SSH private keys
+  /\.pem$|\.key$|\.p12$|\.pfx$/i,
+  // certificate files
+  /(?:^|\/)\.ssh\//i,
+  // ~/.ssh/ directory
+  /(?:^|\/)\.aws\/credentials/i,
+  // AWS credentials
+  /(?:^|\/)\.netrc$/i,
+  // netrc (stores HTTP credentials)
+  /(?:^|\/)(passwd|shadow|sudoers)$/i,
+  // /etc/passwd, /etc/shadow
+  /(?:^|\/)credentials(?:\.json)?$/i
+  // generic credentials files
+];
+function isSensitivePath(p) {
+  return SENSITIVE_PATTERNS.some((re) => re.test(p));
+}
+function splitOnPipe(cmd) {
+  const segments = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < cmd.length; i++) {
+    const ch = cmd[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+    } else if (ch === "|" && !inSingle && !inDouble && cmd[i + 1] !== "|" && (i === 0 || cmd[i - 1] !== "|")) {
+      segments.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) segments.push(current.trim());
+  return segments.filter(Boolean);
+}
+function positionalTokens(segment) {
+  return segment.split(/\s+/).slice(1).filter((t) => !t.startsWith("-") && !t.startsWith("@") && t.length > 0);
+}
+function analyzePipeChain(command) {
+  const segments = splitOnPipe(command);
+  if (segments.length < 2) {
+    return {
+      isPipeline: false,
+      hasSensitiveSource: false,
+      hasExternalSink: false,
+      hasObfuscation: false,
+      sourceFiles: [],
+      sinkTargets: [],
+      risk: "none"
+    };
+  }
+  const sourceFiles = [];
+  const sinkTargets = [];
+  let hasSensitiveSource = false;
+  let hasExternalSink = false;
+  let hasObfuscation = false;
+  for (const segment of segments) {
+    const tokens = segment.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0) continue;
+    const binary = tokens[0].toLowerCase();
+    const args = positionalTokens(segment);
+    if (SOURCE_COMMANDS.has(binary)) {
+      sourceFiles.push(...args);
+      if (args.some(isSensitivePath)) hasSensitiveSource = true;
+    }
+    if (OBFUSCATORS.has(binary)) hasObfuscation = true;
+    if (SINK_COMMANDS.has(binary)) {
+      const targets = args.filter(
+        (a) => a.includes(".") || a.includes("://") || /^\d+\.\d+/.test(a)
+      );
+      sinkTargets.push(...targets);
+      if (targets.length > 0) hasExternalSink = true;
+    }
+  }
+  const fullCmd = command.toLowerCase();
+  if (!hasSensitiveSource) {
+    const redirMatch = fullCmd.match(/<\s*(\S+)/);
+    if (redirMatch && isSensitivePath(redirMatch[1])) {
+      hasSensitiveSource = true;
+      sourceFiles.push(redirMatch[1]);
+    }
+  }
+  const risk = hasSensitiveSource && hasExternalSink && hasObfuscation ? "critical" : hasSensitiveSource && hasExternalSink ? "high" : hasExternalSink ? "medium" : "none";
+  return {
+    isPipeline: true,
+    hasSensitiveSource,
+    hasExternalSink,
+    hasObfuscation,
+    sourceFiles,
+    sinkTargets,
+    risk
+  };
+}
+
+// src/policy/flag-tables.ts
+import path6 from "path";
+var FLAGS_WITH_VALUES = {
+  curl: /* @__PURE__ */ new Set([
+    "-H",
+    "--header",
+    "-A",
+    "--user-agent",
+    "-e",
+    "--referer",
+    "-x",
+    "--proxy",
+    "-u",
+    "--user",
+    "-d",
+    "--data",
+    "--data-raw",
+    "--data-binary",
+    "-o",
+    "--output",
+    "-F",
+    "--form",
+    "--connect-to",
+    "--resolve",
+    "--cacert",
+    "--cert",
+    "--key",
+    "-m",
+    "--max-time"
+  ]),
+  wget: /* @__PURE__ */ new Set([
+    "-O",
+    "--output-document",
+    "-P",
+    "--directory-prefix",
+    "-U",
+    "--user-agent",
+    "-e",
+    "--execute",
+    "--proxy",
+    "--ca-certificate"
+  ]),
+  nc: /* @__PURE__ */ new Set(["-x", "-p", "-s", "-w", "-W", "-I", "-O"]),
+  ncat: /* @__PURE__ */ new Set(["-x", "-p", "-s", "--proxy", "--proxy-auth", "-w", "--wait"]),
+  netcat: /* @__PURE__ */ new Set(["-x", "-p", "-s", "-w"]),
+  ssh: /* @__PURE__ */ new Set([
+    "-i",
+    "-l",
+    "-p",
+    "-o",
+    "-E",
+    "-F",
+    "-J",
+    "-L",
+    "-R",
+    "-W",
+    "-b",
+    "-c",
+    "-D",
+    "-e",
+    "-I",
+    "-S"
+  ]),
+  scp: /* @__PURE__ */ new Set(["-i", "-o", "-P", "-S"]),
+  rsync: /* @__PURE__ */ new Set(["-e", "--rsh", "--rsync-path", "--password-file", "--log-file"]),
+  socat: /* @__PURE__ */ new Set([])
+  // socat uses address syntax, not flags — no value-flags
+};
+function extractPositionalArgs(tokens, binary) {
+  const binaryName = path6.basename(binary).replace(/\.exe$/i, "");
+  const flagsWithValues = FLAGS_WITH_VALUES[binaryName] ?? /* @__PURE__ */ new Set();
+  const positional = [];
+  let skipNext = false;
+  for (const token of tokens) {
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    if (token.startsWith("--") && token.includes("=")) continue;
+    if (token.startsWith("-") && token.length === 2 && flagsWithValues.has(token)) {
+      skipNext = true;
+      continue;
+    }
+    if (token.startsWith("--") && flagsWithValues.has(token)) {
+      skipNext = true;
+      continue;
+    }
+    const shortFlag = token.slice(0, 2);
+    if (token.startsWith("-") && token.length > 2 && flagsWithValues.has(shortFlag)) continue;
+    if (token.startsWith("-")) continue;
+    if (token.startsWith("@")) continue;
+    positional.push(token);
+  }
+  return positional;
+}
+function extractNetworkTargets(tokens, binary) {
+  return extractPositionalArgs(tokens, binary).map((t) => t.includes("@") ? t.split("@")[1] : t).map((t) => {
+    const colonIdx = t.indexOf(":");
+    if (colonIdx === -1) return t;
+    const afterColon = t.slice(colonIdx + 1);
+    if (/^\d+$/.test(afterColon)) return t.slice(0, colonIdx);
+    return t;
+  }).filter(Boolean);
+}
+
+// src/policy/ssh-parser.ts
+function tokenize(cmd) {
+  const tokens = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (const ch of cmd) {
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+    } else if ((ch === " " || ch === "	") && !inSingle && !inDouble) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+function parseHost(raw) {
+  return raw.split("@").pop().split(":")[0];
+}
+function extractAllSshHosts(tokens) {
+  const hosts = /* @__PURE__ */ new Set();
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "-J" && tokens[i + 1]) {
+      for (const hop of tokens[++i].split(",")) {
+        const h = parseHost(hop);
+        if (h) hosts.add(h);
+      }
+      continue;
+    }
+    if (t === "-o" && tokens[i + 1]?.toLowerCase().startsWith("proxyjump=")) {
+      const val = tokens[++i].split("=").slice(1).join("=");
+      for (const hop of val.split(",")) {
+        const h = parseHost(hop);
+        if (h) hosts.add(h);
+      }
+      continue;
+    }
+    if (t === "-o" && tokens[i + 1]?.toLowerCase().startsWith("proxycommand=")) {
+      const raw = tokens[++i].split("=").slice(1).join("=").replace(/^['"]|['"]$/g, "");
+      const subTokens = tokenize(raw);
+      const binary = subTokens[0] ?? "";
+      extractNetworkTargets(subTokens.slice(1), binary).forEach((h) => hosts.add(h));
+      extractAllSshHosts(subTokens.slice(1)).forEach((h) => hosts.add(h));
+      continue;
+    }
+    if (!t.startsWith("-")) {
+      const h = parseHost(t);
+      if (h) hosts.add(h);
+    }
+  }
+  return [...hosts].filter(Boolean);
+}
+
 // src/policy/index.ts
-function tokenize(toolName) {
+function tokenize2(toolName) {
   return toolName.toLowerCase().split(/[_.\-\s]+/).filter(Boolean);
 }
 function matchesPattern(text, patterns) {
@@ -1045,9 +1454,9 @@ function matchesPattern(text, patterns) {
   const withoutDotSlash = text.replace(/^\.\//, "");
   return isMatch(withoutDotSlash) || isMatch(`./${withoutDotSlash}`);
 }
-function getNestedValue(obj, path10) {
+function getNestedValue(obj, path13) {
   if (!obj || typeof obj !== "object") return null;
-  return path10.split(".").reduce((prev, curr) => prev?.[curr], obj);
+  return path13.split(".").reduce((prev, curr) => prev?.[curr], obj);
 }
 function evaluateSmartConditions(args, rule) {
   if (!rule.conditions || rule.conditions.length === 0) return true;
@@ -1171,7 +1580,7 @@ async function analyzeShellCommand(command) {
   }
   return { actions, paths, allTokens };
 }
-async function evaluatePolicy(toolName, args, agent) {
+async function evaluatePolicy(toolName, args, agent, cwd) {
   const config = getConfig();
   if (matchesPattern(toolName, config.policy.ignoredTools)) return { decision: "allow" };
   if (config.policy.smartRules.length > 0) {
@@ -1201,11 +1610,55 @@ async function evaluatePolicy(toolName, args, agent) {
     if (INLINE_EXEC_PATTERN.test(shellCommand.trim())) {
       return { decision: "review", blockedByLabel: "Node9 Standard (Inline Execution)", tier: 3 };
     }
+    const pipeAnalysis = analyzePipeChain(shellCommand);
+    if (pipeAnalysis.isPipeline) {
+      if (pipeAnalysis.risk === "critical") {
+        return {
+          decision: "block",
+          blockedByLabel: "Node9: Pipe-Chain Exfiltration (critical)",
+          reason: `Sensitive file piped through obfuscator to network sink: ${pipeAnalysis.sourceFiles.join(", ")} \u2192 ${pipeAnalysis.sinkTargets.join(", ")}`,
+          tier: 3
+        };
+      }
+      if (pipeAnalysis.risk === "high") {
+        return {
+          decision: "review",
+          blockedByLabel: "Node9: Pipe-Chain Exfiltration (high)",
+          reason: `Sensitive file piped to network sink: ${pipeAnalysis.sourceFiles.join(", ")} \u2192 ${pipeAnalysis.sinkTargets.join(", ")}`,
+          tier: 3
+        };
+      }
+    }
+    const firstToken = analyzed.actions[0] ?? "";
+    if (["ssh", "scp", "rsync"].includes(firstToken)) {
+      const rawTokens = shellCommand.trim().split(/\s+/);
+      const sshHosts = extractAllSshHosts(rawTokens.slice(1));
+      allTokens.push(...sshHosts);
+    }
+    if (firstToken && path7.posix.isAbsolute(firstToken)) {
+      const prov = checkProvenance(firstToken, cwd);
+      if (prov.trustLevel === "suspect") {
+        return {
+          decision: config.settings.mode === "strict" ? "block" : "review",
+          blockedByLabel: "Node9: Suspect Binary",
+          reason: `Binary "${firstToken}" resolved to ${prov.resolvedPath} \u2014 ${prov.reason}`,
+          tier: 3
+        };
+      }
+      if (prov.trustLevel === "unknown" && config.settings.mode === "strict") {
+        return {
+          decision: "review",
+          blockedByLabel: "Node9: Unknown Binary (strict mode)",
+          reason: `Binary "${firstToken}" \u2014 ${prov.reason}`,
+          tier: 3
+        };
+      }
+    }
     if (isSqlTool(toolName, config.policy.toolInspection)) {
       allTokens = allTokens.filter((t) => !SQL_DML_KEYWORDS.has(t.toLowerCase()));
     }
   } else {
-    allTokens = tokenize(toolName);
+    allTokens = tokenize2(toolName);
     if (args && typeof args === "object") {
       const flattenedArgs = JSON.stringify(args).toLowerCase();
       const extraTokens = flattenedArgs.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 1);
@@ -1283,18 +1736,18 @@ function isIgnoredTool(toolName) {
 }
 
 // src/auth/state.ts
-import fs5 from "fs";
-import path5 from "path";
-import os4 from "os";
-var PAUSED_FILE = path5.join(os4.homedir(), ".node9", "PAUSED");
-var TRUST_FILE = path5.join(os4.homedir(), ".node9", "trust.json");
+import fs6 from "fs";
+import path8 from "path";
+import os5 from "os";
+var PAUSED_FILE = path8.join(os5.homedir(), ".node9", "PAUSED");
+var TRUST_FILE = path8.join(os5.homedir(), ".node9", "trust.json");
 function checkPause() {
   try {
-    if (!fs5.existsSync(PAUSED_FILE)) return { paused: false };
-    const state = JSON.parse(fs5.readFileSync(PAUSED_FILE, "utf-8"));
+    if (!fs6.existsSync(PAUSED_FILE)) return { paused: false };
+    const state = JSON.parse(fs6.readFileSync(PAUSED_FILE, "utf-8"));
     if (state.expiry > 0 && Date.now() >= state.expiry) {
       try {
-        fs5.unlinkSync(PAUSED_FILE);
+        fs6.unlinkSync(PAUSED_FILE);
       } catch {
       }
       return { paused: false };
@@ -1305,20 +1758,20 @@ function checkPause() {
   }
 }
 function atomicWriteSync(filePath, data, options) {
-  const dir = path5.dirname(filePath);
-  if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
-  const tmpPath = `${filePath}.${os4.hostname()}.${process.pid}.tmp`;
-  fs5.writeFileSync(tmpPath, data, options);
-  fs5.renameSync(tmpPath, filePath);
+  const dir = path8.dirname(filePath);
+  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.${os5.hostname()}.${process.pid}.tmp`;
+  fs6.writeFileSync(tmpPath, data, options);
+  fs6.renameSync(tmpPath, filePath);
 }
 function getActiveTrustSession(toolName) {
   try {
-    if (!fs5.existsSync(TRUST_FILE)) return false;
-    const trust = JSON.parse(fs5.readFileSync(TRUST_FILE, "utf-8"));
+    if (!fs6.existsSync(TRUST_FILE)) return false;
+    const trust = JSON.parse(fs6.readFileSync(TRUST_FILE, "utf-8"));
     const now = Date.now();
     const active = trust.entries.filter((e) => e.expiry > now);
     if (active.length !== trust.entries.length) {
-      fs5.writeFileSync(TRUST_FILE, JSON.stringify({ entries: active }, null, 2));
+      fs6.writeFileSync(TRUST_FILE, JSON.stringify({ entries: active }, null, 2));
     }
     return active.some((e) => e.tool === toolName || matchesPattern(toolName, e.tool));
   } catch {
@@ -1329,8 +1782,8 @@ function writeTrustSession(toolName, durationMs) {
   try {
     let trust = { entries: [] };
     try {
-      if (fs5.existsSync(TRUST_FILE)) {
-        trust = JSON.parse(fs5.readFileSync(TRUST_FILE, "utf-8"));
+      if (fs6.existsSync(TRUST_FILE)) {
+        trust = JSON.parse(fs6.readFileSync(TRUST_FILE, "utf-8"));
       }
     } catch {
     }
@@ -1346,9 +1799,9 @@ function writeTrustSession(toolName, durationMs) {
 }
 function getPersistentDecision(toolName) {
   try {
-    const file = path5.join(os4.homedir(), ".node9", "decisions.json");
-    if (!fs5.existsSync(file)) return null;
-    const decisions = JSON.parse(fs5.readFileSync(file, "utf-8"));
+    const file = path8.join(os5.homedir(), ".node9", "decisions.json");
+    if (!fs6.existsSync(file)) return null;
+    const decisions = JSON.parse(fs6.readFileSync(file, "utf-8"));
     const d = decisions[toolName];
     if (d === "allow" || d === "deny") return d;
   } catch {
@@ -1357,17 +1810,17 @@ function getPersistentDecision(toolName) {
 }
 
 // src/auth/daemon.ts
-import fs6 from "fs";
-import path6 from "path";
-import os5 from "os";
+import fs7 from "fs";
+import path9 from "path";
+import os6 from "os";
 import { spawnSync } from "child_process";
 var DAEMON_PORT = 7391;
 var DAEMON_HOST = "127.0.0.1";
 function getInternalToken() {
   try {
-    const pidFile = path6.join(os5.homedir(), ".node9", "daemon.pid");
-    if (!fs6.existsSync(pidFile)) return null;
-    const data = JSON.parse(fs6.readFileSync(pidFile, "utf-8"));
+    const pidFile = path9.join(os6.homedir(), ".node9", "daemon.pid");
+    if (!fs7.existsSync(pidFile)) return null;
+    const data = JSON.parse(fs7.readFileSync(pidFile, "utf-8"));
     process.kill(data.pid, 0);
     return data.internalToken ?? null;
   } catch {
@@ -1375,10 +1828,10 @@ function getInternalToken() {
   }
 }
 function isDaemonRunning() {
-  const pidFile = path6.join(os5.homedir(), ".node9", "daemon.pid");
-  if (fs6.existsSync(pidFile)) {
+  const pidFile = path9.join(os6.homedir(), ".node9", "daemon.pid");
+  if (fs7.existsSync(pidFile)) {
     try {
-      const { pid, port } = JSON.parse(fs6.readFileSync(pidFile, "utf-8"));
+      const { pid, port } = JSON.parse(fs7.readFileSync(pidFile, "utf-8"));
       if (port !== DAEMON_PORT) return false;
       process.kill(pid, 0);
       return true;
@@ -1474,16 +1927,16 @@ async function resolveViaDaemon(id, decision, internalToken) {
 
 // src/auth/orchestrator.ts
 import net from "net";
-import path9 from "path";
-import os7 from "os";
+import path12 from "path";
+import os8 from "os";
 import { randomUUID } from "crypto";
 
 // src/ui/native.ts
 import { spawn } from "child_process";
-import path8 from "path";
+import path11 from "path";
 
 // src/context-sniper.ts
-import path7 from "path";
+import path10 from "path";
 function smartTruncate(str, maxLen = 500) {
   if (str.length <= maxLen) return str;
   const edge = Math.floor(maxLen / 2) - 3;
@@ -1551,7 +2004,7 @@ function computeRiskMetadata(args, tier, blockedByLabel, matchedField, matchedWo
       intent = "EDIT";
       if (obj.file_path) {
         editFilePath = String(obj.file_path);
-        editFileName = path7.basename(editFilePath);
+        editFileName = path10.basename(editFilePath);
       }
       const result = extractContext(String(obj.new_string), matchedWord);
       contextSnippet = result.snippet;
@@ -1606,7 +2059,7 @@ function formatArgs(args, matchedField, matchedWord) {
   if (typeof parsed === "object" && !Array.isArray(parsed)) {
     const obj = parsed;
     if (obj.old_string !== void 0 && obj.new_string !== void 0) {
-      const file = obj.file_path ? path8.basename(String(obj.file_path)) : "file";
+      const file = obj.file_path ? path11.basename(String(obj.file_path)) : "file";
       const oldPreview = smartTruncate(String(obj.old_string), 120);
       const newPreview = extractContext(String(obj.new_string), matchedWord).snippet;
       return {
@@ -1781,8 +2234,8 @@ end run`;
 }
 
 // src/auth/cloud.ts
-import fs7 from "fs";
-import os6 from "os";
+import fs8 from "fs";
+import os7 from "os";
 function auditLocalAllow(toolName, args, checkedBy, creds, meta) {
   return fetch(`${creds.apiUrl}/audit`, {
     method: "POST",
@@ -1794,9 +2247,9 @@ function auditLocalAllow(toolName, args, checkedBy, creds, meta) {
       context: {
         agent: meta?.agent,
         mcpServer: meta?.mcpServer,
-        hostname: os6.hostname(),
+        hostname: os7.hostname(),
         cwd: process.cwd(),
-        platform: os6.platform()
+        platform: os7.platform()
       }
     }),
     signal: AbortSignal.timeout(5e3)
@@ -1817,9 +2270,9 @@ async function initNode9SaaS(toolName, args, creds, meta, riskMetadata) {
         context: {
           agent: meta?.agent,
           mcpServer: meta?.mcpServer,
-          hostname: os6.hostname(),
+          hostname: os7.hostname(),
           cwd: process.cwd(),
-          platform: os6.platform()
+          platform: os7.platform()
         },
         ...riskMetadata && { riskMetadata }
       }),
@@ -1875,14 +2328,14 @@ async function resolveNode9SaaS(requestId, creds, approved, decidedBy) {
     });
     clearTimeout(timer);
     if (!res.ok) {
-      fs7.appendFileSync(
+      fs8.appendFileSync(
         HOOK_DEBUG_LOG,
         `[resolve-cloud] PATCH ${resolveUrl} \u2192 HTTP ${res.status}
 `
       );
     }
   } catch (err) {
-    fs7.appendFileSync(
+    fs8.appendFileSync(
       HOOK_DEBUG_LOG,
       `[resolve-cloud] PATCH failed for ${requestId}: ${err.message}
 `
@@ -1891,7 +2344,7 @@ async function resolveNode9SaaS(requestId, creds, approved, decidedBy) {
 }
 
 // src/auth/orchestrator.ts
-var ACTIVITY_SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path9.join(os7.tmpdir(), "node9-activity.sock");
+var ACTIVITY_SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path12.join(os8.tmpdir(), "node9-activity.sock");
 function notifyActivity(data) {
   return new Promise((resolve) => {
     try {
@@ -1973,7 +2426,7 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
   }
   if (config.settings.mode === "audit") {
     if (!isIgnoredTool(toolName)) {
-      const policyResult = await evaluatePolicy(toolName, args, meta?.agent);
+      const policyResult = await evaluatePolicy(toolName, args, meta?.agent, options?.cwd);
       if (policyResult.decision === "review") {
         appendLocalAudit(toolName, args, "allow", "audit-mode", meta);
         if (approvers.cloud && creds?.apiKey) {