@midaslabs/mcp 1.0.0

package/README.md

@@ -0,0 +1,77 @@
+# Midas MCP Server (`@midas/mcp`)
+
+Trade crypto, equities, and prediction markets — and read your portfolio — directly from **Claude, Cursor, or any MCP-compatible client**, using the Midas AI trading tools.
+
+`@midas/mcp` is a small local server you run via `npx`. It bridges your MCP client to the hosted Midas MCP endpoint, authenticated by a Midas API key. **No local wallet, no secrets beyond the key.** Every tool runs against the Midas API as your account.
+
+## Quick start
+
+1. **Get an API key** — in the Midas web app: **Settings → API keys (Developer) → Create key**. Copy the `midas_live_…` value (shown once).
+
+2. **Add it to your MCP client config:**
+
+   **Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+   ```json
+   {
+     "mcpServers": {
+       "midas": {
+         "command": "npx",
+         "args": ["-y", "@midas/mcp"],
+         "env": { "MIDAS_API_KEY": "midas_live_your_key_here" }
+       }
+     }
+   }
+   ```
+
+   **Cursor** (`.cursor/mcp.json` in your project, or the global Cursor MCP settings):
+   ```json
+   {
+     "mcpServers": {
+       "midas": {
+         "command": "npx",
+         "args": ["-y", "@midas/mcp"],
+         "env": { "MIDAS_API_KEY": "midas_live_your_key_here" }
+       }
+     }
+   }
+   ```
+
+3. **Restart the client.** The Midas tools appear automatically.
+
+## What you can do
+
+- "Show my portfolio" / "What's my P&L?"
+- "What's the price of ETH?" / "Search for BONK"
+- "Preview a swap of $100 USDC into SOL" → confirm to execute
+- "Bet $50 on Brazil to win on Polymarket"
+- "Open a 2x long on BTC perps"
+
+The full tool set (prices, market data, portfolio/positions, swaps, perps, Polymarket, World Cup markets) is whatever the Midas server exposes — this package proxies all of them, so it stays in sync with the API automatically.
+
+> **Trades require confirmation.** Fund-moving actions (swaps, perps) return a preview; the agent confirms via a dedicated step before anything executes. This is enforced server-side.
+
+## Configuration
+
+| Env var | Required | Default | Purpose |
+|---|---|---|---|
+| `MIDAS_API_KEY` | **yes** | — | Your `midas_live_…` key. Missing → the server exits with a clear error. |
+| `MIDAS_API_URL` | no | the hosted API | Override the API base (e.g. `http://localhost:3000` for local dev). The MCP endpoint is `${MIDAS_API_URL}/mcp`. |
+
+## How it works
+
+```
+Claude / Cursor  ──stdio──►  @midas/mcp (this package)  ──HTTPS + Bearer key──►  Midas /mcp
+```
+
+It's a thin **bridge**: it doesn't reimplement any trading logic. It connects to the hosted Midas MCP server as a client and proxies `tools/list` + `tools/call` through. So all tools, all auth, and all trade safety live on the server — this package just makes them reachable from a local stdio MCP client.
+
+## Troubleshooting
+
+- **"MIDAS_API_KEY … not set"** — add the `env` block above with a real key.
+- **Tools don't appear** — restart the MCP client after editing the config; check the key isn't revoked.
+- **Local dev** — set `MIDAS_API_URL=http://localhost:3000` and make sure the API (with the `/mcp` endpoint) is running.
+
+## Requirements
+
+- Node.js ≥ 18.
+- A Midas account + API key.

package/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: midas
+description: Execute crypto trades, manage your portfolio, and access AI market analysis via Midas. Supports spot, perpetuals, and prediction markets.
+---
+
+# Midas Trading Skill
+
+Use Midas to trade assets, manage your portfolio, and research markets — crypto, equity perps, and prediction markets (Polymarket) — directly from your MCP client.
+
+## Available tools
+
+The skill proxies the full Midas MCP tool set, including:
+
+- **Trading** — `preview_swap` (+ `confirm_action` to execute), `open_perps` / `close_perps`, `place_prediction_bet`. Swaps and perps go through a preview→confirm step before any funds move.
+- **Markets & prices** — `quote_price`, `search_tokens` / `search_all_markets`, `get_market_orderbook`, `get_market_activity`.
+- **Portfolio & positions** — Hyperliquid account, combo/prediction positions, order history.
+- **Research** — `get_market_analysis`, World Cup market tools, `web_search`.
+
+The exact list reflects whatever the Midas server exposes (the skill proxies it), so it stays current automatically.
+
+## Setup
+
+1. Generate a key in the Midas web app → **Settings → API keys (Developer)**.
+2. Set `MIDAS_API_KEY` in your MCP client config (see the package README for Claude Desktop / Cursor JSON).
+
+```json
+{
+  "mcpServers": {
+    "midas": {
+      "command": "npx",
+      "args": ["-y", "@midas/mcp"],
+      "env": { "MIDAS_API_KEY": "midas_live_..." }
+    }
+  }
+}
+```
+
+## Notes
+
+- A key authenticates as **one Midas account** — the skill acts as that user.
+- Fund-moving trades require explicit confirmation; the agent previews first.

package/dist/auth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads the Midas API key from the environment. The MCP client (Claude Desktop,
+ * Cursor, …) injects it via the server's `env` block — see README. Fails loudly
+ * with a link rather than starting a server that 401s on every call.
+ */
+export declare function getApiKey(): string;

package/dist/auth.js

