disunday 1.0.0

package/dist/commands/remove-project.js

@@ -0,0 +1,119 @@
+// /remove-project command - Remove Discord channels for a project.
+import path from 'node:path';
+import * as errore from 'errore';
+import { getDatabase } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { abbreviatePath } from '../utils.js';
+const logger = createLogger(LogPrefix.REMOVE_PROJECT);
+export async function handleRemoveProjectCommand({ command, appId }) {
+    await command.deferReply({ ephemeral: false });
+    const directory = command.options.getString('project', true);
+    const guild = command.guild;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    try {
+        const db = getDatabase();
+        // Get channel IDs for this directory
+        const channels = db
+            .prepare('SELECT channel_id, channel_type FROM channel_directories WHERE directory = ?')
+            .all(directory);
+        if (channels.length === 0) {
+            await command.editReply(`No channels found for directory: \`${directory}\``);
+            return;
+        }
+        const deletedChannels = [];
+        const failedChannels = [];
+        for (const { channel_id, channel_type } of channels) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (channel instanceof Error) {
+                logger.error(`Failed to fetch channel ${channel_id}:`, channel);
+                failedChannels.push(`${channel_type}: ${channel_id}`);
+                continue;
+            }
+            if (channel) {
+                try {
+                    await channel.delete(`Removed by /remove-project command`);
+                    deletedChannels.push(`${channel_type}: ${channel_id}`);
+                }
+                catch (error) {
+                    logger.error(`Failed to delete channel ${channel_id}:`, error);
+                    failedChannels.push(`${channel_type}: ${channel_id}`);
+                }
+            }
+            else {
+                deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
+            }
+        }
+        // Remove from database
+        db.prepare('DELETE FROM channel_directories WHERE directory = ?').run(directory);
+        const projectName = path.basename(directory);
+        let message = `Removed project **${projectName}**\n`;
+        message += `Directory: \`${directory}\`\n\n`;
+        if (deletedChannels.length > 0) {
+            message += `Deleted channels:\n${deletedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        if (failedChannels.length > 0) {
+            message += `\n\nFailed to delete (may be in another server):\n${failedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        await command.editReply(message);
+        logger.log(`Removed project ${projectName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[REMOVE-PROJECT] Error:', error);
+        await command.editReply(`Failed to remove project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    const guild = interaction.guild;
+    if (!guild) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const db = getDatabase();
+        // Get all directories with channels
+        const allChannels = db
+            .prepare('SELECT DISTINCT directory, channel_id FROM channel_directories WHERE channel_type = ?')
+            .all('text');
+        // Filter to only channels that exist in this guild
+        const projectsInGuild = [];
+        for (const { directory, channel_id } of allChannels) {
+            const channel = await errore.tryAsync({
+                try: () => guild.channels.fetch(channel_id),
+                catch: (e) => e,
+            });
+            if (channel instanceof Error) {
+                // Channel not in this guild, skip
+                continue;
+            }
+            if (channel) {
+                projectsInGuild.push({ directory, channelId: channel_id });
+            }
+        }
+        const projects = projectsInGuild
+            .filter(({ directory }) => {
+            const baseName = path.basename(directory);
+            const searchText = `${baseName} ${directory}`.toLowerCase();
+            return searchText.includes(focusedValue.toLowerCase());
+        })
+            .slice(0, 25)
+            .map(({ directory }) => {
+            const name = `${path.basename(directory)} (${abbreviatePath(directory)})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '...' : name,
+                value: directory,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/rename.js

@@ -0,0 +1,70 @@
+import { ChannelType } from 'discord.js';
+import { getDatabase, getThreadWorktree } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getDisundayMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.SESSION);
+export async function handleRenameCommand({ command, }) {
+    const newTitle = command.options.getString('title', true);
+    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;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const thread = channel;
+    const textChannel = await resolveTextChannel(thread);
+    const { projectDirectory: directory } = getDisundayMetadata(textChannel);
+    if (!directory) {
+        await command.editReply('Could not determine project directory for this channel');
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.editReply('No active session in this thread');
+        return;
+    }
+    const sessionId = row.session_id;
+    const worktreeInfo = getThreadWorktree(channel.id);
+    const sdkDirectory = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
+        ? worktreeInfo.worktree_directory
+        : directory;
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        if (getClient instanceof Error) {
+            await command.editReply(`Failed to rename: ${getClient.message}`);
+            return;
+        }
+        await getClient().session.update({
+            path: { id: sessionId },
+            body: { title: newTitle },
+            query: { directory: sdkDirectory },
+        });
+        await thread.setName(newTitle.slice(0, 100)).catch(() => { });
+        await command.editReply(`✅ Session renamed to: **${newTitle}**`);
+        logger.log(`[RENAME] Session ${sessionId} renamed to "${newTitle}"`);
+    }
+    catch (error) {
+        logger.error('[RENAME] Error:', error);
+        await command.editReply(`Failed to rename: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/restart-opencode-server.js

@@ -0,0 +1,77 @@
+// /restart-opencode-server command - Restart the opencode server for the current channel.
+// Used for resolving opencode state issues, internal bugs, refreshing auth state, plugins, etc.
+import { ChannelType } from 'discord.js';
+import { restartOpencodeServer } from '../opencode.js';
+import { resolveTextChannel, getDisundayMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.OPENCODE);
+export async function handleRestartOpencodeServerCommand({ command, appId }) {
+    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);
+    let projectDirectory;
+    let channelAppId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = getDisundayMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = getDisundayMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+    }
+    else {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await command.reply({
+            content: 'This channel is not configured for this bot',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Defer reply since restart may take a moment
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    logger.log(`[RESTART] Restarting opencode server for directory: ${projectDirectory}`);
+    const result = await restartOpencodeServer(projectDirectory);
+    if (result instanceof Error) {
+        logger.error('[RESTART] Failed:', result);
+        await command.editReply({
+            content: `Failed to restart opencode server: ${result.message}`,
+        });
+        return;
+    }
+    await command.editReply({
+        content: `🔄 Opencode server **restarted** successfully`,
+    });
+    logger.log(`[RESTART] Opencode server restarted for directory: ${projectDirectory}`);
+}

package/dist/commands/resume.js

@@ -0,0 +1,276 @@
+import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import fs from 'node:fs';
+import { getDatabase, getChannelDirectory } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { sendThreadMessage, resolveTextChannel, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { collectLastAssistantParts } from '../message-formatting.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.RESUME);
+const sessionCache = new Map();
+const CACHE_TTL = 30_000;
+export async function refreshSessionCache(projectDirectory) {
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        return [];
+    }
+    try {
+        const response = await getClient().session.list({
+            query: { directory: projectDirectory },
+        });
+        const sessions = (response.data || []).map((s) => ({
+            id: s.id,
+            title: s.title,
+            updated: new Date(s.time.updated).getTime(),
+        }));
+        sessionCache.set(projectDirectory, { sessions, timestamp: Date.now() });
+        return sessions;
+    }
+    catch {
+        return sessionCache.get(projectDirectory)?.sessions || [];
+    }
+}
+export async function handleResumeCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const sessionId = command.options.getString('session', true);
+    if (sessionId === '__refresh__') {
+        const channelConfig = getChannelDirectory(command.channelId);
+        if (channelConfig?.directory) {
+            await refreshSessionCache(channelConfig.directory);
+        }
+        await command.editReply('🔄 Session list refreshed! Run `/resume` again to see updated list.');
+        return;
+    }
+    if (sessionId.startsWith('__header_')) {
+        await command.editReply('Please select a session, not a header.');
+        return;
+    }
+    const channel = command.channel;
+    const isThread = channel &&
+        [
+            ChannelType.PublicThread,
+            ChannelType.PrivateThread,
+            ChannelType.AnnouncementThread,
+        ].includes(channel.type);
+    if (isThread) {
+        await command.editReply('This command can only be used in project channels, not threads');
+        return;
+    }
+    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 sessionResponse = await getClient().session.get({
+            path: { id: sessionId },
+        });
+        if (!sessionResponse.data) {
+            await command.editReply(`Session not found: \`${sessionId}\`\n\nMake sure the session ID is correct. You can find it with \`opencode session list\` in terminal.`);
+            return;
+        }
+        const sessionTitle = sessionResponse.data.title;
+        const thread = await textChannel.threads.create({
+            name: `Resume: ${sessionTitle}`.slice(0, 100),
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `Resuming session ${sessionId}`,
+        });
+        await thread.members.add(command.user.id);
+        getDatabase()
+            .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+            .run(thread.id, sessionId);
+        logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`);
+        const terminalCmd = `opencode -s ${sessionId} ${projectDirectory}`;
+        const sessionInfoContent = `📋 **Session Info**\n**ID:** \`${sessionId}\`\n**Terminal:**\n\`\`\`\n${terminalCmd}\n\`\`\``;
+        const infoMessage = await sendThreadMessage(thread, sessionInfoContent);
+        await infoMessage.pin().catch(() => { });
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data) {
+            throw new Error('Failed to fetch session messages');
+        }
+        const messages = messagesResponse.data;
+        await command.editReply(`Resumed session "${sessionTitle}" in ${thread.toString()}`);
+        await sendThreadMessage(thread, `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
+        const { partIds, content, skippedCount } = collectLastAssistantParts({
+            messages,
+        });
+        if (skippedCount > 0) {
+            await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+        }
+        if (content.trim()) {
+            const discordMessage = await sendThreadMessage(thread, content);
+            const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+            const transaction = getDatabase().transaction((ids) => {
+                for (const partId of ids) {
+                    stmt.run(partId, discordMessage.id, thread.id);
+                }
+            });
+            transaction(partIds);
+        }
+        const messageCount = messages.length;
+        await sendThreadMessage(thread, `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`);
+    }
+    catch (error) {
+        logger.error('[RESUME] Error:', error);
+        await command.editReply(`Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+function getDateGroup(timestamp) {
+    const now = new Date();
+    const date = new Date(timestamp);
+    const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const yesterdayStart = new Date(todayStart.getTime() - 24 * 60 * 60 * 1000);
+    const weekStart = new Date(todayStart.getTime() - 7 * 24 * 60 * 60 * 1000);
+    if (date >= todayStart) {
+        return 'today';
+    }
+    if (date >= yesterdayStart) {
+        return 'yesterday';
+    }
+    if (date >= weekStart) {
+        return 'thisWeek';
+    }
+    return 'older';
+}
+function formatRelativeTime(timestamp) {
+    const now = Date.now();
+    const diff = now - timestamp;
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(diff / 3600000);
+    if (minutes < 1) {
+        return 'just now';
+    }
+    if (minutes < 60) {
+        return `${minutes}m ago`;
+    }
+    if (hours < 24) {
+        return `${hours}h ago`;
+    }
+    const date = new Date(timestamp);
+    return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+const GROUP_LABELS = {
+    today: '📅 Today',
+    yesterday: '📆 Yesterday',
+    thisWeek: '🗓️ This Week',
+    older: '📁 Older',
+};
+export async function handleResumeAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    let projectDirectory;
+    if (interaction.channel) {
+        const textChannel = await resolveTextChannel(interaction.channel);
+        if (textChannel) {
+            const channelConfig = getChannelDirectory(textChannel.id);
+            if (channelConfig?.appId && channelConfig.appId !== appId) {
+                await interaction.respond([]);
+                return;
+            }
+            projectDirectory = channelConfig?.directory;
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const cached = sessionCache.get(projectDirectory);
+        let sessions;
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+            sessions = cached.sessions;
+        }
+        else {
+            const timeoutPromise = new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve(cached?.sessions || []);
+                }, 2000);
+            });
+            sessions = await Promise.race([
+                refreshSessionCache(projectDirectory),
+                timeoutPromise,
+            ]);
+        }
+        const filtered = sessions
+            .filter((session) => {
+            return session.title.toLowerCase().includes(focusedValue.toLowerCase());
+        })
+            .sort((a, b) => {
+            return b.updated - a.updated;
+        });
+        const grouped = new Map();
+        for (const session of filtered) {
+            const group = getDateGroup(session.updated);
+            if (!grouped.has(group)) {
+                grouped.set(group, []);
+            }
+            grouped.get(group).push(session);
+        }
+        const choices = [
+            {
+                name: '🔄 Refresh list (type session ID if not shown)',
+                value: '__refresh__',
+            },
+        ];
+        const groupOrder = ['today', 'yesterday', 'thisWeek', 'older'];
+        let totalItems = 1;
+        for (const group of groupOrder) {
+            const groupSessions = grouped.get(group);
+            if (!groupSessions || groupSessions.length === 0) {
+                continue;
+            }
+            if (totalItems >= 25) {
+                break;
+            }
+            choices.push({
+                name: `── ${GROUP_LABELS[group]} ──`,
+                value: `__header_${group}__`,
+            });
+            totalItems++;
+            for (const session of groupSessions) {
+                if (totalItems >= 25) {
+                    break;
+                }
+                const timeStr = formatRelativeTime(session.updated);
+                const prefix = '   ';
+                const suffix = ` (${timeStr})`;
+                const maxTitleLength = 100 - prefix.length - suffix.length;
+                let title = session.title;
+                if (title.length > maxTitleLength) {
+                    title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…';
+                }
+                choices.push({
+                    name: `${prefix}${title}${suffix}`,
+                    value: session.id,
+                });
+                totalItems++;
+            }
+        }
+        await interaction.respond(choices);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching sessions:', error);
+        await interaction.respond([]).catch(() => { });
+    }
+}

package/dist/commands/run-config.js

@@ -0,0 +1,79 @@
+// /run-config command - Configure notification settings for /run command.
+import { ChannelType } from 'discord.js';
+import { getRunConfig, setRunConfig } from '../database.js';
+import { resolveTextChannel, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+export async function handleRunConfigCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const subcommand = command.options.getSubcommand();
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let channelId = channel.id;
+    if (isThread) {
+        const textChannel = await resolveTextChannel(channel);
+        if (textChannel) {
+            channelId = textChannel.id;
+        }
+    }
+    const currentConfig = getRunConfig(channelId);
+    if (subcommand === 'show') {
+        const discordStatus = currentConfig.notify_discord ? '✅' : '❌';
+        const systemStatus = currentConfig.notify_system ? '✅' : '❌';
+        const webhookStatus = currentConfig.webhook_url
+            ? `\`${currentConfig.webhook_url.slice(0, 30)}...\``
+            : '(not set)';
+        await command.reply({
+            content: [
+                '**Run Notification Settings**',
+                '',
+                `${discordStatus} Discord notifications`,
+                `${systemStatus} System notifications`,
+                `🔗 Webhook: ${webhookStatus}`,
+            ].join('\n'),
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (subcommand === 'discord') {
+        const enabled = command.options.getBoolean('enabled', true);
+        setRunConfig(channelId, { notify_discord: enabled ? 1 : 0 });
+        await command.reply({
+            content: `${enabled ? '✅' : '❌'} Discord notifications ${enabled ? 'enabled' : 'disabled'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (subcommand === 'system') {
+        const enabled = command.options.getBoolean('enabled', true);
+        setRunConfig(channelId, { notify_system: enabled ? 1 : 0 });
+        await command.reply({
+            content: `${enabled ? '✅' : '❌'} System notifications ${enabled ? 'enabled' : 'disabled'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (subcommand === 'webhook') {
+        const url = command.options.getString('url');
+        setRunConfig(channelId, { webhook_url: url || null });
+        await command.reply({
+            content: url
+                ? `🔗 Webhook URL set to \`${url.slice(0, 30)}...\``
+                : '🔗 Webhook URL cleared',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+}