lazy-gravity 0.4.0 → 0.5.0

package/dist/bot/index.js

@@ -92,6 +92,7 @@ const selectHandler_1 = require("../handlers/selectHandler");
 const approvalButtonAction_1 = require("../handlers/approvalButtonAction");
 const planningButtonAction_1 = require("../handlers/planningButtonAction");
 const errorPopupButtonAction_1 = require("../handlers/errorPopupButtonAction");
+const runCommandButtonAction_1 = require("../handlers/runCommandButtonAction");
 const modelButtonAction_1 = require("../handlers/modelButtonAction");
 const autoAcceptButtonAction_1 = require("../handlers/autoAcceptButtonAction");
 const templateButtonAction_1 = require("../handlers/templateButtonAction");
@@ -831,6 +832,7 @@ const startBot = async (cliLogLevel) => {
                 parseApprovalCustomId: cdpBridgeManager_1.parseApprovalCustomId,
                 parseErrorPopupCustomId: cdpBridgeManager_1.parseErrorPopupCustomId,
                 parsePlanningCustomId: cdpBridgeManager_1.parsePlanningCustomId,
+                parseRunCommandCustomId: cdpBridgeManager_1.parseRunCommandCustomId,
                 joinHandler,
                 userPrefRepo,
                 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, joinHandler, userPrefRepo),
