lazy-gravity 0.10.0 → 0.12.0

package/dist/services/chatSessionService.js

@@ -40,7 +40,7 @@ const GET_NEW_CHAT_BUTTON_SCRIPT = `(() => {
  * The title element is a div with the text-ellipsis class inside the header.
  */
 const GET_CHAT_TITLE_SCRIPT = `(() => {
-    const panel = document.querySelector('.antigravity-agent-side-panel');
+    const panel = document.querySelector('.antigravity-agent-side-panel') || document.body;
     if (!panel) return { title: '', hasActiveChat: false };
     const header = panel.querySelector('div[class*="border-b"]');
     if (!header) return { title: '', hasActiveChat: false };
@@ -58,7 +58,7 @@ const GET_CHAT_TITLE_SCRIPT = `(() => {
     return { title: title || '(Untitled)', hasActiveChat };
 })()`;
 const GET_SESSION_VIEW_STATE_SCRIPT = `(() => {
-    const panel = document.querySelector('.antigravity-agent-side-panel');
+    const panel = document.querySelector('.antigravity-agent-side-panel') || document.body;
     if (!panel) {
         return {
             panelFound: false,
@@ -169,7 +169,8 @@ const SCRAPE_PAST_CONVERSATIONS_SCRIPT = `(() => {
     // 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');
+        || document.querySelector('.antigravity-agent-side-panel')
+        || document.body;
     if (!panel) return null;
 
     const items = [];
@@ -276,9 +277,11 @@ function buildActivateChatByTitleScript(title) {
         for (const node of nodes) {
             const text = normalize(node.textContent || '');
             if (!text) continue;
+            
+            const isShort = wanted.length < 5;
             if (text === wanted) {
                 exact.push({ node, textLength: text.length });
-            } else if (text.includes(wanted)) {
+            } else if (!isShort && text.includes(wanted)) {
                 includes.push({ node, textLength: text.length });
             } else if (wordsMatch(text, wantedRaw)) {
                 fuzzy.push({ node, textLength: text.length });
@@ -369,10 +372,12 @@ function buildActivateViaPastConversationsScript(title) {
                     if (!pattern) continue;
                     const p = normalize(pattern);
                     const pLoose = normalizeLoose(pattern);
+                    const isShort = p.length < 5;
+                    
                     if (
                         text === p ||
-                        text.includes(p) ||
-                        (pLoose && (textLoose === pLoose || textLoose.includes(pLoose)))
+                        (pLoose && textLoose === pLoose) ||
+                        (!isShort && (text.includes(p) || (pLoose && textLoose.includes(pLoose))))
                     ) {
                         matched.push({ el, score: Math.abs(text.length - pattern.length) });
                         break;
@@ -611,7 +616,8 @@ class ChatSessionService {
                 const isVisible = (el) => !!el && el instanceof HTMLElement && el.offsetParent !== null;
                 const quickInputPanels = Array.from(document.querySelectorAll('div[class*="bg-quickinput-background"]'));
                 const panel = quickInputPanels.find((el) => isVisible(el))
-                    || document.querySelector('.antigravity-agent-side-panel');
+                    || document.querySelector('.antigravity-agent-side-panel')
+                    || document.body;
                 if (!panel) return false;
                 const containers = Array.from(
                     panel.querySelectorAll('div[class*="overflow-auto"], div[class*="overflow-y-scroll"]')
@@ -1095,12 +1101,13 @@ class ChatSessionService {
     /**
      * Rename the current chat in the Antigravity UI directly by updating the DOM.
      * Note: This is a cosmetic change until Antigravity persists a rename.
+     * IDE syncing for chat renaming is strictly "best-effort".
      */
     async renameCurrentChatInUI(cdpService, newTitle) {
         try {
             const contextId = cdpService.getPrimaryContextId();
             const RENAME_SCRIPT = `(() => {
-                const panel = document.querySelector('.antigravity-agent-side-panel');
+                const panel = document.querySelector('.antigravity-agent-side-panel') || document.body;
                 if (!panel) return { ok: false, error: 'Panel not found' };
                 const header = panel.querySelector('div[class*="border-b"]');
                 const titleEl = header?.querySelector('div[class*="text-ellipsis"]');

package/dist/services/heartbeatService.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatService = void 0;
+exports.parseInterval = parseInterval;
+exports.formatDuration = formatDuration;
+exports.formatRelativeTime = formatRelativeTime;
+const discord_js_1 = require("discord.js");
+const logger_1 = require("../utils/logger");
+const configLoader_1 = require("../utils/configLoader");
+class HeartbeatService {
+    client = null;
+    bridge = null;
+    intervalId = null;
+    generationToken = 0;
+    isSending = false;
+    botStartTime = Date.now();
+    lastActivityTimestamp = Date.now();
+    constructor() { }
+    init(client, bridge) {
+        this.client = client;
+        this.bridge = bridge;
+        this.botStartTime = Date.now();
+        this.lastActivityTimestamp = Date.now();
+    }
+    recordActivity() {
+        this.lastActivityTimestamp = Date.now();
+    }
+    start() {
+        this.stop();
+        const config = configLoader_1.ConfigLoader.load();
+        if (!config.heartbeatEnabled) {
+            logger_1.logger.info('[HeartbeatService] Periodic heartbeat is disabled.');
+            return;
+        }
+        const channelId = config.heartbeatChannelId;
+        if (!channelId) {
+            logger_1.logger.warn('[HeartbeatService] Enabled but heartbeatChannelId is not configured.');
+            return;
+        }
+        let interval = config.heartbeatIntervalMs ?? 3600000;
+        if (interval < 10000) {
+            logger_1.logger.warn(`[HeartbeatService] Interval ${interval}ms is too low. Clamping to 10000ms.`);
+            interval = 10000;
+        }
+        else if (interval > 2147483647) {
+            logger_1.logger.warn(`[HeartbeatService] Interval ${interval}ms is too high (max is 2147483647ms). Clamping to 2147483647ms.`);
+            interval = 2147483647;
+        }
+        logger_1.logger.info(`[HeartbeatService] Starting periodic heartbeat every ${interval}ms to channel ${channelId}`);
+        // Run immediately on start
+        this.sendHeartbeat().catch(err => {
+            logger_1.logger.error('[HeartbeatService] Failed to send initial heartbeat:', err);
+        });
+        this.intervalId = setInterval(() => {
+            this.sendHeartbeat().catch(err => {
+                logger_1.logger.error('[HeartbeatService] Failed to send periodic heartbeat:', err);
+            });
+        }, interval);
+    }
+    stop() {
+        this.generationToken++;
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    async updateConfig(enabled, intervalMs, channelId) {
+        this.generationToken++;
+        const config = configLoader_1.ConfigLoader.load();
+        // If channel changed, clear the last message ID
+        if (config.heartbeatChannelId !== channelId) {
+            if (config.heartbeatChannelId && config.heartbeatLastMessageId) {
+                try {
+                    const oldChannel = await this.client?.channels.fetch(config.heartbeatChannelId);
+                    if (oldChannel && oldChannel.isTextBased()) {
+                        const oldMsg = await oldChannel.messages.fetch(config.heartbeatLastMessageId);
+                        if (oldMsg) {
+                            await oldMsg.delete().catch(() => { });
+                        }
+                    }
+                }
+                catch (err) {
+                    logger_1.logger.debug('[HeartbeatService] Failed to delete old heartbeat message from previous channel:', err);
+                }
+            }
+            configLoader_1.ConfigLoader.save({ heartbeatLastMessageId: undefined });
+        }
+        // Save to config.json
+        configLoader_1.ConfigLoader.save({
+            heartbeatEnabled: enabled,
+            heartbeatIntervalMs: intervalMs,
+            heartbeatChannelId: channelId,
+        });
+        logger_1.logger.info(`[HeartbeatService] Config updated: enabled=${enabled}, interval=${intervalMs}ms, channel=${channelId}`);
+        // Restart loop
+        this.start();
+    }
+    async disable() {
+        this.generationToken++;
+        const config = configLoader_1.ConfigLoader.load();
+        if (config.heartbeatChannelId && config.heartbeatLastMessageId) {
+            try {
+                const oldChannel = await this.client?.channels.fetch(config.heartbeatChannelId);
+                if (oldChannel && oldChannel.isTextBased()) {
+                    const oldMsg = await oldChannel.messages.fetch(config.heartbeatLastMessageId);
+                    if (oldMsg) {
+                        await oldMsg.delete().catch(() => { });
+                    }
+                }
+            }
+            catch (err) {
+                logger_1.logger.debug('[HeartbeatService] Failed to delete heartbeat message upon disabling:', err);
+            }
+        }
+        configLoader_1.ConfigLoader.save({
+            heartbeatEnabled: false,
+            heartbeatLastMessageId: undefined,
+        });
+        this.stop();
+        logger_1.logger.info('[HeartbeatService] Heartbeat disabled.');
+    }
+    async sendHeartbeat() {
+        if (!this.client || !this.bridge) {
+            logger_1.logger.warn('[HeartbeatService] Cannot send heartbeat: client or bridge not initialized.');
+            return;
+        }
+        if (this.isSending) {
+            logger_1.logger.debug('[HeartbeatService] Heartbeat send already in flight. Skipping overlapping execution.');
+            return;
+        }
+        const gen = this.generationToken;
+        this.isSending = true;
+        const config = configLoader_1.ConfigLoader.load();
+        const channelId = config.heartbeatChannelId;
+        if (!channelId) {
+            this.isSending = false;
+            return;
+        }
+        try {
+            const channel = await this.client.channels.fetch(channelId);
+            if (gen !== this.generationToken) {
+                logger_1.logger.debug(`[HeartbeatService] Aborting heartbeat send: stale generation (expected ${gen}, current ${this.generationToken})`);
+                return;
+            }
+            if (!channel || !channel.isTextBased()) {
+                logger_1.logger.warn(`[HeartbeatService] Channel ${channelId} not found or is not a text channel.`);
+                return;
+            }
+            const embed = this.buildHeartbeatEmbed();
+            const lastMessageId = config.heartbeatLastMessageId;
+            if (lastMessageId) {
+                try {
+                    const message = await channel.messages.fetch(lastMessageId);
+                    if (gen !== this.generationToken) {
+                        logger_1.logger.debug('[HeartbeatService] Aborting message edit: stale generation');
+                        return;
+                    }
+                    if (message && message.author.id === this.client.user?.id) {
+                        await message.edit({ embeds: [embed] });
+                        logger_1.logger.debug(`[HeartbeatService] Updated heartbeat message in-place: ${lastMessageId}`);
+                        return;
+                    }
+                }
+                catch (fetchErr) {
+                    logger_1.logger.debug(`[HeartbeatService] Failed to fetch or edit message ${lastMessageId}, sending new one.`);
+                }
+            }
+            if (gen !== this.generationToken) {
+                logger_1.logger.debug('[HeartbeatService] Aborting message send: stale generation');
+                return;
+            }
+            // Send new message
+            const newMsg = await channel.send({ embeds: [embed] });
+            if (gen !== this.generationToken) {
+                logger_1.logger.debug(`[HeartbeatService] Stale generation after send. Deleting new message ${newMsg.id} to avoid leakage.`);
+                await newMsg.delete().catch(() => { });
+                return;
+            }
+            configLoader_1.ConfigLoader.save({ heartbeatLastMessageId: newMsg.id });
+            logger_1.logger.info(`[HeartbeatService] Sent new heartbeat message: ${newMsg.id}`);
+        }
+        catch (error) {
+            logger_1.logger.error('[HeartbeatService] Error in sendHeartbeat:', error);
+        }
+        finally {
+            this.isSending = false;
+        }
+    }
+    buildHeartbeatEmbed() {
+        const uptimeMs = Date.now() - this.botStartTime;
+        const uptimeStr = formatDuration(uptimeMs);
+        const activeWorkspaces = this.bridge?.pool.getActiveWorkspaceNames() || [];
+        const activeCount = activeWorkspaces.length;
+        const activeList = activeCount > 0 ? activeWorkspaces.join(', ') : 'None';
+        const lastActivityStr = formatRelativeTime(this.lastActivityTimestamp);
+        return new discord_js_1.EmbedBuilder()
+            .setTitle('💓 LazyGravity Heartbeat')
+            .setColor(0x00CC88)
+            .addFields({ name: 'Status', value: '🟢 Running', inline: true }, { name: 'Uptime', value: uptimeStr, inline: true }, { name: 'Active Sessions', value: `${activeCount} (${activeList})`, inline: true }, { name: 'Last Activity', value: lastActivityStr, inline: true })
+            .setFooter({ text: `Last updated: ${new Date().toLocaleString()}` })
+            .setTimestamp();
+    }
+}
+exports.HeartbeatService = HeartbeatService;
+/**
+ * Parse a duration string like "1h", "6h", "30m", or "2d" to milliseconds.
+ * Requiring a unit prevents ambiguity with bare numbers.
+ */
+function parseInterval(str) {
+    const match = str.trim().toLowerCase().match(/^(\d+)(ms|s|m|h|d)$/);
+    if (!match)
+        return null;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case 'ms': return value;
+        case 's': return value * 1000;
+        case 'm': return value * 60 * 1000;
+        case 'h': return value * 60 * 60 * 1000;
+        case 'd': return value * 24 * 60 * 60 * 1000;
+        default: return null;
+    }
+}
+/**
+ * Format milliseconds to a human-readable duration (e.g. "2h 15m")
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor((ms / 1000) % 60);
+    const minutes = Math.floor((ms / (1000 * 60)) % 60);
+    const hours = Math.floor((ms / (1000 * 60 * 60)) % 24);
+    const days = Math.floor(ms / (1000 * 60 * 60 * 24));
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (seconds > 0 || parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+/**
+ * Format a past timestamp to a relative string (e.g. "5m ago")
+ */
+function formatRelativeTime(timestamp) {
+    const diff = Date.now() - timestamp;
+    if (diff < 5000)
+        return 'just now';
+    const seconds = Math.floor(diff / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ${minutes % 60}m ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}

package/dist/services/notificationSender.js

@@ -82,7 +82,7 @@ function customId(prefix, projectName, channelId) {
 // ---------------------------------------------------------------------------
 /** Build the approval notification message. */
 function buildApprovalNotification(opts) {
-    const { title, description, projectName, channelId, toolNames, extraFields, hasAlwaysAllow, alwaysAllowText } = opts;
+    const { title, description, projectName, channelId, toolNames, extraFields, hasAlwaysAllow, alwaysAllowText, walkthroughCustomId, taskCustomId } = opts;
     const richContent = (0, richContentBuilder_1.pipe)((0, richContentBuilder_1.createRichContent)(), (rc) => (0, richContentBuilder_1.withTitle)(rc, title), (rc) => (0, richContentBuilder_1.withDescription)(rc, description), (rc) => (0, richContentBuilder_1.withColor)(rc, COLOR_APPROVAL), (rc) => (0, richContentBuilder_1.addField)(rc, 'Project', projectName, true), (rc) => toolNames && toolNames.length > 0
         ? (0, richContentBuilder_1.addField)(rc, 'Tools', toolNames.join(', '), true)
         : rc, (rc) => extraFields
@@ -98,6 +98,16 @@ function buildApprovalNotification(opts) {
     const components = [
         buttonRow(...buttons),
     ];
+    const artifactButtons = [];
+    if (walkthroughCustomId) {
+        artifactButtons.push(button(walkthroughCustomId, 'Review walkthrough.md', 'success'));
+    }
+    if (taskCustomId) {
+        artifactButtons.push(button(taskCustomId, 'Review task.md', 'primary'));
+    }
+    if (artifactButtons.length > 0) {
+        components.push(buttonRow(...artifactButtons));
+    }
     return { richContent, components };
 }
 /** Build the planning mode notification message. */
@@ -107,8 +117,8 @@ function buildPlanningNotification(opts) {
         ? extraFields.reduce((acc, f) => (0, richContentBuilder_1.addField)(acc, f.name, f.value, f.inline), rc)
         : rc, (rc) => (0, richContentBuilder_1.withFooter)(rc, 'Planning mode detected'), (rc) => (0, richContentBuilder_1.withTimestamp)(rc));
     const buttons = [];
-    const openLabel = opts.openText || 'Open';
     if (opts.hasOpenButton !== false) {
+        const openLabel = opts.openText || 'Open Plan';
         buttons.push(button(customId(PLANNING_OPEN_ACTION_PREFIX, projectName, channelId), openLabel, 'primary'));
     }
     const buttonLabel = opts.proceedText || 'Proceed';

package/dist/services/planningDetector.js

@@ -247,7 +247,7 @@ class PlanningDetector {
      * @returns true if click succeeded
      */
     async clickRejectButton(buttonText) {
-        const text = buttonText ?? this.lastDetectedInfo?.rejectText ?? 'Reject All';
+        const text = buttonText || this.lastDetectedInfo?.rejectText || 'Reject All';
         return this.clickButton(text);
     }
     /**

package/dist/services/promptDispatcher.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptDispatcher = void 0;
+const logger_1 = require("../utils/logger");
 /**
  * Dispatcher that calls the existing sendPromptToAntigravity.
  * Unifies dependency injection on the caller side and simplifies event handlers.
  */
 class PromptDispatcher {
     deps;
+    activeMonitors = new Map();
     constructor(deps) {
         this.deps = deps;
     }
@@ -17,7 +19,25 @@ class PromptDispatcher {
         await this._dispatch(req, { ...req.options, resumeOnly: true });
     }
     async _dispatch(req, options) {
-        await this.deps.sendPromptImpl(this.deps.bridge, req.message, req.prompt, req.cdp, this.deps.modeService, this.deps.modelService, req.inboundImages ?? [], options);
+        const channelId = req.message.channelId;
+        const existing = this.activeMonitors.get(channelId);
+        if (existing) {
+            logger_1.logger.info(`[PromptDispatcher] Aborting previous active monitor for channel ${channelId}`);
+            await existing.stop().catch((err) => logger_1.logger.error('[PromptDispatcher] Error stopping monitor:', err));
+            this.activeMonitors.delete(channelId);
+        }
+        const wrappedOptions = {
+            ...(options || {}),
+            onMonitorCreated: (monitor) => {
+                this.activeMonitors.set(channelId, monitor);
+                options?.onMonitorCreated?.(monitor);
+            },
+            onFullCompletion: () => {
+                this.activeMonitors.delete(channelId);
+                options?.onFullCompletion?.();
+            }
+        };
+        await this.deps.sendPromptImpl(this.deps.bridge, req.message, req.prompt, req.cdp, this.deps.modeService, this.deps.modelService, req.inboundImages ?? [], wrappedOptions);
     }
 }
 exports.PromptDispatcher = PromptDispatcher;