@otto-assistant/otto 0.1.1 → 0.7.15

package/dist/commands/verbosity.js

@@ -0,0 +1,125 @@
+// /verbosity command.
+// Shows a dropdown to set output verbosity level for sessions in a channel.
+// 'text_and_essential_tools' (default): shows text and essential tools (edits, custom MCP tools)
+// 'tools_and_text': shows all output including tool executions
+// 'text_only': only shows text responses
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, MessageFlags, ChannelType, } from 'discord.js';
+import { getChannelVerbosity, setChannelVerbosity, } from '../database.js';
+import { getPrisma } from '../db.js';
+import { store } from '../store.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const verbosityLogger = createLogger(LogPrefix.VERBOSITY);
+const VERBOSITY_OPTIONS = [
+    {
+        value: 'tools_and_text',
+        label: 'Tools and text',
+        description: 'All output including tool executions and status messages',
+    },
+    {
+        value: 'text_and_essential_tools',
+        label: 'Text and essential tools',
+        description: 'Text + essential tools (edits, custom MCP). Hides read/search.',
+    },
+    {
+        value: 'text_only',
+        label: 'Text only',
+        description: 'Only text responses. Hides all tools and status messages.',
+    },
+];
+function resolveChannelId(channel) {
+    if (!channel) {
+        return null;
+    }
+    if (channel.type === ChannelType.GuildText) {
+        return channel.id;
+    }
+    if (channel.type === ChannelType.PublicThread ||
+        channel.type === ChannelType.PrivateThread ||
+        channel.type === ChannelType.AnnouncementThread) {
+        return channel.parentId || channel.id;
+    }
+    return channel.id;
+}
+/**
+ * Check if there is a per-channel verbosity override in the DB.
+ * Returns the override value if it exists, null otherwise.
+ */
+async function getChannelVerbosityOverride(channelId) {
+    const prisma = await getPrisma();
+    const row = await prisma.channel_verbosity.findUnique({
+        where: { channel_id: channelId },
+    });
+    if (row?.verbosity) {
+        return row.verbosity;
+    }
+    return null;
+}
+/**
+ * Handle the /verbosity slash command.
+ * Shows a dropdown with the current verbosity level and available options.
+ */
+export async function handleVerbosityCommand({ command, }) {
+    verbosityLogger.log('[VERBOSITY] Command called');
+    const channelId = resolveChannelId(command.channel);
+    if (!channelId) {
+        await command.reply({
+            content: 'Could not determine channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const override = await getChannelVerbosityOverride(channelId);
+    const currentLevel = override || store.getState().defaultVerbosity;
+    const source = override ? 'channel override' : 'global default';
+    const options = VERBOSITY_OPTIONS.map((opt) => ({
+        label: opt.label,
+        value: opt.value,
+        description: opt.description,
+        default: opt.value === currentLevel,
+    }));
+    const selectMenu = new StringSelectMenuBuilder()
+        .setCustomId(`verbosity_select:${channelId}`)
+        .setPlaceholder('Select verbosity level')
+        .addOptions(options);
+    const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+    await command.reply({
+        content: `**Verbosity**\nCurrent: \`${currentLevel}\` (${source})`,
+        components: [actionRow],
+        flags: MessageFlags.Ephemeral,
+    });
+}
+/**
+ * Handle the verbosity select menu interaction.
+ * Sets the selected verbosity level for the channel.
+ */
+export async function handleVerbositySelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('verbosity_select:')) {
+        return;
+    }
+    await interaction.deferUpdate();
+    const channelId = customId.replace('verbosity_select:', '');
+    const level = interaction.values[0];
+    if (!level) {
+        await interaction.editReply({
+            content: 'No level selected.',
+            components: [],
+        });
+        return;
+    }
+    const currentLevel = await getChannelVerbosity(channelId);
+    if (currentLevel === level) {
+        await interaction.editReply({
+            content: `Verbosity is already \`${level}\` for this channel.`,
+            components: [],
+        });
+        return;
+    }
+    await setChannelVerbosity(channelId, level);
+    verbosityLogger.log(`[VERBOSITY] Set channel ${channelId} to ${level}`);
+    const description = VERBOSITY_OPTIONS.find((o) => o.value === level)?.description || '';
+    await interaction.editReply({
+        content: `Verbosity set to \`${level}\` for this channel.\n${description}\nApplies immediately, including active sessions.`,
+        components: [],
+    });
+}

package/dist/commands/vscode.js

@@ -0,0 +1,269 @@
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { TunnelClient } from 'traforo/client';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('VSCODE');
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS;
+const MAX_SESSION_MINUTES = 30;
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000;
+const TUNNEL_BASE_DOMAIN = 'otto.dev';
+const TUNNEL_ID_BYTES = 16;
+const READY_TIMEOUT_MS = 60_000;
+const LOCAL_HOST = '127.0.0.1';
+const activeSessions = new Map();
+export function createVscodeTunnelId() {
+    return crypto.randomBytes(TUNNEL_ID_BYTES).toString('hex');
+}
+export function buildCoderaftArgs({ port, workingDirectory, }) {
+    return [
+        'coderaft',
+        '--port',
+        String(port),
+        '--host',
+        LOCAL_HOST,
+        '--without-connection-token',
+        '--disable-workspace-trust',
+        '--default-folder',
+        workingDirectory,
+    ];
+}
+function createPortWaiter({ port, process: proc, timeoutMs, }) {
+    return new Promise((resolve, reject) => {
+        const maxAttempts = Math.ceil(timeoutMs / 100);
+        let attempts = 0;
+        const check = () => {
+            if (proc.exitCode !== null) {
+                reject(new Error(`coderaft exited with code ${proc.exitCode} before becoming ready`));
+                return;
+            }
+            const socket = net.createConnection(port, LOCAL_HOST);
+            socket.on('connect', () => {
+                socket.destroy();
+                resolve();
+            });
+            socket.on('error', () => {
+                socket.destroy();
+                attempts += 1;
+                if (attempts >= maxAttempts) {
+                    reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`));
+                    return;
+                }
+                setTimeout(check, 100);
+            });
+        };
+        check();
+    });
+}
+function getAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.on('error', reject);
+        server.listen(0, LOCAL_HOST, () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                server.close(() => {
+                    reject(new Error('Failed to resolve an available port'));
+                });
+                return;
+            }
+            const port = address.port;
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(port);
+            });
+        });
+    });
+}
+function cleanupSession(session) {
+    clearTimeout(session.timeoutTimer);
+    try {
+        session.tunnelClient.close();
+    }
+    catch { }
+    if (session.coderaftProcess.exitCode === null) {
+        try {
+            session.coderaftProcess.kill('SIGTERM');
+        }
+        catch { }
+    }
+}
+export function getActiveVscodeSession({ sessionKey }) {
+    return activeSessions.get(sessionKey);
+}
+export function stopVscode({ sessionKey }) {
+    const session = activeSessions.get(sessionKey);
+    if (!session) {
+        return false;
+    }
+    activeSessions.delete(sessionKey);
+    cleanupSession(session);
+    logger.log(`VS Code stopped (key: ${sessionKey})`);
+    return true;
+}
+export async function startVscode({ sessionKey, startedBy, workingDirectory, }) {
+    const existing = activeSessions.get(sessionKey);
+    if (existing) {
+        return existing;
+    }
+    const port = await getAvailablePort();
+    const tunnelId = createVscodeTunnelId();
+    const args = buildCoderaftArgs({
+        port,
+        workingDirectory,
+    });
+    const coderaftProcess = spawn('bunx', args, {
+        cwd: workingDirectory,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            PORT: String(port),
+        },
+    });
+    coderaftProcess.stdout?.on('data', (data) => {
+        logger.log(data.toString().trim());
+    });
+    coderaftProcess.stderr?.on('data', (data) => {
+        logger.error(data.toString().trim());
+    });
+    try {
+        await createPortWaiter({
+            port,
+            process: coderaftProcess,
+            timeoutMs: READY_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        if (coderaftProcess.exitCode === null) {
+            coderaftProcess.kill('SIGTERM');
+        }
+        throw error;
+    }
+    const tunnelClient = new TunnelClient({
+        localPort: port,
+        localHost: LOCAL_HOST,
+        tunnelId,
+        baseDomain: TUNNEL_BASE_DOMAIN,
+    });
+    try {
+        await Promise.race([
+            tunnelClient.connect(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Tunnel connection timed out after 15s'));
+                }, 15_000);
+            }),
+        ]);
+    }
+    catch (error) {
+        tunnelClient.close();
+        if (coderaftProcess.exitCode === null) {
+            coderaftProcess.kill('SIGTERM');
+        }
+        throw error;
+    }
+    const url = tunnelClient.url;
+    const timeoutTimer = setTimeout(() => {
+        logger.log(`VS Code auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`);
+        stopVscode({ sessionKey });
+    }, MAX_SESSION_MS);
+    timeoutTimer.unref();
+    const session = {
+        coderaftProcess,
+        tunnelClient,
+        url,
+        workingDirectory,
+        startedBy,
+        startedAt: Date.now(),
+        timeoutTimer,
+    };
+    coderaftProcess.once('exit', (code, signal) => {
+        const current = activeSessions.get(sessionKey);
+        if (current !== session) {
+            return;
+        }
+        logger.log(`VS Code process exited (key: ${sessionKey}, code: ${code}, signal: ${signal ?? 'none'})`);
+        stopVscode({ sessionKey });
+    });
+    activeSessions.set(sessionKey, session);
+    logger.log(`VS Code started by ${startedBy}: ${url}`);
+    return session;
+}
+export async function handleVscodeCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in a text channel or thread.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SECURE_REPLY_FLAGS });
+    const sessionKey = channel.id;
+    const existing = getActiveVscodeSession({ sessionKey });
+    if (existing) {
+        await command.editReply({
+            content: `VS Code is already running for this thread. ` +
+                `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes from startup.\n` +
+                `${existing.url}`,
+        });
+        return;
+    }
+    try {
+        const session = await startVscode({
+            sessionKey,
+            startedBy: command.user.tag,
+            workingDirectory: resolved.workingDirectory,
+        });
+        await command.editReply({
+            content: `VS Code started for \`${session.workingDirectory}\`. ` +
+                `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes, so open it before it expires.\n` +
+                `${session.url}`,
+        });
+    }
+    catch (error) {
+        logger.error('Failed to start VS Code:', error);
+        await command.editReply({
+            content: `Failed to start VS Code: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+export function cleanupAllVscodeSessions() {
+    for (const sessionKey of activeSessions.keys()) {
+        stopVscode({ sessionKey });
+    }
+}
+function onProcessExit() {
+    cleanupAllVscodeSessions();
+}
+process.on('SIGINT', onProcessExit);
+process.on('SIGTERM', onProcessExit);
+process.on('exit', onProcessExit);

package/dist/commands/worktree-settings.js

@@ -0,0 +1,43 @@
+// /toggle-worktrees command.
+// Allows per-channel opt-in for automatic worktree creation,
+// as an alternative to the global --use-worktrees CLI flag.
+import { ChatInputCommandInteraction, MessageFlags, ChannelType, } from 'discord.js';
+import { getChannelWorktreesEnabled, setChannelWorktreesEnabled, } from '../database.js';
+import { getOttoMetadata } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const worktreeSettingsLogger = createLogger(LogPrefix.WORKTREE);
+/**
+ * Handle the /toggle-worktrees slash command.
+ * Toggles automatic worktree creation for new sessions in this channel.
+ */
+export async function handleToggleWorktreesCommand({ command, }) {
+    worktreeSettingsLogger.log('[TOGGLE_WORKTREES] Command called');
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.reply({
+            content: 'This command can only be used in text channels (not threads).',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const textChannel = channel;
+    const metadata = await getOttoMetadata(textChannel);
+    if (!metadata.projectDirectory) {
+        await command.reply({
+            content: 'This channel is not configured with a project directory.\nUse `/add-project` to set up this channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const wasEnabled = await getChannelWorktreesEnabled(textChannel.id);
+    const nextEnabled = !wasEnabled;
+    await setChannelWorktreesEnabled(textChannel.id, nextEnabled);
+    const nextLabel = nextEnabled ? 'enabled' : 'disabled';
+    worktreeSettingsLogger.log(`[TOGGLE_WORKTREES] ${nextLabel.toUpperCase()} for channel ${textChannel.id}`);
+    await command.reply({
+        content: nextEnabled
+            ? `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will now automatically create git worktrees.\n\nNew setting for **#${textChannel.name}**: **enabled**.`
+            : `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${textChannel.name}** will use the main project directory.\n\nNew setting for **#${textChannel.name}**: **disabled**.`,
+        flags: MessageFlags.Ephemeral,
+    });
+}