@openpump/mcp 1.0.0

package/dist/chunk-P5IDZOR3.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+// src/middleware/api-key-auth.ts
+var UNAUTHORIZED_RESPONSE = {
+  jsonrpc: "2.0",
+  error: { code: -32001, message: "Unauthorized: Invalid API key" },
+  id: null
+};
+function extractRawKey(req) {
+  const xApiKey = req.headers["x-api-key"];
+  if (typeof xApiKey === "string") return xApiKey;
+  const auth = req.headers["authorization"];
+  if (typeof auth === "string" && auth.startsWith("Bearer ")) {
+    return auth.slice(7);
+  }
+  return void 0;
+}
+async function validateViaRestApi(apiKey, apiBaseUrl) {
+  try {
+    const res = await fetch(`${apiBaseUrl}/api/auth/validate`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return {
+      userId: data.userId,
+      apiKeyId: data.apiKeyId ?? "",
+      scopes: data.scopes,
+      wallets: data.wallets.map((w, i) => ({
+        id: w.id,
+        publicKey: w.publicKey,
+        label: w.label,
+        index: w.index ?? i
+      })),
+      apiKey
+    };
+  } catch {
+    return null;
+  }
+}
+function createApiKeyMiddleware(apiBaseUrl) {
+  return async function apiKeyMiddleware(req, res, next) {
+    const rawKey = extractRawKey(req);
+    if (!rawKey?.startsWith("op_sk_live_")) {
+      res.status(401).json(UNAUTHORIZED_RESPONSE);
+      return;
+    }
+    const userContext = await validateViaRestApi(rawKey, apiBaseUrl);
+    if (!userContext) {
+      res.status(401).json(UNAUTHORIZED_RESPONSE);
+      return;
+    }
+    req.userContext = userContext;
+    next();
+  };
+}
+async function validateApiKey(apiKey, apiBaseUrl) {
+  return validateViaRestApi(apiKey, apiBaseUrl);
+}
+
+export {
+  createApiKeyMiddleware,
+  validateApiKey
+};

package/dist/cli/init.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+// src/cli/init.ts
+import * as p2 from "@clack/prompts";
+import color from "picocolors";
+
+// src/cli/config.ts
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function getClaudeDesktopConfigPath() {
+  const home = os.homedir();
+  switch (process.platform) {
+    case "darwin": {
+      return path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    case "win32": {
+      return path.join(
+        process.env["APPDATA"] ?? path.join(home, "AppData", "Roaming"),
+        "Claude",
+        "claude_desktop_config.json"
+      );
+    }
+    default: {
+      return path.join(home, ".config", "Claude", "claude_desktop_config.json");
+    }
+  }
+}
+function getCursorConfigPath() {
+  return path.join(os.homedir(), ".cursor", "mcp.json");
+}
+function detectClients() {
+  const clients = [];
+  const desktopPath = getClaudeDesktopConfigPath();
+  const desktopDir = path.dirname(desktopPath);
+  const desktopDirExists = fs.existsSync(desktopDir);
+  const desktopFileExists = fs.existsSync(desktopPath);
+  if (desktopDirExists || desktopFileExists) {
+    clients.push({
+      type: "claude-desktop",
+      name: "Claude Desktop",
+      configPath: desktopPath,
+      exists: desktopFileExists
+    });
+  }
+  const cursorPath = getCursorConfigPath();
+  const cursorDir = path.dirname(cursorPath);
+  const cursorDirExists = fs.existsSync(cursorDir);
+  const cursorFileExists = fs.existsSync(cursorPath);
+  if (cursorDirExists || cursorFileExists) {
+    clients.push({
+      type: "cursor",
+      name: "Cursor",
+      configPath: cursorPath,
+      exists: cursorFileExists
+    });
+  }
+  try {
+    execSync("claude --version", { stdio: "ignore" });
+    clients.push({
+      type: "claude-code",
+      name: "Claude Code",
+      configPath: null,
+      exists: true
+    });
+  } catch {
+  }
+  return clients;
+}
+function buildServerEntry(apiKey) {
+  return {
+    command: "npx",
+    args: ["-y", "@openpump/mcp@latest"],
+    env: {
+      OPENPUMP_API_KEY: apiKey
+    }
+  };
+}
+function readConfigFile(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return { mcpServers: {} };
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf8");
+    if (!raw.trim()) {
+      return { mcpServers: {} };
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { mcpServers: {} };
+    }
+    return parsed;
+  } catch {
+    return { mcpServers: {} };
+  }
+}
+function mergeServerEntry(config, apiKey) {
+  const mcpServers = typeof config["mcpServers"] === "object" && config["mcpServers"] !== null && !Array.isArray(config["mcpServers"]) ? { ...config["mcpServers"] } : {};
+  const alreadyExists = "openpump" in mcpServers;
+  mcpServers["openpump"] = buildServerEntry(apiKey);
+  return {
+    config: { ...config, mcpServers },
+    alreadyExists
+  };
+}
+function writeConfigFile(configPath, config) {
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+function writeClientConfigs(clients, apiKey) {
+  const outcomes = [];
+  for (const client of clients) {
+    try {
+      if (client.type === "claude-code") {
+        execSync(
+          "claude mcp add openpump --transport stdio -- npx -y @openpump/mcp@latest",
+          {
+            stdio: "ignore",
+            env: { ...process.env, OPENPUMP_API_KEY: apiKey }
+          }
+        );
+        outcomes.push({
+          clientName: client.name,
+          success: true,
+          message: "Configured via `claude mcp add`"
+        });
+        continue;
+      }
+      if (!client.configPath) {
+        outcomes.push({
+          clientName: client.name,
+          success: false,
+          message: "No config path available"
+        });
+        continue;
+      }
+      const existing = readConfigFile(client.configPath);
+      const { config: merged } = mergeServerEntry(existing, apiKey);
+      writeConfigFile(client.configPath, merged);
+      outcomes.push({
+        clientName: client.name,
+        success: true,
+        message: `Updated ${client.configPath}`
+      });
+    } catch (error) {
+      outcomes.push({
+        clientName: client.name,
+        success: false,
+        message: `Failed: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  }
+  return outcomes;
+}
+
+// src/cli/prompts.ts
+import * as p from "@clack/prompts";
+function validateApiKey(value) {
+  if (!value.trim()) return "API key is required";
+  if (!value.startsWith("op_sk_live_"))
+    return 'API key must start with "op_sk_live_"';
+  if (value.length < 20) return "API key appears too short";
+  return void 0;
+}
+function validateApiKeyPrompt(value) {
+  return validateApiKey(value ?? "");
+}
+async function runPrompts(detected, flagApiKey) {
+  let apiKey;
+  if (flagApiKey) {
+    const error = validateApiKey(flagApiKey);
+    if (error) {
+      p.log.error(`Invalid --api-key: ${error}`);
+      return null;
+    }
+    apiKey = flagApiKey;
+    p.log.info("Using API key from --api-key flag");
+  } else {
+    const keyResult = await p.text({
+      message: "Enter your OpenPump API key:",
+      placeholder: "op_sk_live_...",
+      validate: validateApiKeyPrompt
+    });
+    if (p.isCancel(keyResult)) {
+      p.cancel("Setup cancelled.");
+      return null;
+    }
+    apiKey = keyResult;
+  }
+  const clientOptions = detected.map((c) => ({
+    value: c.type,
+    label: c.name,
+    hint: c.exists ? "config file found" : "directory found, will create config"
+  }));
+  const selectedTypes = await p.multiselect({
+    message: "Which clients do you want to configure?",
+    options: clientOptions,
+    required: true
+  });
+  if (p.isCancel(selectedTypes)) {
+    p.cancel("Setup cancelled.");
+    return null;
+  }
+  const selectedClients = [];
+  for (const clientType of selectedTypes) {
+    const client = detected.find((c) => c.type === clientType);
+    if (!client) continue;
+    let overwrite = false;
+    if (client.configPath && client.exists) {
+      const existing = readConfigFile(client.configPath);
+      const mcpServers = existing["mcpServers"];
+      if (typeof mcpServers === "object" && mcpServers !== null && "openpump" in mcpServers) {
+        const confirmResult = await p.confirm({
+          message: `${client.name} already has an OpenPump entry. Overwrite?`
+        });
+        if (p.isCancel(confirmResult)) {
+          p.cancel("Setup cancelled.");
+          return null;
+        }
+        if (!confirmResult) {
+          p.log.info(`Skipping ${client.name}`);
+          continue;
+        }
+        overwrite = true;
+      }
+    }
+    selectedClients.push({
+      type: client.type,
+      name: client.name,
+      configPath: client.configPath,
+      overwrite
+    });
+  }
+  if (selectedClients.length === 0) {
+    p.log.warn("No clients selected for configuration.");
+    return null;
+  }
+  return { apiKey, clients: selectedClients };
+}
+
+// src/cli/init.ts
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let apiKey;
+  let help = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--api-key" && args[i + 1]) {
+      apiKey = args[i + 1];
+      i++;
+    }
+  }
+  return { apiKey, help };
+}
+function printHelp() {
+  console.log(`
+  ${color.bold("@openpump/mcp init")} -- Configure MCP clients for OpenPump
+
+  ${color.dim("Usage:")}
+    npx @openpump/mcp init [options]
+
+  ${color.dim("Options:")}
+    --api-key <key>  OpenPump API key (op_sk_live_...)
+    --help, -h       Show this help message
+
+  ${color.dim("Supported Clients:")}
+    - Claude Desktop (macOS, Windows, Linux)
+    - Cursor
+    - Claude Code (via claude mcp add)
+
+  ${color.dim("Get your API key at:")}
+    https://openpump.io/dashboard/api-keys
+`);
+}
+try {
+  const { apiKey: flagApiKey, help } = parseArgs(process.argv);
+  if (help) {
+    printHelp();
+    process.exit(0);
+  }
+  p2.intro(color.bgCyan(color.black(" @openpump/mcp init ")));
+  const detected = detectClients();
+  if (detected.length === 0) {
+    p2.log.warn("No supported MCP clients detected on this system.");
+    p2.log.info("Supported clients: Claude Desktop, Cursor, Claude Code");
+    p2.outro("Install a supported client and try again.");
+    process.exit(0);
+  }
+  p2.log.info(`Found ${detected.length.toString()} MCP client(s): ${detected.map((c) => c.name).join(", ")}`);
+  const result = await runPrompts(detected, flagApiKey);
+  if (!result) {
+    process.exit(0);
+  }
+  const s = p2.spinner();
+  s.start("Writing configuration files...");
+  const outcomes = writeClientConfigs(result.clients, result.apiKey);
+  s.stop("Configuration complete!");
+  for (const outcome of outcomes) {
+    if (outcome.success) {
+      p2.log.success(`${outcome.clientName}: ${outcome.message}`);
+    } else {
+      p2.log.error(`${outcome.clientName}: ${outcome.message}`);
+    }
+  }
+  const configuredClients = outcomes.filter((o) => o.success).map((o) => o.clientName);
+  if (configuredClients.length > 0) {
+    p2.outro(
+      `Restart ${configuredClients.join(", ")} to activate. Problems? ${color.underline(color.cyan("https://openpump.io/docs/mcp"))}`
+    );
+  } else {
+    p2.outro("No clients were configured. Run again to retry.");
+  }
+} catch (error) {
+  p2.log.error(String(error));
+  process.exit(1);
+}

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+// src/index.ts
+if (process.argv[2] === "init") {
+  await import("./cli/init.js");
+} else {
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const { createMcpServer } = await import("./server-MDSOEEF3.js");
+  const { validateApiKey } = await import("./api-key-auth-VAQIKP2Q.js");
+  const API_KEY = process.env["OPENPUMP_API_KEY"] ?? "";
+  const API_BASE_URL = process.env["OPENPUMP_API_URL"] ?? "https://openpump.io";
+  if (!API_KEY) {
+    console.error("ERROR: OPENPUMP_API_KEY environment variable is required.");
+    console.error("");
+    console.error("Set it to your OpenPump API key (op_sk_live_...) and try again.");
+    console.error("");
+    console.error("Example:");
+    console.error("  OPENPUMP_API_KEY=op_sk_live_abc123 npx @openpump/mcp");
+    process.exit(1);
+  }
+  if (!API_KEY.startsWith("op_sk_live_")) {
+    console.error('ERROR: OPENPUMP_API_KEY must start with "op_sk_live_".');
+    console.error("");
+    console.error(`Received: "${API_KEY.slice(0, 12)}..."`);
+    process.exit(1);
+  }
+  console.error("Validating API key...");
+  const userContext = await validateApiKey(API_KEY, API_BASE_URL);
+  if (!userContext) {
+    console.error("ERROR: API key validation failed.");
+    console.error("");
+    console.error("Possible causes:");
+    console.error("  - Invalid or expired API key");
+    console.error("  - API server unreachable at " + API_BASE_URL);
+    console.error("  - Network connectivity issue");
+    process.exit(1);
+  }
+  console.error(`Authenticated as user ${userContext.userId} with ${userContext.wallets.length.toString()} wallet(s).`);
+  try {
+    const res = await fetch(`${API_BASE_URL}/api/wallets`, {
+      headers: { Authorization: `Bearer ${API_KEY}` }
+    });
+    if (res.ok) {
+      const body = await res.json();
+      const list = body.data ?? [];
+      const balanceMap = new Map(
+        list.filter((w) => w.solBalance != null).map((w) => [w.id, w.solBalance])
+      );
+      if (balanceMap.size > 0) {
+        for (const wallet of userContext.wallets) {
+          const bal = balanceMap.get(wallet.id);
+          if (bal !== void 0) wallet.solBalance = bal;
+        }
+      }
+    }
+  } catch {
+  }
+  const server = createMcpServer(userContext, API_BASE_URL);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("OpenPump MCP server running on stdio transport.");
+}

package/dist/server-MDSOEEF3.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  createMcpServer
+} from "./chunk-J3BWHCCH.js";
+export {
+  createMcpServer
+};

package/dist/server-http.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import {
+  createMcpServer
+} from "./chunk-J3BWHCCH.js";
+import {
+  createApiKeyMiddleware
+} from "./chunk-P5IDZOR3.js";
+
+// src/server-http.ts
+import express from "express";
+import { randomUUID } from "crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var API_BASE_URL = process.env["OPENPUMP_API_URL"] ?? "https://openpump.io";
+var app = express();
+app.use(express.json());
+var sessions = /* @__PURE__ */ new Map();
+var SESSION_TTL_HOURS = Number(process.env["MCP_SESSION_TTL_HOURS"] ?? 4);
+var SESSION_TTL_MS = SESSION_TTL_HOURS * 60 * 60 * 1e3;
+setInterval(() => {
+  const cutoff = Date.now() - SESSION_TTL_MS;
+  for (const [id, session] of sessions) {
+    if (session.lastActivity < cutoff) {
+      sessions.delete(id);
+    }
+  }
+}, 6e4).unref();
+async function enrichWalletBalances(userContext) {
+  try {
+    const res = await fetch(`${API_BASE_URL}/api/wallets`, {
+      headers: { Authorization: `Bearer ${userContext.apiKey}` }
+    });
+    if (!res.ok) return userContext;
+    const body = await res.json();
+    const list = body.data ?? [];
+    const balanceMap = new Map(
+      list.filter((w) => w.solBalance != null).map((w) => [w.id, w.solBalance])
+    );
+    if (balanceMap.size === 0) return userContext;
+    return {
+      ...userContext,
+      wallets: userContext.wallets.map((w) => ({
+        ...w,
+        solBalance: balanceMap.get(w.id) ?? w.solBalance
+      }))
+    };
+  } catch {
+    return userContext;
+  }
+}
+app.use("/mcp", createApiKeyMiddleware(API_BASE_URL));
+app.all("/mcp", async (req, res) => {
+  const sessionId = req.headers["mcp-session-id"];
+  const sessionIdStr = typeof sessionId === "string" ? sessionId : void 0;
+  const userContext = req.userContext;
+  if (!userContext) {
+    res.status(401).json({ error: "Unauthorized" });
+    return;
+  }
+  if (req.method === "POST" && !sessionIdStr) {
+    const enrichedContext = await enrichWalletBalances(userContext);
+    const newSessionId = randomUUID();
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => newSessionId,
+      enableDnsRebindingProtection: false
+    });
+    const mcpServer = createMcpServer(enrichedContext, API_BASE_URL);
+    await mcpServer.connect(transport);
+    sessions.set(newSessionId, { transport, lastActivity: Date.now() });
+    await transport.handleRequest(req, res, req.body);
+    return;
+  }
+  if (!sessionIdStr) {
+    res.status(400).json({ error: "Missing mcp-session-id header" });
+    return;
+  }
+  let session = sessions.get(sessionIdStr);
+  if (!session) {
+    if (req.method !== "POST") {
+      res.status(404).json({ error: "Session not found or expired" });
+      return;
+    }
+    const enrichedContext = await enrichWalletBalances(userContext);
+    const recoveredTransport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => sessionIdStr,
+      enableDnsRebindingProtection: false
+    });
+    const recoveredServer = createMcpServer(enrichedContext, API_BASE_URL);
+    await recoveredServer.connect(recoveredTransport);
+    const incomingMethod = req.body?.method;
+    if (incomingMethod !== "initialize") {
+      const syntheticInitBody = {
+        jsonrpc: "2.0",
+        id: "__recover__",
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "session-recover", version: "1.0" }
+        }
+      };
+      const noopSink = {
+        statusCode: 200,
+        headersSent: false,
+        setHeader: () => noopSink,
+        getHeader: () => void 0,
+        removeHeader: () => noopSink,
+        writeHead: () => {
+          noopSink.headersSent = true;
+          return noopSink;
+        },
+        write: () => true,
+        end: () => {
+          noopSink.headersSent = true;
+          return noopSink;
+        },
+        status: () => noopSink,
+        json: () => noopSink,
+        send: () => noopSink,
+        on: () => noopSink,
+        once: () => noopSink,
+        off: () => noopSink,
+        emit: () => true,
+        flushHeaders: () => {
+        }
+      };
+      try {
+        await recoveredTransport.handleRequest(
+          req,
+          noopSink,
+          syntheticInitBody
+        );
+      } catch {
+      }
+    }
+    session = { transport: recoveredTransport, lastActivity: Date.now() };
+    sessions.set(sessionIdStr, session);
+    await recoveredTransport.handleRequest(req, res, req.body);
+    return;
+  }
+  session.lastActivity = Date.now();
+  if (req.method === "DELETE") {
+    sessions.delete(sessionIdStr);
+    res.status(200).end();
+    return;
+  }
+  await session.transport.handleRequest(req, res, req.body);
+});
+var PORT = Number(process.env["PORT"] ?? 3001);
+app.listen(PORT, () => {
+  console.error(`OpenPump MCP server running on http://localhost:${PORT.toString()}/mcp`);
+  console.error(`API base URL: ${API_BASE_URL}`);
+});

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@openpump/mcp",
+  "version": "1.0.0",
+  "private": false,
+  "description": "OpenPump MCP server for Solana token operations on pump.fun - works with Claude Desktop, Cursor, and any MCP client",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openpump/openpump",
+    "directory": "packages/mcp-client"
+  },
+  "homepage": "https://openpump.io/docs/mcp",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "solana",
+    "pump-fun",
+    "ai",
+    "claude",
+    "cursor"
+  ],
+  "bin": {
+    "openpump-mcp": "./dist/index.js",
+    "@openpump/mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./http": "./dist/server-http.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx watch --env-file=../../.env src/index.ts",
+    "start": "node dist/index.js",
+    "start:http": "node dist/server-http.js",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "@modelcontextprotocol/sdk": "1.27.1",
+    "express": "^4.18.0",
+    "picocolors": "^1.1.1",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@openpump/typescript-config": "workspace:*",
+    "@types/express": "^4.17.21",
+    "tsup": "^8.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.2.0"
+  }
+}