disunday 1.0.0

package/dist/commands/run.js

@@ -0,0 +1,240 @@
+// /run command - Execute terminal commands directly from Discord.
+// Supports immediate execution and background mode with dual notifications.
+import { ChannelType, EmbedBuilder, } from 'discord.js';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { getChannelDirectory, getRunConfig } from '../database.js';
+import { resolveTextChannel, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getBashWhitelist } from '../config.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const execAsync = promisify(exec);
+const logger = createLogger(LogPrefix.DISCORD);
+const MAX_TIMEOUT_MS = 300_000;
+const MAX_OUTPUT_LENGTH = 1900;
+const backgroundJobs = new Map();
+function validateCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return { valid: false, reason: 'Empty command' };
+    }
+    // Extract the base command (first word, handle paths)
+    const firstWord = trimmed.split(/\s+/)[0] || '';
+    const baseCommand = firstWord.split('/').pop() || firstWord;
+    const whitelist = getBashWhitelist();
+    // Check if wildcard is allowed
+    if (whitelist.includes('*')) {
+        return { valid: true };
+    }
+    if (!whitelist.includes(baseCommand)) {
+        return {
+            valid: false,
+            reason: `Command \`${baseCommand}\` is not in the whitelist.\nAllowed: ${whitelist.slice(0, 10).join(', ')}${whitelist.length > 10 ? '...' : ''}`,
+        };
+    }
+    return { valid: true };
+}
+async function sendSystemNotification({ title, message, }) {
+    if (process.platform === 'darwin') {
+        const escapedTitle = title.replace(/"/g, '\\"');
+        const escapedMessage = message.replace(/"/g, '\\"');
+        try {
+            await execAsync(`osascript -e 'display notification "${escapedMessage}" with title "${escapedTitle}"'`);
+        }
+        catch {
+            // Ignore notification failures
+        }
+    }
+    // Terminal bell
+    process.stdout.write('\x07');
+}
+async function sendWebhook({ url, payload, }) {
+    try {
+        await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+    }
+    catch {
+        // Ignore webhook failures
+    }
+}
+function createResultEmbed({ command, stdout, stderr, exitCode, durationMs, background, }) {
+    const success = exitCode === 0;
+    const durationSec = (durationMs / 1000).toFixed(1);
+    const embed = new EmbedBuilder()
+        .setColor(success ? 0x00ff00 : 0xff0000)
+        .setTitle(`${success ? '✅' : '❌'} ${background ? '[BG] ' : ''}${command.slice(0, 50)}${command.length > 50 ? '...' : ''}`)
+        .setFooter({ text: `Exit: ${exitCode ?? 'killed'} | ${durationSec}s` })
+        .setTimestamp();
+    const output = stdout || stderr || '(no output)';
+    const truncated = output.length > MAX_OUTPUT_LENGTH
+        ? output.slice(0, MAX_OUTPUT_LENGTH) + '\n... (truncated)'
+        : output;
+    embed.setDescription(`\`\`\`\n${truncated}\n\`\`\``);
+    return embed;
+}
+export async function handleRunCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    // Get options
+    const cmdString = command.options.getString('command', true);
+    const background = command.options.getBoolean('background') ?? false;
+    const timeoutSec = command.options.getInteger('timeout') ?? 30;
+    const subdirectory = command.options.getString('directory');
+    // Validate command against whitelist
+    const validation = validateCommand(cmdString);
+    if (!validation.valid) {
+        await command.reply({
+            content: `❌ ${validation.reason}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Get project directory
+    let projectDirectory;
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (isThread) {
+        const textChannel = await resolveTextChannel(channel);
+        if (textChannel) {
+            const config = getChannelDirectory(textChannel.id);
+            projectDirectory = config?.directory;
+        }
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const config = getChannelDirectory(channel.id);
+        projectDirectory = config?.directory;
+    }
+    if (!projectDirectory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const cwd = subdirectory
+        ? `${projectDirectory}/${subdirectory}`
+        : projectDirectory;
+    const timeoutMs = Math.min(timeoutSec * 1000, MAX_TIMEOUT_MS);
+    const runConfig = getRunConfig(channel.id);
+    const sendableChannel = channel;
+    if (background) {
+        await command.reply({
+            content: `⏳ Running in background: \`${cmdString}\``,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const jobId = `${channel.id}-${Date.now()}`;
+        backgroundJobs.set(jobId, {
+            command: cmdString,
+            startTime: Date.now(),
+            threadId: channel.id,
+            userId: command.user.id,
+        });
+        const startTime = Date.now();
+        exec(cmdString, { cwd, timeout: timeoutMs, maxBuffer: 10 * 1024 * 1024 }, async (error, stdout, stderr) => {
+            const durationMs = Date.now() - startTime;
+            const exitCode = error?.code ?? (error ? 1 : 0);
+            backgroundJobs.delete(jobId);
+            const embed = createResultEmbed({
+                command: cmdString,
+                stdout,
+                stderr,
+                exitCode,
+                durationMs,
+                background: true,
+            });
+            if (runConfig.notify_discord) {
+                try {
+                    await sendableChannel.send({
+                        content: `<@${command.user.id}>`,
+                        embeds: [embed],
+                        flags: NOTIFY_MESSAGE_FLAGS,
+                    });
+                }
+                catch (e) {
+                    logger.error('Failed to send background result:', e);
+                }
+            }
+            if (runConfig.notify_system) {
+                const status = exitCode === 0 ? '✅ Success' : '❌ Failed';
+                await sendSystemNotification({
+                    title: 'Disunday',
+                    message: `${status}: ${cmdString.slice(0, 30)}`,
+                });
+            }
+            if (runConfig.webhook_url) {
+                await sendWebhook({
+                    url: runConfig.webhook_url,
+                    payload: {
+                        type: 'run_complete',
+                        command: cmdString,
+                        exitCode,
+                        durationMs,
+                        stdout: stdout.slice(0, 1000),
+                        stderr: stderr.slice(0, 1000),
+                        userId: command.user.id,
+                        channelId: channel.id,
+                    },
+                });
+            }
+        });
+    }
+    else {
+        // Immediate execution
+        await command.deferReply();
+        const startTime = Date.now();
+        try {
+            const { stdout, stderr } = await execAsync(cmdString, {
+                cwd,
+                timeout: timeoutMs,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            const durationMs = Date.now() - startTime;
+            const embed = createResultEmbed({
+                command: cmdString,
+                stdout,
+                stderr,
+                exitCode: 0,
+                durationMs,
+            });
+            await command.editReply({ embeds: [embed] });
+        }
+        catch (error) {
+            const durationMs = Date.now() - startTime;
+            const execError = error;
+            const embed = createResultEmbed({
+                command: cmdString,
+                stdout: execError.stdout || '',
+                stderr: execError.stderr || (error instanceof Error ? error.message : ''),
+                exitCode: execError.killed ? null : (execError.code ?? 1),
+                durationMs,
+            });
+            await command.editReply({ embeds: [embed] });
+        }
+    }
+}
+export async function handleRunAutocomplete({ interaction, }) {
+    const focused = interaction.options.getFocused();
+    const whitelist = getBashWhitelist();
+    const suggestions = whitelist
+        .filter((cmd) => {
+        return cmd.toLowerCase().startsWith(focused.toLowerCase());
+    })
+        .slice(0, 25)
+        .map((cmd) => {
+        return { name: cmd, value: cmd };
+    });
+    await interaction.respond(suggestions);
+}

package/dist/commands/schedule.js

@@ -0,0 +1,170 @@
+import { createScheduledMessage, getSchedulesByChannel, getScheduleById, cancelSchedule, } from '../database.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const scheduleLogger = createLogger(LogPrefix.INTERACTION);
+function parseTimeInput(input) {
+    const now = Date.now();
+    const relativeMatch = input.match(/^(\d+)\s*(s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?)$/i);
+    if (relativeMatch) {
+        const value = parseInt(relativeMatch[1], 10);
+        const unit = relativeMatch[2].toLowerCase();
+        const multipliers = {
+            s: 1000,
+            sec: 1000,
+            second: 1000,
+            seconds: 1000,
+            m: 60 * 1000,
+            min: 60 * 1000,
+            minute: 60 * 1000,
+            minutes: 60 * 1000,
+            h: 60 * 60 * 1000,
+            hr: 60 * 60 * 1000,
+            hour: 60 * 60 * 1000,
+            hours: 60 * 60 * 1000,
+            d: 24 * 60 * 60 * 1000,
+            day: 24 * 60 * 60 * 1000,
+            days: 24 * 60 * 60 * 1000,
+        };
+        const multiplier = multipliers[unit];
+        if (multiplier) {
+            return now + value * multiplier;
+        }
+    }
+    const timeMatch = input.match(/^(\d{1,2}):(\d{2})\s*(am|pm)?$/i);
+    if (timeMatch) {
+        let hours = parseInt(timeMatch[1], 10);
+        const minutes = parseInt(timeMatch[2], 10);
+        const meridiem = timeMatch[3]?.toLowerCase();
+        if (meridiem === 'pm' && hours < 12) {
+            hours += 12;
+        }
+        if (meridiem === 'am' && hours === 12) {
+            hours = 0;
+        }
+        const target = new Date();
+        target.setHours(hours, minutes, 0, 0);
+        if (target.getTime() <= now) {
+            target.setDate(target.getDate() + 1);
+        }
+        return target.getTime();
+    }
+    return null;
+}
+function formatScheduleTime(timestamp) {
+    const date = new Date(timestamp);
+    const now = Date.now();
+    const diff = timestamp - now;
+    const relative = (() => {
+        if (diff < 60000) {
+            return `${Math.ceil(diff / 1000)}s`;
+        }
+        if (diff < 3600000) {
+            return `${Math.ceil(diff / 60000)}m`;
+        }
+        if (diff < 86400000) {
+            return `${Math.ceil(diff / 3600000)}h`;
+        }
+        return `${Math.ceil(diff / 86400000)}d`;
+    })();
+    const timeStr = date.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true,
+    });
+    return `${timeStr} (in ${relative})`;
+}
+export async function handleScheduleCommand({ command, appId, }) {
+    const subcommand = command.options.getSubcommand();
+    switch (subcommand) {
+        case 'add': {
+            const prompt = command.options.getString('prompt', true);
+            const time = command.options.getString('time', true);
+            const scheduledAt = parseTimeInput(time);
+            if (!scheduledAt) {
+                await command.reply({
+                    content: `❌ Invalid time format. Use:\n• Relative: \`30m\`, \`2h\`, \`1d\`\n• Absolute: \`3:00pm\`, \`14:30\``,
+                    ephemeral: true,
+                });
+                return;
+            }
+            if (scheduledAt <= Date.now()) {
+                await command.reply({
+                    content: '❌ Scheduled time must be in the future',
+                    ephemeral: true,
+                });
+                return;
+            }
+            const channelId = command.channelId;
+            const isThread = command.channel?.isThread();
+            const threadId = isThread ? command.channelId : undefined;
+            const parentChannelId = isThread ? command.channel.parentId : null;
+            const id = createScheduledMessage({
+                channelId: parentChannelId || channelId,
+                threadId,
+                prompt,
+                scheduledAt,
+                createdBy: command.user.id,
+            });
+            scheduleLogger.log(`[SCHEDULE] Created schedule #${id} for ${formatScheduleTime(scheduledAt)}`);
+            await command.reply({
+                content: `⏰ Scheduled **#${id}** for ${formatScheduleTime(scheduledAt)}\n\`\`\`\n${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}\n\`\`\``,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        case 'list': {
+            const channelId = command.channelId;
+            const schedules = getSchedulesByChannel(channelId);
+            if (schedules.length === 0) {
+                await command.reply({
+                    content: '📭 No pending schedules in this channel',
+                    ephemeral: true,
+                });
+                return;
+            }
+            const lines = schedules.map((s) => {
+                const time = formatScheduleTime(s.scheduled_at);
+                const preview = s.prompt.slice(0, 40) + (s.prompt.length > 40 ? '...' : '');
+                return `**#${s.id}** ${time}\n└ ${preview}`;
+            });
+            await command.reply({
+                content: `📋 **Pending Schedules**\n\n${lines.join('\n\n')}`,
+                ephemeral: true,
+            });
+            return;
+        }
+        case 'cancel': {
+            const id = command.options.getInteger('id', true);
+            const schedule = getScheduleById(id);
+            if (!schedule) {
+                await command.reply({
+                    content: `❌ Schedule #${id} not found`,
+                    ephemeral: true,
+                });
+                return;
+            }
+            if (schedule.status !== 'pending') {
+                await command.reply({
+                    content: `❌ Schedule #${id} is already ${schedule.status}`,
+                    ephemeral: true,
+                });
+                return;
+            }
+            const cancelled = cancelSchedule(id, command.user.id);
+            if (cancelled) {
+                scheduleLogger.log(`[SCHEDULE] Cancelled schedule #${id}`);
+                await command.reply({
+                    content: `✅ Cancelled schedule **#${id}**`,
+                    flags: SILENT_MESSAGE_FLAGS,
+                });
+            }
+            else {
+                await command.reply({
+                    content: `❌ Failed to cancel schedule #${id}`,
+                    ephemeral: true,
+                });
+            }
+            return;
+        }
+    }
+}

package/dist/commands/session-info.js

@@ -0,0 +1,58 @@
+import { ChannelType } from 'discord.js';
+import { getDatabase, getThreadWorktree } from '../database.js';
+import { resolveTextChannel, getDisundayMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+export async function handleSessionInfoCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getDisundayMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    const worktreeInfo = getThreadWorktree(channel.id);
+    const sdkDirectory = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+        ? worktreeInfo.worktree_directory
+        : directory;
+    const terminalCmd = `opencode -s ${sessionId} ${sdkDirectory}`;
+    await command.reply({
+        content: `📋 **Session Info**\n\n**Session ID:** \`${sessionId}\`\n**Directory:** \`${sdkDirectory}\`\n\n**Terminal command:**\n\`\`\`\n${terminalCmd}\n\`\`\``,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}

package/dist/commands/session.js

@@ -0,0 +1,191 @@
+// /new-session command - Start a new OpenCode session.
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDatabase, getChannelDirectory } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { handleOpencodeSession } from '../session-handler.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.SESSION);
+export async function handleSessionCommand({ command, appId }) {
+    await command.deferReply({ ephemeral: false });
+    const prompt = command.options.getString('prompt', true);
+    const filesString = command.options.getString('files') || '';
+    const agent = command.options.getString('agent') || undefined;
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels');
+        return;
+    }
+    const textChannel = channel;
+    const channelConfig = getChannelDirectory(textChannel.id);
+    const projectDirectory = channelConfig?.directory;
+    const channelAppId = channelConfig?.appId || undefined;
+    if (channelAppId && channelAppId !== appId) {
+        await command.editReply('This channel is not configured for this bot');
+        return;
+    }
+    if (!projectDirectory) {
+        await command.editReply('This channel is not configured with a project directory');
+        return;
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        await command.editReply(`Directory does not exist: ${projectDirectory}`);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await command.editReply(getClient.message);
+            return;
+        }
+        const files = filesString
+            .split(',')
+            .map((f) => f.trim())
+            .filter((f) => f);
+        let fullPrompt = prompt;
+        if (files.length > 0) {
+            fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
+        }
+        const starterMessage = await textChannel.send({
+            content: `🚀 **Starting OpenCode session**\n📝 ${prompt}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: prompt.slice(0, 100),
+            autoArchiveDuration: 1440,
+            reason: 'OpenCode session',
+        });
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
+        await command.editReply(`Created new session in ${thread.toString()}`);
+        await handleOpencodeSession({
+            prompt: fullPrompt,
+            thread,
+            projectDirectory,
+            channelId: textChannel.id,
+            agent,
+        });
+    }
+    catch (error) {
+        logger.error('[SESSION] Error:', error);
+        await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+async function handleAgentAutocomplete({ interaction, appId }) {
+    const focusedValue = interaction.options.getFocused();
+    let projectDirectory;
+    if (interaction.channel && interaction.channel.type === ChannelType.GuildText) {
+        const channelConfig = getChannelDirectory(interaction.channel.id);
+        if (channelConfig) {
+            if (channelConfig.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
+            }
+            projectDirectory = channelConfig.directory;
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await interaction.respond([]);
+            return;
+        }
+        const agentsResponse = await getClient().app.agents({
+            query: { directory: projectDirectory },
+        });
+        if (!agentsResponse.data || agentsResponse.data.length === 0) {
+            await interaction.respond([]);
+            return;
+        }
+        const agents = agentsResponse.data
+            .filter((a) => {
+            const hidden = a.hidden;
+            return (a.mode === 'primary' || a.mode === 'all') && !hidden;
+        })
+            .filter((a) => a.name.toLowerCase().includes(focusedValue.toLowerCase()))
+            .slice(0, 25);
+        const choices = agents.map((agent) => ({
+            name: agent.name.slice(0, 100),
+            value: agent.name,
+        }));
+        await interaction.respond(choices);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching agents:', error);
+        await interaction.respond([]);
+    }
+}
+export async function handleSessionAutocomplete({ interaction, appId, }) {
+    const focusedOption = interaction.options.getFocused(true);
+    if (focusedOption.name === 'agent') {
+        await handleAgentAutocomplete({ interaction, appId });
+        return;
+    }
+    if (focusedOption.name !== 'files') {
+        return;
+    }
+    const focusedValue = focusedOption.value;
+    const parts = focusedValue.split(',');
+    const previousFiles = parts
+        .slice(0, -1)
+        .map((f) => f.trim())
+        .filter((f) => f);
+    const currentQuery = (parts[parts.length - 1] || '').trim();
+    let projectDirectory;
+    if (interaction.channel && interaction.channel.type === ChannelType.GuildText) {
+        const channelConfig = getChannelDirectory(interaction.channel.id);
+        if (channelConfig) {
+            if (channelConfig.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
+            }
+            projectDirectory = channelConfig.directory;
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await interaction.respond([]);
+            return;
+        }
+        const response = await getClient().find.files({
+            query: {
+                query: currentQuery || '',
+            },
+        });
+        const files = response.data || [];
+        const prefix = previousFiles.length > 0 ? previousFiles.join(', ') + ', ' : '';
+        const choices = files
+            .map((file) => {
+            const fullValue = prefix + file;
+            const allFiles = [...previousFiles, file];
+            const allBasenames = allFiles.map((f) => f.split('/').pop() || f);
+            let displayName = allBasenames.join(', ');
+            if (displayName.length > 100) {
+                displayName = '…' + displayName.slice(-97);
+            }
+            return {
+                name: displayName,
+                value: fullValue,
+            };
+        })
+            .filter((choice) => choice.value.length <= 100)
+            .slice(0, 25);
+        await interaction.respond(choices);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching files:', error);
+        await interaction.respond([]);
+    }
+}