lazy-gravity 0.0.4 → 0.2.0

package/dist/events/messageCreateHandler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMessageCreateHandler = createMessageCreateHandler;
 const discord_js_1 = require("discord.js");
 const messageParser_1 = require("../commands/messageParser");
+const plainTextFormatter_1 = require("../utils/plainTextFormatter");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const modeService_1 = require("../services/modeService");
 const imageHandler_1 = require("../utils/imageHandler");
@@ -10,11 +11,30 @@ const logger_1 = require("../utils/logger");
 function createMessageCreateHandler(deps) {
     const getCurrentCdp = deps.getCurrentCdp ?? cdpBridgeManager_1.getCurrentCdp;
     const ensureApprovalDetector = deps.ensureApprovalDetector ?? cdpBridgeManager_1.ensureApprovalDetector;
+    const ensureErrorPopupDetector = deps.ensureErrorPopupDetector ?? cdpBridgeManager_1.ensureErrorPopupDetector;
+    const ensurePlanningDetector = deps.ensurePlanningDetector ?? cdpBridgeManager_1.ensurePlanningDetector;
     const registerApprovalWorkspaceChannel = deps.registerApprovalWorkspaceChannel ?? cdpBridgeManager_1.registerApprovalWorkspaceChannel;
     const registerApprovalSessionChannel = deps.registerApprovalSessionChannel ?? cdpBridgeManager_1.registerApprovalSessionChannel;
     const downloadInboundImageAttachments = deps.downloadInboundImageAttachments ?? imageHandler_1.downloadInboundImageAttachments;
     const cleanupInboundImageAttachments = deps.cleanupInboundImageAttachments ?? imageHandler_1.cleanupInboundImageAttachments;
     const isImageAttachment = deps.isImageAttachment ?? imageHandler_1.isImageAttachment;
+    // Per-workspace prompt queue: serializes send→response cycles
+    const workspaceQueues = new Map();
+    const workspaceQueueDepths = new Map();
+    function enqueueForWorkspace(workspacePath, task) {
+        // .catch: ensure a prior rejection never stalls the chain
+        const current = (workspaceQueues.get(workspacePath) ?? Promise.resolve()).catch(() => { });
+        const next = current.then(async () => {
+            try {
+                await task();
+            }
+            catch (err) {
+                logger_1.logger.error('[WorkspaceQueue] task error:', err?.message || err);
+            }
+        });
+        workspaceQueues.set(workspacePath, next);
+        return next;
+    }
     return async (message) => {
         if (message.author.bot)
             return;
@@ -36,12 +56,12 @@ function createMessageCreateHandler(deps) {
             if (parsed.commandName === 'status') {
                 const activeNames = deps.bridge.pool.getActiveWorkspaceNames();
                 const currentMode = deps.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: deps.bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true })
-                    .setFooter({ text: '💡 Use the slash command /status for more detailed information' })
-                    .setTimestamp();
+                const statusFields = [
+                    { 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: deps.bridge.autoAccept.isEnabled() ? '🟢 ON' : '⚪ OFF', inline: true },
+                ];
+                let statusDescription = '';
                 if (activeNames.length > 0) {
                     const lines = activeNames.map((name) => {
                         const cdp = deps.bridge.pool.getConnected(name);
@@ -49,15 +69,33 @@ function createMessageCreateHandler(deps) {
                         const detectorActive = deps.bridge.pool.getApprovalDetector(name)?.isActive() ? ' [Detecting]' : '';
                         return `• **${name}** — Contexts: ${contexts}${detectorActive}`;
                     });
-                    embed.setDescription(`**Connected Projects:**\n${lines.join('\n')}`);
+                    statusDescription = `**Connected Projects:**\n${lines.join('\n')}`;
                 }
                 else {
-                    embed.setDescription('Send a message to auto-connect to a project.');
+                    statusDescription = 'Send a message to auto-connect to a project.';
                 }
+                const statusOutputFormat = deps.userPrefRepo?.getOutputFormat(message.author.id) ?? 'embed';
+                if (statusOutputFormat === 'plain') {
+                    const chunks = (0, plainTextFormatter_1.formatAsPlainText)({
+                        title: '🔧 Bot Status',
+                        description: statusDescription,
+                        fields: statusFields,
+                        footerText: 'Use the slash command /status for more detailed information',
+                    });
+                    await message.reply({ content: chunks[0] });
+                    return;
+                }
+                const embed = new discord_js_1.EmbedBuilder()
+                    .setTitle('🔧 Bot Status')
+                    .setColor(activeNames.length > 0 ? 0x00CC88 : 0x888888)
+                    .addFields(...statusFields)
+                    .setDescription(statusDescription)
+                    .setFooter({ text: '💡 Use the slash command /status for more detailed information' })
+                    .setTimestamp();
                 await message.reply({ embeds: [embed] });
                 return;
             }
-            const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup'];
+            const slashOnlyCommands = ['help', 'stop', 'model', 'mode', 'project', 'chat', 'new', 'cleanup', 'join', 'mirror', 'output'];
             if (slashOnlyCommands.includes(parsed.commandName)) {
                 await message.reply({
                     content: `💡 Please use \`/${parsed.commandName}\` as a slash command.\nType \`/${parsed.commandName}\` in the Discord input field to see suggestions.`,
@@ -76,6 +114,7 @@ function createMessageCreateHandler(deps) {
                         chatSessionRepo: deps.chatSessionRepo,
                         channelManager: deps.channelManager,
                         titleGenerator: deps.titleGenerator,
+                        userPrefRepo: deps.userPrefRepo,
                     });
                 }
                 else {
@@ -96,51 +135,126 @@ function createMessageCreateHandler(deps) {
             const workspacePath = deps.wsHandler.getWorkspaceForChannel(message.channelId);
             try {
                 if (workspacePath) {
-                    try {
-                        const cdp = await deps.bridge.pool.getOrConnect(workspacePath);
-                        const dirName = deps.bridge.pool.extractDirName(workspacePath);
-                        deps.bridge.lastActiveWorkspace = dirName;
-                        deps.bridge.lastActiveChannel = message.channel;
-                        registerApprovalWorkspaceChannel(deps.bridge, dirName, message.channel);
-                        ensureApprovalDetector(deps.bridge, cdp, dirName, deps.client);
-                        const session = deps.chatSessionRepo.findByChannelId(message.channelId);
-                        if (session?.displayName) {
-                            registerApprovalSessionChannel(deps.bridge, dirName, session.displayName, message.channel);
+                    const projectLabel = deps.bridge.pool.extractProjectName(workspacePath);
+                    // Track queue depth for hourglass reactions
+                    const currentDepth = workspaceQueueDepths.get(workspacePath) ?? 0;
+                    workspaceQueueDepths.set(workspacePath, currentDepth + 1);
+                    const newDepth = currentDepth + 1;
+                    if (currentDepth > 0) {
+                        logger_1.logger.info(`[Queue:${projectLabel}] Enqueued (depth: ${newDepth}, channel: ${message.channelId})`);
+                        await message.react('⏳').catch(() => { });
+                    }
+                    else {
+                        logger_1.logger.info(`[Queue:${projectLabel}] Processing immediately (depth: ${newDepth}, channel: ${message.channelId})`);
+                    }
+                    const queueStartTime = Date.now();
+                    await enqueueForWorkspace(workspacePath, async () => {
+                        const waitMs = Date.now() - queueStartTime;
+                        if (waitMs > 100) {
+                            logger_1.logger.info(`[Queue:${projectLabel}] Task started after ${Math.round(waitMs / 1000)}s wait (channel: ${message.channelId})`);
                         }
-                        if (session?.isRenamed && session.displayName) {
-                            const activationResult = await deps.chatSessionService.activateSessionByTitle(cdp, session.displayName);
-                            if (!activationResult.ok) {
-                                const reason = activationResult.error ? ` (${activationResult.error})` : '';
-                                await message.reply(`⚠️ Could not route this message to the bound session (${session.displayName}). ` +
-                                    `Please open /chat and verify the session${reason}.`).catch(() => { });
-                                return;
-                            }
+                        // Remove hourglass when task starts processing
+                        const botId = message.client.user?.id;
+                        if (botId) {
+                            await message.reactions.resolve('⏳')?.users.remove(botId).catch(() => { });
                         }
-                        else if (session && !session.isRenamed) {
-                            try {
-                                const chatResult = await deps.chatSessionService.startNewChat(cdp);
-                                if (!chatResult.ok) {
-                                    logger_1.logger.warn('[MessageCreate] Failed to start new chat in Antigravity:', chatResult.error);
+                        try {
+                            const cdp = await deps.bridge.pool.getOrConnect(workspacePath);
+                            const projectName = deps.bridge.pool.extractProjectName(workspacePath);
+                            deps.bridge.lastActiveWorkspace = projectName;
+                            deps.bridge.lastActiveChannel = message.channel;
+                            registerApprovalWorkspaceChannel(deps.bridge, projectName, message.channel);
+                            ensureApprovalDetector(deps.bridge, cdp, projectName, deps.client);
+                            ensureErrorPopupDetector(deps.bridge, cdp, projectName, deps.client);
+                            ensurePlanningDetector(deps.bridge, cdp, projectName, deps.client);
+                            const session = deps.chatSessionRepo.findByChannelId(message.channelId);
+                            if (session?.displayName) {
+                                registerApprovalSessionChannel(deps.bridge, projectName, session.displayName, message.channel);
+                            }
+                            if (session?.isRenamed && session.displayName) {
+                                const activationResult = await deps.chatSessionService.activateSessionByTitle(cdp, session.displayName);
+                                if (!activationResult.ok) {
+                                    const reason = activationResult.error ? ` (${activationResult.error})` : '';
+                                    await message.reply(`⚠️ Could not route this message to the bound session (${session.displayName}). ` +
+                                        `Please open /chat and verify the session${reason}.`).catch(() => { });
+                                    return;
+                                }
+                            }
+                            else if (session && !session.isRenamed) {
+                                try {
+                                    const chatResult = await deps.chatSessionService.startNewChat(cdp);
+                                    if (!chatResult.ok) {
+                                        logger_1.logger.warn('[MessageCreate] Failed to start new chat in Antigravity:', chatResult.error);
+                                        message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
+                                    }
+                                }
+                                catch (err) {
+                                    logger_1.logger.error('[MessageCreate] startNewChat error:', err);
                                     message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
                                 }
                             }
-                            catch (err) {
-                                logger_1.logger.error('[MessageCreate] startNewChat error:', err);
-                                message.channel.send(`⚠️ Could not open a new chat in Antigravity. Sending to existing chat.`).catch(() => { });
+                            await deps.autoRenameChannel(message, deps.chatSessionRepo, deps.titleGenerator, deps.channelManager, cdp);
+                            // Re-register session channel after autoRenameChannel sets displayName
+                            const updatedSession = deps.chatSessionRepo.findByChannelId(message.channelId);
+                            if (updatedSession?.displayName) {
+                                registerApprovalSessionChannel(deps.bridge, projectName, updatedSession.displayName, message.channel);
                             }
+                            // Register echo hash so UserMessageDetector skips this message
+                            const userMsgDetector = deps.bridge.pool.getUserMessageDetector?.(projectName);
+                            if (userMsgDetector) {
+                                userMsgDetector.addEchoHash(promptText);
+                            }
+                            // Wait for full response cycle (onComplete/onTimeout) before releasing the queue.
+                            // Safety timeout (360s) prevents permanent queue deadlock if onFullCompletion
+                            // is never called due to a bug.
+                            const QUEUE_SAFETY_TIMEOUT_MS = 360_000;
+                            const promptStartTime = Date.now();
+                            await new Promise((resolve) => {
+                                const safetyTimer = setTimeout(() => {
+                                    logger_1.logger.warn(`[Queue:${projectName}] Safety timeout — releasing queue after 360s ` +
+                                        `(channel: ${message.channelId})`);
+                                    resolve();
+                                }, QUEUE_SAFETY_TIMEOUT_MS);
+                                let settled = false;
+                                const settle = () => {
+                                    if (settled)
+                                        return;
+                                    settled = true;
+                                    clearTimeout(safetyTimer);
+                                    const elapsed = Math.round((Date.now() - promptStartTime) / 1000);
+                                    logger_1.logger.info(`[Queue:${projectName}] Prompt completed in ${elapsed}s ` +
+                                        `(channel: ${message.channelId})`);
+                                    resolve();
+                                };
+                                deps.sendPromptToAntigravity(deps.bridge, message, promptText, cdp, deps.modeService, deps.modelService, inboundImages, {
+                                    chatSessionService: deps.chatSessionService,
+                                    chatSessionRepo: deps.chatSessionRepo,
+                                    channelManager: deps.channelManager,
+                                    titleGenerator: deps.titleGenerator,
+                                    userPrefRepo: deps.userPrefRepo,
+                                    onFullCompletion: settle,
+                                }).catch((err) => {
+                                    // sendPromptToAntigravity rejected before onFullCompletion fired
+                                    // (e.g. setup code threw before top-level try/catch).
+                                    // Release the queue immediately instead of waiting for safety timeout.
+                                    logger_1.logger.error(`[Queue:${projectName}] sendPromptToAntigravity rejected early ` +
+                                        `(channel: ${message.channelId}):`, err?.message || err);
+                                    settle();
+                                });
+                            });
                         }
-                        await deps.autoRenameChannel(message, deps.chatSessionRepo, deps.titleGenerator, deps.channelManager, cdp);
-                        await deps.sendPromptToAntigravity(deps.bridge, message, promptText, cdp, deps.modeService, deps.modelService, inboundImages, {
-                            chatSessionService: deps.chatSessionService,
-                            chatSessionRepo: deps.chatSessionRepo,
-                            channelManager: deps.channelManager,
-                            titleGenerator: deps.titleGenerator,
-                        });
-                    }
-                    catch (e) {
-                        await message.reply(`Failed to connect to workspace: ${e.message}`);
-                        return;
-                    }
+                        catch (e) {
+                            logger_1.logger.error(`[Queue:${projectLabel}] Task failed (channel: ${message.channelId}):`, e.message);
+                            await message.reply(`Failed to connect to workspace: ${e.message}`);
+                        }
+                        finally {
+                            const remainingDepth = (workspaceQueueDepths.get(workspacePath) ?? 1) - 1;
+                            workspaceQueueDepths.set(workspacePath, remainingDepth);
+                            if (remainingDepth > 0) {
+                                logger_1.logger.info(`[Queue:${projectLabel}] Task done, ${remainingDepth} remaining`);
+                            }
+                        }
+                    });
                 }
                 else {
                     await message.reply('No project is configured for this channel. Please create or select one with `/project`.');

package/dist/services/antigravityLauncher.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureAntigravityRunning = ensureAntigravityRunning;
 const logger_1 = require("../utils/logger");
 const cdpPorts_1 = require("../utils/cdpPorts");
+const pathUtils_1 = require("../utils/pathUtils");
 const http = __importStar(require("http"));
 /**
  * Check if CDP responds on the specified port.
@@ -69,10 +70,10 @@ function checkPort(port) {
  * Called during Bot initialization.
  */
 async function ensureAntigravityRunning() {
-    logger_1.logger.info('[AntigravityLauncher] Checking CDP ports...');
+    logger_1.logger.debug('[AntigravityLauncher] Checking CDP ports...');
     for (const port of cdpPorts_1.CDP_PORTS) {
         if (await checkPort(port)) {
-            logger_1.logger.info(`[AntigravityLauncher] OK — Port ${port} responding`);
+            logger_1.logger.debug(`[AntigravityLauncher] OK — Port ${port} responding`);
             return;
         }
     }
@@ -83,7 +84,7 @@ async function ensureAntigravityRunning() {
     logger_1.logger.warn('  Please run AntigravityDebug.command before starting the Bot');
     logger_1.logger.warn('');
     logger_1.logger.warn('  Or manually:');
-    logger_1.logger.warn('    open -a Antigravity --args --remote-debugging-port=9222');
+    logger_1.logger.warn(`    ${(0, pathUtils_1.getAntigravityCdpHint)(9222)}`);
     logger_1.logger.warn('='.repeat(70));
     logger_1.logger.warn('');
 }

package/dist/services/approvalDetector.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApprovalDetector = void 0;
+exports.buildClickScript = buildClickScript;
 const logger_1 = require("../utils/logger");
 /**
  * Approval button detection script for the Antigravity UI
@@ -205,6 +206,7 @@ class ApprovalDetector {
     cdpService;
     pollIntervalMs;
     onApprovalRequired;
+    onResolved;
     pollTimer = null;
     isRunning = false;
     /** Key of the last detected button info (for duplicate notification prevention) */
@@ -215,6 +217,7 @@ class ApprovalDetector {
         this.cdpService = options.cdpService;
         this.pollIntervalMs = options.pollIntervalMs ?? 1500;
         this.onApprovalRequired = options.onApprovalRequired;
+        this.onResolved = options.onResolved;
     }
     /**
      * Start monitoring.
@@ -285,8 +288,12 @@ class ApprovalDetector {
             }
             else {
                 // Reset when buttons disappear (prepare for next approval detection)
+                const wasDetected = this.lastDetectedKey !== null;
                 this.lastDetectedKey = null;
                 this.lastDetectedInfo = null;
+                if (wasDetected && this.onResolved) {
+                    this.onResolved();
+                }
             }
         }
         catch (error) {