@node9/proxy 0.2.1

package/dist/cli.js

@@ -0,0 +1,2754 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// src/core.ts
+var import_chalk = __toESM(require("chalk"));
+var import_prompts = require("@inquirer/prompts");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_picomatch = __toESM(require("picomatch"));
+var import_sh_syntax = require("sh-syntax");
+var DANGEROUS_WORDS = [
+  "delete",
+  "drop",
+  "remove",
+  "terminate",
+  "refund",
+  "write",
+  "update",
+  "destroy",
+  "rm",
+  "rmdir",
+  "purge",
+  "format"
+];
+function tokenize(toolName) {
+  return toolName.toLowerCase().split(/[_.\-\s]+/).filter(Boolean);
+}
+function containsDangerousWord(toolName, dangerousWords) {
+  const tokens = tokenize(toolName);
+  return dangerousWords.some((word) => tokens.includes(word.toLowerCase()));
+}
+function matchesPattern(text, patterns) {
+  const p = Array.isArray(patterns) ? patterns : [patterns];
+  if (p.length === 0) return false;
+  const isMatch = (0, import_picomatch.default)(p, { nocase: true, dot: true });
+  const target = text.toLowerCase();
+  const directMatch = isMatch(target);
+  if (directMatch) return true;
+  const withoutDotSlash = text.replace(/^\.\//, "");
+  return isMatch(withoutDotSlash) || isMatch(`./${withoutDotSlash}`);
+}
+function getNestedValue(obj, path5) {
+  if (!obj || typeof obj !== "object") return null;
+  return path5.split(".").reduce((prev, curr) => prev?.[curr], obj);
+}
+function extractShellCommand(toolName, args, toolInspection) {
+  const patterns = Object.keys(toolInspection);
+  const matchingPattern = patterns.find((p) => matchesPattern(toolName, p));
+  if (!matchingPattern) return null;
+  const fieldPath = toolInspection[matchingPattern];
+  const value = getNestedValue(args, fieldPath);
+  return typeof value === "string" ? value : null;
+}
+async function analyzeShellCommand(command) {
+  const actions = [];
+  const paths = [];
+  const allTokens = [];
+  const addToken = (token) => {
+    const lower = token.toLowerCase();
+    allTokens.push(lower);
+    if (lower.includes("/")) {
+      const segments = lower.split("/").filter(Boolean);
+      allTokens.push(...segments);
+    }
+    if (lower.startsWith("-")) {
+      allTokens.push(lower.replace(/^-+/, ""));
+    }
+  };
+  try {
+    const ast = await (0, import_sh_syntax.parse)(command);
+    const walk = (node) => {
+      if (!node) return;
+      if (node.type === "CallExpr") {
+        const parts = (node.Args || []).map((arg) => {
+          return (arg.Parts || []).map((p) => p.Value || "").join("");
+        }).filter((s) => s.length > 0);
+        if (parts.length > 0) {
+          actions.push(parts[0].toLowerCase());
+          parts.forEach((p) => addToken(p));
+          parts.slice(1).forEach((p) => {
+            if (!p.startsWith("-")) paths.push(p);
+          });
+        }
+      }
+      for (const key in node) {
+        if (key === "Parent") continue;
+        const val = node[key];
+        if (Array.isArray(val)) {
+          val.forEach((child) => {
+            if (child && typeof child === "object" && "type" in child) {
+              walk(child);
+            }
+          });
+        } else if (val && typeof val === "object" && "type" in val) {
+          walk(val);
+        }
+      }
+    };
+    walk(ast);
+  } catch {
+  }
+  if (allTokens.length === 0) {
+    const normalized = command.replace(/\\(.)/g, "$1");
+    const sanitized = normalized.replace(/["'<>]/g, " ");
+    const segments = sanitized.split(/[|;&]|\$\(|\)|`/);
+    segments.forEach((segment) => {
+      const tokens = segment.trim().split(/\s+/).filter(Boolean);
+      if (tokens.length > 0) {
+        const action = tokens[0].toLowerCase();
+        if (!actions.includes(action)) actions.push(action);
+        tokens.forEach((t) => {
+          addToken(t);
+          if (t !== tokens[0] && !t.startsWith("-")) {
+            if (!paths.includes(t)) paths.push(t);
+          }
+        });
+      }
+    });
+  }
+  return { actions, paths, allTokens };
+}
+function redactSecrets(text) {
+  if (!text) return text;
+  let redacted = text;
+  redacted = redacted.replace(
+    /(authorization:\s*(?:bearer|basic)\s+)[a-zA-Z0-9._\-\/\\=]+/gi,
+    "$1********"
+  );
+  redacted = redacted.replace(
+    /(api[_-]?key|secret|password|token)([:=]\s*['"]?)[a-zA-Z0-9._\-]{8,}/gi,
+    "$1$2********"
+  );
+  return redacted;
+}
+var DEFAULT_CONFIG = {
+  settings: { mode: "standard" },
+  policy: {
+    dangerousWords: DANGEROUS_WORDS,
+    ignoredTools: [
+      "list_*",
+      "get_*",
+      "read_*",
+      "describe_*",
+      "read",
+      "write",
+      "edit",
+      "multiedit",
+      "glob",
+      "grep",
+      "ls",
+      "notebookread",
+      "notebookedit",
+      "todoread",
+      "todowrite",
+      "webfetch",
+      "websearch",
+      "exitplanmode",
+      "askuserquestion"
+    ],
+    toolInspection: {
+      bash: "command",
+      run_shell_command: "command",
+      shell: "command",
+      "terminal.execute": "command"
+    },
+    rules: [
+      { action: "rm", allowPaths: ["**/node_modules/**", "dist/**", "build/**", ".DS_Store"] }
+    ]
+  },
+  environments: {}
+};
+var cachedConfig = null;
+function getGlobalSettings() {
+  try {
+    const globalConfigPath = import_path.default.join(import_os.default.homedir(), ".node9", "config.json");
+    if (import_fs.default.existsSync(globalConfigPath)) {
+      const parsed = JSON.parse(import_fs.default.readFileSync(globalConfigPath, "utf-8"));
+      const settings = parsed.settings || {};
+      return {
+        mode: settings.mode || "standard",
+        autoStartDaemon: settings.autoStartDaemon !== false,
+        slackEnabled: settings.slackEnabled !== false,
+        // agentMode defaults to false — user must explicitly opt in via `node9 login`
+        agentMode: settings.agentMode === true
+      };
+    }
+  } catch {
+  }
+  return { mode: "standard", autoStartDaemon: true, slackEnabled: true, agentMode: false };
+}
+function hasSlack() {
+  const creds = getCredentials();
+  if (!creds?.apiKey) return false;
+  return getGlobalSettings().slackEnabled;
+}
+function getInternalToken() {
+  try {
+    const pidFile = import_path.default.join(import_os.default.homedir(), ".node9", "daemon.pid");
+    if (!import_fs.default.existsSync(pidFile)) return null;
+    const data = JSON.parse(import_fs.default.readFileSync(pidFile, "utf-8"));
+    process.kill(data.pid, 0);
+    return data.internalToken ?? null;
+  } catch {
+    return null;
+  }
+}
+async function evaluatePolicy(toolName, args) {
+  const config = getConfig();
+  if (matchesPattern(toolName, config.policy.ignoredTools)) return "allow";
+  const shellCommand = extractShellCommand(toolName, args, config.policy.toolInspection);
+  if (shellCommand) {
+    const { actions, paths, allTokens } = await analyzeShellCommand(shellCommand);
+    const INLINE_EXEC_PATTERN = /^(python3?|bash|sh|zsh|perl|ruby|node|php|lua)\s+(-c|-e|-eval)\s/i;
+    if (INLINE_EXEC_PATTERN.test(shellCommand.trim())) return "review";
+    for (const action of actions) {
+      const basename = action.includes("/") ? action.split("/").pop() : action;
+      const rule = config.policy.rules.find(
+        (r) => r.action === action || matchesPattern(action, r.action) || basename && (r.action === basename || matchesPattern(basename, r.action))
+      );
+      if (rule) {
+        if (paths.length > 0) {
+          const anyBlocked = paths.some((p) => matchesPattern(p, rule.blockPaths || []));
+          if (anyBlocked) return "review";
+          const allAllowed = paths.every((p) => matchesPattern(p, rule.allowPaths || []));
+          if (allAllowed) return "allow";
+        }
+        return "review";
+      }
+    }
+    const isDangerous2 = allTokens.some(
+      (token) => config.policy.dangerousWords.some((word) => {
+        const w = word.toLowerCase();
+        if (token === w) return true;
+        try {
+          return new RegExp(`\\b${w}\\b`, "i").test(token);
+        } catch {
+          return false;
+        }
+      })
+    );
+    if (isDangerous2) return "review";
+    if (config.settings.mode === "strict") return "review";
+    return "allow";
+  }
+  const isDangerous = containsDangerousWord(toolName, config.policy.dangerousWords);
+  if (isDangerous || config.settings.mode === "strict") {
+    const envConfig = getActiveEnvironment(config);
+    if (envConfig?.requireApproval === false) return "allow";
+    return "review";
+  }
+  return "allow";
+}
+function isIgnoredTool(toolName) {
+  const config = getConfig();
+  return matchesPattern(toolName, config.policy.ignoredTools);
+}
+var DAEMON_PORT = 7391;
+var DAEMON_HOST = "127.0.0.1";
+function isDaemonRunning() {
+  try {
+    const pidFile = import_path.default.join(import_os.default.homedir(), ".node9", "daemon.pid");
+    if (!import_fs.default.existsSync(pidFile)) return false;
+    const { pid, port } = JSON.parse(import_fs.default.readFileSync(pidFile, "utf-8"));
+    if (port !== DAEMON_PORT) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getPersistentDecision(toolName) {
+  try {
+    const file = import_path.default.join(import_os.default.homedir(), ".node9", "decisions.json");
+    if (!import_fs.default.existsSync(file)) return null;
+    const decisions = JSON.parse(import_fs.default.readFileSync(file, "utf-8"));
+    const d = decisions[toolName];
+    if (d === "allow" || d === "deny") return d;
+  } catch {
+  }
+  return null;
+}
+async function askDaemon(toolName, args, meta) {
+  const base = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
+  const checkRes = await fetch(`${base}/check`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ toolName, args, agent: meta?.agent, mcpServer: meta?.mcpServer }),
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!checkRes.ok) throw new Error("Daemon fail");
+  const { id } = await checkRes.json();
+  const waitRes = await fetch(`${base}/wait/${id}`, { signal: AbortSignal.timeout(12e4) });
+  if (!waitRes.ok) return "deny";
+  const { decision } = await waitRes.json();
+  if (decision === "allow") return "allow";
+  if (decision === "abandoned") return "abandoned";
+  return "deny";
+}
+async function notifyDaemonViewer(toolName, args, meta) {
+  const base = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
+  const res = await fetch(`${base}/check`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      toolName,
+      args,
+      slackDelegated: true,
+      agent: meta?.agent,
+      mcpServer: meta?.mcpServer
+    }),
+    signal: AbortSignal.timeout(3e3)
+  });
+  if (!res.ok) throw new Error("Daemon unreachable");
+  const { id } = await res.json();
+  return id;
+}
+async function resolveViaDaemon(id, decision, internalToken) {
+  const base = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
+  await fetch(`${base}/resolve/${id}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-Node9-Internal": internalToken },
+    body: JSON.stringify({ decision }),
+    signal: AbortSignal.timeout(3e3)
+  });
+}
+async function authorizeHeadless(toolName, args, allowTerminalFallback = false, meta) {
+  const { agentMode } = getGlobalSettings();
+  const cloudEnforced = agentMode && hasSlack();
+  if (!cloudEnforced) {
+    if (isIgnoredTool(toolName)) return { approved: true };
+    const policyDecision = await evaluatePolicy(toolName, args);
+    if (policyDecision === "allow") return { approved: true, checkedBy: "local-policy" };
+    const persistent = getPersistentDecision(toolName);
+    if (persistent === "allow") return { approved: true, checkedBy: "persistent" };
+    if (persistent === "deny")
+      return {
+        approved: false,
+        reason: `Node9: "${toolName}" is set to always deny.`,
+        blockedBy: "persistent-deny",
+        changeHint: `Open the daemon UI to manage decisions:  node9 daemon --openui`
+      };
+  }
+  if (cloudEnforced) {
+    const creds = getCredentials();
+    const envConfig = getActiveEnvironment(getConfig());
+    let viewerId = null;
+    const internalToken = getInternalToken();
+    if (isDaemonRunning() && internalToken) {
+      viewerId = await notifyDaemonViewer(toolName, args, meta).catch(() => null);
+    }
+    const approved = await callNode9SaaS(toolName, args, creds, envConfig?.slackChannel, meta);
+    if (viewerId && internalToken) {
+      resolveViaDaemon(viewerId, approved ? "allow" : "deny", internalToken).catch(() => null);
+    }
+    return {
+      approved,
+      checkedBy: approved ? "cloud" : void 0,
+      blockedBy: approved ? void 0 : "team-policy",
+      changeHint: approved ? void 0 : `Visit your Node9 dashboard \u2192 Policy Studio to change this rule`
+    };
+  }
+  if (isDaemonRunning()) {
+    console.error(import_chalk.default.yellow("\n\u{1F6E1}\uFE0F  Node9: Action suspended \u2014 waiting for your approval."));
+    console.error(import_chalk.default.cyan(`   Browser UI \u2192 http://${DAEMON_HOST}:${DAEMON_PORT}/
+`));
+    try {
+      const daemonDecision = await askDaemon(toolName, args, meta);
+      if (daemonDecision === "abandoned") {
+        console.error(import_chalk.default.yellow("\n\u26A0\uFE0F  Browser closed without a decision. Falling back..."));
+      } else {
+        return {
+          approved: daemonDecision === "allow",
+          reason: daemonDecision === "deny" ? `Node9 blocked "${toolName}" \u2014 denied in browser.` : void 0,
+          checkedBy: daemonDecision === "allow" ? "daemon" : void 0,
+          blockedBy: daemonDecision === "deny" ? "local-decision" : void 0,
+          changeHint: daemonDecision === "deny" ? `Open the daemon UI to change:  node9 daemon --openui` : void 0
+        };
+      }
+    } catch {
+    }
+  }
+  if (allowTerminalFallback && process.stdout.isTTY) {
+    console.log(import_chalk.default.bgRed.white.bold(` \u{1F6D1} NODE9 INTERCEPTOR `));
+    console.log(`${import_chalk.default.bold("Action:")} ${import_chalk.default.red(toolName)}`);
+    const argsPreview = JSON.stringify(args, null, 2);
+    console.log(
+      `${import_chalk.default.bold("Args:")}
+${import_chalk.default.gray(argsPreview.length > 500 ? argsPreview.slice(0, 500) + "..." : argsPreview)}`
+    );
+    const controller = new AbortController();
+    const TIMEOUT_MS = 3e4;
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+      const approved = await (0, import_prompts.confirm)(
+        { message: `Authorize? (auto-deny in ${TIMEOUT_MS / 1e3}s)`, default: false },
+        { signal: controller.signal }
+      );
+      clearTimeout(timer);
+      return { approved };
+    } catch {
+      clearTimeout(timer);
+      console.error(import_chalk.default.yellow("\n\u23F1  Prompt timed out \u2014 action denied by default."));
+      return { approved: false };
+    }
+  }
+  return {
+    approved: false,
+    noApprovalMechanism: true,
+    reason: `Node9 blocked "${toolName}". No approval mechanism is active.`,
+    blockedBy: "no-approval-mechanism",
+    changeHint: `Start the approval daemon:  node9 daemon --background
+   Or connect to your team:   node9 login <apiKey>`
+  };
+}
+function listCredentialProfiles() {
+  try {
+    const credPath = import_path.default.join(import_os.default.homedir(), ".node9", "credentials.json");
+    if (!import_fs.default.existsSync(credPath)) return [];
+    const creds = JSON.parse(import_fs.default.readFileSync(credPath, "utf-8"));
+    if (!creds.apiKey) return Object.keys(creds).filter((k) => typeof creds[k] === "object");
+  } catch {
+  }
+  return [];
+}
+function getConfig() {
+  if (cachedConfig) return cachedConfig;
+  const projectConfig = tryLoadConfig(import_path.default.join(process.cwd(), "node9.config.json"));
+  if (projectConfig) {
+    cachedConfig = buildConfig(projectConfig);
+    return cachedConfig;
+  }
+  const globalConfig = tryLoadConfig(import_path.default.join(import_os.default.homedir(), ".node9", "config.json"));
+  if (globalConfig) {
+    cachedConfig = buildConfig(globalConfig);
+    return cachedConfig;
+  }
+  cachedConfig = DEFAULT_CONFIG;
+  return cachedConfig;
+}
+function tryLoadConfig(filePath) {
+  if (!import_fs.default.existsSync(filePath)) return null;
+  try {
+    const config = JSON.parse(import_fs.default.readFileSync(filePath, "utf-8"));
+    validateConfig(config, filePath);
+    return config;
+  } catch {
+    return null;
+  }
+}
+function validateConfig(config, path5) {
+  const allowedTopLevel = ["version", "settings", "policy", "environments", "apiKey", "apiUrl"];
+  Object.keys(config).forEach((key) => {
+    if (!allowedTopLevel.includes(key))
+      console.warn(import_chalk.default.yellow(`\u26A0\uFE0F  Node9: Unknown top-level key "${key}" in ${path5}`));
+  });
+}
+function buildConfig(parsed) {
+  const p = parsed.policy || {};
+  const s = parsed.settings || {};
+  return {
+    settings: {
+      mode: s.mode ?? DEFAULT_CONFIG.settings.mode,
+      autoStartDaemon: s.autoStartDaemon ?? DEFAULT_CONFIG.settings.autoStartDaemon
+    },
+    policy: {
+      dangerousWords: p.dangerousWords ?? DEFAULT_CONFIG.policy.dangerousWords,
+      ignoredTools: p.ignoredTools ?? DEFAULT_CONFIG.policy.ignoredTools,
+      toolInspection: p.toolInspection ?? DEFAULT_CONFIG.policy.toolInspection,
+      rules: p.rules ?? DEFAULT_CONFIG.policy.rules
+    },
+    environments: parsed.environments || {}
+  };
+}
+function getActiveEnvironment(config) {
+  const env = process.env.NODE_ENV || "development";
+  return config.environments[env] ?? null;
+}
+function getCredentials() {
+  const DEFAULT_API_URL = "https://api.node9.ai/api/v1/intercept";
+  if (process.env.NODE9_API_KEY)
+    return {
+      apiKey: process.env.NODE9_API_KEY,
+      apiUrl: process.env.NODE9_API_URL || DEFAULT_API_URL
+    };
+  try {
+    const projectConfigPath = import_path.default.join(process.cwd(), "node9.config.json");
+    if (import_fs.default.existsSync(projectConfigPath)) {
+      const projectConfig = JSON.parse(import_fs.default.readFileSync(projectConfigPath, "utf-8"));
+      if (typeof projectConfig.apiKey === "string" && projectConfig.apiKey) {
+        return {
+          apiKey: projectConfig.apiKey,
+          apiUrl: typeof projectConfig.apiUrl === "string" && projectConfig.apiUrl || DEFAULT_API_URL
+        };
+      }
+    }
+  } catch {
+  }
+  try {
+    const credPath = import_path.default.join(import_os.default.homedir(), ".node9", "credentials.json");
+    if (import_fs.default.existsSync(credPath)) {
+      const creds = JSON.parse(import_fs.default.readFileSync(credPath, "utf-8"));
+      const profileName = process.env.NODE9_PROFILE || "default";
+      const profile = creds[profileName];
+      if (profile?.apiKey) {
+        return {
+          apiKey: profile.apiKey,
+          apiUrl: profile.apiUrl || DEFAULT_API_URL
+        };
+      }
+      if (creds.apiKey) {
+        return {
+          apiKey: creds.apiKey,
+          apiUrl: creds.apiUrl || DEFAULT_API_URL
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function authorizeAction(toolName, args) {
+  const result = await authorizeHeadless(toolName, args, true);
+  return result.approved;
+}
+async function callNode9SaaS(toolName, args, creds, slackChannel, meta) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 35e3);
+    const response = await fetch(creds.apiUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${creds.apiKey}` },
+      body: JSON.stringify({
+        toolName,
+        args,
+        slackChannel,
+        context: {
+          agent: meta?.agent,
+          mcpServer: meta?.mcpServer,
+          hostname: import_os.default.hostname(),
+          cwd: process.cwd(),
+          platform: import_os.default.platform()
+        }
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) throw new Error("API fail");
+    const data = await response.json();
+    if (!data.pending) return data.approved;
+    if (!data.requestId) return false;
+    const statusUrl = `${creds.apiUrl}/status/${data.requestId}`;
+    console.error(import_chalk.default.yellow("\n\u{1F6E1}\uFE0F  Node9: Action suspended \u2014 waiting for your approval."));
+    if (isDaemonRunning()) {
+      console.error(
+        import_chalk.default.cyan("   Browser UI \u2192 ") + import_chalk.default.bold(`http://${DAEMON_HOST}:${DAEMON_PORT}/`)
+      );
+    }
+    console.error(import_chalk.default.cyan("   Dashboard  \u2192 ") + import_chalk.default.bold("Mission Control > Flows"));
+    console.error(import_chalk.default.gray("   Agent is paused. Approve or deny to continue.\n"));
+    const POLL_INTERVAL_MS = 3e3;
+    const POLL_DEADLINE = Date.now() + 5 * 60 * 1e3;
+    while (Date.now() < POLL_DEADLINE) {
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+      try {
+        const statusRes = await fetch(statusUrl, {
+          headers: { Authorization: `Bearer ${creds.apiKey}` },
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (!statusRes.ok) continue;
+        const { status } = await statusRes.json();
+        if (status === "APPROVED") {
+          console.error(import_chalk.default.green("\u2705  Approved \u2014 continuing.\n"));
+          return true;
+        }
+        if (status === "DENIED" || status === "AUTO_BLOCKED" || status === "TIMED_OUT") {
+          console.error(import_chalk.default.red("\u274C  Denied \u2014 action blocked.\n"));
+          return false;
+        }
+      } catch {
+      }
+    }
+    console.error(import_chalk.default.yellow("\u23F1  Timed out waiting for approval \u2014 action blocked.\n"));
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/setup.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_prompts2 = require("@inquirer/prompts");
+function printDaemonTip() {
+  console.log(
+    import_chalk2.default.cyan("\n   \u{1F4A1} Enable browser approvals (no API key needed):") + import_chalk2.default.green("  node9 daemon --background")
+  );
+}
+function fullPathCommand(subcommand) {
+  if (process.env.NODE9_TESTING === "1") return `node9 ${subcommand}`;
+  const nodeExec = process.execPath;
+  const cliScript = process.argv[1];
+  return `${nodeExec} ${cliScript} ${subcommand}`;
+}
+function readJson(filePath) {
+  try {
+    if (import_fs2.default.existsSync(filePath)) {
+      return JSON.parse(import_fs2.default.readFileSync(filePath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function writeJson(filePath, data) {
+  const dir = import_path2.default.dirname(filePath);
+  if (!import_fs2.default.existsSync(dir)) import_fs2.default.mkdirSync(dir, { recursive: true });
+  import_fs2.default.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+async function setupClaude() {
+  const homeDir2 = import_os2.default.homedir();
+  const mcpPath = import_path2.default.join(homeDir2, ".claude.json");
+  const hooksPath = import_path2.default.join(homeDir2, ".claude", "settings.json");
+  const claudeConfig = readJson(mcpPath) ?? {};
+  const settings = readJson(hooksPath) ?? {};
+  const servers = claudeConfig.mcpServers ?? {};
+  let anythingChanged = false;
+  if (!settings.hooks) settings.hooks = {};
+  const hasPreHook = settings.hooks.PreToolUse?.some(
+    (m) => m.hooks.some((h) => h.command?.includes("node9 check") || h.command?.includes("cli.js check"))
+  );
+  if (!hasPreHook) {
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+    settings.hooks.PreToolUse.push({
+      matcher: ".*",
+      hooks: [{ type: "command", command: fullPathCommand("check"), timeout: 60 }]
+    });
+    console.log(import_chalk2.default.green("  \u2705 PreToolUse hook added  \u2192 node9 check"));
+    anythingChanged = true;
+  }
+  const hasPostHook = settings.hooks.PostToolUse?.some(
+    (m) => m.hooks.some((h) => h.command?.includes("node9 log") || h.command?.includes("cli.js log"))
+  );
+  if (!hasPostHook) {
+    if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+    settings.hooks.PostToolUse.push({
+      matcher: ".*",
+      hooks: [{ type: "command", command: fullPathCommand("log") }]
+    });
+    console.log(import_chalk2.default.green("  \u2705 PostToolUse hook added \u2192 node9 log"));
+    anythingChanged = true;
+  }
+  if (anythingChanged) {
+    writeJson(hooksPath, settings);
+    console.log("");
+  }
+  const serversToWrap = [];
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server.command || server.command === "node9") continue;
+    const parts = [server.command, ...server.args ?? []];
+    serversToWrap.push({ name, originalCmd: parts.join(" "), parts });
+  }
+  if (serversToWrap.length > 0) {
+    console.log(import_chalk2.default.bold("The following existing entries will be modified:\n"));
+    console.log(import_chalk2.default.white(`  ${mcpPath}`));
+    for (const { name, originalCmd } of serversToWrap) {
+      console.log(import_chalk2.default.gray(`    \u2022 ${name}: "${originalCmd}" \u2192 node9 ${originalCmd}`));
+    }
+    console.log("");
+    const proceed = await (0, import_prompts2.confirm)({ message: "Wrap these MCP servers?", default: true });
+    if (proceed) {
+      for (const { name, parts } of serversToWrap) {
+        servers[name] = { ...servers[name], command: "node9", args: parts };
+      }
+      claudeConfig.mcpServers = servers;
+      writeJson(mcpPath, claudeConfig);
+      console.log(import_chalk2.default.green(`
+  \u2705 ${serversToWrap.length} MCP server(s) wrapped`));
+      anythingChanged = true;
+    } else {
+      console.log(import_chalk2.default.yellow("  Skipped MCP server wrapping."));
+    }
+    console.log("");
+  }
+  if (!anythingChanged && serversToWrap.length === 0) {
+    console.log(import_chalk2.default.blue("\u2139\uFE0F  Node9 is already fully configured for Claude Code."));
+    printDaemonTip();
+    return;
+  }
+  if (anythingChanged) {
+    console.log(import_chalk2.default.green.bold("\u{1F6E1}\uFE0F  Node9 is now protecting Claude Code!"));
+    console.log(import_chalk2.default.gray("    Restart Claude Code for changes to take effect."));
+    printDaemonTip();
+  }
+}
+async function setupGemini() {
+  const homeDir2 = import_os2.default.homedir();
+  const settingsPath = import_path2.default.join(homeDir2, ".gemini", "settings.json");
+  const settings = readJson(settingsPath) ?? {};
+  const servers = settings.mcpServers ?? {};
+  let anythingChanged = false;
+  if (!settings.hooks) settings.hooks = {};
+  const hasBeforeHook = Array.isArray(settings.hooks.BeforeTool) && settings.hooks.BeforeTool.some(
+    (m) => m.hooks.some((h) => h.command?.includes("node9 check") || h.command?.includes("cli.js check"))
+  );
+  if (!hasBeforeHook) {
+    if (!settings.hooks.BeforeTool) settings.hooks.BeforeTool = [];
+    if (!Array.isArray(settings.hooks.BeforeTool)) settings.hooks.BeforeTool = [];
+    settings.hooks.BeforeTool.push({
+      matcher: ".*",
+      hooks: [
+        { name: "node9-check", type: "command", command: fullPathCommand("check"), timeout: 6e4 }
+      ]
+    });
+    console.log(import_chalk2.default.green("  \u2705 BeforeTool hook added \u2192 node9 check"));
+    anythingChanged = true;
+  }
+  const hasAfterHook = Array.isArray(settings.hooks.AfterTool) && settings.hooks.AfterTool.some(
+    (m) => m.hooks.some((h) => h.command?.includes("node9 log") || h.command?.includes("cli.js log"))
+  );
+  if (!hasAfterHook) {
+    if (!settings.hooks.AfterTool) settings.hooks.AfterTool = [];
+    if (!Array.isArray(settings.hooks.AfterTool)) settings.hooks.AfterTool = [];
+    settings.hooks.AfterTool.push({
+      matcher: ".*",
+      hooks: [{ name: "node9-log", type: "command", command: fullPathCommand("log") }]
+    });
+    console.log(import_chalk2.default.green("  \u2705 AfterTool hook added  \u2192 node9 log"));
+    anythingChanged = true;
+  }
+  if (anythingChanged) {
+    writeJson(settingsPath, settings);
+    console.log("");
+  }
+  const serversToWrap = [];
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server.command || server.command === "node9") continue;
+    const parts = [server.command, ...server.args ?? []];
+    serversToWrap.push({ name, originalCmd: parts.join(" "), parts });
+  }
+  if (serversToWrap.length > 0) {
+    console.log(import_chalk2.default.bold("The following existing entries will be modified:\n"));
+    console.log(import_chalk2.default.white(`  ${settingsPath}  (mcpServers)`));
+    for (const { name, originalCmd } of serversToWrap) {
+      console.log(import_chalk2.default.gray(`    \u2022 ${name}: "${originalCmd}" \u2192 node9 ${originalCmd}`));
+    }
+    console.log("");
+    const proceed = await (0, import_prompts2.confirm)({ message: "Wrap these MCP servers?", default: true });
+    if (proceed) {
+      for (const { name, parts } of serversToWrap) {
+        servers[name] = { ...servers[name], command: "node9", args: parts };
+      }
+      settings.mcpServers = servers;
+      writeJson(settingsPath, settings);
+      console.log(import_chalk2.default.green(`
+  \u2705 ${serversToWrap.length} MCP server(s) wrapped`));
+      anythingChanged = true;
+    } else {
+      console.log(import_chalk2.default.yellow("  Skipped MCP server wrapping."));
+    }
+    console.log("");
+  }
+  if (!anythingChanged && serversToWrap.length === 0) {
+    console.log(import_chalk2.default.blue("\u2139\uFE0F  Node9 is already fully configured for Gemini CLI."));
+    printDaemonTip();
+    return;
+  }
+  if (anythingChanged) {
+    console.log(import_chalk2.default.green.bold("\u{1F6E1}\uFE0F  Node9 is now protecting Gemini CLI!"));
+    console.log(import_chalk2.default.gray("    Restart Gemini CLI for changes to take effect."));
+    printDaemonTip();
+  }
+}
+async function setupCursor() {
+  const homeDir2 = import_os2.default.homedir();
+  const mcpPath = import_path2.default.join(homeDir2, ".cursor", "mcp.json");
+  const hooksPath = import_path2.default.join(homeDir2, ".cursor", "hooks.json");
+  const mcpConfig = readJson(mcpPath) ?? {};
+  const hooksFile = readJson(hooksPath) ?? { version: 1 };
+  const servers = mcpConfig.mcpServers ?? {};
+  let anythingChanged = false;
+  if (!hooksFile.hooks) hooksFile.hooks = {};
+  const hasPreHook = hooksFile.hooks.preToolUse?.some(
+    (h) => h.command === "node9" && h.args?.includes("check") || h.command?.includes("cli.js")
+  );
+  if (!hasPreHook) {
+    if (!hooksFile.hooks.preToolUse) hooksFile.hooks.preToolUse = [];
+    hooksFile.hooks.preToolUse.push({ command: fullPathCommand("check") });
+    console.log(import_chalk2.default.green("  \u2705 preToolUse hook added \u2192 node9 check"));
+    anythingChanged = true;
+  }
+  const hasPostHook = hooksFile.hooks.postToolUse?.some(
+    (h) => h.command === "node9" && h.args?.includes("log") || h.command?.includes("cli.js")
+  );
+  if (!hasPostHook) {
+    if (!hooksFile.hooks.postToolUse) hooksFile.hooks.postToolUse = [];
+    hooksFile.hooks.postToolUse.push({ command: fullPathCommand("log") });
+    console.log(import_chalk2.default.green("  \u2705 postToolUse hook added \u2192 node9 log"));
+    anythingChanged = true;
+  }
+  if (anythingChanged) {
+    writeJson(hooksPath, hooksFile);
+    console.log("");
+  }
+  const serversToWrap = [];
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server.command || server.command === "node9") continue;
+    const parts = [server.command, ...server.args ?? []];
+    serversToWrap.push({ name, originalCmd: parts.join(" "), parts });
+  }
+  if (serversToWrap.length > 0) {
+    console.log(import_chalk2.default.bold("The following existing entries will be modified:\n"));
+    console.log(import_chalk2.default.white(`  ${mcpPath}`));
+    for (const { name, originalCmd } of serversToWrap) {
+      console.log(import_chalk2.default.gray(`    \u2022 ${name}: "${originalCmd}" \u2192 node9 ${originalCmd}`));
+    }
+    console.log("");
+    const proceed = await (0, import_prompts2.confirm)({ message: "Wrap these MCP servers?", default: true });
+    if (proceed) {
+      for (const { name, parts } of serversToWrap) {
+        servers[name] = { ...servers[name], command: "node9", args: parts };
+      }
+      mcpConfig.mcpServers = servers;
+      writeJson(mcpPath, mcpConfig);
+      console.log(import_chalk2.default.green(`
+  \u2705 ${serversToWrap.length} MCP server(s) wrapped`));
+      anythingChanged = true;
+    } else {
+      console.log(import_chalk2.default.yellow("  Skipped MCP server wrapping."));
+    }
+    console.log("");
+  }
+  if (!anythingChanged && serversToWrap.length === 0) {
+    console.log(import_chalk2.default.blue("\u2139\uFE0F  Node9 is already fully configured for Cursor."));
+    printDaemonTip();
+    return;
+  }
+  if (anythingChanged) {
+    console.log(import_chalk2.default.green.bold("\u{1F6E1}\uFE0F  Node9 is now protecting Cursor!"));
+    console.log(import_chalk2.default.gray("    Restart Cursor for changes to take effect."));
+    printDaemonTip();
+  }
+}
+
+// src/daemon/ui.html
+var ui_default = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Node9 Security Guard</title>
+    <style>
+      @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&family=Fira+Code:wght@400;500&display=swap');
+      :root {
+        --bg: #0a0c10;
+        --card: #1c2128;
+        --panel: #161b22;
+        --border: #30363d;
+        --text: #adbac7;
+        --text-bright: #cdd9e5;
+        --muted: #768390;
+        --primary: #f0883e;
+        --success: #347d39;
+        --danger: #c93c37;
+        --accent: #539bf5;
+      }
+      * {
+        box-sizing: border-box;
+        margin: 0;
+        padding: 0;
+      }
+      body {
+        background: var(--bg);
+        color: var(--text);
+        font-family:
+          'Inter',
+          -apple-system,
+          sans-serif;
+        min-height: 100vh;
+      }
+
+      .shell {
+        max-width: 1000px;
+        margin: 0 auto;
+        padding: 32px 24px 48px;
+        display: grid;
+        grid-template-rows: auto 1fr;
+        gap: 24px;
+      }
+      header {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        padding-bottom: 20px;
+        border-bottom: 1px solid var(--border);
+      }
+      .logo {
+        font-size: 24px;
+      }
+      h1 {
+        font-size: 18px;
+        font-weight: 700;
+        color: var(--text-bright);
+        letter-spacing: -0.3px;
+      }
+      .status-badge {
+        margin-left: auto;
+        font-size: 11px;
+        font-weight: 700;
+        padding: 3px 10px;
+        border-radius: 6px;
+        text-transform: uppercase;
+        letter-spacing: 0.5px;
+        background: rgba(48, 54, 61, 0.5);
+        border: 1px solid var(--border);
+        color: var(--muted);
+      }
+      .status-badge.online {
+        color: #57ab5a;
+        border-color: rgba(52, 125, 57, 0.4);
+      }
+
+      .body {
+        display: grid;
+        grid-template-columns: 1fr 272px;
+        gap: 20px;
+        align-items: start;
+      }
+
+      .warning-banner {
+        display: none;
+        background: rgba(240, 136, 62, 0.08);
+        border: 1px solid rgba(240, 136, 62, 0.3);
+        border-radius: 10px;
+        padding: 10px 14px;
+        margin-bottom: 14px;
+        font-size: 12px;
+        color: var(--primary);
+        line-height: 1.5;
+      }
+      .warning-banner.show {
+        display: block;
+      }
+
+      .main {
+        min-width: 0;
+      }
+      .section-title {
+        font-size: 11px;
+        font-weight: 700;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+        color: var(--muted);
+        margin-bottom: 12px;
+      }
+      #empty {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        gap: 10px;
+        padding: 48px 24px;
+        border: 2px dashed var(--border);
+        border-radius: 16px;
+        color: var(--muted);
+        font-size: 13px;
+        text-align: center;
+        line-height: 1.5;
+      }
+      #empty .empty-icon {
+        font-size: 28px;
+      }
+      .card {
+        background: var(--card);
+        border: 1px solid var(--border);
+        border-radius: 14px;
+        padding: 24px;
+        margin-bottom: 16px;
+        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.3);
+        animation: pop 0.35s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+      }
+      .card.slack-viewer {
+        border-color: rgba(83, 155, 245, 0.3);
+      }
+      @keyframes pop {
+        from {
+          opacity: 0;
+          transform: scale(0.97) translateY(6px);
+        }
+        to {
+          opacity: 1;
+          transform: none;
+        }
+      }
+      .label {
+        font-size: 10px;
+        font-weight: 700;
+        text-transform: uppercase;
+        color: var(--muted);
+        letter-spacing: 1px;
+        display: block;
+        margin-bottom: 6px;
+      }
+      .source-row {
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        margin-bottom: 10px;
+        flex-wrap: wrap;
+      }
+      .agent-badge {
+        font-size: 11px;
+        font-weight: 600;
+        padding: 2px 8px;
+        border-radius: 5px;
+        background: rgba(83, 155, 245, 0.12);
+        border: 1px solid rgba(83, 155, 245, 0.25);
+        color: var(--accent);
+        letter-spacing: 0.2px;
+      }
+      .mcp-badge {
+        font-size: 11px;
+        font-weight: 600;
+        padding: 2px 8px;
+        border-radius: 5px;
+        background: rgba(87, 171, 90, 0.12);
+        border: 1px solid rgba(87, 171, 90, 0.25);
+        color: #57ab5a;
+        font-family: 'Fira Code', monospace;
+        letter-spacing: 0.2px;
+      }
+      .source-arrow {
+        font-size: 11px;
+        color: var(--muted);
+      }
+      .tool-chip {
+        display: inline-block;
+        padding: 3px 10px;
+        background: rgba(240, 136, 62, 0.1);
+        color: var(--primary);
+        border-radius: 6px;
+        font-family: 'Fira Code', monospace;
+        font-size: 13px;
+        font-weight: 500;
+        margin-bottom: 16px;
+      }
+      .slack-indicator {
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        font-size: 11px;
+        color: var(--accent);
+        background: rgba(83, 155, 245, 0.08);
+        border: 1px solid rgba(83, 155, 245, 0.2);
+        border-radius: 6px;
+        padding: 5px 10px;
+        margin-bottom: 14px;
+      }
+      pre {
+        background: #0d1117;
+        padding: 14px 16px;
+        border-radius: 10px;
+        font-family: 'Fira Code', monospace;
+        font-size: 12px;
+        color: #e6edf3;
+        line-height: 1.6;
+        border: 1px solid var(--border);
+        margin-bottom: 20px;
+        overflow-x: auto;
+        white-space: pre-wrap;
+        word-break: break-all;
+      }
+      .actions {
+        display: grid;
+        grid-template-columns: 1fr 1fr;
+        gap: 8px;
+      }
+      button {
+        padding: 11px 14px;
+        border-radius: 8px;
+        border: 1px solid transparent;
+        font-size: 13px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.15s ease;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 6px;
+        font-family: inherit;
+      }
+      .btn-allow {
+        background: var(--success);
+        color: #fff;
+        grid-column: span 2;
+      }
+      .btn-deny {
+        background: var(--danger);
+        color: #fff;
+        grid-column: span 2;
+      }
+      .btn-secondary {
+        background: transparent;
+        border-color: var(--border);
+        color: var(--text);
+        font-size: 12px;
+        font-weight: 500;
+      }
+      button:hover:not(:disabled) {
+        filter: brightness(1.15);
+        transform: translateY(-1px);
+      }
+      button:active:not(:disabled) {
+        transform: none;
+        filter: brightness(0.95);
+      }
+      button:disabled {
+        opacity: 0.35;
+        cursor: not-allowed;
+      }
+
+      .sidebar {
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+        position: sticky;
+        top: 24px;
+      }
+      .panel {
+        background: var(--panel);
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        padding: 16px;
+      }
+      .panel-title {
+        font-size: 12px;
+        font-weight: 700;
+        color: var(--text-bright);
+        margin-bottom: 12px;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+      }
+      .setting-row {
+        display: flex;
+        align-items: flex-start;
+        gap: 12px;
+        margin-bottom: 12px;
+      }
+      .setting-row:last-child {
+        margin-bottom: 0;
+      }
+      .setting-text {
+        flex: 1;
+      }
+      .setting-label {
+        font-size: 12px;
+        color: var(--text-bright);
+        margin-bottom: 3px;
+      }
+      .setting-desc {
+        font-size: 11px;
+        color: var(--muted);
+        line-height: 1.5;
+      }
+      .toggle {
+        position: relative;
+        display: inline-block;
+        width: 40px;
+        height: 22px;
+        flex-shrink: 0;
+        margin-top: 1px;
+      }
+      .toggle input {
+        opacity: 0;
+        width: 0;
+        height: 0;
+      }
+      .slider {
+        position: absolute;
+        cursor: pointer;
+        inset: 0;
+        background: #30363d;
+        border-radius: 22px;
+        transition: 0.2s;
+      }
+      .slider:before {
+        content: '';
+        position: absolute;
+        width: 16px;
+        height: 16px;
+        left: 3px;
+        bottom: 3px;
+        background: #fff;
+        border-radius: 50%;
+        transition: 0.2s;
+      }
+      input:checked + .slider {
+        background: var(--success);
+      }
+      input:checked + .slider:before {
+        transform: translateX(18px);
+      }
+      input:disabled + .slider {
+        opacity: 0.4;
+        cursor: not-allowed;
+      }
+
+      .slack-key-row {
+        display: flex;
+        gap: 6px;
+        margin-top: 10px;
+      }
+      .slack-key-input {
+        flex: 1;
+        background: #0d1117;
+        border: 1px solid var(--border);
+        border-radius: 6px;
+        color: var(--text-bright);
+        padding: 6px 10px;
+        font-size: 12px;
+        font-family: 'Fira Code', monospace;
+        outline: none;
+      }
+      .slack-key-input:focus {
+        border-color: var(--accent);
+      }
+      .btn-save-key {
+        background: var(--accent);
+        color: #fff;
+        border: none;
+        border-radius: 6px;
+        padding: 6px 12px;
+        font-size: 12px;
+        font-weight: 600;
+        cursor: pointer;
+        white-space: nowrap;
+        font-family: inherit;
+      }
+      .btn-save-key:hover {
+        filter: brightness(1.1);
+      }
+      .slack-status-line {
+        font-size: 11px;
+        color: var(--muted);
+        margin-top: 6px;
+      }
+      .slack-status-line.active {
+        color: #57ab5a;
+      }
+
+      .decisions-empty {
+        font-size: 12px;
+        color: var(--muted);
+      }
+      .decision-row {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        padding: 7px 0;
+        border-bottom: 1px solid var(--border);
+      }
+      .decision-row:last-child {
+        border-bottom: none;
+      }
+      .decision-tool {
+        flex: 1;
+        font-family: 'Fira Code', monospace;
+        font-size: 11px;
+        color: var(--text-bright);
+        word-break: break-all;
+      }
+      .decision-badge {
+        padding: 2px 6px;
+        border-radius: 4px;
+        font-size: 10px;
+        font-weight: 700;
+        text-transform: uppercase;
+        letter-spacing: 0.4px;
+        white-space: nowrap;
+      }
+      .decision-badge.allow {
+        background: rgba(52, 125, 57, 0.2);
+        color: #57ab5a;
+      }
+      .decision-badge.deny {
+        background: rgba(201, 60, 55, 0.2);
+        color: #e5534b;
+      }
+      .btn-revoke {
+        background: transparent;
+        border: 1px solid var(--border);
+        color: var(--muted);
+        padding: 3px 8px;
+        font-size: 10px;
+        border-radius: 5px;
+        white-space: nowrap;
+        font-family: inherit;
+        cursor: pointer;
+      }
+      .btn-revoke:hover {
+        border-color: var(--danger);
+        color: var(--danger);
+      }
+
+      .modal-overlay {
+        display: none;
+        position: fixed;
+        inset: 0;
+        background: rgba(0, 0, 0, 0.7);
+        z-index: 100;
+        align-items: center;
+        justify-content: center;
+      }
+      .modal-overlay.show {
+        display: flex;
+      }
+      .modal {
+        background: var(--card);
+        border: 1px solid var(--border);
+        border-radius: 16px;
+        padding: 28px;
+        max-width: 380px;
+        width: 90%;
+      }
+      .modal h2 {
+        font-size: 16px;
+        color: var(--text-bright);
+        margin-bottom: 10px;
+      }
+      .modal p {
+        font-size: 13px;
+        color: var(--muted);
+        line-height: 1.6;
+        margin-bottom: 20px;
+      }
+      .modal-actions {
+        display: flex;
+        gap: 10px;
+      }
+      .modal-actions button {
+        flex: 1;
+        padding: 10px;
+        border-radius: 8px;
+        font-size: 13px;
+        font-weight: 600;
+        cursor: pointer;
+        font-family: inherit;
+      }
+      .btn-modal-yes {
+        background: var(--success);
+        color: #fff;
+        border: none;
+      }
+      .btn-modal-no {
+        background: transparent;
+        color: var(--text);
+        border: 1px solid var(--border);
+      }
+
+      @media (max-width: 680px) {
+        .body {
+          grid-template-columns: 1fr;
+        }
+        .sidebar {
+          position: static;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="shell">
+      <header>
+        <span class="logo">\u{1F6E1}\uFE0F</span>
+        <h1>Node9 Guard</h1>
+        <div id="st" class="status-badge">Waiting...</div>
+      </header>
+
+      <div class="body">
+        <div class="main">
+          <div id="warnBanner" class="warning-banner">
+            \u26A0\uFE0F Auto-start is off \u2014 daemon started manually. Run "node9 daemon stop" to stop it, or
+            enable Auto-start in Settings.
+          </div>
+          <div class="section-title">Pending Approvals</div>
+          <div id="list"></div>
+          <div id="empty">
+            <span class="empty-icon">\u2728</span>
+            <span>All clear \u2014 no pending tool calls.</span>
+          </div>
+        </div>
+
+        <div class="sidebar">
+          <div class="panel">
+            <div class="panel-title">\u2699\uFE0F Settings</div>
+            <div class="setting-row">
+              <div class="setting-text">
+                <div class="setting-label">Auto-start daemon</div>
+                <div class="setting-desc">
+                  Open this browser automatically when a dangerous call arrives.
+                </div>
+              </div>
+              <label class="toggle">
+                <input
+                  type="checkbox"
+                  id="autoStartToggle"
+                  onchange="saveSetting('autoStartDaemon', this.checked)"
+                />
+                <span class="slider"></span>
+              </label>
+            </div>
+          </div>
+
+          <div class="panel">
+            <div class="panel-title">\u{1F4AC} Slack Approvals</div>
+            <div class="setting-row">
+              <div class="setting-text">
+                <div class="setting-label">Enable Slack</div>
+                <div class="setting-desc">
+                  Use Slack as the approval authority when a key is saved.
+                </div>
+              </div>
+              <label class="toggle">
+                <input
+                  type="checkbox"
+                  id="slackEnabledToggle"
+                  onchange="saveSetting('slackEnabled', this.checked)"
+                />
+                <span class="slider"></span>
+              </label>
+            </div>
+            <div class="slack-key-row">
+              <input
+                type="password"
+                id="slackKeyInput"
+                class="slack-key-input"
+                placeholder="Paste API key\u2026"
+              />
+              <button class="btn-save-key" onclick="saveSlackKey()">Save</button>
+            </div>
+            <div id="slackStatusLine" class="slack-status-line">No key saved</div>
+          </div>
+
+          <div class="panel">
+            <div class="panel-title">\u{1F4CB} Persistent Decisions</div>
+            <div id="decisionsList"><span class="decisions-empty">None yet.</span></div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div id="slackModal" class="modal-overlay">
+      <div class="modal">
+        <h2>\u2705 Slack key saved</h2>
+        <p>
+          Slack is now the approval authority. Would you like to
+          <strong>disable the browser popup</strong>? You can re-enable it in Settings anytime.
+        </p>
+        <div class="modal-actions">
+          <button class="btn-modal-yes" onclick="dismissModal(true)">Yes, disable popup</button>
+          <button class="btn-modal-no" onclick="dismissModal(false)">Keep popup</button>
+        </div>
+      </div>
+    </div>
+
+    <script>
+      const CSRF_TOKEN = '{{CSRF_TOKEN}}';
+      const list = document.getElementById('list');
+      const empty = document.getElementById('empty');
+      const st = document.getElementById('st');
+      const requests = new Set();
+      let orgName = null;
+      let autoDenyMs = 120000;
+
+      function highlightSyntax(code) {
+        if (typeof code !== 'string') return esc(code);
+        return esc(code)
+          .replace(
+            /(\\b(sudo|rm|cat|grep|ls|git|npm|yarn|pnpm|python3|node|curl|wget|sh|bash|zsh|docker)\\b)/g,
+            '<span class="hl-cmd"></span>'
+          )
+          .replace(/(\\s)(-[-a-zA-Z0-9]+)/g, '<span class="hl-flag"></span>')
+          .replace(/(".*?"|'.*?')/g, '<span class="hl-str"></span>');
+      }
+
+      function updateDenyButton(id, timestamp) {
+        const btn = document.querySelector('#c-' + id + ' .btn-deny');
+        if (!btn) return;
+        const elapsed = Date.now() - timestamp;
+        const remaining = Math.max(0, Math.ceil((autoDenyMs - elapsed) / 1000));
+        if (remaining <= 0) {
+          btn.textContent = 'Auto-Denying...';
+          btn.disabled = true;
+        } else {
+          btn.textContent = 'Block Action (' + remaining + 's)';
+          setTimeout(() => updateDenyButton(id, timestamp), 1000);
+        }
+      }
+
+      function esc(s) {
+        return String(s)
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;');
+      }
+      function refresh() {
+        empty.style.display = requests.size === 0 ? 'block' : 'none';
+      }
+
+      function sendDecision(id, decision, persist) {
+        const card = document.getElementById('c-' + id);
+        if (card) card.style.opacity = '0.5';
+        fetch('/decision/' + id, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'X-Node9-Token': CSRF_TOKEN },
+          body: JSON.stringify({ decision, persist: !!persist }),
+        });
+        setTimeout(() => {
+          card?.remove();
+          requests.delete(id);
+          refresh();
+        }, 200);
+      }
+
+      function addCard(req) {
+        if (requests.has(req.id)) return;
+        requests.add(req.id);
+        refresh();
+        const isSlack = !!req.slackDelegated;
+        const cmd = esc(
+          String(
+            req.args &&
+              (req.args.command ||
+                req.args.cmd ||
+                req.args.script ||
+                JSON.stringify(req.args, null, 2))
+          )
+        );
+        const card = document.createElement('div');
+        card.className = 'card' + (isSlack ? ' slack-viewer' : '');
+        card.id = 'c-' + req.id;
+        const agentLabel = req.agent ? esc(req.agent) : 'AI Agent';
+        const mcpLabel = req.mcpServer ? esc(req.mcpServer) : null;
+        card.innerHTML = \`
+        <div class="source-row">
+          <span class="agent-badge">\${agentLabel}</span>
+          \${mcpLabel ? \`<span class="source-arrow">\u2192</span><span class="mcp-badge">mcp::\${mcpLabel}</span>\` : ''}
+        </div>
+        <div class="tool-chip">\${esc(req.toolName)}</div>
+        \${isSlack ? '<div class="slack-indicator">\u26A1 Awaiting Slack approval \u2014 view only</div>' : ''}
+        <span class="label">Input Payload</span>
+        <pre>\${cmd}</pre>
+        <div class="actions">
+          <button class="btn-allow" onclick="sendDecision('\${req.id}','allow',false)" \${isSlack ? 'disabled' : ''}>Approve Execution</button>
+          <button class="btn-deny"  onclick="sendDecision('\${req.id}','deny',false)"  \${isSlack ? 'disabled' : ''}>Block Action</button>
+          <button class="btn-secondary" onclick="sendDecision('\${req.id}','allow',true)" \${isSlack ? 'disabled' : ''}>Always Allow</button>
+          <button class="btn-secondary" onclick="sendDecision('\${req.id}','deny',true)"  \${isSlack ? 'disabled' : ''}>Always Deny</button>
+        </div>
+      \`;
+        list.appendChild(card);
+        if (!isSlack) updateDenyButton(req.id, req.timestamp || Date.now());
+        if (!isSlack) {
+          try {
+            new Audio(
+              'data:audio/wav;base64,UklGRl9vT19XQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YTdvT18AAACAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA='
+            ).play();
+          } catch (e) {}
+        }
+      }
+
+      function connect() {
+        const ev = new EventSource('/events');
+        ev.onopen = () => {
+          st.className = 'status-badge online';
+          st.innerText = 'System Live';
+        };
+        ev.onerror = () => {
+          st.className = 'status-badge';
+          st.innerText = 'Reconnecting...';
+          setTimeout(connect, 2000);
+          ev.close();
+        };
+        ev.addEventListener('init', (e) => {
+          const data = JSON.parse(e.data);
+          orgName = data.orgName;
+          autoDenyMs = data.autoDenyMs;
+          if (orgName) {
+            const b = document.getElementById('cloudBadge');
+            b.innerText = orgName;
+            b.classList.add('online');
+          }
+          data.requests.forEach(addCard);
+        });
+        ev.addEventListener('add', (e) => {
+          addCard(JSON.parse(e.data));
+        });
+        ev.addEventListener('remove', (e) => {
+          const id = JSON.parse(e.data).id;
+          document.getElementById('c-' + id)?.remove();
+          requests.delete(id);
+          refresh();
+        });
+        ev.addEventListener('decisions', (e) => {
+          renderDecisions(JSON.parse(e.data));
+        });
+        ev.addEventListener('slack-status', (e) => {
+          applySlackStatus(JSON.parse(e.data));
+        });
+      }
+      connect();
+
+      function saveSetting(key, value) {
+        fetch('/settings', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'X-Node9-Token': CSRF_TOKEN },
+          body: JSON.stringify({ [key]: value }),
+        }).catch(() => {});
+      }
+
+      fetch('/settings')
+        .then((r) => r.json())
+        .then((s) => {
+          const tog = document.getElementById('autoStartToggle');
+          tog.checked = s.autoStartDaemon;
+          if (!s.autoStarted) {
+            tog.disabled = true;
+            tog.title = 'Start the daemon via "node9 daemon" to change this setting';
+          }
+          if (!s.autoStartDaemon && !s.autoStarted) {
+            document.getElementById('warnBanner').classList.add('show');
+          }
+        })
+        .catch(() => {});
+
+      document.getElementById('autoStartToggle').addEventListener('change', function () {
+        document.getElementById('warnBanner').classList.toggle('show', !this.checked);
+      });
+
+      function applySlackStatus(s) {
+        const tog = document.getElementById('slackEnabledToggle');
+        const line = document.getElementById('slackStatusLine');
+        tog.disabled = !s.hasKey;
+        tog.checked = s.hasKey && s.enabled;
+        if (s.hasKey) {
+          line.textContent = s.enabled
+            ? '\u{1F7E2} Slack active \u2014 approvals handled by Slack'
+            : '\u26AB Key saved, Slack disabled';
+          line.className = 'slack-status-line' + (s.enabled ? ' active' : '');
+        } else {
+          line.textContent = 'No key saved';
+          line.className = 'slack-status-line';
+        }
+      }
+
+      fetch('/slack-status')
+        .then((r) => r.json())
+        .then(applySlackStatus)
+        .catch(() => {});
+
+      function saveSlackKey() {
+        const key = document.getElementById('slackKeyInput').value.trim();
+        if (!key) return;
+        fetch('/slack-key', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'X-Node9-Token': CSRF_TOKEN },
+          body: JSON.stringify({ apiKey: key }),
+        })
+          .then((r) => {
+            if (r.ok) {
+              document.getElementById('slackKeyInput').value = '';
+              document.getElementById('slackModal').classList.add('show');
+            }
+          })
+          .catch(() => {});
+      }
+
+      function dismissModal(disablePopup) {
+        document.getElementById('slackModal').classList.remove('show');
+        if (disablePopup) {
+          saveSetting('autoStartDaemon', false);
+          document.getElementById('autoStartToggle').checked = false;
+          document.getElementById('warnBanner').classList.remove('show');
+        }
+      }
+
+      function renderDecisions(decisions) {
+        const dl = document.getElementById('decisionsList');
+        const entries = Object.entries(decisions);
+        if (entries.length === 0) {
+          dl.innerHTML = '<span class="decisions-empty">None yet.</span>';
+          return;
+        }
+        dl.innerHTML = entries
+          .map(
+            ([tool, dec]) => \`
+        <div class="decision-row" id="dr-\${encodeURIComponent(tool)}">
+          <span class="decision-tool">\${esc(tool)}</span>
+          <span class="decision-badge \${esc(dec)}">\${dec === 'allow' ? 'Always Allow' : 'Always Deny'}</span>
+          <button class="btn-revoke" onclick="revokeDecision(this)">Revoke</button>
+        </div>
+      \`
+          )
+          .join('');
+        entries.forEach(([tool]) => {
+          const row = document.getElementById('dr-' + encodeURIComponent(tool));
+          if (row) row.querySelector('.btn-revoke').dataset.tool = tool;
+        });
+      }
+
+      function revokeDecision(btn) {
+        const toolName = btn.dataset.tool;
+        if (!toolName) return;
+        fetch('/decisions/' + encodeURIComponent(toolName), {
+          method: 'DELETE',
+          headers: { 'X-Node9-Token': CSRF_TOKEN },
+        }).catch(() => {});
+        document.getElementById('dr-' + encodeURIComponent(toolName))?.remove();
+        if (!document.querySelector('#decisionsList .decision-row')) {
+          document.getElementById('decisionsList').innerHTML =
+            '<span class="decisions-empty">None yet.</span>';
+        }
+      }
+
+      fetch('/decisions')
+        .then((r) => r.json())
+        .then(renderDecisions)
+        .catch(() => {});
+    </script>
+  </body>
+</html>
+`;
+
+// src/daemon/ui.ts
+var UI_HTML_TEMPLATE = ui_default;
+
+// src/daemon/index.ts
+var import_http = __toESM(require("http"));
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+var import_child_process = require("child_process");
+var import_crypto = require("crypto");
+var import_chalk3 = __toESM(require("chalk"));
+var DAEMON_PORT2 = 7391;
+var DAEMON_HOST2 = "127.0.0.1";
+var homeDir = import_os3.default.homedir();
+var DAEMON_PID_FILE = import_path3.default.join(homeDir, ".node9", "daemon.pid");
+var DECISIONS_FILE = import_path3.default.join(homeDir, ".node9", "decisions.json");
+var GLOBAL_CONFIG_FILE = import_path3.default.join(homeDir, ".node9", "config.json");
+var CREDENTIALS_FILE = import_path3.default.join(homeDir, ".node9", "credentials.json");
+var AUDIT_LOG_FILE = import_path3.default.join(homeDir, ".node9", "audit.log");
+var SECRET_KEY_RE = /password|secret|token|key|apikey|credential|auth/i;
+function redactArgs(value) {
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(redactArgs);
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    result[k] = SECRET_KEY_RE.test(k) ? "[REDACTED]" : redactArgs(v);
+  }
+  return result;
+}
+function appendAuditLog(data) {
+  try {
+    const entry = JSON.stringify({ ...data, args: redactArgs(data.args) }) + "\n";
+    const dir = import_path3.default.dirname(AUDIT_LOG_FILE);
+    if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
+    import_fs3.default.appendFileSync(AUDIT_LOG_FILE, entry);
+  } catch {
+  }
+}
+function getAuditHistory(limit = 20) {
+  try {
+    if (!import_fs3.default.existsSync(AUDIT_LOG_FILE)) return [];
+    const lines = import_fs3.default.readFileSync(AUDIT_LOG_FILE, "utf-8").trim().split("\n");
+    if (lines.length === 1 && lines[0] === "") return [];
+    return lines.slice(-limit).map((l) => JSON.parse(l)).reverse();
+  } catch {
+    return [];
+  }
+}
+var AUTO_DENY_MS = 12e4;
+function getOrgName() {
+  try {
+    if (import_fs3.default.existsSync(CREDENTIALS_FILE)) {
+      return "Node9 Cloud";
+    }
+  } catch {
+  }
+  return null;
+}
+var autoStarted = process.env.NODE9_AUTO_STARTED === "1";
+function readGlobalSettings() {
+  try {
+    if (import_fs3.default.existsSync(GLOBAL_CONFIG_FILE)) {
+      const config = JSON.parse(import_fs3.default.readFileSync(GLOBAL_CONFIG_FILE, "utf-8"));
+      const s = config?.settings ?? {};
+      return {
+        autoStartDaemon: s.autoStartDaemon !== false,
+        slackEnabled: s.slackEnabled !== false,
+        agentMode: s.agentMode === true
+      };
+    }
+  } catch {
+  }
+  return { autoStartDaemon: true, slackEnabled: true, agentMode: false };
+}
+function hasStoredSlackKey() {
+  return import_fs3.default.existsSync(CREDENTIALS_FILE);
+}
+function writeGlobalSetting(key, value) {
+  let config = {};
+  try {
+    if (import_fs3.default.existsSync(GLOBAL_CONFIG_FILE)) {
+      config = JSON.parse(import_fs3.default.readFileSync(GLOBAL_CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  if (!config.settings || typeof config.settings !== "object") config.settings = {};
+  config.settings[key] = value;
+  const dir = import_path3.default.dirname(GLOBAL_CONFIG_FILE);
+  if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
+  import_fs3.default.writeFileSync(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 384 });
+}
+var pending = /* @__PURE__ */ new Map();
+var sseClients = /* @__PURE__ */ new Set();
+var abandonTimer = null;
+var daemonServer = null;
+function abandonPending() {
+  abandonTimer = null;
+  pending.forEach((entry, id) => {
+    clearTimeout(entry.timer);
+    if (entry.waiter) entry.waiter("abandoned");
+    else entry.earlyDecision = "abandoned";
+    pending.delete(id);
+    broadcast("remove", { id });
+  });
+  if (autoStarted) {
+    try {
+      import_fs3.default.unlinkSync(DAEMON_PID_FILE);
+    } catch {
+    }
+    setTimeout(() => {
+      daemonServer?.close();
+      process.exit(0);
+    }, 200);
+  }
+}
+function broadcast(event, data) {
+  const msg = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+  sseClients.forEach((client) => {
+    try {
+      client.write(msg);
+    } catch {
+      sseClients.delete(client);
+    }
+  });
+}
+function openBrowser(url) {
+  try {
+    const opts = { stdio: "ignore" };
+    if (process.platform === "darwin") (0, import_child_process.execSync)(`open "${url}"`, opts);
+    else if (process.platform === "win32") (0, import_child_process.execSync)(`cmd /c start "" "${url}"`, opts);
+    else (0, import_child_process.execSync)(`xdg-open "${url}"`, opts);
+  } catch {
+  }
+}
+function readBody(req) {
+  return new Promise((resolve) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => resolve(body));
+  });
+}
+function readPersistentDecisions() {
+  try {
+    if (import_fs3.default.existsSync(DECISIONS_FILE)) {
+      return JSON.parse(import_fs3.default.readFileSync(DECISIONS_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function writePersistentDecision(toolName, decision) {
+  try {
+    const dir = import_path3.default.dirname(DECISIONS_FILE);
+    if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
+    const decisions = readPersistentDecisions();
+    decisions[toolName] = decision;
+    import_fs3.default.writeFileSync(DECISIONS_FILE, JSON.stringify(decisions, null, 2));
+    broadcast("decisions", decisions);
+  } catch {
+  }
+}
+function startDaemon() {
+  const csrfToken = (0, import_crypto.randomUUID)();
+  const internalToken = (0, import_crypto.randomUUID)();
+  const UI_HTML = UI_HTML_TEMPLATE.replace("{{CSRF_TOKEN}}", csrfToken);
+  const validToken = (req) => req.headers["x-node9-token"] === csrfToken;
+  const server = import_http.default.createServer(async (req, res) => {
+    const { pathname } = new URL(req.url || "/", `http://${req.headers.host}`);
+    if (req.method === "GET" && pathname === "/") {
+      res.writeHead(200, { "Content-Type": "text/html" });
+      return res.end(UI_HTML);
+    }
+    if (req.method === "GET" && pathname === "/events") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      if (abandonTimer) {
+        clearTimeout(abandonTimer);
+        abandonTimer = null;
+      }
+      sseClients.add(res);
+      res.write(
+        `event: init
+data: ${JSON.stringify({
+          requests: Array.from(pending.values()).map((e) => ({
+            id: e.id,
+            toolName: e.toolName,
+            args: e.args,
+            slackDelegated: e.slackDelegated,
+            timestamp: e.timestamp,
+            agent: e.agent,
+            mcpServer: e.mcpServer
+          })),
+          orgName: getOrgName(),
+          autoDenyMs: AUTO_DENY_MS
+        })}
+
+`
+      );
+      res.write(`event: decisions
+data: ${JSON.stringify(readPersistentDecisions())}
+
+`);
+      return req.on("close", () => {
+        sseClients.delete(res);
+        if (sseClients.size === 0 && pending.size > 0) {
+          abandonTimer = setTimeout(abandonPending, 2e3);
+        }
+      });
+    }
+    if (req.method === "POST" && pathname === "/check") {
+      try {
+        const body = await readBody(req);
+        if (body.length > 65536) return res.writeHead(413).end();
+        const { toolName, args, slackDelegated = false, agent, mcpServer } = JSON.parse(body);
+        const id = (0, import_crypto.randomUUID)();
+        const entry = {
+          id,
+          toolName,
+          args,
+          agent: typeof agent === "string" ? agent : void 0,
+          mcpServer: typeof mcpServer === "string" ? mcpServer : void 0,
+          slackDelegated: !!slackDelegated,
+          timestamp: Date.now(),
+          earlyDecision: null,
+          waiter: null,
+          timer: setTimeout(() => {
+            if (pending.has(id)) {
+              const e = pending.get(id);
+              appendAuditLog({
+                toolName: e.toolName,
+                args: e.args,
+                decision: "auto-deny",
+                timestamp: Date.now()
+              });
+              if (e.waiter) e.waiter("deny");
+              else e.earlyDecision = "deny";
+              pending.delete(id);
+              broadcast("remove", { id });
+            }
+          }, AUTO_DENY_MS)
+        };
+        pending.set(id, entry);
+        broadcast("add", {
+          id,
+          toolName,
+          args,
+          slackDelegated: entry.slackDelegated,
+          agent: entry.agent,
+          mcpServer: entry.mcpServer
+        });
+        if (sseClients.size === 0) openBrowser(`http://127.0.0.1:${DAEMON_PORT2}/`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ id }));
+      } catch {
+        res.writeHead(400).end();
+      }
+    }
+    if (req.method === "GET" && pathname.startsWith("/wait/")) {
+      const id = pathname.split("/").pop();
+      const entry = pending.get(id);
+      if (!entry) return res.writeHead(404).end();
+      if (entry.earlyDecision) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        return res.end(JSON.stringify({ decision: entry.earlyDecision }));
+      }
+      entry.waiter = (d) => {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ decision: d }));
+      };
+      return;
+    }
+    if (req.method === "POST" && pathname.startsWith("/decision/")) {
+      if (!validToken(req)) return res.writeHead(403).end();
+      try {
+        const id = pathname.split("/").pop();
+        const entry = pending.get(id);
+        if (!entry) return res.writeHead(404).end();
+        const { decision, persist } = JSON.parse(await readBody(req));
+        if (persist) writePersistentDecision(entry.toolName, decision);
+        appendAuditLog({
+          toolName: entry.toolName,
+          args: entry.args,
+          decision,
+          timestamp: Date.now()
+        });
+        clearTimeout(entry.timer);
+        if (entry.waiter) entry.waiter(decision);
+        else entry.earlyDecision = decision;
+        pending.delete(id);
+        broadcast("remove", { id });
+        res.writeHead(200);
+        return res.end(JSON.stringify({ ok: true }));
+      } catch {
+        res.writeHead(400).end();
+      }
+    }
+    if (req.method === "GET" && pathname === "/settings") {
+      const s = readGlobalSettings();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ ...s, autoStarted }));
+    }
+    if (req.method === "POST" && pathname === "/settings") {
+      if (!validToken(req)) return res.writeHead(403).end();
+      try {
+        const body = await readBody(req);
+        const data = JSON.parse(body);
+        if (data.autoStartDaemon !== void 0)
+          writeGlobalSetting("autoStartDaemon", data.autoStartDaemon);
+        if (data.slackEnabled !== void 0) writeGlobalSetting("slackEnabled", data.slackEnabled);
+        if (data.agentMode !== void 0) writeGlobalSetting("agentMode", data.agentMode);
+        res.writeHead(200);
+        return res.end(JSON.stringify({ ok: true }));
+      } catch {
+        res.writeHead(400).end();
+      }
+    }
+    if (req.method === "GET" && pathname === "/slack-status") {
+      const s = readGlobalSettings();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ hasKey: hasStoredSlackKey(), enabled: s.slackEnabled }));
+    }
+    if (req.method === "POST" && pathname === "/slack-key") {
+      if (!validToken(req)) return res.writeHead(403).end();
+      try {
+        const { apiKey } = JSON.parse(await readBody(req));
+        if (!import_fs3.default.existsSync(import_path3.default.dirname(CREDENTIALS_FILE)))
+          import_fs3.default.mkdirSync(import_path3.default.dirname(CREDENTIALS_FILE), { recursive: true });
+        import_fs3.default.writeFileSync(
+          CREDENTIALS_FILE,
+          JSON.stringify({ apiKey, apiUrl: "https://api.node9.ai/api/v1/intercept" }, null, 2),
+          { mode: 384 }
+        );
+        broadcast("slack-status", { hasKey: true, enabled: readGlobalSettings().slackEnabled });
+        res.writeHead(200);
+        return res.end(JSON.stringify({ ok: true }));
+      } catch {
+        res.writeHead(400).end();
+      }
+    }
+    if (req.method === "DELETE" && pathname.startsWith("/decisions/")) {
+      if (!validToken(req)) return res.writeHead(403).end();
+      try {
+        const toolName = decodeURIComponent(pathname.split("/").pop());
+        const decisions = readPersistentDecisions();
+        delete decisions[toolName];
+        import_fs3.default.writeFileSync(DECISIONS_FILE, JSON.stringify(decisions, null, 2));
+        broadcast("decisions", decisions);
+        res.writeHead(200);
+        return res.end(JSON.stringify({ ok: true }));
+      } catch {
+        res.writeHead(400).end();
+      }
+    }
+    if (req.method === "POST" && pathname.startsWith("/resolve/")) {
+      const internalAuth = req.headers["x-node9-internal"];
+      if (internalAuth !== internalToken) return res.writeHead(403).end();
+      try {
+        const id = pathname.split("/").pop();
+        const entry = pending.get(id);
+        if (!entry) return res.writeHead(404).end();
+        const { decision } = JSON.parse(await readBody(req));
+        appendAuditLog({
+          toolName: entry.toolName,
+          args: entry.args,
+          decision,
+          timestamp: Date.now()
+        });
+        clearTimeout(entry.timer);
+        if (entry.waiter) entry.waiter(decision);
+        else entry.earlyDecision = decision;
+        pending.delete(id);
+        broadcast("remove", { id });
+        res.writeHead(200);
+        return res.end(JSON.stringify({ ok: true }));
+      } catch {
+        res.writeHead(400).end();
+      }
+    }
+    if (req.method === "GET" && pathname === "/audit") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify(getAuditHistory()));
+    }
+    res.writeHead(404).end();
+  });
+  daemonServer = server;
+  server.listen(DAEMON_PORT2, DAEMON_HOST2, () => {
+    if (!import_fs3.default.existsSync(import_path3.default.dirname(DAEMON_PID_FILE)))
+      import_fs3.default.mkdirSync(import_path3.default.dirname(DAEMON_PID_FILE), { recursive: true });
+    import_fs3.default.writeFileSync(
+      DAEMON_PID_FILE,
+      JSON.stringify({ pid: process.pid, port: DAEMON_PORT2, internalToken, autoStarted }),
+      { mode: 384 }
+    );
+    console.log(import_chalk3.default.green(`\u{1F6E1}\uFE0F  Node9 Guard LIVE: http://127.0.0.1:${DAEMON_PORT2}`));
+  });
+}
+function stopDaemon() {
+  if (!import_fs3.default.existsSync(DAEMON_PID_FILE)) return console.log(import_chalk3.default.yellow("Not running."));
+  try {
+    const { pid } = JSON.parse(import_fs3.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    process.kill(pid, "SIGTERM");
+    console.log(import_chalk3.default.green("\u2705 Stopped."));
+  } catch {
+    console.log(import_chalk3.default.gray("Cleaned up stale PID file."));
+  } finally {
+    try {
+      import_fs3.default.unlinkSync(DAEMON_PID_FILE);
+    } catch {
+    }
+  }
+}
+function daemonStatus() {
+  if (!import_fs3.default.existsSync(DAEMON_PID_FILE))
+    return console.log(import_chalk3.default.yellow("Node9 daemon: not running"));
+  try {
+    const { pid } = JSON.parse(import_fs3.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    process.kill(pid, 0);
+    console.log(import_chalk3.default.green("Node9 daemon: running"));
+  } catch {
+    console.log(import_chalk3.default.yellow("Node9 daemon: not running (stale PID)"));
+  }
+}
+
+// src/cli.ts
+var import_child_process2 = require("child_process");
+var import_execa = require("execa");
+var import_execa2 = require("execa");
+var import_chalk4 = __toESM(require("chalk"));
+var import_readline = __toESM(require("readline"));
+var import_fs4 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_os4 = __toESM(require("os"));
+var { version } = JSON.parse(
+  import_fs4.default.readFileSync(import_path4.default.join(__dirname, "../package.json"), "utf-8")
+);
+function sanitize(value) {
+  return value.replace(/[\x00-\x1F\x7F]/g, "");
+}
+function openBrowserLocal() {
+  const url = `http://${DAEMON_HOST2}:${DAEMON_PORT2}/`;
+  try {
+    const opts = { stdio: "ignore" };
+    if (process.platform === "darwin") (0, import_child_process2.execSync)(`open "${url}"`, opts);
+    else if (process.platform === "win32") (0, import_child_process2.execSync)(`cmd /c start "" "${url}"`, opts);
+    else (0, import_child_process2.execSync)(`xdg-open "${url}"`, opts);
+  } catch {
+  }
+}
+async function autoStartDaemonAndWait() {
+  try {
+    const child = (0, import_child_process2.spawn)("node9", ["daemon"], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, NODE9_AUTO_STARTED: "1" }
+    });
+    child.unref();
+    for (let i = 0; i < 12; i++) {
+      await new Promise((r) => setTimeout(r, 250));
+      if (isDaemonRunning()) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+var program = new import_commander.Command();
+program.name("node9").description("The Sudo Command for AI Agents").version(version);
+async function runProxy(targetCommand) {
+  const commandParts = (0, import_execa.parseCommandString)(targetCommand);
+  const cmd = commandParts[0];
+  const args = commandParts.slice(1);
+  let executable = cmd;
+  try {
+    const { stdout } = await (0, import_execa2.execa)("which", [cmd]);
+    if (stdout) executable = stdout.trim();
+  } catch {
+  }
+  console.log(import_chalk4.default.green(`\u{1F680} Node9 Proxy Active: Monitoring [${targetCommand}]`));
+  const child = (0, import_child_process2.spawn)(executable, args, {
+    stdio: ["pipe", "pipe", "inherit"],
+    shell: true,
+    env: { ...process.env, FORCE_COLOR: "1", TERM: process.env.TERM || "xterm-256color" }
+  });
+  process.stdin.pipe(child.stdin);
+  const childOut = import_readline.default.createInterface({ input: child.stdout, terminal: false });
+  childOut.on("line", async (line) => {
+    try {
+      const message = JSON.parse(line);
+      if (message.method === "call_tool" || message.method === "tools/call" || message.method === "use_tool") {
+        const name = message.params?.name || message.params?.tool_name || "unknown";
+        const toolArgs = message.params?.arguments || message.params?.tool_input || {};
+        const approved = await authorizeAction(sanitize(name), toolArgs);
+        if (!approved) {
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: message.id,
+            error: { code: -32e3, message: "Node9: Action denied." }
+          };
+          child.stdin.write(JSON.stringify(errorResponse) + "\n");
+          return;
+        }
+      }
+      process.stdout.write(line + "\n");
+    } catch {
+      process.stdout.write(line + "\n");
+    }
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+program.command("login").argument("<apiKey>").option("--local", "Save key for audit/logging only \u2014 local config still controls all decisions").option("--profile <name>", 'Save as a named profile (default: "default")').action((apiKey, options) => {
+  const DEFAULT_API_URL = "https://api.node9.ai/api/v1/intercept";
+  const credPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "credentials.json");
+  if (!import_fs4.default.existsSync(import_path4.default.dirname(credPath)))
+    import_fs4.default.mkdirSync(import_path4.default.dirname(credPath), { recursive: true });
+  const profileName = options.profile || "default";
+  let existingCreds = {};
+  try {
+    if (import_fs4.default.existsSync(credPath)) {
+      const raw = JSON.parse(import_fs4.default.readFileSync(credPath, "utf-8"));
+      if (raw.apiKey) {
+        existingCreds = {
+          default: { apiKey: raw.apiKey, apiUrl: raw.apiUrl || DEFAULT_API_URL }
+        };
+      } else {
+        existingCreds = raw;
+      }
+    }
+  } catch {
+  }
+  existingCreds[profileName] = { apiKey, apiUrl: DEFAULT_API_URL };
+  import_fs4.default.writeFileSync(credPath, JSON.stringify(existingCreds, null, 2), { mode: 384 });
+  if (profileName === "default") {
+    const configPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "config.json");
+    let config = {};
+    try {
+      if (import_fs4.default.existsSync(configPath))
+        config = JSON.parse(import_fs4.default.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+    if (!config.settings || typeof config.settings !== "object") config.settings = {};
+    config.settings.agentMode = !options.local;
+    if (!import_fs4.default.existsSync(import_path4.default.dirname(configPath)))
+      import_fs4.default.mkdirSync(import_path4.default.dirname(configPath), { recursive: true });
+    import_fs4.default.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+  }
+  if (options.profile && profileName !== "default") {
+    console.log(import_chalk4.default.green(`\u2705 Profile "${profileName}" saved`));
+    console.log(import_chalk4.default.gray(`   Switch to it per-session:  NODE9_PROFILE=${profileName} claude`));
+    console.log(
+      import_chalk4.default.gray(
+        `   Or lock a project to it:   add "apiKey": "<your-api-key>" to node9.config.json`
+      )
+    );
+  } else if (options.local) {
+    console.log(import_chalk4.default.green(`\u2705 Privacy mode \u{1F6E1}\uFE0F`));
+    console.log(import_chalk4.default.gray(`   All decisions stay on this machine.`));
+    console.log(
+      import_chalk4.default.gray(`   No data is sent to the cloud. Local config is the only authority.`)
+    );
+    console.log(import_chalk4.default.gray(`   To enable cloud enforcement: node9 login <apiKey>`));
+  } else {
+    console.log(import_chalk4.default.green(`\u2705 Logged in \u2014 agent mode`));
+    console.log(import_chalk4.default.gray(`   Team policy enforced for all calls via Node9 cloud.`));
+    console.log(import_chalk4.default.gray(`   To keep local control only: node9 login <apiKey> --local`));
+  }
+});
+program.command("addto").description("Integrate Node9 with an AI agent").addHelpText("after", "\n  Supported targets:  claude  gemini  cursor").argument("<target>", "The agent to protect: claude | gemini | cursor").action(async (target) => {
+  if (target === "gemini") return await setupGemini();
+  if (target === "claude") return await setupClaude();
+  if (target === "cursor") return await setupCursor();
+  console.error(import_chalk4.default.red(`Unknown target: "${target}". Supported: claude, gemini, cursor`));
+  process.exit(1);
+});
+program.command("init").description("Create ~/.node9/config.json with default policy (safe to run multiple times)").option("--force", "Overwrite existing config").action((options) => {
+  const configPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "config.json");
+  if (import_fs4.default.existsSync(configPath) && !options.force) {
+    console.log(import_chalk4.default.yellow(`\u2139\uFE0F  Global config already exists: ${configPath}`));
+    console.log(import_chalk4.default.gray(`   Run with --force to overwrite.`));
+    return;
+  }
+  const defaultConfig = {
+    version: "1.0",
+    settings: { mode: "standard" },
+    policy: {
+      dangerousWords: DANGEROUS_WORDS,
+      ignoredTools: [
+        "list_*",
+        "get_*",
+        "read_*",
+        "describe_*",
+        "read",
+        "write",
+        "edit",
+        "multiedit",
+        "glob",
+        "grep",
+        "ls",
+        "notebookread",
+        "notebookedit",
+        "todoread",
+        "todowrite",
+        "webfetch",
+        "websearch",
+        "exitplanmode",
+        "askuserquestion"
+      ],
+      toolInspection: {
+        bash: "command",
+        shell: "command",
+        run_shell_command: "command",
+        "terminal.execute": "command"
+      },
+      rules: [
+        {
+          action: "rm",
+          allowPaths: ["**/node_modules/**", "dist/**", "build/**", ".DS_Store"]
+        }
+      ]
+    }
+  };
+  if (!import_fs4.default.existsSync(import_path4.default.dirname(configPath)))
+    import_fs4.default.mkdirSync(import_path4.default.dirname(configPath), { recursive: true });
+  import_fs4.default.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+  console.log(import_chalk4.default.green(`\u2705 Global config created: ${configPath}`));
+  console.log(import_chalk4.default.gray(`   Edit this file to add custom tool inspection or security rules.`));
+});
+program.command("status").description("Show current Node9 mode, policy source, and persistent decisions").action(() => {
+  const creds = getCredentials();
+  const daemonRunning = isDaemonRunning();
+  const settings = getGlobalSettings();
+  console.log("");
+  if (creds && settings.agentMode) {
+    console.log(import_chalk4.default.green("  \u25CF Agent mode") + import_chalk4.default.gray(" \u2014 cloud team policy enforced"));
+    console.log(import_chalk4.default.gray("    All calls \u2192 Node9 cloud \u2192 Policy Studio rules apply"));
+    console.log(import_chalk4.default.gray("    Switch to local control: node9 login <apiKey> --local"));
+  } else if (creds && !settings.agentMode) {
+    console.log(
+      import_chalk4.default.blue("  \u25CF Privacy mode \u{1F6E1}\uFE0F") + import_chalk4.default.gray(" \u2014 all decisions stay on this machine")
+    );
+    console.log(
+      import_chalk4.default.gray("    No data is sent to the cloud. Local config is the only authority.")
+    );
+    console.log(import_chalk4.default.gray("    Enable cloud enforcement: node9 login <apiKey>"));
+  } else {
+    console.log(import_chalk4.default.yellow("  \u25CB Privacy mode \u{1F6E1}\uFE0F") + import_chalk4.default.gray(" \u2014 no API key"));
+    console.log(import_chalk4.default.gray("    All decisions stay on this machine."));
+    console.log(import_chalk4.default.gray("    Connect to your team: node9 login <apiKey>"));
+  }
+  console.log("");
+  if (daemonRunning) {
+    console.log(
+      import_chalk4.default.green("  \u25CF Daemon running") + import_chalk4.default.gray(` \u2192 http://127.0.0.1:${DAEMON_PORT2}/`)
+    );
+  } else {
+    console.log(import_chalk4.default.gray("  \u25CB Daemon stopped"));
+    console.log(import_chalk4.default.gray("    Start: node9 daemon --background"));
+  }
+  console.log("");
+  console.log(`  Mode:    ${import_chalk4.default.white(settings.mode)}`);
+  const projectConfig = import_path4.default.join(process.cwd(), "node9.config.json");
+  const globalConfig = import_path4.default.join(import_os4.default.homedir(), ".node9", "config.json");
+  const configSource = import_fs4.default.existsSync(projectConfig) ? projectConfig : import_fs4.default.existsSync(globalConfig) ? globalConfig : import_chalk4.default.gray("none (built-in defaults)");
+  console.log(`  Config:  ${import_chalk4.default.gray(configSource)}`);
+  const profiles = listCredentialProfiles();
+  if (profiles.length > 1) {
+    const activeProfile = process.env.NODE9_PROFILE || "default";
+    console.log("");
+    console.log(`  Active profile:  ${import_chalk4.default.white(activeProfile)}`);
+    console.log(
+      `  All profiles:    ${profiles.map((p) => p === activeProfile ? import_chalk4.default.green(p) : import_chalk4.default.gray(p)).join(import_chalk4.default.gray(", "))}`
+    );
+    console.log(import_chalk4.default.gray(`  Switch:  NODE9_PROFILE=<name> claude`));
+  }
+  const decisionsFile = import_path4.default.join(import_os4.default.homedir(), ".node9", "decisions.json");
+  let decisions = {};
+  try {
+    if (import_fs4.default.existsSync(decisionsFile))
+      decisions = JSON.parse(import_fs4.default.readFileSync(decisionsFile, "utf-8"));
+  } catch {
+  }
+  const keys = Object.keys(decisions);
+  console.log("");
+  if (keys.length > 0) {
+    console.log(`  Persistent decisions (${keys.length}):`);
+    keys.forEach((tool) => {
+      const d = decisions[tool];
+      const badge = d === "allow" ? import_chalk4.default.green("allow") : import_chalk4.default.red("deny");
+      console.log(`    ${import_chalk4.default.gray("\xB7")} ${tool.padEnd(35)} ${badge}`);
+    });
+    console.log(import_chalk4.default.gray("\n    Manage: node9 daemon --openui \u2192 Decisions tab"));
+  } else {
+    console.log(import_chalk4.default.gray("  No persistent decisions set"));
+  }
+  const auditLogPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "audit.log");
+  try {
+    if (import_fs4.default.existsSync(auditLogPath)) {
+      const lines = import_fs4.default.readFileSync(auditLogPath, "utf-8").split("\n").filter((l) => l.trim().length > 0);
+      console.log("");
+      console.log(
+        `  \u{1F4CB} Local Audit Log: ` + import_chalk4.default.white(`${lines.length} agent action${lines.length !== 1 ? "s" : ""} recorded`) + import_chalk4.default.gray(`  (cat ~/.node9/audit.log to view)`)
+      );
+    }
+  } catch {
+  }
+  console.log("");
+});
+program.command("daemon").description("Run the local approval server (browser HITL for free tier)").addHelpText(
+  "after",
+  "\n  Subcommands: start (default), stop, status\n  Options:\n    --background  (-b)  start detached, no second terminal needed\n    --openui      (-o)  start in background and open the browser (or just open if already running)\n  Example:     node9 daemon --background"
+).argument("[action]", "start | stop | status (default: start)").option("-b, --background", "Start the daemon in the background (detached)").option(
+  "-o, --openui",
+  "Start in background and open browser (or just open browser if already running)"
+).action(
+  async (action, options) => {
+    const cmd = (action ?? "start").toLowerCase();
+    if (cmd === "stop") return stopDaemon();
+    if (cmd === "status") return daemonStatus();
+    if (cmd !== "start" && action !== void 0) {
+      console.error(import_chalk4.default.red(`Unknown daemon action: "${action}". Use: start | stop | status`));
+      process.exit(1);
+    }
+    if (options.openui) {
+      if (isDaemonRunning()) {
+        openBrowserLocal();
+        console.log(import_chalk4.default.green(`\u{1F310}  Opened browser: http://${DAEMON_HOST2}:${DAEMON_PORT2}/`));
+        process.exit(0);
+      }
+      const child = (0, import_child_process2.spawn)("node9", ["daemon"], { detached: true, stdio: "ignore" });
+      child.unref();
+      for (let i = 0; i < 12; i++) {
+        await new Promise((r) => setTimeout(r, 250));
+        if (isDaemonRunning()) break;
+      }
+      openBrowserLocal();
+      console.log(import_chalk4.default.green(`
+\u{1F6E1}\uFE0F  Node9 daemon started + browser opened`));
+      console.log(import_chalk4.default.gray(`   http://${DAEMON_HOST2}:${DAEMON_PORT2}/`));
+      process.exit(0);
+    }
+    if (options.background) {
+      const child = (0, import_child_process2.spawn)("node9", ["daemon"], { detached: true, stdio: "ignore" });
+      child.unref();
+      console.log(import_chalk4.default.green(`
+\u{1F6E1}\uFE0F  Node9 daemon started in background  (PID ${child.pid})`));
+      console.log(import_chalk4.default.gray(`   http://${DAEMON_HOST2}:${DAEMON_PORT2}/`));
+      console.log(import_chalk4.default.gray(`   node9 daemon status  \u2014 check if running`));
+      console.log(import_chalk4.default.gray(`   node9 daemon stop    \u2014 stop it
+`));
+      process.exit(0);
+    }
+    startDaemon();
+  }
+);
+program.command("check").description("Hook handler \u2014 evaluates a tool call before execution").argument("[data]", "JSON string of the tool call").action(async (data) => {
+  const processPayload = async (raw) => {
+    try {
+      if (!raw || raw.trim() === "") process.exit(0);
+      if (process.env.NODE9_DEBUG === "1") {
+        const logPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "hook-debug.log");
+        if (!import_fs4.default.existsSync(import_path4.default.dirname(logPath)))
+          import_fs4.default.mkdirSync(import_path4.default.dirname(logPath), { recursive: true });
+        import_fs4.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${raw}
+`);
+        import_fs4.default.appendFileSync(
+          logPath,
+          `[${(/* @__PURE__ */ new Date()).toISOString()}] TTY: ${process.stdout.isTTY}
+`
+        );
+      }
+      const payload = JSON.parse(raw);
+      const toolName = sanitize(payload.tool_name ?? payload.name ?? "");
+      const toolInput = payload.tool_input ?? payload.args ?? {};
+      const agent = payload.tool_name !== void 0 ? "Claude Code" : payload.name !== void 0 ? "Gemini CLI" : "Terminal";
+      const mcpMatch = toolName.match(/^mcp__([^_](?:[^_]|_(?!_))*?)__/i);
+      const mcpServer = mcpMatch?.[1];
+      const sendBlock = (msg, result2) => {
+        const BLOCKED_BY_LABELS = {
+          "team-policy": "team policy (set by your admin)",
+          "persistent-deny": "you set this tool to always deny",
+          "local-config": "your local config (dangerousWords / rules)",
+          "local-decision": "you denied it in the browser",
+          "no-approval-mechanism": "no approval method is configured"
+        };
+        console.error(import_chalk4.default.red(`
+\u{1F6D1} Node9 blocked "${toolName}"`));
+        if (result2?.blockedBy) {
+          console.error(
+            import_chalk4.default.gray(
+              `   Blocked by: ${BLOCKED_BY_LABELS[result2.blockedBy] ?? result2.blockedBy}`
+            )
+          );
+        }
+        if (result2?.changeHint) {
+          console.error(import_chalk4.default.cyan(`   To change:  ${result2.changeHint}`));
+        }
+        console.error("");
+        process.stdout.write(
+          JSON.stringify({
+            decision: "block",
+            reason: msg,
+            hookSpecificOutput: {
+              hookEventName: "PreToolUse",
+              permissionDecision: "deny",
+              permissionDecisionReason: msg
+            }
+          }) + "\n"
+        );
+        process.exit(0);
+      };
+      if (!toolName) {
+        sendBlock("Node9: unrecognised hook payload \u2014 tool name missing.");
+        return;
+      }
+      const meta = { agent, mcpServer };
+      const result = await authorizeHeadless(toolName, toolInput, false, meta);
+      if (result.approved) {
+        if (result.checkedBy) {
+          process.stderr.write(`\u2713 node9 [${result.checkedBy}]: "${toolName}" allowed
+`);
+        }
+        process.exit(0);
+      }
+      if (result.noApprovalMechanism && !isDaemonRunning() && !process.env.NODE9_NO_AUTO_DAEMON && !process.stdout.isTTY && getGlobalSettings().autoStartDaemon) {
+        console.error(import_chalk4.default.cyan("\n\u{1F6E1}\uFE0F  Node9: Starting approval daemon automatically..."));
+        const daemonReady = await autoStartDaemonAndWait();
+        if (daemonReady) {
+          const retry = await authorizeHeadless(toolName, toolInput, false, meta);
+          if (retry.approved) {
+            if (retry.checkedBy) {
+              process.stderr.write(`\u2713 node9 [${retry.checkedBy}]: "${toolName}" allowed
+`);
+            }
+            process.exit(0);
+          }
+          sendBlock(retry.reason ?? `Node9 blocked "${toolName}".`, retry);
+          return;
+        }
+      }
+      sendBlock(result.reason ?? `Node9 blocked "${toolName}".`, result);
+    } catch (err) {
+      if (process.env.NODE9_DEBUG === "1") {
+        const logPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "hook-debug.log");
+        const errMsg = err instanceof Error ? err.message : String(err);
+        import_fs4.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${errMsg}
+`);
+      }
+      process.exit(0);
+    }
+  };
+  if (data) {
+    await processPayload(data);
+  } else {
+    let raw = "";
+    let processed = false;
+    const done = async () => {
+      if (processed) return;
+      processed = true;
+      if (!raw.trim()) return process.exit(0);
+      await processPayload(raw);
+    };
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => raw += chunk);
+    process.stdin.on("end", () => void done());
+    setTimeout(() => void done(), 5e3);
+  }
+});
+program.command("log").description("PostToolUse hook \u2014 records executed tool calls").argument("[data]", "JSON string of the tool call").action(async (data) => {
+  const logPayload = (raw) => {
+    try {
+      if (!raw || raw.trim() === "") process.exit(0);
+      const payload = JSON.parse(raw);
+      const entry = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        tool: sanitize(payload.tool_name ?? "unknown"),
+        input: JSON.parse(redactSecrets(JSON.stringify(payload.tool_input || {})))
+      };
+      const logPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "audit.log");
+      if (!import_fs4.default.existsSync(import_path4.default.dirname(logPath)))
+        import_fs4.default.mkdirSync(import_path4.default.dirname(logPath), { recursive: true });
+      import_fs4.default.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+    } catch {
+    }
+    process.exit(0);
+  };
+  if (data) {
+    logPayload(data);
+  } else {
+    let raw = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => raw += chunk);
+    process.stdin.on("end", () => logPayload(raw));
+    setTimeout(() => {
+      if (!raw) process.exit(0);
+    }, 500);
+  }
+});
+var HOOK_BASED_AGENTS = {
+  claude: "claude",
+  gemini: "gemini",
+  cursor: "cursor"
+};
+program.argument("[command...]", "The agent command to run (e.g., gemini)").action(async (commandArgs) => {
+  if (commandArgs && commandArgs.length > 0) {
+    const firstArg = commandArgs[0].toLowerCase();
+    if (HOOK_BASED_AGENTS[firstArg] !== void 0) {
+      const target = HOOK_BASED_AGENTS[firstArg];
+      console.error(
+        import_chalk4.default.yellow(`
+\u26A0\uFE0F  Node9 proxy mode does not support "${target}" directly.`)
+      );
+      console.error(
+        import_chalk4.default.white(`
+   "${target}" is an interactive terminal app \u2014 it needs a real`)
+      );
+      console.error(
+        import_chalk4.default.white(`   TTY and communicates via its own hook system, not JSON-RPC.
+`)
+      );
+      console.error(import_chalk4.default.bold(`   Use the hook-based integration instead:
+`));
+      console.error(
+        import_chalk4.default.green(`     node9 addto ${target}   `) + import_chalk4.default.gray("# one-time setup")
+      );
+      console.error(
+        import_chalk4.default.green(`     ${target}              `) + import_chalk4.default.gray("# run normally \u2014 Node9 hooks fire automatically")
+      );
+      console.error(import_chalk4.default.white(`
+   For browser approval popups (no API key required):`));
+      console.error(
+        import_chalk4.default.green(`     node9 daemon --background`) + import_chalk4.default.gray("# start (no second terminal needed)")
+      );
+      console.error(
+        import_chalk4.default.green(`     ${target}              `) + import_chalk4.default.gray("# Node9 will open browser on dangerous actions\n")
+      );
+      process.exit(1);
+    }
+    const fullCommand = commandArgs.join(" ");
+    let result = await authorizeHeadless("shell", { command: fullCommand });
+    if (result.noApprovalMechanism && !isDaemonRunning() && !process.env.NODE9_NO_AUTO_DAEMON && getGlobalSettings().autoStartDaemon) {
+      console.error(import_chalk4.default.cyan("\n\u{1F6E1}\uFE0F  Node9: Starting approval daemon automatically..."));
+      const daemonReady = await autoStartDaemonAndWait();
+      if (daemonReady) result = await authorizeHeadless("shell", { command: fullCommand });
+    }
+    if (result.noApprovalMechanism && process.stdout.isTTY) {
+      result = await authorizeHeadless("shell", { command: fullCommand }, true);
+    }
+    if (!result.approved) {
+      console.error(
+        import_chalk4.default.red(`
+\u274C Node9 Blocked: ${result.reason || "Dangerous command detected."}`)
+      );
+      if (result.blockedBy) {
+        const BLOCKED_BY_LABELS = {
+          "team-policy": "Team policy (Node9 cloud)",
+          "persistent-deny": "Persistent deny rule",
+          "local-config": "Local config",
+          "local-decision": "Browser UI decision",
+          "no-approval-mechanism": "No approval mechanism available"
+        };
+        console.error(
+          import_chalk4.default.gray(`   Blocked by: ${BLOCKED_BY_LABELS[result.blockedBy] ?? result.blockedBy}`)
+        );
+      }
+      if (result.changeHint) {
+        console.error(import_chalk4.default.cyan(`   To change:  ${result.changeHint}`));
+      }
+      process.exit(1);
+    }
+    console.error(import_chalk4.default.green("\n\u2705 Approved \u2014 running command...\n"));
+    await runProxy(fullCommand);
+  } else {
+    program.help();
+  }
+});
+process.on("unhandledRejection", (reason) => {
+  const isCheckHook = process.argv[2] === "check";
+  if (isCheckHook) {
+    if (process.env.NODE9_DEBUG === "1") {
+      const logPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "hook-debug.log");
+      const msg = reason instanceof Error ? reason.message : String(reason);
+      import_fs4.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
+`);
+    }
+    process.exit(0);
+  } else {
+    console.error("[Node9] Unhandled error:", reason);
+    process.exit(1);
+  }
+});
+program.parse();