skimpyclaw 0.3.9 → 0.3.14

package/dist/__tests__/token-efficiency.test.js

@@ -1,27 +1,49 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, afterAll } from 'vitest';
 import { truncateToolResult } from '../providers/utils.js';
+import { existsSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const scratchDir = join(homedir(), '.skimpyclaw', 'scratch');
+// Clean up scratch files created during tests
+afterAll(() => {
+    try {
+        if (existsSync(scratchDir)) {
+            for (const f of readdirSync(scratchDir)) {
+                try {
+                    unlinkSync(join(scratchDir, f));
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch { /* ignore */ }
+});
 describe('token efficiency', () => {
     describe('truncateToolResult', () => {
         it('returns short results unchanged', () => {
             const result = 'short result';
             expect(truncateToolResult(result)).toBe(result);
         });
-        it('truncates at exact boundary', () => {
-            const result = 'x'.repeat(10_240);
-            expect(truncateToolResult(result)).toBe(result); // exactly at limit
+        it('returns results under mask threshold unchanged', () => {
+            const result = 'x'.repeat(7_999);
+            expect(truncateToolResult(result)).toBe(result);
         });
-        it('truncates over limit with notice', () => {
-            const result = 'x'.repeat(20_000);
-            const truncated = truncateToolResult(result);
-            expect(truncated.length).toBeLessThan(result.length);
-            expect(truncated).toContain('[Truncated: 20000 chars total]');
-            expect(truncated.startsWith('x'.repeat(10_240))).toBe(true);
+        it('masks large results to scratch file with summary', () => {
+            const result = 'START' + 'x'.repeat(10_000) + 'END';
+            const masked = truncateToolResult(result);
+            expect(masked.length).toBeLessThan(result.length);
+            expect(masked).toContain('[Full output');
+            expect(masked).toContain('saved to');
+            expect(masked).toContain('.skimpyclaw/scratch/');
+            expect(masked).toContain('use Read tool to access');
+            // Summary includes head and tail
+            expect(masked).toContain('START');
+            expect(masked).toContain('END');
         });
-        it('respects custom maxBytes', () => {
-            const result = 'abcdefghij'; // 10 chars
-            const truncated = truncateToolResult(result, 5);
-            expect(truncated).toContain('[Truncated: 10 chars total]');
-            expect(truncated.startsWith('abcde')).toBe(true);
+        it('includes char count in masked output', () => {
+            const result = 'y'.repeat(20_000);
+            const masked = truncateToolResult(result);
+            expect(masked).toContain('20000 chars');
         });
     });
     describe('retry prompt compression', () => {

package/dist/__tests__/tools.test.js

@@ -60,11 +60,11 @@ describe('getToolDefinitions', () => {
         expect(tools.map(t => t.name)).not.toContain('Browser');
     });
     describe('tool profiles', () => {
-        it('minimal returns exactly 4 built-in tools', async () => {
+        it('minimal returns built-in tools plus Fetch', async () => {
             const config = { ...toolConfig, toolProfile: 'minimal' };
             const tools = await getToolDefinitions(config, { includeAgentTools: true, includeMcp: true });
-            expect(tools).toHaveLength(4);
-            expect(tools.map(t => t.name)).toEqual(['Read', 'Write', 'Glob', 'Bash']);
+            expect(tools).toHaveLength(5);
+            expect(tools.map(t => t.name)).toEqual(['Read', 'Write', 'Glob', 'Bash', 'Fetch']);
         });
         it('minimal excludes Browser even when browser.enabled is true', async () => {
             const config = { ...toolConfig, toolProfile: 'minimal', browser: { enabled: true } };
@@ -199,13 +199,15 @@ describe('bash', () => {
         const result = await executeTool('Bash', { command: 'echo hello' }, toolConfig);
         expect(result.trim()).toBe('hello');
     });
-    it('blocks dangerous commands', async () => {
-        const result = await executeTool('Bash', { command: 'rm -rf /' }, toolConfig);
-        expect(result).toContain('Error: Command blocked');
+    it('blocks dangerous commands via exec approval', async () => {
+        const result = await executeTool('Bash', { command: `rm -rf ${TEST_DIR}` }, toolConfig);
+        expect(result).toContain('⛔');
+        expect(result).toContain('tier 3');
     });
-    it('blocks sudo', async () => {
-        const result = await executeTool('Bash', { command: 'sudo cat /etc/passwd' }, toolConfig);
-        expect(result).toContain('Error: Command blocked');
+    it('blocks sudo via exec approval', async () => {
+        const result = await executeTool('Bash', { command: `sudo ls ${TEST_DIR}` }, toolConfig);
+        expect(result).toContain('⛔');
+        expect(result).toContain('tier 2');
     });
     it('respects cwd when in allowed paths', async () => {
         const result = await executeTool('Bash', { command: 'ls', cwd: TEST_DIR }, toolConfig);

package/dist/agent.js

@@ -52,7 +52,7 @@ export function buildSystemPrompt(agentId, skillsContext) {
             cronJobId: skillsContext?.cronJobId,
             tags: skillsContext?.tags,
         });
-        skillsSection = formatSkillsPrompt(contextSkills, skillsContext?.skillConfig?.maxPromptTokens);
+        skillsSection = formatSkillsPrompt(contextSkills, skillsContext?.skillConfig?.maxPromptTokens, skillsContext?.skillConfig?.dynamicLoading);
     }
     const base = [soul, identity, tools, skillsSection].filter(Boolean).join('\n\n---\n\n');
     const userContext = [user, memory].filter(Boolean).join('\n\n');
@@ -159,7 +159,7 @@ export async function runAgentTurn(agentId, userMessage, config, modelOverride,
     const runTurn = async () => {
         if (toolConfig?.enabled) {
             // Provider-specific routing is centralized in providers/chatWithTools.
-            console.log(`[agent] Running with tools (provider: ${provider}, model: ${modelId}, paths: ${toolConfig.allowedPaths.join(', ')})`);
+            console.log(`[agent] Running with tools (provider: ${provider}, model: ${modelId}, paths: ${(toolConfig.allowedPaths ?? []).join(', ')})`);
             const result = await chatWithTools(messages, chatOptions, config, toolConfig, toolCtx);
             response = result.response;
             toolCalls = result.toolCalls;

package/dist/api.js

@@ -619,6 +619,11 @@ export function registerDashboardAPI(fastify, config) {
             return reply.code(500).send({ error: `Reload failed: ${msg}` });
         }
     });
+    fastify.post('/api/dashboard/mcp/reconnect', async () => {
+        const { reconnectMcp } = await import('./tools.js');
+        await reconnectMcp();
+        return { reconnected: true, timestamp: new Date().toISOString() };
+    });
     // --- Audit Log ---
     // Reads from ~/.skimpyclaw/logs/audit/YYYY-MM-DD.jsonl files
     fastify.get('/api/dashboard/audit', async (request) => {

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

@@ -0,0 +1,7 @@
+import { type Client, type Message, type Interaction } from 'discord.js';
+import type { Config } from '../../types.js';
+import { type PendingApproval } from '../../exec-approval.js';
+export declare function handleCommand(message: Message, command: string, args: string[], config: Config, silenceUntil: Date | null, setSilenceUntil: (d: Date | null) => void): Promise<void>;
+export declare function handleIncomingMessage(message: Message, config: Config): Promise<void>;
+export declare function sendApprovalCard(client: Client, channelId: string, approval: PendingApproval): Promise<void>;
+export declare function handleInteraction(interaction: Interaction): Promise<void>;

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>;