@tensakulabs/discord-mcp 0.1.0

package/README.md

@@ -0,0 +1,124 @@
+# discord-mcp
+
+Discord selfbot MCP server — read & send Discord messages from Claude Code or OpenClaw.
+
+> ⚠️ **Selfbot Warning:** This uses your Discord user token, which violates Discord's ToS. Your account may be banned. Use at your own risk.
+
+## What it does
+
+Exposes 6 Discord tools via MCP (Model Context Protocol):
+
+| Tool | Description |
+|------|-------------|
+| `discord_list_guilds` | List all servers you're in |
+| `discord_list_channels` | List text channels in a server |
+| `discord_get_messages` | Fetch recent messages from a channel |
+| `discord_get_dms` | List your open DM conversations |
+| `discord_send_message` | Send a message (channel or DM) |
+| `discord_get_unread` | Get messages you haven't seen yet |
+
+## Setup
+
+### 1. Install & configure
+
+```bash
+npx discord-mcp setup
+```
+
+This will:
+1. Show you how to extract your Discord token from the desktop app
+2. Save it securely to your OS keychain
+3. Auto-register the MCP server in Claude's config
+
+### 2. Token extraction (step shown during setup)
+
+Open Discord desktop app → DevTools console → paste:
+
+```javascript
+window.webpackChunkdiscord_app.push([[''],{},e=>{m=[];for(let c in e.c)m.push(e.c[c])}]),m.find(m=>m?.exports?.default?.getToken!==void 0).exports.default.getToken()
+```
+
+Copy the returned string.
+
+### 3. Restart Claude
+
+Restart Claude desktop app. You'll see Discord tools available.
+
+### Verify it's working
+
+```bash
+npx discord-mcp status
+# ✅ Connected as: yourname#0
+```
+
+## Manual MCP config (if auto-config fails)
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "discord": {
+      "command": "npx",
+      "args": ["-y", "discord-mcp"]
+    }
+  }
+}
+```
+
+## Usage with Claude
+
+Once registered, Claude can use Discord tools directly:
+
+```
+"What did I miss in the #general channel of the Tensaku server?"
+→ Claude calls discord_list_guilds, discord_list_channels, discord_get_unread
+
+"Reply to Alex saying I'll be there at 5pm"
+→ Claude calls discord_send_message with replyToMessageId
+```
+
+## OpenClaw integration
+
+Add to OpenClaw's MCP config:
+
+```json
+{
+  "mcp": {
+    "servers": [{
+      "name": "discord",
+      "transport": "stdio",
+      "command": "npx",
+      "args": ["-y", "discord-mcp"]
+    }]
+  }
+}
+```
+
+## Security
+
+- Token stored in OS keychain (macOS Keychain, Linux Secret Service, Windows Credential Store)
+- Fallback: AES-256-CBC encrypted file at `~/.config/discord-mcp/token.enc`
+- Token never written to config files or logs
+- State (last-seen timestamps, channel modes) at `~/.config/discord-mcp/state.json`
+
+## Architecture
+
+```
+discord-mcp/
+├── src/
+│   ├── index.ts          MCP server entry — registers 6 tools
+│   ├── cli.ts            setup + status commands
+│   ├── auth.ts           keychain token storage
+│   ├── ratelimit.ts      429 backoff + Discord headers
+│   ├── state.ts          per-channel state (review/auto/muted + last-seen)
+│   └── tools/
+│       ├── list_guilds.ts
+│       ├── list_channels.ts
+│       ├── get_messages.ts
+│       ├── get_dms.ts
+│       ├── send_message.ts
+│       └── get_unread.ts
+```
+
+All Discord API calls go through `rateLimitedFetch` — automatic backoff on 429.

package/dist/auth.js

@@ -0,0 +1,62 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+const SERVICE = "discord-mcp";
+const ACCOUNT = "user-token";
+const CONFIG_DIR = join(homedir(), ".config", "discord-mcp");
+const TOKEN_FILE = join(CONFIG_DIR, "token.enc");
+const KEY_FILE = join(CONFIG_DIR, "key.bin");
+let _keytar = null;
+async function getKeytar() {
+    if (_keytar !== undefined)
+        return _keytar;
+    try {
+        _keytar = (await import("keytar")).default;
+    }
+    catch {
+        _keytar = null;
+    }
+    return _keytar;
+}
+export async function saveToken(token) {
+    const keytar = await getKeytar();
+    try {
+        if (!keytar)
+            throw new Error("keytar not available");
+        await keytar.setPassword(SERVICE, ACCOUNT, token);
+    }
+    catch {
+        // Fallback: encrypt to file (for headless/CI environments)
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        let key;
+        if (existsSync(KEY_FILE)) {
+            key = readFileSync(KEY_FILE);
+        }
+        else {
+            key = randomBytes(32);
+            writeFileSync(KEY_FILE, key, { mode: 0o600 });
+        }
+        const iv = randomBytes(16);
+        const cipher = createCipheriv("aes-256-cbc", key, iv);
+        const enc = Buffer.concat([cipher.update(token, "utf8"), cipher.final()]);
+        writeFileSync(TOKEN_FILE, Buffer.concat([iv, enc]), { mode: 0o600 });
+    }
+}
+export async function getToken() {
+    // Try keychain first
+    const keytar = await getKeytar();
+    const keychainToken = keytar ? await keytar.getPassword(SERVICE, ACCOUNT).catch(() => null) : null;
+    if (keychainToken)
+        return keychainToken;
+    // Fallback: encrypted file
+    if (!existsSync(TOKEN_FILE) || !existsSync(KEY_FILE)) {
+        throw new Error("No Discord token found. Run: npx discord-mcp setup");
+    }
+    const key = readFileSync(KEY_FILE);
+    const raw = readFileSync(TOKEN_FILE);
+    const iv = raw.slice(0, 16);
+    const enc = raw.slice(16);
+    const decipher = createDecipheriv("aes-256-cbc", key, iv);
+    return Buffer.concat([decipher.update(enc), decipher.final()]).toString("utf8");
+}

package/dist/cli.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createInterface } from "readline";
+import { saveToken, getToken } from "./auth.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { execSync } from "child_process";
+import { homedir, platform } from "os";
+import { join } from "path";
+const program = new Command();
+program
+    .name("discord-mcp")
+    .description("Discord selfbot MCP server for Claude")
+    .version("0.1.0");
+program
+    .command("setup")
+    .description("Configure Discord token and register MCP server")
+    .action(async () => {
+    console.log(`
+╔══════════════════════════════════════════════════╗
+║         discord-mcp setup                       ║
+╚══════════════════════════════════════════════════╝
+
+Step 1: Extract your Discord token
+
+  1. Open Discord desktop app
+  2. Press Ctrl+Shift+I (or Cmd+Option+I on Mac) to open DevTools
+  3. Click the "Console" tab
+  4. Paste this one-liner and press Enter:
+
+  window.webpackChunkdiscord_app.push([[''],{},e=>{m=[];for(let c in e.c)m.push(e.c[c])}]),m.find(m=>m?.exports?.default?.getToken!==void 0).exports.default.getToken()
+
+  5. Copy the returned string (no quotes needed)
+
+`);
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const token = await new Promise(resolve => {
+        rl.question("Paste your Discord token: ", ans => { rl.close(); resolve(ans.trim()); });
+    });
+    if (!token || token.length < 20) {
+        console.error("❌ Invalid token. Try again.");
+        process.exit(1);
+    }
+    await saveToken(token);
+    console.log("✅ Token saved securely to OS keychain (or encrypted file fallback).");
+    // Auto-patch claude_desktop_config.json
+    const configPaths = [
+        join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json"), // macOS
+        join(homedir(), ".config", "Claude", "claude_desktop_config.json"), // Linux
+        join(process.env["APPDATA"] ?? "", "Claude", "claude_desktop_config.json"), // Windows
+    ];
+    const configPath = configPaths.find(existsSync);
+    // Write launchd plist (macOS only) — ISC-D6
+    if (platform() === "darwin") {
+        const launchAgentsDir = join(homedir(), "Library", "LaunchAgents");
+        const plistPath = join(launchAgentsDir, "com.discord-mcp.daemon.plist");
+        const npxPath = (() => { try {
+            return execSync("which npx").toString().trim();
+        }
+        catch {
+            return "/usr/local/bin/npx";
+        } })();
+        const logDir = join(homedir(), ".config", "discord-mcp");
+        const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.discord-mcp.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npxPath}</string>
+    <string>@tensakulabs/discord-mcp</string>
+    <string>daemon-start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logDir}/daemon.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/daemon.log</string>
+</dict>
+</plist>`;
+        mkdirSync(launchAgentsDir, { recursive: true });
+        writeFileSync(plistPath, plist);
+        try {
+            execSync(`launchctl unload "${plistPath}" 2>/dev/null; launchctl load "${plistPath}"`);
+            console.log(`✅ Daemon registered: com.discord-mcp.daemon (starts at login, running now)`);
+        }
+        catch {
+            console.log(`✅ Plist written: ${plistPath} (run: launchctl load "${plistPath}")`);
+        }
+    }
+    if (configPath) {
+        const config = JSON.parse(readFileSync(configPath, "utf8"));
+        config.mcpServers ??= {};
+        config.mcpServers["discord"] = {
+            command: "npx",
+            args: ["-y", "@tensakulabs/discord-mcp"],
+        };
+        writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(`✅ Registered in Claude config: ${configPath}`);
+        console.log("\n🎉 Done! Restart Claude to start using Discord tools.");
+    }
+    else {
+        console.log(`
+⚠️  Could not find Claude desktop config automatically.
+
+Add this to your claude_desktop_config.json manually:
+
+  "mcpServers": {
+    "discord": {
+      "command": "npx",
+      "args": ["-y", "@tensakulabs/discord-mcp"]
+    }
+  }
+`);
+    }
+});
+program
+    .command("daemon-start")
+    .description("Start the daemon (called by launchd — not intended for direct use)")
+    .action(async () => {
+    // Dynamically import daemon to start it
+    await import("./daemon.js");
+});
+program
+    .command("status")
+    .description("Check if token is set and valid")
+    .action(async () => {
+    try {
+        const token = await getToken();
+        // Validate token with a lightweight API call
+        const res = await fetch("https://discord.com/api/v10/users/@me", {
+            headers: { Authorization: token },
+        });
+        if (res.ok) {
+            const user = await res.json();
+            console.log(`✅ Connected as: ${user.username}#${user.discriminator}`);
+        }
+        else {
+            console.error(`❌ Token invalid: HTTP ${res.status}`);
+            process.exit(1);
+        }
+    }
+    catch {
+        console.error("❌ No token found. Run: npx @tensakulabs/discord-mcp setup");
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/config.js

@@ -0,0 +1,32 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const CONFIG_DIR = join(homedir(), ".config", "discord-mcp");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const DEFAULTS = {
+    retention: {
+        guild_channels: 30,
+        dms: 90,
+        mentioned: 90,
+        fallback_to_api: true,
+    },
+};
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return DEFAULTS;
+    try {
+        const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+        return {
+            retention: { ...DEFAULTS.retention, ...(raw.retention ?? {}) },
+        };
+    }
+    catch {
+        return DEFAULTS;
+    }
+}
+export function writeDefaultConfig() {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    if (!existsSync(CONFIG_FILE)) {
+        writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULTS, null, 2));
+    }
+}

