@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/commands/session-id.js

@@ -0,0 +1,78 @@
+// /session-id command - Show current session ID and an opencode attach command.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getOpencodeServerPort, initializeOpencodeForDirectory, } from '../opencode.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.SESSION);
+function shellQuote(value) {
+    if (!value) {
+        return "''";
+    }
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+export async function handleSessionIdCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | 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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory, workingDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    let port = getOpencodeServerPort(projectDirectory);
+    if (!port) {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            await command.editReply({
+                content: `Session ID: \`${sessionId}\`\nFailed to resolve OpenCode server port: ${getClient.message}`,
+            });
+            return;
+        }
+        port = getOpencodeServerPort(projectDirectory);
+    }
+    if (!port) {
+        await command.editReply({
+            content: `Session ID: \`${sessionId}\`\nCould not determine OpenCode server port`,
+        });
+        return;
+    }
+    const attachUrl = `http://127.0.0.1:${port}`;
+    const attachCommand = `opencode attach ${attachUrl} --session ${sessionId} --dir ${shellQuote(workingDirectory)}`;
+    await command.editReply({
+        content: `**Session ID:** \`${sessionId}\`\n**Attach command:**\n\`\`\`bash\n${attachCommand}\n\`\`\``,
+    });
+    logger.log(`Session ID shown for thread ${channel.id}: ${sessionId}`);
+}

package/dist/commands/session.js

