@otto-assistant/otto 0.1.2 → 0.7.15

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

@@ -0,0 +1,127 @@
+// /restart-opencode-server command - Restart the single shared opencode server
+// and re-register Discord slash commands.
+// Used for resolving opencode state issues, internal bugs, refreshing auth state,
+// plugins, and picking up new/changed slash commands or agents. Aborts in-progress
+// sessions in this channel before restarting. Note: since there is one shared server,
+// this restart affects all projects. Other runtimes reconnect through their listener
+// backoff loop once the shared server comes back.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { initializeOpencodeForDirectory, restartOpencodeServer } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { disposeRuntimesForDirectory } from '../session-handler/thread-session-runtime.js';
+import { registerCommands } from '../discord-command-registration.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',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_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 text channels or threads',
+            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;
+    // Defer reply since restart may take a moment
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    // Dispose all runtimes for this directory/channel scope.
+    // disposeRuntimesForDirectory aborts active runs, kills listeners, and
+    // removes runtimes from the registry. Scoped by channelId so runtimes
+    // in other channels sharing the same project directory are not affected.
+    const parentChannelId = isThread
+        ? channel.parentId
+        : channel.id;
+    const abortedCount = disposeRuntimesForDirectory({
+        directory: projectDirectory,
+        channelId: parentChannelId || undefined,
+    });
+    logger.log(`[RESTART] Restarting shared opencode server`);
+    const result = await restartOpencodeServer();
+    if (result instanceof Error) {
+        logger.error('[RESTART] Failed:', result);
+        await command.editReply({
+            content: `Failed to restart opencode server: ${result.message}`,
+        });
+        return;
+    }
+    const abortMsg = abortedCount > 0
+        ? ` (aborted ${abortedCount} active session${abortedCount > 1 ? 's' : ''})`
+        : '';
+    await command.editReply({
+        content: `Opencode server **restarted** successfully${abortMsg}. Re-registering slash commands...`,
+    });
+    logger.log('[RESTART] Shared opencode server restarted');
+    // Re-register Discord slash commands after restart so new/changed
+    // commands, agents, and plugins are picked up immediately.
+    const token = command.client.token;
+    if (!token) {
+        logger.error('[RESTART] No bot token available, skipping command registration');
+        await command.editReply({
+            content: `Opencode server **restarted**${abortMsg}, but slash command re-registration skipped (no bot token)`,
+        });
+        return;
+    }
+    const guildIds = [...command.client.guilds.cache.keys()];
+    const opencodeResult = await initializeOpencodeForDirectory(projectDirectory);
+    const [userCommands, agents] = await (async () => {
+        if (opencodeResult instanceof Error) {
+            logger.warn('[RESTART] OpenCode init failed, registering without user commands:', opencodeResult.message);
+            return [[], []];
+        }
+        const getClient = opencodeResult;
+        const [cmds, ags] = await Promise.all([
+            getClient()
+                .command.list({ directory: projectDirectory })
+                .then((r) => r.data || [])
+                .catch((e) => {
+                logger.warn('[RESTART] Failed to load user commands:', e instanceof Error ? e.stack : String(e));
+                return [];
+            }),
+            getClient()
+                .app.agents({ directory: projectDirectory })
+                .then((r) => r.data || [])
+                .catch((e) => {
+                logger.warn('[RESTART] Failed to load agents:', e instanceof Error ? e.stack : String(e));
+                return [];
+            }),
+        ]);
+        return [cmds, ags];
+    })();
+    const registerResult = await registerCommands({ token, appId, guildIds, userCommands, agents })
+        .then(() => null)
+        .catch((e) => (e instanceof Error ? e : new Error(String(e))));
+    if (registerResult instanceof Error) {
+        logger.error('[RESTART] Failed to re-register commands:', registerResult.message);
+        await command.editReply({
+            content: `Opencode server **restarted**${abortMsg}, but slash command re-registration failed: ${registerResult.message}`,
+        });
+        return;
+    }
+    logger.log('[RESTART] Slash commands re-registered');
+    await command.editReply({
+        content: `Opencode server **restarted** and slash commands **re-registered**${abortMsg}`,
+    });
+}