@@ -862,6 +864,7 @@ const startBot = async (cliLogLevel) => {
                             (0, cdpBridgeManager_1.ensureApprovalDetector)(bridge, cdp, projectName);
                             (0, cdpBridgeManager_1.ensureErrorPopupDetector)(bridge, cdp, projectName);
                             (0, cdpBridgeManager_1.ensurePlanningDetector)(bridge, cdp, projectName);
+                            (0, cdpBridgeManager_1.ensureRunCommandDetector)(bridge, cdp, projectName);
                         }
                         catch (e) {
                             await interaction.followUp({
@@ -998,6 +1001,7 @@ const startBot = async (cliLogLevel) => {
                     (0, approvalButtonAction_1.createApprovalButtonAction)({ bridge }),
                     (0, planningButtonAction_1.createPlanningButtonAction)({ bridge }),
                     (0, errorPopupButtonAction_1.createErrorPopupButtonAction)({ bridge }),
+                    (0, runCommandButtonAction_1.createRunCommandButtonAction)({ bridge }),
                     (0, modelButtonAction_1.createModelButtonAction)({ bridge, fetchQuota: () => bridge.quota.fetchQuota(), modelService, userPrefRepo }),
                     (0, autoAcceptButtonAction_1.createAutoAcceptButtonAction)({ autoAcceptService: bridge.autoAccept }),
                     (0, templateButtonAction_1.createTemplateButtonAction)({ bridge, templateRepo }),

package/dist/bot/telegramMessageHandler.js

@@ -134,6 +134,7 @@ function createTelegramMessageHandler(deps) {
             (0, cdpBridgeManager_1.ensureApprovalDetector)(deps.bridge, cdp, projectName);
             (0, cdpBridgeManager_1.ensureErrorPopupDetector)(deps.bridge, cdp, projectName);
             (0, cdpBridgeManager_1.ensurePlanningDetector)(deps.bridge, cdp, projectName);
+            (0, cdpBridgeManager_1.ensureRunCommandDetector)(deps.bridge, cdp, projectName);
             // Acknowledge receipt
             await message.react('\u{1F440}').catch(() => { });
             // Download image attachments if present

package/dist/events/interactionCreateHandler.js

@@ -366,6 +366,72 @@ function createInteractionCreateHandler(deps) {
                     }
                     return;
                 }
+                const runCommandAction = deps.parseRunCommandCustomId(interaction.customId);
+                if (runCommandAction) {
+                    if (runCommandAction.channelId && runCommandAction.channelId !== interaction.channelId) {
+                        await interaction.reply({
+                            content: (0, i18n_1.t)('This run command action is linked to a different session channel.'),
+                            flags: discord_js_1.MessageFlags.Ephemeral,
+                        }).catch(logger_1.logger.error);
+                        return;
+                    }
+                    const runCmdWorkspace = runCommandAction.projectName ?? deps.bridge.lastActiveWorkspace;
+                    const runCmdDetector = runCmdWorkspace
+                        ? deps.bridge.pool.getRunCommandDetector(runCmdWorkspace)
+                        : undefined;
+                    if (!runCmdDetector) {
+                        try {
+                            await interaction.reply({ content: (0, i18n_1.t)('Run command detector not found.'), flags: discord_js_1.MessageFlags.Ephemeral });
+                        }
+                        catch { /* ignore */ }
+                        return;
+                    }
+                    let success = false;
+                    let actionLabel = '';
+                    if (runCommandAction.action === 'run') {
+                        success = await runCmdDetector.runButton();
+                        actionLabel = (0, i18n_1.t)('Run');
+                    }
+                    else {
+                        success = await runCmdDetector.rejectButton();
+                        actionLabel = (0, i18n_1.t)('Reject');
+                    }
+                    try {
+                        if (success) {
+                            const originalEmbed = interaction.message.embeds[0];
+                            const updatedEmbed = originalEmbed
+                                ? discord_js_1.EmbedBuilder.from(originalEmbed)
+                                : new discord_js_1.EmbedBuilder().setTitle('Run Command');
+                            const historyText = `${actionLabel} by <@${interaction.user.id}> (${new Date().toLocaleString('ja-JP')})`;
+                            updatedEmbed
+                                .setColor(runCommandAction.action === 'reject' ? 0xE74C3C : 0x2ECC71)
+                                .addFields({ name: 'Action History', value: historyText, inline: false })
+                                .setTimestamp();
+                            await interaction.update({
+                                embeds: [updatedEmbed],
+                                components: (0, discordButtonUtils_1.disableAllButtons)(interaction.message.components),
+                            });
+                        }
+                        else {
+                            await interaction.reply({ content: (0, i18n_1.t)('Run command button not found.'), flags: discord_js_1.MessageFlags.Ephemeral });
+                        }
+                    }
+                    catch (interactionError) {
+                        if (interactionError?.code === 10062 || interactionError?.code === 40060) {
+                            logger_1.logger.warn('[RunCommand] Interaction expired. Responding directly in the channel.');
+                            if (interaction.channel && 'send' in interaction.channel) {
+                                const fallbackMessage = success
+                                    ? `${actionLabel} completed.`
+                                    : (0, i18n_1.t)('Run command button not found.');
+                                await interaction.channel.send(fallbackMessage).catch(logger_1.logger.error);
+                            }
+                        }
+                        else {
+                            throw interactionError;
+                        }
+                    }
+                    return;
+                }
                 if (interaction.customId === cleanupCommandHandler_1.CLEANUP_ARCHIVE_BTN) {
                     await deps.cleanupHandler.handleArchive(interaction);
                     return;

package/dist/events/messageCreateHandler.js

@@ -14,6 +14,7 @@ function createMessageCreateHandler(deps) {
     const ensureApprovalDetector = deps.ensureApprovalDetector ?? cdpBridgeManager_1.ensureApprovalDetector;
     const ensureErrorPopupDetector = deps.ensureErrorPopupDetector ?? cdpBridgeManager_1.ensureErrorPopupDetector;
     const ensurePlanningDetector = deps.ensurePlanningDetector ?? cdpBridgeManager_1.ensurePlanningDetector;
+    const ensureRunCommandDetector = deps.ensureRunCommandDetector ?? cdpBridgeManager_1.ensureRunCommandDetector;
     const registerApprovalWorkspaceChannel = deps.registerApprovalWorkspaceChannel ?? cdpBridgeManager_1.registerApprovalWorkspaceChannel;
     const registerApprovalSessionChannel = deps.registerApprovalSessionChannel ?? cdpBridgeManager_1.registerApprovalSessionChannel;
     const downloadInboundImageAttachments = deps.downloadInboundImageAttachments ?? imageHandler_1.downloadInboundImageAttachments;
@@ -170,6 +171,7 @@ function createMessageCreateHandler(deps) {
                             ensureApprovalDetector(deps.bridge, cdp, projectName);
                             ensureErrorPopupDetector(deps.bridge, cdp, projectName);
                             ensurePlanningDetector(deps.bridge, cdp, projectName);
+                            ensureRunCommandDetector(deps.bridge, cdp, projectName);
                             const session = deps.chatSessionRepo.findByChannelId(message.channelId);
                             if (session?.displayName) {
                                 registerApprovalSessionChannel(deps.bridge, projectName, session.displayName, platformChannel);

package/dist/handlers/runCommandButtonAction.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Platform-agnostic run command button action.
+ *
+ * Handles Run / Reject button presses for the "Run command?"
+ * dialog from both Discord and Telegram using the ButtonAction interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunCommandButtonAction = createRunCommandButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const logger_1 = require("../utils/logger");
+function createRunCommandButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = (0, cdpBridgeManager_1.parseRunCommandCustomId)(customId);
+            if (!parsed)
+                return null;
+            return {
+                action: parsed.action,
+                projectName: parsed.projectName ?? '',
+                channelId: parsed.channelId ?? '',
+            };
+        },
+        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
+                    .reply({ text: 'This run command action is linked to a different session channel.' })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const detector = projectName
+                ? deps.bridge.pool.getRunCommandDetector(projectName)
+                : undefined;
+            if (!detector) {
+                logger_1.logger.warn(`[RunCommandAction] No detector for project=${projectName}`);
+                await interaction
+                    .reply({ text: 'Run command detector not found.' })
+                    .catch(() => { });
+                return;
+            }
+            let success = false;
+            let actionLabel = '';
+            try {
+                if (action === 'run') {
+                    success = await detector.runButton();
+                    actionLabel = 'Run';
+                }
+                else {
+                    success = await detector.rejectButton();
+                    actionLabel = 'Reject';
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger_1.logger.error(`[RunCommandAction] CDP click failed: ${msg}`);
+                await interaction
+                    .reply({ text: `Run command action failed: ${msg}` })
+                    .catch(() => { });
+                return;
+            }
+            if (success) {
+                await interaction
+                    .update({ text: `${action === 'run' ? '▶️' : '⛔'} ${actionLabel} completed`, components: [] })
+                    .catch((err) => {
+                    logger_1.logger.warn('[RunCommandAction] update failed, trying editReply:', err);
+                    interaction.editReply({ text: `${action === 'run' ? '▶️' : '⛔'} ${actionLabel} completed`, components: [] })
+                        .catch((editErr) => {
+                        logger_1.logger.warn('[RunCommandAction] editReply failed, sending followUp:', editErr);
+                        interaction.followUp({ text: `${action === 'run' ? '▶️' : '⛔'} ${actionLabel} completed` }).catch(() => { });
+                    });
+                });
+            }
+            else {
+                await interaction
+                    .reply({ text: 'Run command button not found.' })
+                    .catch(() => { });
+            }
+        },
+    };
+}

package/dist/services/cdpBridgeManager.js

@@ -10,11 +10,14 @@ exports.buildPlanningCustomId = buildPlanningCustomId;
 exports.parsePlanningCustomId = parsePlanningCustomId;
 exports.buildErrorPopupCustomId = buildErrorPopupCustomId;
 exports.parseErrorPopupCustomId = parseErrorPopupCustomId;
+exports.buildRunCommandCustomId = buildRunCommandCustomId;
+exports.parseRunCommandCustomId = parseRunCommandCustomId;
 exports.initCdpBridge = initCdpBridge;
 exports.getCurrentCdp = getCurrentCdp;
 exports.ensureApprovalDetector = ensureApprovalDetector;
 exports.ensurePlanningDetector = ensurePlanningDetector;
 exports.ensureErrorPopupDetector = ensureErrorPopupDetector;
+exports.ensureRunCommandDetector = ensureRunCommandDetector;
 exports.ensureUserMessageDetector = ensureUserMessageDetector;
 const i18n_1 = require("../utils/i18n");
 const logger_1 = require("../utils/logger");
@@ -24,6 +27,7 @@ const autoAcceptService_1 = require("./autoAcceptService");
 const cdpConnectionPool_1 = require("./cdpConnectionPool");
 const errorPopupDetector_1 = require("./errorPopupDetector");
 const planningDetector_1 = require("./planningDetector");
+const runCommandDetector_1 = require("./runCommandDetector");
 const quotaService_1 = require("./quotaService");
 const userMessageDetector_1 = require("./userMessageDetector");
 const APPROVE_ACTION_PREFIX = 'approve_action';
@@ -34,6 +38,8 @@ const PLANNING_PROCEED_ACTION_PREFIX = 'planning_proceed_action';
 const ERROR_POPUP_DISMISS_ACTION_PREFIX = 'error_popup_dismiss_action';
 const ERROR_POPUP_COPY_DEBUG_ACTION_PREFIX = 'error_popup_copy_debug_action';
 const ERROR_POPUP_RETRY_ACTION_PREFIX = 'error_popup_retry_action';
+const RUN_COMMAND_RUN_ACTION_PREFIX = 'run_command_run_action';
+const RUN_COMMAND_REJECT_ACTION_PREFIX = 'run_command_reject_action';
 function normalizeSessionTitle(title) {
     return title.trim().toLowerCase();
 }
@@ -194,6 +200,34 @@ function parseErrorPopupCustomId(customId) {
     }
     return null;
 }
+function buildRunCommandCustomId(action, projectName, channelId) {
+    const prefix = action === 'run'
+        ? RUN_COMMAND_RUN_ACTION_PREFIX
+        : RUN_COMMAND_REJECT_ACTION_PREFIX;
+    if (channelId && channelId.trim().length > 0) {
+        return `${prefix}:${projectName}:${channelId}`;
+    }
+    return `${prefix}:${projectName}`;
+}
+function parseRunCommandCustomId(customId) {
+    if (customId === RUN_COMMAND_RUN_ACTION_PREFIX) {
+        return { action: 'run', projectName: null, channelId: null };
+    }
+    if (customId === RUN_COMMAND_REJECT_ACTION_PREFIX) {
+        return { action: 'reject', projectName: null, channelId: null };
+    }
+    if (customId.startsWith(`${RUN_COMMAND_RUN_ACTION_PREFIX}:`)) {
+        const rest = customId.substring(`${RUN_COMMAND_RUN_ACTION_PREFIX}:`.length);
+        const [projectName, channelId] = rest.split(':');
+        return { action: 'run', projectName: projectName || null, channelId: channelId || null };
+    }
+    if (customId.startsWith(`${RUN_COMMAND_REJECT_ACTION_PREFIX}:`)) {
+        const rest = customId.substring(`${RUN_COMMAND_REJECT_ACTION_PREFIX}:`.length);
+        const [projectName, channelId] = rest.split(':');
+        return { action: 'reject', projectName: projectName || null, channelId: channelId || null };
+    }
+    return null;
+}
 /** Initialize the CDP bridge (lazy connection: pool creation only) */
 function initCdpBridge(autoApproveDefault) {
     const pool = new cdpConnectionPool_1.CdpConnectionPool({
@@ -412,6 +446,74 @@ function ensureErrorPopupDetector(bridge, cdp, projectName) {
     bridge.pool.registerErrorPopupDetector(projectName, detector);
     logger_1.logger.debug(`[ErrorPopupDetector:${projectName}] Started error popup detection`);
 }
+/**
+ * Helper to start a run command detector for each workspace.
+ * Detects "Run command?" confirmation dialogs and forwards them to Discord.
+ * Does nothing if a detector for the same workspace is already running.
+ */
+function ensureRunCommandDetector(bridge, cdp, projectName) {
+    const existing = bridge.pool.getRunCommandDetector(projectName);
+    if (existing && existing.isActive())
+        return;
+    let lastNotification = null;
+    const detector = new runCommandDetector_1.RunCommandDetector({
+        cdpService: cdp,
+        pollIntervalMs: 2000,
+        onResolved: () => {
+            if (!lastNotification)
+                return;
+            const { sent, payload } = lastNotification;
+            lastNotification = null;
+            const resolved = (0, notificationSender_1.buildResolvedOverlay)(payload, (0, i18n_1.t)('Resolved in Antigravity'));
+            sent.edit(resolved).catch(logger_1.logger.error);
+        },
+        onRunCommandRequired: async (info) => {
+            logger_1.logger.debug(`[RunCommandDetector:${projectName}] Run command detected`);
+            const currentChatTitle = await getCurrentChatTitle(cdp);
+            const targetChannel = resolveApprovalChannelForCurrentChat(bridge, projectName, currentChatTitle);
+            const targetChannelId = targetChannel ? targetChannel.id : '';
+            if (!targetChannel || !targetChannelId) {
+                logger_1.logger.warn(`[RunCommandDetector:${projectName}] Skipped run command notification because chat is not linked to a session` +
+                    `${currentChatTitle ? ` (title="${currentChatTitle}")` : ''}`);
+                return;
+            }
+            if (bridge.autoAccept.isEnabled()) {
+                const accepted = await detector.runButton();
+                const autoPayload = (0, notificationSender_1.buildAutoApprovedNotification)({
+                    accepted,
+                    projectName,
+                    description: `Run: ${info.commandText}`,
+                    approveText: info.runText ?? 'Run',
+                });
+                await targetChannel.send(autoPayload).catch(logger_1.logger.error);
+                if (accepted) {
+                    return;
+                }
+            }
+            const payload = (0, notificationSender_1.buildRunCommandNotification)({
+                title: (0, i18n_1.t)('Run Command?'),
+                commandText: info.commandText,
+                workingDirectory: info.workingDirectory,
+                projectName,
+                channelId: targetChannelId,
+                extraFields: [
+                    { name: (0, i18n_1.t)('Run button'), value: info.runText, inline: true },
+                    { name: (0, i18n_1.t)('Reject button'), value: info.rejectText, inline: true },
+                ],
+            });
+            const sent = await targetChannel.send(payload).catch((err) => {
+                logger_1.logger.error(err);
+                return null;
+            });
+            if (sent) {
+                lastNotification = { sent, payload };
+            }
+        },
+    });
+    detector.start();
+    bridge.pool.registerRunCommandDetector(projectName, detector);
+    logger_1.logger.debug(`[RunCommandDetector:${projectName}] Started run command detection`);
+}
 /**
  * Helper to start a user message detector for a workspace.
  * Detects messages typed directly in the Antigravity UI (e.g., from a PC)

package/dist/services/cdpConnectionPool.js

@@ -16,6 +16,7 @@ class CdpConnectionPool {
     approvalDetectors = new Map();
     errorPopupDetectors = new Map();
     planningDetectors = new Map();
+    runCommandDetectors = new Map();
     userMessageDetectors = new Map();
     connectingPromises = new Map();
     cdpOptions;
@@ -92,6 +93,11 @@ class CdpConnectionPool {
             planningDetector.stop();
             this.planningDetectors.delete(projectName);
         }
+        const runCmdDetector = this.runCommandDetectors.get(projectName);
+        if (runCmdDetector) {
+            runCmdDetector.stop();
+            this.runCommandDetectors.delete(projectName);
+        }
         const userMsgDetector = this.userMessageDetectors.get(projectName);
         if (userMsgDetector) {
             userMsgDetector.stop();
@@ -157,6 +163,22 @@ class CdpConnectionPool {
     getPlanningDetector(projectName) {
         return this.planningDetectors.get(projectName);
     }
+    /**
+     * Register a run command detector for a workspace.
+     */
+    registerRunCommandDetector(projectName, detector) {
+        const existing = this.runCommandDetectors.get(projectName);
+        if (existing && existing.isActive()) {
+            existing.stop();
+        }
+        this.runCommandDetectors.set(projectName, detector);
+    }
+    /**
+     * Get the run command detector for a workspace.
+     */
+    getRunCommandDetector(projectName) {
+        return this.runCommandDetectors.get(projectName);
+    }
     /**
      * Register a user message detector for a workspace.
      */
@@ -226,6 +248,11 @@ class CdpConnectionPool {
                 planDetector.stop();
                 this.planningDetectors.delete(projectName);
             }
+            const runCmdDetector = this.runCommandDetectors.get(projectName);
+            if (runCmdDetector) {
+                runCmdDetector.stop();
+                this.runCommandDetectors.delete(projectName);
+            }
             const userMsgDetector = this.userMessageDetectors.get(projectName);
             if (userMsgDetector) {
                 userMsgDetector.stop();

package/dist/services/chatSessionService.js

@@ -78,8 +78,11 @@ const SCRAPE_PAST_CONVERSATIONS_SCRIPT = `(() => {
     const isVisible = (el) => !!el && el instanceof HTMLElement && el.offsetParent !== null;
     const normalize = (text) => (text || '').trim();
 
-    // Scope to the side panel to avoid picking up file tab names
-    const panel = document.querySelector('.antigravity-agent-side-panel');
+    // Past Conversations opens as a floating QuickInput dialog, not inside the side panel.
+    // Try the visible QuickInput dialog first, then fall back to the side panel.
+    const quickInputPanels = Array.from(document.querySelectorAll('div[class*="bg-quickinput-background"]'));
+    const panel = quickInputPanels.find((el) => isVisible(el))
+        || document.querySelector('.antigravity-agent-side-panel');
     if (!panel) return null;
 
     const items = [];
@@ -136,7 +139,11 @@ const SCRAPE_PAST_CONVERSATIONS_SCRIPT = `(() => {
  */
 const FIND_SHOW_MORE_BUTTON_SCRIPT = `(() => {
     const isVisible = (el) => !!el && el instanceof HTMLElement && el.offsetParent !== null;
-    const els = Array.from(document.querySelectorAll('div, span'));
+    const quickInputPanels = Array.from(document.querySelectorAll('div[class*="bg-quickinput-background"]'));
+    const root = quickInputPanels.find((el) => isVisible(el))
+        || document.querySelector('.antigravity-agent-side-panel')
+        || document;
+    const els = Array.from(root.querySelectorAll('div, span'));
     for (const el of els) {
         if (!isVisible(el)) continue;
         const text = (el.textContent || '').trim();
@@ -454,7 +461,9 @@ class ChatSessionService {
             // Step 3: Wait for panel to render (poll for content, up to 3s)
             const PANEL_READY_CHECK = `(() => {
                 const isVisible = (el) => !!el && el instanceof HTMLElement && el.offsetParent !== null;
-                const panel = document.querySelector('.antigravity-agent-side-panel');
+                const quickInputPanels = Array.from(document.querySelectorAll('div[class*="bg-quickinput-background"]'));
+                const panel = quickInputPanels.find((el) => isVisible(el))
+                    || document.querySelector('.antigravity-agent-side-panel');
                 if (!panel) return false;
                 const containers = Array.from(
                     panel.querySelectorAll('div[class*="overflow-auto"], div[class*="overflow-y-scroll"]')

package/dist/services/notificationSender.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildApprovalNotification = buildApprovalNotification;
 exports.buildPlanningNotification = buildPlanningNotification;
 exports.buildErrorPopupNotification = buildErrorPopupNotification;
+exports.buildRunCommandNotification = buildRunCommandNotification;
 exports.buildAutoApprovedNotification = buildAutoApprovedNotification;
 exports.buildResolvedOverlay = buildResolvedOverlay;
 exports.buildStatusNotification = buildStatusNotification;
@@ -25,6 +26,8 @@ const PLANNING_PROCEED_ACTION_PREFIX = 'planning_proceed_action';
 const ERROR_POPUP_DISMISS_ACTION_PREFIX = 'error_popup_dismiss_action';
 const ERROR_POPUP_COPY_DEBUG_ACTION_PREFIX = 'error_popup_copy_debug_action';
 const ERROR_POPUP_RETRY_ACTION_PREFIX = 'error_popup_retry_action';
+const RUN_COMMAND_RUN_ACTION_PREFIX = 'run_command_run_action';
+const RUN_COMMAND_REJECT_ACTION_PREFIX = 'run_command_reject_action';
 // ---------------------------------------------------------------------------
 // Notification colours
 // ---------------------------------------------------------------------------
@@ -107,6 +110,21 @@ function buildErrorPopupNotification(opts) {
     ];
     return { richContent, components };
 }
+/** Build the run command notification message. */
+function buildRunCommandNotification(opts) {
+    const { title, commandText, workingDirectory, projectName, channelId, extraFields } = opts;
+    const safeCommandText = (commandText || '')
+        .replace(/```/g, '`\u200b``')
+        .slice(0, 3800);
+    const safeWorkingDirectory = (workingDirectory || '(unknown)').slice(0, 1024);
+    const richContent = (0, richContentBuilder_1.pipe)((0, richContentBuilder_1.createRichContent)(), (rc) => (0, richContentBuilder_1.withTitle)(rc, title), (rc) => (0, richContentBuilder_1.withDescription)(rc, `\`\`\`\n${safeCommandText}\n\`\`\``), (rc) => (0, richContentBuilder_1.withColor)(rc, COLOR_APPROVAL), (rc) => (0, richContentBuilder_1.addField)(rc, 'Directory', safeWorkingDirectory, true), (rc) => (0, richContentBuilder_1.addField)(rc, 'Project', projectName, true), (rc) => extraFields
+        ? extraFields.reduce((acc, f) => (0, richContentBuilder_1.addField)(acc, f.name, f.value, f.inline), rc)
+        : rc, (rc) => (0, richContentBuilder_1.withFooter)(rc, 'Run command approval required'), (rc) => (0, richContentBuilder_1.withTimestamp)(rc));
+    const components = [
+        buttonRow(button(customId(RUN_COMMAND_RUN_ACTION_PREFIX, projectName, channelId), 'Run', 'success'), button(customId(RUN_COMMAND_REJECT_ACTION_PREFIX, projectName, channelId), 'Reject', 'danger')),
+    ];
+    return { richContent, components };
+}
 /** Build an auto-approved notification (shown when auto-accept fires). */
 function buildAutoApprovedNotification(opts) {
     const { accepted, projectName, description, approveText } = opts;

package/dist/services/runCommandDetector.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunCommandDetector = void 0;
+const logger_1 = require("../utils/logger");
+const approvalDetector_1 = require("./approvalDetector");
+/**
+ * CDP detection script for the "Run command?" dialog in Claude Code / Antigravity.
+ *
+ * DOM structure (from user-provided inspection):
+ *   <div class="flex flex-col gap-2 border-gray-500/25 border rounded-lg my-1">
+ *     <div>
+ *       <div class="... border-b ..."><span class="opacity-60">Run command?</span></div>
+ *       <div class="...">
+ *         <pre class="whitespace-pre-wrap break-all font-mono text-sm">
+ *           <span class="... opacity-50">~/Code/login</span>
+ *           <span class="opacity-50"> $ </span>python3 -m http.server 8000
+ *         </pre>
+ *       </div>
+ *       <div class="... border-t ...">
+ *         <button>Reject</button>
+ *         <button>Run</button>  (split button with chevron for options)
+ *       </div>
+ *     </div>
+ *   </div>
+ */
+const DETECT_RUN_COMMAND_SCRIPT = `(() => {
+    const RUN_COMMAND_HEADER_PATTERNS = [
+        'run command?', 'run command', 'execute command',
+        'コマンドを実行', 'コマンド実行'
+    ];
+    const RUN_PATTERNS = ['run', '実行', 'execute'];
+    const REJECT_PATTERNS = ['reject', 'cancel', '拒否', 'キャンセル'];
+
+    const normalize = (text) => (text || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+
+    // Find the "Run command?" header span (reverse order to prefer newest card)
+    const allSpans = Array.from(document.querySelectorAll('span')).reverse();
+    const headerSpan = allSpans.find(span => {
+        if (!span.offsetParent && span.offsetParent !== document.body) {
+            const rect = span.getBoundingClientRect();
+            if (rect.width === 0 && rect.height === 0) return false;
+        }
+        const t = normalize(span.textContent || '');
+        return RUN_COMMAND_HEADER_PATTERNS.some(p => t.includes(p));
+    });
+    if (!headerSpan) return null;
+
+    // Navigate up to the rounded-lg container
+    const container = headerSpan.closest('div[class*="rounded-lg"][class*="border"]')
+        || headerSpan.closest('div[class*="gap-2"]')
+        || headerSpan.parentElement?.parentElement?.parentElement;
+    if (!container) return null;
+
+    // Extract command text from <pre> element
+    const pre = container.querySelector('pre');
+    if (!pre) return null;
+
+    const preText = (pre.textContent || '').trim();
+    // Format: "~/Code/login $ python3 -m http.server 8000"
+    // Split on " $ " to separate working directory from command
+    const dollarIdx = preText.indexOf(' $ ');
+    let commandText = preText;
+    let workingDirectory = '';
+    if (dollarIdx >= 0) {
+        workingDirectory = preText.substring(0, dollarIdx).trim();
+        commandText = preText.substring(dollarIdx + 3).trim();
+    }
+
+    // Find Run and Reject buttons within the container
+    const containerButtons = Array.from(container.querySelectorAll('button'))
+        .filter(btn => {
+            if (btn.offsetParent !== null) return true;
+            const rect = btn.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        });
+
+    const runBtn = containerButtons.find(btn => {
+        const t = normalize(btn.textContent || '');
+        // Exclude buttons that are clearly not the Run button (dropdowns, copy, etc.)
+        if (t === '' || t.length > 30) return false;
+        return RUN_PATTERNS.some(p => t === p || t.startsWith(p));
+    });
+
+    const rejectBtn = containerButtons.find(btn => {
+        const t = normalize(btn.textContent || '');
+        if (t === '' || t.length > 30) return false;
+        return REJECT_PATTERNS.some(p => t === p || t.startsWith(p));
+    });
+
+    if (!runBtn || !rejectBtn) return null;
+
+    return {
+        commandText,
+        workingDirectory,
+        runText: (runBtn.textContent || '').trim(),
+        rejectText: (rejectBtn.textContent || '').trim(),
+    };
+})()`;
+/**
+ * Class that detects "Run command?" dialogs in the Antigravity UI via polling.
+ *
+ * Notifies detected dialog info through the onRunCommandRequired callback,
+ * and performs the actual click operations via runButton() / rejectButton() methods.
+ */
+class RunCommandDetector {
+    cdpService;
+    pollIntervalMs;
+    onRunCommandRequired;
+    onResolved;
+    pollTimer = null;
+    isRunning = false;
+    /** Key of the last detected dialog (for duplicate notification prevention) */
+    lastDetectedKey = null;
+    /** Full RunCommandInfo from the last detection (used for clicking) */
+    lastDetectedInfo = null;
+    constructor(options) {
+        this.cdpService = options.cdpService;
+        this.pollIntervalMs = options.pollIntervalMs ?? 1500;
+        this.onRunCommandRequired = options.onRunCommandRequired;
+        this.onResolved = options.onResolved;
+    }
+    /** Start monitoring. */
+    start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.lastDetectedKey = null;
+        this.lastDetectedInfo = null;
+        this.schedulePoll();
+    }
+    /** Stop monitoring. */
+    async stop() {
+        this.isRunning = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    /** Return the last detected run command info. */
+    getLastDetectedInfo() {
+        return this.lastDetectedInfo;
+    }
+    /** Schedule the next poll */
+    schedulePoll() {
+        if (!this.isRunning)
+            return;
+        this.pollTimer = setTimeout(async () => {
+            await this.poll();
+            if (this.isRunning) {
+                this.schedulePoll();
+            }
+        }, this.pollIntervalMs);
+    }
+    /**
+     * Single poll iteration:
+     *   1. Detect run command dialog in DOM (with contextId)
+     *   2. Notify via callback only on new detection (prevent duplicates)
+     *   3. Reset when dialog disappears
+     */
+    async poll() {
+        try {
+            const contextId = this.cdpService.getPrimaryContextId();
+            const callParams = {
+                expression: DETECT_RUN_COMMAND_SCRIPT,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            if (contextId !== null) {
+                callParams.contextId = contextId;
+            }
+            const result = await this.cdpService.call('Runtime.evaluate', callParams);
+            const info = result?.result?.value ?? null;
+            if (info) {
+                // Duplicate prevention: use commandText as key
+                const key = `${info.commandText}::${info.workingDirectory}`;
+                if (key !== this.lastDetectedKey) {
+                    this.lastDetectedKey = key;
+                    this.lastDetectedInfo = info;
+                    this.onRunCommandRequired(info);
+                }
+            }
+            else {
+                const wasDetected = this.lastDetectedKey !== null;
+                this.lastDetectedKey = null;
+                this.lastDetectedInfo = null;
+                if (wasDetected && this.onResolved) {
+                    this.onResolved();
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('WebSocket is not connected')) {
+                return;
+            }
+            logger_1.logger.error('[RunCommandDetector] Error during polling:', error);
+        }
+    }
+    /**
+     * Click the Run button via CDP.
+     * @param buttonText Text of the button to click (default: detected runText or "Run")
+     * @returns true if click succeeded
+     */
+    async runButton(buttonText) {
+        const text = buttonText ?? this.lastDetectedInfo?.runText ?? 'Run';
+        return this.clickButton(text);
+    }
+    /**
+     * Click the Reject button via CDP.
+     * @param buttonText Text of the button to click (default: detected rejectText or "Reject")
+     * @returns true if click succeeded
+     */
+    async rejectButton(buttonText) {
+        const text = buttonText ?? this.lastDetectedInfo?.rejectText ?? 'Reject';
+        return this.clickButton(text);
+    }
+    /**
+     * Internal click handler (shared implementation for runButton / rejectButton).
+     */
+    async clickButton(buttonText) {
+        try {
+            const script = (0, approvalDetector_1.buildClickScript)(buttonText);
+            const result = await this.runEvaluateScript(script);
+            if (result?.ok !== true) {
+                logger_1.logger.warn(`[RunCommandDetector] Click failed for "${buttonText}":`, result?.error ?? 'unknown');
+            }
+            else {
+                logger_1.logger.debug(`[RunCommandDetector] Click OK for "${buttonText}"`);
+            }
+            return result?.ok === true;
+        }
+        catch (error) {
+            logger_1.logger.error('[RunCommandDetector] Error while clicking button:', error);
+            return false;
+        }
+    }
+    /**
+     * Execute Runtime.evaluate with contextId and return result.value.
+     */
+    async runEvaluateScript(expression) {
+        const contextId = this.cdpService.getPrimaryContextId();
+        const callParams = {
+            expression,
+            returnByValue: true,
+            awaitPromise: false,
+        };
+        if (contextId !== null) {
+            callParams.contextId = contextId;
+        }
+        const result = await this.cdpService.call('Runtime.evaluate', callParams);
+        return result?.result?.value;
+    }
+    /** Returns whether monitoring is currently active */
+    isActive() {
+        return this.isRunning;
+    }
+}
+exports.RunCommandDetector = RunCommandDetector;

package/dist/services/updateCheckService.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.COOLDOWN_MS = exports.UPDATE_CHECK_FILE = void 0;
 exports.shouldCheckForUpdates = shouldCheckForUpdates;
 exports.fetchLatestVersion = fetchLatestVersion;
+exports.isGlobalInstall = isGlobalInstall;
 exports.checkForUpdates = checkForUpdates;
 const https = __importStar(require("https"));
 const fs = __importStar(require("fs"));
@@ -127,11 +128,25 @@ function compareSemver(a, b) {
     }
     return 0;
 }
+/**
+ * Detect whether the process is running from a global npm install
+ * (as opposed to a local dev checkout via `ts-node`, `tsx`, etc.).
+ */
+function isGlobalInstall() {
+    const execPath = process.argv[1] || '';
+    // Global installs run from a path containing node_modules
+    // Local dev runs from the source tree (no node_modules/.bin in argv[1])
+    const globalIndicators = ['/lib/node_modules/', '\\node_modules\\lazy-gravity\\'];
+    return globalIndicators.some((indicator) => execPath.includes(indicator));
+}
 /**
  * Non-blocking update check. Call at startup (fire-and-forget).
  * Respects a 24-hour cooldown via a local cache file.
+ * Skipped when running from source (dev/local checkout).
  */
 async function checkForUpdates(currentVersion) {
+    if (!isGlobalInstall())
+        return;
     if (!shouldCheckForUpdates())
         return;
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazy-gravity",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Control Antigravity from anywhere — a local, secure bot (Discord + Telegram) that lets you remotely operate Antigravity on your home PC from your smartphone.",
   "main": "dist/index.js",
   "bin": {