@@ -0,0 +1,176 @@
+// /new-session command - Start a new OpenCode session.
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getChannelDirectory } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.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();
+    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 = await getChannelDirectory(textChannel.id);
+    const projectDirectory = channelConfig?.directory;
+    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()}`);
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory,
+            sdkDirectory: projectDirectory,
+            channelId: textChannel.id,
+            appId,
+        });
+        await runtime.enqueueIncoming({
+            prompt: fullPrompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            agent,
+            appId,
+            mode: 'opencode',
+        });
+    }
+    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, }) {
+    const focusedValue = interaction.options.getFocused();
+    // interaction.channel can be null when the channel isn't cached
+    // (common with gateway-proxy). Use channelId which is always available
+    // from the raw interaction payload.
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
+    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({
+            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, }) {
+    const focusedOption = interaction.options.getFocused(true);
+    if (focusedOption.name === 'agent') {
+        await handleAgentAutocomplete({ interaction });
+        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();
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
+    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: 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([]);
+    }
+}

package/dist/commands/share.js

@@ -0,0 +1,80 @@
+// /share command - Share the current session as a public URL.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { getThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.SHARE);
+export async function handleShareCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | 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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const { projectDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.reply({
+            content: `Failed to share session: ${getClient.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const response = await getClient().session.share({
+            sessionID: sessionId,
+        });
+        if (!response.data?.share?.url) {
+            await command.reply({
+                content: 'Failed to generate share URL',
+                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `🔗 **Session shared:** ${response.data.share.url}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Session ${sessionId} shared: ${response.data.share.url}`);
+    }
+    catch (error) {
+        logger.error('[SHARE] Error:', error);
+        await command.reply({
+            content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/tasks.js

@@ -0,0 +1,205 @@
+// /tasks command — list all scheduled tasks sorted by next run time.
+// Renders a markdown table that the CV2 pipeline auto-formats for Discord,
+// including HTML-backed action buttons for cancellable tasks.
+import { ButtonInteraction, ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
+import { cancelScheduledTask, listScheduledTasks, } from '../database.js';
+import { splitTablesFromMarkdown } from '../format-tables.js';
+import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
+import { formatTimeAgo } from './worktrees.js';
+function formatTimeUntil(date) {
+    const diffMs = date.getTime() - Date.now();
+    if (diffMs <= 0) {
+        return 'due now';
+    }
+    const totalSeconds = Math.floor(diffMs / 1000);
+    if (totalSeconds < 60) {
+        return `in ${totalSeconds}s`;
+    }
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    if (totalMinutes < 60) {
+        return `in ${totalMinutes}m`;
+    }
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours < 24) {
+        return minutes > 0 ? `in ${hours}h ${minutes}m` : `in ${hours}h`;
+    }
+    const days = Math.floor(hours / 24);
+    const remainingHours = hours % 24;
+    return remainingHours > 0 ? `in ${days}d ${remainingHours}h` : `in ${days}d`;
+}
+function scheduleLabel(task) {
+    if (task.schedule_kind === 'cron') {
+        return task.cron_expr || 'cron';
+    }
+    return 'one-time';
+}
+function canCancelTask(task) {
+    return task.status === 'planned' || task.status === 'running';
+}
+// Escape pipe chars and collapse whitespace so free-text fields don't break
+// GFM table column alignment.
+function sanitizeTableCell(value) {
+    return value.replaceAll('|', '\\|').replace(/\s+/g, ' ').trim();
+}
+function buildCancelButtonHtml({ buttonId }) {
+    return `<button id="${buttonId}" variant="secondary">Delete</button>`;
+}
+function buildActionCell(task) {
+    if (!canCancelTask(task)) {
+        return '-';
+    }
+    return buildCancelButtonHtml({ buttonId: `cancel-task-${task.id}` });
+}
+// Cap rows to avoid exceeding Discord's 40-component CV2 limit.
+// Each cancellable row renders as text + action row + button (~4 components),
+// so 10 rows is a safe ceiling.
+const MAX_TASK_ROWS = 10;
+function buildTaskTable({ tasks, }) {
+    const header = '| ID | Status | Prompt | Schedule | Next Run | Action |';
+    const separator = '|---|---|---|---|---|---|';
+    const rows = tasks.map((task) => {
+        const id = String(task.id);
+        const status = task.status;
+        const prompt = sanitizeTableCell(task.prompt_preview.length > 240
+            ? task.prompt_preview.slice(0, 237) + '...'
+            : task.prompt_preview);
+        const schedule = sanitizeTableCell(scheduleLabel(task));
+        const nextRun = (() => {
+            if (task.status === 'completed' ||
+                task.status === 'cancelled' ||
+                task.status === 'failed') {
+                return task.last_run_at ? formatTimeAgo(task.last_run_at) : '-';
+            }
+            return formatTimeUntil(task.next_run_at);
+        })();
+        const action = buildActionCell(task);
+        return `| ${id} | ${status} | ${prompt} | ${schedule} | ${nextRun} | ${action} |`;
+    });
+    return [header, separator, ...rows].join('\n');
+}
+function getTasksActionOwnerKey({ userId, channelId, }) {
+    return `tasks:${userId}:${channelId}`;
+}
+async function renderTasksReply({ guildId, userId, channelId, showAll, notice, editReply, }) {
+    const ownerKey = getTasksActionOwnerKey({ userId, channelId });
+    cancelHtmlActionsForOwner(ownerKey);
+    const statuses = showAll
+        ? undefined
+        : ['planned', 'running'];
+    const allTasks = await listScheduledTasks({ statuses });
+    if (allTasks.length === 0) {
+        const message = notice
+            ? `${notice}\n\nNo scheduled tasks found.`
+            : 'No scheduled tasks found.';
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: message,
+        };
+        await editReply({
+            components: [textDisplay],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const tasks = allTasks.slice(0, MAX_TASK_ROWS);
+    const truncatedNotice = allTasks.length > MAX_TASK_ROWS
+        ? `Showing ${MAX_TASK_ROWS}/${allTasks.length} tasks. Use \`otto task list\` for full list.`
+        : undefined;
+    const combinedNotice = [notice, truncatedNotice].filter(Boolean).join('\n');
+    const cancellableTasksByButtonId = new Map();
+    tasks.forEach((task) => {
+        if (!canCancelTask(task)) {
+            return;
+        }
+        cancellableTasksByButtonId.set(`cancel-task-${task.id}`, task);
+    });
+    const tableMarkdown = buildTaskTable({ tasks });
+    const markdown = combinedNotice
+        ? `${combinedNotice}\n\n${tableMarkdown}`
+        : tableMarkdown;
+    const segments = splitTablesFromMarkdown(markdown, {
+        resolveButtonCustomId: ({ button }) => {
+            const task = cancellableTasksByButtonId.get(button.id);
+            if (!task) {
+                return new Error(`No task registered for button ${button.id}`);
+            }
+            const actionId = registerHtmlAction({
+                ownerKey,
+                threadId: String(task.id),
+                run: async ({ interaction }) => {
+                    await handleCancelTaskAction({
+                        interaction,
+                        taskId: task.id,
+                        showAll,
+                    });
+                },
+            });
+            return buildHtmlActionCustomId(actionId);
+        },
+    });
+    const components = segments.flatMap((segment) => {
+        if (segment.type === 'components') {
+            return segment.components;
+        }
+        const textDisplay = {
+            type: ComponentType.TextDisplay,
+            content: segment.text,
+        };
+        return [textDisplay];
+    });
+    await editReply({
+        components,
+        flags: MessageFlags.IsComponentsV2,
+    });
+}
+async function handleCancelTaskAction({ interaction, taskId, showAll, }) {
+    const guildId = interaction.guildId;
+    if (!guildId) {
+        await interaction.editReply({
+            components: [
+                {
+                    type: ComponentType.TextDisplay,
+                    content: 'This action can only be used in a server.',
+                },
+            ],
+            flags: MessageFlags.IsComponentsV2,
+        });
+        return;
+    }
+    const cancelled = await cancelScheduledTask(taskId);
+    const notice = cancelled
+        ? `Cancelled task #${taskId}.`
+        : `Task #${taskId} not found or already finalized.`;
+    await renderTasksReply({
+        guildId,
+        userId: interaction.user.id,
+        channelId: interaction.channelId,
+        showAll,
+        notice,
+        editReply: (options) => {
+            return interaction.editReply(options);
+        },
+    });
+}
+export async function handleTasksCommand({ command, }) {
+    const guildId = command.guildId;
+    if (!guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const showAll = command.options.getBoolean('all') ?? false;
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    await renderTasksReply({
+        guildId,
+        userId: command.user.id,
+        channelId: command.channelId,
+        showAll,
+        editReply: (options) => {
+            return command.editReply(options);
+        },
+    });
+}

package/dist/commands/thread-deletion-sync.js

@@ -0,0 +1,50 @@
+import { ChatInputCommandInteraction, MessageFlags, } from 'discord.js';
+import { getThreadDeletionSyncMode, resetThreadDeletionSyncMode, setThreadDeletionSyncMode, } from '../database.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const threadDeletionSyncLogger = createLogger(LogPrefix.CLI);
+export const THREAD_DELETION_SYNC_CHOICES = [
+    { name: 'soft', value: 'soft' },
+    { name: 'hard', value: 'hard' },
+    { name: 'reset', value: 'reset' },
+];
+function getModeLabel(mode) {
+    if (mode === 'hard') {
+        return 'hard';
+    }
+    return 'soft';
+}
+export async function handleThreadDeletionSyncCommand({ command, appId, }) {
+    const selectedMode = command.options.getString('mode');
+    if (!selectedMode) {
+        const currentMode = await getThreadDeletionSyncMode({ appId });
+        await command.reply({
+            content: `Thread deletion sync mode is **${getModeLabel(currentMode)}**.`,
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    if (selectedMode === 'reset') {
+        await resetThreadDeletionSyncMode({ appId });
+        threadDeletionSyncLogger.log(`[THREAD_DELETION_SYNC] Reset mode to default for app ${appId}`);
+        await command.reply({
+            content: 'Thread deletion sync mode reset to **soft** (default).\nSoft keeps the OpenCode session and only archives/aborts it.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    if (selectedMode !== 'soft' && selectedMode !== 'hard') {
+        await command.reply({
+            content: `Invalid mode: ${selectedMode}`,
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await setThreadDeletionSyncMode({ appId, mode: selectedMode });
+    threadDeletionSyncLogger.log(`[THREAD_DELETION_SYNC] Set mode ${selectedMode} for app ${appId}`);
+    await command.reply({
+        content: selectedMode === 'hard'
+            ? 'Thread deletion sync mode set to **hard**.\nDeleting a Discord thread will delete the mapped OpenCode session.'
+            : 'Thread deletion sync mode set to **soft**.\nDeleting a Discord thread will archive/abort the mapped OpenCode session.',
+        flags: MessageFlags.Ephemeral,
+    });
+}

package/dist/commands/types.js

@@ -0,0 +1,2 @@
+// Shared types for command handlers.
+export {};