lazy-gravity 0.0.2 → 0.0.3

package/dist/services/cdpBridgeManager.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerApprovalWorkspaceChannel = registerApprovalWorkspaceChannel;
+exports.registerApprovalSessionChannel = registerApprovalSessionChannel;
+exports.resolveApprovalChannelForCurrentChat = resolveApprovalChannelForCurrentChat;
+exports.buildApprovalCustomId = buildApprovalCustomId;
+exports.parseApprovalCustomId = parseApprovalCustomId;
+exports.initCdpBridge = initCdpBridge;
+exports.getCurrentCdp = getCurrentCdp;
+exports.ensureApprovalDetector = ensureApprovalDetector;
+const discord_js_1 = require("discord.js");
+const i18n_1 = require("../utils/i18n");
+const logger_1 = require("../utils/logger");
+const approvalDetector_1 = require("./approvalDetector");
+const autoAcceptService_1 = require("./autoAcceptService");
+const cdpConnectionPool_1 = require("./cdpConnectionPool");
+const quotaService_1 = require("./quotaService");
+const APPROVE_ACTION_PREFIX = 'approve_action';
+const ALWAYS_ALLOW_ACTION_PREFIX = 'always_allow_action';
+const DENY_ACTION_PREFIX = 'deny_action';
+function normalizeSessionTitle(title) {
+    return title.trim().toLowerCase();
+}
+function buildSessionRouteKey(workspaceDirName, sessionTitle) {
+    return `${workspaceDirName}::${normalizeSessionTitle(sessionTitle)}`;
+}
+const GET_CURRENT_CHAT_TITLE_SCRIPT = `(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    if (!panel) return '';
+    const header = panel.querySelector('div[class*="border-b"]');
+    if (!header) return '';
+    const titleEl = header.querySelector('div[class*="text-ellipsis"]');
+    const title = titleEl ? (titleEl.textContent || '').trim() : '';
+    if (!title || title === 'Agent') return '';
+    return title;
+})()`;
+async function getCurrentChatTitle(cdp) {
+    const contexts = cdp.getContexts();
+    for (const ctx of contexts) {
+        try {
+            const result = await cdp.call('Runtime.evaluate', {
+                expression: GET_CURRENT_CHAT_TITLE_SCRIPT,
+                returnByValue: true,
+                contextId: ctx.id,
+            });
+            const value = result?.result?.value;
+            if (typeof value === 'string' && value.trim().length > 0) {
+                return value.trim();
+            }
+        }
+        catch {
+            // Continue to next context
+        }
+    }
+    return null;
+}
+function registerApprovalWorkspaceChannel(bridge, workspaceDirName, channel) {
+    bridge.approvalChannelByWorkspace.set(workspaceDirName, channel);
+}
+function registerApprovalSessionChannel(bridge, workspaceDirName, sessionTitle, channel) {
+    if (!sessionTitle || sessionTitle.trim().length === 0)
+        return;
+    bridge.approvalChannelBySession.set(buildSessionRouteKey(workspaceDirName, sessionTitle), channel);
+    bridge.approvalChannelByWorkspace.set(workspaceDirName, channel);
+}
+function resolveApprovalChannelForCurrentChat(bridge, workspaceDirName, currentChatTitle) {
+    if (!currentChatTitle || currentChatTitle.trim().length === 0) {
+        return null;
+    }
+    const key = buildSessionRouteKey(workspaceDirName, currentChatTitle);
+    return bridge.approvalChannelBySession.get(key) ?? null;
+}
+function buildApprovalCustomId(action, workspaceDirName, channelId) {
+    const prefix = action === 'approve'
+        ? APPROVE_ACTION_PREFIX
+        : action === 'always_allow'
+            ? ALWAYS_ALLOW_ACTION_PREFIX
+            : DENY_ACTION_PREFIX;
+    if (channelId && channelId.trim().length > 0) {
+        return `${prefix}:${workspaceDirName}:${channelId}`;
+    }
+    return `${prefix}:${workspaceDirName}`;
+}
+function parseApprovalCustomId(customId) {
+    if (customId === APPROVE_ACTION_PREFIX) {
+        return { action: 'approve', workspaceDirName: null, channelId: null };
+    }
+    if (customId === ALWAYS_ALLOW_ACTION_PREFIX) {
+        return { action: 'always_allow', workspaceDirName: null, channelId: null };
+    }
+    if (customId === DENY_ACTION_PREFIX) {
+        return { action: 'deny', workspaceDirName: null, channelId: null };
+    }
+    if (customId.startsWith(`${APPROVE_ACTION_PREFIX}:`)) {
+        const rest = customId.substring(`${APPROVE_ACTION_PREFIX}:`.length);
+        const [workspaceDirName, channelId] = rest.split(':');
+        return { action: 'approve', workspaceDirName: workspaceDirName || null, channelId: channelId || null };
+    }
+    if (customId.startsWith(`${ALWAYS_ALLOW_ACTION_PREFIX}:`)) {
+        const rest = customId.substring(`${ALWAYS_ALLOW_ACTION_PREFIX}:`.length);
+        const [workspaceDirName, channelId] = rest.split(':');
+        return { action: 'always_allow', workspaceDirName: workspaceDirName || null, channelId: channelId || null };
+    }
+    if (customId.startsWith(`${DENY_ACTION_PREFIX}:`)) {
+        const rest = customId.substring(`${DENY_ACTION_PREFIX}:`.length);
+        const [workspaceDirName, channelId] = rest.split(':');
+        return { action: 'deny', workspaceDirName: workspaceDirName || null, channelId: channelId || null };
+    }
+    return null;
+}
+/** Initialize the CDP bridge (lazy connection: pool creation only) */
+function initCdpBridge(autoApproveDefault) {
+    const pool = new cdpConnectionPool_1.CdpConnectionPool({
+        cdpCallTimeout: 15000,
+        // Keep CDP reconnection lazy: do not reopen windows in background.
+        // Reconnection is triggered when the next chat/template message is sent.
+        maxReconnectAttempts: 0,
+        reconnectDelayMs: 3000,
+    });
+    const quota = new quotaService_1.QuotaService();
+    const autoAccept = new autoAcceptService_1.AutoAcceptService(autoApproveDefault);
+    return {
+        pool,
+        quota,
+        autoAccept,
+        lastActiveWorkspace: null,
+        lastActiveChannel: null,
+        approvalChannelByWorkspace: new Map(),
+        approvalChannelBySession: new Map(),
+    };
+}
+/**
+ * Helper to get the currently active CdpService from lastActiveWorkspace.
+ * Used in contexts where the workspace path is not explicitly provided,
+ * such as button interactions and model/mode switching.
+ */
+function getCurrentCdp(bridge) {
+    if (!bridge.lastActiveWorkspace)
+        return null;
+    return bridge.pool.getConnected(bridge.lastActiveWorkspace);
+}
+/**
+ * Helper to start an approval detector for each workspace.
+ * Does nothing if a detector for the same workspace is already running.
+ */
+function ensureApprovalDetector(bridge, cdp, workspaceDirName, client) {
+    const existing = bridge.pool.getApprovalDetector(workspaceDirName);
+    if (existing && existing.isActive())
+        return;
+    const detector = new approvalDetector_1.ApprovalDetector({
+        cdpService: cdp,
+        pollIntervalMs: 2000,
+        onApprovalRequired: async (info) => {
+            logger_1.logger.info(`[ApprovalDetector:${workspaceDirName}] Approval button detected (allow="${info.approveText}", deny="${info.denyText}")`);
+            const currentChatTitle = await getCurrentChatTitle(cdp);
+            const targetChannel = resolveApprovalChannelForCurrentChat(bridge, workspaceDirName, currentChatTitle);
+            const targetChannelId = targetChannel && 'id' in targetChannel ? String(targetChannel.id) : '';
+            if (!targetChannel || !targetChannelId || !('send' in targetChannel)) {
+                logger_1.logger.warn(`[ApprovalDetector:${workspaceDirName}] Skipped approval notification because chat is not linked to a Discord session` +
+                    `${currentChatTitle ? ` (title="${currentChatTitle}")` : ''}`);
+                return;
+            }
+            if (bridge.autoAccept.isEnabled()) {
+                const accepted = await detector.alwaysAllowButton() || await detector.approveButton();
+                const autoEmbed = new discord_js_1.EmbedBuilder()
+                    .setTitle(accepted ? (0, i18n_1.t)('Auto-approved') : (0, i18n_1.t)('Auto-approve failed'))
+                    .setDescription(info.description || (0, i18n_1.t)('Antigravity is requesting approval for an action'))
+                    .setColor(accepted ? 0x2ECC71 : 0xF39C12)
+                    .addFields({ name: (0, i18n_1.t)('Auto-approve mode'), value: (0, i18n_1.t)('ON'), inline: true }, { name: (0, i18n_1.t)('Workspace'), value: workspaceDirName, inline: true }, { name: (0, i18n_1.t)('Result'), value: accepted ? (0, i18n_1.t)('Executed Always Allow/Allow') : (0, i18n_1.t)('Manual approval required'), inline: true })
+                    .setTimestamp();
+                await targetChannel.send({ embeds: [autoEmbed] }).catch(logger_1.logger.error);
+                if (accepted) {
+                    return;
+                }
+            }
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle((0, i18n_1.t)('Approval Required'))
+                .setDescription(info.description || (0, i18n_1.t)('Antigravity is requesting approval for an action'))
+                .setColor(0xFFA500)
+                .addFields({ name: (0, i18n_1.t)('Allow button'), value: info.approveText, inline: true }, { name: (0, i18n_1.t)('Allow Chat button'), value: info.alwaysAllowText || (0, i18n_1.t)('In Dropdown'), inline: true }, { name: (0, i18n_1.t)('Deny button'), value: info.denyText || (0, i18n_1.t)('(None)'), inline: true }, { name: (0, i18n_1.t)('Workspace'), value: workspaceDirName, inline: true })
+                .setTimestamp();
+            const approveBtn = new discord_js_1.ButtonBuilder()
+                .setCustomId(buildApprovalCustomId('approve', workspaceDirName, targetChannelId))
+                .setLabel((0, i18n_1.t)('Allow'))
+                .setStyle(discord_js_1.ButtonStyle.Success);
+            const alwaysAllowBtn = new discord_js_1.ButtonBuilder()
+                .setCustomId(buildApprovalCustomId('always_allow', workspaceDirName, targetChannelId))
+                .setLabel((0, i18n_1.t)('Allow Chat'))
+                .setStyle(discord_js_1.ButtonStyle.Primary);
+            const denyBtn = new discord_js_1.ButtonBuilder()
+                .setCustomId(buildApprovalCustomId('deny', workspaceDirName, targetChannelId))
+                .setLabel((0, i18n_1.t)('Deny'))
+                .setStyle(discord_js_1.ButtonStyle.Danger);
+            const row = new discord_js_1.ActionRowBuilder().addComponents(approveBtn, alwaysAllowBtn, denyBtn);
+            targetChannel.send({
+                embeds: [embed],
+                components: [row],
+            }).catch(logger_1.logger.error);
+        },
+    });
+    detector.start();
+    bridge.pool.registerApprovalDetector(workspaceDirName, detector);
+    logger_1.logger.info(`[ApprovalDetector:${workspaceDirName}] Started approval button detection`);
+}

