@tensakulabs/discord-mcp 0.1.4 → 0.1.7

package/dist/auth.js

@@ -4,22 +4,34 @@ import { join } from "path";
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
 import { execSync } from "child_process";
 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");
+function keychainAccount(account) {
+    return account === "default" ? "user-token" : `user-token-${account}`;
+}
+function tokenFilePath(account) {
+    if (account === "default")
+        return join(CONFIG_DIR, "token.enc");
+    return join(CONFIG_DIR, account, "token.enc");
+}
+function keyFilePath(account) {
+    if (account === "default")
+        return join(CONFIG_DIR, "key.bin");
+    return join(CONFIG_DIR, account, "key.bin");
+}
 // macOS: use built-in `security` CLI — no native module compilation required
-function saveMacOSKeychain(token) {
+function saveMacOSKeychain(token, account) {
+    const acct = keychainAccount(account);
     // Delete existing entry first to avoid "already exists" error
     try {
-        execSync(`security delete-generic-password -s "${SERVICE}" -a "${ACCOUNT}" 2>/dev/null`);
+        execSync(`security delete-generic-password -s "${SERVICE}" -a "${acct}" 2>/dev/null`);
     }
     catch { /* not found, ok */ }
-    execSync(`security add-generic-password -s "${SERVICE}" -a "${ACCOUNT}" -w "${token}"`);
+    execSync(`security add-generic-password -s "${SERVICE}" -a "${acct}" -w "${token}"`);
 }
-function getMacOSKeychain() {
+function getMacOSKeychain(account) {
+    const acct = keychainAccount(account);
     try {
-        return execSync(`security find-generic-password -s "${SERVICE}" -a "${ACCOUNT}" -w 2>/dev/null`).toString().trim() || null;
+        return execSync(`security find-generic-password -s "${SERVICE}" -a "${acct}" -w 2>/dev/null`).toString().trim() || null;
     }
     catch {
         return null;
@@ -37,55 +49,64 @@ async function getKeytar() {
     }
     return _keytar;
 }
-export async function saveToken(token) {
+export async function saveToken(token, account = "default") {
     // macOS: security CLI always works — no native module needed
     if (platform() === "darwin") {
-        saveMacOSKeychain(token);
+        saveMacOSKeychain(token, account);
         return;
     }
     // Other platforms: try keytar
     const keytar = await getKeytar();
+    const acct = keychainAccount(account);
     try {
         if (!keytar)
             throw new Error("keytar not available");
-        await keytar.setPassword(SERVICE, ACCOUNT, token);
+        await keytar.setPassword(SERVICE, acct, token);
         return;
     }
     catch { /* fall through */ }
     // Fallback: encrypt to file (for headless/CI environments)
     console.warn("⚠️  Keychain unavailable, using encrypted file fallback.");
+    const tokenFile = tokenFilePath(account);
+    const keyFile = keyFilePath(account);
     mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    if (account !== "default")
+        mkdirSync(join(CONFIG_DIR, account), { recursive: true, mode: 0o700 });
     let key;
-    if (existsSync(KEY_FILE)) {
-        key = readFileSync(KEY_FILE);
+    if (existsSync(keyFile)) {
+        key = readFileSync(keyFile);
     }
     else {
         key = randomBytes(32);
-        writeFileSync(KEY_FILE, key, { mode: 0o600 });
+        writeFileSync(keyFile, 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 });
+    writeFileSync(tokenFile, Buffer.concat([iv, enc]), { mode: 0o600 });
 }
-export async function getToken() {
+export async function getToken(account = "default") {
     // macOS: try security CLI first
     if (platform() === "darwin") {
-        const token = getMacOSKeychain();
+        const token = getMacOSKeychain(account);
         if (token)
             return token;
     }
     // Try keytar
     const keytar = await getKeytar();
-    const keychainToken = keytar ? await keytar.getPassword(SERVICE, ACCOUNT).catch(() => null) : null;
+    const acct = keychainAccount(account);
+    const keychainToken = keytar ? await keytar.getPassword(SERVICE, acct).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 @tensakulabs/discord-mcp setup");
+    const tokenFile = tokenFilePath(account);
+    const keyFile = keyFilePath(account);
+    if (!existsSync(tokenFile) || !existsSync(keyFile)) {
+        const flag = account === "default" ? "" : ` --account ${account}`;
+        throw new Error(`No Discord token found. Run: npx @tensakulabs/discord-mcp setup${flag}`);
     }
-    const key = readFileSync(KEY_FILE);
-    const raw = readFileSync(TOKEN_FILE);
+    const key = readFileSync(keyFile);
+    const raw = readFileSync(tokenFile);
     const iv = raw.slice(0, 16);
     const enc = raw.slice(16);
     const decipher = createDecipheriv("aes-256-cbc", key, iv);

package/dist/cli.js

@@ -10,14 +10,17 @@ const program = new Command();
 program
     .name("discord-mcp")
     .description("Discord selfbot MCP server for Claude")
-    .version("0.1.0");
+    .version("0.1.6");
 program
     .command("setup")
     .description("Configure Discord token and register MCP server")
-    .action(async () => {
+    .option("--account <name>", "Account name (e.g. work, personal)", "default")
+    .action(async (opts) => {
+    const account = opts.account;
+    const accountLabel = account === "default" ? "" : ` [${account}]`;
     console.log(`
 ╔══════════════════════════════════════════════════╗
-║         discord-mcp setup                       ║
+║         discord-mcp setup${accountLabel.padEnd(22)}║
 ╚══════════════════════════════════════════════════╝
 
 Step 1: Extract your Discord token
@@ -32,24 +35,23 @@ Step 1: Extract your Discord token
 
 `);
     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()); });
+    const token = await new Promise(res => {
+        rl.question("Paste your Discord token: ", ans => { rl.close(); res(ans.trim()); });
     });
     if (!token || token.length < 20) {
         console.error("❌ Invalid token. Try again.");
         process.exit(1);
     }
-    await saveToken(token);
+    await saveToken(token, account);
     console.log("✅ Token saved securely to OS keychain (or encrypted file fallback).");
-    // Auto-patch Claude Code settings.json
-    const configPaths = [
-        join(homedir(), ".claude", "settings.json"), // Claude Code (all platforms)
-    ];
-    const configPath = configPaths.find(existsSync);
-    // Write launchd plist (macOS only) — ISC-D6
+    // MCP key and daemon label — namespaced for non-default accounts
+    const mcpKey = account === "default" ? "discord" : `discord-${account}`;
+    const daemonLabel = account === "default" ? "com.discord-mcp.daemon" : `com.discord-mcp.daemon.${account}`;
+    const accountArgs = account === "default" ? [] : ["--account", account];
+    // Write launchd plist (macOS only)
     if (platform() === "darwin") {
         const launchAgentsDir = join(homedir(), "Library", "LaunchAgents");
-        const plistPath = join(launchAgentsDir, "com.discord-mcp.daemon.plist");
+        const plistPath = join(launchAgentsDir, `${daemonLabel}.plist`);
         const npxPath = (() => { try {
             return execSync("which npx").toString().trim();
         }
@@ -62,18 +64,20 @@ Step 1: Extract your Discord token
         catch {
             return "/usr/local/bin";
         } })();
-        const logDir = join(homedir(), ".config", "discord-mcp");
+        const logDir = account === "default"
+            ? join(homedir(), ".config", "discord-mcp")
+            : join(homedir(), ".config", "discord-mcp", account);
+        const daemonCmdArgs = [npxPath, "@tensakulabs/discord-mcp", "daemon-start", ...accountArgs];
+        const plistArgs = daemonCmdArgs.map(a => `    <string>${a}</string>`).join("\n");
         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>
+  <string>${daemonLabel}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${npxPath}</string>
-    <string>@tensakulabs/discord-mcp</string>
-    <string>daemon-start</string>
+${plistArgs}
   </array>
   <key>EnvironmentVariables</key>
   <dict>
@@ -91,61 +95,75 @@ Step 1: Extract your Discord token
 </dict>
 </plist>`;
         mkdirSync(launchAgentsDir, { recursive: true });
+        mkdirSync(logDir, { recursive: true, mode: 0o700 });
         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)`);
+            console.log(`✅ Daemon registered: ${daemonLabel} (starts at login, running now)`);
         }
         catch {
             console.log(`✅ Plist written: ${plistPath} (run: launchctl load "${plistPath}")`);
         }
     }
+    // Auto-patch Claude Code settings.json
+    const configPath = [join(homedir(), ".claude", "settings.json")].find(existsSync);
     if (configPath) {
         const config = JSON.parse(readFileSync(configPath, "utf8"));
         config.mcpServers ??= {};
-        config.mcpServers["discord"] = {
+        config.mcpServers[mcpKey] = {
             command: "npx",
-            args: ["-y", "@tensakulabs/discord-mcp"],
+            args: ["-y", "@tensakulabs/discord-mcp", "mcp", ...accountArgs],
         };
         writeFileSync(configPath, JSON.stringify(config, null, 2));
-        console.log(`✅ Registered in Claude config: ${configPath}`);
+        console.log(`✅ Registered in Claude config as "${mcpKey}": ${configPath}`);
         console.log("\n🎉 Done! Restart Claude Code to start using Discord tools.");
     }
     else {
+        const extraArgs = accountArgs.length ? `, ${accountArgs.map(a => `"${a}"`).join(", ")}` : "";
         console.log(`
 ⚠️  Could not find Claude Code config automatically.
 
 Add this to your ~/.claude/settings.json manually:
 
   "mcpServers": {
-    "discord": {
+    "${mcpKey}": {
       "command": "npx",
-      "args": ["-y", "@tensakulabs/discord-mcp"]
+      "args": ["-y", "@tensakulabs/discord-mcp", "mcp"${extraArgs}]
     }
   }
 `);
     }
 });
+program
+    .command("mcp")
+    .description("Start the MCP server (stdio transport — used by Claude Code)")
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+    process.env.DISCORD_MCP_ACCOUNT = opts.account;
+    await import("./index.js");
+});
 program
     .command("daemon-start")
     .description("Start the daemon (called by launchd — not intended for direct use)")
-    .action(async () => {
-    // Dynamically import daemon to start it
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
+    process.env.DISCORD_MCP_ACCOUNT = opts.account;
     await import("./daemon.js");
 });
 program
     .command("status")
     .description("Check if token is set and valid")
-    .action(async () => {
+    .option("--account <name>", "Account name", "default")
+    .action(async (opts) => {
     try {
-        const token = await getToken();
-        // Validate token with a lightweight API call
+        const token = await getToken(opts.account);
         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}`);
+            const label = opts.account === "default" ? "" : ` [${opts.account}]`;
+            console.log(`✅ Connected as${label}: ${user.username}#${user.discriminator}`);
         }
         else {
             console.error(`❌ Token invalid: HTTP ${res.status}`);
@@ -153,10 +171,34 @@ program
         }
     }
     catch {
-        console.error("❌ No token found. Run: npx @tensakulabs/discord-mcp setup");
+        const flag = opts.account === "default" ? "" : ` --account ${opts.account}`;
+        console.error(`❌ No token found. Run: npx @tensakulabs/discord-mcp setup${flag}`);
         process.exit(1);
     }
 });
+program
+    .command("list-accounts")
+    .description("List all configured Discord accounts")
+    .action(() => {
+    const configPath = join(homedir(), ".claude", "settings.json");
+    if (!existsSync(configPath)) {
+        console.log("No Claude config found.");
+        return;
+    }
+    const config = JSON.parse(readFileSync(configPath, "utf8"));
+    const servers = Object.entries(config.mcpServers ?? {})
+        .filter(([k]) => k === "discord" || k.startsWith("discord-"));
+    if (servers.length === 0) {
+        console.log("No Discord accounts configured. Run: npx @tensakulabs/discord-mcp setup");
+        return;
+    }
+    console.log("Configured Discord accounts:");
+    for (const [key, val] of servers) {
+        const idx = val.args?.indexOf("--account") ?? -1;
+        const name = idx >= 0 && val.args ? (val.args[idx + 1] ?? "default") : "default";
+        console.log(`  ${key} → account: ${name}`);
+    }
+});
 // Default: no subcommand → run MCP server
 program.action(async () => {
     await import("./index.js");

package/dist/config.js

@@ -2,7 +2,11 @@ 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");
+function configFilePath(account) {
+    return account === "default"
+        ? join(CONFIG_DIR, "config.json")
+        : join(CONFIG_DIR, account, "config.json");
+}
 const DEFAULTS = {
     retention: {
         guild_channels: 30,
@@ -17,11 +21,12 @@ const DEFAULTS = {
         on_message: [],
     },
 };
-export function loadConfig() {
-    if (!existsSync(CONFIG_FILE))
+export function loadConfig(account = "default") {
+    const configFile = configFilePath(account);
+    if (!existsSync(configFile))
         return DEFAULTS;
     try {
-        const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+        const raw = JSON.parse(readFileSync(configFile, "utf8"));
         return {
             retention: { ...DEFAULTS.retention, ...(raw.retention ?? {}) },
             hooks: {
@@ -36,9 +41,12 @@ export function loadConfig() {
         return DEFAULTS;
     }
 }
-export function writeDefaultConfig() {
+export function writeDefaultConfig(account = "default") {
+    const configFile = configFilePath(account);
     mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    if (!existsSync(CONFIG_FILE)) {
-        writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULTS, null, 2));
+    if (account !== "default")
+        mkdirSync(join(CONFIG_DIR, account), { recursive: true, mode: 0o700 });
+    if (!existsSync(configFile)) {
+        writeFileSync(configFile, JSON.stringify(DEFAULTS, null, 2));
     }
 }

package/dist/daemon.js

@@ -12,6 +12,7 @@ import { loadConfig } from "./config.js";
 import { fireHooks } from "./hooks.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
+const ACCOUNT = process.env.DISCORD_MCP_ACCOUNT ?? "default";
 let ws = null;
 let heartbeatInterval = null;
 let sequence = null;
@@ -19,10 +20,10 @@ let sessionId = null;
 let resumeGatewayUrl = null;
 let reconnectDelay = 1000;
 let selfId = null; // set from READY event
-const db = initDb();
-schedulePurge();
+const db = initDb(ACCOUNT);
+schedulePurge(ACCOUNT);
 async function connect(resume = false) {
-    const token = await getToken();
+    const token = await getToken(ACCOUNT);
     const url = resume && resumeGatewayUrl ? resumeGatewayUrl : GATEWAY_URL;
     ws = new WebSocket(url);
     ws.on("open", () => {
@@ -116,7 +117,7 @@ function handleEvent(type, data) {
                 mention_type: mentionType,
             });
             // Fire hooks
-            const cfg = loadConfig();
+            const cfg = loadConfig(ACCOUNT);
             const ctx = {
                 author: msg.author.username,
                 content: msg.content,

package/dist/db.js

@@ -3,27 +3,36 @@ 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))
+function dbFilePath(account) {
+    return account === "default"
+        ? join(CONFIG_DIR, "messages.db")
+        : join(CONFIG_DIR, account, "messages.db");
+}
+const _dbs = {};
+export function getDb(account = "default") {
+    if (_dbs[account])
+        return _dbs[account];
+    const dbFile = dbFilePath(account);
+    if (!existsSync(dbFile))
         return null; // ISC-A5: graceful miss
     try {
-        _db = new Database(DB_FILE);
+        const db = new Database(dbFile);
         // ISC-A4: WAL mode prevents corruption on crash
-        _db.pragma("journal_mode = WAL");
-        _db.pragma("synchronous = NORMAL");
-        return _db;
+        db.pragma("journal_mode = WAL");
+        db.pragma("synchronous = NORMAL");
+        _dbs[account] = db;
+        return db;
     }
     catch {
         return null;
     }
 }
-export function initDb() {
+export function initDb(account = "default") {
+    const dbFile = dbFilePath(account);
     mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    const db = new Database(DB_FILE);
+    if (account !== "default")
+        mkdirSync(join(CONFIG_DIR, account), { recursive: true, mode: 0o700 });
+    const db = new Database(dbFile);
     db.pragma("journal_mode = WAL");
     db.pragma("synchronous = NORMAL");
     db.exec(`
@@ -61,7 +70,7 @@ export function initDb() {
     if (!cols.includes("mention_type")) {
         db.exec("ALTER TABLE messages ADD COLUMN mention_type TEXT DEFAULT NULL");
     }
-    _db = db;
+    _dbs[account] = db;
     return db;
 }
 export function insertMessage(db, msg) {

package/dist/index.js

@@ -8,6 +8,7 @@ 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 ACCOUNT = process.env.DISCORD_MCP_ACCOUNT ?? "default";
 const server = new Server({ name: "discord-mcp", version: "0.2.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -106,28 +107,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         let result;
         switch (name) {
             case "discord_list_guilds":
-                result = await listGuilds();
+                result = await listGuilds(ACCOUNT);
                 break;
             case "discord_list_channels":
-                result = await listChannels(args.guildId);
+                result = await listChannels(args.guildId, ACCOUNT);
                 break;
             case "discord_get_messages": {
                 const a = args;
-                result = await getMessages(a.channelId, a.limit, a.since, a.until);
+                result = await getMessages(a.channelId, a.limit, a.since, a.until, ACCOUNT);
                 break;
             }
             case "discord_get_dms":
-                result = await getDMChannels();
+                result = await getDMChannels(ACCOUNT);
                 break;
             case "discord_send_message":
-                result = await sendMessage(args);
+                result = await sendMessage(args, ACCOUNT);
                 break;
             case "discord_get_unread":
-                result = await getUnread(args.channels);
+                result = await getUnread(args.channels, ACCOUNT);
                 break;
             case "discord_search": {
                 const a = args;
-                result = await searchDiscord(a.query, a.channelId, a.since, a.until, a.limit);
+                result = await searchDiscord(a.query, a.channelId, a.since, a.until, a.limit, ACCOUNT);
                 break;
             }
             default:

package/dist/purge.js

@@ -1,10 +1,10 @@
 import { getDb, deleteOlderThan } from "./db.js";
 import { loadConfig } from "./config.js";
-export function runPurge() {
-    const db = getDb();
+export function runPurge(account = "default") {
+    const db = getDb(account);
     if (!db)
         return;
-    const config = loadConfig();
+    const config = loadConfig(account);
     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;
@@ -19,7 +19,7 @@ export function runPurge() {
     deleteOlderThan(db, dmCutoff, true, true);
     console.error(`[discord-mcp] Purge complete.`);
 }
-export function schedulePurge() {
+export function schedulePurge(account = "default") {
     // Run at next 2am, then every 24h
     const now = new Date();
     const next2am = new Date(now);
@@ -28,7 +28,7 @@ export function schedulePurge() {
         next2am.setDate(next2am.getDate() + 1);
     const msUntil2am = next2am.getTime() - now.getTime();
     setTimeout(() => {
-        runPurge();
-        setInterval(runPurge, 24 * 60 * 60 * 1000);
+        runPurge(account);
+        setInterval(() => runPurge(account), 24 * 60 * 60 * 1000);
     }, msUntil2am);
 }

package/dist/state.js

@@ -2,47 +2,54 @@ 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))
+function stateFilePath(account) {
+    return account === "default"
+        ? join(CONFIG_DIR, "state.json")
+        : join(CONFIG_DIR, account, "state.json");
+}
+function load(account) {
+    const stateFile = stateFilePath(account);
+    if (!existsSync(stateFile))
         return {};
     try {
-        return JSON.parse(readFileSync(STATE_FILE, "utf8"));
+        return JSON.parse(readFileSync(stateFile, "utf8"));
     }
     catch {
         return {};
     }
 }
-function save(state) {
+function save(state, account) {
     mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
-    writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), { mode: 0o600 });
+    if (account !== "default")
+        mkdirSync(join(CONFIG_DIR, account), { recursive: true, mode: 0o700 });
+    writeFileSync(stateFilePath(account), JSON.stringify(state, null, 2), { mode: 0o600 });
 }
-export function getChannelMode(channelId) {
-    const state = load();
+export function getChannelMode(channelId, account = "default") {
+    const state = load(account);
     const s = state[channelId] ?? { mode: "review" };
     // Auto-expire
     if (s.expiresAt && Date.now() > s.expiresAt) {
         state[channelId] = { ...s, mode: "review", expiresAt: undefined };
-        save(state);
+        save(state, account);
         return "review";
     }
     return s.mode;
 }
-export function setChannelMode(channelId, mode, durationMs) {
-    const state = load();
+export function setChannelMode(channelId, mode, durationMs, account = "default") {
+    const state = load(account);
     state[channelId] = {
         ...(state[channelId] ?? {}),
         mode,
         expiresAt: durationMs ? Date.now() + durationMs : undefined,
     };
-    save(state);
+    save(state, account);
 }
-export function markSeen(channelId, timestamp) {
-    const state = load();
+export function markSeen(channelId, timestamp, account = "default") {
+    const state = load(account);
     state[channelId] = { ...(state[channelId] ?? { mode: "review" }), lastSeen: timestamp };
-    save(state);
+    save(state, account);
 }
-export function getLastSeen(channelId) {
-    const state = load();
+export function getLastSeen(channelId, account = "default") {
+    const state = load(account);
     return state[channelId]?.lastSeen ?? 0;
 }

package/dist/tools/get_dms.js

@@ -1,7 +1,7 @@
 import { getToken } from "../auth.js";
 import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
-export async function getDMChannels() {
-    const token = await getToken();
+export async function getDMChannels(account = "default") {
+    const token = await getToken(account);
     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}`);

package/dist/tools/get_messages.js

@@ -4,16 +4,16 @@ 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) {
+until, account = "default") {
     const sinceMs = since ? new Date(since).getTime() : undefined;
     const untilMs = until ? new Date(until).getTime() : undefined;
     // ISC-D4: SQLite-first
-    const db = getDb();
+    const db = getDb(account);
     if (db) {
         const rows = queryMessages(db, channelId, limit, sinceMs, untilMs);
         if (rows.length > 0) {
             if (rows.length > 0)
-                markSeen(channelId, rows[0].timestamp);
+                markSeen(channelId, rows[0].timestamp, account);
             return rows.map(r => ({
                 id: r.id,
                 author: r.author_name,
@@ -23,19 +23,19 @@ until) {
         }
     }
     // ISC-D4: REST fallback on miss
-    const config = loadConfig();
+    const config = loadConfig(account);
     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 token = await getToken(account);
+    const 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);
+        markSeen(channelId, latestTs, account);
     }
     return messages.map(m => ({
         id: m.id,

package/dist/tools/get_unread.js

@@ -3,9 +3,9 @@ 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) {
+export async function getUnread(channels, account = "default") {
     // ISC-D4: SQLite-first path
-    const db = getDb();
+    const db = getDb(account);
     if (db) {
         const unreadRows = queryUnread(db);
         if (unreadRows.length > 0) {
@@ -34,13 +34,13 @@ export async function getUnread(channels) {
         }
     }
     // REST fallback (daemon not running or no unread in SQLite)
-    const config = loadConfig();
+    const config = loadConfig(account);
     if (!config.retention.fallback_to_api)
         return [];
-    const token = await getToken();
+    const token = await getToken(account);
     const results = [];
     for (const ch of channels) {
-        const lastSeen = getLastSeen(ch.channelId);
+        const lastSeen = getLastSeen(ch.channelId, account);
         const res = await rateLimitedFetch(`https://discord.com/api/v10/channels/${ch.channelId}/messages?limit=25`, { headers: makeDiscordHeaders(token) });
         if (!res.ok)
             continue;
@@ -49,7 +49,7 @@ export async function getUnread(channels) {
             .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());
+            markSeen(ch.channelId, new Date(messages[0].timestamp).getTime(), account);
             results.push({
                 guild: ch.guildName,
                 channel: ch.channelName,

package/dist/tools/list_channels.js

@@ -1,7 +1,7 @@
 import { getToken } from "../auth.js";
 import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
-export async function listChannels(guildId) {
-    const token = await getToken();
+export async function listChannels(guildId, account = "default") {
+    const token = await getToken(account);
     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}`);

package/dist/tools/list_guilds.js

@@ -1,7 +1,7 @@
 import { getToken } from "../auth.js";
 import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
-export async function listGuilds() {
-    const token = await getToken();
+export async function listGuilds(account = "default") {
+    const token = await getToken(account);
     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}`);

package/dist/tools/search.js

@@ -1,6 +1,6 @@
 import { getDb, searchMessages } from "../db.js";
-export async function searchDiscord(query, channelId, since, until, limit = 50) {
-    const db = getDb();
+export async function searchDiscord(query, channelId, since, until, limit = 50, account = "default") {
+    const db = getDb(account);
     if (!db) {
         throw new Error("Daemon not running — no local message history to search. Start discord-mcp daemon first.");
     }

package/dist/tools/send_message.js

@@ -1,7 +1,7 @@
 import { getToken } from "../auth.js";
 import { makeDiscordHeaders, rateLimitedFetch } from "../ratelimit.js";
-export async function sendMessage(opts) {
-    const token = await getToken();
+export async function sendMessage(opts, account = "default") {
+    const token = await getToken(account);
     let targetChannelId = opts.channelId;
     // If userId given, open DM channel first
     if (!targetChannelId && opts.userId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensakulabs/discord-mcp",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Discord selfbot MCP server — read & send messages via Claude",
   "license": "MIT",
   "type": "module",