package/dist/daemon.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * discord-mcp daemon
+ * Connects to Discord Gateway via WebSocket, ingests messages into SQLite.
+ * Run as a launchd service (com.discord-mcp.daemon).
+ */
+import { WebSocket } from "ws";
+import { getToken } from "./auth.js";
+import { initDb, insertMessage } from "./db.js";
+import { schedulePurge } from "./purge.js";
+const GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
+const IDENTIFY_INTENTS = (1 << 0) | (1 << 9) | (1 << 12); // GUILDS | GUILD_MESSAGES | MESSAGE_CONTENT
+let ws = null;
+let heartbeatInterval = null;
+let sequence = null;
+let sessionId = null;
+let resumeGatewayUrl = null;
+let reconnectDelay = 1000;
+const db = initDb();
+schedulePurge();
+async function connect(resume = false) {
+    const token = await getToken();
+    const url = resume && resumeGatewayUrl ? resumeGatewayUrl : GATEWAY_URL;
+    ws = new WebSocket(url);
+    ws.on("open", () => {
+        reconnectDelay = 1000; // reset on successful connect
+        console.error("[discord-mcp daemon] Connected to gateway.");
+    });
+    ws.on("message", (data) => {
+        const payload = JSON.parse(data.toString());
+        if (payload.s)
+            sequence = payload.s;
+        switch (payload.op) {
+            case 10: // HELLO
+                startHeartbeat(payload.d.heartbeat_interval);
+                if (resume && sessionId) {
+                    send({ op: 6, d: { token, session_id: sessionId, seq: sequence } }); // RESUME
+                }
+                else {
+                    identify(token);
+                }
+                break;
+            case 11: // HEARTBEAT_ACK
+                break;
+            case 1: // HEARTBEAT request
+                sendHeartbeat();
+                break;
+            case 7: // RECONNECT
+                reconnect(true);
+                break;
+            case 9: // INVALID SESSION
+                sessionId = null;
+                setTimeout(() => reconnect(false), 1000 + Math.random() * 4000);
+                break;
+            case 0: // DISPATCH
+                handleEvent(payload.t, payload.d);
+                break;
+        }
+    });
+    ws.on("close", (code) => {
+        clearHeartbeat();
+        console.error(`[discord-mcp daemon] Disconnected (${code}). Reconnecting in ${reconnectDelay}ms...`);
+        setTimeout(() => reconnect(code !== 1000), reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+    });
+    ws.on("error", (err) => {
+        console.error("[discord-mcp daemon] WebSocket error:", err.message);
+    });
+}
+function identify(token) {
+    send({
+        op: 2,
+        d: {
+            token,
+            intents: IDENTIFY_INTENTS,
+            properties: { os: "linux", browser: "discord-mcp", device: "discord-mcp" },
+        },
+    });
+}
+function handleEvent(type, data) {
+    switch (type) {
+        case "READY":
+            sessionId = data.session_id;
+            resumeGatewayUrl = data.resume_gateway_url;
+            console.error(`[discord-mcp daemon] Ready.`);
+            break;
+        case "MESSAGE_CREATE": {
+            const msg = data;
+            if (msg.author?.bot)
+                break; // ignore bots
+            const isMention = Array.isArray(msg.mentions) &&
+                msg.mentions.some((u) => u.id === (data.self_id ?? ""));
+            insertMessage(db, {
+                id: msg.id,
+                channel_id: msg.channel_id,
+                guild_id: msg.guild_id ?? null,
+                author_id: msg.author.id,
+                author_name: msg.author.username,
+                content: msg.content,
+                timestamp: new Date(msg.timestamp).getTime(),
+                is_dm: msg.guild_id ? 0 : 1,
+                is_mention: isMention ? 1 : 0,
+            });
+            break;
+        }
+    }
+}
+function startHeartbeat(intervalMs) {
+    clearHeartbeat();
+    heartbeatInterval = setInterval(sendHeartbeat, intervalMs);
+}
+function clearHeartbeat() {
+    if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+    }
+}
+function sendHeartbeat() {
+    send({ op: 1, d: sequence });
+}
+function send(payload) {
+    if (ws?.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(payload));
+    }
+}
+function reconnect(resume) {
+    ws?.terminate();
+    ws = null;
+    connect(resume);
+}
+// Start
+connect(false);

