lazy-gravity 0.0.2 → 0.0.3

package/dist/bot/index.js

@@ -0,0 +1,914 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBot = exports.getResponseDeliveryModeForTest = void 0;
+exports.createSerialTaskQueueForTest = createSerialTaskQueueForTest;
+const i18n_1 = require("../utils/i18n");
+const logger_1 = require("../utils/logger");
+const discord_js_1 = require("discord.js");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const config_1 = require("../utils/config");
+const slashCommandHandler_1 = require("../commands/slashCommandHandler");
+const registerSlashCommands_1 = require("../commands/registerSlashCommands");
+const modeService_1 = require("../services/modeService");
+const modelService_1 = require("../services/modelService");
+const templateRepository_1 = require("../database/templateRepository");
+const workspaceBindingRepository_1 = require("../database/workspaceBindingRepository");
+const chatSessionRepository_1 = require("../database/chatSessionRepository");
+const workspaceService_1 = require("../services/workspaceService");
+const workspaceCommandHandler_1 = require("../commands/workspaceCommandHandler");
+const chatCommandHandler_1 = require("../commands/chatCommandHandler");
+const cleanupCommandHandler_1 = require("../commands/cleanupCommandHandler");
+const channelManager_1 = require("../services/channelManager");
+const titleGeneratorService_1 = require("../services/titleGeneratorService");
+const chatSessionService_1 = require("../services/chatSessionService");
+const responseMonitor_1 = require("../services/responseMonitor");
+const antigravityLauncher_1 = require("../services/antigravityLauncher");
+const promptDispatcher_1 = require("../services/promptDispatcher");
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const streamMessageFormatter_1 = require("../utils/streamMessageFormatter");
+const discordFormatter_1 = require("../utils/discordFormatter");
+const processLogBuffer_1 = require("../utils/processLogBuffer");
+const imageHandler_1 = require("../utils/imageHandler");
+const modeUi_1 = require("../ui/modeUi");
+const modelsUi_1 = require("../ui/modelsUi");
+const templateUi_1 = require("../ui/templateUi");
+const autoAcceptUi_1 = require("../ui/autoAcceptUi");
+const screenshotUi_1 = require("../ui/screenshotUi");
+const interactionCreateHandler_1 = require("../events/interactionCreateHandler");
+const messageCreateHandler_1 = require("../events/messageCreateHandler");
+// =============================================================================
+// Embed color palette (color-coded by phase)
+// =============================================================================
+const PHASE_COLORS = {
+    sending: 0x5865F2, // Blue
+    thinking: 0x9B59B6, // Purple
+    generating: 0xF39C12, // Gold
+    complete: 0x2ECC71, // Green
+    timeout: 0xE74C3C, // Red
+    error: 0xC0392B, // Dark Red
+};
+const PHASE_ICONS = {
+    sending: '📡',
+    thinking: '🧠',
+    generating: '✍️',
+    complete: '✅',
+    timeout: '⏰',
+    error: '❌',
+};
+const MAX_OUTBOUND_GENERATED_IMAGES = 4;
+const RESPONSE_DELIVERY_MODE = (0, config_1.resolveResponseDeliveryMode)();
+const getResponseDeliveryModeForTest = () => RESPONSE_DELIVERY_MODE;
+exports.getResponseDeliveryModeForTest = getResponseDeliveryModeForTest;
+function createSerialTaskQueueForTest(queueName, traceId) {
+    let queue = Promise.resolve();
+    let queueDepth = 0;
+    let taskSeq = 0;
+    return (task, label = 'queue-task') => {
+        taskSeq += 1;
+        const seq = taskSeq;
+        queueDepth += 1;
+        queue = queue.then(async () => {
+            try {
+                await task();
+            }
+            catch (err) {
+                logger_1.logger.error(`[sendQueue:${traceId}:${queueName}] error #${seq} label=${label}:`, err?.message || err);
+            }
+            finally {
+                queueDepth = Math.max(0, queueDepth - 1);
+            }
+        });
+        return queue;
+    };
+}
+/**
+ * Send a Discord message (prompt) to Antigravity, wait for the response, and relay it back to Discord
+ *
+ * Message strategy:
+ *   - Send new messages per phase instead of editing, to preserve history
+ *   - Visualize the flow of planning/analysis/execution confirmation/implementation as logs
+ */
+async function sendPromptToAntigravity(bridge, message, prompt, cdp, modeService, modelService, inboundImages = [], options) {
+    // Add reaction to acknowledge command receipt
+    await message.react('👀').catch(() => { });
+    const channel = (message.channel && 'send' in message.channel) ? message.channel : null;
+    const monitorTraceId = `${message.channelId}:${message.id}`;
+    const enqueueGeneral = createSerialTaskQueueForTest('general', monitorTraceId);
+    const enqueueResponse = createSerialTaskQueueForTest('response', monitorTraceId);
+    const enqueueActivity = createSerialTaskQueueForTest('activity', monitorTraceId);
+    const sendEmbed = (title, description, color, fields, footerText) => enqueueGeneral(async () => {
+        if (!channel)
+            return;
+        const embed = new discord_js_1.EmbedBuilder()
+            .setTitle(title)
+            .setDescription(description)
+            .setColor(color)
+            .setTimestamp();
+        if (fields && fields.length > 0) {
+            embed.addFields(...fields);
+        }
+        if (footerText) {
+            embed.setFooter({ text: footerText });
+        }
+        await channel.send({ embeds: [embed] }).catch(() => { });
+    }, 'send-embed');
+    const shouldTryGeneratedImages = (inputPrompt, responseText) => {
+        const prompt = (inputPrompt || '').toLowerCase();
+        const response = (responseText || '').toLowerCase();
+        const imageIntentPattern = /(image|images|png|jpg|jpeg|gif|webp|illustration|diagram|render)/i;
+        const imageUrlPattern = /https?:\/\/\S+\.(png|jpg|jpeg|gif|webp)/i;
+        if (imageIntentPattern.test(prompt))
+            return true;
+        if (response.includes('![') || imageUrlPattern.test(response))
+            return true;
+        return false;
+    };
+    const sendGeneratedImages = async (responseText) => {
+        if (!channel)
+            return;
+        if (!shouldTryGeneratedImages(prompt, responseText))
+            return;
+        const extracted = await cdp.extractLatestResponseImages(MAX_OUTBOUND_GENERATED_IMAGES);
+        if (extracted.length === 0)
+            return;
+        const files = [];
+        for (let i = 0; i < extracted.length; i++) {
+            const attachment = await (0, imageHandler_1.toDiscordAttachment)(extracted[i], i);
+            if (attachment)
+                files.push(attachment);
+        }
+        if (files.length === 0)
+            return;
+        await enqueueGeneral(async () => {
+            await channel.send({
+                content: (0, i18n_1.t)(`🖼️ Detected generated images (${files.length})`),
+                files,
+            }).catch(() => { });
+        }, 'send-generated-images');
+    };
+    const tryEmergencyExtractText = async () => {
+        try {
+            const contextId = cdp.getPrimaryContextId();
+            const expression = `(() => {
+                const panel = document.querySelector('.antigravity-agent-side-panel');
+                const scope = panel || document;
+
+                const candidateSelectors = [
+                    '.rendered-markdown',
+                    '.leading-relaxed.select-text',
+                    '.flex.flex-col.gap-y-3',
+                    '[data-message-author-role="assistant"]',
+                    '[data-message-role="assistant"]',
+                    '[class*="assistant-message"]',
+                    '[class*="message-content"]',
+                    '[class*="markdown-body"]',
+                    '.prose',
+                ];
+
+                const looksLikeActivity = (text) => {
+                    const normalized = (text || '').trim().toLowerCase();
+                    if (!normalized) return true;
+                    const activityPattern = /^(?:analy[sz]ing|reading|writing|running|searching|planning|thinking|processing|loading|executing|testing|debugging|analyzed|read|wrote|ran)/i;
+                    return activityPattern.test(normalized) && normalized.length <= 220;
+                };
+
+                const clean = (text) => (text || '').replace(/\\r/g, '').replace(/\\n{3,}/g, '\\n\\n').trim();
+
+                const candidates = [];
+                const seen = new Set();
+                for (const selector of candidateSelectors) {
+                    const nodes = scope.querySelectorAll(selector);
+                    for (const node of nodes) {
+                        if (!node || seen.has(node)) continue;
+                        seen.add(node);
+                        candidates.push(node);
+                    }
+                }
+
+                for (let i = candidates.length - 1; i >= 0; i--) {
+                    const node = candidates[i];
+                    const text = clean(node.innerText || node.textContent || '');
+                    if (!text || text.length < 20) continue;
+                    if (looksLikeActivity(text)) continue;
+                    if (/^(good|bad)$/i.test(text)) continue;
+                    return text;
+                }
+
+                return '';
+            })()`;
+            const callParams = {
+                expression,
+                returnByValue: true,
+                awaitPromise: true,
+            };
+            if (contextId !== null)
+                callParams.contextId = contextId;
+            const res = await cdp.call('Runtime.evaluate', callParams);
+            const value = res?.result?.value;
+            return typeof value === 'string' ? value.trim() : '';
+        }
+        catch {
+            return '';
+        }
+    };
+    const clearWatchingReaction = async () => {
+        const botId = message.client.user?.id;
+        if (botId) {
+            await message.reactions.resolve('👀')?.users.remove(botId).catch(() => { });
+        }
+    };
+    if (!cdp.isConnected()) {
+        await sendEmbed(`${PHASE_ICONS.error} Connection Error`, 'Not connected to Antigravity.\nStart with `open -a Antigravity --args --remote-debugging-port=9223`, then send a message to auto-connect.', PHASE_COLORS.error);
+        await clearWatchingReaction();
+        await message.react('❌').catch(() => { });
+        return;
+    }
+    const localMode = modeService.getCurrentMode();
+    const modeName = modeService_1.MODE_UI_NAMES[localMode] || localMode;
+    const currentModel = (await cdp.getCurrentModel()) || modelService.getCurrentModel();
+    const fastModel = currentModel;
+    const planModel = currentModel;
+    await sendEmbed(`${PHASE_ICONS.sending} [${modeName} - ${currentModel}${localMode === 'plan' ? ' (Thinking)' : ''}] Sending...`, (0, streamMessageFormatter_1.buildModeModelLines)(modeName, fastModel, planModel).join('\n'), PHASE_COLORS.sending);
+    let isFinalized = false;
+    let lastProgressText = '';
+    let lastActivityLogText = '';
+    const LIVE_RESPONSE_MAX_LEN = 3800;
+    const LIVE_ACTIVITY_MAX_LEN = 3800;
+    const processLogBuffer = new processLogBuffer_1.ProcessLogBuffer({
+        maxChars: LIVE_ACTIVITY_MAX_LEN,
+        maxEntries: 120,
+        maxEntryLength: 220,
+    });
+    const liveResponseMessages = [];
+    const liveActivityMessages = [];
+    let lastLiveResponseKey = '';
+    let lastLiveActivityKey = '';
+    let liveResponseUpdateVersion = 0;
+    let liveActivityUpdateVersion = 0;
+    const ACTIVITY_PLACEHOLDER = (0, i18n_1.t)('Collecting process logs...');
+    const buildLiveResponseDescriptions = (text) => {
+        const normalized = (text || '').trim();
+        if (!normalized) {
+            return [(0, i18n_1.t)('Waiting for output...')];
+        }
+        return (0, streamMessageFormatter_1.splitForEmbedDescription)((0, discordFormatter_1.formatForDiscord)(normalized), LIVE_RESPONSE_MAX_LEN);
+    };
+    const buildLiveActivityDescriptions = (text) => {
+        const normalized = (text || '').trim();
+        if (!normalized)
+            return [ACTIVITY_PLACEHOLDER];
+        const formatted = (0, discordFormatter_1.formatForDiscord)(normalized);
+        return [(0, streamMessageFormatter_1.fitForSingleEmbedDescription)(formatted, LIVE_ACTIVITY_MAX_LEN)];
+    };
+    const appendProcessLogs = (text) => {
+        const normalized = (text || '').trim();
+        if (!normalized)
+            return processLogBuffer.snapshot();
+        return processLogBuffer.append(normalized);
+    };
+    const upsertLiveResponseEmbeds = (title, rawText, color, footerText, opts) => enqueueResponse(async () => {
+        if (opts?.skipWhenFinalized && isFinalized)
+            return;
+        if (opts?.expectedVersion !== undefined && opts.expectedVersion !== liveResponseUpdateVersion)
+            return;
+        if (!channel)
+            return;
+        const descriptions = buildLiveResponseDescriptions(rawText);
+        const renderKey = `${title}|${color}|${footerText}|${descriptions.join('\n<<<PAGE_BREAK>>>\n')}`;
+        if (renderKey === lastLiveResponseKey && liveResponseMessages.length > 0) {
+            return;
+        }
+        lastLiveResponseKey = renderKey;
+        for (let i = 0; i < descriptions.length; i++) {
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle(descriptions.length > 1 ? `${title} (${i + 1}/${descriptions.length})` : title)
+                .setDescription(descriptions[i])
+                .setColor(color)
+                .setFooter({ text: footerText })
+                .setTimestamp();
+            if (!liveResponseMessages[i]) {
+                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+                continue;
+            }
+            await liveResponseMessages[i].edit({ embeds: [embed] }).catch(async () => {
+                liveResponseMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+            });
+        }
+        // Delete excess messages if page count decreased
+        while (liveResponseMessages.length > descriptions.length) {
+            const extra = liveResponseMessages.pop();
+            if (!extra)
+                continue;
+            await extra.delete().catch(() => { });
+        }
+    }, `upsert-response:${opts?.source ?? 'unknown'}`);
+    const upsertLiveActivityEmbeds = (title, rawText, color, footerText, opts) => enqueueActivity(async () => {
+        if (opts?.skipWhenFinalized && isFinalized)
+            return;
+        if (opts?.expectedVersion !== undefined && opts.expectedVersion !== liveActivityUpdateVersion)
+            return;
+        if (!channel)
+            return;
+        const descriptions = buildLiveActivityDescriptions(rawText);
+        const renderKey = `${title}|${color}|${footerText}|${descriptions.join('\n<<<PAGE_BREAK>>>\n')}`;
+        if (renderKey === lastLiveActivityKey && liveActivityMessages.length > 0) {
+            return;
+        }
+        lastLiveActivityKey = renderKey;
+        for (let i = 0; i < descriptions.length; i++) {
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle(descriptions.length > 1 ? `${title} (${i + 1}/${descriptions.length})` : title)
+                .setDescription(descriptions[i])
+                .setColor(color)
+                .setFooter({ text: footerText })
+                .setTimestamp();
+            if (!liveActivityMessages[i]) {
+                liveActivityMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+                continue;
+            }
+            await liveActivityMessages[i].edit({ embeds: [embed] }).catch(async () => {
+                liveActivityMessages[i] = await channel.send({ embeds: [embed] }).catch(() => null);
+            });
+        }
+        while (liveActivityMessages.length > descriptions.length) {
+            const extra = liveActivityMessages.pop();
+            if (!extra)
+                continue;
+            await extra.delete().catch(() => { });
+        }
+    }, `upsert-activity:${opts?.source ?? 'unknown'}`);
+    try {
+        let injectResult;
+        if (inboundImages.length > 0) {
+            injectResult = await cdp.injectMessageWithImageFiles(prompt, inboundImages.map((image) => image.localPath));
+            if (!injectResult.ok) {
+                await sendEmbed((0, i18n_1.t)('🖼️ Attached image fallback'), (0, i18n_1.t)('Failed to attach image directly, resending via URL reference.'), PHASE_COLORS.thinking);
+                injectResult = await cdp.injectMessage((0, imageHandler_1.buildPromptWithAttachmentUrls)(prompt, inboundImages));
+            }
+        }
+        else {
+            injectResult = await cdp.injectMessage(prompt);
+        }
+        if (!injectResult.ok) {
+            isFinalized = true;
+            await sendEmbed(`${PHASE_ICONS.error} Message Injection Failed`, `Failed to send message: ${injectResult.error}`, PHASE_COLORS.error);
+            await clearWatchingReaction();
+            await message.react('❌').catch(() => { });
+            return;
+        }
+        const startTime = Date.now();
+        await upsertLiveActivityEmbeds(`${PHASE_ICONS.thinking} Process Log`, '', PHASE_COLORS.thinking, (0, i18n_1.t)('⏱️ Elapsed: 0s | Process log'), { source: 'initial' });
+        const monitor = new responseMonitor_1.ResponseMonitor({
+            cdpService: cdp,
+            pollIntervalMs: 2000,
+            maxDurationMs: 300000,
+            stopGoneConfirmCount: 3,
+            onPhaseChange: (_phase, _text) => {
+                // Phase transitions are already logged inside ResponseMonitor.setPhase()
+            },
+            onProcessLog: (logText) => {
+                if (isFinalized)
+                    return;
+                if (logText && logText.trim().length > 0) {
+                    lastActivityLogText = appendProcessLogs(logText);
+                }
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                liveActivityUpdateVersion += 1;
+                const activityVersion = liveActivityUpdateVersion;
+                upsertLiveActivityEmbeds(`${PHASE_ICONS.thinking} Process Log`, lastActivityLogText || ACTIVITY_PLACEHOLDER, PHASE_COLORS.thinking, (0, i18n_1.t)(`⏱️ Elapsed: ${elapsed}s | Process log`), {
+                    source: 'process-log',
+                    expectedVersion: activityVersion,
+                    skipWhenFinalized: true,
+                }).catch(() => { });
+            },
+            onProgress: (text) => {
+                if (isFinalized)
+                    return;
+                // TODO: Re-enable live output streaming after RESPONSE_TEXT reliably excludes process logs.
+                const separated = (0, discordFormatter_1.splitOutputAndLogs)(text);
+                if (separated.output && separated.output.trim().length > 0) {
+                    lastProgressText = separated.output;
+                }
+            },
+            onComplete: async (finalText) => {
+                isFinalized = true;
+                try {
+                    const elapsed = Math.round((Date.now() - startTime) / 1000);
+                    const responseText = (finalText && finalText.trim().length > 0)
+                        ? finalText
+                        : lastProgressText;
+                    const emergencyText = (!responseText || responseText.trim().length === 0)
+                        ? await tryEmergencyExtractText()
+                        : '';
+                    const finalResponseText = responseText && responseText.trim().length > 0
+                        ? responseText
+                        : emergencyText;
+                    const separated = (0, discordFormatter_1.splitOutputAndLogs)(finalResponseText);
+                    const finalOutputText = separated.output || finalResponseText;
+                    // Process logs are now collected by onProcessLog callback directly;
+                    // sanitizeActivityLines is NOT applied because it would strip the very
+                    // content we want to display (activity messages, tool names, etc.)
+                    const finalLogText = lastActivityLogText || processLogBuffer.snapshot();
+                    if (finalLogText && finalLogText.trim().length > 0) {
+                        logger_1.logger.divider('Process Log');
+                        console.info(finalLogText);
+                    }
+                    if (finalOutputText && finalOutputText.trim().length > 0) {
+                        logger_1.logger.divider(`Output (${finalOutputText.length} chars)`);
+                        console.info(finalOutputText);
+                    }
+                    logger_1.logger.divider();
+                    liveActivityUpdateVersion += 1;
+                    const activityVersion = liveActivityUpdateVersion;
+                    await upsertLiveActivityEmbeds(`${PHASE_ICONS.thinking} Process Log`, finalLogText || ACTIVITY_PLACEHOLDER, PHASE_COLORS.thinking, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), {
+                        source: 'complete',
+                        expectedVersion: activityVersion,
+                    });
+                    liveResponseUpdateVersion += 1;
+                    const responseVersion = liveResponseUpdateVersion;
+                    if (finalOutputText && finalOutputText.trim().length > 0) {
+                        await upsertLiveResponseEmbeds(`${PHASE_ICONS.complete} Final Output`, finalOutputText, PHASE_COLORS.complete, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), {
+                            source: 'complete',
+                            expectedVersion: responseVersion,
+                        });
+                    }
+                    else {
+                        await upsertLiveResponseEmbeds(`${PHASE_ICONS.complete} Complete`, (0, i18n_1.t)('Failed to extract response. Use `/screenshot` to verify.'), PHASE_COLORS.complete, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Complete`), {
+                            source: 'complete',
+                            expectedVersion: responseVersion,
+                        });
+                    }
+                    if (options && message.guild) {
+                        try {
+                            const sessionInfo = await options.chatSessionService.getCurrentSessionInfo(cdp);
+                            if (sessionInfo && sessionInfo.hasActiveChat && sessionInfo.title && sessionInfo.title !== (0, i18n_1.t)('(Untitled)')) {
+                                const session = options.chatSessionRepo.findByChannelId(message.channelId);
+                                const workspaceDirName = session
+                                    ? bridge.pool.extractDirName(session.workspacePath)
+                                    : cdp.getCurrentWorkspaceName();
+                                if (workspaceDirName) {
+                                    (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, workspaceDirName, sessionInfo.title, message.channel);
+                                }
+                                const newName = options.titleGenerator.sanitizeForChannelName(sessionInfo.title);
+                                if (session && session.displayName !== sessionInfo.title) {
+                                    const formattedName = `${session.sessionNumber}-${newName}`;
+                                    await options.channelManager.renameChannel(message.guild, message.channelId, formattedName);
+                                    options.chatSessionRepo.updateDisplayName(message.channelId, sessionInfo.title);
+                                }
+                            }
+                        }
+                        catch (e) {
+                            logger_1.logger.error('[Rename] Failed to get title from Antigravity and rename:', e);
+                        }
+                    }
+                    if (monitor.getPhase() === 'quotaReached' || monitor.getQuotaDetected()) {
+                        await sendEmbed('⚠️ Model Quota Reached', 'Model quota limit reached. Please wait or switch to a different model with `/model`.', 0xFF6B6B, undefined, 'Quota Reached — consider switching models');
+                        await clearWatchingReaction();
+                        await message.react('⚠️').catch(() => { });
+                        return;
+                    }
+                    await sendGeneratedImages(finalOutputText || '');
+                    await clearWatchingReaction();
+                    await message.react(finalOutputText && finalOutputText.trim().length > 0 ? '✅' : '⚠️').catch(() => { });
+                }
+                catch (error) {
+                    logger_1.logger.error(`[sendPromptToAntigravity:${monitorTraceId}] onComplete failed:`, error);
+                }
+            },
+            onTimeout: async (lastText) => {
+                isFinalized = true;
+                try {
+                    const elapsed = Math.round((Date.now() - startTime) / 1000);
+                    const timeoutText = (lastText && lastText.trim().length > 0)
+                        ? lastText
+                        : lastProgressText;
+                    const separated = (0, discordFormatter_1.splitOutputAndLogs)(timeoutText || '');
+                    const sanitizedTimeoutLogs = lastActivityLogText || processLogBuffer.snapshot();
+                    const payload = separated.output && separated.output.trim().length > 0
+                        ? (0, i18n_1.t)(`${separated.output}\n\n[Monitor Ended] Timeout after 5 minutes.`)
+                        : 'Monitor ended after 5 minutes. No text was retrieved.';
+                    liveResponseUpdateVersion += 1;
+                    const responseVersion = liveResponseUpdateVersion;
+                    await upsertLiveResponseEmbeds(`${PHASE_ICONS.timeout} Timeout`, payload, PHASE_COLORS.timeout, `⏱️ Elapsed: ${elapsed}s | Timeout`, {
+                        source: 'timeout',
+                        expectedVersion: responseVersion,
+                    });
+                    liveActivityUpdateVersion += 1;
+                    const activityVersion = liveActivityUpdateVersion;
+                    await upsertLiveActivityEmbeds(`${PHASE_ICONS.thinking} Process Log`, sanitizedTimeoutLogs || ACTIVITY_PLACEHOLDER, PHASE_COLORS.thinking, (0, i18n_1.t)(`⏱️ Time: ${elapsed}s | Process log`), {
+                        source: 'timeout',
+                        expectedVersion: activityVersion,
+                    });
+                    await clearWatchingReaction();
+                    await message.react('⚠️').catch(() => { });
+                }
+                catch (error) {
+                    logger_1.logger.error(`[sendPromptToAntigravity:${monitorTraceId}] onTimeout failed:`, error);
+                }
+            },
+        });
+        await monitor.start();
+    }
+    catch (e) {
+        isFinalized = true;
+        await sendEmbed(`${PHASE_ICONS.error} Error`, (0, i18n_1.t)(`Error occurred during processing: ${e.message}`), PHASE_COLORS.error);
+        await clearWatchingReaction();
+        await message.react('❌').catch(() => { });
+    }
+}
+// =============================================================================
+// Bot main entry point
+// =============================================================================
+const startBot = async () => {
+    const config = (0, config_1.loadConfig)();
+    const dbPath = process.env.NODE_ENV === 'test' ? ':memory:' : 'antigravity.db';
+    const db = new better_sqlite3_1.default(dbPath);
+    const modeService = new modeService_1.ModeService();
+    const modelService = new modelService_1.ModelService();
+    const templateRepo = new templateRepository_1.TemplateRepository(db);
+    const workspaceBindingRepo = new workspaceBindingRepository_1.WorkspaceBindingRepository(db);
+    const chatSessionRepo = new chatSessionRepository_1.ChatSessionRepository(db);
+    const workspaceService = new workspaceService_1.WorkspaceService(config.workspaceBaseDir);
+    const channelManager = new channelManager_1.ChannelManager();
+    // Auto-launch Antigravity with CDP port if not already running
+    await (0, antigravityLauncher_1.ensureAntigravityRunning)();
+    // Initialize CDP bridge (lazy connection: pool creation only)
+    const bridge = (0, cdpBridgeManager_1.initCdpBridge)(config.autoApproveFileEdits);
+    // Initialize CDP-dependent services (constructor CDP dependency removed)
+    const chatSessionService = new chatSessionService_1.ChatSessionService();
+    const titleGenerator = new titleGeneratorService_1.TitleGeneratorService();
+    const promptDispatcher = new promptDispatcher_1.PromptDispatcher({
+        bridge,
+        modeService,
+        modelService,
+        sendPromptImpl: sendPromptToAntigravity,
+    });
+    // Initialize command handlers
+    const wsHandler = new workspaceCommandHandler_1.WorkspaceCommandHandler(workspaceBindingRepo, chatSessionRepo, workspaceService, channelManager);
+    const chatHandler = new chatCommandHandler_1.ChatCommandHandler(chatSessionService, chatSessionRepo, workspaceBindingRepo, channelManager, workspaceService, bridge.pool);
+    const cleanupHandler = new cleanupCommandHandler_1.CleanupCommandHandler(chatSessionRepo, workspaceBindingRepo);
+    const slashCommandHandler = new slashCommandHandler_1.SlashCommandHandler(templateRepo);
+    const client = new discord_js_1.Client({
+        intents: [
+            discord_js_1.GatewayIntentBits.Guilds,
+            discord_js_1.GatewayIntentBits.GuildMessages,
+            discord_js_1.GatewayIntentBits.MessageContent,
+        ]
+    });
+    client.once(discord_js_1.Events.ClientReady, async (readyClient) => {
+        logger_1.logger.info(`Ready! Logged in as ${readyClient.user.tag}`);
+        try {
+            await (0, registerSlashCommands_1.registerSlashCommands)(config.discordToken, config.clientId, config.guildId);
+        }
+        catch (error) {
+            logger_1.logger.warn('Failed to register slash commands, but text commands remain available.');
+        }
+    });
+    // [Discord Interactions API] Slash command interaction handler
+    client.on(discord_js_1.Events.InteractionCreate, (0, interactionCreateHandler_1.createInteractionCreateHandler)({
+        config,
+        bridge,
+        cleanupHandler,
+        modeService,
+        modelService,
+        slashCommandHandler,
+        wsHandler,
+        chatHandler,
+        client,
+        sendModeUI: modeUi_1.sendModeUI,
+        sendModelsUI: modelsUi_1.sendModelsUI,
+        sendAutoAcceptUI: autoAcceptUi_1.sendAutoAcceptUI,
+        getCurrentCdp: cdpBridgeManager_1.getCurrentCdp,
+        parseApprovalCustomId: cdpBridgeManager_1.parseApprovalCustomId,
+        handleSlashInteraction: async (interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg) => handleSlashInteraction(interaction, handler, bridgeArg, wsHandlerArg, chatHandlerArg, cleanupHandlerArg, modeServiceArg, modelServiceArg, autoAcceptServiceArg, clientArg, promptDispatcher, templateRepo),
+        handleTemplateUse: async (interaction, templateId) => {
+            const template = templateRepo.findById(templateId);
+            if (!template) {
+                await interaction.followUp({
+                    content: 'Template not found. It may have been deleted.',
+                    flags: discord_js_1.MessageFlags.Ephemeral,
+                });
+                return;
+            }
+            // Resolve CDP via workspace binding (same flow as text messages)
+            const channelId = interaction.channelId;
+            const workspacePath = wsHandler.getWorkspaceForChannel(channelId);
+            let cdp = null;
+            if (workspacePath) {
+                try {
+                    cdp = await bridge.pool.getOrConnect(workspacePath);
+                    const dirName = bridge.pool.extractDirName(workspacePath);
+                    bridge.lastActiveWorkspace = dirName;
+                    bridge.lastActiveChannel = interaction.channel;
+                    (0, cdpBridgeManager_1.registerApprovalWorkspaceChannel)(bridge, dirName, interaction.channel);
+                    const session = chatSessionRepo.findByChannelId(channelId);
+                    if (session?.displayName) {
+                        (0, cdpBridgeManager_1.registerApprovalSessionChannel)(bridge, dirName, session.displayName, interaction.channel);
+                    }
+                    (0, cdpBridgeManager_1.ensureApprovalDetector)(bridge, cdp, dirName, client);
+                }
+                catch (e) {
+                    await interaction.followUp({
+                        content: `Failed to connect to workspace: ${e.message}`,
+                        flags: discord_js_1.MessageFlags.Ephemeral,
+                    });
+                    return;
+                }
+            }
+            else {
+                cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            }
+            if (!cdp) {
+                await interaction.followUp({
+                    content: 'Not connected to CDP. Please connect to a project first.',
+                    flags: discord_js_1.MessageFlags.Ephemeral,
+                });
+                return;
+            }
+            const followUp = await interaction.followUp({
+                content: `Executing template **${template.name}**...`,
+            });
+            if (followUp instanceof discord_js_1.Message) {
+                await promptDispatcher.send({
+                    message: followUp,
+                    prompt: template.prompt,
+                    cdp,
+                    inboundImages: [],
+                    options: {
+                        chatSessionService,
+                        chatSessionRepo,
+                        channelManager,
+                        titleGenerator,
+                    },
+                });
+            }
+        },
+    }));
+    // [Text message handler]
+    client.on(discord_js_1.Events.MessageCreate, (0, messageCreateHandler_1.createMessageCreateHandler)({
+        config,
+        bridge,
+        modeService,
+        modelService,
+        slashCommandHandler,
+        wsHandler,
+        chatSessionService,
+        chatSessionRepo,
+        channelManager,
+        titleGenerator,
+        client,
+        sendPromptToAntigravity: async (_bridge, message, prompt, cdp, _modeService, _modelService, inboundImages = [], options) => promptDispatcher.send({
+            message,
+            prompt,
+            cdp,
+            inboundImages,
+            options,
+        }),
+        autoRenameChannel,
+        handleScreenshot: screenshotUi_1.handleScreenshot,
+    }));
+    await client.login(config.discordToken);
+};
+exports.startBot = startBot;
+/**
+ * Auto-rename channel on first message send
+ */
+async function autoRenameChannel(message, chatSessionRepo, titleGenerator, channelManager, cdp) {
+    const session = chatSessionRepo.findByChannelId(message.channelId);
+    if (!session || session.isRenamed)
+        return;
+    const guild = message.guild;
+    if (!guild)
+        return;
+    try {
+        const title = await titleGenerator.generateTitle(message.content, cdp);
+        const newName = `${session.sessionNumber}-${title}`;
+        await channelManager.renameChannel(guild, message.channelId, newName);
+        chatSessionRepo.updateDisplayName(message.channelId, title);
+    }
+    catch (err) {
+        logger_1.logger.error('[AutoRename] Rename failed:', err);
+    }
+}
+/**
+ * Handle Discord Interactions API slash commands
+ */
+async function handleSlashInteraction(interaction, handler, bridge, wsHandler, chatHandler, cleanupHandler, modeService, modelService, autoAcceptService, _client, promptDispatcher, templateRepo) {
+    const commandName = interaction.commandName;
+    switch (commandName) {
+        case 'help': {
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle('📖 LazyGravity Commands')
+                .setColor(0x5865F2)
+                .setDescription('Commands for controlling Antigravity from Discord.')
+                .addFields({
+                name: '💬 Chat', value: [
+                    '`/new` — Start a new chat session',
+                    '`/chat` — Show current session info + list',
+                ].join('\n')
+            }, {
+                name: '⏹️ Control', value: [
+                    '`/stop` — Interrupt active LLM generation',
+                    '`/screenshot` — Capture Antigravity screen',
+                ].join('\n')
+            }, {
+                name: '⚙️ Settings', value: [
+                    '`/mode` — Display and change execution mode',
+                    '`/model [name]` — Display and change LLM model',
+                ].join('\n')
+            }, {
+                name: '📁 Projects', value: [
+                    '`/project` — Display project list',
+                    '`/project create <name>` — Create a new project',
+                ].join('\n')
+            }, {
+                name: '📝 Templates', value: [
+                    '`/template list` — Show templates with execute buttons (click to run)',
+                    '`/template add <name> <prompt>` — Register a template',
+                    '`/template delete <name>` — Delete a template',
+                ].join('\n')
+            }, {
+                name: '🔧 System', value: [
+                    '`/status` — Display overall bot status',
+                    '`/autoaccept` — Toggle auto-approve mode for approval dialogs via buttons',
+                    '`/cleanup [days]` — Clean up unused channels/categories',
+                    '`/help` — Show this help',
+                ].join('\n')
+            })
+                .setFooter({ text: 'Text messages are sent directly to Antigravity' })
+                .setTimestamp();
+            await interaction.editReply({ embeds: [embed] });
+            break;
+        }
+        case 'mode': {
+            await (0, modeUi_1.sendModeUI)(interaction, modeService);
+            break;
+        }
+        case 'model': {
+            const modelName = interaction.options.getString('name');
+            if (!modelName) {
+                await (0, modelsUi_1.sendModelsUI)(interaction, {
+                    getCurrentCdp: () => (0, cdpBridgeManager_1.getCurrentCdp)(bridge),
+                    fetchQuota: async () => bridge.quota.fetchQuota(),
+                });
+            }
+            else {
+                const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                if (!cdp) {
+                    await interaction.editReply({ content: 'Not connected to CDP.' });
+                    break;
+                }
+                const res = await cdp.setUiModel(modelName);
+                if (res.ok) {
+                    await interaction.editReply({ content: `Model changed to **${res.model}**.` });
+                }
+                else {
+                    await interaction.editReply({ content: res.error || 'Failed to change model.' });
+                }
+            }
+            break;
+        }
+        case 'template': {
+            const subcommand = interaction.options.getSubcommand();
+            if (subcommand === 'list') {
+                const templates = templateRepo.findAll();
+                await (0, templateUi_1.sendTemplateUI)(interaction, templates);
+                break;
+            }
+            let args;
+            switch (subcommand) {
+                case 'add': {
+                    const name = interaction.options.getString('name', true);
+                    const prompt = interaction.options.getString('prompt', true);
+                    args = ['add', name, prompt];
+                    break;
+                }
+                case 'delete': {
+                    const name = interaction.options.getString('name', true);
+                    args = ['delete', name];
+                    break;
+                }
+                default:
+                    args = [];
+            }
+            const result = await handler.handleCommand('template', args);
+            await interaction.editReply({ content: result.message });
+            break;
+        }
+        case 'status': {
+            const activeNames = bridge.pool.getActiveWorkspaceNames();
+            const currentModel = (() => {
+                const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+                return cdp ? 'CDP Connected' : 'Disconnected';
+            })();
+            const currentMode = modeService.getCurrentMode();
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle('🔧 Bot Status')
+                .setColor(activeNames.length > 0 ? 0x00CC88 : 0x888888)
+                .addFields({ name: 'CDP Connection', value: activeNames.length > 0 ? `🟢 ${activeNames.length} project(s) connected` : '⚪ Disconnected', inline: true }, { name: 'Mode', value: modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode, inline: true }, { name: 'Auto Approve', value: autoAcceptService.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true })
+                .setTimestamp();
+            if (activeNames.length > 0) {
+                const lines = activeNames.map((name) => {
+                    const cdp = bridge.pool.getConnected(name);
+                    const contexts = cdp ? cdp.getContexts().length : 0;
+                    const detectorActive = bridge.pool.getApprovalDetector(name)?.isActive() ? ' [Detecting]' : '';
+                    return `• **${name}** — Contexts: ${contexts}${detectorActive}`;
+                });
+                embed.setDescription(`**Connected Projects:**\n${lines.join('\n')}`);
+            }
+            else {
+                embed.setDescription('Send a message to auto-connect to a project.');
+            }
+            await interaction.editReply({ embeds: [embed] });
+            break;
+        }
+        case 'autoaccept': {
+            const requestedMode = interaction.options.getString('mode');
+            if (!requestedMode) {
+                await (0, autoAcceptUi_1.sendAutoAcceptUI)(interaction, autoAcceptService);
+                break;
+            }
+            const result = autoAcceptService.handle(requestedMode);
+            await interaction.editReply({ content: result.message });
+            break;
+        }
+        case 'screenshot': {
+            await (0, screenshotUi_1.handleScreenshot)(interaction, (0, cdpBridgeManager_1.getCurrentCdp)(bridge));
+            break;
+        }
+        case 'stop': {
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(bridge);
+            if (!cdp) {
+                await interaction.editReply({ content: '⚠️ Not connected to CDP. Please connect to a project first.' });
+                break;
+            }
+            try {
+                const contextId = cdp.getPrimaryContextId();
+                const callParams = {
+                    expression: responseMonitor_1.RESPONSE_SELECTORS.CLICK_STOP_BUTTON,
+                    returnByValue: true,
+                    awaitPromise: false,
+                };
+                if (contextId !== null) {
+                    callParams.contextId = contextId;
+                }
+                const result = await cdp.call('Runtime.evaluate', callParams);
+                const value = result?.result?.value;
+                if (value?.ok) {
+                    const embed = new discord_js_1.EmbedBuilder()
+                        .setTitle('⏹️ Generation Interrupted')
+                        .setDescription('AI response generation was safely stopped.')
+                        .setColor(0xE74C3C)
+                        .setTimestamp();
+                    await interaction.editReply({ embeds: [embed] });
+                }
+                else {
+                    const embed = new discord_js_1.EmbedBuilder()
+                        .setTitle('⚠️ Could Not Stop')
+                        .setDescription(value?.error || 'Stop button not found. The LLM may not be running.')
+                        .setColor(0xF39C12)
+                        .setTimestamp();
+                    await interaction.editReply({ embeds: [embed] });
+                }
+            }
+            catch (e) {
+                await interaction.editReply({ content: `❌ Error during stop processing: ${e.message}` });
+            }
+            break;
+        }
+        case 'project': {
+            const wsSub = interaction.options.getSubcommand(false);
+            if (wsSub === 'create') {
+                if (!interaction.guild) {
+                    await interaction.editReply({ content: 'This command can only be used in a server.' });
+                    break;
+                }
+                await wsHandler.handleCreate(interaction, interaction.guild);
+            }
+            else {
+                // /project list or /project (default)
+                await wsHandler.handleShow(interaction);
+            }
+            break;
+        }
+        case 'new': {
+            await chatHandler.handleNew(interaction);
+            break;
+        }
+        case 'chat': {
+            await chatHandler.handleChat(interaction);
+            break;
+        }
+        case 'cleanup': {
+            await cleanupHandler.handleCleanup(interaction);
+            break;
+        }
+        default:
+            await interaction.editReply({
+                content: `Unknown command: /${commandName}`,
+            });
+    }
+}