agentverify 1.6.0 → 2.0.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to the `agentverify` CLI/SDK package are documented here.
 
+## [2.0.0] - 2026-10-30
+
+### Added
+
+- `agentverify mcp`: run Agent Verify as an MCP server (stdio) for Claude Code, Cursor, Windsurf and VS Code.
+  Tools: `scan_path`, `scan_code`, `scan_mcp_config`. Reads `AGENTVERIFY_API_KEY`.
+  `claude mcp add agentverify -e AGENTVERIFY_API_KEY=av_your_key -- npx -y agentverify mcp`
+- Folder scans from the MCP server are combined into one report (60 files / 5MB, agent files first, tests last) and
+  each finding is mapped back to its file and line.
+- MCP config checks read only the server definitions and mask secret values locally before sending.
+- `Finding.line` is now part of the SDK type.
+- `agentverify/guard`: Agent Guard runtime protection (`createGuard`, `wrap`, `wrapAll`, `GuardBlockedError`).
+
 ## [1.6.0] - 2026-10-27
 
 ### Added

package/dist/cli.js

@@ -2,8 +2,8 @@
 "use strict";
 
 // src/cli.ts
-var import_fs2 = require("fs");
-var import_path = require("path");
+var import_fs4 = require("fs");
+var import_path3 = require("path");
 
 // src/sdk.ts
 var DEFAULT_API_URL = "https://agentverify-api.agentverify.workers.dev/v1/scan";
@@ -115,8 +115,393 @@ async function scan(input, options) {
   }
 }
 
-// src/profile.ts
+// src/mcp.ts
+var import_readline = require("readline");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+
+// src/files.ts
 var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var SCANNABLE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".py", ".json", ".yaml", ".yml", ".toml", ".md", ".mjs", ".cjs", ".sh"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "vendor", "coverage", ".cache", ".venv", "venv", "__pycache__", "out", "target"]);
