@agentwares/agentguard 0.1.7 → 0.1.9

package/dist/chunk-TW5KJREH.js

@@ -0,0 +1,190 @@
+// src/configs.ts
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { join, resolve } from "path";
+function candidateConfigs(cwd = process.cwd(), home = homedir(), env = process.env) {
+  const desktop = platform() === "darwin" ? join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") : platform() === "win32" ? join(
+    env.APPDATA ?? join(home, "AppData", "Roaming"),
+    "Claude",
+    "claude_desktop_config.json"
+  ) : join(
+    env.XDG_CONFIG_HOME ?? join(home, ".config"),
+    "Claude",
+    "claude_desktop_config.json"
+  );
+  return [
+    {
+      kind: "claude-code-project",
+      label: "Claude Code (project .mcp.json)",
+      path: join(cwd, ".mcp.json"),
+      serversKey: "mcpServers"
+    },
+    {
+      kind: "cursor-project",
+      label: "Cursor (project)",
+      path: join(cwd, ".cursor", "mcp.json"),
+      serversKey: "mcpServers"
+    },
+    {
+      kind: "vscode",
+      label: "VS Code (project)",
+      path: join(cwd, ".vscode", "mcp.json"),
+      serversKey: "servers"
+    },
+    { kind: "generic", label: "mcp.json", path: join(cwd, "mcp.json"), serversKey: "mcpServers" },
+    {
+      kind: "gemini-project",
+      label: "Gemini CLI (project .gemini/settings.json)",
+      path: join(cwd, ".gemini", "settings.json"),
+      serversKey: "mcpServers"
+    },
+    { kind: "claude-desktop", label: "Claude Desktop", path: desktop, serversKey: "mcpServers" },
+    {
+      kind: "cursor-user",
+      label: "Cursor (user)",
+      path: join(home, ".cursor", "mcp.json"),
+      serversKey: "mcpServers"
+    },
+    {
+      kind: "windsurf",
+      label: "Windsurf",
+      path: join(home, ".codeium", "windsurf", "mcp_config.json"),
+      serversKey: "mcpServers"
+    },
+    {
+      kind: "claude-code-user",
+      label: "Claude Code (user ~/.claude.json)",
+      path: join(home, ".claude.json"),
+      serversKey: "mcpServers"
+    },
+    {
+      kind: "gemini-user",
+      label: "Gemini CLI (user ~/.gemini/settings.json)",
+      path: join(home, ".gemini", "settings.json"),
+      serversKey: "mcpServers"
+    }
+  ];
+}
+function isGeminiConfig(file) {
+  return file.kind === "gemini-project" || file.kind === "gemini-user" || /[/\\]\.gemini[/\\]settings\.json$/.test(file.path);
+}
+function detectClientConfigs(cwd, home, env) {
+  return candidateConfigs(cwd, home, env).filter((c) => existsSync(c.path));
+}
+function describeConfigPath(path) {
+  const abs = resolve(path);
+  const known = candidateConfigs().find((c) => c.path === abs);
+  if (known) return known;
+  let serversKey = "mcpServers";
+  try {
+    const parsed = JSON.parse(readFileSync(abs, "utf8"));
+    if (parsed.servers && !parsed.mcpServers) serversKey = "servers";
+  } catch {
+  }
+  return {
+    kind: abs.includes(".vscode") ? "vscode" : "generic",
+    label: abs,
+    path: abs,
+    serversKey
+  };
+}
+function readServers(file) {
+  const raw = JSON.parse(readFileSync(file.path, "utf8"));
+  const servers = raw[file.serversKey];
+  if (!servers || typeof servers !== "object") return {};
+  return servers;
+}
+var PROXY_SERVER_NAME = "agentguard";
+var PROXY_PACKAGE = "@agentwares/agentguard";
+function isProxyEntry(entry) {
+  return (entry.args ?? []).some((a) => a === "agentguard" || /(^|\/)agentguard(\.js)?$/.test(a)) && (entry.args ?? []).includes("proxy");
+}
+function serversToUpstreams(servers) {
+  const upstreams = [];
+  const skipped = [];
+  for (const [rawName, entry] of Object.entries(servers)) {
+    if (isProxyEntry(entry)) {
+      skipped.push({ name: rawName, reason: "already the agentguard proxy" });
+      continue;
+    }
+    const name = rawName.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/^[^a-zA-Z0-9]+/, "") || "upstream";
+    const url = typeof entry.httpUrl === "string" ? entry.httpUrl : entry.url;
+    if (url) {
+      upstreams.push({
+        name,
+        url,
+        headers: entry.headers ?? {},
+        args: [],
+        env: {},
+        prefix: false,
+        timeout_ms: 6e4
+      });
+    } else if (entry.command) {
+      upstreams.push({
+        name,
+        command: entry.command,
+        args: entry.args ?? [],
+        env: entry.env ?? {},
+        cwd: entry.cwd,
+        headers: {},
+        prefix: false,
+        timeout_ms: 6e4
+      });
+    } else {
+      skipped.push({ name: rawName, reason: "no `command` or `url`" });
+    }
+  }
+  return { upstreams, skipped };
+}
+function backupPath(file) {
+  return `${file.path}.agentguard-backup`;
+}
+function proxyEntry(file, policyPath, opts = {}) {
+  const args = ["-y", PROXY_PACKAGE, "proxy", "--config", policyPath];
+  if (opts.agent) args.push("--agent", opts.agent);
+  const entry = { command: "npx", args };
+  if (file.serversKey === "servers") entry.type = "stdio";
+  return entry;
+}
+function rewriteClientConfig(file, policyPath, opts = {}) {
+  const raw = JSON.parse(readFileSync(file.path, "utf8"));
+  const servers = raw[file.serversKey] ?? {};
+  const replaced = Object.keys(servers).filter((n) => !isProxyEntry(servers[n]));
+  const backup = backupPath(file);
+  if (!existsSync(backup)) copyFileSync(file.path, backup);
+  raw[file.serversKey] = { [PROXY_SERVER_NAME]: proxyEntry(file, policyPath, opts) };
+  writeFileSync(file.path, JSON.stringify(raw, null, 2) + "\n");
+  return { backup, replaced };
+}
+function restoreClientConfig(file) {
+  const backup = backupPath(file);
+  if (!existsSync(backup)) return false;
+  copyFileSync(backup, file.path);
+  return true;
+}
+function mergeServerIntoConfig(file, name, entry) {
+  const raw = JSON.parse(readFileSync(file.path, "utf8"));
+  const servers = raw[file.serversKey] ?? {};
+  const replaced = name in servers;
+  const backup = backupPath(file);
+  if (!existsSync(backup)) copyFileSync(file.path, backup);
+  raw[file.serversKey] = { ...servers, [name]: entry };
+  writeFileSync(file.path, JSON.stringify(raw, null, 2) + "\n");
+  return { backup, replaced };
+}
+
+export {
+  candidateConfigs,
+  isGeminiConfig,
+  detectClientConfigs,
+  describeConfigPath,
+  readServers,
+  PROXY_SERVER_NAME,
+  PROXY_PACKAGE,
+  serversToUpstreams,
+  proxyEntry,
+  rewriteClientConfig,
+  restoreClientConfig,
+  mergeServerIntoConfig
+};
+//# sourceMappingURL=chunk-TW5KJREH.js.map

