@prism-llm-labs/mcp-proxy 0.1.0

package/src/cli.ts

@@ -0,0 +1,173 @@
+/**
+ * mcp-proxy CLI
+ *
+ * Usage (everything after -- is the target command):
+ *   mcp-proxy [options] -- <command> [args...]
+ *
+ * Examples:
+ *   PRISM_API_KEY=prism_live_... mcp-proxy -- npx @modelcontextprotocol/server-filesystem /path
+ *   mcp-proxy --prism-key prism_live_... -- node my-mcp-server.js
+ *
+ * Claude Desktop config:
+ *   {
+ *     "mcpServers": {
+ *       "filesystem": {
+ *         "command": "npx",
+ *         "args": ["@prism-llm-labs/mcp-proxy", "--", "npx", "@modelcontextprotocol/server-filesystem", "/path"],
+ *         "env": { "PRISM_API_KEY": "prism_live_..." }
+ *       }
+ *     }
+ *   }
+ *
+ * Options:
+ *   --prism-key <key>          Prism API key (default: $PRISM_API_KEY)
+ *   --server-name <name>       Name shown in dashboard (default: target command basename)
+ *   --project <id>             Project ID for attribution
+ *   --team <id>                Team attribution tag
+ *   --environment <env>        production|staging|development (default: production)
+ *   --session-id <id>          Explicit session ID (default: auto-generated UUID)
+ *   --session-budget <usd>     Session budget in USD (e.g. 0.10)
+ *   --max-tool-calls <n>       Max tool/resource/prompt calls per session
+ *   --capture-inputs           Log call arguments to tags (opt-in, redacted)
+ *   --capture-outputs          Log call results to tags (opt-in, redacted)
+ *   --ingest-url <url>         Override Prism ingest URL (for self-hosted)
+ *   --cost <tool=usd,...>      Per-tool cost overrides, e.g. "run_bash=0.002"
+ */
+
+import { PrismMcpProxy } from "./proxy.js";
+import type { ProxyOptions } from "./types.js";
+
+function usage(): void {
+  process.stderr.write(
+    "Usage: mcp-proxy [options] -- <command> [args...]\n" +
+    "\nOptions:\n" +
+    "  --prism-key <key>          Prism API key (default: $PRISM_API_KEY)\n" +
+    "  --server-name <name>       Name shown in dashboard\n" +
+    "  --project <id>             Project ID for attribution\n" +
+    "  --team <id>                Team attribution tag\n" +
+    "  --environment <env>        production|staging|development\n" +
+    "  --session-id <id>          Explicit session ID\n" +
+    "  --session-budget <usd>     Session budget in USD\n" +
+    "  --max-tool-calls <n>       Max calls per session\n" +
+    "  --capture-inputs           Log call arguments to tags\n" +
+    "  --capture-outputs          Log call results to tags\n" +
+    "  --ingest-url <url>         Override Prism ingest URL\n" +
+    "  --cost <tool=usd,...>      Per-tool cost overrides\n" +
+    "\nExample:\n" +
+    "  mcp-proxy -- npx @modelcontextprotocol/server-filesystem /path/to/dir\n",
+  );
+}
+
+function parseArgs(argv: string[]): { target: string[]; opts: ProxyOptions } | null {
+  const args = argv.slice(2); // strip node + script path
+  const opts: ProxyOptions = {};
+  let i = 0;
+
+  // Find -- separator
+  const dashDash = args.indexOf("--");
+
+  if (dashDash === -1) {
+    process.stderr.write("[mcp-proxy] Error: missing -- separator before target command\n");
+    return null;
+  }
+
+  const target = args.slice(dashDash + 1);
+  if (target.length === 0) {
+    process.stderr.write("[mcp-proxy] Error: no target command after --\n");
+    return null;
+  }
+
+  // Parse options before --
+  const optArgs = args.slice(0, dashDash);
+  while (i < optArgs.length) {
+    const flag = optArgs[i]!;
+    switch (flag) {
+      case "--prism-key":
+        opts.prismKey = optArgs[++i];
+        break;
+      case "--server-name":
+        opts.serverName = optArgs[++i];
+        break;
+      case "--project":
+        opts.project = optArgs[++i];
+        break;
+      case "--team":
+        opts.team = optArgs[++i];
+        break;
+      case "--environment":
+        opts.environment = optArgs[++i];
+        break;
+      case "--session-id":
+        opts.sessionId = optArgs[++i];
+        break;
+      case "--session-budget": {
+        const budget = parseFloat(optArgs[++i] ?? "");
+        if (!isNaN(budget)) opts.sessionBudgetUsd = budget;
+        break;
+      }
+      case "--max-tool-calls": {
+        const max = parseInt(optArgs[++i] ?? "", 10);
+        if (!isNaN(max)) opts.maxToolCallsPerSession = max;
+        break;
+      }
+      case "--capture-inputs":
+        opts.captureInputs = true;
+        break;
+      case "--capture-outputs":
+        opts.captureOutputs = true;
+        break;
+      case "--ingest-url":
+        opts.ingestUrl = optArgs[++i];
+        break;
+      case "--cost": {
+        const overrides: Record<string, number> = {};
+        const pairs = (optArgs[++i] ?? "").split(",");
+        for (const pair of pairs) {
+          const [tool, cost] = pair.split("=");
+          if (tool && cost) {
+            const usd = parseFloat(cost);
+            if (!isNaN(usd)) overrides[tool] = usd;
+          }
+        }
+        opts.costOverrides = overrides;
+        break;
+      }
+      case "--help":
+      case "-h":
+        usage();
+        process.exit(0);
+        break;
+      default:
+        process.stderr.write(`[mcp-proxy] Unknown flag: ${flag}\n`);
+        return null;
+    }
+    i++;
+  }
+
+  return { target, opts };
+}
+
+async function main(): Promise<void> {
+  const parsed = parseArgs(process.argv);
+  if (!parsed) {
+    usage();
+    process.exit(1);
+  }
+
+  const [targetCommand, ...targetArgs] = parsed.target as [string, ...string[]];
+  const proxy = new PrismMcpProxy(targetCommand, targetArgs, parsed.opts);
+
+  // Graceful shutdown on SIGINT / SIGTERM
+  for (const sig of ["SIGINT", "SIGTERM"] as const) {
+    process.on(sig, () => process.exit(0));
+  }
+
+  try {
+    await proxy.run();
+  } catch (err) {
+    process.stderr.write(`[mcp-proxy] Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+  }
+}
+
+main();

package/src/index.ts

@@ -0,0 +1,2 @@
+export { PrismMcpProxy } from "./proxy.js";
+export type { ProxyOptions } from "./types.js";

package/src/proxy.ts

@@ -0,0 +1,366 @@
+/**
+ * PrismMcpProxy — transparent process-level MCP proxy.
+ *
+ * Architecture:
+ *   AI Client (Claude Desktop, Cline, etc.)
+ *       ↕  MCP / stdio
+ *   PrismMcpProxy                ← this package
+ *       ↕  MCP / stdio
+ *   Target MCP server (any server, unmodified)
+ *
+ * The proxy:
+ *  1. Spawns the target as a child process via StdioClientTransport
+ *  2. Discovers what capabilities the target declares (tools / resources / prompts)
+ *  3. Creates a proxy Server that re-advertises those same capabilities
+ *  4. Intercepts every tool call, resource read, and prompt get:
+ *       – checks session budget + loop limits (pre-call)
+ *       – forwards the request to the target
+ *       – measures wall-clock latency
+ *       – ships a fire-and-forget McpEvent to /api/mcp/ingest
+ *       – returns the target's response unchanged
+ *  5. Connects the proxy Server to the caller via StdioServerTransport
+ */
+
+import { Server }               from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Client }               from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+  type ServerCapabilities,
+} from "@modelcontextprotocol/sdk/types.js";
+import { McpEventTracker, SessionBudgetChecker, lookupToolCost } from "@prism-llm-labs/mcp-sdk";
+import type { McpPrimitiveType } from "@prism-llm-labs/mcp-sdk";
+import type { ProxyOptions } from "./types.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+const DEFAULT_REDACT_KEYS = ["password", "token", "key", "secret", "api_key", "authorization"];
+
+function redactObject(obj: unknown, keys: string[]): unknown {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) return obj.map((v) => redactObject(v, keys));
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+    out[k] = keys.some((r) => k.toLowerCase().includes(r.toLowerCase()))
+      ? "[REDACTED]"
+      : redactObject(v, keys);
+  }
+  return out;
+}
+
+function safeJson(val: unknown, redactKeys: string[], maxLen: number): string {
+  try {
+    const s = JSON.stringify(redactObject(val, redactKeys));
+    return s.length <= maxLen ? s : s.slice(0, maxLen) + "…";
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+function orgFromKey(key: string): string {
+  const parts = key.split("_");
+  return parts.length >= 4 ? (parts[2] ?? "") : "";
+}
+
+function ts(): string {
+  return new Date().toISOString().replace("T", " ").slice(0, 23);
+}
+
+// ── Core class ────────────────────────────────────────────────────────────────
+
+export class PrismMcpProxy {
+  private readonly opts: {
+    prismKey:              string;
+    serverName:            string;
+    project:               string;
+    team:                  string;
+    environment:           string;
+    sessionId:             string;
+    sessionBudgetUsd?:     number;
+    maxToolCallsPerSession?: number;
+    captureInputs:         boolean;
+    captureOutputs:        boolean;
+    costOverrides:         Record<string, number>;
+  };
+  private readonly tracker:    McpEventTracker;
+  private readonly budget:     SessionBudgetChecker;
+  private readonly redactKeys: string[];
+
+  constructor(
+    private readonly targetCommand: string,
+    private readonly targetArgs:    string[],
+    options: ProxyOptions = {},
+  ) {
+    const key = options.prismKey ?? process.env["PRISM_API_KEY"] ?? "";
+    if (!key) {
+      process.stderr.write("[prism-proxy] PRISM_API_KEY not set — telemetry disabled\n");
+    }
+
+    this.opts = {
+      prismKey:              key,
+      serverName:            options.serverName     ?? targetCommand.split(/[\\/]/).pop() ?? "mcp-server",
+      project:               options.project        ?? process.env["PRISM_PROJECT"]     ?? "",
+      team:                  options.team           ?? process.env["PRISM_TEAM"]        ?? "",
+      environment:           options.environment    ?? process.env["PRISM_ENVIRONMENT"] ?? "production",
+      sessionId:             options.sessionId      ?? crypto.randomUUID(),
+      sessionBudgetUsd:      options.sessionBudgetUsd,
+      maxToolCallsPerSession: options.maxToolCallsPerSession,
+      captureInputs:         options.captureInputs  ?? false,
+      captureOutputs:        options.captureOutputs ?? false,
+      costOverrides:         options.costOverrides  ?? {},
+    };
+
+    this.redactKeys = options.redactKeys ?? DEFAULT_REDACT_KEYS;
+    this.tracker    = new McpEventTracker(key, this.opts.serverName, options.ingestUrl);
+    this.budget     = new SessionBudgetChecker(orgFromKey(key));
+  }
+
+  /**
+   * Start the proxy. Blocks until the AI client disconnects.
+   * Spawn the target server, connect both transports, then wait.
+   */
+  async run(): Promise<void> {
+    // ── 1. Connect to target server ──────────────────────────────────────────
+    const targetTransport = new StdioClientTransport({
+      command: this.targetCommand,
+      args:    this.targetArgs,
+      stderr:  "pipe",   // don't let target's stderr pollute our stdout
+    });
+
+    const targetClient = new Client(
+      { name: "prism-proxy-client", version: "1.0.0" },
+      { capabilities: {} },
+    );
+
+    await targetClient.connect(targetTransport);
+
+    const caps: ServerCapabilities = targetClient.getServerCapabilities() ?? {};
+    const hasTools     = !!caps.tools;
+    const hasResources = !!caps.resources;
+    const hasPrompts   = !!caps.prompts;
+
+    // ── 2. Build proxy server ────────────────────────────────────────────────
+    const proxyCaps: ServerCapabilities = {};
+    if (hasTools)     proxyCaps.tools     = {};
+    if (hasResources) proxyCaps.resources = { listChanged: false, subscribe: false };
+    if (hasPrompts)   proxyCaps.prompts   = { listChanged: false };
+
+    const proxyServer = new Server(
+      { name: this.opts.serverName, version: "1.0.0" },
+      { capabilities: proxyCaps },
+    );
+
+    // ── 3. Register handlers ─────────────────────────────────────────────────
+
+    if (hasTools) {
+      proxyServer.setRequestHandler(
+        ListToolsRequestSchema,
+        () => targetClient.listTools(),
+      );
+
+      proxyServer.setRequestHandler(
+        CallToolRequestSchema,
+        (req) => this._handleToolCall(req.params.name, req.params.arguments ?? {}, targetClient),
+      );
+    }
+
+    if (hasResources) {
+      proxyServer.setRequestHandler(
+        ListResourcesRequestSchema,
+        () => targetClient.listResources(),
+      );
+
+      // Resource templates — not all servers support this; ignore if unavailable
+      proxyServer.setRequestHandler(
+        ListResourceTemplatesRequestSchema,
+        async () => {
+          try {
+            return await targetClient.listResourceTemplates();
+          } catch {
+            return { resourceTemplates: [] };
+          }
+        },
+      );
+
+      proxyServer.setRequestHandler(
+        ReadResourceRequestSchema,
+        (req) => this._handleResourceRead(req.params.uri, targetClient),
+      );
+    }
+
+    if (hasPrompts) {
+      proxyServer.setRequestHandler(
+        ListPromptsRequestSchema,
+        () => targetClient.listPrompts(),
+      );
+
+      proxyServer.setRequestHandler(
+        GetPromptRequestSchema,
+        (req) => this._handlePromptGet(
+          req.params.name,
+          req.params.arguments as Record<string, string> | undefined,
+          targetClient,
+        ),
+      );
+    }
+
+    // ── 4. Connect proxy to the AI client via stdio ──────────────────────────
+    const proxyTransport = new StdioServerTransport();
+    await proxyServer.connect(proxyTransport);
+
+    // ── 5. Wait for disconnect ───────────────────────────────────────────────
+    await new Promise<void>((resolve) => {
+      proxyTransport.onclose = resolve;
+    });
+
+    try { await targetClient.close(); } catch { /* ignore */ }
+  }
+
+  // ── Private: tool call intercept ──────────────────────────────────────────
+
+  private async _handleToolCall(
+    name:   string,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    args:   Record<string, any>,
+    target: Client,
+  ) {
+    await this._checkBudget();
+
+    const estimatedCost = lookupToolCost(name, this.opts.costOverrides);
+    const start         = Date.now();
+    const eventTags: Record<string, string> = {};
+
+    if (this.opts.captureInputs) {
+      eventTags["tool_input"] = safeJson(args, this.redactKeys, 1000);
+    }
+
+    let status:   "ok" | "error" | "timeout" = "ok";
+    let errorMsg  = "";
+
+    let result: Awaited<ReturnType<Client["callTool"]>>;
+    try {
+      result = await target.callTool({ name, arguments: args });
+    } catch (err) {
+      status   = "error";
+      errorMsg = err instanceof Error ? err.message : String(err);
+      this._ship("tool", name, Date.now() - start, estimatedCost, "estimated", status, errorMsg, eventTags);
+      throw err;
+    }
+
+    const latencyMs = Date.now() - start;
+
+    // MCP tool errors are returned in the result (not thrown) with isError=true
+    if (result.isError) {
+      status = "error";
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const content = result.content as any[];
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const errBlock = Array.isArray(content) ? content.find((c: any) => c?.type === "text") : null;
+      errorMsg = (errBlock as { text?: string } | null)?.text ?? "Tool returned error";
+    }
+
+    if (this.opts.captureOutputs) {
+      eventTags["tool_output"] = safeJson(result.content, this.redactKeys, 1000);
+    }
+
+    this._ship("tool", name, latencyMs, estimatedCost, "estimated", status, errorMsg, eventTags);
+    return result;
+  }
+
+  // ── Private: resource read intercept ─────────────────────────────────────
+
+  private async _handleResourceRead(uri: string, target: Client) {
+    await this._checkBudget();
+
+    const start = Date.now();
+    let status: "ok" | "error" | "timeout" = "ok";
+    let errorMsg = "";
+
+    let result: Awaited<ReturnType<Client["readResource"]>>;
+    try {
+      result = await target.readResource({ uri });
+    } catch (err) {
+      status   = "error";
+      errorMsg = err instanceof Error ? err.message : String(err);
+      this._ship("resource", uri, Date.now() - start, 0, "estimated", status, errorMsg, {});
+      throw err;
+    }
+
+    this._ship("resource", uri, Date.now() - start, 0, "estimated", status, errorMsg, {});
+    return result;
+  }
+
+  // ── Private: prompt get intercept ────────────────────────────────────────
+
+  private async _handlePromptGet(
+    name:   string,
+    args:   Record<string, string> | undefined,
+    target: Client,
+  ) {
+    await this._checkBudget();
+
+    const start = Date.now();
+    let status: "ok" | "error" | "timeout" = "ok";
+    let errorMsg = "";
+
+    let result: Awaited<ReturnType<Client["getPrompt"]>>;
+    try {
+      result = await target.getPrompt({ name, arguments: args });
+    } catch (err) {
+      status   = "error";
+      errorMsg = err instanceof Error ? err.message : String(err);
+      this._ship("prompt", name, Date.now() - start, 0, "estimated", status, errorMsg, {});
+      throw err;
+    }
+
+    this._ship("prompt", name, Date.now() - start, 0, "estimated", status, errorMsg, {});
+    return result;
+  }
+
+  // ── Private: shared helpers ───────────────────────────────────────────────
+
+  private async _checkBudget(): Promise<void> {
+    await this.budget.checkOrThrow(
+      this.opts.sessionId,
+      this.opts.sessionBudgetUsd,
+      this.opts.maxToolCallsPerSession,
+    );
+  }
+
+  private _ship(
+    primitiveType: McpPrimitiveType,
+    toolName:      string,
+    latencyMs:     number,
+    costUsd:       number,
+    costStatus:    "estimated" | "actual",
+    status:        "ok" | "error" | "timeout",
+    errorMessage:  string,
+    tags:          Record<string, string>,
+  ): void {
+    this.tracker.capture({
+      timestamp:            ts(),
+      session_id:           this.opts.sessionId,
+      project_id:           this.opts.project,
+      team_id:              this.opts.team,
+      user_id:              "",
+      environment:          this.opts.environment,
+      tool_name:            toolName,
+      downstream_resource:  "",
+      execution_latency_ms: latencyMs,
+      tool_cost_usd:        costUsd,
+      cost_status:          costStatus,
+      status,
+      error_message:        errorMessage,
+      llm_request_id:       "",
+      primitive_type:       primitiveType,
+      tags,
+    }).catch(() => {});
+  }
+}

package/src/types.ts

@@ -0,0 +1,49 @@
+export interface ProxyOptions {
+  /** Prism API key — or set PRISM_API_KEY env var */
+  prismKey?: string;
+  /**
+   * Name shown in the Prism dashboard as the MCP server name.
+   * Defaults to the basename of the target command.
+   */
+  serverName?: string;
+  /** Project ID for cost attribution */
+  project?: string;
+  /** Team attribution tag */
+  team?: string;
+  /** "production" | "staging" | "development" (default: "production") */
+  environment?: string;
+  /**
+   * Explicit session ID. Auto-generated UUID if omitted.
+   * One proxy process = one session = one agent run.
+   */
+  sessionId?: string;
+  /**
+   * Session budget in USD. All tool/resource/prompt calls are blocked
+   * when combined session cost exceeds this value.
+   */
+  sessionBudgetUsd?: number;
+  /**
+   * Maximum MCP primitive calls per session.
+   * Blocks further calls when exceeded — loop detection guard.
+   */
+  maxToolCallsPerSession?: number;
+  /**
+   * Log call arguments into tags["tool_input"] (truncated to 1000 chars).
+   * Opt-in only — disabled by default for privacy.
+   */
+  captureInputs?: boolean;
+  /**
+   * Log call results into tags["tool_output"] (truncated to 1000 chars).
+   * Opt-in only — disabled by default for privacy.
+   */
+  captureOutputs?: boolean;
+  /**
+   * Keys to redact from captured inputs/outputs.
+   * Default: ["password", "token", "key", "secret", "api_key", "authorization"]
+   */
+  redactKeys?: string[];
+  /** Override ingest URL (for testing / self-hosted Prism) */
+  ingestUrl?: string;
+  /** Per-tool cost overrides in USD per call (tool_name → usd) */
+  costOverrides?: Record<string, number>;
+}

package/tests/proxy.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import { PrismMcpProxy } from "../src/proxy.js";
+
+describe("PrismMcpProxy", () => {
+  it("constructs without throwing when no key is set", () => {
+    // Should warn but not throw — observability must never crash the app
+    const proxy = new PrismMcpProxy("echo", ["hello"], {
+      prismKey:   "",
+      serverName: "test-server",
+      project:    "proj-1",
+    });
+    expect(proxy).toBeDefined();
+  });
+
+  it("derives server name from target command basename", () => {
+    // serverName should default to the last segment of the command path
+    const proxy = new PrismMcpProxy(
+      "/usr/local/bin/my-mcp-server",
+      [],
+      { prismKey: "prism_live_abc_def" },
+    );
+    // Access via cast to test private field
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((proxy as any).opts.serverName).toBe("my-mcp-server");
+  });
+
+  it("accepts all option overrides", () => {
+    const proxy = new PrismMcpProxy("cmd", [], {
+      prismKey:              "prism_live_abc_def",
+      serverName:            "my-server",
+      project:               "proj",
+      team:                  "team-a",
+      environment:           "staging",
+      sessionId:             "sess-123",
+      sessionBudgetUsd:      0.50,
+      maxToolCallsPerSession: 100,
+      captureInputs:         true,
+      captureOutputs:        true,
+      costOverrides:         { bash: 0.005 },
+      ingestUrl:             "https://example.com/api/mcp/ingest",
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const opts = (proxy as any).opts;
+    expect(opts.serverName).toBe("my-server");
+    expect(opts.sessionBudgetUsd).toBe(0.50);
+    expect(opts.maxToolCallsPerSession).toBe(100);
+    expect(opts.captureInputs).toBe(true);
+    expect(opts.costOverrides).toEqual({ bash: 0.005 });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target":            "ES2020",
+    "module":            "ESNext",
+    "moduleResolution":  "bundler",
+    "lib":               ["ES2020"],
+    "strict":            true,
+    "skipLibCheck":      true,
+    "declaration":       true,
+    "declarationMap":    true,
+    "sourceMap":         true,
+    "outDir":            "./dist",
+    "rootDir":           "./src"
+  },
+  "include":  ["src/**/*"],
+  "exclude":  ["node_modules", "dist", "tests"]
+}

package/tsup.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig([
+  // Library entry — consumed programmatically
+  {
+    entry:     ["src/index.ts"],
+    format:    ["cjs", "esm"],
+    dts:       true,
+    clean:     true,
+    sourcemap: true,
+    external:  ["@modelcontextprotocol/sdk"],
+  },
+  // CLI entry — executable bin; shebang added via banner
+  {
+    entry:     { cli: "src/cli.ts" },
+    format:    ["cjs"],
+    dts:       false,
+    clean:     false,
+    sourcemap: false,
+    external:  ["@modelcontextprotocol/sdk"],
+    banner:    { js: "#!/usr/bin/env node" },
+  },
+]);