@agentscore-xyz/mcp-server 2.0.2 → 2.1.0

package/README.md

@@ -1,6 +1,6 @@
 # @agentscore-xyz/mcp-server
 
-MCP security trust layer. Scan packages, get trust verdicts, check incident exposure, query the abuse database. Five tools for MCP security decisions. No API key, zero config.
+MCP security trust layer. Scan packages, get trust verdicts, inspect repo-wide MCP dependencies, generate Policy Gate setup, check incident exposure, and query the abuse database. Seven tools for MCP security decisions. No API key, zero config.
 
 [![KYA Scan](https://agentscores.xyz/api/scan/badge?npm=@agentscore-xyz/mcp-server)](https://agentscores.xyz/scan?npm=@agentscore-xyz/mcp-server)
 
@@ -45,16 +45,36 @@ Your AI can now make security decisions about MCP packages:
 >
 > **Claude:** *calls scan_package* "Score 75/100, MODERATE risk. Found: preinstall script modifying npm registry config. No provenance attestations."
 
+> **You:** "Check this repo for MCP dependencies"
+>
+> **Claude:** *calls check_my_repo* "MCP dependencies found: 5. Two are warnings. Run generate_policy_gate_setup to turn these checks into a CI gate."
+
+> **You:** "Set up AgentScore Policy Gate for this repo"
+>
+> **Claude:** *calls generate_policy_gate_setup* "Here is the exact GitHub Actions workflow, the AGENTSCORE_KEY secret name, and the pilot link for your repo."
+
 ## Available Tools
 
 | Tool | What it does |
 |------|-------------|
 | `scan_package` | Full security scan: install scripts, prompt injection, source code patterns, provenance posture, MCP tool extraction |
 | `get_verdict` | Trust decision: allow, warn, or block based on scan findings. Also reports monitoring status and publisher posture. |
+| `check_my_repo` | Inspect the current repo for MCP dependencies and summarise verdicts for every package detected locally. |
+| `generate_policy_gate_setup` | Generate the exact GitHub Actions workflow and pilot handoff link needed to enforce Policy Gate in CI. |
 | `check_exposure` | Incident response: which monitored MCP servers depend on a given package? |
 | `check_abuse` | Query the KYA abuse database for reported packages or agents |
 | `monitor_status` | Check if a package is under continuous monitoring and get scan history |
 
+## From Ad-Hoc Scans To CI Enforcement
+
+The MCP server now bridges one-off package checks into the sticky product:
+
+1. Run `check_my_repo` to see every MCP package used in a repo.
+2. Run `generate_policy_gate_setup` to get the exact GitHub Actions workflow.
+3. Start the free pilot to receive a repo-scoped `AGENTSCORE_KEY`.
+
+That turns "is this package safe?" into "this repo now enforces MCP dependency policy on every PR."
+
 ## Risk Levels
 
 | Score | Risk | Meaning |
@@ -77,7 +97,7 @@ Your AI can now make security decisions about MCP packages:
 
 ## Monitoring
 
-AgentScore continuously monitors 60+ MCP packages. The `check_exposure` and `monitor_status` tools use this live dataset. When a package like axios gets compromised, you can instantly find which MCP servers are affected.
+AgentScore continuously monitors hundreds of MCP packages. The `check_exposure` and `monitor_status` tools use this live dataset. When a package like axios gets compromised, you can instantly find which MCP servers are affected.
 
 ## Links
 

package/dist/api.js

@@ -1,4 +1,4 @@
-const BASE_URL = "https://agentscores.xyz";
+const BASE_URL = "https://www.agentscores.xyz";
 const TIMEOUT_MS = 8000;
 export class ApiError extends Error {
     status;

package/dist/index.js

@@ -5,7 +5,7 @@ import { z } from "zod";
 import { handleTool } from "./tools.js";
 const server = new McpServer({
     name: "agentscore",
-    version: "2.0.2",
+    version: "2.1.0",
 });
 // --- Tools ---
 server.tool("scan_package", "Scan an npm package for MCP security issues. Checks install scripts, prompt injection patterns, suspicious URLs, source code patterns, dependency count, metadata completeness, and publisher provenance. Returns score (0-100), risk level, and detailed findings.", {
@@ -23,11 +23,18 @@ server.tool("check_abuse", "Check if a package or agent has been reported to the
 server.tool("monitor_status", "Check if an MCP package is under continuous monitoring and get its scan history. Shows current score, risk level, and recent changes.", {
     npm: z.string().describe("npm package name"),
 }, async (args) => handleTool("monitor_status", args));
+server.tool("check_my_repo", "Inspect the current repo for MCP dependencies, look up AgentScore verdicts for each package, and summarise what should be gated in CI. Use this when a developer wants to understand all MCP packages in a repo instead of scanning one package at a time.", {
+    path: z.string().optional().describe("Optional path to the repo root. Defaults to the current working directory."),
+}, async (args) => handleTool("check_my_repo", args));
+server.tool("generate_policy_gate_setup", "Generate the exact GitHub Actions workflow needed to enforce AgentScore Policy Gate for a repo. Detects MCP dependencies locally and returns the YAML, secret name, and pilot link needed for setup.", {
+    path: z.string().optional().describe("Optional path to the repo root. Defaults to the current working directory."),
+    repo_url: z.string().optional().describe("Optional repository URL override for the pilot handoff link."),
+}, async (args) => handleTool("generate_policy_gate_setup", args));
 // --- Start ---
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("AgentScore MCP server v2.0 running on stdio");
+    console.error("AgentScore MCP server v2.1 running on stdio");
 }
 main().catch((err) => {
     console.error("Fatal error:", err);

package/dist/repo.d.ts

@@ -0,0 +1,14 @@
+export type RepoDependency = {
+    name: string;
+    requestedVersion: string | null;
+    version: string | null;
+    source: string;
+};
+type RepositoryContext = {
+    repoPath: string;
+    repoUrl: string | null;
+    dependencies: RepoDependency[];
+    checkedFiles: string[];
+};
+export declare function inspectRepoForMcpDependencies(inputPath?: string): RepositoryContext;
+export {};

package/dist/repo.js

@@ -0,0 +1,172 @@
+import fs from "node:fs";
+import path from "node:path";
+const MCP_NAME_PATTERNS = [/mcp/i, /@modelcontextprotocol/i, /model-context-protocol/i];
+const CANDIDATE_CONFIG_FILES = [
+    ".mcp.json",
+    "mcp.json",
+    ".cursor/mcp.json",
+    ".vscode/mcp.json",
+    "claude_desktop_config.json",
+];
+function isMcpPackageName(value) {
+    return MCP_NAME_PATTERNS.some((pattern) => pattern.test(value));
+}
+function normaliseRequestedVersion(spec) {
+    if (!spec)
+        return null;
+    const trimmed = spec.trim();
+    if (!trimmed)
+        return null;
+    const cleaned = trimmed.replace(/^[~^]/, "");
+    return cleaned || null;
+}
+function readJsonIfExists(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveLockedVersion(lockfile, packageName) {
+    if (!lockfile)
+        return null;
+    const packageEntry = lockfile.packages?.[`node_modules/${packageName}`];
+    if (packageEntry?.version)
+        return packageEntry.version;
+    const dependencyEntry = lockfile.dependencies?.[packageName];
+    if (dependencyEntry?.version)
+        return dependencyEntry.version;
+    return null;
+}
+function extractRepositoryUrl(pkg, repoPath) {
+    const pkgRepository = typeof pkg?.repository === "string"
+        ? pkg.repository
+        : pkg?.repository?.url;
+    if (pkgRepository)
+        return pkgRepository;
+    const gitConfigPath = path.join(repoPath, ".git", "config");
+    if (!fs.existsSync(gitConfigPath))
+        return null;
+    try {
+        const gitConfig = fs.readFileSync(gitConfigPath, "utf8");
+        const match = gitConfig.match(/\[remote "origin"\][\s\S]*?url = (.+)/);
+        return match?.[1]?.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function addDependency(dependencyMap, candidate) {
+    const existing = dependencyMap.get(candidate.name);
+    if (!existing) {
+        dependencyMap.set(candidate.name, candidate);
+        return;
+    }
+    dependencyMap.set(candidate.name, {
+        ...existing,
+        requestedVersion: existing.requestedVersion || candidate.requestedVersion,
+        version: existing.version || candidate.version,
+        source: existing.source,
+    });
+}
+function collectFromPackageJson(repoPath, dependencyMap, checkedFiles) {
+    const packageJsonPath = path.join(repoPath, "package.json");
+    const lockfilePath = path.join(repoPath, "package-lock.json");
+    const pkg = readJsonIfExists(packageJsonPath);
+    if (!pkg)
+        return null;
+    checkedFiles.push("package.json");
+    const lockfile = readJsonIfExists(lockfilePath);
+    if (lockfile)
+        checkedFiles.push("package-lock.json");
+    const dependencies = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+    };
+    for (const [name, requestedVersion] of Object.entries(dependencies)) {
+        if (!isMcpPackageName(name))
+            continue;
+        addDependency(dependencyMap, {
+            name,
+            requestedVersion: typeof requestedVersion === "string"
+                ? normaliseRequestedVersion(requestedVersion) || requestedVersion
+                : null,
+            version: resolveLockedVersion(lockfile, name),
+            source: "package.json",
+        });
+    }
+    return extractRepositoryUrl(pkg, repoPath);
+}
+function extractPackagesFromCommandObject(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const command = typeof value.command === "string" ? value.command : "";
+    const args = Array.isArray(value.args)
+        ? value.args.filter((item) => typeof item === "string")
+        : [];
+    if (!command || args.length === 0)
+        return [];
+    const commandUsesPackages = ["npx", "pnpm", "pnpx", "bunx", "yarn", "npm"];
+    if (!commandUsesPackages.includes(command))
+        return [];
+    return args.filter((arg) => {
+        if (!arg || arg.startsWith("-"))
+            return false;
+        if (["exec", "dlx", "create"].includes(arg))
+            return false;
+        return isMcpPackageName(arg);
+    });
+}
+function walkForConfigPackages(value, source, dependencyMap) {
+    if (!value)
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            walkForConfigPackages(item, source, dependencyMap);
+        }
+        return;
+    }
+    if (typeof value !== "object")
+        return;
+    for (const packageName of extractPackagesFromCommandObject(value)) {
+        addDependency(dependencyMap, {
+            name: packageName,
+            requestedVersion: null,
+            version: null,
+            source,
+        });
+    }
+    for (const child of Object.values(value)) {
+        walkForConfigPackages(child, source, dependencyMap);
+    }
+}
+function collectFromConfigFiles(repoPath, dependencyMap, checkedFiles) {
+    for (const relativePath of CANDIDATE_CONFIG_FILES) {
+        const absolutePath = path.join(repoPath, relativePath);
+        const config = readJsonIfExists(absolutePath);
+        if (!config)
+            continue;
+        checkedFiles.push(relativePath);
+        walkForConfigPackages(config, relativePath, dependencyMap);
+    }
+}
+export function inspectRepoForMcpDependencies(inputPath) {
+    const repoPath = path.resolve(inputPath || ".");
+    if (!fs.existsSync(repoPath)) {
+        throw new Error(`Path does not exist: ${repoPath}`);
+    }
+    const dependencyMap = new Map();
+    const checkedFiles = [];
+    const repoUrl = collectFromPackageJson(repoPath, dependencyMap, checkedFiles);
+    collectFromConfigFiles(repoPath, dependencyMap, checkedFiles);
+    const dependencies = [...dependencyMap.values()].sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        repoPath,
+        repoUrl,
+        dependencies,
+        checkedFiles,
+    };
+}

package/dist/tools.js

@@ -1,7 +1,53 @@
 import { fetchApi, ApiError } from "./api.js";
+import { inspectRepoForMcpDependencies, } from "./repo.js";
+const WEBSITE_BASE = "https://www.agentscores.xyz";
 function text(s, isError = false) {
     return { content: [{ type: "text", text: s }], isError };
 }
+function buildIntentUrl(intent, value) {
+    const url = new URL("/contact", WEBSITE_BASE);
+    url.searchParams.set("intent", intent);
+    if (intent === "pilot" && value) {
+        url.searchParams.set("repo", value);
+    }
+    if (intent === "review" && value) {
+        url.searchParams.set("package", value);
+    }
+    return url.toString();
+}
+function normaliseRepositoryUrl(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("git@github.com:")) {
+        return `https://github.com/${trimmed.slice("git@github.com:".length).replace(/\.git$/, "")}`;
+    }
+    if (trimmed.startsWith("https://github.com/")) {
+        return trimmed.replace(/\.git$/, "");
+    }
+    return trimmed;
+}
+function policyGateHint(options) {
+    const lines = [
+        "",
+        "Policy Gate:",
+        "  Run check_my_repo to inspect every MCP dependency used by this repo.",
+        "  Run generate_policy_gate_setup to turn the same checks into a CI gate.",
+    ];
+    if (options.repoUrl) {
+        lines.push(`  Start a free pilot: ${buildIntentUrl("pilot", options.repoUrl)}`);
+    }
+    else if (options.packageName) {
+        lines.push(`  Start a free pilot: ${buildIntentUrl("pilot")}`);
+        lines.push(`  Need a written review for this package? ${buildIntentUrl("review", options.packageName)}`);
+    }
+    else {
+        lines.push(`  Start a free pilot: ${buildIntentUrl("pilot")}`);
+    }
+    return lines.join("\n");
+}
 function handleApiError(err) {
     if (err instanceof ApiError) {
         if (err.status === 429) {
@@ -9,7 +55,10 @@ function handleApiError(err) {
         }
         return text(`AgentScore API error: ${err.message}`, true);
     }
-    return text("AgentScore API is temporarily unavailable.", true);
+    if (err instanceof Error) {
+        return text(err.message, true);
+    }
+    return text("AgentScore is temporarily unavailable.", true);
 }
 function formatScan(data) {
     const lines = [
@@ -40,6 +89,7 @@ function formatScan(data) {
             lines.push(`  ${t.name}: ${t.description?.slice(0, 100) || "no description"}`);
         }
     }
+    lines.push(policyGateHint({ packageName: data.package }));
     return lines.join("\n");
 }
 function formatVerdict(data) {
@@ -61,6 +111,7 @@ function formatVerdict(data) {
     if (data.tool_count > 0) {
         lines.push("", `Tools exposed: ${data.tool_count}`);
     }
+    lines.push(policyGateHint({ packageName: data.package }));
     return lines.join("\n");
 }
 function formatExposure(data) {
@@ -114,6 +165,113 @@ function formatMonitor(data) {
     }
     return lines.join("\n");
 }
+async function fetchVerdictForDependency(dep) {
+    try {
+        const data = await fetchApi("/api/verdict", { npm: dep.name });
+        return {
+            name: dep.name,
+            requestedVersion: dep.requestedVersion,
+            version: dep.version || data.version || dep.requestedVersion,
+            source: dep.source,
+            verdict: data.verdict || "unknown",
+            score: typeof data.score === "number" ? data.score : null,
+            risk: data.risk || null,
+            monitored: Boolean(data.monitored),
+            reasons: Array.isArray(data.reasons) ? data.reasons : [],
+        };
+    }
+    catch (err) {
+        if (err instanceof ApiError) {
+            return {
+                name: dep.name,
+                requestedVersion: dep.requestedVersion,
+                version: dep.version || dep.requestedVersion,
+                source: dep.source,
+                verdict: "unknown",
+                score: null,
+                risk: null,
+                reasons: [err.code || "lookup_failed"],
+            };
+        }
+        throw err;
+    }
+}
+function formatRepoSummary(repoPath, repoUrl, checkedFiles, results) {
+    const lines = [
+        `Repo path: ${repoPath}`,
+        `Repository: ${repoUrl || "not detected"}`,
+        `Checked files: ${checkedFiles.length > 0 ? checkedFiles.join(", ") : "none"}`,
+    ];
+    if (results.length === 0) {
+        lines.push("", "No MCP dependencies found in the checked files.");
+        lines.push("If this repo uses MCP packages indirectly, point me at the repo root or add them explicitly.");
+        return lines.join("\n");
+    }
+    const counts = {
+        allow: results.filter((item) => item.verdict === "allow").length,
+        warn: results.filter((item) => item.verdict === "warn").length,
+        block: results.filter((item) => item.verdict === "block").length,
+        unknown: results.filter((item) => item.verdict === "unknown").length,
+    };
+    lines.push("", `MCP dependencies found: ${results.length}`, `Allow: ${counts.allow} | Warn: ${counts.warn} | Block: ${counts.block} | Unknown: ${counts.unknown}`, "", "Dependency verdicts:");
+    for (const item of results) {
+        const version = item.version || item.requestedVersion || "version unknown";
+        const score = item.score ?? "?";
+        const risk = item.risk || "unknown";
+        const reasons = item.reasons.length > 0 ? ` | reasons: ${item.reasons.join(", ")}` : "";
+        lines.push(`  ${item.name}@${version} - ${item.verdict.toUpperCase()} (${score}/100, ${risk}) [source: ${item.source}]${reasons}`);
+    }
+    lines.push("", "Next step:", "  Run generate_policy_gate_setup to get the exact GitHub Actions workflow for this repo.", `  Start a free pilot: ${buildIntentUrl("pilot", repoUrl)}`);
+    return lines.join("\n");
+}
+function buildWorkflowYaml(packages) {
+    const lines = [
+        "name: AgentScore Policy Gate",
+        "",
+        "on:",
+        "  pull_request:",
+        "  push:",
+        "    branches: [main]",
+        "",
+        "jobs:",
+        "  mcp-policy:",
+        "    runs-on: ubuntu-latest",
+        "    steps:",
+        "      - uses: actions/checkout@v4",
+        "      - uses: Thezenmonster/mcp-verdict-action@v1",
+        "        with:",
+        "          api-key: ${{ secrets.AGENTSCORE_KEY }}",
+        '          fail-open: "false"',
+    ];
+    if (packages.length > 0) {
+        lines.push(`          packages: "${packages.join(",")}"`);
+    }
+    return lines.join("\n");
+}
+function formatPolicyGateSetup(repoPath, repoUrl, dependencies, checkedFiles) {
+    const explicitPackages = dependencies.map((dep) => dep.name);
+    const pilotUrl = buildIntentUrl("pilot", repoUrl);
+    const lines = [
+        `Repo path: ${repoPath}`,
+        `Repository: ${repoUrl || "not detected"}`,
+        `Checked files: ${checkedFiles.length > 0 ? checkedFiles.join(", ") : "none"}`,
+        `Detected MCP dependencies: ${explicitPackages.length > 0 ? explicitPackages.join(", ") : "none"}`,
+        "",
+        "Next steps:",
+        `1. Start a free Policy Gate pilot to get a repo-scoped key: ${pilotUrl}`,
+        "2. Add a GitHub Actions secret named AGENTSCORE_KEY to the repo.",
+        "3. Save this workflow as .github/workflows/agentscore-policy-gate.yml:",
+        "",
+        buildWorkflowYaml(explicitPackages),
+    ];
+    if (explicitPackages.length === 0) {
+        lines.push("", "Note:", "  No MCP packages were detected locally. The Action can still auto-detect root package.json dependencies,", "  but if this repo uses MCP packages via config files only, add them explicitly to the packages input.");
+    }
+    else {
+        lines.push("", "Why this workflow uses an explicit package list:", "  It keeps CI aligned with the MCP dependencies detected in this repo, even when they come from config files", "  and not just the root package.json.");
+    }
+    return lines.join("\n");
+}
 export async function handleTool(name, args) {
     try {
         switch (name) {
@@ -154,6 +312,20 @@ export async function handleTool(name, args) {
                 const data = await fetchApi("/api/monitor", { npm });
                 return text(formatMonitor(data));
             }
+            case "check_my_repo": {
+                const inputPath = typeof args.path === "string" ? args.path : undefined;
+                const repo = inspectRepoForMcpDependencies(inputPath);
+                const repoUrl = normaliseRepositoryUrl(repo.repoUrl);
+                const results = await Promise.all(repo.dependencies.map(fetchVerdictForDependency));
+                return text(formatRepoSummary(repo.repoPath, repoUrl, repo.checkedFiles, results));
+            }
+            case "generate_policy_gate_setup": {
+                const inputPath = typeof args.path === "string" ? args.path : undefined;
+                const repoUrlArg = typeof args.repo_url === "string" ? args.repo_url : undefined;
+                const repo = inspectRepoForMcpDependencies(inputPath);
+                const repoUrl = normaliseRepositoryUrl(repoUrlArg || repo.repoUrl);
+                return text(formatPolicyGateSetup(repo.repoPath, repoUrl, repo.dependencies, repo.checkedFiles));
+            }
             default:
                 return text(`Unknown tool: ${name}`, true);
         }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@agentscore-xyz/mcp-server",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "mcpName": "io.github.Thezenmonster/agentscore",
-  "description": "MCP security trust layer. Scan packages, get trust verdicts, check incident exposure, query abuse database. Five tools for MCP security decisions.",
+  "description": "MCP security trust layer. Scan packages, inspect repo MCP dependencies, generate Policy Gate setup, check exposure, and query abuse data.",
   "type": "module",
   "bin": {
     "agentscore-mcp": "./dist/index.js"