skimpyclaw 0.3.10 → 0.3.15

package/dist/channels/discord/handlers.js

@@ -0,0 +1,479 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, AttachmentBuilder, } from 'discord.js';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
+import { getCurrentModel, setCurrentModel } 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, } 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';
+import { KNOWN_COMMANDS } from './types.js';
+import { getHistory, addToHistory, clearHistory, replaceHistory, getDiscordToolConfig, getDiscordRunContext, conversationKey, buildHelpText, sendLongText, startTypingIndicator, } from './utils.js';
+// ── Command handler ─────────────────────────────────────────────────
+export async function handleCommand(message, command, args, config, silenceUntil, setSilenceUntil) {
+    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 { getLastMessage } = await import('../../gateway.js');
+        const last = getLastMessage();
+        const jobs = getCronJobs();
+        const jobList = jobs.map(j => `- ${j.name}: ${j.nextRun?.toLocaleString() || 'unknown'}`).join('\n');
+        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);
+            replaceHistory(key, summary);
+            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;
+        const until = new Date(Date.now() + minutes * 60 * 1000);
+        setSilenceUntil(until);
+        await message.reply(`Proactive messages silenced until ${until.toLocaleTimeString()}`);
+        return;
+    }
+    await message.reply(`Unknown command: /${command}\n\nType /help to see available commands.`);
+}
+// ── Incoming message handler ────────────────────────────────────────
+export async function handleIncomingMessage(message, config) {
+    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 {
+            const imageResponse = await fetch(attachment.url);
+            const imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
+            const base64Image = imageBuffer.toString('base64');
+            const mediaType = attachment.contentType || 'image/jpeg';
+            const caption = message.content.trim() || "What's in this image?";
+            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 {
+            if (!config.voice) {
+                await message.reply('Voice transcription not configured. Add a "voice" section to config.json.');
+                return;
+            }
+            const voiceResponse = await fetch(attachment.url);
+            const buffer = Buffer.from(await voiceResponse.arrayBuffer());
+            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 {
+                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);
+                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 voiceAttachment = new AttachmentBuilder(speech.buffer, {
+                            name: `voice-reply.${speech.format}`,
+                            description: 'Voice reply'
+                        });
+                        await message.reply({ files: [voiceAttachment] });
+                        console.log('[discord] Voice reply sent');
+                    }
+                    catch (err) {
+                        console.error('[discord] TTS synthesis failed:', err);
+                    }
+                }
+                const combined = `> 🎤 ${transcription}\n\n${agentResponse}`;
+                await sendLongText(message, combined);
+            }
+            finally {
+                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, ...cmdArgs] = 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 {
+            // handleCommand is called from index.ts which passes silenceUntil/setter
+            // For DM free-text that happens to match a command, delegate up
+            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();
+    }
+}
+// ── Approval card ───────────────────────────────────────────────────
+export async function sendApprovalCard(client, channelId, approval) {
+    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],
+    });
+}
+// ── Button interaction handler ──────────────────────────────────────
+export 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';
+    }
+    await interaction.reply({ content: statusText, ephemeral: true });
+    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: [],
+            });
+        }
+    }
+    catch {
+        // Message may already be edited or deleted
+    }
+}

package/dist/channels/discord/index.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../types.js';
+export declare function initDiscord(cfg: Config): Promise<boolean>;
+export declare function startDiscord(): Promise<void>;
+export declare function stopDiscord(): Promise<void>;
+export declare function isDiscordSilenced(): boolean;
+export declare function getDiscordDefaultTarget(cfg: Config): string | null;
+export declare function sendDiscordProactiveMessage(target: string | number, message: string): Promise<void>;
+export declare function sendDiscordProactiveVoice(target: string | number, buffer: Buffer, format: string): Promise<void>;

package/dist/channels/discord/index.js

@@ -0,0 +1,149 @@
+import { Client, GatewayIntentBits, Partials, AttachmentBuilder, } from 'discord.js';
+import { onApprovalEvent } from '../../exec-approval.js';
+import { KNOWN_COMMANDS } from './types.js';
+import { handleCommand, handleIncomingMessage, handleInteraction, sendApprovalCard } from './handlers.js';
+import { splitToChunks } from './utils.js';
+let client = null;
+let config;
+let silenceUntil = null;
+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) => {
+        if (message.author.bot)
+            return;
+        void (async () => {
+            const text = message.content.trim();
+            const isPrefixedCommand = text.startsWith('/') || text.startsWith('!');
+            const isDm = message.channel.isDMBased();
+            // Route commands through handleCommand with silenceUntil access
+            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)) {
+                    await handleCommand(message, command, args, config, silenceUntil, (d) => { silenceUntil = d; });
+                    return;
+                }
+                if (isPrefixedCommand) {
+                    await message.reply(`Unknown command: /${command}\n\nType /help to see available commands.`);
+                    return;
+                }
+            }
+            // Non-command messages
+            await handleIncomingMessage(message, config);
+        })();
+    });
+    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
+    onApprovalEvent('created', (event) => {
+        if (!client)
+            return;
+        const { approval } = event;
+        const meta = approval.channelMeta;
+        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(client, 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] });
+    }
+}

package/dist/channels/discord/types.d.ts

@@ -0,0 +1,6 @@
+export declare const BOT_COMMANDS: {
+    command: string;
+    description: string;
+}[];
+export declare const KNOWN_COMMANDS: Set<string>;
+export declare const MAX_HISTORY_PAIRS = 5;

package/dist/channels/discord/types.js

@@ -0,0 +1,17 @@
+export 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' },
+];
+export const KNOWN_COMMANDS = new Set(BOT_COMMANDS.map(c => c.command));
+export const MAX_HISTORY_PAIRS = 5;

package/dist/channels/discord/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Message } from 'discord.js';
+import type { AgentRunContext, ChatMessage, Config, ToolConfig } from '../../types.js';
+export declare function getHistory(key: string): Promise<ChatMessage[]>;
+export declare function addToHistory(key: string, userMsg: string, assistantMsg: string): Promise<void>;
+export declare function clearHistory(key: string): Promise<void>;
+/** Replace history with a compact summary (used by /compact). */
+export declare function replaceHistory(key: string, summary: string): void;
+export declare function getDiscordToolConfig(cfg: Config): ToolConfig;
+export declare function conversationKey(message: Message): string;
+export declare function getDiscordRunContext(message: Message): AgentRunContext;
+export declare function buildHelpText(cfg: Config): string;
+export declare function splitToChunks(text: string, maxLength: number): string[];
+export declare function sendLongText(message: Message, text: string): Promise<void>;
+export declare function startTypingIndicator(message: Message): () => void;