daemoon-mcp 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jaebin Lee
+
+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,80 @@
+# daemoon-mcp
+
+Stdio MCP shim for [Daemoon](https://daemoon.dev) — one Bearer token gives any
+MCP-aware AI agent access to Vercel, GitHub, Cloudflare, Supabase, Google Cloud,
+Stripe, Resend, OpenAI, and Anthropic.
+
+## Install
+
+```bash
+npx -y daemoon-mcp
+```
+
+## Usage
+
+Generate a Daemoon token at https://daemoon.dev/dashboard, then drop into your
+agent's MCP config:
+
+### Claude Code
+
+```bash
+claude mcp add daemoon --command "npx" --args "-y,daemoon-mcp" --env "DAEMOON_TOKEN=dmn_..."
+```
+
+Or paste into `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "daemoon": {
+      "command": "npx",
+      "args": ["-y", "daemoon-mcp"],
+      "env": { "DAEMOON_TOKEN": "dmn_..." }
+    }
+  }
+}
+```
+
+### Cursor
+
+`Settings → MCP → Add new server`:
+
+```json
+{
+  "daemoon": {
+    "command": "npx",
+    "args": ["-y", "daemoon-mcp"],
+    "env": { "DAEMOON_TOKEN": "dmn_..." }
+  }
+}
+```
+
+## What it does
+
+`daemoon-mcp` is a tiny stdio→HTTP shim. The actual tools live at
+`https://daemoon.dev/api/mcp`. The token in `DAEMOON_TOKEN` authenticates each
+call to your Daemoon vault — the agent never sees the underlying provider
+credentials.
+
+18 tools across 9 providers:
+
+- `vercel.list_projects`, `vercel.create_project`, `vercel.create_deployment`
+- `github.list_repos`, `github.create_repo`
+- `supabase.list_projects`, `supabase.run_sql`
+- `cloudflare.list_zones`, `cloudflare.create_dns_record`
+- `gcp.list_projects`, `gcp.list_services`
+- `stripe.list_products`, `stripe.list_customers`, `stripe.create_payment_link`
+- `resend.send_email`, `resend.list_domains`
+- `openai.list_models`, `openai.chat_completion`
+- `anthropic.create_message`
+
+## Configuration
+
+| Env var            | Default                                | Description                                  |
+|--------------------|----------------------------------------|----------------------------------------------|
+| `DAEMOON_TOKEN`    | — (required)                           | PAT generated at daemoon.dev/dashboard       |
+| `DAEMOON_ENDPOINT` | `https://daemoon.dev/api/mcp`          | Override for self-hosted Daemoon             |
+
+## License
+
+MIT. Source: https://github.com/daemoon-dev/daemoon

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "daemoon-mcp",
+  "version": "1.0.1",
+  "description": "Stdio MCP shim for Daemoon — one Bearer token for Vercel, GitHub, Cloudflare, Supabase, GCP, Stripe, Resend, OpenAI, Anthropic.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "daemoon-mcp": "src/index.js"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "claude-code",
+    "cursor",
+    "vercel",
+    "github",
+    "cloudflare",
+    "supabase",
+    "gcp",
+    "stripe",
+    "resend",
+    "openai",
+    "anthropic"
+  ],
+  "author": "Daemoon",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daemoon-dev/daemoon.git",
+    "directory": "npm-shim"
+  },
+  "homepage": "https://daemoon.dev",
+  "bugs": {
+    "url": "https://github.com/daemoon-dev/daemoon/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/* Daemoon MCP stdio shim — proxies stdio MCP traffic to https://daemoon.dev/api/mcp.
+ *
+ * Usage (Claude Code config):
+ *   {
+ *     "mcpServers": {
+ *       "daemoon": {
+ *         "command": "npx",
+ *         "args": ["-y", "daemoon-mcp"],
+ *         "env": { "DAEMOON_TOKEN": "dmn_..." }
+ *       }
+ *     }
+ *   }
+ *
+ * Generate DAEMOON_TOKEN at https://daemoon.dev/dashboard.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const ENDPOINT = process.env.DAEMOON_ENDPOINT || "https://daemoon.dev/api/mcp";
+const TOKEN = process.env.DAEMOON_TOKEN;
+
+if (!TOKEN) {
+  console.error(
+    "DAEMOON_TOKEN env var is required. Generate one at https://daemoon.dev/dashboard.",
+  );
+  process.exit(1);
+}
+
+const VERSION = "1.0.1";
+
+let rpcId = 0;
+
+async function call(method, params) {
+  const id = ++rpcId;
+  const res = await fetch(ENDPOINT, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${TOKEN}`,
+      "Content-Type": "application/json",
+      "User-Agent": `daemoon-mcp/${VERSION}`,
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} }),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(
+      `Daemoon ${method} ${res.status}: ${text.slice(0, 300)}`,
+    );
+  }
+  const data = await res.json();
+  if (data.error) {
+    const msg = data.error.message ?? JSON.stringify(data.error);
+    throw new Error(`Daemoon ${method}: ${msg}`);
+  }
+  return data.result;
+}
+
+async function main() {
+  const server = new Server(
+    { name: "daemoon", version: VERSION },
+    { capabilities: { tools: {} } },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const result = await call("tools/list", {});
+    return result;
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async req => {
+    try {
+      const result = await call("tools/call", req.params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true,
+      };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(err => {
+  console.error("daemoon-mcp crashed:", err);
+  process.exit(1);
+});