@orrery-labs/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orrery
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# @orrery-labs/mcp
+
+Local stdio MCP bridge for Orrery.
+
+Use this package when an MCP client prefers launching a local server process
+instead of connecting directly to Orrery's remote HTTP endpoint.
+
+The bridge is intentionally thin:
+
+```text
+Claude / Cursor / local agent
+        ↓ stdio MCP (Content-Length framed JSON-RPC)
+@orrery-labs/mcp
+        ↓ HTTPS JSON-RPC
+https://orrery.me/api/mcp/v1
+        ↓
+Orrery x402/API-credit tools
+```
+
+It does not duplicate Orrery taxonomy, pricing, Kalshi, alert, or signal
+logic. All tool calls are forwarded to the canonical remote MCP endpoint.
+
+## Install
+
+```bash
+npx @orrery-labs/mcp
+```
+
+## Claude Desktop
+
+```json
+{
+  "mcpServers": {
+    "orrery": {
+      "command": "npx",
+      "args": ["-y", "@orrery-labs/mcp"],
+      "env": {
+        "ORRERY_API_KEY": "orrery_live_..."
+      }
+    }
+  }
+}
+```
+
+## Cursor
+
+```json
+{
+  "mcpServers": {
+    "orrery": {
+      "command": "npx",
+      "args": ["-y", "@orrery-labs/mcp"],
+      "env": {
+        "ORRERY_API_KEY": "orrery_live_..."
+      }
+    }
+  }
+}
+```
+
+## Configuration
+
+| Env var | Default | Purpose |
+|---|---|---|
+| `ORRERY_MCP_URL` | `https://orrery.me/api/mcp/v1` | Remote MCP endpoint |
+| `ORRERY_API_KEY` | unset | Orrery API-credit key, forwarded as `X-Orrery-API-Key` |
+| `ORRERY_X_PAYMENT` | unset | x402 payment proof, forwarded as `X-PAYMENT` |
+| `ORRERY_PAYMENT_SIGNATURE` | unset | x402 payment proof, forwarded as `PAYMENT-SIGNATURE` |
+| `ORRERY_MCP_STDIO_FRAMING` | `content-length` | Use `newline` only for local smoke tests |
+
+CLI flags mirror the env vars:
+
+```bash
+orrery-mcp --url https://orrery.me/api/mcp/v1 --api-key orrery_live_...
+```
+
+For quick shell smoke tests that send one JSON-RPC object per line:
+
+```bash
+ORRERY_MCP_STDIO_FRAMING=newline orrery-mcp --url http://localhost:3000/api/mcp/v1
+```
+
+## Safety
+
+Orrery is read-only. The MCP bridge exposes intelligence tools, resources,
+and prompts. It does not trade, submit orders, connect to Polymarket/Kalshi
+accounts, read private positions, or provide buy/sell recommendations.

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import { stdin, stdout, stderr, exit } from "node:process";
+function parseArgs(argv) {
+    const opts = {
+        url: process.env.ORRERY_MCP_URL ?? "https://orrery.me/api/mcp/v1",
+        apiKey: process.env.ORRERY_API_KEY ?? null,
+        payment: process.env.ORRERY_X_PAYMENT ?? null,
+        paymentSignature: process.env.ORRERY_PAYMENT_SIGNATURE ?? null,
+        framing: process.env.ORRERY_MCP_STDIO_FRAMING === "newline"
+            ? "newline"
+            : "content-length",
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--help" || arg === "-h") {
+            printHelp();
+            exit(0);
+        }
+        if (arg === "--url")
+            opts.url = requireValue(argv, ++i, "--url");
+        else if (arg === "--api-key")
+            opts.apiKey = requireValue(argv, ++i, "--api-key");
+        else if (arg === "--payment")
+            opts.payment = requireValue(argv, ++i, "--payment");
+        else if (arg === "--payment-signature") {
+            opts.paymentSignature = requireValue(argv, ++i, "--payment-signature");
+        }
+        else if (arg === "--stdio-framing") {
+            const value = requireValue(argv, ++i, "--stdio-framing");
+            if (value !== "content-length" && value !== "newline") {
+                throw new Error("--stdio-framing must be content-length or newline");
+            }
+            opts.framing = value;
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    opts.url = opts.url.replace(/\/$/, "");
+    return opts;
+}
+function requireValue(argv, index, flag) {
+    const value = argv[index];
+    if (!value || value.startsWith("--"))
+        throw new Error(`Missing value for ${flag}`);
+    return value;
+}
+function printHelp() {
+    stderr.write(`@orrery-labs/mcp
+
+Local stdio MCP bridge for Orrery.
+
+Usage:
+  orrery-mcp [--url URL] [--api-key KEY] [--payment PROOF]
+
+Env:
+  ORRERY_MCP_URL            default https://orrery.me/api/mcp/v1
+  ORRERY_API_KEY            forwarded as X-Orrery-API-Key
+  ORRERY_X_PAYMENT          forwarded as X-PAYMENT
+  ORRERY_PAYMENT_SIGNATURE  forwarded as PAYMENT-SIGNATURE
+  ORRERY_MCP_STDIO_FRAMING  content-length (default) or newline
+
+The process accepts standard MCP Content-Length framed JSON-RPC from
+stdin and writes Content-Length framed responses to stdout. It also
+accepts newline-delimited JSON-RPC for smoke tests; pass
+--stdio-framing newline if your test harness expects line output.
+`);
+}
+async function main() {
+    let opts;
+    try {
+        opts = parseArgs(process.argv.slice(2));
+    }
+    catch (err) {
+        stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        printHelp();
+        exit(1);
+    }
+    let input = Buffer.alloc(0);
+    let processing = false;
+    async function pump() {
+        if (processing)
+            return;
+        processing = true;
+        try {
+            while (true) {
+                const message = readNextMessage();
+                if (message === null)
+                    return;
+                try {
+                    await handlePayloadText(message, opts);
+                }
+                catch (err) {
+                    write({
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: {
+                            code: -32603,
+                            message: err instanceof Error ? err.message : String(err),
+                        },
+                    }, opts);
+                }
+            }
+        }
+        finally {
+            processing = false;
+        }
+    }
+    function readNextMessage() {
+        if (input.length === 0)
+            return null;
+        const headerEnd = input.indexOf("\r\n\r\n");
+        if (headerEnd >= 0) {
+            const header = input.subarray(0, headerEnd).toString("utf8");
+            const match = /^Content-Length:\s*(\d+)\s*$/im.exec(header);
+            if (match) {
+                const length = Number(match[1]);
+                if (!Number.isSafeInteger(length) || length < 0) {
+                    input = input.subarray(headerEnd + 4);
+                    write({
+                        jsonrpc: "2.0",
+                        id: null,
+                        error: { code: -32700, message: "Invalid Content-Length header" },
+                    }, opts);
+                    return null;
+                }
+                const bodyStart = headerEnd + 4;
+                const bodyEnd = bodyStart + length;
+                if (input.length < bodyEnd)
+                    return null;
+                const body = input.subarray(bodyStart, bodyEnd).toString("utf8");
+                input = input.subarray(bodyEnd);
+                return body;
+            }
+        }
+        const preview = input.subarray(0, Math.min(64, input.length)).toString("utf8");
+        if (/^Content-Length:/i.test(preview) && headerEnd < 0)
+            return null;
+        const newline = input.indexOf(10);
+        if (newline < 0)
+            return null;
+        const line = input.subarray(0, newline).toString("utf8").trim();
+        input = input.subarray(newline + 1);
+        return line || null;
+    }
+    stdin.on("data", (chunk) => {
+        input = Buffer.concat([input, chunk]);
+        void pump();
+    });
+    stdin.on("error", (err) => {
+        stderr.write(`stdin error: ${err.message}\n`);
+        exit(1);
+    });
+}
+async function handlePayloadText(text, opts) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return;
+    let payload;
+    try {
+        payload = JSON.parse(trimmed);
+    }
+    catch {
+        write({
+            jsonrpc: "2.0",
+            id: null,
+            error: { code: -32700, message: "Parse error: invalid JSON" },
+        }, opts);
+        return;
+    }
+    const response = await forward(payload, opts);
+    if (response !== null)
+        write(response, opts);
+}
+async function forward(payload, opts) {
+    const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "X-Orrery-MCP-Bridge": "@orrery-labs/mcp/0.1.0",
+    };
+    if (opts.apiKey)
+        headers["X-Orrery-API-Key"] = opts.apiKey;
+    if (opts.payment)
+        headers["X-PAYMENT"] = opts.payment;
+    if (opts.paymentSignature)
+        headers["PAYMENT-SIGNATURE"] = opts.paymentSignature;
+    const res = await fetch(opts.url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+    });
+    // MCP notifications do not require a response. Orrery returns 204 for
+    // notifications/initialized; keep stdout clean in that case.
+    if (res.status === 204)
+        return null;
+    const text = await res.text();
+    if (!text.trim())
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {
+            jsonrpc: "2.0",
+            id: idFor(payload),
+            error: {
+                code: -32603,
+                message: `Remote MCP returned non-JSON HTTP ${res.status}`,
+                data: text.slice(0, 500),
+            },
+        };
+    }
+}
+function idFor(payload) {
+    if (Array.isArray(payload))
+        return null;
+    return payload.id ?? null;
+}
+function write(value, opts) {
+    const body = JSON.stringify(value);
+    if (opts.framing === "newline") {
+        stdout.write(`${body}\n`);
+        return;
+    }
+    const length = Buffer.byteLength(body, "utf8");
+    stdout.write(`Content-Length: ${length}\r\n\r\n${body}`);
+}
+void main();

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@orrery-labs/mcp",
+  "version": "0.1.0",
+  "description": "Local stdio MCP bridge for Orrery prediction-market intelligence.",
+  "type": "module",
+  "bin": {
+    "orrery-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "orrery",
+    "mcp",
+    "model-context-protocol",
+    "prediction-markets",
+    "polymarket",
+    "kalshi",
+    "agents"
+  ],
+  "homepage": "https://orrery.me/docs/agents/mcp",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bez111/orrery.git",
+    "directory": "sdk/mcp"
+  },
+  "license": "MIT",
+  "author": "Orrery <hello@orrery.me>",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0"
+  }
+}