package/dist/services/cdpConnectionPool.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpConnectionPool = void 0;
+const logger_1 = require("../utils/logger");
+const cdpService_1 = require("./cdpService");
+/**
+ * Pool that manages independent CdpService instances per workspace.
+ *
+ * Each workspace owns its own WebSocket / contexts / pendingCalls, so
+ * switching to workspace B while workspace A's ResponseMonitor is polling
+ * does not destroy A's WebSocket.
+ */
+class CdpConnectionPool {
+    connections = new Map();
+    approvalDetectors = new Map();
+    connectingPromises = new Map();
+    cdpOptions;
+    constructor(cdpOptions = {}) {
+        this.cdpOptions = cdpOptions;
+    }
+    /**
+     * Get a CdpService for the given workspace path.
+     * Creates a new connection and caches it if not already connected.
+     * Prevents concurrent connections via Promise locking.
+     *
+     * @param workspacePath Full path of the workspace
+     * @returns Connected CdpService
+     */
+    async getOrConnect(workspacePath) {
+        const dirName = this.extractDirName(workspacePath);
+        // Return existing connection if available
+        const existing = this.connections.get(dirName);
+        if (existing && existing.isConnected()) {
+            // Re-validate that the still-open window is actually bound to this workspace.
+            await existing.discoverAndConnectForWorkspace(workspacePath);
+            return existing;
+        }
+        // Wait for the pending connection promise if one exists (prevents concurrent connections)
+        const pending = this.connectingPromises.get(dirName);
+        if (pending) {
+            return pending;
+        }
+        // Start a new connection
+        const connectPromise = this.createAndConnect(workspacePath, dirName);
+        this.connectingPromises.set(dirName, connectPromise);
+        try {
+            const cdp = await connectPromise;
+            return cdp;
+        }
+        finally {
+            this.connectingPromises.delete(dirName);
+        }
+    }
+    /**
+     * Get a connected CdpService (read-only).
+     * Returns null if not connected.
+     */
+    getConnected(workspaceDirName) {
+        const cdp = this.connections.get(workspaceDirName);
+        if (cdp && cdp.isConnected()) {
+            return cdp;
+        }
+        return null;
+    }
+    /**
+     * Disconnect the specified workspace.
+     */
+    disconnectWorkspace(workspaceDirName) {
+        const cdp = this.connections.get(workspaceDirName);
+        if (cdp) {
+            cdp.disconnect().catch((err) => {
+                logger_1.logger.error(`[CdpConnectionPool] Error while disconnecting ${workspaceDirName}:`, err);
+            });
+            this.connections.delete(workspaceDirName);
+        }
+        const detector = this.approvalDetectors.get(workspaceDirName);
+        if (detector) {
+            detector.stop();
+            this.approvalDetectors.delete(workspaceDirName);
+        }
+    }
+    /**
+     * Disconnect all workspace connections.
+     */
+    disconnectAll() {
+        for (const dirName of [...this.connections.keys()]) {
+            this.disconnectWorkspace(dirName);
+        }
+    }
+    /**
+     * Register an approval detector for a workspace.
+     */
+    registerApprovalDetector(workspaceDirName, detector) {
+        // Stop existing detector
+        const existing = this.approvalDetectors.get(workspaceDirName);
+        if (existing && existing.isActive()) {
+            existing.stop();
+        }
+        this.approvalDetectors.set(workspaceDirName, detector);
+    }
+    /**
+     * Get the approval detector for a workspace.
+     */
+    getApprovalDetector(workspaceDirName) {
+        return this.approvalDetectors.get(workspaceDirName);
+    }
+    /**
+     * Return a list of workspace names with active connections.
+     */
+    getActiveWorkspaceNames() {
+        const active = [];
+        for (const [name, cdp] of this.connections) {
+            if (cdp.isConnected()) {
+                active.push(name);
+            }
+        }
+        return active;
+    }
+    /**
+     * Extract the directory name from a workspace path.
+     */
+    extractDirName(workspacePath) {
+        return workspacePath.split('/').filter(Boolean).pop() || workspacePath;
+    }
+    /**
+     * Create a new CdpService and connect to the workspace.
+     */
+    async createAndConnect(workspacePath, dirName) {
+        // Disconnect old connection if exists
+        const old = this.connections.get(dirName);
+        if (old) {
+            await old.disconnect().catch(() => { });
+            this.connections.delete(dirName);
+        }
+        const cdp = new cdpService_1.CdpService(this.cdpOptions);
+        // Auto-cleanup on disconnect
+        cdp.on('disconnected', () => {
+            logger_1.logger.error(`[CdpConnectionPool] Workspace "${dirName}" disconnected`);
+            // Only remove from Map when reconnection fails
+            // (CdpService attempts reconnection internally, so we don't remove here)
+        });
+        cdp.on('reconnectFailed', () => {
+            logger_1.logger.error(`[CdpConnectionPool] Reconnection failed for workspace "${dirName}". Removing from pool`);
+            this.connections.delete(dirName);
+            const detector = this.approvalDetectors.get(dirName);
+            if (detector) {
+                detector.stop();
+                this.approvalDetectors.delete(dirName);
+            }
+        });
+        // Connect to the workspace
+        await cdp.discoverAndConnectForWorkspace(workspacePath);
+        this.connections.set(dirName, cdp);
+        return cdp;
+    }
+}
+exports.CdpConnectionPool = CdpConnectionPool;