lazy-gravity 0.10.0 → 0.12.0

package/dist/handlers/fileChangeButtonAction.js

@@ -4,7 +4,7 @@ exports.createFileChangeButtonAction = createFileChangeButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
-const approvalDetector_1 = require("../services/approvalDetector");
+const questionActionUtils_1 = require("../utils/questionActionUtils");
 function createFileChangeButtonAction(deps) {
     return {
         match(customId) {
@@ -36,32 +36,20 @@ function createFileChangeButtonAction(deps) {
                 return;
             }
             const targetText = action === 'accept' ? 'Accept all' : 'Reject all';
-            try {
-                const result = await cdp.call('Runtime.evaluate', {
-                    expression: (0, approvalDetector_1.buildClickScript)(targetText),
-                    returnByValue: true,
-                    awaitPromise: true,
+            const success = await (0, questionActionUtils_1.executeBrowserClick)(cdp, targetText);
+            if (success) {
+                await interaction
+                    .update({
+                    text: `${action === 'accept' ? '✅ Accepted' : '❌ Rejected'} file changes.`,
+                    components: [],
+                })
+                    .catch((err) => {
+                    logger_1.logger.warn('[FileChangeAction] update failed:', err);
                 });
-                if (result?.result?.value?.ok) {
-                    await interaction
-                        .update({
-                        text: `${action === 'accept' ? '✅ Accepted' : '❌ Rejected'} file changes.`,
-                        components: [],
-                    })
-                        .catch((err) => {
-                        logger_1.logger.warn('[FileChangeAction] update failed:', err);
-                    });
-                }
-                else {
-                    await interaction
-                        .followUp({ text: `Could not find the "${targetText}" button in the IDE. The file change prompt may have been dismissed.` })
-                        .catch(() => { });
-                }
             }
-            catch (error) {
-                logger_1.logger.error('[FileChangeAction] Error clicking button:', error);
+            else {
                 await interaction
-                    .followUp({ text: 'An error occurred while interacting with the IDE.' })
+                    .followUp({ text: `Could not find the "${targetText}" button in the IDE. The file change prompt may have been dismissed.` })
                     .catch(() => { });
             }
         },

package/dist/handlers/genericActionButtonAction.js

@@ -4,14 +4,7 @@ exports.parseGenericActionCustomId = parseGenericActionCustomId;
 exports.createGenericActionButtonAction = createGenericActionButtonAction;
 const logger_1 = require("../utils/logger");
 const projectResolver_1 = require("../utils/projectResolver");
-const approvalDetector_1 = require("../services/approvalDetector");
-/**
- * Parses a generic action button customId into its components.
- * Format: action_btn_[action_name]:[project_name]:[channel_id]
- *
- * @param customId The customId to parse
- * @returns Parsed action details, or null if not an action button
- */
+const questionActionUtils_1 = require("../utils/questionActionUtils");
 function parseGenericActionCustomId(customId) {
     if (!customId.startsWith('action_btn_'))
         return null;
@@ -19,10 +12,15 @@ function parseGenericActionCustomId(customId) {
     const actionName = parts[0].replace('action_btn_', '').replace(/_/g, ' ');
     // Capitalize first letter
     const formattedName = actionName.charAt(0).toUpperCase() + actionName.slice(1);
+    if (parts.length < 3) {
+        return { actionName: formattedName };
+    }
+    const channelId = parts[parts.length - 1];
+    const projectName = parts.slice(1, parts.length - 1).join(':');
     return {
         actionName: formattedName,
-        projectName: parts[1] || undefined,
-        channelId: parts[2] || undefined,
+        projectName: projectName || undefined,
+        channelId: channelId || undefined,
     };
 }
 function createGenericActionButtonAction(deps) {
@@ -42,12 +40,17 @@ function createGenericActionButtonAction(deps) {
             const actionName = params.actionName;
             const channelId = params.channelId || interaction.channel?.id;
             if (!channelId) {
+                await interaction.reply({
+                    text: 'Error: Cannot resolve channel ID.',
+                    ephemeral: true,
+                }).catch(() => { });
                 return;
             }
             const projectName = (0, projectResolver_1.resolveProjectName)(deps, channelId, params.projectName);
             await interaction.deferUpdate().catch(() => { });
+            const accountName = deps.bridge.selectedAccountByChannel?.get(channelId) || 'default';
             const cdp = projectName
-                ? deps.bridge.pool.getConnected(projectName)
+                ? deps.bridge.pool.getConnected(projectName, accountName)
                 : null;
             if (!cdp) {
                 await interaction.followUp({
@@ -57,13 +60,8 @@ function createGenericActionButtonAction(deps) {
             }
             // Simulate DOM click instead of chat injection
             logger_1.logger.info(`[GenericActionButton] Clicking action button "${actionName}" via DOM script`);
-            const script = (0, approvalDetector_1.buildClickScript)(actionName);
-            const evalResult = await cdp.call('Runtime.evaluate', {
-                expression: script,
-                returnByValue: true,
-            });
-            const resultValue = evalResult.result?.value;
-            if (!resultValue?.ok) {
+            const success = await (0, questionActionUtils_1.executeBrowserClick)(cdp, actionName);
+            if (!success) {
                 await interaction.followUp({
                     text: `Failed to execute action: Button "${actionName}" not found or obscured.`,
                 }).catch(() => { });

package/dist/handlers/planningButtonAction.js

@@ -5,11 +5,48 @@
  * Handles Open / Proceed button presses for the planning mode dialog
  * from both Discord and Telegram using the ButtonAction interface.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPlanningButtonAction = createPlanningButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const pathUtils_1 = require("../utils/pathUtils");
 const MAX_PLAN_CONTENT = 4096;
 function createPlanningButtonAction(deps) {
     return {
@@ -25,11 +62,10 @@ function createPlanningButtonAction(deps) {
         },
         async execute(interaction, params) {
             const { action, channelId } = params;
-            // Acknowledge immediately so Telegram doesn't time out
-            await interaction.deferUpdate().catch(() => { });
             if (channelId && channelId !== interaction.channel.id) {
+                await interaction.deferUpdate().catch(() => { });
                 await interaction
-                    .reply({ text: 'This planning action is linked to a different session channel.' })
+                    .followUp({ text: 'This planning action is linked to a different session channel.', ephemeral: true })
                     .catch(() => { });
                 return;
             }
@@ -38,14 +74,42 @@ function createPlanningButtonAction(deps) {
                 ? deps.bridge.pool.getPlanningDetector(projectName)
                 : undefined;
             if (!detector) {
+                await interaction.deferUpdate().catch(() => { });
                 await interaction
-                    .reply({ text: 'Planning detector not found.' })
+                    .followUp({ text: 'Planning detector not found.', ephemeral: true })
                     .catch(() => { });
                 return;
             }
             if (action === 'open') {
+                const info = detector.getLastDetectedInfo();
+                const isReview = info?.openText?.toLowerCase().includes('review');
+                let modalFailed = false;
+                if (isReview && interaction.showModal) {
+                    try {
+                        await interaction.showModal({
+                            title: 'Submit Comment',
+                            customId: `plan_comment_${projectName || ''}_${channelId}`,
+                            components: [{
+                                    components: [{
+                                            type: 'textInput',
+                                            customId: 'comment',
+                                            label: 'Add a message...',
+                                            style: 'paragraph',
+                                            required: false
+                                        }]
+                                }]
+                        });
+                        return;
+                    }
+                    catch (err) {
+                        logger_1.logger.error('[PlanningAction] showModal failed:', err);
+                        modalFailed = true;
+                    }
+                }
+                // Acknowledge if we didn't show a modal
+                await interaction.deferUpdate().catch(() => { });
                 let clicked = false;
-                if (detector.getLastDetectedInfo()?.hasOpenButton) {
+                if (info?.hasOpenButton && (!isReview || modalFailed)) {
                     try {
                         clicked = await detector.clickOpenButton();
                         if (clicked) {
@@ -56,7 +120,8 @@ function createPlanningButtonAction(deps) {
                         logger_1.logger.error('[PlanningAction] clickOpenButton failed:', e);
                     }
                 }
-                // Extract plan content with retry
+                // Since we only come here if it's NOT a review (or modal failed),
+                // we can just extract plan content and followUp
                 let planContent = null;
                 for (let attempt = 0; attempt < 3; attempt++) {
                     planContent = await detector.extractPlanContent();
@@ -64,22 +129,42 @@ function createPlanningButtonAction(deps) {
                         break;
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
+                if (!planContent && !clicked) {
+                    // Fallback to reading implementation_plan.md from the workspace
+                    const workspaceId = deps.wsHandler.getWorkspaceForChannel(interaction.channel.id);
+                    if (workspaceId) {
+                        const planFile = path.join(workspaceId, 'implementation_plan.md');
+                        if (fs.existsSync(planFile)) {
+                            try {
+                                planContent = fs.readFileSync(planFile, 'utf8');
+                                // Proactively open the file in the IDE
+                                (0, child_process_1.execFile)((0, pathUtils_1.getAntigravityCliPath)(), [planFile], (err) => {
+                                    if (err)
+                                        logger_1.logger.error(`[PlanningAction] Failed to open plan via CLI: ${err.message}`);
+                                });
+                            }
+                            catch (err) {
+                                logger_1.logger.error(`[PlanningAction] Failed to read plan file: ${err.message}`);
+                            }
+                        }
+                    }
+                }
                 if (!planContent && !clicked) {
                     await interaction
-                        .reply({ text: 'Plan content could not be extracted from the IDE.' })
+                        .followUp({ text: 'Plan content could not be extracted from the IDE or workspace.' })
                         .catch(() => { });
                     return;
                 }
                 await interaction
-                    .update({
+                    .editReply({
                     text: '📋 Plan opened',
                     components: [],
                 })
                     .catch((err) => {
-                    logger_1.logger.warn('[PlanningAction] update failed:', err);
+                    logger_1.logger.warn('[PlanningAction] editReply failed:', err);
                 });
                 if (planContent) {
-                    const truncated = planContent.length > MAX_PLAN_CONTENT
+                    let truncated = planContent.length > MAX_PLAN_CONTENT
                         ? planContent.substring(0, MAX_PLAN_CONTENT - 15) + '\n\n(truncated)'
                         : planContent;
                     await interaction
@@ -90,13 +175,16 @@ function createPlanningButtonAction(deps) {
                 }
                 else {
                     await interaction
-                        .followUp({ text: 'Could not extract plan content from the editor.' })
-                        .catch(() => { });
+                        .followUp({ text: 'Plan opened in IDE, but content could not be extracted.' })
+                        .catch((err) => {
+                        logger_1.logger.warn('[PlanningAction] followUp failed:', err);
+                    });
                 }
             }
             else if (action === 'reject') {
+                await interaction.deferUpdate().catch(() => { });
                 // Reject action
-                await interaction.reply({ text: 'Rejection of the plan is not allowed.' }).catch(() => { });
+                await interaction.followUp({ text: 'Rejection of the plan is not allowed.', ephemeral: true }).catch(() => { });
                 return;
             }
             else {
@@ -114,17 +202,17 @@ function createPlanningButtonAction(deps) {
                 }
                 if (clicked) {
                     await interaction
-                        .update({
-                        text: '▶️ Proceed started',
+                        .editReply({
+                        text: '▶️ Proceed started.\n\n⏳ IDE is working on the response...',
                         components: [],
                     })
                         .catch((err) => {
-                        logger_1.logger.warn('[PlanningAction] update failed:', err);
+                        logger_1.logger.warn('[PlanningAction] editReply failed:', err);
                     });
                 }
                 else {
                     await interaction
-                        .reply({ text: 'Proceed button not found.' })
+                        .followUp({ text: 'Proceed button not found.', ephemeral: true })
                         .catch(() => { });
                 }
             }

package/dist/handlers/planningModalSubmitAction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = execute;
+const i18n_1 = require("../utils/i18n");
+const logger_1 = require("../utils/logger");
+async function execute(interaction, projectName, pool, accountName) {
+    try {
+        if (!projectName) {
+            await interaction.reply({ text: (0, i18n_1.t)('Project name not found.'), ephemeral: true });
+            return;
+        }
+        const cdp = pool.getConnected(projectName, accountName);
+        if (!cdp) {
+            await interaction.reply({ text: (0, i18n_1.t)('Not connected to workspace.'), ephemeral: true });
+            return;
+        }
+        const comment = interaction.fields.get('comment')?.trim();
+        if (!comment) {
+            await interaction.reply({ text: (0, i18n_1.t)('Comment cannot be empty.'), ephemeral: true });
+            return;
+        }
+        await interaction.deferUpdate();
+        // Inject the comment into the chat
+        const result = await cdp.injectMessage(comment);
+        if (!result.ok) {
+            await interaction.followUp({ text: (0, i18n_1.t)('Failed to submit comment: {{error}}', { error: result.error }), ephemeral: true });
+            return;
+        }
+        await interaction.followUp({ text: (0, i18n_1.t)('Comment submitted to the plan successfully.'), ephemeral: true });
+    }
+    catch (error) {
+        logger_1.logger.error('[PlanningModalSubmit] Error:', error);
+        try {
+            await interaction.followUp({ text: (0, i18n_1.t)('An error occurred while submitting your comment.'), ephemeral: true });
+        }
+        catch { /* ignore */ }
+    }
+}

package/dist/handlers/questionSelectAction.js

@@ -13,16 +13,16 @@ function createQuestionSelectAction(deps) {
         async execute(interaction, values) {
             const parsed = (0, questionActionUtils_1.parseQuestionCustomId)(interaction.customId, notificationSender_1.QUESTION_SELECT_ACTION_PREFIX);
             if (!parsed)
-                return;
+                return false;
             const selectedOption = parseInt(values[0], 10);
             if (isNaN(selectedOption))
-                return;
+                return false;
             const channelId = parsed.channelId;
             if (channelId && channelId !== interaction.channel.id) {
                 await interaction
                     .reply({ text: 'This question is linked to a different session channel.', ephemeral: true })
                     .catch(() => { });
-                return;
+                return false;
             }
             const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, parsed.projectName);
             logger_1.logger.debug(`[QuestionSelectAction] project=${projectName ?? 'null'} channel=${interaction.channel.id}`);
@@ -34,7 +34,7 @@ function createQuestionSelectAction(deps) {
                 await interaction
                     .reply({ text: 'Question detector not found.', ephemeral: true })
                     .catch(() => { });
-                return;
+                return false;
             }
             await interaction.deferUpdate().catch(() => { });
             let success = false;
@@ -47,16 +47,16 @@ function createQuestionSelectAction(deps) {
                 await interaction
                     .followUp({ text: `Failed to answer question: ${msg}`, ephemeral: true })
                     .catch(() => { });
-                return;
+                return false;
             }
             if (success) {
-                const updatePayload = { text: `✅ Submitted option ${selectedOption + 1}`, components: [] };
+                const updatePayload = { text: `✅ Submitted option ${selectedOption + 1}.\n\n⏳ IDE is working on the response...`, components: [] };
                 try {
                     await interaction.editReply(updatePayload);
                 }
                 catch (editErr) {
                     logger_1.logger.warn('[QuestionSelectAction] editReply failed, sending followUp:', editErr);
-                    await interaction.followUp({ text: `✅ Submitted option ${selectedOption + 1}` }).catch(() => { });
+                    await interaction.followUp({ text: `✅ Submitted option ${selectedOption + 1}.\n\n⏳ IDE is working on the response...` }).catch(() => { });
                 }
             }
             else {
@@ -64,6 +64,7 @@ function createQuestionSelectAction(deps) {
                     .followUp({ text: 'Failed to answer question (it may have been resolved already).', ephemeral: true })
                     .catch(() => { });
             }
+            return success;
         },
     };
 }

package/dist/handlers/questionSkipAction.js

@@ -14,13 +14,13 @@ function createQuestionSkipAction(deps) {
         async execute(interaction, params) {
             const parsed = (0, questionActionUtils_1.parseQuestionCustomId)(interaction.customId, notificationSender_1.QUESTION_SKIP_ACTION_PREFIX);
             if (!parsed)
-                return;
+                return false;
             const channelId = parsed.channelId;
             if (channelId && channelId !== interaction.channel.id) {
                 await interaction
                     .reply({ text: 'This question is linked to a different session channel.', ephemeral: true })
                     .catch(() => { });
-                return;
+                return false;
             }
             const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, parsed.projectName);
             logger_1.logger.debug(`[QuestionSkipAction] project=${projectName ?? 'null'} channel=${interaction.channel.id}`);
@@ -32,7 +32,7 @@ function createQuestionSkipAction(deps) {
                 await interaction
                     .reply({ text: 'Question detector not found.', ephemeral: true })
                     .catch(() => { });
-                return;
+                return false;
             }
             await interaction.deferUpdate().catch(() => { });
             let success = false;
@@ -45,16 +45,16 @@ function createQuestionSkipAction(deps) {
                 await interaction
                     .followUp({ text: `Failed to skip question: ${msg}`, ephemeral: true })
                     .catch(() => { });
-                return;
+                return false;
             }
             if (success) {
-                const updatePayload = { text: `✅ Skipped question`, components: [] };
+                const updatePayload = { text: '✅ Skipped question.\n\n⏳ IDE is working on the response...', components: [] };
                 try {
                     await interaction.editReply(updatePayload);
                 }
                 catch (editErr) {
                     logger_1.logger.warn('[QuestionSkipAction] editReply failed, sending followUp:', editErr);
-                    await interaction.followUp({ text: `✅ Skipped question` }).catch(() => { });
+                    await interaction.followUp({ text: '✅ Skipped question.\n\n⏳ IDE is working on the response...' }).catch(() => { });
                 }
             }
             else {
@@ -62,6 +62,7 @@ function createQuestionSkipAction(deps) {
                     .followUp({ text: 'Failed to skip question (it may have been resolved already).', ephemeral: true })
                     .catch(() => { });
             }
+            return success;
         },
     };
 }

package/dist/platform/discord/wrappers.js

@@ -15,6 +15,7 @@ exports.wrapDiscordMessage = wrapDiscordMessage;
 exports.wrapDiscordButton = wrapDiscordButton;
 exports.wrapDiscordSelect = wrapDiscordSelect;
 exports.wrapDiscordCommand = wrapDiscordCommand;
+exports.wrapDiscordModalSubmit = wrapDiscordModalSubmit;
 const discord_js_1 = require("discord.js");
 // ---------------------------------------------------------------------------
 // Style mapping
@@ -107,6 +108,32 @@ function toDiscordComponents(rows) {
         return actionRow;
     });
 }
+/**
+ * Convert a platform ModalDef to a discord.js ModalBuilder.
+ */
+function toDiscordModal(modal) {
+    const builder = new discord_js_1.ModalBuilder()
+        .setCustomId(modal.customId)
+        .setTitle(modal.title);
+    for (const row of modal.components) {
+        const actionRow = new discord_js_1.ActionRowBuilder();
+        for (const comp of row.components) {
+            const input = new discord_js_1.TextInputBuilder()
+                .setCustomId(comp.customId)
+                .setLabel(comp.label)
+                .setStyle(comp.style === 'paragraph' ? discord_js_1.TextInputStyle.Paragraph : discord_js_1.TextInputStyle.Short);
+            if (comp.placeholder !== undefined) {
+                input.setPlaceholder(comp.placeholder);
+            }
+            if (comp.required !== undefined) {
+                input.setRequired(comp.required);
+            }
+            actionRow.addComponents(input);
+        }
+        builder.addComponents(actionRow);
+    }
+    return builder;
+}
 /**
  * Convert a platform MessagePayload to discord.js message send/reply options.
  *
@@ -256,6 +283,9 @@ function wrapDiscordButton(interaction) {
             const sent = await interaction.followUp(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
             return wrapDiscordSentMessage(sent);
         },
+        async showModal(modal) {
+            await interaction.showModal(toDiscordModal(modal));
+        },
     };
 }
 /** Wrap a discord.js StringSelectMenuInteraction as a PlatformSelectInteraction. */
@@ -329,3 +359,49 @@ function wrapDiscordCommand(interaction) {
         },
     };
 }
+/** Wrap a discord.js ModalSubmitInteraction as a PlatformModalSubmitInteraction. */
+function wrapDiscordModalSubmit(interaction) {
+    const user = wrapDiscordUser(interaction.user);
+    const channel = interaction.channel
+        ? wrapDiscordChannel(interaction.channel)
+        : buildFallbackChannel(interaction.channelId ?? 'unknown');
+    const fields = new Map();
+    for (const [key, field] of interaction.fields.fields.entries()) {
+        fields.set(key, interaction.fields.getTextInputValue(key));
+    }
+    return {
+        id: interaction.id,
+        platform: 'discord',
+        customId: interaction.customId,
+        user,
+        channel,
+        messageId: interaction.message?.id ?? null,
+        fields,
+        async deferUpdate() {
+            if (interaction.isFromMessage()) {
+                await interaction.deferUpdate();
+            }
+            else {
+                await interaction.deferReply({ ephemeral: true });
+            }
+        },
+        async reply(payload) {
+            await interaction.reply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async update(payload) {
+            if (interaction.isFromMessage()) {
+                await interaction.update(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            }
+            else {
+                await interaction.reply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            }
+        },
+        async editReply(payload) {
+            await interaction.editReply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async followUp(payload) {
+            const sent = await interaction.followUp(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            return wrapDiscordSentMessage(sent);
+        },
+    };
+}