skimpyclaw 0.3.14 → 0.4.0

package/dist/discord.js

@@ -1,792 +0,0 @@
-import { Client, GatewayIntentBits, Partials, ActionRowBuilder, ButtonBuilder, ButtonStyle, AttachmentBuilder, } from 'discord.js';
-import { join } from 'path';
-import { homedir } from 'os';
-import { tmpdir } from 'os';
-import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
-import { getCurrentModel, setCurrentModel, getLastMessage } from './gateway.js';
-import { getCronJobs, runCronJob } from './cron.js';
-import { runAgentTurn } from './agent.js';
-import { runHeartbeatCheck } from './heartbeat.js';
-import { isAllowed, isRateLimited } from './security.js';
-import { getActiveCodeAgents, getRecentCodeAgents } from './tools.js';
-import { listApprovals, approveRequest, denyRequest, getApproval, onApprovalEvent, } from './exec-approval.js';
-import { transcribeAudio, synthesizeSpeech } from './voice.js';
-import * as sessions from './sessions.js';
-import { formatAliases, formatModelSelectionError, getModelSelectionUsage, resolveModelSelection } from './model-selection.js';
-function getDiscordRunContext(message) {
-    return {
-        userId: message.author.id,
-        sessionId: message.channel.id,
-        channel: 'discord',
-        trigger: 'discord',
-        metadata: {
-            username: message.author.username,
-        },
-    };
-}
-const BOT_COMMANDS = [
-    { command: 'help', description: 'Show available commands' },
-    { command: 'model', description: 'Switch model (fast/smart/opus)' },
-    { command: 'status', description: 'Show bot status' },
-    { command: 'clear', description: 'Clear conversation history' },
-    { command: 'compact', description: 'Compress conversation history' },
-    { command: 'silence', description: 'Pause proactive messages' },
-    { command: 'cron', description: 'List or run scheduled jobs' },
-    { command: 'tasks', description: 'List active coding agents and cron jobs' },
-    { command: 'cancel', description: 'Cancel a coding agent (use dashboard) or cron job' },
-    { command: 'approvals', description: 'List pending exec approvals' },
-    { command: 'approve', description: 'Approve an exec request by ID' },
-    { command: 'deny', description: 'Deny an exec request by ID' },
-    { command: 'heartbeat', description: 'Trigger heartbeat check' },
-];
-const KNOWN_COMMANDS = new Set(BOT_COMMANDS.map(c => c.command));
-const MAX_HISTORY_PAIRS = 5;
-const chatHistory = new Map();
-// Track which keys have been loaded from disk this session
-const loadedFromDisk = new Set();
-const DEFAULT_DISCORD_TOOLS = {
-    enabled: true,
-    allowedPaths: [join(homedir(), '.skimpyclaw')],
-    maxIterations: 30,
-    bashTimeout: 15000,
-};
-let client = null;
-let config;
-let silenceUntil = null;
-async function getHistory(key) {
-    // Lazy-load from disk on first access this session
-    if (!loadedFromDisk.has(key)) {
-        loadedFromDisk.add(key);
-        const diskHistory = await sessions.loadHistory('discord', key).catch(() => []);
-        if (diskHistory.length > 0 && !chatHistory.has(key)) {
-            chatHistory.set(key, diskHistory);
-        }
-    }
-    return chatHistory.get(key) || [];
-}
-async function addToHistory(key, userMsg, assistantMsg) {
-    const history = await getHistory(key);
-    history.push({ role: 'user', content: userMsg });
-    history.push({ role: 'assistant', content: assistantMsg });
-    while (history.length > MAX_HISTORY_PAIRS * 2) {
-        history.shift();
-        history.shift();
-    }
-    chatHistory.set(key, history);
-    // Persist to disk (fire-and-forget)
-    sessions.saveExchange('discord', key, userMsg, assistantMsg).catch(() => { });
-}
-async function clearHistory(key) {
-    chatHistory.delete(key);
-    loadedFromDisk.delete(key);
-    await sessions.clearHistory('discord', key).catch(() => { });
-}
-function getDiscordToolConfig(cfg) {
-    const discord = cfg.channels.discord;
-    if (discord?.tools) {
-        return {
-            ...DEFAULT_DISCORD_TOOLS,
-            ...discord.tools,
-            allowedPaths: discord.tools.allowedPaths ?? discord.defaultAllowedPaths ?? DEFAULT_DISCORD_TOOLS.allowedPaths,
-        };
-    }
-    if (discord?.defaultAllowedPaths?.length) {
-        return {
-            ...DEFAULT_DISCORD_TOOLS,
-            allowedPaths: discord.defaultAllowedPaths,
-        };
-    }
-    return DEFAULT_DISCORD_TOOLS;
-}
-function conversationKey(message) {
-    if (message.channel.isDMBased()) {
-        return `dm:${message.author.id}`;
-    }
-    return `channel:${message.channelId}`;
-}
-function buildHelpText(cfg) {
-    const agentConfig = cfg.agents.list[cfg.agents.default];
-    const emoji = agentConfig?.identity?.emoji || '🦞';
-    const name = agentConfig?.identity?.name || 'SkimpyClaw';
-    const commandList = BOT_COMMANDS.map(c => `/${c.command} - ${c.description}`).join('\n');
-    return `${emoji} ${name} online.\n\nSend a message to chat, or use a command:\n\n${commandList}`;
-}
-function splitToChunks(text, maxLength) {
-    if (text.length <= maxLength)
-        return [text];
-    const chunks = [];
-    let current = '';
-    for (const paragraph of text.split('\n\n')) {
-        if (current.length + paragraph.length + 2 > maxLength) {
-            if (current)
-                chunks.push(current.trim());
-            // If a single paragraph exceeds maxLength, split it on newlines or hard-cut
-            if (paragraph.length > maxLength) {
-                const lines = paragraph.split('\n');
-                let lineBuf = '';
-                for (const line of lines) {
-                    if (lineBuf.length + line.length + 1 > maxLength) {
-                        if (lineBuf)
-                            chunks.push(lineBuf.trim());
-                        // If a single line still exceeds, hard-cut it
-                        if (line.length > maxLength) {
-                            for (let i = 0; i < line.length; i += maxLength) {
-                                chunks.push(line.slice(i, i + maxLength));
-                            }
-                            lineBuf = '';
-                        }
-                        else {
-                            lineBuf = line;
-                        }
-                    }
-                    else {
-                        lineBuf += (lineBuf ? '\n' : '') + line;
-                    }
-                }
-                current = lineBuf;
-            }
-            else {
-                current = paragraph;
-            }
-        }
-        else {
-            current += (current ? '\n\n' : '') + paragraph;
-        }
-    }
-    if (current)
-        chunks.push(current.trim());
-    return chunks.filter(c => c.length > 0);
-}
-async function sendLongText(message, text) {
-    const chunks = splitToChunks(text, 1900);
-    for (const chunk of chunks) {
-        await message.reply(chunk);
-    }
-}
-function startTypingIndicator(message) {
-    const maxDurationMs = 90_000;
-    let stopped = false;
-    const stop = () => {
-        if (stopped)
-            return;
-        stopped = true;
-        clearInterval(interval);
-        clearTimeout(watchdog);
-    };
-    const channel = message.channel;
-    if (typeof channel.sendTyping === 'function') {
-        void channel.sendTyping().catch(() => { });
-    }
-    const interval = setInterval(() => {
-        if (stopped)
-            return;
-        if (typeof channel.sendTyping === 'function') {
-            void channel.sendTyping().catch(() => { });
-        }
-    }, 4000);
-    const watchdog = setTimeout(() => {
-        console.warn('[discord] Typing indicator watchdog reached; auto-stopping.');
-        stop();
-    }, maxDurationMs);
-    return stop;
-}
-async function handleCommand(message, command, args) {
-    const rawArgs = args.join(' ').trim();
-    if (command === 'start' || command === 'help') {
-        await sendLongText(message, buildHelpText(config));
-        return;
-    }
-    if (command === 'model') {
-        if (!rawArgs) {
-            const current = getCurrentModel();
-            const aliases = formatAliases(config);
-            await message.reply(`Current: ${current}\nAliases: ${aliases}\n\nUsage: /model <alias|provider/model|model-id>\n${getModelSelectionUsage()}`);
-            return;
-        }
-        const selection = resolveModelSelection(rawArgs, config);
-        if (!selection.ok || !selection.resolved) {
-            const errorMessage = selection.error || 'Invalid model selection';
-            await message.reply(formatModelSelectionError(errorMessage, config));
-            return;
-        }
-        setCurrentModel(selection.resolved);
-        if (selection.aliasUsed) {
-            await message.reply(`Model switched to: ${selection.aliasUsed} (${selection.resolved})`);
-        }
-        else {
-            await message.reply(`Model switched to: ${selection.resolved}`);
-        }
-        return;
-    }
-    if (command === 'status') {
-        const model = getCurrentModel();
-        const last = getLastMessage();
-        const jobs = getCronJobs();
-        const jobList = jobs.map(j => `- ${j.name}: ${j.nextRun?.toLocaleString() || 'unknown'}`).join('\n');
-        // Coding agents status (multi-agent)
-        const caActive = getActiveCodeAgents();
-        const caRecent = getRecentCodeAgents(3);
-        const caAll = [...caActive, ...caRecent];
-        let caLine = 'Coding Agents: idle';
-        if (caAll.length > 0) {
-            const runningCount = caActive.length;
-            const completedCount = caRecent.filter(t => t.status === 'completed').length;
-            const failedCount = caRecent.filter(t => t.status === 'failed' || t.status === 'timeout').length;
-            const parts = [];
-            if (runningCount)
-                parts.push(`${runningCount} running`);
-            if (completedCount)
-                parts.push(`${completedCount} completed`);
-            if (failedCount)
-                parts.push(`${failedCount} failed`);
-            caLine = `Coding Agents: ${parts.join(', ') || 'idle'}`;
-            const caPreview = caAll.slice(0, 5).map(t => {
-                const elapsed = t.durationSeconds != null
-                    ? (t.durationSeconds < 60 ? `${t.durationSeconds}s` : `${Math.floor(t.durationSeconds / 60)}m ${t.durationSeconds % 60}s`)
-                    : (Math.round((Date.now() - new Date(t.startedAt).getTime()) / 1000) + 's');
-                const taskPreview = t.task.length > 50 ? t.task.slice(0, 50) + '...' : t.task;
-                return `  ${t.id}: ${t.status.toUpperCase()} (${t.agent}, ${elapsed}) — ${taskPreview}`;
-            }).join('\n');
-            if (caPreview)
-                caLine += '\n' + caPreview;
-        }
-        await message.reply(`Agent: ${config.agents.default}\n` +
-            `Model: ${model}\n` +
-            `Last message: ${last?.toLocaleString() || 'never'}\n` +
-            `Silence until: ${silenceUntil?.toLocaleString() || 'not silenced'}\n\n` +
-            `${caLine}\n\n` +
-            `Scheduled jobs:\n${jobList || '(none)'}`);
-        return;
-    }
-    if (command === 'cron') {
-        const subcommand = args[0];
-        if (!subcommand || subcommand === 'list') {
-            const jobs = getCronJobs();
-            if (jobs.length === 0) {
-                await message.reply('No scheduled jobs.');
-                return;
-            }
-            const list = jobs.map(j => `${j.id}: ${j.name} (next: ${j.nextRun?.toLocaleString() || '?'})`).join('\n');
-            await message.reply(`Scheduled jobs:\n${list}`);
-            return;
-        }
-        if (subcommand === 'run') {
-            const jobId = args[1];
-            if (!jobId) {
-                await message.reply('Usage: /cron run <job-id>');
-                return;
-            }
-            try {
-                await runCronJob(jobId, config);
-                await message.reply(`Triggered: ${jobId}`);
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : 'Unknown error';
-                await message.reply(`Error: ${msg}`);
-            }
-            return;
-        }
-        await message.reply('Usage: /cron list | /cron run <id>');
-        return;
-    }
-    if (command === 'heartbeat') {
-        const stopTyping = startTypingIndicator(message);
-        try {
-            const response = await runHeartbeatCheck(config);
-            await sendLongText(message, `Heartbeat:\n\n${response}`);
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : 'Unknown error';
-            await message.reply(`Heartbeat error: ${msg}`);
-        }
-        finally {
-            stopTyping();
-        }
-        return;
-    }
-    if (command === 'approvals') {
-        const pending = listApprovals();
-        if (pending.length === 0) {
-            await message.reply('No pending exec approvals.');
-            return;
-        }
-        for (const approval of pending.slice(0, 10)) {
-            const cmdPreview = approval.command.length > 80
-                ? approval.command.slice(0, 80) + '...'
-                : approval.command;
-            const expiresIn = Math.max(0, Math.round((approval.expiresAt.getTime() - Date.now()) / 1000));
-            const expiresStr = expiresIn < 60 ? `${expiresIn}s` : `${Math.floor(expiresIn / 60)}m`;
-            const row = new ActionRowBuilder().addComponents(new ButtonBuilder()
-                .setCustomId(`approve:${approval.id}`)
-                .setLabel('Approve')
-                .setStyle(ButtonStyle.Success), new ButtonBuilder()
-                .setCustomId(`deny:${approval.id}`)
-                .setLabel('Deny')
-                .setStyle(ButtonStyle.Danger));
-            await message.reply({
-                content: `⛔ Approval #${approval.id}\n` +
-                    `Tier ${approval.tier}: ${approval.reason}\n` +
-                    `Command: ${cmdPreview}\n` +
-                    `${approval.cwd ? `CWD: ${approval.cwd}\n` : ''}` +
-                    `Expires in: ${expiresStr}`,
-                components: [row],
-            });
-        }
-        return;
-    }
-    if (command === 'approve') {
-        const id = rawArgs;
-        if (!id) {
-            await message.reply('Usage: /approve <id>');
-            return;
-        }
-        const by = message.author.username || message.author.id;
-        const success = approveRequest(id, by);
-        if (success) {
-            await message.reply(`✅ Approved #${id}`);
-        }
-        else {
-            const existing = getApproval(id);
-            if (existing) {
-                await message.reply(`Cannot approve #${id} — status is already "${existing.status}".`);
-            }
-            else {
-                await message.reply(`No pending approval found with ID "${id}".`);
-            }
-        }
-        return;
-    }
-    if (command === 'deny') {
-        const id = rawArgs;
-        if (!id) {
-            await message.reply('Usage: /deny <id>');
-            return;
-        }
-        const by = message.author.username || message.author.id;
-        const success = denyRequest(id, by);
-        if (success) {
-            await message.reply(`❌ Denied #${id}`);
-        }
-        else {
-            const existing = getApproval(id);
-            if (existing) {
-                await message.reply(`Cannot deny #${id} — status is already "${existing.status}".`);
-            }
-            else {
-                await message.reply(`No pending approval found with ID "${id}".`);
-            }
-        }
-        return;
-    }
-    if (command === 'tasks') {
-        await message.reply('Use `/agents` to list active coding agents, or `/cron` to manage scheduled tasks.');
-        return;
-    }
-    if (command === 'cancel') {
-        await message.reply('Use the dashboard to cancel coding agents, or `/cron` to manage scheduled tasks.');
-        return;
-    }
-    if (command === 'clear') {
-        await clearHistory(conversationKey(message));
-        await message.reply('Conversation cleared. Starting fresh.');
-        return;
-    }
-    if (command === 'compact') {
-        const key = conversationKey(message);
-        const history = await getHistory(key);
-        if (history.length === 0) {
-            await message.reply('No conversation history to compact.');
-            return;
-        }
-        const stopTyping = startTypingIndicator(message);
-        try {
-            const historyText = history.map(m => `${m.role}: ${m.content}`).join('\n');
-            const summary = await runAgentTurn(config.agents.default, `Summarize this conversation in 2-3 sentences so you can remember the context:\n\n${historyText}`, config, getCurrentModel(), undefined, undefined, getDiscordRunContext(message));
-            await clearHistory(key);
-            chatHistory.set(key, [
-                { role: 'user', content: 'Summary of our previous conversation:' },
-                { role: 'assistant', content: summary },
-            ]);
-            loadedFromDisk.add(key); // Mark as loaded so we don't re-load on next access
-            await sessions.replaceWithSummary('discord', key, summary);
-            await message.reply(`Compacted ${history.length} messages into a summary.`);
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : 'Unknown error';
-            await message.reply(`Error: ${msg}`);
-        }
-        finally {
-            stopTyping();
-        }
-        return;
-    }
-    if (command === 'silence') {
-        const minutes = parseInt(rawArgs, 10) || 30;
-        silenceUntil = new Date(Date.now() + minutes * 60 * 1000);
-        await message.reply(`Proactive messages silenced until ${silenceUntil.toLocaleTimeString()}`);
-        return;
-    }
-    await message.reply(`Unknown command: /${command}\n\nType /help to see available commands.`);
-}
-async function handleIncomingMessage(message) {
-    if (message.author.bot)
-        return;
-    if (!config.channels.discord)
-        return;
-    console.log(`[discord] Received message from ${message.author.id} in ${message.channelId}: ${JSON.stringify(message.content).slice(0, 120)}`);
-    const senderId = message.author.id;
-    const senderUsername = message.author.username;
-    if (!isAllowed(config.channels.discord.allowFrom, senderId, senderUsername)) {
-        console.log(`[discord] Blocked message from ${senderId} (@${senderUsername})`);
-        return;
-    }
-    if (isRateLimited(senderId)) {
-        await message.reply('Too many messages. Please wait a moment.');
-        return;
-    }
-    // Check for image attachments
-    const imageAttachments = message.attachments.filter(a => a.contentType?.startsWith('image/'));
-    if (imageAttachments.size > 0) {
-        const attachment = imageAttachments.first();
-        const stopTyping = startTypingIndicator(message);
-        try {
-            // Download the image
-            const imageResponse = await fetch(attachment.url);
-            const imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
-            const base64Image = imageBuffer.toString('base64');
-            // Determine media type
-            const mediaType = attachment.contentType || 'image/jpeg';
-            // Get message text or use default
-            const caption = message.content.trim() || "What's in this image?";
-            // Build multi-part content array
-            const content = [
-                {
-                    type: 'image',
-                    source: {
-                        type: 'base64',
-                        media_type: mediaType,
-                        data: base64Image,
-                    },
-                },
-                {
-                    type: 'text',
-                    text: caption,
-                },
-            ];
-            const key = conversationKey(message);
-            const history = await getHistory(key);
-            const response = await runAgentTurn(config.agents.default, content, config, getCurrentModel(), getDiscordToolConfig(config), history, getDiscordRunContext(message));
-            await addToHistory(key, `[Image: ${caption}]`, response);
-            await sendLongText(message, response);
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : 'Unknown error';
-            await message.reply(`Error processing image: ${msg}`);
-        }
-        finally {
-            stopTyping();
-        }
-        return;
-    }
-    // Check for voice message attachments
-    const voiceAttachments = message.attachments.filter(a => a.contentType?.startsWith('audio/') || a.contentType?.startsWith('voice/'));
-    if (voiceAttachments.size > 0) {
-        const attachment = voiceAttachments.first();
-        const stopTyping = startTypingIndicator(message);
-        try {
-            // Check if voice config is available
-            if (!config.voice) {
-                await message.reply('Voice transcription not configured. Add a "voice" section to config.json.');
-                return;
-            }
-            // Download the voice file
-            const voiceResponse = await fetch(attachment.url);
-            const buffer = Buffer.from(await voiceResponse.arrayBuffer());
-            // Save to temp file
-            const ext = attachment.name?.split('.').pop() || 'ogg';
-            const tempDir = join(tmpdir(), 'skimpyclaw-voice');
-            if (!existsSync(tempDir))
-                mkdirSync(tempDir, { recursive: true });
-            const tempPath = join(tempDir, `discord-voice-${Date.now()}.${ext}`);
-            writeFileSync(tempPath, buffer);
-            try {
-                // Transcribe
-                const result = await transcribeAudio(tempPath, config.voice);
-                const transcription = result.text.trim();
-                console.log(`[discord] Transcription result: ${transcription}`);
-                if (!transcription) {
-                    await message.reply('Could not transcribe audio — no speech detected.');
-                    return;
-                }
-                const key = conversationKey(message);
-                const history = await getHistory(key);
-                const agentResponse = await runAgentTurn(config.agents.default, transcription, config, getCurrentModel(), getDiscordToolConfig(config), history, getDiscordRunContext(message));
-                await addToHistory(key, transcription, agentResponse);
-                // TTS voice reply if sendVoice enabled
-                console.log('[discord] TTS check - sendVoice:', config.voice?.channels?.['discord']?.sendVoice);
-                if (config.voice?.channels?.['discord']?.sendVoice) {
-                    console.log('[discord] Attempting TTS synthesis...');
-                    try {
-                        const speech = await synthesizeSpeech(agentResponse, config.voice);
-                        console.log('[discord] TTS synthesis success:', speech.format, speech.provider, 'buffer size:', speech.buffer.length);
-                        const attachment = new AttachmentBuilder(speech.buffer, {
-                            name: `voice-reply.${speech.format}`,
-                            description: 'Voice reply'
-                        });
-                        await message.reply({ files: [attachment] });
-                        console.log('[discord] Voice reply sent');
-                    }
-                    catch (err) {
-                        console.error('[discord] TTS synthesis failed:', err);
-                        // Non-fatal — text reply still sends below
-                    }
-                }
-                // Format response with transcription in a blockquote
-                const combined = `> 🎤 ${transcription}\n\n${agentResponse}`;
-                await sendLongText(message, combined);
-            }
-            finally {
-                // Clean up temp file
-                try {
-                    unlinkSync(tempPath);
-                }
-                catch { /* best effort */ }
-            }
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : 'Unknown error';
-            await message.reply(`Voice transcription error: ${msg}`);
-        }
-        finally {
-            stopTyping();
-        }
-        return;
-    }
-    const text = message.content.trim();
-    if (!text)
-        return;
-    const isPrefixedCommand = text.startsWith('/') || text.startsWith('!');
-    const isDm = message.channel.isDMBased();
-    if (isPrefixedCommand || isDm) {
-        const commandText = isPrefixedCommand ? text.slice(1).trim() : text;
-        const [commandPart, ...args] = commandText.split(/\s+/);
-        const command = (commandPart || '').toLowerCase();
-        if (!KNOWN_COMMANDS.has(command)) {
-            if (isPrefixedCommand) {
-                await message.reply(`Unknown command: /${command}\n\nType /help to see available commands.`);
-                return;
-            }
-        }
-        else {
-            await handleCommand(message, command, args);
-            return;
-        }
-    }
-    const key = conversationKey(message);
-    const stopTyping = startTypingIndicator(message);
-    try {
-        const history = await getHistory(key);
-        const response = await runAgentTurn(config.agents.default, text, config, getCurrentModel(), getDiscordToolConfig(config), history, getDiscordRunContext(message));
-        await addToHistory(key, text, response);
-        await sendLongText(message, response);
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : 'Unknown error';
-        await message.reply(`Error: ${msg}`);
-    }
-    finally {
-        stopTyping();
-    }
-}
-/** Send an approval card message with approve/deny buttons to a Discord channel. */
-async function sendApprovalCard(channelId, approval) {
-    if (!client)
-        return;
-    const channel = await client.channels.fetch(channelId).catch(() => null);
-    if (!channel || !('send' in channel) || typeof channel.send !== 'function')
-        return;
-    const cmdPreview = approval.command.length > 80
-        ? approval.command.slice(0, 80) + '...'
-        : approval.command;
-    const expiresIn = Math.max(0, Math.round((approval.expiresAt.getTime() - Date.now()) / 1000));
-    const expiresStr = expiresIn < 60 ? `${expiresIn}s` : `${Math.floor(expiresIn / 60)}m`;
-    const row = new ActionRowBuilder().addComponents(new ButtonBuilder()
-        .setCustomId(`approve:${approval.id}`)
-        .setLabel('Approve')
-        .setStyle(ButtonStyle.Success), new ButtonBuilder()
-        .setCustomId(`deny:${approval.id}`)
-        .setLabel('Deny')
-        .setStyle(ButtonStyle.Danger));
-    await channel.send({
-        content: `⛔ Exec approval needed: #${approval.id}\n` +
-            `Tier ${approval.tier}: ${approval.reason}\n` +
-            `Command: ${cmdPreview}\n` +
-            `${approval.cwd ? `CWD: ${approval.cwd}\n` : ''}` +
-            `Expires in: ${expiresStr}`,
-        components: [row],
-    });
-}
-/** Handle Discord button interactions for approval approve/deny. */
-async function handleInteraction(interaction) {
-    if (!interaction.isButton())
-        return;
-    const customId = interaction.customId;
-    const [action, id] = customId.split(':');
-    if (!id || (action !== 'approve' && action !== 'deny')) {
-        await interaction.reply({ content: 'Unknown action', ephemeral: true });
-        return;
-    }
-    const by = interaction.user.username || interaction.user.id;
-    let success;
-    let statusText;
-    if (action === 'approve') {
-        success = approveRequest(id, by);
-        statusText = success ? `✅ Approved by @${by}` : 'Failed — not pending';
-    }
-    else {
-        success = denyRequest(id, by);
-        statusText = success ? `❌ Denied by @${by}` : 'Failed — not pending';
-    }
-    // Ephemeral acknowledgement to the clicker
-    await interaction.reply({ content: statusText, ephemeral: true });
-    // Update the original message to reflect the resolved status
-    try {
-        const approval = getApproval(id);
-        if (approval) {
-            const cmdPreview = approval.command.length > 80
-                ? approval.command.slice(0, 80) + '...'
-                : approval.command;
-            await interaction.message.edit({
-                content: `${statusText}\n\n` +
-                    `Approval #${id}\n` +
-                    `Tier ${approval.tier}: ${approval.reason}\n` +
-                    `Command: ${cmdPreview}`,
-                components: [], // Remove buttons after resolution
-            });
-        }
-    }
-    catch {
-        // Message may already be edited or deleted — ignore
-    }
-}
-export async function initDiscord(cfg) {
-    const discord = cfg.channels.discord;
-    if (!discord?.enabled || !discord.token) {
-        console.log('[discord] Disabled or no token configured');
-        return false;
-    }
-    config = cfg;
-    client = new Client({
-        intents: [
-            GatewayIntentBits.Guilds,
-            GatewayIntentBits.GuildMessages,
-            GatewayIntentBits.DirectMessages,
-            GatewayIntentBits.MessageContent,
-        ],
-        partials: [Partials.Channel],
-    });
-    client.on('messageCreate', (message) => {
-        void handleIncomingMessage(message);
-    });
-    // Handle button interactions (approval approve/deny)
-    client.on('interactionCreate', (interaction) => {
-        void handleInteraction(interaction);
-    });
-    client.once('clientReady', () => {
-        console.log(`[discord] Bot started as ${client?.user?.tag ?? 'unknown'}`);
-    });
-    client.on('error', (error) => {
-        console.error('[discord] Client error:', error);
-    });
-    // Subscribe to approval-created events — proactively post to Discord for discord-origin approvals
-    onApprovalEvent('created', (event) => {
-        if (!client)
-            return;
-        const { approval } = event;
-        const meta = approval.channelMeta;
-        // Only post discord-origin approvals (or fallback when no channel set)
-        if (meta?.channel && meta.channel !== 'discord')
-            return;
-        let targetChannelId;
-        if (meta?.chatId) {
-            targetChannelId = String(meta.chatId);
-        }
-        if (!targetChannelId) {
-            targetChannelId = getDiscordDefaultTarget(cfg) ?? undefined;
-        }
-        if (!targetChannelId)
-            return;
-        void sendApprovalCard(targetChannelId, approval).catch((err) => {
-            console.error('[discord] Failed to send approval notification:', err);
-        });
-    });
-    return true;
-}
-export async function startDiscord() {
-    if (!client || !config.channels.discord?.token)
-        return;
-    console.log('[discord] Starting bot...');
-    await client.login(config.channels.discord.token);
-}
-export async function stopDiscord() {
-    if (!client)
-        return;
-    client.destroy();
-    console.log('[discord] Bot stopped');
-}
-export function isDiscordSilenced() {
-    if (!silenceUntil)
-        return false;
-    return new Date() < silenceUntil;
-}
-export function getDiscordDefaultTarget(cfg) {
-    const discord = cfg.channels.discord;
-    if (!discord)
-        return null;
-    if (discord.defaultChannelId?.trim())
-        return discord.defaultChannelId.trim();
-    for (const entry of discord.allowFrom) {
-        const value = String(entry).trim();
-        if (value)
-            return value;
-    }
-    return null;
-}
-async function sendChunked(target, text) {
-    const chunks = splitToChunks(text, 1900);
-    for (const chunk of chunks) {
-        await target.send(chunk);
-    }
-}
-export async function sendDiscordProactiveMessage(target, message) {
-    if (!client || isDiscordSilenced())
-        return;
-    const targetId = String(target);
-    const channel = await client.channels.fetch(targetId).catch(() => null);
-    if (channel && 'send' in channel && typeof channel.send === 'function') {
-        await sendChunked(channel, message);
-        return;
-    }
-    const user = await client.users.fetch(targetId).catch(() => null);
-    if (user) {
-        await sendChunked(user, message);
-    }
-}
-export async function sendDiscordProactiveVoice(target, buffer, format) {
-    if (!client || isDiscordSilenced())
-        return;
-    const targetId = String(target);
-    const attachment = new AttachmentBuilder(buffer, {
-        name: `voice.${format}`,
-        description: 'Voice message',
-    });
-    const channel = await client.channels.fetch(targetId).catch(() => null);
-    if (channel && 'send' in channel && typeof channel.send === 'function') {
-        await channel.send({ files: [attachment] });
-        return;
-    }
-    const user = await client.users.fetch(targetId).catch(() => null);
-    if (user) {
-        await user.send({ files: [attachment] });
-    }
-}