package/dist/commands/resume.js

@@ -0,0 +1,149 @@
+// /resume command - Resume an existing OpenCode session.
+import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import fs from 'node:fs';
+import { getChannelDirectory, setThreadSession, setPartMessagesBatch, getAllThreadSessionIds, } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { sendThreadMessage, resolveProjectDirectoryFromAutocomplete, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { collectSessionChunks, batchChunksForDiscord } from '../message-formatting.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import * as errore from 'errore';
+const logger = createLogger(LogPrefix.RESUME);
+export async function handleResumeCommand({ command, }) {
+    await command.deferReply();
+    const sessionId = command.options.getString('session', true);
+    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 = 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 sessionResponse = await getClient().session.get({
+            sessionID: sessionId,
+        });
+        if (!sessionResponse.data) {
+            await command.editReply('Session not found');
+            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}`,
+        });
+        // Claim the resumed session immediately so external polling does not race
+        // and create a duplicate Sync thread before the rest of this setup runs.
+        await setThreadSession(thread.id, sessionId);
+        // Add user to thread so it appears in their sidebar
+        await thread.members.add(command.user.id);
+        logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`);
+        const messagesResponse = await getClient().session.messages({
+            sessionID: 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...*`);
+        try {
+            const { chunks, skippedCount } = collectSessionChunks({
+                messages,
+                limit: 30,
+            });
+            if (skippedCount > 0) {
+                await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+            }
+            const batched = batchChunksForDiscord(chunks);
+            for (const batch of batched) {
+                const discordMessage = await sendThreadMessage(thread, batch.content);
+                await setPartMessagesBatch(batch.partIds.map((partId) => ({
+                    partId,
+                    messageId: discordMessage.id,
+                    threadId: thread.id,
+                })));
+            }
+            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 (sendError) {
+            logger.error('[RESUME] Error sending messages to thread:', sendError);
+            await sendThreadMessage(thread, `Failed to load message history, but session is connected. You can still send new messages.`, { flags: NOTIFY_MESSAGE_FLAGS });
+        }
+    }
+    catch (error) {
+        logger.error('[RESUME] Error:', error);
+        await command.editReply(`Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleResumeAutocomplete({ 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 sessionsResponse = await getClient().session.list();
+        if (!sessionsResponse.data) {
+            await interaction.respond([]);
+            return;
+        }
+        const existingSessionIds = new Set(await getAllThreadSessionIds());
+        const sessions = sessionsResponse.data
+            .filter((session) => !existingSessionIds.has(session.id))
+            .filter((session) => session.title.toLowerCase().includes(focusedValue.toLowerCase()))
+            .slice(0, 25)
+            .map((session) => {
+            const dateStr = new Date(session.time.updated).toLocaleString();
+            const suffix = ` (${dateStr})`;
+            const maxTitleLength = 100 - suffix.length;
+            let title = session.title;
+            if (title.length > maxTitleLength) {
+                title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…';
+            }
+            return {
+                name: `${title}${suffix}`,
+                value: session.id,
+            };
+        });
+        await interaction.respond(sessions);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching sessions:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/run-command.js

@@ -0,0 +1,79 @@
+// /run-shell-command command - Run an arbitrary shell command in the project directory.
+// Resolves the project directory from the channel and executes the command with it as cwd.
+// Also used by the ! prefix shortcut in discord messages (e.g. "!ls -la").
+// Messages starting with ! are intercepted before session handling and routed here.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+import { execAsync } from '../worktrees.js';
+import { stripAnsi } from '../utils.js';
+const logger = createLogger(LogPrefix.INTERACTION);
+const MAX_OUTPUT_CHARS = 1900;
+export async function runShellCommand({ command, directory, }) {
+    try {
+        const { stdout, stderr } = await execAsync(command, { cwd: directory });
+        const output = stripAnsi([stdout, stderr].filter(Boolean).join('\n').trim());
+        const header = `\`${command}\` exited with 0`;
+        if (!output) {
+            return header;
+        }
+        return formatOutput(output, header);
+    }
+    catch (error) {
+        const execError = error;
+        const output = stripAnsi([execError.stdout, execError.stderr].filter(Boolean).join('\n').trim());
+        const exitCode = execError.code ?? 1;
+        logger.error(`[RUN-COMMAND] Command "${command}" exited with ${exitCode}:`, error);
+        const header = `\`${command}\` exited with ${exitCode}`;
+        return formatOutput(output || execError.message || 'Unknown error', header);
+    }
+}
+export async function handleRunCommand({ 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);
+    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: 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 input = command.options.getString('command', true);
+    await command.deferReply();
+    const result = await runShellCommand({
+        command: input,
+        directory: resolved.workingDirectory,
+    });
+    await command.editReply({ content: result });
+}
+function formatOutput(output, header) {
+    // Reserve space for header + newline + code block delimiters (```\n...\n```)
+    const overhead = header.length + 1 + 3 + 1 + 1 + 3; // header\n```\n...\n```
+    const maxContent = MAX_OUTPUT_CHARS - overhead;
+    const truncated = output.length > maxContent
+        ? output.slice(0, maxContent - 14) + '\n... truncated'
+        : output;
+    return `${header}\n\`\`\`\n${truncated}\n\`\`\``;
+}

package/dist/commands/screenshare.js

@@ -0,0 +1,303 @@
+// /screenshare command - Start screen sharing via VNC + WebSocket bridge + otto tunnel.
+// On macOS: uses built-in Screen Sharing (port 5900).
+// On Linux: spawns x11vnc against the current $DISPLAY.
+// Exposes the VNC stream via an in-process websockify bridge and a traforo tunnel,
+// then sends the user a noVNC URL they can open in a browser.
+//
+// /screenshare-stop command - Stops the active screen share for this guild.
+import { MessageFlags } from 'discord.js';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { TunnelClient } from 'traforo/client';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { startWebsockify } from '../websockify.js';
+import { createLogger } from '../logger.js';
+import { execAsync } from '../worktrees.js';
+const logger = createLogger('SCREEN');
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS;
+/** One active screenshare per guild (Discord) or per machine (CLI) */
+const activeSessions = new Map();
+const VNC_PORT = 5900;
+const MAX_SESSION_MINUTES = 30;
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000;
+const TUNNEL_BASE_DOMAIN = 'otto.dev';
+const SCREENSHARE_TUNNEL_ID_BYTES = 16;
+// Public noVNC client — we point it at our tunnel URL
+export function buildNoVncUrl({ tunnelHost }) {
+    const params = new URLSearchParams({
+        autoconnect: 'true',
+        host: tunnelHost,
+        port: '443',
+        encrypt: '1',
+        resize: 'scale',
+        view_only: 'false',
+    });
+    return `https://novnc.com/noVNC/vnc.html?${params.toString()}`;
+}
+export function createScreenshareTunnelId() {
+    return crypto.randomBytes(SCREENSHARE_TUNNEL_ID_BYTES).toString('hex');
+}
+// macOS has two separate services:
+// - "Screen Sharing" = view-only VNC (com.apple.screensharing)
+// - "Remote Management" = full control VNC with mouse/keyboard (ARDAgent)
+// We need Remote Management for interactive control, not just Screen Sharing.
+export async function ensureMacRemoteManagement() {
+    // Check if port 5900 is listening via netstat (no sudo needed).
+    // lsof and launchctl list both require sudo for system daemons.
+    try {
+        const { stdout } = await execAsync('netstat -an | grep "\\.5900 " | grep LISTEN', { timeout: 5000 });
+        if (stdout.trim()) {
+            return;
+        }
+    }
+    catch {
+        // not listening
+    }
+    throw new Error('macOS Remote Management is not enabled.\n' +
+        'Enable it: **System Settings > General > Sharing > Remote Management**\n' +
+        'Make sure "VNC viewers may control screen with password" is enabled.\n' +
+        'Or via terminal:\n' +
+        '```\nsudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart \\\n' +
+        '  -activate -configure -allowAccessFor -allUsers -privs -all \\\n' +
+        '  -clientopts -setvnclegacy -vnclegacy yes \\\n' +
+        '  -restart -agent -console\n```');
+}
+export function spawnX11Vnc() {
+    const display = process.env['DISPLAY'] || ':0';
+    const child = spawn('x11vnc', [
+        '-display', display,
+        '-nopw',
+        '-localhost',
+        '-rfbport', String(VNC_PORT),
+        '-shared',
+        '-forever',
+    ], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    child.stdout?.on('data', (data) => {
+        logger.log(`x11vnc: ${data.toString().trim()}`);
+    });
+    child.stderr?.on('data', (data) => {
+        logger.error(`x11vnc: ${data.toString().trim()}`);
+    });
+    return child;
+}
+function waitForPort({ 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(`x11vnc exited with code ${proc.exitCode} before becoming ready`));
+                return;
+            }
+            const sock = net.createConnection(port, 'localhost');
+            sock.on('connect', () => {
+                sock.destroy();
+                resolve();
+            });
+            sock.on('error', () => {
+                sock.destroy();
+                if (++attempts >= maxAttempts) {
+                    reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`));
+                }
+                else {
+                    setTimeout(check, 100);
+                }
+            });
+        };
+        check();
+    });
+}
+export function cleanupSession(session) {
+    clearTimeout(session.timeoutTimer);
+    try {
+        session.tunnelClient.close();
+    }
+    catch { }
+    try {
+        session.wss.close();
+    }
+    catch { }
+    if (session.vncProcess) {
+        try {
+            session.vncProcess.kill();
+        }
+        catch { }
+    }
+}
+/**
+ * Core screenshare start logic, reused by both Discord command and CLI.
+ * Returns the session or throws on failure.
+ */
+export async function startScreenshare({ sessionKey, startedBy, }) {
+    const existing = activeSessions.get(sessionKey);
+    if (existing) {
+        throw new Error(`Screen sharing is already active: ${existing.noVncUrl}`);
+    }
+    const platform = process.platform;
+    let vncProcess;
+    // Step 1: ensure VNC server is running
+    if (platform === 'darwin') {
+        await ensureMacRemoteManagement();
+    }
+    else if (platform === 'linux') {
+        if (!process.env['DISPLAY']) {
+            throw new Error('No $DISPLAY found. Screen sharing requires a running X11 display.');
+        }
+        try {
+            await execAsync('which x11vnc', { timeout: 3000 });
+        }
+        catch {
+            throw new Error('x11vnc is not installed. Install it with: sudo apt install x11vnc');
+        }
+        vncProcess = spawnX11Vnc();
+        // Wait for x11vnc to actually be ready (port 5900 accepting connections)
+        // instead of a blind 1s sleep. Polls every 100ms, fails if process exits first.
+        await waitForPort({ port: VNC_PORT, process: vncProcess, timeoutMs: 3000 });
+    }
+    else {
+        throw new Error(`Screen sharing is not supported on ${platform}. Only macOS and Linux are supported.`);
+    }
+    // Step 2: start in-process websockify bridge
+    let wsInstance;
+    try {
+        wsInstance = await startWebsockify({
+            wsPort: 0,
+            tcpHost: 'localhost',
+            tcpPort: VNC_PORT,
+        });
+    }
+    catch (err) {
+        if (vncProcess) {
+            vncProcess.kill();
+        }
+        throw err;
+    }
+    // Step 3: create tunnel
+    const tunnelId = createScreenshareTunnelId();
+    const tunnelClient = new TunnelClient({
+        localPort: wsInstance.port,
+        tunnelId,
+        baseDomain: TUNNEL_BASE_DOMAIN,
+    });
+    try {
+        await Promise.race([
+            tunnelClient.connect(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Tunnel connection timed out after 15s'));
+                }, 15000);
+            }),
+        ]);
+    }
+    catch (err) {
+        tunnelClient.close();
+        wsInstance.close();
+        if (vncProcess) {
+            vncProcess.kill();
+        }
+        throw err;
+    }
+    const tunnelHost = `${tunnelId}-tunnel.${TUNNEL_BASE_DOMAIN}`;
+    const tunnelUrl = `https://${tunnelHost}`;
+    const noVncUrl = buildNoVncUrl({ tunnelHost });
+    // Auto-kill after a short session so a leaked URL does not stay usable all day.
+    const timeoutTimer = setTimeout(() => {
+        logger.log(`Screen share auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`);
+        stopScreenshare({ sessionKey });
+    }, MAX_SESSION_MS);
+    // Don't keep the process alive just for this timer
+    timeoutTimer.unref();
+    const session = {
+        tunnelClient,
+        wss: wsInstance.wss,
+        vncProcess,
+        url: tunnelUrl,
+        noVncUrl,
+        startedBy,
+        startedAt: Date.now(),
+        timeoutTimer,
+    };
+    activeSessions.set(sessionKey, session);
+    logger.log(`Screen share started by ${startedBy}: ${tunnelUrl}`);
+    return session;
+}
+/**
+ * Core screenshare stop logic, reused by both Discord command and CLI.
+ */
+export function stopScreenshare({ sessionKey }) {
+    const session = activeSessions.get(sessionKey);
+    if (!session) {
+        return false;
+    }
+    cleanupSession(session);
+    activeSessions.delete(sessionKey);
+    logger.log(`Screen share stopped (key: ${sessionKey})`);
+    return true;
+}
+export async function handleScreenshareCommand({ command, }) {
+    const guildId = command.guildId;
+    if (!guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SECURE_REPLY_FLAGS });
+    try {
+        const session = await startScreenshare({
+            sessionKey: guildId,
+            startedBy: command.user.tag,
+        });
+        await command.editReply({
+            content: `Screen sharing started. This reply is private and the URL uses a high-entropy tunnel id. ` +
+                `It will auto-stop after ${MAX_SESSION_MINUTES} minutes. Use /screenshare-stop to stop sooner.\n` +
+                `${session.noVncUrl}`,
+        });
+    }
+    catch (err) {
+        logger.error('Failed to start screen share:', err);
+        await command.editReply({
+            content: `Failed to start screen share: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+}
+export async function handleScreenshareStopCommand({ command, }) {
+    const guildId = command.guildId;
+    if (!guildId) {
+        await command.reply({
+            content: 'This command can only be used in a server',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const stopped = stopScreenshare({ sessionKey: guildId });
+    if (!stopped) {
+        await command.reply({
+            content: 'No active screen share to stop',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.reply({
+        content: 'Screen sharing stopped',
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}
+/** Cleanup all sessions on bot shutdown */
+export function cleanupAllScreenshares() {
+    for (const [guildId, session] of activeSessions) {
+        cleanupSession(session);
+        activeSessions.delete(guildId);
+    }
+}
+// Kill all screenshares when the process exits (Ctrl+C, SIGTERM, etc.)
+function onProcessExit() {
+    cleanupAllScreenshares();
+}
+process.on('SIGINT', onProcessExit);
+process.on('SIGTERM', onProcessExit);
+process.on('exit', onProcessExit);

package/dist/commands/screenshare.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { buildNoVncUrl, createScreenshareTunnelId } from './screenshare.js';
+describe('screenshare security defaults', () => {
+    test('generates a 128-bit tunnel id', () => {
+        const ids = new Set(Array.from({ length: 32 }, () => {
+            return createScreenshareTunnelId();
+        }));
+        expect(ids.size).toBe(32);
+        for (const id of ids) {
+            expect(id).toMatch(/^[0-9a-f]{32}$/);
+        }
+    });
+    test('builds a secure noVNC URL', () => {
+        const url = new URL(buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.otto.dev' }));
+        expect(url.origin).toBe('https://novnc.com');
+        expect(url.searchParams.get('host')).toBe('0123456789abcdef-tunnel.otto.dev');
+        expect(url.searchParams.get('port')).toBe('443');
+        expect(url.searchParams.get('encrypt')).toBe('1');
+    });
+});