@agentwares/agentguard 0.1.2 → 0.1.4

package/dist/cli.js

@@ -805,9 +805,6 @@ var require_dist = __commonJS({
   }
 });
 
-// src/cli.ts
-import { readFileSync as readFileSync4 } from "fs";
-
 // src/args.ts
 var VALUE_FLAGS = /* @__PURE__ */ new Set([
   "config",
@@ -914,6 +911,19 @@ function flagNumber(args, name) {
   return Number.isFinite(n) ? n : void 0;
 }
 
+// src/version.ts
+import { readFileSync } from "fs";
+var cached;
+function version() {
+  if (cached !== void 0) return cached;
+  try {
+    cached = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+  } catch {
+    cached = "0.0.0";
+  }
+  return cached;
+}
+
 // src/context.ts
 import { existsSync as existsSync2 } from "fs";
 import { resolve } from "path";
@@ -925,9 +935,9 @@ import {
   FileStateStore,
   loadPolicyFile
 } from "@agentwares/agentguard-core/node";
-import { existsSync as exists, readFileSync } from "fs";
+import { existsSync as exists, readFileSync as readFileSync2 } from "fs";
 
-// ../../packages/mcp-kit/dist/chunk-AO7AV7MI.js
+// ../../packages/mcp-kit/dist/chunk-7LRFDQNC.js
 import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import {
@@ -939,6 +949,19 @@ import {
 import { z } from "zod";
 
 // ../../packages/x402/dist/index.js
+var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var USDC_DECIMALS = 6;
+var USDC_EIP712_DOMAIN = { name: "USD Coin", version: "2" };
+function toAtomicUnits(amountUsd, decimals = USDC_DECIMALS) {
+  const trimmed = amountUsd.trim();
+  if (!/^\d+(\.\d+)?$/.test(trimmed)) throw new Error(`not a decimal amount: ${amountUsd}`);
+  const [whole = "0", fraction = ""] = trimmed.split(".");
+  if (fraction.length > decimals) {
+    throw new Error(`${amountUsd} has more than ${decimals} decimal places`);
+  }
+  return `${whole}${fraction.padEnd(decimals, "0")}`.replace(/^0+(?=\d)/, "");
+}
+var DEFAULT_X402_NETWORK = "eip155:8453";
 var X402_HEADER = "X-Payment-Requirements";
 var X402_REQUIRED_HEADER = "PAYMENT-REQUIRED";
 function toAmount(priceUsd) {
@@ -948,42 +971,69 @@ function toAmount(priceUsd) {
 }
 function buildPaymentRequired(opts) {
   const amountUsd = toAmount(opts.priceUsd);
-  const accepts = [
-    {
+  const creditsPayTo = opts.creditsPayTo ?? opts.selfServe?.keysUrl;
+  const accepts = [];
+  if (opts.payTo) {
+    accepts.push({
       rail: "x402",
+      scheme: "exact",
       amountUsd,
+      amount: toAtomicUnits(amountUsd, opts.assetDecimals),
       resource: opts.resource,
       description: opts.description,
-      network: "eip155:8453",
-      asset: "USDC",
+      mimeType: "application/json",
+      network: opts.network ?? DEFAULT_X402_NETWORK,
+      asset: opts.asset ?? USDC_BASE,
+      extra: opts.assetDomain ?? USDC_EIP712_DOMAIN,
       payTo: opts.payTo,
-      maxTimeoutSeconds: 300
-    },
-    {
-      rail: "mpp",
+      maxTimeoutSeconds: 300,
+      ...opts.bazaar ? { bazaar: opts.bazaar } : {}
+    });
+  }
+  if (creditsPayTo) {
+    accepts.push({
+      rail: "prepaid_credits",
       amountUsd,
       resource: opts.resource,
       description: opts.description,
       currency: "usd",
-      payTo: opts.payTo,
-      maxTimeoutSeconds: 300
-    }
-  ];
+      payTo: creditsPayTo,
+      maxTimeoutSeconds: 300,
+      // funding a balance ends at a hosted Stripe Checkout page, which an agent cannot fill in
+      humanRequired: true
+    });
+  }
   const live = opts.live === true;
+  const selfServe = opts.selfServe;
+  const x402Rail = accepts.find((a) => a.rail === "x402" && a.payTo);
+  const usdcFix = x402Rail ? `Pay in USDC with no account and no human: take the \`accepts\` entry with \`rail: "x402"\`, sign an EIP-3009 transferWithAuthorization for ${x402Rail.amountUsd} USDC to ${x402Rail.payTo} on ${x402Rail.network}, and retry with it base64 in the X-PAYMENT header. The facilitator submits the transfer, so you need USDC and no gas. ` : "";
+  const sampleFix = opts.sampleMode ? "Free first: retry with sample=true \u2014 no key, no payment. " : "";
+  const cardFix = selfServe ? `Or pay by card: POST ${selfServe.keysUrl} (no auth, no signup) returns a key and a Stripe Checkout URL. Funding that key needs a person at a browser; if you are running unattended, surface the URL to your operator rather than retrying, or use the USDC rail above. Once funded, send Authorization: Bearer <key>, plus Idempotency-Key so a repeated call is charged once.` : "";
+  const liveFix = usdcFix || cardFix ? `${sampleFix}${usdcFix}${cardFix}`.trim() : "Retry with a PAYMENT header satisfying one of `accepts`, or send an API key with credit balance.";
   const body = {
     code: "PAYMENT_REQUIRED",
     cause: live ? `This call costs $${amountUsd}. No valid payment or credit was presented.` : `This call costs $${amountUsd}. Pay-per-call (x402 / Stripe MPP) is coming soon; use an API key with prepaid credits.`,
-    fix: live ? "Retry with a PAYMENT header satisfying one of `accepts`, or send an API key with credit balance." : `Create an API key${opts.signupUrl ? ` at ${opts.signupUrl}` : ""} and retry with Authorization: Bearer <key>. Try the free sample mode first.`,
+    fix: live ? liveFix : `Create an API key${opts.signupUrl ? ` at ${opts.signupUrl}` : ""} and retry with Authorization: Bearer <key>. Try the free sample mode first.`,
     retryable: true,
     priceUsd: opts.priceUsd,
     accepts,
     comingSoon: !live,
-    alternatives: ["api_key_credits", "sample_mode"]
+    alternatives: [
+      ...creditsPayTo ? ["api_key_credits"] : [],
+      ...opts.sampleMode ? ["sample_mode"] : []
+    ],
+    ...selfServe ? { selfServe } : {},
+    ...opts.bazaar ? { extensions: { bazaar: opts.bazaar } } : {}
   };
-  const encoded = JSON.stringify({ x402Version: 2, accepts, resource: opts.resource });
+  const encoded = JSON.stringify({
+    x402Version: 2,
+    accepts,
+    resource: opts.resource,
+    ...opts.bazaar ? { extensions: { bazaar: opts.bazaar } } : {}
+  });
   const headers = {
     "Content-Type": "application/json",
-    "WWW-Authenticate": `Payment realm="agentwares", methods="x402 mpp", price="${amountUsd} USD"`,
+    "WWW-Authenticate": `Payment realm="agentwares", methods="x402 prepaid_credits", price="${amountUsd} USD"`,
     [X402_HEADER]: encoded,
     [X402_REQUIRED_HEADER]: btoa(encoded),
     "Cache-Control": "no-store"
@@ -1001,7 +1051,7 @@ var StubVerifier = class {
   }
 };
 
-// ../../packages/mcp-kit/dist/chunk-AO7AV7MI.js
+// ../../packages/mcp-kit/dist/chunk-7LRFDQNC.js
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -1183,13 +1233,13 @@ function defineTool(opts) {
     annotations,
     handler,
     async invoke(rawInput, ctx) {
-      const fail = (err) => {
+      const fail2 = (err) => {
         const result = errorResult(err, { requestId: ctx.requestId });
         if (output) delete result.structuredContent;
         return result;
       };
       const parsed = input.safeParse(rawInput ?? {});
-      if (!parsed.success) return fail(invalidInputError(parsed.error.issues));
+      if (!parsed.success) return fail2(invalidInputError(parsed.error.issues));
       try {
         const value = await handler(parsed.data, ctx);
         if (output && !isCallToolResult(value)) {
@@ -1207,7 +1257,7 @@ function defineTool(opts) {
         }
         return toCallToolResult(value);
       } catch (err) {
-        return fail(err);
+        return fail2(err);
       }
     }
   };
@@ -1448,6 +1498,7 @@ function withPayment(tool, opts) {
     );
   }
   const verifier = opts.verifier ?? new StubVerifier();
+  const liveRail = opts.verifier !== void 0;
   const input = tool.input.extend({
     [sampleField]: z2.boolean().default(false).describe(
       "Set true to return an example response at no charge (sample mode). Default false."
@@ -1472,23 +1523,46 @@ function withPayment(tool, opts) {
         if (auth.ok) return tool.handler(record, { ...ctx, userId: auth.userId });
         reason = auth.reason;
       }
+      const resource = ctx.resourceUrl ?? tool.name;
       const required = buildPaymentRequired({
-        resource: tool.name,
+        resource,
         priceUsd: opts.priceUsd,
         live: opts.live,
         description: opts.description,
         payTo: opts.payTo,
-        signupUrl: opts.signupUrl
+        creditsPayTo: opts.creditsPayTo,
+        signupUrl: opts.signupUrl,
+        selfServe: opts.selfServe,
+        // withPayment always adds a free `sample` flag to the tool's input schema
+        sampleMode: true,
+        ...opts.bazaar ? { bazaar: opts.bazaar } : {}
       });
-      const requirement = required.body.accepts[0];
-      if (requirement) {
-        const verified = await verifier.verify(
-          new Request(`https://mcp.local/${tool.name}`, { headers: ctx.headers }),
-          requirement
-        );
-        if (verified.ok) return tool.handler(record, ctx);
-        reason = reason ?? verified.reason;
+      const advertised = required.body.accepts.find((a) => a.rail === "prepaid_credits") ?? required.body.accepts[0];
+      const requirement = advertised ?? {
+        rail: "prepaid_credits",
+        amountUsd: String(required.body.priceUsd),
+        resource,
+        ...opts.description ? { description: opts.description } : {}
+      };
+      const verified = await verifier.verify(
+        new Request(`https://mcp.local/${tool.name}`, { headers: ctx.headers }),
+        requirement
+      );
+      if (verified.ok) {
+        let result;
+        try {
+          result = await tool.handler(record, ctx);
+        } catch (error) {
+          await opts.onPaidFailure?.(ctx, verified, error);
+          throw error;
+        }
+        const settled = await verifier.settle?.(verified);
+        if (settled && !settled.ok) {
+          opts.onSettlementFailure?.(ctx, verified, settled.reason);
+        }
+        return result;
       }
+      reason = liveRail ? verified.reason ?? reason : reason ?? verified.reason;
       throw paymentRequiredError(required.body, reason);
     }
   });
@@ -1881,7 +1955,7 @@ import {
   keyFromHeaders,
   resolveAgent
 } from "@agentwares/agentguard-core";
-var PROXY_VERSION = "0.1.0";
+var PROXY_VERSION = version();
 function headerValue(extra, name) {
   const raw = extra.requestInfo?.headers?.[name] ?? extra.requestInfo?.headers?.[name.toLowerCase()];
   if (Array.isArray(raw)) return raw[0];
@@ -2355,8 +2429,8 @@ var MAX_HEADERS_SIZE = 2 * 1024 * 1024;
 
 // ../../node_modules/.pnpm/resend@6.25.0/node_modules/resend/dist/index.mjs
 var import_standardwebhooks = __toESM(require_dist(), 1);
-var version = "6.25.0";
-var defaultUserAgent = `resend-node:${version}`;
+var version2 = "6.25.0";
+var defaultUserAgent = `resend-node:${version2}`;
 
 // ../../packages/notify/dist/index.js
 var palette = {
@@ -2600,7 +2674,7 @@ function readRegistration(loaded) {
   const file = registrationPath(loaded.stateDir);
   if (!exists(file)) return void 0;
   try {
-    const reg = JSON.parse(readFileSync(file, "utf8"));
+    const reg = JSON.parse(readFileSync2(file, "utf8"));
     return reg;
   } catch {
     return void 0;
@@ -2615,104 +2689,12 @@ function describeError(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// src/commands/control.ts
-async function pokeHttp(io, reg, path, body) {
-  if (!reg) return;
-  try {
-    const res = await fetch(`${reg.baseUrl}${path}`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${reg.token}`, "Content-Type": "application/json" },
-      body: body === void 0 ? void 0 : JSON.stringify(body),
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (!res.ok)
-      io.err(
-        `running proxy at ${reg.baseUrl} answered ${res.status} (the file switch still applies)`
-      );
-  } catch {
-    io.err(
-      `no proxy answering at ${reg.baseUrl} (stale ${reg.pid}?) \u2014 the file switch still applies`
-    );
-  }
-}
-async function killCommand(args, io) {
-  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
-  const { kill } = createFileGuard(loaded, { alerts: false, env: io.env });
-  const reason = args.positionals.join(" ") || flagString(args, "reason") || `agentguard kill by ${io.env.USER ?? "operator"}`;
-  kill.kill(reason);
-  await pokeHttp(io, readRegistration(loaded), "/kill", { reason });
-  io.out(
-    `KILLED: ${kill.path} written \u2014 every tool call through this policy now returns KILLED. Clear with: agentguard resume`
-  );
-  return 0;
-}
-async function resumeCommand(args, io) {
-  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
-  const { kill } = createFileGuard(loaded, { alerts: false, env: io.env });
-  kill.resume();
-  await pokeHttp(io, readRegistration(loaded), "/resume");
-  io.out(`resumed: ${kill.path} removed`);
-  if (io.env[loaded.policy.kill.env])
-    io.err(
-      `note: ${loaded.policy.kill.env} is set in this shell's environment; proxies started from it stay killed`
-    );
-  return 0;
-}
-async function decideCommand(decision, args, io) {
-  const id = args.positionals[0];
-  if (!id) {
-    io.err(
-      `usage: agentguard ${decision === "approved" ? "approve" : "deny"} <approval-id> [--by name] [--note text]`
-    );
-    return 1;
-  }
-  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
-  const { guard } = createFileGuard(loaded, { alerts: false, env: io.env });
-  const record = await guard.decide(
-    id,
-    decision,
-    flagString(args, "by") ?? io.env.USER ?? "cli",
-    flagString(args, "note")
-  );
-  if (!record) {
-    io.err(`no approval ${id} \u2014 pending ones: agentguard approvals`);
-    return 1;
-  }
-  io.out(
-    `${record.status}: ${record.tool} (${record.id}, run ${record.run_id})${record.status === "approved" ? " \u2014 the agent may now retry the identical call once" : ""}`
-  );
-  return 0;
-}
-async function approvalsCommand(args, io) {
-  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
-  const { guard } = createFileGuard(loaded, { alerts: false, env: io.env });
-  const list = await guard.approvals.list(flagBool(args, "all") ? void 0 : "pending");
-  if (flagBool(args, "json")) {
-    io.out(JSON.stringify(list, null, 2));
-    return 0;
-  }
-  if (list.length === 0) {
-    io.out(flagBool(args, "all") ? "no approvals recorded" : "no pending approvals");
-    return 0;
-  }
-  for (const r of list) {
-    io.out(
-      `${r.id}  ${r.status.padEnd(9)} ${r.tool}  run ${r.run_id}${r.agent ? ` agent ${r.agent}` : ""}  expires ${r.expires_at}`
-    );
-    io.out(`  args: ${JSON.stringify(r.args).slice(0, 300)}`);
-    if (r.status === "pending")
-      io.out(`  \u2192 agentguard approve ${r.id}   |   agentguard deny ${r.id}`);
-  }
-  return 0;
-}
-
-// src/commands/init.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync3 } from "fs";
-import { relative, resolve as resolve3 } from "path";
-import YAML from "yaml";
+// src/commands/connect.ts
+import { existsSync as existsSync4 } from "fs";
+import { relative } from "path";
 
 // src/configs.ts
-import { copyFileSync, existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2, platform } from "os";
 import { join as join2, resolve as resolve2 } from "path";
 function candidateConfigs(cwd = process.cwd(), home = homedir2(), env = process.env) {
@@ -2775,7 +2757,7 @@ function describeConfigPath(path) {
   if (known) return known;
   let serversKey = "mcpServers";
   try {
-    const parsed = JSON.parse(readFileSync2(abs, "utf8"));
+    const parsed = JSON.parse(readFileSync3(abs, "utf8"));
     if (parsed.servers && !parsed.mcpServers) serversKey = "servers";
   } catch {
   }
@@ -2787,12 +2769,13 @@ function describeConfigPath(path) {
   };
 }
 function readServers(file) {
-  const raw = JSON.parse(readFileSync2(file.path, "utf8"));
+  const raw = JSON.parse(readFileSync3(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");
 }
@@ -2836,14 +2819,14 @@ function backupPath(file) {
   return `${file.path}.agentguard-backup`;
 }
 function proxyEntry(file, policyPath, opts = {}) {
-  const args = ["-y", "agentguard", "proxy", "--config", policyPath];
+  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(readFileSync2(file.path, "utf8"));
+  const raw = JSON.parse(readFileSync3(file.path, "utf8"));
   const servers = raw[file.serversKey] ?? {};
   const replaced = Object.keys(servers).filter((n) => !isProxyEntry(servers[n]));
   const backup = backupPath(file);
@@ -2858,6 +2841,216 @@ function restoreClientConfig(file) {
   copyFileSync(backup, file.path);
   return true;
 }
+function mergeServerIntoConfig(file, name, entry) {
+  const raw = JSON.parse(readFileSync3(file.path, "utf8"));
+  const servers = raw[file.serversKey] ?? {};
+  const replaced = name in servers;
+  const backup = backupPath(file);
+  if (!existsSync3(backup)) copyFileSync(file.path, backup);
+  raw[file.serversKey] = { ...servers, [name]: entry };
+  writeFileSync2(file.path, JSON.stringify(raw, null, 2) + "\n");
+  return { backup, replaced };
+}
+
+// src/commands/connect.ts
+var DEFAULT_PROXY_URL = "https://agentwares-agentguard-proxy.vercel.app";
+function fail(e) {
+  throw e;
+}
+async function connectCommand(args, io, fetchImpl = fetch) {
+  const key = args.positionals[0] ?? io.env.AGENTGUARD_KEY;
+  if (!key) {
+    io.err("usage: agentguard connect <key> [--write] [--client <path>] [--url <proxy-url>]");
+    io.err("  the key is on your dashboard; it starts with agk_");
+    return 2;
+  }
+  const base = (flagString(args, "url") ?? io.env.AGENTGUARD_PROXY_URL ?? DEFAULT_PROXY_URL).replace(/\/+$/, "");
+  let res;
+  try {
+    res = await fetchImpl(`${base}/connect`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ key })
+    });
+  } catch (err) {
+    fail({
+      code: "PROXY_UNREACHABLE",
+      cause: `could not reach ${base}: ${err instanceof Error ? err.message : String(err)}`,
+      fix: "check the network, or pass --url if you run your own proxy",
+      retryable: true
+    });
+  }
+  const text = await res.text();
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    fail({
+      code: "PROXY_BAD_RESPONSE",
+      cause: `${base}/connect returned ${res.status} that was not JSON: ${text.slice(0, 200)}`,
+      fix: "check --url points at an agentguard proxy, not at the dashboard",
+      retryable: false
+    });
+  }
+  if (!res.ok) {
+    const e = body;
+    fail({
+      code: e.code ?? "CONNECT_REFUSED",
+      cause: e.cause ?? `${base}/connect returned ${res.status}`,
+      fix: e.fix ?? "check the key on your dashboard; revoked keys stop working immediately",
+      retryable: e.retryable ?? false
+    });
+  }
+  const conn = body;
+  if (flagBool(args, "json")) {
+    io.out(JSON.stringify(conn, null, 2));
+    return 0;
+  }
+  const rel = (p) => p.startsWith(io.cwd + "/") ? relative(io.cwd, p) : p;
+  const entry = conn.mcpServers[PROXY_SERVER_NAME] ?? {
+    type: "http",
+    url: conn.mcpUrl,
+    headers: conn.headers
+  };
+  if (!flagBool(args, "write")) {
+    io.out(JSON.stringify({ mcpServers: { [PROXY_SERVER_NAME]: entry } }, null, 2));
+  } else {
+    const explicit = flagString(args, "client");
+    const configs = explicit ? [describeConfigPath(explicit)] : detectClientConfigs(io.cwd, homeFrom(io), io.env);
+    const projectLevel = configs.filter((c) => c.path.startsWith(io.cwd + "/"));
+    let chosen;
+    if (explicit || flagBool(args, "all")) chosen = configs;
+    else chosen = projectLevel.slice(0, 1);
+    if (chosen.length === 0) {
+      io.err(
+        "no MCP config found here (.mcp.json, .cursor/mcp.json, .vscode/mcp.json). Create one, or paste this into your client:"
+      );
+      io.out(JSON.stringify({ mcpServers: { [PROXY_SERVER_NAME]: entry } }, null, 2));
+      return 1;
+    }
+    for (const c of chosen) {
+      if (!existsSync4(c.path)) {
+        io.err(`no MCP config at ${c.path}`);
+        return 1;
+      }
+      const { backup, replaced } = mergeServerIntoConfig(c, PROXY_SERVER_NAME, entry);
+      io.out(
+        `${replaced ? "updated" : "wrote  "} ${rel(c.path)} (${c.label}) \u2192 ${PROXY_SERVER_NAME} = ${conn.mcpUrl}`
+      );
+      io.out(`backup  ${rel(backup)}`);
+    }
+    for (const c of configs.filter((c2) => !chosen.includes(c2)))
+      io.out(
+        `found   ${c.path} (${c.label}, user-level) \u2014 not touched; pass --client ${JSON.stringify(c.path)} to write it too`
+      );
+  }
+  const band = conn.band ? ` band=${conn.band.tier} (${conn.band.quantity} calls/mo)` : "";
+  io.out(`
+proxy ${conn.slug} (${conn.proxyId}) mode=${conn.mode}${band}`);
+  if (conn.upstreams?.length) io.out(`upstreams: ${conn.upstreams.join(", ")}`);
+  if (conn.dashboardUrl) io.out(`dashboard: ${conn.dashboardUrl}`);
+  if (conn.claudeCode) io.out(`claude code: ${conn.claudeCode}`);
+  if (!flagBool(args, "write"))
+    io.out(`
+run again with --write to add this to your MCP client config`);
+  return 0;
+}
+
+// src/commands/control.ts
+async function pokeHttp(io, reg, path, body) {
+  if (!reg) return;
+  try {
+    const res = await fetch(`${reg.baseUrl}${path}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${reg.token}`, "Content-Type": "application/json" },
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok)
+      io.err(
+        `running proxy at ${reg.baseUrl} answered ${res.status} (the file switch still applies)`
+      );
+  } catch {
+    io.err(
+      `no proxy answering at ${reg.baseUrl} (stale ${reg.pid}?) \u2014 the file switch still applies`
+    );
+  }
+}
+async function killCommand(args, io) {
+  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
+  const { kill } = createFileGuard(loaded, { alerts: false, env: io.env });
+  const reason = args.positionals.join(" ") || flagString(args, "reason") || `agentguard kill by ${io.env.USER ?? "operator"}`;
+  kill.kill(reason);
+  await pokeHttp(io, readRegistration(loaded), "/kill", { reason });
+  io.out(
+    `KILLED: ${kill.path} written \u2014 every tool call through this policy now returns KILLED. Clear with: agentguard resume`
+  );
+  return 0;
+}
+async function resumeCommand(args, io) {
+  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
+  const { kill } = createFileGuard(loaded, { alerts: false, env: io.env });
+  kill.resume();
+  await pokeHttp(io, readRegistration(loaded), "/resume");
+  io.out(`resumed: ${kill.path} removed`);
+  if (io.env[loaded.policy.kill.env])
+    io.err(
+      `note: ${loaded.policy.kill.env} is set in this shell's environment; proxies started from it stay killed`
+    );
+  return 0;
+}
+async function decideCommand(decision, args, io) {
+  const id = args.positionals[0];
+  if (!id) {
+    io.err(
+      `usage: agentguard ${decision === "approved" ? "approve" : "deny"} <approval-id> [--by name] [--note text]`
+    );
+    return 1;
+  }
+  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
+  const { guard } = createFileGuard(loaded, { alerts: false, env: io.env });
+  const record = await guard.decide(
+    id,
+    decision,
+    flagString(args, "by") ?? io.env.USER ?? "cli",
+    flagString(args, "note")
+  );
+  if (!record) {
+    io.err(`no approval ${id} \u2014 pending ones: agentguard approvals`);
+    return 1;
+  }
+  io.out(
+    `${record.status}: ${record.tool} (${record.id}, run ${record.run_id})${record.status === "approved" ? " \u2014 the agent may now retry the identical call once" : ""}`
+  );
+  return 0;
+}
+async function approvalsCommand(args, io) {
+  const loaded = loadPolicyFor(args, io, { allowMissingEnv: true });
+  const { guard } = createFileGuard(loaded, { alerts: false, env: io.env });
+  const list = await guard.approvals.list(flagBool(args, "all") ? void 0 : "pending");
+  if (flagBool(args, "json")) {
+    io.out(JSON.stringify(list, null, 2));
+    return 0;
+  }
+  if (list.length === 0) {
+    io.out(flagBool(args, "all") ? "no approvals recorded" : "no pending approvals");
+    return 0;
+  }
+  for (const r of list) {
+    io.out(
+      `${r.id}  ${r.status.padEnd(9)} ${r.tool}  run ${r.run_id}${r.agent ? ` agent ${r.agent}` : ""}  expires ${r.expires_at}`
+    );
+    io.out(`  args: ${JSON.stringify(r.args).slice(0, 300)}`);
+    if (r.status === "pending")
+      io.out(`  \u2192 agentguard approve ${r.id}   |   agentguard deny ${r.id}`);
+  }
+  return 0;
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync5, writeFileSync as writeFileSync3 } from "fs";
+import { relative as relative2, resolve as resolve3 } from "path";
+import YAML from "yaml";
 
 // src/commands/tools.ts
 import {
@@ -2948,7 +3141,7 @@ var ProxyRuntime = class {
   }
   async connect(upstream) {
     const client = new Client(
-      { name: "agentguard", version: "0.1.0" },
+      { name: "agentguard", version: version() },
       { capabilities: { sampling: {}, elicitation: {} } }
     );
     const conn = {
@@ -3592,7 +3785,7 @@ async function initCommand(args, io) {
   const explicit = flagString(args, "client");
   const configs = explicit ? [describeConfigPath(resolve3(io.cwd, explicit))] : detectClientConfigs(io.cwd, homeFrom(io), io.env);
   const rel = (p) => {
-    const r = relative(io.cwd, p);
+    const r = relative2(io.cwd, p);
     return r.startsWith("..") ? p : r || ".";
   };
   if (flagBool(args, "undo")) {
@@ -3619,7 +3812,7 @@ async function initCommand(args, io) {
         `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) => existsSync4(c.path))) {
+  if (!chosen.every((c) => existsSync5(c.path))) {
     io.err(`no MCP config at ${chosen.map((c) => c.path).join(", ")}`);
     return 1;
   }
@@ -3638,7 +3831,7 @@ async function initCommand(args, io) {
     );
   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 && existsSync4(policyPath)) {
+  if (skipped.some((s) => s.reason.includes("already")) && upstreams.length === 0 && existsSync5(policyPath)) {
     io.out(
       `already initialized: ${rel(policyPath)} exists and ${chosen.map((c) => rel(c.path)).join(", ")} already points at agentguard`
     );
@@ -3665,7 +3858,7 @@ async function initCommand(args, io) {
     }
   }
   const mode = flagString(args, "mode") ?? "dry-run";
-  if (existsSync4(policyPath) && !flagBool(args, "force")) {
+  if (existsSync5(policyPath) && !flagBool(args, "force")) {
     io.out(`kept    ${rel(policyPath)} (exists; pass --force to regenerate)`);
   } else {
     writeFileSync3(policyPath, renderStarterPolicy({ upstreams, tools: probed, mode, probeErrors }));
@@ -3679,6 +3872,11 @@ async function initCommand(args, io) {
   }
   if (flagBool(args, "rewrite") !== false) {
     for (const c of chosen) {
+      if (resolve3(c.path) === resolve3(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")
       });
@@ -3704,13 +3902,13 @@ async function initCommand(args, io) {
 }
 
 // src/commands/keys.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import YAML2, { isMap, isSeq, YAMLSeq } from "yaml";
 import { generateAgentKey, hashAgentKey } from "@agentwares/agentguard-core";
 async function keyCommand(args, io) {
   const [sub, name] = args.positionals;
   const path = policyPathFrom(args, io);
-  const doc = YAML2.parseDocument(readFileSync3(path, "utf8"));
+  const doc = YAML2.parseDocument(readFileSync4(path, "utf8"));
   let agents = doc.get("agents");
   if (!isSeq(agents)) {
     agents = new YAMLSeq();
@@ -4071,19 +4269,13 @@ async function statusCommand(args, io) {
 }
 
 // src/cli.ts
-function version2() {
-  try {
-    return JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8")).version;
-  } catch {
-    return "0.0.0";
-  }
-}
 var HELP = `agentguard \u2014 MCP policy proxy for agents that touch production
 
   npx @agentwares/agentguard init                 read your MCP config, write agentguard.yaml (dry-run), route every server through the proxy
   agentguard report [--run id|--all]  what this run did / would have destroyed / spent, where it was halted
   agentguard diff [--run id]          record-by-record mutation diff from a dry run
   agentguard verify [audit.jsonl]     prove the hash-chained audit log was not edited
+  agentguard connect <key> [--write]  point this machine at your hosted proxy (paid tiers)
 
   agentguard proxy [--http --port 8788] [--agent name] [--run-id id] [--mode dry-run|enforce]
   agentguard tools [--json]           the tools your agent will see, with class and why
@@ -4100,7 +4292,7 @@ Docs: https://github.com/agentwares/agentguard/tree/main/apps/agentguard-cli`;
 async function main(argv, io = defaultIo()) {
   const args = parseArgs(argv);
   if (args.flags.version) {
-    io.out(version2());
+    io.out(version());
     return 0;
   }
   if (args.command === void 0 && !args.flags.help && io.tty === false) {
@@ -4128,6 +4320,8 @@ async function main(argv, io = defaultIo()) {
         return await diffCommand(args, io);
       case "verify":
         return await verifyCommand(args, io);
+      case "connect":
+        return await connectCommand(args, io);
       case "status":
         return await statusCommand(args, io);
       case "tools":
@@ -4174,6 +4368,6 @@ if (isMain) {
 export {
   HELP,
   main,
-  version2 as version
+  version
 };
 //# sourceMappingURL=cli.js.map