package/dist/chunk-TW5KJREH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/configs.ts"],"sourcesContent":["/**\n * Find the agent's existing MCP config (Claude Code, Claude Desktop, Cursor, VS Code, Windsurf,\n * Gemini CLI, generic `mcp.json`), read its servers, and rewrite it so every server goes through\n * the proxy.\n */\nimport { copyFileSync, existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { homedir, platform } from \"node:os\";\nimport { join, resolve } from \"node:path\";\nimport type { Upstream } from \"@agentwares/agentguard-core\";\n\nexport type ClientKind =\n  | \"claude-code-project\"\n  | \"claude-code-user\"\n  | \"claude-desktop\"\n  | \"cursor-project\"\n  | \"cursor-user\"\n  | \"vscode\"\n  | \"windsurf\"\n  | \"gemini-project\"\n  | \"gemini-user\"\n  | \"generic\";\n\nexport interface ClientConfigFile {\n  kind: ClientKind;\n  label: string;\n  path: string;\n  /** `mcpServers` (most clients) or `servers` (VS Code) */\n  serversKey: \"mcpServers\" | \"servers\";\n}\n\nexport interface ServerEntry {\n  type?: string;\n  command?: string;\n  args?: string[];\n  env?: Record<string, string>;\n  cwd?: string;\n  url?: string;\n  /** Gemini CLI's name for a Streamable HTTP endpoint (its `url` means SSE) */\n  httpUrl?: string;\n  headers?: Record<string, string>;\n  [k: string]: unknown;\n}\n\nexport function candidateConfigs(\n  cwd: string = process.cwd(),\n  home: string = homedir(),\n  env: NodeJS.ProcessEnv = process.env,\n): ClientConfigFile[] {\n  const desktop =\n    platform() === \"darwin\"\n      ? join(home, \"Library\", \"Application Support\", \"Claude\", \"claude_desktop_config.json\")\n      : platform() === \"win32\"\n        ? join(\n            env.APPDATA ?? join(home, \"AppData\", \"Roaming\"),\n            \"Claude\",\n            \"claude_desktop_config.json\",\n          )\n        : join(\n            env.XDG_CONFIG_HOME ?? join(home, \".config\"),\n            \"Claude\",\n            \"claude_desktop_config.json\",\n          );\n  return [\n    {\n      kind: \"claude-code-project\",\n      label: \"Claude Code (project .mcp.json)\",\n      path: join(cwd, \".mcp.json\"),\n      serversKey: \"mcpServers\",\n    },\n    {\n      kind: \"cursor-project\",\n      label: \"Cursor (project)\",\n      path: join(cwd, \".cursor\", \"mcp.json\"),\n      serversKey: \"mcpServers\",\n    },\n    {\n      kind: \"vscode\",\n      label: \"VS Code (project)\",\n      path: join(cwd, \".vscode\", \"mcp.json\"),\n      serversKey: \"servers\",\n    },\n    { kind: \"generic\", label: \"mcp.json\", path: join(cwd, \"mcp.json\"), serversKey: \"mcpServers\" },\n    {\n      kind: \"gemini-project\",\n      label: \"Gemini CLI (project .gemini/settings.json)\",\n      path: join(cwd, \".gemini\", \"settings.json\"),\n      serversKey: \"mcpServers\",\n    },\n    { kind: \"claude-desktop\", label: \"Claude Desktop\", path: desktop, serversKey: \"mcpServers\" },\n    {\n      kind: \"cursor-user\",\n      label: \"Cursor (user)\",\n      path: join(home, \".cursor\", \"mcp.json\"),\n      serversKey: \"mcpServers\",\n    },\n    {\n      kind: \"windsurf\",\n      label: \"Windsurf\",\n      path: join(home, \".codeium\", \"windsurf\", \"mcp_config.json\"),\n      serversKey: \"mcpServers\",\n    },\n    {\n      kind: \"claude-code-user\",\n      label: \"Claude Code (user ~/.claude.json)\",\n      path: join(home, \".claude.json\"),\n      serversKey: \"mcpServers\",\n    },\n    {\n      kind: \"gemini-user\",\n      label: \"Gemini CLI (user ~/.gemini/settings.json)\",\n      path: join(home, \".gemini\", \"settings.json\"),\n      serversKey: \"mcpServers\",\n    },\n  ];\n}\n\n/** Gemini CLI reads `httpUrl` for Streamable HTTP and `url` for SSE, unlike every other client. */\nexport function isGeminiConfig(file: ClientConfigFile): boolean {\n  return (\n    file.kind === \"gemini-project\" ||\n    file.kind === \"gemini-user\" ||\n    /[/\\\\]\\.gemini[/\\\\]settings\\.json$/.test(file.path)\n  );\n}\n\n/** Configs that exist on disk, project-level first. */\nexport function detectClientConfigs(\n  cwd?: string,\n  home?: string,\n  env?: NodeJS.ProcessEnv,\n): ClientConfigFile[] {\n  return candidateConfigs(cwd, home, env).filter((c) => existsSync(c.path));\n}\n\n/** Describe an explicit path the user passed with `--client`. */\nexport function describeConfigPath(path: string): ClientConfigFile {\n  const abs = resolve(path);\n  const known = candidateConfigs().find((c) => c.path === abs);\n  if (known) return known;\n  let serversKey: \"mcpServers\" | \"servers\" = \"mcpServers\";\n  try {\n    const parsed = JSON.parse(readFileSync(abs, \"utf8\")) as Record<string, unknown>;\n    if (parsed.servers && !parsed.mcpServers) serversKey = \"servers\";\n  } catch {\n    // unreadable: caller reports\n  }\n  return {\n    kind: abs.includes(\".vscode\") ? \"vscode\" : \"generic\",\n    label: abs,\n    path: abs,\n    serversKey,\n  };\n}\n\nexport function readServers(file: ClientConfigFile): Record<string, ServerEntry> {\n  const raw = JSON.parse(readFileSync(file.path, \"utf8\")) as Record<string, unknown>;\n  const servers = raw[file.serversKey];\n  if (!servers || typeof servers !== \"object\") return {};\n  return servers as Record<string, ServerEntry>;\n}\n\nexport const PROXY_SERVER_NAME = \"agentguard\";\n\n/** What `npx` is told to fetch. Must be the published package name. */\nexport const PROXY_PACKAGE = \"@agentwares/agentguard\";\n\nexport function isProxyEntry(entry: ServerEntry): boolean {\n  return (\n    (entry.args ?? []).some((a) => a === \"agentguard\" || /(^|\\/)agentguard(\\.js)?$/.test(a)) &&\n    (entry.args ?? []).includes(\"proxy\")\n  );\n}\n\n/** Client servers → policy upstreams. Names are sanitized; secrets stay where they were (in the config). */\nexport function serversToUpstreams(servers: Record<string, ServerEntry>): {\n  upstreams: Upstream[];\n  skipped: { name: string; reason: string }[];\n} {\n  const upstreams: Upstream[] = [];\n  const skipped: { name: string; reason: string }[] = [];\n  for (const [rawName, entry] of Object.entries(servers)) {\n    if (isProxyEntry(entry)) {\n      skipped.push({ name: rawName, reason: \"already the agentguard proxy\" });\n      continue;\n    }\n    const name =\n      rawName.replace(/[^a-zA-Z0-9_-]/g, \"-\").replace(/^[^a-zA-Z0-9]+/, \"\") || \"upstream\";\n    // `httpUrl` is Gemini CLI's Streamable HTTP field; agentguard reaches upstreams that way.\n    const url = typeof entry.httpUrl === \"string\" ? entry.httpUrl : entry.url;\n    if (url) {\n      upstreams.push({\n        name,\n        url,\n        headers: entry.headers ?? {},\n        args: [],\n        env: {},\n        prefix: false,\n        timeout_ms: 60_000,\n      });\n    } else if (entry.command) {\n      upstreams.push({\n        name,\n        command: entry.command,\n        args: entry.args ?? [],\n        env: entry.env ?? {},\n        cwd: entry.cwd,\n        headers: {},\n        prefix: false,\n        timeout_ms: 60_000,\n      });\n    } else {\n      skipped.push({ name: rawName, reason: \"no `command` or `url`\" });\n    }\n  }\n  return { upstreams, skipped };\n}\n\nexport function backupPath(file: ClientConfigFile): string {\n  return `${file.path}.agentguard-backup`;\n}\n\n/** The entry that replaces every server: one proxy, all upstreams behind it. */\nexport function proxyEntry(\n  file: ClientConfigFile,\n  policyPath: string,\n  opts: { agent?: string } = {},\n): ServerEntry {\n  // The published name, scope and all. `npx -y agentguard` 404s — that package does not\n  // exist — so every config this wrote failed to start the proxy, and the line printed next\n  // to it already said `npx @agentwares/agentguard proxy`. Worse than broken: the unscoped\n  // name is unclaimed, so anyone who took it would have their code run by our onboarding.\n  const args = [\"-y\", PROXY_PACKAGE, \"proxy\", \"--config\", policyPath];\n  if (opts.agent) args.push(\"--agent\", opts.agent);\n  const entry: ServerEntry = { command: \"npx\", args };\n  if (file.serversKey === \"servers\") entry.type = \"stdio\";\n  return entry;\n}\n\n/** Back up the file (once) and replace its servers with the single proxy entry. */\nexport function rewriteClientConfig(\n  file: ClientConfigFile,\n  policyPath: string,\n  opts: { agent?: string } = {},\n): { backup: string; replaced: string[] } {\n  const raw = JSON.parse(readFileSync(file.path, \"utf8\")) as Record<string, unknown>;\n  const servers = (raw[file.serversKey] as Record<string, ServerEntry> | undefined) ?? {};\n  const replaced = Object.keys(servers).filter((n) => !isProxyEntry(servers[n]!));\n  const backup = backupPath(file);\n  if (!existsSync(backup)) copyFileSync(file.path, backup);\n  raw[file.serversKey] = { [PROXY_SERVER_NAME]: proxyEntry(file, policyPath, opts) };\n  writeFileSync(file.path, JSON.stringify(raw, null, 2) + \"\\n\");\n  return { backup, replaced };\n}\n\n/** `agentguard init --undo`: restore the backup. */\nexport function restoreClientConfig(file: ClientConfigFile): boolean {\n  const backup = backupPath(file);\n  if (!existsSync(backup)) return false;\n  copyFileSync(backup, file.path);\n  return true;\n}\n\n/**\n * Add (or replace) one named server in a client config, leaving every other server alone.\n *\n * `rewriteClientConfig` is the `init` path: it replaces the whole server list with the local\n * proxy. `connect` is the opposite shape — the hosted proxy is one more remote server sitting\n * alongside whatever the client already has — so it merges instead of replacing. Both back the\n * file up once before touching it, so `init --undo` still restores either.\n */\nexport function mergeServerIntoConfig(\n  file: ClientConfigFile,\n  name: string,\n  entry: ServerEntry,\n): { backup: string; replaced: boolean } {\n  const raw = JSON.parse(readFileSync(file.path, \"utf8\")) as Record<string, unknown>;\n  const servers = (raw[file.serversKey] as Record<string, ServerEntry> | undefined) ?? {};\n  const replaced = name in servers;\n  const backup = backupPath(file);\n  if (!existsSync(backup)) copyFileSync(file.path, backup);\n  raw[file.serversKey] = { ...servers, [name]: entry };\n  writeFileSync(file.path, JSON.stringify(raw, null, 2) + \"\\n\");\n  return { backup, replaced };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-VQWQ5TOM.js

@@ -0,0 +1,113 @@
+import {
+  ProxyRuntime
+} from "./chunk-D66U3PVB.js";
+import {
+  flagBool,
+  loadPolicyFor
+} from "./chunk-SUXQTT3X.js";
+
+// src/commands/tools.ts
+import {
+  Guard,
+  classifyTool,
+  parsePolicy
+} from "@agentwares/agentguard-core";
+async function probeUpstreams(upstreams, opts = {}) {
+  const policy = opts.policy ?? parsePolicy({ upstreams });
+  const loaded = {
+    policy: { ...policy, upstreams },
+    path: "",
+    baseDir: process.cwd(),
+    stateDir: "",
+    auditPath: "",
+    killPath: ""
+  };
+  const guard = new Guard({ policy: loaded.policy, env: opts.env ?? {} });
+  const runtime = new ProxyRuntime({
+    loaded,
+    guard,
+    defaultRunId: "probe",
+    log: opts.log ?? (() => void 0),
+    connectTimeoutMs: opts.timeoutMs ?? 15e3
+  });
+  try {
+    await runtime.start();
+    return {
+      tools: runtime.listTools().map((t) => ({
+        upstream: t.upstream,
+        name: t.name,
+        tool: t.tool,
+        classification: classifyTool(
+          { name: t.name, annotations: t.tool.annotations },
+          loaded.policy
+        )
+      })),
+      upstreams: runtime.upstreamStatus()
+    };
+  } finally {
+    await runtime.close();
+  }
+}
+function formatToolTable(tools) {
+  const width = Math.min(48, Math.max(12, ...tools.map((t) => t.name.length)));
+  const lines = [
+    `${"tool".padEnd(width)}  ${"class".padEnd(8)}${"verb".padEnd(9)}${"upstream".padEnd(14)}why`
+  ];
+  for (const t of tools) {
+    const c = t.classification;
+    lines.push(
+      `${t.name.padEnd(width)}  ${c.class.padEnd(8)}${c.verb.padEnd(9)}${t.upstream.padEnd(14)}${c.source}: ${c.reason}`
+    );
+  }
+  return lines;
+}
+async function toolsCommand(args, io) {
+  const loaded = loadPolicyFor(args, io);
+  const result = await probeUpstreams(loaded.policy.upstreams, {
+    policy: loaded.policy,
+    log: io.err,
+    env: io.env
+  });
+  if (flagBool(args, "json")) {
+    io.out(
+      JSON.stringify(
+        {
+          upstreams: result.upstreams,
+          tools: result.tools.map((t) => ({
+            name: t.name,
+            upstream: t.upstream,
+            ...t.classification
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  for (const u of result.upstreams)
+    io.err(
+      `${u.connected ? "ok  " : "down"} ${u.name}: ${u.connected ? `${u.tools} tools` : u.error}`
+    );
+  if (result.upstreams.length === 0)
+    io.err(
+      "no upstreams in the policy: an MCP client sees agentguard's own read-only tools instead (agentguard_get_status, agentguard_get_report, agentguard_verify_audit_log)"
+    );
+  for (const line of formatToolTable(result.tools)) io.out(line);
+  const counts = result.tools.reduce(
+    (acc, t) => ({ ...acc, [t.classification.class]: (acc[t.classification.class] ?? 0) + 1 }),
+    {}
+  );
+  io.err(
+    `
+${result.tools.length} tools: ${Object.entries(counts).map(([k, v]) => `${v} ${k}`).join(", ")} \xB7 mode ${loaded.policy.mode}`
+  );
+  return result.upstreams.every((u) => u.connected) ? 0 : 2;
+}
+
+export {
+  probeUpstreams,
+  formatToolTable,
+  toolsCommand
+};
+//# sourceMappingURL=chunk-VQWQ5TOM.js.map

package/dist/chunk-VQWQ5TOM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/tools.ts"],"sourcesContent":["/**\n * `agentguard tools` — connect to every upstream and print the tools the agent will see,\n * with their class and why. Also the probe `init` uses to seed the policy.\n */\nimport {\n  Guard,\n  classifyTool,\n  parsePolicy,\n  type Classification,\n  type Policy,\n  type Upstream,\n} from \"@agentwares/agentguard-core\";\nimport type { LoadedPolicy } from \"@agentwares/agentguard-core/node\";\nimport type { Tool } from \"@modelcontextprotocol/sdk/types.js\";\nimport { ProxyRuntime } from \"../proxy/runtime.js\";\nimport { loadPolicyFor, type Io } from \"../context.js\";\nimport type { ParsedArgs } from \"../args.js\";\nimport { flagBool } from \"../args.js\";\n\nexport interface ProbedTool {\n  upstream: string;\n  name: string;\n  tool: Tool;\n  classification: Classification;\n}\n\nexport interface ProbeResult {\n  tools: ProbedTool[];\n  upstreams: { name: string; connected: boolean; tools: number; error?: string }[];\n}\n\n/** Connect to the upstreams (with a policy for classification), list tools, disconnect. */\nexport async function probeUpstreams(\n  upstreams: Upstream[],\n  opts: {\n    policy?: Policy;\n    timeoutMs?: number;\n    log?: (l: string) => void;\n    env?: NodeJS.ProcessEnv;\n  } = {},\n): Promise<ProbeResult> {\n  const policy = opts.policy ?? parsePolicy({ upstreams });\n  const loaded: LoadedPolicy = {\n    policy: { ...policy, upstreams },\n    path: \"\",\n    baseDir: process.cwd(),\n    stateDir: \"\",\n    auditPath: \"\",\n    killPath: \"\",\n  };\n  const guard = new Guard({ policy: loaded.policy, env: opts.env ?? {} });\n  const runtime = new ProxyRuntime({\n    loaded,\n    guard,\n    defaultRunId: \"probe\",\n    log: opts.log ?? (() => undefined),\n    connectTimeoutMs: opts.timeoutMs ?? 15_000,\n  });\n  try {\n    await runtime.start();\n    return {\n      tools: runtime.listTools().map((t) => ({\n        upstream: t.upstream,\n        name: t.name,\n        tool: t.tool,\n        classification: classifyTool(\n          { name: t.name, annotations: t.tool.annotations },\n          loaded.policy,\n        ),\n      })),\n      upstreams: runtime.upstreamStatus(),\n    };\n  } finally {\n    await runtime.close();\n  }\n}\n\nexport function formatToolTable(tools: ProbedTool[]): string[] {\n  const width = Math.min(48, Math.max(12, ...tools.map((t) => t.name.length)));\n  const lines = [\n    `${\"tool\".padEnd(width)}  ${\"class\".padEnd(8)}${\"verb\".padEnd(9)}${\"upstream\".padEnd(14)}why`,\n  ];\n  for (const t of tools) {\n    const c = t.classification;\n    lines.push(\n      `${t.name.padEnd(width)}  ${c.class.padEnd(8)}${c.verb.padEnd(9)}${t.upstream.padEnd(14)}${c.source}: ${c.reason}`,\n    );\n  }\n  return lines;\n}\n\nexport async function toolsCommand(args: ParsedArgs, io: Io): Promise<number> {\n  const loaded = loadPolicyFor(args, io);\n  const result = await probeUpstreams(loaded.policy.upstreams, {\n    policy: loaded.policy,\n    log: io.err,\n    env: io.env,\n  });\n  if (flagBool(args, \"json\")) {\n    io.out(\n      JSON.stringify(\n        {\n          upstreams: result.upstreams,\n          tools: result.tools.map((t) => ({\n            name: t.name,\n            upstream: t.upstream,\n            ...t.classification,\n          })),\n        },\n        null,\n        2,\n      ),\n    );\n    return 0;\n  }\n  for (const u of result.upstreams)\n    io.err(\n      `${u.connected ? \"ok  \" : \"down\"} ${u.name}: ${u.connected ? `${u.tools} tools` : u.error}`,\n    );\n  if (result.upstreams.length === 0)\n    io.err(\n      \"no upstreams in the policy: an MCP client sees agentguard's own read-only tools instead (agentguard_get_status, agentguard_get_report, agentguard_verify_audit_log)\",\n    );\n  for (const line of formatToolTable(result.tools)) io.out(line);\n  const counts = result.tools.reduce<Record<string, number>>(\n    (acc, t) => ({ ...acc, [t.classification.class]: (acc[t.classification.class] ?? 0) + 1 }),\n    {},\n  );\n  io.err(\n    `\\n${result.tools.length} tools: ${Object.entries(counts)\n      .map(([k, v]) => `${v} ${k}`)\n      .join(\", \")} · mode ${loaded.policy.mode}`,\n  );\n  return result.upstreams.every((u) => u.connected) ? 0 : 2;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-X4M7YWQA.js

@@ -0,0 +1,270 @@
+import {
+  probeUpstreams
+} from "./chunk-VQWQ5TOM.js";
+import {
+  describeConfigPath,
+  detectClientConfigs,
+  readServers,
+  restoreClientConfig,
+  rewriteClientConfig,
+  serversToUpstreams
+} from "./chunk-TW5KJREH.js";
+import {
+  flagBool,
+  flagString,
+  homeFrom,
+  policyPathFrom
+} from "./chunk-SUXQTT3X.js";
+
+// src/commands/init.ts
+import { existsSync, writeFileSync } from "fs";
+import { relative, resolve } from "path";
+import YAML from "yaml";
+function dump(value, indent = 0) {
+  const text = YAML.stringify(value, { indent: 2, lineWidth: 100 }).trimEnd();
+  const pad = " ".repeat(indent);
+  return text.split("\n").map((l) => pad + l).join("\n");
+}
+function flow(list) {
+  return list.length === 0 ? "[]" : `[${list.map((s) => JSON.stringify(s)).join(", ")}]`;
+}
+function renderStarterPolicy(opts) {
+  const tools = opts.tools ?? [];
+  const unknown = tools.filter((t) => t.classification.class === "unknown").map((t) => t.name);
+  const destructive = tools.filter((t) => t.classification.destructive || t.classification.verb === "delete").map((t) => t.name);
+  const spend = tools.filter((t) => t.classification.class === "spend").map((t) => t.name);
+  const date = (opts.generatedAt ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const counts = tools.reduce(
+    (acc, t) => ({ ...acc, [t.classification.class]: (acc[t.classification.class] ?? 0) + 1 }),
+    {}
+  );
+  const detected = tools.length === 0 ? ["#   (no upstreams probed \u2014 run `agentguard tools` after fixing the upstreams above)"] : tools.map(
+    (t) => `#   ${t.name.padEnd(36)} ${t.classification.class.padEnd(8)} ${t.classification.verb.padEnd(8)} ${t.classification.source}: ${t.classification.reason}`
+  );
+  const probeNotes = (opts.probeErrors ?? []).map((e) => `#   ! ${e}`);
+  const upstreamsYaml = opts.upstreams.length ? dump({ upstreams: opts.upstreams.map(cleanUpstream) }) : 'upstreams: []\n  # - name: crm\n  #   url: https://mcp.example.com/mcp\n  #   auth: ${CRM_TOKEN}\n  # - name: files\n  #   command: npx\n  #   args: [-y, "@modelcontextprotocol/server-filesystem", "."]';
+  return `# agentguard.yaml \u2014 generated by \`agentguard init\` on ${date}
+# Every knob is explained inline. Docs: https://github.com/agentwares/agentguard/tree/main/apps/agentguard-cli#policy
+version: 1
+
+# dry-run: reads pass through; writes and spends are FAKED (plausible success, nothing executes)
+# and recorded. Run your agent once, then \`agentguard report\` and \`agentguard diff\`.
+# Flip to \`enforce\` when the diff looks right. Caps and the loop breaker apply in both modes.
+mode: ${opts.mode ?? "dry-run"}
+
+# The servers your agent used to talk to directly. agentguard connects to them and holds their
+# credentials; your agent only talks to agentguard. Use \${ENV_VAR} for secrets.
+${upstreamsYaml}
+
+# Detected tools (${tools.length}${tools.length ? `: ${Object.entries(counts).map(([k, v]) => `${v} ${k}`).join(", ")}` : ""}):
+${[...detected, ...probeNotes].join("\n")}
+# readOnlyHint annotations and verb heuristics classify most tools. List anything that is wrong here;
+# these patterns win over annotations. \`*\` matches anything.
+classify:
+  read: []
+  write: ${flow(unknown)}${unknown.length ? "   # could not be classified \u2014 treated as writes; move to read: if they only read" : ""}
+  spend: ${flow(spend)}
+  unknown: write   # a tool nobody can classify counts as a write (alternatives: read | block)
+
+# Blast-radius caps. The call that would exceed a cap gets CAP_EXCEEDED with the remaining budget.
+# \`writes\` counts every write or spend; \`deletes\`/\`emails\` count the subsets matched by \`counters\`.
+caps:
+  per_run:
+    tool_calls: 400
+    writes: 50
+    deletes: 10
+    emails: 5
+    spend_usd: 25
+  per_day:
+    spend_usd: 200
+
+# Dollar amounts. Declare how to read the amount from a spend tool's arguments; results reporting
+# cost_usd / amount_usd are picked up automatically. Unknown spend tools cost \`default_usd\`.
+spend:
+  tools: {}
+  #  stripe_create_charge: { amount_arg: amount, divisor: 100, currency_arg: currency }
+  #  openai_*: { fixed_usd: 0.01 }
+  default_usd: 0
+
+# Semantic loop breaker: the same (tool, normalized arguments) ${3} times in the last 30 calls, or a
+# repeating A\u2192B\u2192A\u2192B cycle, returns LOOP_DETECTED. Timestamps, ids and whitespace are ignored.
+loop:
+  window: 30
+  max_repeats: 3
+  max_cycle_len: 4
+  max_read_repeats: 10
+
+# Always fake these, even in enforce mode. Remove entries as you gain trust.
+dry_run:
+  tools: []
+  synthesize: true
+
+# Destructive actions that need a human. The agent gets APPROVAL_REQUIRED with an id; you run
+# \`agentguard approve <id>\` (or click the link in Slack); the agent retries the identical call once.
+approval:
+  tools: ${flow(destructive)}
+  wait_s: 0          # > 0 holds the call open this long waiting for the decision
+  ttl_s: 3600
+  # notify:
+  #   slack: \${SLACK_WEBHOOK_URL}
+
+# Kill switch: \`agentguard kill\` creates this file (or POST /kill on the HTTP proxy); every call
+# returns KILLED until \`agentguard resume\`. AGENTGUARD_KILL=1 in the environment does the same.
+kill:
+  file: .agentguard/KILL
+
+# Scoped agent keys for the HTTP proxy: \`agentguard key create deployer --allow 'crm_get_*'\`.
+# Only the key's hash is stored here; the agent sends the key as a Bearer token.
+agents: []
+
+# Alerts on halts (Slack incoming webhook or any HTTPS endpoint; signed with X-Agentwares-Signature).
+# alerts:
+#   slack: \${SLACK_WEBHOOK_URL}
+#   on: [LOOP_DETECTED, CAP_EXCEEDED, KILLED, APPROVAL_REQUIRED]
+
+# Hash-chained JSONL of every call; \`agentguard verify\` proves it was not edited.
+audit:
+  path: .agentguard/audit.jsonl
+  redact: true
+  include_results: false
+`;
+}
+function cleanUpstream(u) {
+  const out = { name: u.name };
+  if (u.url) {
+    out.url = u.url;
+    if (Object.keys(u.headers).length) out.headers = u.headers;
+  } else {
+    out.command = u.command;
+    if (u.args.length) out.args = u.args;
+    if (Object.keys(u.env).length) out.env = u.env;
+    if (u.cwd) out.cwd = u.cwd;
+  }
+  return out;
+}
+async function initCommand(args, io) {
+  const policyPath = policyPathFrom(args, io);
+  const explicit = flagString(args, "client");
+  const configs = explicit ? [describeConfigPath(resolve(io.cwd, explicit))] : detectClientConfigs(io.cwd, homeFrom(io), io.env);
+  const rel = (p) => {
+    const r = relative(io.cwd, p);
+    return r.startsWith("..") ? p : r || ".";
+  };
+  if (flagBool(args, "undo")) {
+    let restored = 0;
+    for (const c of configs) {
+      if (restoreClientConfig(c)) {
+        io.out(`restored ${rel(c.path)} from backup`);
+        restored += 1;
+      }
+    }
+    if (restored === 0)
+      io.err("nothing to undo (no *.agentguard-backup files next to your MCP configs)");
+    return 0;
+  }
+  const projectLevel = configs.filter((c) => c.path.startsWith(io.cwd + "/"));
+  const userLevel = configs.filter((c) => !projectLevel.includes(c));
+  let chosen;
+  if (explicit) chosen = configs;
+  else if (flagBool(args, "all")) chosen = configs;
+  else chosen = projectLevel.slice(0, 1);
+  if (!explicit && !flagBool(args, "all")) {
+    for (const c of userLevel)
+      io.out(
+        `found   ${c.path} (${c.label}, user-level) \u2014 not touched; pass --client ${JSON.stringify(c.path)} to route it through agentguard`
+      );
+  }
+  if (!chosen.every((c) => existsSync(c.path))) {
+    io.err(`no MCP config at ${chosen.map((c) => c.path).join(", ")}`);
+    return 1;
+  }
+  const servers = {};
+  for (const c of chosen) {
+    const found = readServers(c);
+    io.out(
+      `found   ${rel(c.path)} (${c.label}) \u2192 ${Object.keys(found).length} server${Object.keys(found).length === 1 ? "" : "s"}: ${Object.keys(found).join(", ") || "none"}`
+    );
+    for (const [name, entry] of Object.entries(found))
+      if (!(name in servers)) servers[name] = entry;
+  }
+  if (chosen.length === 0)
+    io.out(
+      "found   no MCP config (Claude Code .mcp.json, Cursor, VS Code, Claude Desktop, Windsurf, Gemini CLI) \u2014 writing a policy with no upstreams"
+    );
+  const { upstreams, skipped } = serversToUpstreams(servers);
+  for (const s of skipped) io.err(`skipped ${s.name}: ${s.reason}`);
+  if (skipped.some((s) => s.reason.includes("already")) && upstreams.length === 0 && existsSync(policyPath)) {
+    io.out(
+      `already initialized: ${rel(policyPath)} exists and ${chosen.map((c) => rel(c.path)).join(", ")} already points at agentguard`
+    );
+    return 0;
+  }
+  let probed = [];
+  const probeErrors = [];
+  if (flagBool(args, "probe") !== false && upstreams.length > 0) {
+    io.out(`probing ${upstreams.length} upstream${upstreams.length === 1 ? "" : "s"}\u2026`);
+    const result = await probeUpstreams(upstreams, {
+      log: () => void 0,
+      env: io.env,
+      timeoutMs: 2e4
+    });
+    probed = result.tools;
+    for (const u of result.upstreams) {
+      if (u.connected) io.out(`        ${u.name}: ${u.tools} tools`);
+      else {
+        io.err(
+          `        ${u.name}: could not connect (${u.error}) \u2014 the proxy will keep retrying at start; fix the entry in agentguard.yaml`
+        );
+        probeErrors.push(`${u.name}: ${u.error}`);
+      }
+    }
+  }
+  const mode = flagString(args, "mode") ?? "dry-run";
+  if (existsSync(policyPath) && !flagBool(args, "force")) {
+    io.out(`kept    ${rel(policyPath)} (exists; pass --force to regenerate)`);
+  } else {
+    writeFileSync(policyPath, renderStarterPolicy({ upstreams, tools: probed, mode, probeErrors }));
+    const counts = probed.reduce(
+      (acc, t) => ({ ...acc, [t.classification.class]: (acc[t.classification.class] ?? 0) + 1 }),
+      {}
+    );
+    io.out(
+      `wrote   ${rel(policyPath)} (mode: ${mode}, ${upstreams.length} upstream${upstreams.length === 1 ? "" : "s"}${probed.length ? `, ${probed.length} tools: ${Object.entries(counts).map(([k, v]) => `${v} ${k}`).join(", ")}` : ""})`
+    );
+  }
+  if (flagBool(args, "rewrite") !== false) {
+    for (const c of chosen) {
+      if (resolve(c.path) === resolve(policyPath)) {
+        throw new Error(
+          `refusing: ${rel(c.path)} is both the policy file (--config) and a client config. Rewriting it would replace the policy with the proxy entry and leave the proxy pointing at itself. Use --config for the policy path and --client for the client's config, or let --config default to agentguard.yaml.`
+        );
+      }
+      const { backup, replaced } = rewriteClientConfig(c, policyPath, {
+        agent: flagString(args, "agent")
+      });
+      io.out(
+        `rewrote ${rel(c.path)} \u2192 ${replaced.length ? `${replaced.join(", ")} now go through` : "points at"} \`npx @agentwares/agentguard proxy\` (backup: ${rel(backup)})`
+      );
+    }
+  }
+  io.out("");
+  io.out("Next:");
+  io.out(
+    `  1. restart your MCP client so it re-reads ${chosen.map((c) => rel(c.path)).join(", ") || "its config"}`
+  );
+  io.out(
+    `  2. run your agent once \u2014 ${mode === "dry-run" ? "writes are faked; nothing executes upstream" : "enforce mode: caps, loop breaker and approvals are live"}`
+  );
+  io.out("  3. agentguard report        # what this run would have destroyed / spent");
+  io.out("     agentguard diff          # the record-by-record mutation diff");
+  if (mode === "dry-run")
+    io.out(`  4. set \`mode: enforce\` in ${rel(policyPath)} when it looks right`);
+  io.out("  undo any time: agentguard init --undo");
+  return 0;
+}
+
+export {
+  renderStarterPolicy,
+  initCommand
+};
+//# sourceMappingURL=chunk-X4M7YWQA.js.map