package/dist/db.js

@@ -0,0 +1,125 @@
+import Database from "better-sqlite3";
+import { mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const CONFIG_DIR = join(homedir(), ".config", "discord-mcp");
+const DB_FILE = join(CONFIG_DIR, "messages.db");
+let _db = null;
+export function getDb() {
+    if (_db)
+        return _db;
+    if (!existsSync(DB_FILE))
+        return null; // ISC-A5: graceful miss
+    try {
+        _db = new Database(DB_FILE);
+        // ISC-A4: WAL mode prevents corruption on crash
+        _db.pragma("journal_mode = WAL");
+        _db.pragma("synchronous = NORMAL");
+        return _db;
+    }
+    catch {
+        return null;
+    }
+}
+export function initDb() {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    const db = new Database(DB_FILE);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id          TEXT PRIMARY KEY,
+      channel_id  TEXT NOT NULL,
+      guild_id    TEXT,
+      author_id   TEXT NOT NULL,
+      author_name TEXT NOT NULL,
+      content     TEXT NOT NULL,
+      timestamp   INTEGER NOT NULL,  -- unix ms
+      is_dm       INTEGER NOT NULL DEFAULT 0,
+      is_mention  INTEGER NOT NULL DEFAULT 0,
+      seen        INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_channel_ts ON messages(channel_id, timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_seen ON messages(seen, timestamp DESC);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+      content,
+      author_name,
+      content='messages',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, content, author_name)
+      VALUES (new.rowid, new.content, new.author_name);
+    END;
+  `);
+    _db = db;
+    return db;
+}
+export function insertMessage(db, msg) {
+    const stmt = db.prepare(`
+    INSERT OR IGNORE INTO messages
+      (id, channel_id, guild_id, author_id, author_name, content, timestamp, is_dm, is_mention, seen)
+    VALUES
+      (@id, @channel_id, @guild_id, @author_id, @author_name, @content, @timestamp, @is_dm, @is_mention, 0)
+  `);
+    stmt.run(msg);
+}
+export function queryMessages(db, channelId, limit, since, until) {
+    let sql = "SELECT * FROM messages WHERE channel_id = ?";
+    const params = [channelId];
+    if (since) {
+        sql += " AND timestamp >= ?";
+        params.push(since);
+    }
+    if (until) {
+        sql += " AND timestamp <= ?";
+        params.push(until);
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ?";
+    params.push(limit);
+    return db.prepare(sql).all(...params);
+}
+export function queryUnread(db) {
+    return db.prepare("SELECT * FROM messages WHERE seen = 0 ORDER BY timestamp ASC").all();
+}
+export function markAllSeen(db, ids) {
+    if (ids.length === 0)
+        return;
+    const placeholders = ids.map(() => "?").join(",");
+    db.prepare(`UPDATE messages SET seen = 1 WHERE id IN (${placeholders})`).run(...ids);
+}
+export function searchMessages(db, query, channelId, since, until, limit = 50) {
+    // FTS5 search
+    let sql = `
+    SELECT m.* FROM messages m
+    JOIN messages_fts f ON m.rowid = f.rowid
+    WHERE messages_fts MATCH ?
+  `;
+    const params = [query];
+    if (channelId) {
+        sql += " AND m.channel_id = ?";
+        params.push(channelId);
+    }
+    if (since) {
+        sql += " AND m.timestamp >= ?";
+        params.push(since);
+    }
+    if (until) {
+        sql += " AND m.timestamp <= ?";
+        params.push(until);
+    }
+    sql += " ORDER BY m.timestamp DESC LIMIT ?";
+    params.push(limit);
+    return db.prepare(sql).all(...params);
+}
+export function deleteOlderThan(db, cutoffMs, isDm, isMention) {
+    db.prepare(`
+    DELETE FROM messages
+    WHERE timestamp < ?
+      AND is_dm = ?
+      AND is_mention = ?
+  `).run(cutoffMs, isDm ? 1 : 0, isMention ? 1 : 0);
+}

package/dist/index.js

@@ -0,0 +1,144 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { listGuilds } from "./tools/list_guilds.js";
+import { listChannels } from "./tools/list_channels.js";
+import { getMessages } from "./tools/get_messages.js";
+import { getDMChannels } from "./tools/get_dms.js";
+import { sendMessage } from "./tools/send_message.js";
+import { getUnread } from "./tools/get_unread.js";
+import { searchDiscord } from "./tools/search.js";
+const server = new Server({ name: "discord-mcp", version: "0.2.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "discord_list_guilds",
+            description: "List all Discord servers (guilds) the user is a member of.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "discord_list_channels",
+            description: "List text channels in a guild.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    guildId: { type: "string", description: "Guild ID from discord_list_guilds" },
+                },
+                required: ["guildId"],
+            },
+        },
+        {
+            name: "discord_get_messages",
+            description: "Get messages from a channel. Uses local cache if daemon is running, Discord API otherwise.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    channelId: { type: "string" },
+                    limit: { type: "number", default: 25, description: "Max messages (1-100)" },
+                    since: { type: "string", description: "ISO date or datetime e.g. '2026-02-25' or 'yesterday'" },
+                    until: { type: "string", description: "ISO date or datetime upper bound" },
+                },
+                required: ["channelId"],
+            },
+        },
+        {
+            name: "discord_get_dms",
+            description: "List the user's open DM conversations.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "discord_send_message",
+            description: "Send a message to a channel or user (DM). Specify channelId OR userId.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    channelId: { type: "string", description: "Guild channel ID" },
+                    userId: { type: "string", description: "User ID to DM" },
+                    content: { type: "string", description: "Message text" },
+                    replyToMessageId: { type: "string", description: "Optional message ID to reply to" },
+                },
+                required: ["content"],
+            },
+        },
+        {
+            name: "discord_get_unread",
+            description: "Get messages you haven't seen yet. Uses local cache when daemon is running.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    channels: {
+                        type: "array",
+                        description: "Channels to check.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                guildName: { type: "string" },
+                                channelName: { type: "string" },
+                                channelId: { type: "string" },
+                            },
+                            required: ["guildName", "channelName", "channelId"],
+                        },
+                    },
+                },
+                required: ["channels"],
+            },
+        },
+        {
+            name: "discord_search",
+            description: "Full-text search across locally cached Discord messages (requires daemon).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search terms" },
+                    channelId: { type: "string", description: "Limit to a specific channel (optional)" },
+                    since: { type: "string", description: "ISO date lower bound (optional)" },
+                    until: { type: "string", description: "ISO date upper bound (optional)" },
+                    limit: { type: "number", default: 50, description: "Max results" },
+                },
+                required: ["query"],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case "discord_list_guilds":
+                result = await listGuilds();
+                break;
+            case "discord_list_channels":
+                result = await listChannels(args.guildId);
+                break;
+            case "discord_get_messages": {
+                const a = args;
+                result = await getMessages(a.channelId, a.limit, a.since, a.until);
+                break;
+            }
+            case "discord_get_dms":
+                result = await getDMChannels();
+                break;
+            case "discord_send_message":
+                result = await sendMessage(args);
+                break;
+            case "discord_get_unread":
+                result = await getUnread(args.channels);
+                break;
+            case "discord_search": {
+                const a = args;
+                result = await searchDiscord(a.query, a.channelId, a.since, a.until, a.limit);
+                break;
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/purge.js

@@ -0,0 +1,34 @@
+import { getDb, deleteOlderThan } from "./db.js";
+import { loadConfig } from "./config.js";
+export function runPurge() {
+    const db = getDb();
+    if (!db)
+        return;
+    const config = loadConfig();
+    const now = Date.now();
+    const guildCutoff = now - config.retention.guild_channels * 24 * 60 * 60 * 1000;
+    const dmCutoff = now - config.retention.dms * 24 * 60 * 60 * 1000;
+    const mentionCutoff = now - config.retention.mentioned * 24 * 60 * 60 * 1000;
+    // Purge guild messages (not DM, not mention)
+    deleteOlderThan(db, guildCutoff, false, false);
+    // Purge DMs
+    deleteOlderThan(db, dmCutoff, true, false);
+    // Purge mentions
+    deleteOlderThan(db, mentionCutoff, false, true);
+    // DM mentions use the more conservative of dm/mention retention (dm wins)
+    deleteOlderThan(db, dmCutoff, true, true);
+    console.error(`[discord-mcp] Purge complete.`);
+}
+export function schedulePurge() {
+    // Run at next 2am, then every 24h
+    const now = new Date();
+    const next2am = new Date(now);
+    next2am.setHours(2, 0, 0, 0);
+    if (next2am <= now)
+        next2am.setDate(next2am.getDate() + 1);
+    const msUntil2am = next2am.getTime() - now.getTime();
+    setTimeout(() => {
+        runPurge();
+        setInterval(runPurge, 24 * 60 * 60 * 1000);
+    }, msUntil2am);
+}

package/dist/ratelimit.js

@@ -0,0 +1,19 @@
+export async function rateLimitedFetch(input, init, retries = 4) {
+    const res = await fetch(input, init);
+    if (res.status === 429 && retries > 0) {
+        const retryAfter = Number(res.headers.get("retry-after") ?? 1);
+        const delay = Math.min(retryAfter * 1000, 8000);
+        console.error(`[discord-mcp] Rate limited. Retrying in ${delay}ms...`);
+        await new Promise(r => setTimeout(r, delay));
+        return rateLimitedFetch(input, init, retries - 1);
+    }
+    return res;
+}
+export function makeDiscordHeaders(token) {
+    return {
+        // ISC-C2: user token — NO "Bot " prefix
+        "Authorization": token,
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (compatible; discord-mcp/0.1)",
+    };
+}

package/dist/state.js

@@ -0,0 +1,48 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const CONFIG_DIR = join(homedir(), ".config", "discord-mcp");
+const STATE_FILE = join(CONFIG_DIR, "state.json");
+function load() {
+    if (!existsSync(STATE_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(STATE_FILE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function save(state) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+export function getChannelMode(channelId) {
+    const state = load();
+    const s = state[channelId] ?? { mode: "review" };
+    // Auto-expire
+    if (s.expiresAt && Date.now() > s.expiresAt) {
+        state[channelId] = { ...s, mode: "review", expiresAt: undefined };
+        save(state);
+        return "review";
+    }
+    return s.mode;
+}
+export function setChannelMode(channelId, mode, durationMs) {
+    const state = load();
+    state[channelId] = {
+        ...(state[channelId] ?? {}),
+        mode,
+        expiresAt: durationMs ? Date.now() + durationMs : undefined,
+    };
+    save(state);
+}
+export function markSeen(channelId, timestamp) {
+    const state = load();
+    state[channelId] = { ...(state[channelId] ?? { mode: "review" }), lastSeen: timestamp };
+    save(state);
+}
+export function getLastSeen(channelId) {
+    const state = load();
+    return state[channelId]?.lastSeen ?? 0;
+}

package/dist/tools/get_dms.js

@@ -0,0 +1,17 @@
+import { getToken } from "../auth.js";
+import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
+export async function getDMChannels() {
+    const token = await getToken();
+    const res = await rateLimitedFetch("https://discord.com/api/v10/users/@me/channels", { headers: makeDiscordHeaders(token) });
+    if (!res.ok)
+        throw new Error(`Discord API error: ${res.status}`);
+    const channels = await res.json();
+    // type 1 = DM, type 3 = GROUP_DM
+    return channels
+        .filter(c => c.type === 1 || c.type === 3)
+        .map(c => ({
+        channelId: c.id,
+        with: c.recipients.map(r => r.username).join(", "),
+        lastMessageId: c.last_message_id,
+    }));
+}

package/dist/tools/get_messages.js

@@ -0,0 +1,47 @@
+import { getDb, queryMessages } from "../db.js";
+import { getToken } from "../auth.js";
+import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
+import { markSeen } from "../state.js";
+import { loadConfig } from "../config.js";
+export async function getMessages(channelId, limit = 25, since, // ISO date string e.g. "2026-02-25" or "2026-02-25T00:00:00Z"
+until) {
+    const sinceMs = since ? new Date(since).getTime() : undefined;
+    const untilMs = until ? new Date(until).getTime() : undefined;
+    // ISC-D4: SQLite-first
+    const db = getDb();
+    if (db) {
+        const rows = queryMessages(db, channelId, limit, sinceMs, untilMs);
+        if (rows.length > 0) {
+            if (rows.length > 0)
+                markSeen(channelId, rows[0].timestamp);
+            return rows.map(r => ({
+                id: r.id,
+                author: r.author_name,
+                content: r.content,
+                timestamp: new Date(r.timestamp).toISOString(),
+            }));
+        }
+    }
+    // ISC-D4: REST fallback on miss
+    const config = loadConfig();
+    if (!config.retention.fallback_to_api) {
+        return []; // privacy mode — no REST fallback
+    }
+    const token = await getToken();
+    let url = `https://discord.com/api/v10/channels/${channelId}/messages?limit=${Math.min(limit, 100)}`;
+    const res = await rateLimitedFetch(url, { headers: makeDiscordHeaders(token) });
+    if (!res.ok)
+        throw new Error(`Discord API error: ${res.status}`);
+    const messages = await res.json();
+    if (messages.length > 0) {
+        const latestTs = new Date(messages[0].timestamp).getTime();
+        markSeen(channelId, latestTs);
+    }
+    return messages.map(m => ({
+        id: m.id,
+        author: m.author.username,
+        content: m.content,
+        timestamp: m.timestamp,
+        replyTo: m.referenced_message?.content,
+    }));
+}

package/dist/tools/get_unread.js

@@ -0,0 +1,67 @@
+import { getDb, queryUnread, markAllSeen } from "../db.js";
+import { getToken } from "../auth.js";
+import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
+import { getLastSeen, markSeen } from "../state.js";
+import { loadConfig } from "../config.js";
+export async function getUnread(channels) {
+    // ISC-D4: SQLite-first path
+    const db = getDb();
+    if (db) {
+        const unreadRows = queryUnread(db);
+        if (unreadRows.length > 0) {
+            // Group by channel
+            const grouped = {};
+            for (const row of unreadRows) {
+                if (!grouped[row.channel_id])
+                    grouped[row.channel_id] = [];
+                grouped[row.channel_id].push(row);
+            }
+            markAllSeen(db, unreadRows.map(r => r.id));
+            return Object.entries(grouped).map(([channelId, msgs]) => {
+                const ch = channels.find(c => c.channelId === channelId);
+                return {
+                    guild: ch?.guildName ?? "Unknown",
+                    channel: ch?.channelName ?? channelId,
+                    channelId,
+                    messages: msgs.map(m => ({
+                        id: m.id,
+                        author: m.author_name,
+                        content: m.content,
+                        timestamp: new Date(m.timestamp).toISOString(),
+                    })),
+                };
+            });
+        }
+    }
+    // REST fallback (daemon not running or no unread in SQLite)
+    const config = loadConfig();
+    if (!config.retention.fallback_to_api)
+        return [];
+    const token = await getToken();
+    const results = [];
+    for (const ch of channels) {
+        const lastSeen = getLastSeen(ch.channelId);
+        const res = await rateLimitedFetch(`https://discord.com/api/v10/channels/${ch.channelId}/messages?limit=25`, { headers: makeDiscordHeaders(token) });
+        if (!res.ok)
+            continue;
+        const messages = await res.json();
+        const unread = messages
+            .filter(m => !m.author.bot && new Date(m.timestamp).getTime() > lastSeen)
+            .reverse();
+        if (unread.length > 0) {
+            markSeen(ch.channelId, new Date(messages[0].timestamp).getTime());
+            results.push({
+                guild: ch.guildName,
+                channel: ch.channelName,
+                channelId: ch.channelId,
+                messages: unread.map(m => ({
+                    id: m.id,
+                    author: m.author.username,
+                    content: m.content,
+                    timestamp: m.timestamp,
+                })),
+            });
+        }
+    }
+    return results;
+}

package/dist/tools/list_channels.js

@@ -0,0 +1,13 @@
+import { getToken } from "../auth.js";
+import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
+export async function listChannels(guildId) {
+    const token = await getToken();
+    const res = await rateLimitedFetch(`https://discord.com/api/v10/guilds/${guildId}/channels`, { headers: makeDiscordHeaders(token) });
+    if (!res.ok)
+        throw new Error(`Discord API error: ${res.status}`);
+    const channels = await res.json();
+    // type 0 = GUILD_TEXT, type 5 = GUILD_ANNOUNCEMENT
+    return channels
+        .filter(c => c.type === 0 || c.type === 5)
+        .map(c => ({ id: c.id, name: c.name, topic: c.topic }));
+}

package/dist/tools/list_guilds.js

@@ -0,0 +1,10 @@
+import { getToken } from "../auth.js";
+import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
+export async function listGuilds() {
+    const token = await getToken();
+    const res = await rateLimitedFetch("https://discord.com/api/v10/users/@me/guilds", { headers: makeDiscordHeaders(token) });
+    if (!res.ok)
+        throw new Error(`Discord API error: ${res.status}`);
+    const guilds = await res.json();
+    return guilds.map(g => ({ id: g.id, name: g.name }));
+}

package/dist/tools/search.js

@@ -0,0 +1,19 @@
+import { getDb, searchMessages } from "../db.js";
+export async function searchDiscord(query, channelId, since, until, limit = 50) {
+    const db = getDb();
+    if (!db) {
+        throw new Error("Daemon not running — no local message history to search. Start discord-mcp daemon first.");
+    }
+    const sinceMs = since ? new Date(since).getTime() : undefined;
+    const untilMs = until ? new Date(until).getTime() : undefined;
+    const rows = searchMessages(db, query, channelId, sinceMs, untilMs, limit);
+    return rows.map(r => ({
+        id: r.id,
+        author: r.author_name,
+        content: r.content,
+        channel_id: r.channel_id,
+        timestamp: new Date(r.timestamp).toISOString(),
+        is_dm: r.is_dm === 1,
+        is_mention: r.is_mention === 1,
+    }));
+}

package/dist/tools/send_message.js

@@ -0,0 +1,35 @@
+import { getToken } from "../auth.js";
+import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
+export async function sendMessage(opts) {
+    const token = await getToken();
+    let targetChannelId = opts.channelId;
+    // If userId given, open DM channel first
+    if (!targetChannelId && opts.userId) {
+        const dmRes = await rateLimitedFetch("https://discord.com/api/v10/users/@me/channels", {
+            method: "POST",
+            headers: makeDiscordHeaders(token),
+            body: JSON.stringify({ recipient_id: opts.userId }),
+        });
+        if (!dmRes.ok)
+            throw new Error(`Failed to open DM: ${dmRes.status}`);
+        const dm = await dmRes.json();
+        targetChannelId = dm.id;
+    }
+    if (!targetChannelId)
+        throw new Error("Must provide channelId or userId");
+    const body = { content: opts.content };
+    if (opts.replyToMessageId) {
+        body.message_reference = { message_id: opts.replyToMessageId };
+    }
+    const res = await rateLimitedFetch(`https://discord.com/api/v10/channels/${targetChannelId}/messages`, {
+        method: "POST",
+        headers: makeDiscordHeaders(token),
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const err = await res.json();
+        throw new Error(`Failed to send: ${res.status} — ${JSON.stringify(err)}`);
+    }
+    const msg = await res.json();
+    return { messageId: msg.id, timestamp: msg.timestamp, channelId: targetChannelId };
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@tensakulabs/discord-mcp",
+  "version": "0.1.0",
+  "description": "Discord selfbot MCP server — read & send messages via Claude",
+  "type": "module",
+  "bin": {
+    "discord-mcp": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^9.0.0",
+    "ws": "^8.16.0",
+    "commander": "^12.0.0"
+  },
+  "optionalDependencies": {
+    "keytar": "^7.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.0.0",
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/ws": "^8.5.0"
+  }
+}