lazy-gravity 0.5.3 → 0.5.5

package/dist/commands/joinCommandHandler.js

@@ -97,13 +97,22 @@ class JoinCommandHandler {
         // Step 1: Check if a channel already exists for this session
         const existingSession = this.chatSessionRepo.findByDisplayName(projectName, selectedTitle);
         if (existingSession) {
-            const embed = new discord_js_1.EmbedBuilder()
-                .setTitle((0, i18n_1.t)('🔗 Session Already Connected'))
-                .setDescription((0, i18n_1.t)(`This session already has a channel:\n→ <#${existingSession.channelId}>`))
-                .setColor(0x3498DB)
-                .setTimestamp();
-            await interaction.editReply({ embeds: [embed], components: [] });
-            return;
+            const channel = await guild.channels.fetch(existingSession.channelId).catch(() => null);
+            if (channel) {
+                const embed = new discord_js_1.EmbedBuilder()
+                    .setTitle((0, i18n_1.t)('🔗 Session Already Connected'))
+                    .setDescription((0, i18n_1.t)(`This session already has a channel:\n→ <#${existingSession.channelId}>`))
+                    .setColor(0x3498DB)
+                    .setTimestamp();
+                await interaction.editReply({ embeds: [embed], components: [] });
+                return;
+            }
+            else {
+                // Clean up stale bindings since the channel is gone
+                logger_1.logger.info(`[Cleanup] Removed stale session binding for deleted channel ${existingSession.channelId}`);
+                this.chatSessionRepo.deleteByChannelId(existingSession.channelId);
+                this.bindingRepo.deleteByChannelId(existingSession.channelId);
+            }
         }
         // Step 2: Connect to CDP
         let cdp;

package/dist/commands/workspaceCommandHandler.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkspaceCommandHandler = exports.WORKSPACE_SELECT_ID = exports.PROJECT_SELECT_ID = void 0;
 const i18n_1 = require("../utils/i18n");
 const fs_1 = __importDefault(require("fs"));
+const logger_1 = require("../utils/logger");
 const discord_js_1 = require("discord.js");
 const projectListUi_1 = require("../ui/projectListUi");
 // Re-export for backward compatibility
@@ -22,6 +23,41 @@ class WorkspaceCommandHandler {
     workspaceService;
     channelManager;
     processingWorkspaces = new Set();
+    /**
+     * Filters out stale bindings where the Discord channel no longer exists.
+     * Deletes stale bindings from the repository.
+     */
+    async getValidBindings(bindings, guild) {
+        const validBindings = [];
+        for (const b of bindings) {
+            try {
+                // Try fetching the channel from Discord API
+                try {
+                    const channel = await guild.channels.fetch(b.channelId);
+                    if (channel)
+                        validBindings.push(b);
+                }
+                catch (error) {
+                    // Only cleanup for confirmed deleted channels (code 10003)
+                    if (error instanceof discord_js_1.DiscordAPIError && error.code === 10003) {
+                        logger_1.logger.info(`[Cleanup] Removed stale binding for deleted channel ${b.channelId}`);
+                        this.chatSessionRepo.deleteByChannelId(b.channelId);
+                        this.bindingRepo.deleteByChannelId(b.channelId);
+                        continue;
+                    }
+                    // Transient failures: preserve binding for next validation attempt
+                    logger_1.logger.error(`[Cleanup] Failed to validate binding for channel ${b.channelId}`, error);
+                    validBindings.push(b);
+                }
+            }
+            catch (error) {
+                logger_1.logger.error(`[Cleanup] Failed to remove stale binding for channel ${b.channelId}`, error);
+                this.chatSessionRepo.deleteByChannelId(b.channelId);
+                this.bindingRepo.deleteByChannelId(b.channelId);
+            }
+        }
+        return validBindings;
+    }
     constructor(bindingRepo, chatSessionRepo, workspaceService, channelManager) {
         this.bindingRepo = bindingRepo;
         this.chatSessionRepo = chatSessionRepo;
@@ -61,7 +97,8 @@ class WorkspaceCommandHandler {
             return;
         }
         // Check if the same project is already bound (prevent duplicates)
-        const existingBindings = this.bindingRepo.findByWorkspacePathAndGuildId(workspacePath, guild.id);
+        let existingBindings = this.bindingRepo.findByWorkspacePathAndGuildId(workspacePath, guild.id);
+        existingBindings = await this.getValidBindings(existingBindings, guild);
         if (existingBindings.length > 0) {
             const channelLinks = existingBindings.map(b => `<#${b.channelId}>`).join(', ');
             const fullPath = this.workspaceService.getWorkspacePath(workspacePath);
@@ -148,7 +185,8 @@ class WorkspaceCommandHandler {
         }
         // Check for existing project
         if (this.workspaceService.exists(name)) {
-            const existingBindings = this.bindingRepo.findByWorkspacePathAndGuildId(name, guild.id);
+            let existingBindings = this.bindingRepo.findByWorkspacePathAndGuildId(name, guild.id);
+            existingBindings = await this.getValidBindings(existingBindings, guild);
             if (existingBindings.length > 0) {
                 const channelLinks = existingBindings.map(b => `<#${b.channelId}>`).join(', ');
                 await interaction.editReply({

package/dist/events/messageCreateHandler.js

@@ -177,12 +177,37 @@ function createMessageCreateHandler(deps) {
                                 registerApprovalSessionChannel(deps.bridge, projectName, session.displayName, platformChannel);
                             }
                             if (session?.isRenamed && session.displayName) {
-                                const activationResult = await deps.chatSessionService.activateSessionByTitle(cdp, session.displayName);
+                                let 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;
+                                    // Recovery: Antigravity may have renamed the session.
+                                    // Check if the currently active chat is the renamed version.
+                                    const currentInfo = await deps.chatSessionService.getCurrentSessionInfo(cdp);
+                                    const isRecoverable = currentInfo.hasActiveChat
+                                        && currentInfo.title.trim() !== ''
+                                        && currentInfo.title !== session.displayName;
+                                    if (isRecoverable) {
+                                        const siblings = deps.chatSessionRepo.findByCategoryId(session.categoryId);
+                                        const ownedByOther = siblings.some((s) => s.channelId !== message.channelId
+                                            && s.displayName === currentInfo.title);
+                                        if (!ownedByOther) {
+                                            const recoveredTitle = currentInfo.title;
+                                            const retryResult = await deps.chatSessionService.activateSessionByTitle(cdp, recoveredTitle);
+                                            if (retryResult.ok) {
+                                                logger_1.logger.info(`[SessionRecovery] Adopting renamed title: ` +
+                                                    `"${session.displayName}" -> "${recoveredTitle}" ` +
+                                                    `(channel: ${message.channelId})`);
+                                                deps.chatSessionRepo.updateDisplayName(message.channelId, recoveredTitle);
+                                                registerApprovalSessionChannel(deps.bridge, projectName, recoveredTitle, platformChannel);
+                                            }
+                                            activationResult = retryResult;
+                                        }
+                                    }
+                                    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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazy-gravity",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "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": {