+var SKIP_FILES = /* @__PURE__ */ new Set(["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "poetry.lock", "Cargo.lock", "composer.lock", "tsconfig.json"]);
+var MAX_FILES = 60;
+var MAX_TOTAL_BYTES = 5 * 1024 * 1024;
+var MAX_FILE_BYTES = 400 * 1024;
+function filePriority(relPath) {
+  const p = relPath.toLowerCase().replace(/\\/g, "/");
+  const name = p.split("/").pop() ?? p;
+  let score = 0;
+  if (/(^|\/)(tests?|__tests__|spec|e2e|fixtures?|examples?)\//.test(p) || /\.(test|spec)\.[a-z]+$/.test(name)) score -= 80;
+  if (/(agent|tool|mcp|prompt|crew|graph|server|config|policy|skill)/.test(name)) score += 30;
+  if (/(^|\/)(agents?|tools?|mcp|src|app|lib)\//.test(p)) score += 10;
+  if (name.endsWith(".md")) score -= 20;
+  if (name === "skill.md" || name === "agents.md" || name === "claude.md") score += 40;
+  return score - p.split("/").length;
+}
+function walk(dir, out) {
+  let entries;
+  try {
+    entries = (0, import_fs.readdirSync)(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry) || SKIP_FILES.has(entry)) continue;
+    const full = (0, import_path.join)(dir, entry);
+    let st;
+    try {
+      st = (0, import_fs.statSync)(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) walk(full, out);
+    else if (SCANNABLE_EXTENSIONS.has((0, import_path.extname)(entry).toLowerCase())) out.push(full);
+  }
+}
+function pickFiles(target) {
+  const notes = [];
+  let st;
+  try {
+    st = (0, import_fs.statSync)(target);
+  } catch {
+    throw new Error(`Path not found: ${target}`);
+  }
+  if (st.isFile()) {
+    if (st.size > MAX_TOTAL_BYTES) throw new Error(`${(0, import_path.basename)(target)} is larger than 5MB, which is the most one scan can take.`);
+    return { files: [{ path: (0, import_path.basename)(target), content: (0, import_fs.readFileSync)(target, "utf8") }], notes };
+  }
+  const all = [];
+  walk(target, all);
+  if (all.length === 0) throw new Error(`No agent files found in ${target}. Agent Verify reads ${[...SCANNABLE_EXTENSIONS].join(" ")} files.`);
+  const ranked = all.map((full) => ({ full, rel: (0, import_path.relative)(target, full).split(import_path.sep).join("/") })).sort((a, b) => filePriority(b.rel) - filePriority(a.rel) || a.rel.localeCompare(b.rel));
+  const files = [];
+  let total = 0;
+  let tooBig = 0;
+  for (const { full, rel } of ranked) {
+    if (files.length >= MAX_FILES) break;
+    let size = 0;
+    try {
+      size = (0, import_fs.statSync)(full).size;
+    } catch {
+      continue;
+    }
+    if (size > MAX_FILE_BYTES) {
+      tooBig++;
+      continue;
+    }
+    if (total + size > MAX_TOTAL_BYTES) break;
+    files.push({ path: rel, content: (0, import_fs.readFileSync)(full, "utf8") });
+    total += size;
+  }
+  const left = ranked.length - files.length - tooBig;
+  if (left > 0) notes.push(`${left} lower-priority file(s) were left out to stay within one scan (${MAX_FILES} files / 5MB).`);
+  if (tooBig > 0) notes.push(`${tooBig} file(s) over 400KB were skipped.`);
+  return { files, notes };
+}
+function combineFiles(files) {
+  if (files.length === 1) return files[0].content;
+  return files.map((f) => `// ===== FILE: ${f.path} =====
+${f.content}`).join("\n\n");
+}
+function locateLine(files, combinedLine) {
+  if (files.length === 1) return { path: files[0].path, line: combinedLine };
+  let cursor = 1;
+  for (let i = 0; i < files.length; i++) {
+    const start = cursor + 1;
+    const lines = files[i].content.split("\n").length;
+    if (combinedLine >= start && combinedLine < start + lines) return { path: files[i].path, line: combinedLine - start + 1 };
+    cursor = start + lines + 1;
+  }
+  return null;
+}
+function knownMcpConfigPaths(cwd = process.cwd()) {
+  const home = (0, import_os.homedir)();
+  const appData = process.env.APPDATA ?? (0, import_path.join)(home, "AppData", "Roaming");
+  const claudeDesktop = (0, import_os.platform)() === "win32" ? (0, import_path.join)(appData, "Claude", "claude_desktop_config.json") : (0, import_os.platform)() === "darwin" ? (0, import_path.join)(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") : (0, import_path.join)(home, ".config", "Claude", "claude_desktop_config.json");
+  return [
+    { client: "Claude Code (this project)", path: (0, import_path.join)(cwd, ".mcp.json") },
+    { client: "Claude Code (user)", path: (0, import_path.join)(home, ".claude.json") },
+    { client: "Claude Desktop", path: claudeDesktop },
+    { client: "Cursor (this project)", path: (0, import_path.join)(cwd, ".cursor", "mcp.json") },
+    { client: "Cursor (user)", path: (0, import_path.join)(home, ".cursor", "mcp.json") },
+    { client: "VS Code (this project)", path: (0, import_path.join)(cwd, ".vscode", "mcp.json") },
+    { client: "Windsurf", path: (0, import_path.join)(home, ".codeium", "windsurf", "mcp_config.json") }
+  ];
+}
+function extractMcpServers(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!data || typeof data !== "object") return null;
+  const servers = {};
+  const take = (obj, prefix = "") => {
+    if (!obj || typeof obj !== "object") return;
+    for (const key of ["mcpServers", "servers"]) {
+      const block = obj[key];
+      if (block && typeof block === "object" && !Array.isArray(block)) {
+        for (const [name, def] of Object.entries(block)) servers[prefix + name] = def;
+      }
+    }
+  };
+  take(data);
+  const projects = data.projects;
+  if (projects && typeof projects === "object") {
+    for (const [proj, value] of Object.entries(projects)) take(value, `${(0, import_path.basename)(proj)}/`);
+  }
+  return Object.keys(servers).length ? servers : null;
+}
+var SECRET_NAME = /(TOKEN|KEY|SECRET|PASSWORD|PASSWD|PAT|AUTH|CREDENTIAL|COOKIE|SESSION)/i;
+var SECRET_VALUE = /^(sk-|sk_|ghp_|gho_|github_pat_|xox[abp]-|AKIA|AIza|hf_|npm_|glpat-|eyJ)/;
+function mask(value) {
+  return value.length <= 4 ? "****redacted" : `${value.slice(0, 4)}****redacted`;
+}
+function redactMcpSecrets(servers) {
+  const clean = (node, parentKey = "") => {
+    if (typeof node === "string") {
+      if (/^\$\{|^<|^\$[A-Z_]/.test(node)) return node;
+      if (SECRET_NAME.test(parentKey) || SECRET_VALUE.test(node)) return mask(node);
+      const flag = node.match(/^(--?[A-Za-z0-9_-]*(?:token|key|secret|password|auth)[A-Za-z0-9_-]*=)(.+)$/i);
+      if (flag) return flag[1] + mask(flag[2]);
+      return node;
+    }
+    if (Array.isArray(node)) return node.map((item) => clean(item, parentKey));
+    if (node && typeof node === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(node)) out[k] = clean(v, k);
+      return out;
+    }
+    return node;
+  };
+  return clean(servers);
+}
+function existingMcpConfigs(cwd = process.cwd()) {
+  return knownMcpConfigPaths(cwd).filter((c2) => (0, import_fs.existsSync)(c2.path));
+}
+
+// src/mcp.ts
+var SUPPORTED_PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var PRICING_URL = "https://aimodularity.com/agentverify/pricing/";
+var DASHBOARD_URL = "https://aimodularity.com/agentverify/dashboard/";
+var TOOLS = [
+  {
+    name: "scan_path",
+    title: "Scan agent files",
+    description: "Scan an AI agent for security risks before it is deployed: dangerous tool permissions, prompt injection paths, exposed secrets, risky MCP servers, missing approval gates, SQL/SSRF/code-execution risks, and framework-specific issues (LangChain, CrewAI, AutoGen, OpenAI Agents SDK, Claude Agent SDK). Give a file or a folder; a folder is scanned as one report using the most important agent files (up to 60 files / 5MB). Returns a verdict, a 0-100 security score (higher is safer) and findings with file and line.",
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string", description: "File or folder to scan. Relative paths are resolved from the current project." } },
+      required: ["path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "scan_code",
+    title: "Scan agent code",
+    description: "Scan a snippet of agent code, a tool definition, a system prompt or an MCP config for security risks. Use this for code that is not saved to a file yet. Returns a verdict, a security score and findings.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "The code or config to scan." },
+        fileName: { type: "string", description: "A file name with the right extension (e.g. agent.py, mcp.json) so the language is detected." }
+      },
+      required: ["content"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "scan_mcp_config",
+    title: "Check my MCP servers",
+    description: "Check the MCP servers configured on this computer (Claude Code, Claude Desktop, Cursor, VS Code, Windsurf) for risks such as broad filesystem access, unpinned packages, remote servers without auth, auto-approved tools and API keys stored in plain text. Only the server definitions are read, and secret values are masked on this computer before anything is sent.",
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string", description: "Optional: a specific MCP config file. Leave empty to check all known locations." } },
+      additionalProperties: false
+    }
+  }
+];
+var SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+var SEVERITY_LABEL = { critical: "CRITICAL", high: "HIGH", medium: "MEDIUM", low: "LOW" };
+function verdictLine(result) {
+  const verdict = result.verdict === "VERIFIED" ? "VERIFIED" : result.verdict === "NOT_ASSESSED" ? "NOT ASSESSED" : "NOT VERIFIED";
+  return `**Verdict: ${verdict}** \u2014 Security score ${result.riskScore}/100 (higher is safer, ${result.riskLevel})`;
+}
+function fixText(f) {
+  if (f.fixLocked) return `Fix: included with Agent Verify Pro (${PRICING_URL})`;
+  const steps = (f.recommendedFix ?? "").trim();
+  const code = (f.quickFix ?? f.fixCode ?? "").trim();
+  if (!steps && !code) return null;
+  return [steps ? `Fix: ${steps}` : "", code ? "```\n" + code + "\n```" : ""].filter(Boolean).join("\n");
+}
+function formatReport(result, opts) {
+  const findings = [...result.findings ?? []].sort((a, b) => (SEVERITY_ORDER[a.severity] ?? 9) - (SEVERITY_ORDER[b.severity] ?? 9));
+  const counts = ["critical", "high", "medium", "low"].map((s) => [s, findings.filter((f) => f.severity === s).length]).filter(([, n]) => n > 0);
+  const lines = [`# Agent Verify: ${opts.title}`, "", verdictLine(result)];
+  lines.push(findings.length ? `Findings: ${counts.map(([s, n]) => `${n} ${s}`).join(", ")}` : "No findings.");
+  if (result.reportInsights?.topBlocker) lines.push(`Fix first: ${result.reportInsights.topBlocker}`);
+  for (const note of opts.notes ?? []) lines.push(`Note: ${note}`);
+  findings.forEach((f, i) => {
+    const where = typeof f.line === "number" && f.line > 0 ? opts.files ? locateLine(opts.files, f.line) : { path: opts.title, line: f.line } : null;
+    lines.push("", `## ${i + 1}. [${SEVERITY_LABEL[f.severity] ?? f.severity}] ${f.title} (${f.code})`);
+    if (where) lines.push(`Location: ${where.path}:${where.line}`);
+    if (f.evidence) lines.push(`Evidence: ${f.evidence}`);
+    lines.push(`What is wrong: ${f.whatIsWrong}`);
+    if (f.whyItMatters) lines.push(`Why it matters: ${f.whyItMatters}`);
+    const fix = fixText(f);
+    if (fix) lines.push(fix);
+  });
+  const locked = findings.filter((f) => f.fixLocked).length;
+  if (locked > 0) lines.push("", `Step-by-step fixes and corrected code for ${locked} finding(s) are included with Pro: ${PRICING_URL}`);
+  if (result.reportUrl) lines.push("", `Full report: ${result.reportUrl}`);
+  lines.push("", "Agent Verify is an automated, evidence-based check, not a guarantee. Re-scan after making changes.");
+  return lines.join("\n");
+}
+function textResult(text, isError = false, structured) {
+  return { content: [{ type: "text", text }], ...isError ? { isError: true } : {}, ...structured ? { structuredContent: structured } : {} };
+}
+function summary(result) {
+  return {
+    verdict: result.verdict,
+    securityScore: result.riskScore,
+    riskLevel: result.riskLevel,
+    findings: (result.findings ?? []).map((f) => ({ code: f.code, severity: f.severity, title: f.title, line: f.line ?? null })),
+    reportUrl: result.reportUrl ?? null
+  };
+}
+async function callTool(name, args, opts) {
+  const tool = TOOLS.find((t) => t.name === name);
+  if (!tool) return textResult(`Unknown tool: ${name}`, true);
+  if (!opts.apiKey) {
+    return textResult(
+      "Agent Verify needs an API key. Create a free one in the dashboard (API / CLI tab): " + DASHBOARD_URL + "\nThen set AGENTVERIFY_API_KEY in this MCP server's environment and restart it.",
+      true
+    );
+  }
+  const doScan = opts.scanFn ?? scan;
+  const cwd = opts.cwd ?? process.cwd();
+  try {
+    if (name === "scan_code") {
+      const content2 = typeof args.content === "string" ? args.content : "";
+      if (!content2.trim()) return textResult('Nothing to scan: "content" is empty.', true);
+      const fileName = typeof args.fileName === "string" && args.fileName.trim() ? args.fileName.trim() : "agent";
+      const result2 = await doScan({ content: content2, fileName, platform: "MCP" }, { apiKey: opts.apiKey, apiUrl: opts.apiUrl });
+      return textResult(formatReport(result2, { title: fileName }), false, summary(result2));
+    }
+    if (name === "scan_path") {
+      const raw = typeof args.path === "string" ? args.path.trim() : "";
+      if (!raw) return textResult('Give a file or folder "path" to scan.', true);
+      const target = (0, import_path2.resolve)(cwd, raw);
+      const picked = pickFiles(target);
+      const fileName = picked.files.length === 1 ? picked.files[0].path : `${raw.replace(/[\\/]+$/, "") || "project"} (${picked.files.length} files)`;
+      const result2 = await doScan({ content: combineFiles(picked.files), fileName, platform: "MCP" }, { apiKey: opts.apiKey, apiUrl: opts.apiUrl });
+      const notes = [...picked.notes];
+      if (picked.files.length > 1) notes.unshift(`Scanned ${picked.files.length} files together as one report.`);
+      return textResult(formatReport(result2, { title: fileName, files: picked.files, notes }), false, summary(result2));
+    }
+    const explicit = typeof args.path === "string" && args.path.trim() ? (0, import_path2.resolve)(cwd, args.path.trim()) : "";
+    const configs = explicit ? [{ client: "Config file", path: explicit }] : existingMcpConfigs(cwd);
+    if (configs.length === 0) return textResult('No MCP config files were found in the usual places (Claude Code, Claude Desktop, Cursor, VS Code, Windsurf). Pass a "path" to check a specific file.');
+    const servers = {};
+    const read = [];
+    for (const cfg of configs) {
+      let rawText = "";
+      try {
+        rawText = (0, import_fs2.readFileSync)(cfg.path, "utf8");
+      } catch {
+        continue;
+      }
+      const found = extractMcpServers(rawText);
+      if (!found) continue;
+      read.push(`${cfg.client}: ${Object.keys(found).length} server(s)`);
+      for (const [server, def] of Object.entries(found)) servers[`${cfg.client} \u203A ${server}`] = def;
+    }
+    if (Object.keys(servers).length === 0) return textResult(`Found ${configs.length} config file(s), but none of them define any MCP servers.`);
+    const content = JSON.stringify({ mcpServers: redactMcpSecrets(servers) }, null, 2);
+    const result = await doScan({ content, fileName: "mcp.json", platform: "MCP" }, { apiKey: opts.apiKey, apiUrl: opts.apiUrl });
+    return textResult(
+      formatReport(result, { title: `MCP servers (${Object.keys(servers).length})`, notes: [`Checked: ${read.join("; ")}`, "Secret values were masked on this computer before scanning."] }),
+      false,
+      summary(result)
+    );
+  } catch (err) {
+    return textResult(`Scan failed: ${err instanceof Error ? err.message : String(err)}`, true);
+  }
+}
+async function handleMessage(msg, opts) {
+  const isNotification = msg.id === void 0 || msg.id === null;
+  const reply = (result) => isNotification ? null : { jsonrpc: "2.0", id: msg.id, result };
+  const fail = (code, message) => isNotification ? null : { jsonrpc: "2.0", id: msg.id ?? null, error: { code, message } };
+  switch (msg.method) {
+    case "initialize": {
+      const requested = typeof msg.params?.protocolVersion === "string" ? msg.params.protocolVersion : "";
+      return reply({
+        protocolVersion: SUPPORTED_PROTOCOLS.includes(requested) ? requested : SUPPORTED_PROTOCOLS[0],
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: "agentverify", title: "Agent Verify", version: opts.version },
+        instructions: "Use Agent Verify to check AI agent code, tools, prompts and MCP configs for security risks before deploying. Run scan_path on the agent folder after making changes, and fix critical and high findings first."
+      });
+    }
+    case "ping":
+      return reply({});
+    case "tools/list":
+      return reply({ tools: TOOLS });
+    case "tools/call": {
+      const name = typeof msg.params?.name === "string" ? msg.params.name : "";
+      const args = msg.params?.arguments && typeof msg.params.arguments === "object" ? msg.params.arguments : {};
+      return reply(await callTool(name, args, opts));
+    }
+    case "resources/list":
+      return reply({ resources: [] });
+    case "prompts/list":
+      return reply({ prompts: [] });
+    default:
+      if (typeof msg.method === "string" && msg.method.startsWith("notifications/")) return null;
+      return fail(-32601, `Method not found: ${msg.method}`);
+  }
+}
+function runMcpServer(opts) {
+  return new Promise((done) => {
+    const rl = (0, import_readline.createInterface)({ input: process.stdin, crlfDelay: Infinity });
+    const send = (obj) => process.stdout.write(JSON.stringify(obj) + "\n");
+    let pending = 0;
+    let closed = false;
+    const maybeDone = () => {
+      if (closed && pending === 0) done();
+    };
+    rl.on("line", (line) => {
+      const text = line.trim();
+      if (!text) return;
+      let msg;
+      try {
+        msg = JSON.parse(text);
+      } catch {
+        send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+        return;
+      }
+      pending++;
+      handleMessage(msg, opts).then((res) => {
+        if (res) send(res);
+      }).catch((err) => send({ jsonrpc: "2.0", id: msg.id ?? null, error: { code: -32603, message: err instanceof Error ? err.message : "Internal error" } })).finally(() => {
+        pending--;
+        maybeDone();
+      });
+    });
+    rl.on("close", () => {
+      closed = true;
+      maybeDone();
+    });
+    process.stderr.write(`Agent Verify MCP server ${opts.version} ready${opts.apiKey ? "" : " (no API key set: tools will explain how to add one)"}
+`);
+  });
+}
+
+// src/profile.ts
+var import_fs3 = require("fs");
 var SUPPORTED_PROFILES = ["owasp-agentic-skills-2026"];
 var SUPPORTED_ASSESSMENT_SCHEMA = "1.1.0";
 var LOCAL_LIMITS = { maxFiles: 5e3, maxFileBytes: 8 * 1024 * 1024, maxTotalBytes: 32 * 1024 * 1024, maxDepth: 64 };
@@ -198,13 +583,13 @@ function decodeStrict(bytes) {
 function listEntries(dir, shown) {
   const entries = [];
   if (process.platform === "win32") {
-    for (const d of (0, import_fs.readdirSync)(dir, { withFileTypes: true })) {
+    for (const d of (0, import_fs3.readdirSync)(dir, { withFileTypes: true })) {
       const problem = nameProblem(d.name);
       if (problem) throw new PackageError(`An entry in ${displayPath(shown)} ${problem}, so it cannot be sent faithfully.`);
       entries.push({ name: d.name, kind: d.isSymbolicLink() ? "symlink" : d.isDirectory() ? "dir" : d.isFile() ? "file" : "other" });
     }
   } else {
-    for (const d of (0, import_fs.readdirSync)(dir, { withFileTypes: true, encoding: "buffer" })) {
+    for (const d of (0, import_fs3.readdirSync)(dir, { withFileTypes: true, encoding: "buffer" })) {
       let name;
       try {
         name = decodeStrict(d.name);
@@ -221,23 +606,23 @@ var specialMessage = (rel) => `${displayPath(rel)} is not a regular file or dire
 function readRegularFile(full, rel, budget) {
   let fd;
   try {
-    fd = (0, import_fs.openSync)(full, import_fs.constants.O_RDONLY | (import_fs.constants.O_NOFOLLOW ?? 0));
+    fd = (0, import_fs3.openSync)(full, import_fs3.constants.O_RDONLY | (import_fs3.constants.O_NOFOLLOW ?? 0));
   } catch (e) {
     const code = e.code;
     if (code === "ELOOP") throw new PackageError(symlinkMessage(rel));
     throw new PackageError(`Could not read ${displayPath(rel)}: ${code ?? "unknown error"}.`);
   }
   try {
-    const st = (0, import_fs.fstatSync)(fd);
+    const st = (0, import_fs3.fstatSync)(fd);
     if (!st.isFile()) throw new PackageError(specialMessage(rel));
     if (st.size > LOCAL_LIMITS.maxFileBytes) throw new PackageError(`${displayPath(rel)} is ${st.size} bytes, over the CLI's local read guard of ${LOCAL_LIMITS.maxFileBytes} bytes.`);
-    const bytes = (0, import_fs.readFileSync)(fd);
+    const bytes = (0, import_fs3.readFileSync)(fd);
     if (bytes.length > LOCAL_LIMITS.maxFileBytes) throw new PackageError(`${displayPath(rel)} grew past the CLI's local read guard while it was being read.`);
     budget.total += bytes.length;
     if (budget.total > LOCAL_LIMITS.maxTotalBytes) throw new PackageError(`The package is larger than the CLI's local guard of ${LOCAL_LIMITS.maxTotalBytes} bytes.`);
     return bytes;
   } finally {
-    (0, import_fs.closeSync)(fd);
+    (0, import_fs3.closeSync)(fd);
   }
 }
 var extensionOf = (name) => {
@@ -247,7 +632,7 @@ var extensionOf = (name) => {
 function buildPackage(root) {
   let rootStat;
   try {
-    rootStat = (0, import_fs.lstatSync)(root);
+    rootStat = (0, import_fs3.lstatSync)(root);
   } catch {
     throw new PackageError(`${displayPath(root)} does not exist or cannot be read.`);
   }
@@ -256,7 +641,7 @@ function buildPackage(root) {
   const files = [];
   const skipped = [];
   const budget = { total: 0 };
-  const walk = (dir, prefix, depth) => {
+  const walk2 = (dir, prefix, depth) => {
     if (depth > LOCAL_LIMITS.maxDepth) throw new PackageError(`The package is nested deeper than ${LOCAL_LIMITS.maxDepth} directories.`);
     for (const entry of listEntries(dir, prefix || ".")) {
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -268,7 +653,7 @@ function buildPackage(root) {
           skipped.push({ path: rel, reason: "vendored directory" });
           continue;
         }
-        walk(full, rel, depth + 1);
+        walk2(full, rel, depth + 1);
         continue;
       }
       if (BINARY_EXTENSIONS.has(extensionOf(entry.name))) {
@@ -286,7 +671,7 @@ function buildPackage(root) {
       files.push({ path: rel, content });
     }
   };
-  walk(root, "", 0);
+  walk2(root, "", 0);
   if (files.length === 0) throw new PackageError(`${displayPath(root)} contains no files to assess.`);
   return { files, skipped };
 }
@@ -299,7 +684,7 @@ async function postProfile(apiUrl, apiKey, body, timeoutMs) {
   try {
     const response = await fetch(apiUrl, {
       method: "POST",
-      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "User-Agent": "agentverify-cli/1.6.0" },
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "User-Agent": "agentverify-cli/2.0.0" },
       body,
       signal: controller.signal
     });
@@ -365,7 +750,7 @@ function formatAssessment(body, skipped) {
 }
 
 // src/cli.ts
-var VERSION = "1.6.0";
+var VERSION = "2.0.0";
 var API_URL = process.env.AGENTVERIFY_API_URL ?? "https://agentverify-api.agentverify.workers.dev/v1/scan";
 var A2SPA_DOCS_URL = "https://aimodularity.com/A2SPA/docs";
 var EXIT_OK = 0;
@@ -387,18 +772,18 @@ var write = (value = "") => process.stdout.write(`${value}
 `);
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".py", ".json", ".yaml", ".yml", ".toml", ".md", ".mjs", ".cjs", ".sh"]);
 var MAX_SCAN_FILE_BYTES = 5 * 1024 * 1024;
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "vendor", "coverage", ".cache"]);
+var SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "vendor", "coverage", ".cache"]);
 function collectFiles(dir) {
   const files = [];
   try {
-    const entries = (0, import_fs2.readdirSync)(dir);
+    const entries = (0, import_fs4.readdirSync)(dir);
     for (const entry of entries) {
-      if (SKIP_DIRS.has(entry)) continue;
-      const fullPath = (0, import_path.join)(dir, entry);
-      const stat = (0, import_fs2.statSync)(fullPath);
+      if (SKIP_DIRS2.has(entry)) continue;
+      const fullPath = (0, import_path3.join)(dir, entry);
+      const stat = (0, import_fs4.statSync)(fullPath);
       if (stat.isDirectory()) {
         files.push(...collectFiles(fullPath));
-      } else if (SUPPORTED_EXTENSIONS.has((0, import_path.extname)(entry).toLowerCase())) {
+      } else if (SUPPORTED_EXTENSIONS.has((0, import_path3.extname)(entry).toLowerCase())) {
         files.push(fullPath);
       }
     }
@@ -458,9 +843,12 @@ ${c.gray}Execution trust analysis for AI agents${c.reset}
 ${c.bold}Usage:${c.reset}
   agentverify scan [dir] --key <api-key>
   agentverify scan --file <file> --key <api-key>
+  agentverify mcp
 
 ${c.bold}Commands:${c.reset}
   scan          Scan agent files in a directory or a single file
+  mcp           Run as an MCP server so Claude Code, Cursor, VS Code and other AI
+                tools can scan agents while you code (reads AGENTVERIFY_API_KEY)
 
 ${c.bold}Options:${c.reset}
   --key, -k     API key (or set AGENTVERIFY_API_KEY env var)
@@ -498,6 +886,9 @@ ${c.bold}Examples:${c.reset}
   ${c.gray}# Markdown summary for pull requests${c.reset}
   agentverify scan . --key av_your_key --markdown
 
+  ${c.gray}# Let Claude Code scan your agents (one-time setup)${c.reset}
+  claude mcp add agentverify -e AGENTVERIFY_API_KEY=av_your_key -- npx -y agentverify mcp
+
   ${c.gray}# Assess a skill directory against a profile (alpha); --json prints the service's response${c.reset}
   agentverify scan ./my-skill --profile ${SUPPORTED_PROFILES[0]} --key av_your_key
 
@@ -578,8 +969,8 @@ ${c.bold}Threat categories:${c.reset}`);
   write(`${c.gray}Re-scan:${c.reset} agentverify scan --file ${fileName} --key $AGENTVERIFY_API_KEY
 `);
 }
-function markdownSummary(results, summary) {
-  const lines = ["# Agent Verify", "", `Files scanned: ${summary.total}`, `Verified: ${summary.verified}`, `Not verified: ${summary.notVerified}`, `Not assessed: ${summary.notAssessed}`, `Errors: ${summary.errors}`, ""];
+function markdownSummary(results, summary2) {
+  const lines = ["# Agent Verify", "", `Files scanned: ${summary2.total}`, `Verified: ${summary2.verified}`, `Not verified: ${summary2.notVerified}`, `Not assessed: ${summary2.notAssessed}`, `Errors: ${summary2.errors}`, ""];
   for (const item of results) {
     if (!item.result) {
       lines.push(`## ${item.file}`, "", `Error: ${item.error ?? "Unknown error"}`, "");
@@ -599,20 +990,20 @@ function markdownSummary(results, summary) {
   lines.push(`A2SPA docs: ${A2SPA_DOCS_URL}`);
   return lines.join("\n");
 }
-function writeGithubJobSummary(results, summary) {
+function writeGithubJobSummary(results, summary2) {
   const summaryPath = process.env.GITHUB_STEP_SUMMARY;
   if (!summaryPath) return;
   try {
-    (0, import_fs2.appendFileSync)(summaryPath, `${markdownSummary(results, summary)}
+    (0, import_fs4.appendFileSync)(summaryPath, `${markdownSummary(results, summary2)}
 `);
   } catch (e) {
     console.error(`Warning: could not write GitHub job summary: ${e instanceof Error ? e.message : e}`);
   }
 }
-function writeSummaryFile(path, results, summary) {
+function writeSummaryFile(path, results, summary2) {
   if (!path) return;
   try {
-    (0, import_fs2.writeFileSync)(path, JSON.stringify({ results, summary }, null, 2));
+    (0, import_fs4.writeFileSync)(path, JSON.stringify({ results, summary: summary2 }, null, 2));
   } catch (e) {
     console.error(`Warning: could not write summary file: ${e instanceof Error ? e.message : e}`);
   }
@@ -670,12 +1061,12 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
     const batch = files.slice(i, i + CONCURRENCY);
     const batchResults = await Promise.allSettled(
       batch.map(async (filePath) => {
-        const fileStat = (0, import_fs2.statSync)(filePath);
+        const fileStat = (0, import_fs4.statSync)(filePath);
         if (fileStat.size > MAX_SCAN_FILE_BYTES) {
           throw new Error(`File is ${(fileStat.size / 1024 / 1024).toFixed(1)}MB, over the ${MAX_SCAN_FILE_BYTES / 1024 / 1024}MB scan limit \u2014 skipped`);
         }
-        const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
-        const relPath = (0, import_path.relative)(args.dir === "." ? process.cwd() : args.dir, filePath);
+        const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
+        const relPath = (0, import_path3.relative)(args.dir === "." ? process.cwd() : args.dir, filePath);
         const result = await scan(
           { content, fileName: relPath, policyId: args.policy || void 0 },
           { apiKey: args.key, apiUrl: API_URL }
@@ -697,7 +1088,7 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
         else notVerified++;
       } else {
         const filePath = batch[j];
-        const relPath = (0, import_path.relative)(args.dir, filePath);
+        const relPath = (0, import_path3.relative)(args.dir, filePath);
         const errMsg = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
         if (!args.json) {
           write(`  ${c.yellow}\u26A0${c.reset}  ${c.yellow}WARNING${c.reset}      ${relPath.padEnd(30)}  ${c.gray}${errMsg}${c.reset}`);
@@ -707,11 +1098,11 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
       }
     }
   }
-  const summary = { total: files.length, verified, notVerified, notAssessed, errors };
-  writeGithubJobSummary(jsonResults, summary);
-  writeSummaryFile(args.summaryFile, jsonResults, summary);
+  const summary2 = { total: files.length, verified, notVerified, notAssessed, errors };
+  writeGithubJobSummary(jsonResults, summary2);
+  writeSummaryFile(args.summaryFile, jsonResults, summary2);
   if (args.json) {
-    write(JSON.stringify({ results: jsonResults, summary }, null, 2));
+    write(JSON.stringify({ results: jsonResults, summary: summary2 }, null, 2));
     if (errors > 0) process.exit(EXIT_EXECUTION_ERROR);
     if (args.ci) {
       if (notVerified > 0) process.exit(EXIT_NOT_VERIFIED);
@@ -720,7 +1111,7 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
     return;
   }
   if (args.markdown) {
-    write(markdownSummary(jsonResults, summary));
+    write(markdownSummary(jsonResults, summary2));
     if (errors > 0) process.exit(EXIT_EXECUTION_ERROR);
     if (args.ci) {
       if (notVerified > 0) process.exit(EXIT_NOT_VERIFIED);
@@ -843,6 +1234,10 @@ async function main() {
     printHelp();
     process.exit(EXIT_OK);
   }
+  if (args.command === "mcp") {
+    await runMcpServer({ version: VERSION, apiKey: args.key, apiUrl: API_URL });
+    return;
+  }
   if (args.command === "scan") {
     if (args.profiles.length > 0) await runProfile(args);
     else await runScan(args);