coil-mcp 1.7.0

package/README.md

@@ -0,0 +1,91 @@
+# coil-mcp
+
+**Live US stock market data and trading signals, as an MCP server.** Market regime, ranked buy
+lists, 0-100 opportunity / entry-timing / hold-strength scores across ~575 S&P 500, Nasdaq-100
+and macro names, sector rotation, and a 24/7 crypto board covering 81 pairs.
+
+The free tier needs **no key, no wallet, no signup**.
+
+## Install
+
+Claude Code speaks remote MCP directly — you do not need this package:
+
+```
+claude mcp add --transport http coil https://coil.trade/mcp
+```
+
+For clients that launch servers by command (Claude Desktop, Cursor, Windsurf), use this bridge:
+
+```json
+{
+  "mcpServers": {
+    "coil": { "command": "npx", "args": ["-y", "coil-mcp"] }
+  }
+}
+```
+
+Or run it directly:
+
+```
+npx -y coil-mcp
+```
+
+## What you get for free
+
+The full board, delayed one market day, with no account of any kind:
+`get_market_regime`, `get_buy_list`, `get_stock_read`, `get_market_leaders`, `get_sector_read`,
+`get_crypto_trend`, `get_morning_brief`, `get_day_board`, `get_rotation`, `get_crypto_day`,
+`get_crypto_night`, `get_hold_state`.
+
+## Live data
+
+Every free tool has a `*_live` twin. Two ways to open them:
+
+**Pay per call** — x402, USDC on Base, Solana or Algorand. $0.001 to $0.25 per read, no
+account and no card. A wallet-equipped client pays inline via `params._meta["x402/payment"]`
+(@x402/mcp compatible). Cheapest read is `/api/crypto/gate` at $0.001.
+
+**Subscribe** — [Coil Live](https://coil.trade/live-feed) is $29/mo and unlocks every `*_live`
+tool plus two sold nowhere else: `get_engine_feed` and `get_live_rules`.
+
+```
+COIL_LICENSE_KEY=your_key npx -y coil-mcp   # subscription
+COIL_KEY=your_free_key    npx -y coil-mcp   # free key: 25 live calls/day on the cheap slices
+```
+
+Mint a free key with no signup flow:
+
+```
+curl -X POST https://coil.trade/api/key -H 'Content-Type: application/json' \
+  -d '{"email":"you@example.com"}'
+```
+
+Or sign in with a wallet instead of an email — SIWX / CAIP-122 on Base, Solana or Algorand.
+The signature moves no funds. See [coil.trade/auth.md](https://coil.trade/auth.md).
+
+## What this package is
+
+A dependency-free stdio bridge. It forwards JSON-RPC verbatim to `https://coil.trade/mcp` and
+never inspects, rewrites or caches a payload — whatever the server supports, this supports,
+including tools added after you installed it. Point it elsewhere with `COIL_MCP_URL`.
+
+Zero dependencies is deliberate: a market-data bridge should not ask you to trust a package
+tree. Node 18+.
+
+## Honest limits
+
+Coil is an **impersonal research publication** — identical for every reader, never
+individualized advice. Scores describe historical and technical structure, not future returns.
+Where a study failed, the read says so: the overnight crypto continuation product ships its own
+refutation, because the ranking beat its random null but the studied trade lost money at real
+Robinhood taker fees.
+
+The engine's live record, next to SPY and QQQ, win or lose: [coil.trade/results](https://coil.trade/results)
+
+## Links
+
+- Agent docs and the full endpoint catalogue: [coil.trade/agents](https://coil.trade/agents)
+- OpenAPI: [coil.trade/openapi.json](https://coil.trade/openapi.json)
+- Free proof chain: [coil.trade/api/board/proof](https://coil.trade/api/board/proof)
+
+MIT © Coil Technologies LLC

package/bin/coil-mcp.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+// coil-mcp — stdio bridge to Coil's remote MCP server (https://coil.trade/mcp).
+//
+// WHY THIS EXISTS: Claude Code speaks remote MCP natively, so for that client this package is
+// redundant. It exists for the clients that only speak stdio (Claude Desktop configs, Cursor,
+// Windsurf, and anything driving an MCP server by command+args) and for the operators who
+// reach for `npx` before reading docs. Measured channel ranking says ~99% of MCP distribution
+// routes around the directories and through npm/PyPI — this is the npm half of that.
+//
+// ZERO DEPENDENCIES on purpose: an install that pulls a tree is an install a cautious operator
+// abandons, and a market-data bridge asking for transitive trust is a bad trade. Node 18+ has
+// fetch and that is all this needs.
+//
+//   npx -y coil-mcp                 # free tier: delayed board, no key, no wallet
+//   COIL_KEY=... npx -y coil-mcp    # free key  -> higher daily limit on the cheap slices
+//   COIL_LICENSE_KEY=... npx -y coil-mcp   # Coil Live subscription -> every *_live tool
+//
+// It is a PROXY, not a client: it forwards JSON-RPC verbatim and never inspects, rewrites or
+// caches a payload. Whatever the server supports, this supports, including tools added later.
+const ENDPOINT = process.env.COIL_MCP_URL || "https://coil.trade/mcp";
+const VERSION = "1.0.0";
+
+function headers() {
+  const h = {
+    "content-type": "application/json",
+    // Our worker can answer either way; accept both so a server-side switch to SSE framing
+    // does not break installed clients.
+    accept: "application/json, text/event-stream",
+    "user-agent": `coil-mcp/${VERSION} (+https://coil.trade/agents)`,
+  };
+  if (process.env.COIL_KEY) h["X-Coil-Key"] = process.env.COIL_KEY;
+  if (process.env.COIL_LICENSE_KEY) h["X-License-Key"] = process.env.COIL_LICENSE_KEY;
+  return h;
+}
+
+// The server may reply as plain JSON or as SSE (`data: {...}`). Take the LAST data frame:
+// that is the terminal message of the response stream.
+function parseBody(text, contentType = "") {
+  const t = text.trim();
+  if (contentType.includes("text/event-stream") || t.startsWith("event:") || t.startsWith("data:")) {
+    const frames = t.split("\n").filter((l) => l.startsWith("data: ")).map((l) => l.slice(6));
+    if (!frames.length) throw new Error("empty SSE response");
+    return JSON.parse(frames[frames.length - 1]);
+  }
+  return JSON.parse(t);
+}
+
+async function forward(msg) {
+  const r = await fetch(ENDPOINT, { method: "POST", headers: headers(), body: JSON.stringify(msg) });
+  const text = await r.text();
+  if (!r.ok && !text.trim()) throw new Error(`HTTP ${r.status} from ${ENDPOINT}`);
+  return parseBody(text, r.headers.get("content-type") || "");
+}
+
+const out = (obj) => process.stdout.write(JSON.stringify(obj) + "\n");
+
+// MCP stdio framing is newline-delimited JSON. Buffer across chunk boundaries — a large
+// tools/list reply arrives split, and parsing per-chunk drops messages non-deterministically.
+let buf = "";
+let stdinEnded = false;
+const inflight = new Set();
+
+// Requests are dispatched CONCURRENTLY and each reply is written when it lands. JSON-RPC ids
+// exist precisely so responses need not be ordered, and awaiting inside the read loop would
+// serialise a client's whole batch behind its slowest call.
+function dispatch(msg) {
+  // Notifications carry no id and expect no reply. Forward and stay silent — emitting a
+  // response to a notification is a protocol violation some clients treat as fatal.
+  const isNotification = msg.id === undefined || msg.id === null;
+  const p = forward(msg)
+    .then((res) => { if (!isNotification) out(res); })
+    .catch((e) => {
+      if (!isNotification) {
+        out({ jsonrpc: "2.0", id: msg.id,
+              error: { code: -32603, message: `coil-mcp bridge: ${String(e && e.message || e)}` } });
+      }
+    })
+    .finally(() => { inflight.delete(p); maybeExit(); });
+  inflight.add(p);
+}
+
+// Exit ONLY when stdin is closed AND nothing is in flight. Exiting on "end" alone kills every
+// pending request — the first version did exactly that and emitted zero responses for a piped
+// session, which is how a bridge ships looking fine and works for nobody.
+function maybeExit() {
+  if (stdinEnded && inflight.size === 0) process.exit(0);
+}
+
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  buf += chunk;
+  let i;
+  while ((i = buf.indexOf("\n")) >= 0) {
+    const line = buf.slice(0, i).trim();
+    buf = buf.slice(i + 1);
+    if (!line) continue;
+    let msg;
+    try { msg = JSON.parse(line); } catch { continue; }   // not our frame; drop it, never crash
+    dispatch(msg);
+  }
+});
+process.stdin.on("end", () => {
+  const tail = buf.trim();          // a final line with no trailing newline is still a message
+  buf = "";
+  if (tail) { try { dispatch(JSON.parse(tail)); } catch { /* not our frame */ } }
+  stdinEnded = true;
+  maybeExit();
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "coil-mcp",
+  "version": "1.7.0",
+  "description": "MCP server for live US stock market data and trading signals \u2014 market regime (risk-on/risk-off), ranked buy lists, 0-100 opportunity and hold scores across ~575 S&P 500 and Nasdaq-100 names, sector rotation, and a 24/7 crypto board for 81 pairs. Free tier needs no key, no wallet, no signup; pay-per-call over x402 in USDC for live data.",
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "mcp-server",
+    "claude",
+    "claude-code",
+    "claude-desktop",
+    "cursor",
+    "windsurf",
+    "ai-agent",
+    "llm-tools",
+    "stock-market",
+    "stocks",
+    "market-data",
+    "trading",
+    "trading-signals",
+    "stock-scanner",
+    "finance",
+    "financial-data",
+    "sp500",
+    "nasdaq",
+    "market-regime",
+    "sector-rotation",
+    "crypto",
+    "bitcoin",
+    "x402",
+    "agentic-payments",
+    "usdc"
+  ],
+  "homepage": "https://coil.trade/agents",
+  "bugs": {
+    "url": "https://coil.trade/agents"
+  },
+  "license": "MIT",
+  "author": "Coil Technologies LLC",
+  "type": "module",
+  "bin": {
+    "coil-mcp": "bin/coil-mcp.mjs"
+  },
+  "files": [
+    "bin/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}