@@ -0,0 +1,20 @@
+/**
+ * Reads the Midas API key from the environment. The MCP client (Claude Desktop,
+ * Cursor, …) injects it via the server's `env` block — see README. Fails loudly
+ * with a link rather than starting a server that 401s on every call.
+ */
+export function getApiKey() {
+    const key = process.env.MIDAS_API_KEY?.trim();
+    if (!key) {
+        throw new Error('MIDAS_API_KEY environment variable is not set.\n' +
+            'Generate a key in the Midas web app → Settings → API keys (Developer),\n' +
+            'then add it to your MCP client config, e.g.:\n' +
+            '  "env": { "MIDAS_API_KEY": "midas_live_..." }');
+    }
+    // Keys are minted as `midas_live_<prefix>_<secret>`. A soft shape check catches
+    // an obviously-wrong value (e.g. a placeholder) before the first request.
+    if (!key.startsWith('midas_live_')) {
+        throw new Error(`MIDAS_API_KEY does not look like a Midas key (expected "midas_live_…", got "${key.slice(0, 12)}…").`);
+    }
+    return key;
+}

package/dist/config.d.ts

@@ -0,0 +1 @@
+export declare function getMcpUrl(): URL;

package/dist/config.js

@@ -0,0 +1,10 @@
+/**
+ * Where the hosted Midas MCP endpoint lives. Override with MIDAS_API_URL for
+ * local dev (e.g. http://localhost:3000) or a custom prod domain. The default
+ * is the deployed API host; the MCP endpoint is `${base}/mcp`.
+ */
+const DEFAULT_BASE_URL = 'https://stss-api-production.up.railway.app';
+export function getMcpUrl() {
+    const base = (process.env.MIDAS_API_URL?.trim() || DEFAULT_BASE_URL).replace(/\/$/, '');
+    return new URL(`${base}/mcp`);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createBridgeServer } from './server.js';
+// `npx @midas/mcp --version` / `-v` — print and exit (the bin contract).
+// Reads the version from package.json without a JSON import assertion.
+async function printVersionAndExit() {
+    const { readFile } = await import('node:fs/promises');
+    const { fileURLToPath } = await import('node:url');
+    const { dirname, join } = await import('node:path');
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(await readFile(join(here, '..', 'package.json'), 'utf8'));
+    process.stdout.write(`${pkg.version}\n`);
+    process.exit(0);
+}
+async function main() {
+    const arg = process.argv[2];
+    if (arg === '--version' || arg === '-v') {
+        await printVersionAndExit();
+        return;
+    }
+    // getApiKey() (inside createBridgeServer) throws a friendly, link-bearing
+    // error when MIDAS_API_KEY is missing — surface it to stderr and exit non-zero
+    // so the MCP client shows a real failure instead of a silent hang.
+    const { server } = await createBridgeServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Stays alive on stdio; the client drives requests. Nothing else to do.
+}
+main().catch((err) => {
+    process.stderr.write(`[midas-mcp] ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,14 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+/**
+ * Builds the local stdio MCP server. It is a thin BRIDGE: it doesn't define
+ * tools itself — it connects (as an MCP client) to the hosted Midas MCP
+ * endpoint (`${MIDAS_API_URL}/mcp`) with the user's API key, and proxies
+ * tools/list + tools/call straight through. So every tool the hosted server
+ * exposes is available here with zero duplication, and trading still flows
+ * through the server's preview→confirm path unchanged.
+ */
+export declare function createBridgeServer(): Promise<{
+    server: Server;
+    upstream: Client;
+}>;

package/dist/server.js

@@ -0,0 +1,42 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { getApiKey } from './auth.js';
+import { getMcpUrl } from './config.js';
+/**
+ * Builds the local stdio MCP server. It is a thin BRIDGE: it doesn't define
+ * tools itself — it connects (as an MCP client) to the hosted Midas MCP
+ * endpoint (`${MIDAS_API_URL}/mcp`) with the user's API key, and proxies
+ * tools/list + tools/call straight through. So every tool the hosted server
+ * exposes is available here with zero duplication, and trading still flows
+ * through the server's preview→confirm path unchanged.
+ */
+export async function createBridgeServer() {
+    const apiKey = getApiKey();
+    // --- upstream: connect to the hosted /mcp as a client ---
+    const upstream = new Client({ name: 'midas-mcp-bridge', version: '1.0.0' }, { capabilities: {} });
+    const transport = new StreamableHTTPClientTransport(getMcpUrl(), {
+        requestInit: {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        },
+    });
+    await upstream.connect(transport);
+    // --- downstream: the stdio server the MCP client (Claude/Cursor) talks to ---
+    const server = new Server({ name: 'midas', version: '1.0.0' }, { capabilities: { tools: {} } });
+    // Proxy: list the hosted server's tools verbatim.
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const { tools } = await upstream.listTools();
+        return { tools };
+    });
+    // Proxy: forward a tool call to the hosted server and relay the result.
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const result = await upstream.callTool({
+            name: request.params.name,
+            arguments: request.params.arguments ?? {},
+        });
+        // The hosted server already returns a CallToolResult ({ content, isError }).
+        return result;
+    });
+    return { server, upstream };
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@midaslabs/mcp",
+  "version": "1.0.0",
+  "description": "Midas AI trading MCP server — use Midas from Claude, Cursor, and any MCP client",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "midas-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "SKILL.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "check-types": "tsc --noEmit",
+    "test": "npm run build && node --experimental-strip-types --test \"test/*.test.ts\"",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}