@gonzih/cc-discord 0.1.0 → 0.1.2

package/dist/bot.js

@@ -1,798 +0,0 @@
-/**
- * Discord bot that routes messages to/from a Claude Code subprocess.
- * One ClaudeProcess per channel (or channel:thread) — sessions are isolated per channel.
- */
-import { Client, GatewayIntentBits, REST, Routes, SlashCommandBuilder, EmbedBuilder, AttachmentBuilder, Events, ChannelType, } from "discord.js";
-import { existsSync, createWriteStream } from "fs";
-import { basename } from "path";
-import https from "https";
-import http from "http";
-import { ClaudeProcess, extractText } from "./claude.js";
-import { transcribeVoice, isVoiceAvailable } from "./voice.js";
-import { formatForDiscord, splitLongMessage, stripAnsi } from "./formatter.js";
-import { getCurrentToken } from "./tokens.js";
-import { writeChatLog } from "./notifier.js";
-import { CronManager } from "./cron.js";
-import { parseRoutingTag, ensureMetaAgent, routeToMetaAgent } from "./router.js";
-import { metaAgentStatusKey } from "@gonzih/cc-wire";
-/** Convert a Discord snowflake string to a safe 53-bit integer for CronManager compatibility. */
-function snowflakeToInt(id) {
-    // Discord snowflakes are up to 2^63, beyond Number.MAX_SAFE_INTEGER.
-    // Mask to 53 bits for safe integer range while maintaining per-channel consistency.
-    return Number(BigInt(id) & BigInt(0x001FFFFFFFFFFFFF));
-}
-// Claude Sonnet 4.6 pricing (per 1M tokens)
-const PRICING = {
-    inputPerM: 3.00,
-    outputPerM: 15.00,
-    cacheReadPerM: 0.30,
-    cacheWritePerM: 3.75,
-};
-function computeCostUsd(usage) {
-    return (usage.inputTokens * PRICING.inputPerM / 1_000_000 +
-        usage.outputTokens * PRICING.outputPerM / 1_000_000 +
-        usage.cacheReadTokens * PRICING.cacheReadPerM / 1_000_000 +
-        usage.cacheWriteTokens * PRICING.cacheWritePerM / 1_000_000);
-}
-// Debounces streaming chunks. Resets on each chunk. Fires 800ms after last chunk.
-const FLUSH_DELAY_MS = 800;
-// Discord typing indicator: re-send every 9s (indicator expires after ~10s)
-const TYPING_INTERVAL_MS = 9000;
-/** Prepend [MM-DD HH:mm] so Claude knows when the message was received. */
-export function stampPrompt(text, now = new Date()) {
-    const mm = String(now.getMonth() + 1).padStart(2, "0");
-    const dd = String(now.getDate()).padStart(2, "0");
-    const hh = String(now.getHours()).padStart(2, "0");
-    const min = String(now.getMinutes()).padStart(2, "0");
-    return `[${mm}-${dd} ${hh}:${min}] ${text}`;
-}
-function formatTokens(n) {
-    if (n >= 1000)
-        return `${(n / 1000).toFixed(1)}k`;
-    return String(n);
-}
-/** Download a URL to a file on disk. */
-function downloadFile(url, dest) {
-    return new Promise((resolve, reject) => {
-        const file = createWriteStream(dest);
-        const getter = url.startsWith("https") ? https : http;
-        getter.get(url, (res) => {
-            if (res.statusCode !== 200) {
-                reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
-                return;
-            }
-            res.pipe(file);
-            file.on("finish", () => file.close(() => resolve()));
-            file.on("error", reject);
-        }).on("error", reject);
-    });
-}
-/** Fetch a URL and return it as a base64 string. */
-async function fetchAsBase64(url) {
-    return new Promise((resolve, reject) => {
-        const getter = url.startsWith("https") ? https : http;
-        getter.get(url, (res) => {
-            if (res.statusCode !== 200) {
-                reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
-                return;
-            }
-            const chunks = [];
-            res.on("data", (chunk) => chunks.push(chunk));
-            res.on("end", () => resolve(Buffer.concat(chunks).toString("base64")));
-            res.on("error", reject);
-        }).on("error", reject);
-    });
-}
-export class CcDiscordBot {
-    client;
-    sessions = new Map();
-    costs = new Map();
-    opts;
-    redis;
-    namespace;
-    lastActiveChannelId;
-    cron;
-    /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
-    mcpSession;
-    constructor(opts) {
-        this.opts = opts;
-        this.redis = opts.redis;
-        this.namespace = opts.namespace ?? "default";
-        this.client = new Client({
-            intents: [
-                GatewayIntentBits.Guilds,
-                GatewayIntentBits.GuildMessages,
-                GatewayIntentBits.MessageContent,
-                GatewayIntentBits.DirectMessages,
-            ],
-        });
-        this.cron = new CronManager(opts.cwd ?? process.cwd(), (chatIdNum, prompt, _jobId, done) => {
-            // Reverse-lookup channelId from the stored integer
-            const channelId = this.reverseSnowflakeLookup(chatIdNum);
-            if (!channelId) {
-                console.warn(`[cron] no channelId found for chatId=${chatIdNum}`);
-                done();
-                return;
-            }
-            this.runCronTask(channelId, prompt, done);
-        });
-        this.client.once(Events.ClientReady, (readyClient) => {
-            console.log(`[discord] logged in as ${readyClient.user.tag}`);
-            this.registerSlashCommands().catch((err) => {
-                console.error("[discord] slash command registration failed:", err.message);
-            });
-        });
-        this.client.on(Events.MessageCreate, (msg) => {
-            void this.handleMessage(msg);
-        });
-        this.client.on(Events.InteractionCreate, (interaction) => {
-            if (!interaction.isChatInputCommand())
-                return;
-            void this.handleSlashCommand(interaction);
-        });
-        this.client.on("error", (err) => {
-            console.error("[discord] client error:", err.message);
-        });
-        void this.client.login(opts.discordToken);
-        console.log("[discord] bot starting...");
-        console.log(`[voice] whisper available: ${isVoiceAvailable()}`);
-    }
-    /** Reverse-lookup: find the channelId string for a cron-stored integer */
-    snowflakeMap = new Map();
-    storeSnowflake(channelId) {
-        const n = snowflakeToInt(channelId);
-        this.snowflakeMap.set(n, channelId);
-        return n;
-    }
-    reverseSnowflakeLookup(n) {
-        return this.snowflakeMap.get(n);
-    }
-    /** Session key: "channelId" or "channelId:threadId" for threads */
-    sessionKey(channelId, threadId) {
-        return threadId ? `${channelId}:${threadId}` : channelId;
-    }
-    /** Get the channel/thread for sending messages */
-    async getChannel(channelId) {
-        try {
-            const channel = await this.client.channels.fetch(channelId);
-            if (!channel)
-                return null;
-            if (channel.type === ChannelType.GuildText ||
-                channel.type === ChannelType.DM ||
-                channel.type === ChannelType.GuildNews ||
-                channel.type === ChannelType.PublicThread ||
-                channel.type === ChannelType.PrivateThread ||
-                channel.type === ChannelType.GuildVoice) {
-                return channel;
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /** Send text to a channel, splitting at 2000 chars, sending file attachments if detected. */
-    async sendToChannel(channel, text) {
-        // Check for file paths written by Claude tools (lines like: "File written: /path/to/file")
-        const filePathMatch = text.match(/(?:^|\n)\s*(?:file written|wrote file|created file|saved to|output:)\s*[:\-]?\s*(\/[^\s\n]+)/im);
-        if (filePathMatch) {
-            const filePath = filePathMatch[1].trim();
-            if (existsSync(filePath)) {
-                try {
-                    const attachment = new AttachmentBuilder(filePath, { name: basename(filePath) });
-                    await channel.send({ files: [attachment] });
-                    return;
-                }
-                catch (err) {
-                    console.warn(`[bot] failed to send file ${filePath}:`, err.message);
-                }
-            }
-        }
-        const formatted = formatForDiscord(text);
-        const chunks = splitLongMessage(formatted);
-        for (const chunk of chunks) {
-            if (!chunk.trim())
-                continue;
-            await channel.send(chunk).catch((err) => {
-                console.error("[bot] send failed:", err.message);
-            });
-        }
-    }
-    /** Send to a channel by ID — used by notifier callbacks. */
-    async sendToChannelById(channelId, text) {
-        const channel = await this.getChannel(channelId);
-        if (!channel) {
-            console.warn(`[bot] sendToChannelById: channel ${channelId} not found`);
-            return;
-        }
-        await this.sendToChannel(channel, text);
-    }
-    isAllowed(userId) {
-        if (!this.opts.allowedUserIds?.length)
-            return true;
-        return this.opts.allowedUserIds.includes(userId);
-    }
-    async handleMessage(msg) {
-        // Skip bots (including self)
-        if (msg.author.bot)
-            return;
-        const userId = msg.author.id;
-        if (!this.isAllowed(userId))
-            return;
-        // Track last active channel
-        this.lastActiveChannelId = msg.channelId;
-        const channelId = msg.channelId;
-        const threadId = msg.channel.isThread() ? msg.channelId : undefined;
-        // For threads, the parent channel is the actual channel
-        const effectiveChannelId = threadId ?? channelId;
-        const sessionKey = this.sessionKey(effectiveChannelId, threadId);
-        // Store snowflake mapping for cron reverse-lookup
-        this.storeSnowflake(effectiveChannelId);
-        // Check for voice/audio attachments
-        const audioAttachment = msg.attachments.find((att) => {
-            const name = att.name?.toLowerCase() ?? "";
-            const ct = att.contentType?.toLowerCase() ?? "";
-            return (name.endsWith(".ogg") || name.endsWith(".mp3") || name.endsWith(".m4a") ||
-                ct.includes("ogg") || ct.includes("mpeg") || ct.includes("mp4a"));
-        });
-        if (audioAttachment) {
-            await this.handleVoice(msg, effectiveChannelId, audioAttachment.url, audioAttachment.name ?? "audio.ogg");
-            return;
-        }
-        // Image attachments
-        const imageAttachment = msg.attachments.find((att) => {
-            const ct = att.contentType?.toLowerCase() ?? "";
-            return ct.startsWith("image/");
-        });
-        if (imageAttachment) {
-            await this.handleImage(msg, effectiveChannelId, imageAttachment.url, imageAttachment.contentType ?? "image/jpeg");
-            return;
-        }
-        let text = msg.content.trim();
-        if (!text)
-            return;
-        // Strip @mention
-        text = text.replace(/<@!?\d+>/g, "").trim();
-        if (!text)
-            return;
-        // #tag / #org/repo routing — delegate to meta-agent
-        if (this.redis) {
-            const routing = parseRoutingTag(text);
-            if (routing) {
-                const channel = msg.channel;
-                await channel.send(`→ #${routing.namespace}`).catch(() => { });
-                this.writeChatMessage("user", "discord", text, effectiveChannelId);
-                this.opts.registerRoutedChannelId?.(routing.namespace, effectiveChannelId);
-                try {
-                    await ensureMetaAgent(routing.namespace, routing.repoUrl, (toolName, args) => this.callCcAgentTool(toolName, args ?? {}), this.redis);
-                    await routeToMetaAgent(routing.namespace, routing.strippedMessage, this.redis);
-                }
-                catch (err) {
-                    await channel.send(`Failed to route to #${routing.namespace}: ${err.message}`).catch(() => { });
-                }
-                return;
-            }
-        }
-        // Channel name → meta-agent namespace routing
-        if (this.redis) {
-            const channelName = msg.channel.name ?? "";
-            if (channelName && channelName !== "general") {
-                // Check if a meta-agent is running for this channel name as namespace
-                const ns = channelName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-                try {
-                    const statusRaw = await this.redis.get(metaAgentStatusKey(ns));
-                    if (statusRaw) {
-                        const status = JSON.parse(statusRaw);
-                        if (status.status === "running" || status.status === "idle") {
-                            // Route to meta-agent
-                            const channel = msg.channel;
-                            await channel.send(`→ #${ns} (meta-agent)`).catch(() => { });
-                            this.writeChatMessage("user", "discord", text, effectiveChannelId);
-                            this.opts.registerRoutedChannelId?.(ns, effectiveChannelId);
-                            try {
-                                await routeToMetaAgent(ns, text, this.redis);
-                            }
-                            catch (err) {
-                                await channel.send(`Failed to route to #${ns}: ${err.message}`).catch(() => { });
-                            }
-                            return;
-                        }
-                    }
-                }
-                catch {
-                    // Redis error — fall through to local session
-                }
-            }
-        }
-        // Local Claude session
-        const session = this.getOrCreateSession(effectiveChannelId, msg.channel);
-        try {
-            session.currentPrompt = text;
-            session.claude.sendPrompt(stampPrompt(text));
-            this.startTyping(effectiveChannelId, msg.channel, session);
-            this.writeChatMessage("user", "discord", text, effectiveChannelId);
-        }
-        catch (err) {
-            await msg.channel.send(`Error sending to Claude: ${err.message}`).catch(() => { });
-            this.killSession(effectiveChannelId);
-        }
-    }
-    async handleVoice(msg, channelId, audioUrl, _fileName) {
-        const channel = msg.channel;
-        await channel.sendTyping().catch(() => { });
-        try {
-            const transcript = await transcribeVoice(audioUrl);
-            if (!transcript || transcript === "[empty transcription]") {
-                await channel.send("Could not transcribe voice message.").catch(() => { });
-                return;
-            }
-            const session = this.getOrCreateSession(channelId, channel);
-            session.currentPrompt = transcript;
-            session.claude.sendPrompt(stampPrompt(transcript));
-            this.startTyping(channelId, channel, session);
-            this.writeChatMessage("user", "discord", transcript, channelId);
-        }
-        catch (err) {
-            const errMsg = err.message;
-            let userMsg;
-            if (errMsg.includes("whisper-cpp not found")) {
-                userMsg = "Voice transcription unavailable — whisper-cpp not installed";
-            }
-            else if (errMsg.includes("No whisper model found")) {
-                userMsg = "Voice transcription unavailable — no whisper model found";
-            }
-            else {
-                userMsg = `Voice transcription failed: ${errMsg}`;
-            }
-            await channel.send(userMsg).catch(() => { });
-        }
-    }
-    async handleImage(msg, channelId, imageUrl, contentType) {
-        const channel = msg.channel;
-        await channel.sendTyping().catch(() => { });
-        try {
-            const base64Data = await fetchAsBase64(imageUrl);
-            const caption = msg.content.trim() || "";
-            const session = this.getOrCreateSession(channelId, channel);
-            session.claude.sendImage(base64Data, contentType, stampPrompt(caption));
-            this.startTyping(channelId, channel, session);
-        }
-        catch (err) {
-            await channel.send(`Failed to process image: ${err.message}`).catch(() => { });
-        }
-    }
-    getOrCreateSession(channelId, channel) {
-        const key = this.sessionKey(channelId);
-        let session = this.sessions.get(key);
-        if (session && !session.claude.exited)
-            return session;
-        if (session) {
-            // Process exited — clean up
-            if (session.flushTimer)
-                clearTimeout(session.flushTimer);
-            if (session.typingTimer)
-                clearInterval(session.typingTimer);
-        }
-        const claude = new ClaudeProcess({
-            cwd: this.opts.cwd ?? process.cwd(),
-            token: this.opts.claudeToken ?? getCurrentToken(),
-        });
-        session = {
-            claude,
-            pendingText: "",
-            flushTimer: null,
-            typingTimer: null,
-            writtenFiles: new Set(),
-            currentPrompt: "",
-        };
-        claude.on("message", (msg) => {
-            void this.onClaudeMessage(channelId, channel, session, msg);
-        });
-        claude.on("usage", (usage) => {
-            this.addUsage(channelId, usage);
-        });
-        claude.on("error", (err) => {
-            console.error(`[claude:${channelId}] error:`, err.message);
-        });
-        claude.on("exit", (code) => {
-            console.log(`[claude:${channelId}] process exited (code=${code})`);
-            if (session.typingTimer) {
-                clearInterval(session.typingTimer);
-                session.typingTimer = null;
-            }
-        });
-        this.sessions.set(key, session);
-        return session;
-    }
-    async onClaudeMessage(channelId, channel, session, msg) {
-        if (msg.type === "assistant") {
-            const text = extractText(msg);
-            if (!text)
-                return;
-            // Detect file paths in output
-            const filePathMatch = text.match(/(?:^|\n)\s*(?:file written|wrote file|created file|saved to|output:)\s*[:\-]?\s*(\/[^\s\n]+)/im);
-            if (filePathMatch) {
-                const filePath = filePathMatch[1].trim();
-                if (existsSync(filePath)) {
-                    session.writtenFiles.add(filePath);
-                }
-            }
-            // Accumulate streaming text and debounce flush
-            session.pendingText += (session.pendingText ? "\n" : "") + text;
-            if (session.flushTimer)
-                clearTimeout(session.flushTimer);
-            session.flushTimer = setTimeout(() => {
-                void this.flushSession(channelId, channel, session);
-            }, FLUSH_DELAY_MS);
-        }
-        else if (msg.type === "result") {
-            // Final result — flush immediately
-            if (session.flushTimer) {
-                clearTimeout(session.flushTimer);
-                session.flushTimer = null;
-            }
-            const resultText = extractText(msg);
-            if (resultText && !session.pendingText) {
-                session.pendingText = resultText;
-            }
-            await this.flushSession(channelId, channel, session);
-            // Send any files written during this turn
-            for (const filePath of session.writtenFiles) {
-                if (existsSync(filePath)) {
-                    try {
-                        const attachment = new AttachmentBuilder(filePath, { name: basename(filePath) });
-                        await channel.send({ files: [attachment] });
-                    }
-                    catch (err) {
-                        console.warn(`[bot] failed to send file ${filePath}:`, err.message);
-                    }
-                }
-            }
-            session.writtenFiles.clear();
-            // Stop typing indicator
-            if (session.typingTimer) {
-                clearInterval(session.typingTimer);
-                session.typingTimer = null;
-            }
-            this.getCost(channelId).messageCount++;
-        }
-    }
-    async flushSession(channelId, channel, session) {
-        const text = stripAnsi(session.pendingText.trim());
-        session.pendingText = "";
-        session.flushTimer = null;
-        if (!text)
-            return;
-        this.writeChatMessage("assistant", "claude", text, channelId);
-        await this.sendToChannel(channel, text);
-    }
-    startTyping(channelId, channel, session) {
-        if (session.typingTimer)
-            return; // already running
-        // Send immediately
-        channel.sendTyping().catch(() => { });
-        session.typingTimer = setInterval(() => {
-            channel.sendTyping().catch(() => { });
-        }, TYPING_INTERVAL_MS);
-    }
-    killSession(channelId) {
-        const key = this.sessionKey(channelId);
-        const session = this.sessions.get(key);
-        if (!session)
-            return;
-        if (session.flushTimer)
-            clearTimeout(session.flushTimer);
-        if (session.typingTimer)
-            clearInterval(session.typingTimer);
-        session.claude.kill();
-        this.sessions.delete(key);
-    }
-    getCost(channelId) {
-        let cost = this.costs.get(channelId);
-        if (!cost) {
-            cost = { totalInputTokens: 0, totalOutputTokens: 0, totalCacheReadTokens: 0, totalCacheWriteTokens: 0, totalCostUsd: 0, messageCount: 0 };
-            this.costs.set(channelId, cost);
-        }
-        return cost;
-    }
-    addUsage(channelId, usage) {
-        const cost = this.getCost(channelId);
-        cost.totalInputTokens += usage.inputTokens;
-        cost.totalOutputTokens += usage.outputTokens;
-        cost.totalCacheReadTokens += usage.cacheReadTokens;
-        cost.totalCacheWriteTokens += usage.cacheWriteTokens;
-        cost.totalCostUsd += computeCostUsd(usage);
-    }
-    buildCostEmbed(channelId) {
-        const cost = this.getCost(channelId);
-        const inputCost = cost.totalInputTokens * PRICING.inputPerM / 1_000_000;
-        const outputCost = cost.totalOutputTokens * PRICING.outputPerM / 1_000_000;
-        const cacheReadCost = cost.totalCacheReadTokens * PRICING.cacheReadPerM / 1_000_000;
-        const cacheWriteCost = cost.totalCacheWriteTokens * PRICING.cacheWritePerM / 1_000_000;
-        return new EmbedBuilder()
-            .setTitle("Session Cost")
-            .setColor(0x5865F2)
-            .addFields({ name: "Messages", value: String(cost.messageCount), inline: true }, { name: "Total", value: `$${cost.totalCostUsd.toFixed(3)}`, inline: true }, { name: "\u200B", value: "\u200B", inline: false }, { name: "Input", value: `${formatTokens(cost.totalInputTokens)} tokens ($${inputCost.toFixed(3)})`, inline: true }, { name: "Output", value: `${formatTokens(cost.totalOutputTokens)} tokens ($${outputCost.toFixed(3)})`, inline: true }, { name: "Cache Read", value: `${formatTokens(cost.totalCacheReadTokens)} tokens ($${cacheReadCost.toFixed(3)})`, inline: true }, { name: "Cache Write", value: `${formatTokens(cost.totalCacheWriteTokens)} tokens ($${cacheWriteCost.toFixed(3)})`, inline: true });
-    }
-    async registerSlashCommands() {
-        const commands = [
-            new SlashCommandBuilder().setName("reset").setDescription("Reset Claude session for this channel"),
-            new SlashCommandBuilder().setName("costs").setDescription("Show token usage and cost for this channel"),
-            new SlashCommandBuilder().setName("mcp_status").setDescription("Check MCP server connection status"),
-            new SlashCommandBuilder()
-                .setName("crons")
-                .setDescription("Manage cron jobs")
-                .addSubcommand((sub) => sub.setName("list").setDescription("List cron jobs for this channel"))
-                .addSubcommand((sub) => sub.setName("add")
-                .setDescription("Add a cron job")
-                .addStringOption((opt) => opt.setName("schedule").setDescription("Schedule (e.g. every 1h)").setRequired(true))
-                .addStringOption((opt) => opt.setName("prompt").setDescription("Prompt to send").setRequired(true)))
-                .addSubcommand((sub) => sub.setName("remove")
-                .setDescription("Remove a cron job")
-                .addStringOption((opt) => opt.setName("id").setDescription("Job ID").setRequired(true)))
-                .addSubcommand((sub) => sub.setName("clear").setDescription("Clear all cron jobs for this channel")),
-            new SlashCommandBuilder()
-                .setName("wiki")
-                .setDescription("Wiki page info (pass namespace to look up)")
-                .addStringOption((opt) => opt.setName("namespace").setDescription("Namespace to look up").setRequired(false)),
-        ].map((cmd) => cmd.toJSON());
-        const rest = new REST().setToken(this.opts.discordToken);
-        if (this.opts.guildIds?.length) {
-            for (const guildId of this.opts.guildIds) {
-                try {
-                    const appId = this.client.application?.id;
-                    if (!appId) {
-                        console.warn("[discord] application ID not available yet");
-                        return;
-                    }
-                    await rest.put(Routes.applicationGuildCommands(appId, guildId), { body: commands });
-                    console.log(`[discord] slash commands registered for guild ${guildId}`);
-                }
-                catch (err) {
-                    console.error(`[discord] slash command registration failed for guild ${guildId}:`, err.message);
-                }
-            }
-        }
-        else {
-            // Global commands (can take up to 1hr to propagate)
-            try {
-                const appId = this.client.application?.id;
-                if (!appId) {
-                    console.warn("[discord] application ID not available yet");
-                    return;
-                }
-                await rest.put(Routes.applicationCommands(appId), { body: commands });
-                console.log("[discord] slash commands registered globally");
-            }
-            catch (err) {
-                console.error("[discord] global slash command registration failed:", err.message);
-            }
-        }
-    }
-    async handleSlashCommand(interaction) {
-        const channelId = interaction.channelId;
-        const userId = interaction.user.id;
-        if (!this.isAllowed(userId)) {
-            await interaction.reply({ content: "Not authorized.", ephemeral: true });
-            return;
-        }
-        this.lastActiveChannelId = channelId;
-        switch (interaction.commandName) {
-            case "reset": {
-                this.killSession(channelId);
-                await interaction.reply("Session reset. Send a message to start.");
-                break;
-            }
-            case "costs": {
-                const embed = this.buildCostEmbed(channelId);
-                await interaction.reply({ embeds: [embed] });
-                break;
-            }
-            case "mcp_status": {
-                await interaction.deferReply();
-                try {
-                    const result = await this.callCcAgentTool("get_version");
-                    await interaction.editReply(result ? `MCP connected. Version: ${result}` : "MCP connected (no version info).");
-                }
-                catch (err) {
-                    await interaction.editReply(`MCP unavailable: ${err.message}`);
-                }
-                break;
-            }
-            case "crons": {
-                await this.handleCronsCommand(interaction, channelId);
-                break;
-            }
-            case "wiki": {
-                await interaction.deferReply();
-                const ns = interaction.options.getString("namespace") ?? this.namespace;
-                try {
-                    const result = await this.callCcAgentTool("get_wiki", { namespace: ns });
-                    if (result) {
-                        const chunks = splitLongMessage(result);
-                        await interaction.editReply(chunks[0]);
-                        for (const chunk of chunks.slice(1)) {
-                            await interaction.followUp(chunk);
-                        }
-                    }
-                    else {
-                        await interaction.editReply("No wiki content found.");
-                    }
-                }
-                catch (err) {
-                    await interaction.editReply(`Wiki lookup failed: ${err.message}`);
-                }
-                break;
-            }
-        }
-    }
-    async handleCronsCommand(interaction, channelId) {
-        const sub = interaction.options.getSubcommand();
-        const chatIdNum = this.storeSnowflake(channelId);
-        switch (sub) {
-            case "list": {
-                const jobs = this.cron.list(chatIdNum);
-                if (jobs.length === 0) {
-                    await interaction.reply("No cron jobs for this channel.");
-                }
-                else {
-                    const lines = jobs.map((j) => `• **${j.id}** ${j.schedule}: \`${j.prompt}\``);
-                    await interaction.reply(lines.join("\n"));
-                }
-                break;
-            }
-            case "add": {
-                const schedule = interaction.options.getString("schedule", true);
-                const prompt = interaction.options.getString("prompt", true);
-                const job = this.cron.add(chatIdNum, schedule, prompt);
-                if (!job) {
-                    await interaction.reply("Invalid schedule. Use format: `every 30m`, `every 2h`, `every 1d`");
-                }
-                else {
-                    await interaction.reply(`Cron job added: **${job.id}** (${job.schedule})`);
-                }
-                break;
-            }
-            case "remove": {
-                const id = interaction.options.getString("id", true);
-                const removed = this.cron.remove(chatIdNum, id);
-                await interaction.reply(removed ? `Removed cron job ${id}.` : `Job ${id} not found.`);
-                break;
-            }
-            case "clear": {
-                const count = this.cron.clearAll(chatIdNum);
-                await interaction.reply(`Cleared ${count} cron job(s).`);
-                break;
-            }
-            default:
-                await interaction.reply("Unknown subcommand.");
-        }
-    }
-    /**
-     * Call a cc-agent MCP tool via a dedicated ClaudeProcess.
-     * Returns the tool result as a string, or null on failure.
-     */
-    async callCcAgentTool(toolName, args = {}) {
-        return new Promise((resolve) => {
-            const prompt = `Use the ${toolName} tool with these arguments: ${JSON.stringify(args)}. Return only the raw result, no extra commentary.`;
-            const claude = new ClaudeProcess({
-                cwd: this.opts.cwd ?? process.cwd(),
-                token: this.opts.claudeToken ?? getCurrentToken(),
-            });
-            let result = "";
-            const timeout = setTimeout(() => {
-                claude.kill();
-                resolve(null);
-            }, 30_000);
-            claude.on("message", (msg) => {
-                if (msg.type === "result") {
-                    result = extractText(msg) || result;
-                }
-                else if (msg.type === "assistant") {
-                    result += extractText(msg);
-                }
-            });
-            claude.on("exit", () => {
-                clearTimeout(timeout);
-                resolve(result.trim() || null);
-            });
-            claude.on("error", () => {
-                clearTimeout(timeout);
-                resolve(null);
-            });
-            claude.sendPrompt(prompt);
-        });
-    }
-    runCronTask(channelId, prompt, done) {
-        const getChannel = this.getChannel.bind(this);
-        void (async () => {
-            const channel = await getChannel(channelId);
-            if (!channel) {
-                console.warn(`[cron] channel ${channelId} not found`);
-                done();
-                return;
-            }
-            const session = this.getOrCreateSession(channelId, channel);
-            try {
-                session.currentPrompt = prompt;
-                session.claude.sendPrompt(stampPrompt(prompt));
-                this.startTyping(channelId, channel, session);
-                // Listen for result to call done()
-                const onExit = () => { done(); };
-                session.claude.once("exit", onExit);
-            }
-            catch (err) {
-                console.error(`[cron:${channelId}] error:`, err.message);
-                done();
-            }
-        })();
-    }
-    /** Write a message to the Redis chat log. Fire-and-forget. */
-    writeChatMessage(role, source, content, channelId) {
-        if (!this.redis)
-            return;
-        const msg = {
-            id: crypto.randomUUID(),
-            source,
-            role,
-            content,
-            timestamp: new Date().toISOString(),
-            chatId: snowflakeToInt(channelId),
-        };
-        writeChatLog(this.redis, this.namespace, msg);
-    }
-    /** Returns the last channelId that sent a message. */
-    getLastActiveChannelId() {
-        return this.lastActiveChannelId;
-    }
-    /**
-     * Feed a text message into the active Claude session for the given channel.
-     * Called by the notifier when a UI message arrives via Redis pub/sub.
-     */
-    async handleUserMessage(channelId, text) {
-        const channel = await this.getChannel(channelId);
-        if (!channel) {
-            console.warn(`[bot] handleUserMessage: channel ${channelId} not found`);
-            return;
-        }
-        const session = this.getOrCreateSession(channelId, channel);
-        try {
-            session.currentPrompt = text;
-            session.claude.sendPrompt(stampPrompt(text));
-            this.startTyping(channelId, channel, session);
-            this.writeChatMessage("user", "ui", text, channelId);
-        }
-        catch (err) {
-            await channel.send(`Error sending to Claude: ${err.message}`).catch(() => { });
-            this.killSession(channelId);
-        }
-    }
-    /**
-     * Forward a cc-agent job notification into an existing Claude session.
-     * Unlike handleUserMessage, this never creates a new session.
-     */
-    forwardNotification(channelId, text) {
-        const key = this.sessionKey(channelId);
-        const session = this.sessions.get(key);
-        if (!session || session.claude.exited)
-            return;
-        try {
-            session.claude.sendPrompt(stampPrompt(text));
-            this.writeChatMessage("user", "cc-tg", text, channelId);
-        }
-        catch (err) {
-            console.error(`[forwardNotification:${channelId}] failed:`, err.message);
-        }
-    }
-    stop() {
-        for (const [key, session] of this.sessions) {
-            if (session.flushTimer)
-                clearTimeout(session.flushTimer);
-            if (session.typingTimer)
-                clearInterval(session.typingTimer);
-            session.claude.kill();
-            this.sessions.delete(key);
-        }
-        void this.client.destroy();
-    }
-}