@chainpatrol/mcp 1.10.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @chainpatrol/mcp
+
+## 1.10.0
+
+### Minor Changes
+
+- 8d8861e: Add `@chainpatrol/mcp`, an MCP server exposing every public API operation as a
+  tool, and a `chainpatrol mcp` command that serves it over stdio.
+
+  The tool surface is generated from the external API router rather than written
+  by hand, so agents reach the same capabilities the API exposes. Large value
+  lists and long explanatory prose are served as MCP resources instead of being
+  inlined in every schema, and workflow guides (organization healthcheck, trend
+  search, weekly customer-success sweep) ship as MCP prompts.
+
+  Point an MCP client at `chainpatrol mcp` after `chainpatrol login`, or set
+  `CHAINPATROL_API_KEY` for a service account.

package/README.md

@@ -0,0 +1,69 @@
+# @chainpatrol/mcp
+
+The official ChainPatrol [MCP](https://modelcontextprotocol.io) server. Every
+public API operation is available as a tool, so an agent never has to drop down
+to raw HTTP.
+
+## Use it
+
+The server ships with the CLI, which already handles login:
+
+```bash
+npm install -g @chainpatrol/cli
+chainpatrol login
+chainpatrol mcp        # speaks MCP on stdio
+```
+
+Point an MCP client at that command. For Claude Code:
+
+```jsonc
+{
+  "mcpServers": {
+    "chainpatrol": {
+      "command": "chainpatrol",
+      "args": ["mcp"],
+    },
+  },
+}
+```
+
+For a service account, set `CHAINPATROL_API_KEY` instead of logging in.
+
+## What it exposes
+
+- **Tools** — one per public API operation: asset checks and search, reports,
+  proposal review, detections and detection configs, takedowns, threats,
+  metrics, healthchecks, and organization management.
+- **Resources** — the large value lists (`chainpatrol://enums/asset_type`) and
+  the guides explaining what a proposal label or reject reason means.
+- **Prompts** — the organization healthcheck, trend search, and weekly
+  customer-success sweep.
+
+Most tools are scoped to one organization and there is no implicit default, so
+call `user_orgs` first and pass the slug explicitly.
+
+## Configuration
+
+| Variable                 | Purpose                                                       |
+| ------------------------ | ------------------------------------------------------------- |
+| `CHAINPATROL_API_KEY`    | API key; takes precedence over a stored login.                |
+| `CHAINPATROL_API_URL`    | API base URL. Defaults to `https://app.chainpatrol.io`.       |
+| `CHAINPATROL_CONFIG_DIR` | Where credentials are read from.                              |
+| `CHAINPATROL_MCP_TOOLS`  | Comma-separated tool names to expose. Everything, by default. |
+
+`CHAINPATROL_MCP_TOOLS` exists only to trade breadth for context budget — it is
+not an access control. Authorization is enforced by the API against the
+credential in use. Both entry points read it: `chainpatrol-mcp`, and
+`chainpatrol mcp`, where an explicit `--tools` takes precedence.
+
+## The tool surface is generated
+
+`src/generated/tools.json` is produced from the external tRPC router by
+`yarn tools:generate`, so a tool exists for every public operation by
+construction rather than by hand. `yarn tools:check` fails when the committed
+manifest no longer matches the router, and runs in CI — a new API endpoint
+cannot ship without the MCP surface catching up.
+
+Two deliberate gaps, both listed with reasons in the manifest's `excluded`
+array: `/internal/*` paths, and the three inbound webhook receivers
+(Cloudflare, GitHub, Notion) that third-party services call and users do not.

package/dist/chainpatrol-config.d.ts

@@ -0,0 +1,29 @@
+declare const DEFAULT_API_URL = "https://app.chainpatrol.io";
+interface StoredConfig {
+    apiUrl: string;
+    defaultOrg?: string;
+}
+declare function configDir(): string;
+declare function readJsonFile<T>(path: string): T | null;
+/**
+ * The configuration as written on disk, with no environment applied.
+ *
+ * Use this for read-modify-write: saving the *effective* config would persist a
+ * one-off `CHAINPATROL_API_URL` as the stored default, so a later command run
+ * without the variable would keep talking to the wrong API.
+ */
+declare function readStoredConfig(): StoredConfig;
+/**
+ * The effective API URL.
+ *
+ * `CHAINPATROL_API_URL` takes precedence over a stored `apiUrl` — MCP clients
+ * launch a server with an environment rather than a config file — and is read
+ * on each call rather than once at module load, so a value set after import
+ * still applies. A blank value counts as unset.
+ *
+ * Takes an already-read `stored` config when the caller has one, so resolving
+ * the whole configuration does not read the same file twice.
+ */
+declare function resolveApiUrl(stored?: StoredConfig): string;
+
+export { DEFAULT_API_URL, type StoredConfig, configDir, readJsonFile, readStoredConfig, resolveApiUrl };

package/dist/chainpatrol-config.js

@@ -0,0 +1,15 @@
+import {
+  DEFAULT_API_URL,
+  configDir,
+  readJsonFile,
+  readStoredConfig,
+  resolveApiUrl
+} from "./chunk-4VHYP4ZH.js";
+export {
+  DEFAULT_API_URL,
+  configDir,
+  readJsonFile,
+  readStoredConfig,
+  resolveApiUrl
+};
+//# sourceMappingURL=chainpatrol-config.js.map

package/dist/chainpatrol-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-4VHYP4ZH.js

@@ -0,0 +1,39 @@
+// src/chainpatrol-config.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_API_URL = "https://app.chainpatrol.io";
+function configDir() {
+  if (process.env.CHAINPATROL_CONFIG_DIR) return process.env.CHAINPATROL_CONFIG_DIR;
+  const legacy = join(homedir(), ".chainpatrol");
+  const xdg = join(
+    process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+    "chainpatrol"
+  );
+  return existsSync(legacy) && !existsSync(xdg) ? legacy : xdg;
+}
+function readJsonFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readStoredConfig() {
+  const stored = readJsonFile(join(configDir(), "config.json"));
+  return { apiUrl: DEFAULT_API_URL, ...stored };
+}
+function resolveApiUrl(stored = readStoredConfig()) {
+  const fromEnv = process.env.CHAINPATROL_API_URL?.trim();
+  return fromEnv || stored.apiUrl;
+}
+
+export {
+  DEFAULT_API_URL,
+  configDir,
+  readJsonFile,
+  readStoredConfig,
+  resolveApiUrl
+};
+//# sourceMappingURL=chunk-4VHYP4ZH.js.map

package/dist/chunk-4VHYP4ZH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/chainpatrol-config.ts"],"sourcesContent":["/**\n * The on-disk configuration shared by every ChainPatrol entry point.\n *\n * `chainpatrol`, `chainpatrol mcp` and the standalone `chainpatrol-mcp` binary\n * all read the same `config.json`, so the rules for finding it and for letting\n * `CHAINPATROL_API_URL` override it live here rather than in each of them. They\n * were duplicated once and drifted on exactly that precedence, which is the\n * reason this module exists.\n */\nimport { existsSync, readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\n\nexport const DEFAULT_API_URL = \"https://app.chainpatrol.io\";\n\nexport interface StoredConfig {\n  apiUrl: string;\n  defaultOrg?: string;\n}\n\nexport function configDir(): string {\n  if (process.env.CHAINPATROL_CONFIG_DIR) return process.env.CHAINPATROL_CONFIG_DIR;\n\n  // The legacy path wins only when it is the one that exists.\n  const legacy = join(homedir(), \".chainpatrol\");\n  const xdg = join(\n    process.env.XDG_CONFIG_HOME ?? join(homedir(), \".config\"),\n    \"chainpatrol\",\n  );\n  return existsSync(legacy) && !existsSync(xdg) ? legacy : xdg;\n}\n\nexport function readJsonFile<T>(path: string): T | null {\n  if (!existsSync(path)) return null;\n  try {\n    return JSON.parse(readFileSync(path, \"utf-8\")) as T;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * The configuration as written on disk, with no environment applied.\n *\n * Use this for read-modify-write: saving the *effective* config would persist a\n * one-off `CHAINPATROL_API_URL` as the stored default, so a later command run\n * without the variable would keep talking to the wrong API.\n */\nexport function readStoredConfig(): StoredConfig {\n  const stored = readJsonFile<Partial<StoredConfig>>(join(configDir(), \"config.json\"));\n  return { apiUrl: DEFAULT_API_URL, ...stored };\n}\n\n/**\n * The effective API URL.\n *\n * `CHAINPATROL_API_URL` takes precedence over a stored `apiUrl` — MCP clients\n * launch a server with an environment rather than a config file — and is read\n * on each call rather than once at module load, so a value set after import\n * still applies. A blank value counts as unset.\n *\n * Takes an already-read `stored` config when the caller has one, so resolving\n * the whole configuration does not read the same file twice.\n */\nexport function resolveApiUrl(stored: StoredConfig = readStoredConfig()): string {\n  const fromEnv = process.env.CHAINPATROL_API_URL?.trim();\n  return fromEnv || stored.apiUrl;\n}\n"],"mappings":";AASA,SAAS,YAAY,oBAAoB;AACzC,SAAS,eAAe;AACxB,SAAS,YAAY;AAEd,IAAM,kBAAkB;AAOxB,SAAS,YAAoB;AAClC,MAAI,QAAQ,IAAI,uBAAwB,QAAO,QAAQ,IAAI;AAG3D,QAAM,SAAS,KAAK,QAAQ,GAAG,cAAc;AAC7C,QAAM,MAAM;AAAA,IACV,QAAQ,IAAI,mBAAmB,KAAK,QAAQ,GAAG,SAAS;AAAA,IACxD;AAAA,EACF;AACA,SAAO,WAAW,MAAM,KAAK,CAAC,WAAW,GAAG,IAAI,SAAS;AAC3D;AAEO,SAAS,aAAgB,MAAwB;AACtD,MAAI,CAAC,WAAW,IAAI,EAAG,QAAO;AAC9B,MAAI;AACF,WAAO,KAAK,MAAM,aAAa,MAAM,OAAO,CAAC;AAAA,EAC/C,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AASO,SAAS,mBAAiC;AAC/C,QAAM,SAAS,aAAoC,KAAK,UAAU,GAAG,aAAa,CAAC;AACnF,SAAO,EAAE,QAAQ,iBAAiB,GAAG,OAAO;AAC9C;AAaO,SAAS,cAAc,SAAuB,iBAAiB,GAAW;AAC/E,QAAM,UAAU,QAAQ,IAAI,qBAAqB,KAAK;AACtD,SAAO,WAAW,OAAO;AAC3B;","names":[]}