agentverify 1.4.0 → 2.0.0

package/dist/cli.mjs

@@ -4,9 +4,645 @@ import {
 } from "./chunk-XVA2M2HS.mjs";
 
 // src/cli.ts
-import { readFileSync, readdirSync, statSync, appendFileSync, writeFileSync } from "fs";
-import { join, relative, extname } from "path";
-var VERSION = "1.4.0";
+import { readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2, appendFileSync, writeFileSync } from "fs";
+import { join as join2, relative as relative2, extname as extname2 } from "path";
+
+// src/mcp.ts
+import { createInterface } from "readline";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve } from "path";
+
+// src/files.ts
+import { readFileSync, readdirSync, statSync, existsSync } from "fs";
+import { basename, extname, join, relative, sep } from "path";
+import { homedir, platform } from "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 = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry) || SKIP_FILES.has(entry)) continue;
+    const full = join(dir, entry);
+    let st;
+    try {
+      st = statSync(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) walk(full, out);
+    else if (SCANNABLE_EXTENSIONS.has(extname(entry).toLowerCase())) out.push(full);
+  }
+}
+function pickFiles(target) {
+  const notes = [];
+  let st;
+  try {
+    st = statSync(target);
+  } catch {
+    throw new Error(`Path not found: ${target}`);
+  }
+  if (st.isFile()) {
+    if (st.size > MAX_TOTAL_BYTES) throw new Error(`${basename(target)} is larger than 5MB, which is the most one scan can take.`);
+    return { files: [{ path: basename(target), content: 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: relative(target, full).split(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 = statSync(full).size;
+    } catch {
+      continue;
+    }
+    if (size > MAX_FILE_BYTES) {
+      tooBig++;
+      continue;
+    }
+    if (total + size > MAX_TOTAL_BYTES) break;
+    files.push({ path: rel, content: 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 = homedir();
+  const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+  const claudeDesktop = platform() === "win32" ? join(appData, "Claude", "claude_desktop_config.json") : platform() === "darwin" ? join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") : join(home, ".config", "Claude", "claude_desktop_config.json");
+  return [
+    { client: "Claude Code (this project)", path: join(cwd, ".mcp.json") },
+    { client: "Claude Code (user)", path: join(home, ".claude.json") },
+    { client: "Claude Desktop", path: claudeDesktop },
+    { client: "Cursor (this project)", path: join(cwd, ".cursor", "mcp.json") },
+    { client: "Cursor (user)", path: join(home, ".cursor", "mcp.json") },
+    { client: "VS Code (this project)", path: join(cwd, ".vscode", "mcp.json") },
+    { client: "Windsurf", 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, `${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) => 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 = 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() ? 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 = readFileSync2(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 = 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
+import { closeSync, constants, fstatSync, lstatSync, openSync, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "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 };
+var VENDORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "__pycache__"]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".bmp",
+  ".tif",
+  ".tiff",
+  ".avif",
+  ".pdf",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".zip",
+  ".gz",
+  ".tgz",
+  ".tar",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".wasm",
+  ".so",
+  ".dll",
+  ".dylib",
+  ".exe",
+  ".class",
+  ".jar",
+  ".pyc",
+  ".sqlite",
+  ".db"
+]);
+var PackageError = class extends Error {
+};
+function displayPath(path) {
+  return JSON.stringify(safeText(path));
+}
+function safeText(text) {
+  let out = "";
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    const hidden = cp < 32 || cp >= 127 && cp <= 159 || cp === 173 || cp === 1564 || cp === 6158 || cp === 65279 || cp >= 8203 && cp <= 8207 || cp >= 8234 && cp <= 8238 || cp >= 8288 && cp <= 8292 || cp >= 8294 && cp <= 8297 || cp >= 917504 && cp <= 917999 || cp >= 55296 && cp <= 57343;
+    out += hidden ? `\\u{${cp.toString(16).toUpperCase().padStart(4, "0")}}` : ch;
+  }
+  return out;
+}
+function nameProblem(name) {
+  for (let i = 0; i < name.length; i++) {
+    const c2 = name.charCodeAt(i);
+    if (c2 >= 55296 && c2 <= 56319) {
+      const next = name.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i++;
+        continue;
+      }
+      return "contains an unpaired UTF-16 surrogate";
+    }
+    if (c2 >= 56320 && c2 <= 57343) return "contains an unpaired UTF-16 surrogate";
+  }
+  return null;
+}
+var strictUtf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+function decodeStrict(bytes) {
+  return strictUtf8.decode(bytes);
+}
+function listEntries(dir, shown) {
+  const entries = [];
+  if (process.platform === "win32") {
+    for (const d of readdirSync2(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 readdirSync2(dir, { withFileTypes: true, encoding: "buffer" })) {
+      let name;
+      try {
+        name = decodeStrict(d.name);
+      } catch {
+        throw new PackageError(`An entry in ${displayPath(shown)} has a name that is not valid UTF-8, so it cannot be sent faithfully.`);
+      }
+      entries.push({ name, kind: d.isSymbolicLink() ? "symlink" : d.isDirectory() ? "dir" : d.isFile() ? "file" : "other" });
+    }
+  }
+  return entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+var symlinkMessage = (rel) => `${displayPath(rel)} is a symbolic link. The CLI does not follow symbolic links, and a package containing one cannot be represented faithfully. Replace it with the file or directory it points to, or remove it.`;
+var specialMessage = (rel) => `${displayPath(rel)} is not a regular file or directory (it is a device, socket or pipe), so it cannot be sent.`;
+function readRegularFile(full, rel, budget) {
+  let fd;
+  try {
+    fd = openSync(full, constants.O_RDONLY | (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 = 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 = readFileSync3(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 {
+    closeSync(fd);
+  }
+}
+var extensionOf = (name) => {
+  const i = name.lastIndexOf(".");
+  return i <= 0 ? "" : name.slice(i).toLowerCase();
+};
+function buildPackage(root) {
+  let rootStat;
+  try {
+    rootStat = lstatSync(root);
+  } catch {
+    throw new PackageError(`${displayPath(root)} does not exist or cannot be read.`);
+  }
+  if (rootStat.isSymbolicLink()) throw new PackageError(symlinkMessage(root));
+  if (!rootStat.isDirectory()) throw new PackageError(`${displayPath(root)} is not a directory. A profile assessment takes a directory.`);
+  const files = [];
+  const skipped = [];
+  const budget = { total: 0 };
+  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;
+      const full = `${dir}/${entry.name}`;
+      if (entry.kind === "symlink") throw new PackageError(symlinkMessage(rel));
+      if (entry.kind === "other") throw new PackageError(specialMessage(rel));
+      if (entry.kind === "dir") {
+        if (VENDORED_DIRS.has(entry.name)) {
+          skipped.push({ path: rel, reason: "vendored directory" });
+          continue;
+        }
+        walk2(full, rel, depth + 1);
+        continue;
+      }
+      if (BINARY_EXTENSIONS.has(extensionOf(entry.name))) {
+        skipped.push({ path: rel, reason: "binary asset" });
+        continue;
+      }
+      if (files.length >= LOCAL_LIMITS.maxFiles) throw new PackageError(`The package has more than ${LOCAL_LIMITS.maxFiles} files, over the CLI's local guard.`);
+      const bytes = readRegularFile(full, rel, budget);
+      let content;
+      try {
+        content = decodeStrict(bytes);
+      } catch {
+        throw new PackageError(`${displayPath(rel)} is not valid UTF-8 text, so it cannot be sent faithfully. If it is a binary asset, give it a recognized binary extension or remove it from the package.`);
+      }
+      files.push({ path: rel, content });
+    }
+  };
+  walk2(root, "", 0);
+  if (files.length === 0) throw new PackageError(`${displayPath(root)} contains no files to assess.`);
+  return { files, skipped };
+}
+function serializeRequest(profile, files) {
+  return JSON.stringify({ profile, files });
+}
+async function postProfile(apiUrl, apiKey, body, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "User-Agent": "agentverify-cli/2.0.0" },
+      body,
+      signal: controller.signal
+    });
+    const text = await response.text();
+    let json = null;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      json = null;
+    }
+    return { kind: "response", status: response.status, text, json };
+  } catch (e) {
+    if (e instanceof Error && e.name === "AbortError") return { kind: "failure", message: `Request timed out after ${timeoutMs}ms` };
+    return { kind: "failure", message: `Request failed: ${e instanceof Error ? e.message : String(e)}` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str = (v) => typeof v === "string" ? safeText(v) : typeof v === "number" || typeof v === "boolean" ? String(v) : "";
+function formatAssessment(body, skipped) {
+  const a = isObj(body.assessment) ? body.assessment : {};
+  const profile = isObj(a.profile) ? a.profile : {};
+  const pkg = isObj(a.package) ? a.package : {};
+  const lines = [];
+  lines.push("Agent Verify profile assessment");
+  lines.push(`Profile:            ${str(body.profile)}`);
+  lines.push(`Framework:          ${str(profile.framework)} (upstream ${str(profile.upstreamRepo)} @ ${str(profile.upstreamCommit).slice(0, 12)}, ${str(profile.upstreamStatus)}; profile version ${str(profile.agentverifyProfileVersion)})`);
+  lines.push(`Assessment schema:  ${str(a.schemaVersion)}`);
+  lines.push(`Interpretation:     scanner ${str(profile.scannerVersion)}, engine ${str(profile.assessmentEngineVersion)}, risk rubric ${str(profile.riskRubricVersion)}, key allowlist ${str(profile.keyAllowlistVersion)}, normalization ${str(profile.normalizationVersion)}`);
+  lines.push(`Package:            ${str(pkg.fileCount)} files, digest ${str(pkg.digest)}`);
+  lines.push(`Attestation:        ${body.attestation === null ? "none (this profile assessment is unsigned)" : "present (not verified by this CLI)"}`);
+  lines.push("");
+  for (const control of Array.isArray(a.controls) ? a.controls : []) {
+    if (!isObj(control)) continue;
+    const cov = isObj(control.coverage) ? control.coverage : {};
+    lines.push(`${str(control.controlId)} ${str(control.title)}: ${str(control.status)} (confidence ${str(control.confidence)})`);
+    lines.push(`  ${str(cov.evidenceObserved)} evidence observed, ${str(cov.gapIdentified)} gaps identified, ${str(cov.notAssessed)} not assessed, of ${str(cov.total)} checks`);
+    for (const check of Array.isArray(control.checks) ? control.checks : []) {
+      if (isObj(check)) lines.push(`  ${str(check.checkId)} ${str(check.status)}: ${str(check.title)}`);
+    }
+    lines.push("");
+  }
+  const gaps = (Array.isArray(a.evidence) ? a.evidence : []).filter((e) => isObj(e) && e.polarity === "gap");
+  lines.push(`Gaps identified (${gaps.length}):`);
+  for (const g of gaps) {
+    lines.push(`  [${str(g.severity)}] ${str(g.kind)}: ${str(g.summary)}`);
+    const locations = (Array.isArray(g.locations) ? g.locations : []).filter(isObj).slice(0, 3).map((l) => `${str(l.file)}${l.line !== void 0 ? `:${str(l.line)}` : ""}`);
+    if (locations.length) lines.push(`      at ${locations.join(", ")}`);
+  }
+  if (gaps.length === 0) lines.push("  none");
+  const notImplemented = Array.isArray(a.notImplementedControls) ? a.notImplementedControls.map(str).join(", ") : "";
+  lines.push("");
+  lines.push(`Not assessed by this profile version: ${notImplemented || "none"}`);
+  for (const note of Array.isArray(a.notes) ? a.notes : []) lines.push(`Note: ${str(note)}`);
+  if (skipped.length > 0) {
+    lines.push("");
+    lines.push(`Skipped from the package (${skipped.length}), not sent:`);
+    for (const s of skipped.slice(0, 20)) lines.push(`  ${displayPath(s.path)}: ${s.reason}`);
+    if (skipped.length > 20) lines.push(`  and ${skipped.length - 20} more`);
+  }
+  return lines;
+}
+
+// src/cli.ts
+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;
@@ -26,20 +662,20 @@ var c = {
 };
 var write = (value = "") => process.stdout.write(`${value}
 `);
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".ts", ".py", ".json", ".yaml", ".yml", ".md", ".mjs", ".cjs"]);
+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 = readdirSync(dir);
+    const entries = readdirSync3(dir);
     for (const entry of entries) {
-      if (SKIP_DIRS.has(entry)) continue;
-      const fullPath = join(dir, entry);
-      const stat = statSync(fullPath);
+      if (SKIP_DIRS2.has(entry)) continue;
+      const fullPath = join2(dir, entry);
+      const stat = statSync2(fullPath);
       if (stat.isDirectory()) {
         files.push(...collectFiles(fullPath));
-      } else if (SUPPORTED_EXTENSIONS.has(extname(entry).toLowerCase())) {
+      } else if (SUPPORTED_EXTENSIONS.has(extname2(entry).toLowerCase())) {
         files.push(fullPath);
       }
     }
@@ -61,7 +697,8 @@ function parseArgs(argv) {
     help: false,
     version: false,
     policy: "",
-    summaryFile: ""
+    summaryFile: "",
+    profiles: []
   };
   if (result.command === "--help" || result.command === "-h") {
     result.command = "";
@@ -81,6 +718,8 @@ function parseArgs(argv) {
     else if (arg === "--allow-not-assessed") result.allowNotAssessed = true;
     else if (arg === "--policy") result.policy = args[++i] ?? "";
     else if (arg === "--summary-file") result.summaryFile = args[++i] ?? "";
+    else if (arg === "--profile") result.profiles.push(args[++i] ?? "");
+    else if (arg.startsWith("--profile=")) result.profiles.push(arg.slice("--profile=".length));
     else if (arg === "--help" || arg === "-h") result.help = true;
     else if (arg === "--version" || arg === "-v") result.version = true;
     else if (!arg.startsWith("-")) result.dir = arg;
@@ -96,9 +735,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)
@@ -112,6 +754,11 @@ ${c.bold}Options:${c.reset}
                 in addition to the scanner's own verdict (e.g. financial-agent)
   --summary-file <path>
                 Write results as JSON to this path (in addition to any other output)
+  --profile <id>
+                (alpha) Assess a directory against an assessment profile instead of
+                scanning files individually. Supported: ${SUPPORTED_PROFILES.join(", ")}
+                Takes a directory; not combinable with --file, --ci, --policy,
+                --allow-not-assessed, --markdown or --summary-file.
   --version, -v Print version
   --help, -h    Show this help message
 
@@ -131,12 +778,23 @@ ${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
+
 ${c.bold}Exit codes (--ci):${c.reset}
   0   All scanned files verified
   1   NOT VERIFIED \u2014 a security/verification check failed
   2   NOT ASSESSED \u2014 insufficient evidence for a verdict (see --allow-not-assessed)
   3   Execution error \u2014 the scan itself could not run (bad key, network, missing file)
 
+${c.bold}Exit codes (--profile):${c.reset}
+  0   The assessment completed. Control and check statuses (including GAP_IDENTIFIED)
+      do not affect the exit code.
+  3   Usage or execution error \u2014 nothing was assessed
+
 ${c.bold}Get your API key:${c.reset}
   https://aimodularity.com/agentverify/dashboard
 
@@ -190,6 +848,8 @@ ${c.bold}Fix first:${c.reset}`);
   else write(`  No blocking fixes detected. Re-scan after any material change.`);
   if (result.reportInsights?.nextAction) write(`
 ${c.bold}Next action:${c.reset} ${result.reportInsights.nextAction}`);
+  const lockedFixes = (result.findings ?? []).filter((f) => f.fixLocked).length;
+  if (lockedFixes > 0) write(`${c.gray}Step-by-step fixes and corrected code for ${lockedFixes} finding${lockedFixes === 1 ? "" : "s"} are included with Pro: https://aimodularity.com/agentverify/pricing/${c.reset}`);
   const threats = getRelevantThreatCategories(result);
   if (threats.length) {
     write(`
@@ -201,8 +861,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"}`, "");
@@ -222,20 +882,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 {
-    appendFileSync(summaryPath, `${markdownSummary(results, summary)}
+    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 {
-    writeFileSync(path, JSON.stringify({ results, summary }, null, 2));
+    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}`);
   }
@@ -278,7 +938,7 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
     files = collectFiles(dir);
     if (files.length === 0) {
       write(`${c.yellow}No agent files found in ${dir}${c.reset}`);
-      write(`${c.gray}Supported: .js .ts .py .json .yaml .yml .md${c.reset}
+      write(`${c.gray}Supported: .js .jsx .ts .tsx .py .json .yaml .yml .toml .md .sh${c.reset}
 `);
       process.exit(0);
     }
@@ -293,12 +953,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 = statSync(filePath);
+        const fileStat = statSync2(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 = readFileSync(filePath, "utf-8");
-        const relPath = relative(args.dir === "." ? process.cwd() : args.dir, filePath);
+        const content = readFileSync4(filePath, "utf-8");
+        const relPath = relative2(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 }
@@ -320,7 +980,7 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
         else notVerified++;
       } else {
         const filePath = batch[j];
-        const relPath = relative(args.dir, filePath);
+        const relPath = relative2(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}`);
@@ -330,11 +990,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);
@@ -343,7 +1003,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);
@@ -373,6 +1033,89 @@ ${c.gray}No dashboard report was saved. Check API key access and retry if you ne
     if (notAssessed > 0 && !args.allowNotAssessed) process.exit(EXIT_NOT_ASSESSED);
   }
 }
+var PROFILE_TIMEOUT_MS = 6e4;
+function profileUsageError(message) {
+  console.error(`
+${c.red}Error:${c.reset} ${message}`);
+  console.error(`Run ${c.cyan}agentverify --help${c.reset} for usage
+`);
+  process.exitCode = EXIT_EXECUTION_ERROR;
+}
+function profileFailure(json, message, detail = {}) {
+  if (json) write(JSON.stringify({ error: message, ...detail }, null, 2));
+  else console.error(`
+${c.red}Error:${c.reset} ${safeText(message)}
+`);
+  process.exitCode = EXIT_EXECUTION_ERROR;
+}
+async function runProfile(args) {
+  if (args.profiles.length > 1) return profileUsageError("--profile was given more than once.");
+  const profile = args.profiles[0];
+  if (profile === "") return profileUsageError(`--profile requires a value. Supported profiles: ${SUPPORTED_PROFILES.join(", ")}`);
+  if (!SUPPORTED_PROFILES.includes(profile)) {
+    return profileUsageError(`Unknown profile ${JSON.stringify(safeText(profile))}. Supported profiles: ${SUPPORTED_PROFILES.join(", ")}`);
+  }
+  const conflicts = [];
+  if (args.file) conflicts.push("--file");
+  if (args.ci) conflicts.push("--ci");
+  if (args.allowNotAssessed) conflicts.push("--allow-not-assessed");
+  if (args.policy) conflicts.push("--policy");
+  if (args.markdown) conflicts.push("--markdown");
+  if (args.summaryFile) conflicts.push("--summary-file");
+  if (conflicts.length > 0) return profileUsageError(`--profile cannot be combined with ${conflicts.join(", ")}. A profile assessment takes a directory and reports its own result.`);
+  if (!args.key) {
+    console.error(`
+${c.red}Error:${c.reset} API key required
+`);
+    console.error(`  Set with --key av_your_key or AGENTVERIFY_API_KEY env var.`);
+    console.error(`  Get your key at https://aimodularity.com/agentverify/dashboard/
+`);
+    process.exitCode = EXIT_EXECUTION_ERROR;
+    return;
+  }
+  let built;
+  try {
+    built = buildPackage(args.dir);
+  } catch (e) {
+    return profileFailure(args.json, e instanceof PackageError ? e.message : `Could not read the package: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (args.json && built.skipped.length > 0) {
+    console.error(`Note: ${built.skipped.length} entries were skipped from the package and not sent: ${built.skipped.slice(0, 20).map((s) => `${displayPath(s.path)} (${s.reason})`).join(", ")}${built.skipped.length > 20 ? `, and ${built.skipped.length - 20} more` : ""}`);
+  }
+  const result = await postProfile(API_URL, args.key, serializeRequest(profile, built.files), PROFILE_TIMEOUT_MS);
+  if (result.kind === "failure") return profileFailure(args.json, result.message);
+  const body = result.json;
+  const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+  if (result.status !== 200) {
+    if (isObject(body) && typeof body.error === "string") {
+      if (args.json) {
+        write(JSON.stringify(body, null, 2));
+      } else {
+        console.error(`
+${c.red}Error:${c.reset} ${safeText(body.error)} (HTTP ${result.status})`);
+        const rejection = body.rejection;
+        if (isObject(rejection)) console.error(`  rejection: ${safeText(String(rejection.code ?? ""))}: ${safeText(String(rejection.message ?? ""))}${typeof rejection.path === "string" ? ` (${JSON.stringify(safeText(rejection.path))})` : ""}`);
+        if (Array.isArray(body.supportedProfiles)) console.error(`  supported profiles: ${body.supportedProfiles.map((p) => safeText(String(p))).join(", ")}`);
+        console.error("");
+      }
+      process.exitCode = EXIT_EXECUTION_ERROR;
+      return;
+    }
+    return profileFailure(args.json, `Unexpected response from the service (HTTP ${result.status})`, { status: result.status });
+  }
+  if (!isObject(body) || typeof body.profile !== "string" || !isObject(body.assessment)) {
+    return profileFailure(args.json, "The service returned a response that is not a profile assessment", { status: result.status });
+  }
+  if (args.json) {
+    write(JSON.stringify(body, null, 2));
+    return;
+  }
+  const schema = body.assessment.schemaVersion;
+  if (schema !== SUPPORTED_ASSESSMENT_SCHEMA) {
+    return profileFailure(false, `This CLI prints assessment schema ${SUPPORTED_ASSESSMENT_SCHEMA}, but the service returned ${JSON.stringify(safeText(String(schema)))}. Update the CLI, or use --json to receive the raw response.`);
+  }
+  for (const line of formatAssessment(body, built.skipped)) write(line);
+}
 async function main() {
   const args = parseArgs(process.argv);
   if (args.version) {
@@ -383,8 +1126,13 @@ 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") {
-    await runScan(args);
+    if (args.profiles.length > 0) await runProfile(args);
+    else await runScan(args);
   } else {
     console.error(`
 ${c.red}Unknown command: ${args.command}${c.reset}`);