lazy-gravity 0.6.1 → 0.7.0

package/dist/services/cdpBridgeManager.js

@@ -229,8 +229,10 @@ function parseRunCommandCustomId(customId) {
     return null;
 }
 /** Initialize the CDP bridge (lazy connection: pool creation only) */
-function initCdpBridge(autoApproveDefault) {
+function initCdpBridge(autoApproveDefault, accountPorts = {}, accountUserDataDirs = {}) {
     const pool = new cdpConnectionPool_1.CdpConnectionPool({
+        accountPorts,
+        accountUserDataDirs,
         cdpCallTimeout: 15000,
         // Keep CDP reconnection lazy: do not reopen windows in background.
         // Reconnection is triggered when the next chat/template message is sent.
@@ -247,6 +249,7 @@ function initCdpBridge(autoApproveDefault) {
         lastActiveChannel: null,
         approvalChannelByWorkspace: new Map(),
         approvalChannelBySession: new Map(),
+        selectedAccountByChannel: new Map(),
     };
 }
 /**
@@ -263,8 +266,8 @@ function getCurrentCdp(bridge) {
  * 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, projectName) {
-    const existing = bridge.pool.getApprovalDetector(projectName);
+function ensureApprovalDetector(bridge, cdp, projectName, accountName = 'default') {
+    const existing = bridge.pool.getApprovalDetector(projectName, accountName);
     if (existing && existing.isActive())
         return;
     // Track the most recent notification for auto-disable on resolve.
@@ -327,15 +330,15 @@ function ensureApprovalDetector(bridge, cdp, projectName) {
         },
     });
     detector.start();
-    bridge.pool.registerApprovalDetector(projectName, detector);
+    bridge.pool.registerApprovalDetector(projectName, detector, accountName);
     logger_1.logger.debug(`[ApprovalDetector:${projectName}] Started approval button detection`);
 }
 /**
  * Helper to start a planning detector for each workspace.
  * Does nothing if a detector for the same workspace is already running.
  */
-function ensurePlanningDetector(bridge, cdp, projectName) {
-    const existing = bridge.pool.getPlanningDetector(projectName);
+function ensurePlanningDetector(bridge, cdp, projectName, accountName = 'default') {
+    const existing = bridge.pool.getPlanningDetector(projectName, accountName);
     if (existing && existing.isActive())
         return;
     // Track the most recent planning notification for auto-disable on resolve.
@@ -387,15 +390,15 @@ function ensurePlanningDetector(bridge, cdp, projectName) {
         },
     });
     detector.start();
-    bridge.pool.registerPlanningDetector(projectName, detector);
+    bridge.pool.registerPlanningDetector(projectName, detector, accountName);
     logger_1.logger.debug(`[PlanningDetector:${projectName}] Started planning button detection`);
 }
 /**
  * Helper to start an error popup detector for each workspace.
  * Does nothing if a detector for the same workspace is already running.
  */
-function ensureErrorPopupDetector(bridge, cdp, projectName) {
-    const existing = bridge.pool.getErrorPopupDetector(projectName);
+function ensureErrorPopupDetector(bridge, cdp, projectName, accountName = 'default') {
+    const existing = bridge.pool.getErrorPopupDetector(projectName, accountName);
     if (existing && existing.isActive())
         return;
     // Track the most recent error notification for auto-disable on resolve.
@@ -443,7 +446,7 @@ function ensureErrorPopupDetector(bridge, cdp, projectName) {
         },
     });
     detector.start();
-    bridge.pool.registerErrorPopupDetector(projectName, detector);
+    bridge.pool.registerErrorPopupDetector(projectName, detector, accountName);
     logger_1.logger.debug(`[ErrorPopupDetector:${projectName}] Started error popup detection`);
 }
 /**
@@ -451,8 +454,8 @@ function ensureErrorPopupDetector(bridge, cdp, projectName) {
  * 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);
+function ensureRunCommandDetector(bridge, cdp, projectName, accountName = 'default') {
+    const existing = bridge.pool.getRunCommandDetector(projectName, accountName);
     if (existing && existing.isActive())
         return;
     let lastNotification = null;
@@ -511,7 +514,7 @@ function ensureRunCommandDetector(bridge, cdp, projectName) {
         },
     });
     detector.start();
-    bridge.pool.registerRunCommandDetector(projectName, detector);
+    bridge.pool.registerRunCommandDetector(projectName, detector, accountName);
     logger_1.logger.debug(`[RunCommandDetector:${projectName}] Started run command detection`);
 }
 /**
@@ -520,16 +523,18 @@ function ensureRunCommandDetector(bridge, cdp, projectName) {
  * and mirrors them to a Discord channel.
  * Does nothing if a detector for the same workspace is already running.
  */
-function ensureUserMessageDetector(bridge, cdp, projectName, onUserMessage) {
-    const existing = bridge.pool.getUserMessageDetector(projectName);
-    if (existing && existing.isActive())
+function ensureUserMessageDetector(bridge, cdp, projectName, onUserMessage, accountName = 'default') {
+    const existing = bridge.pool.getUserMessageDetector(projectName, accountName);
+    if (existing && existing.isActive()) {
+        existing.on('message', onUserMessage);
         return;
+    }
     const detector = new userMessageDetector_1.UserMessageDetector({
         cdpService: cdp,
         pollIntervalMs: 2000,
-        onUserMessage,
     });
+    detector.on('message', onUserMessage);
     detector.start();
-    bridge.pool.registerUserMessageDetector(projectName, detector);
+    bridge.pool.registerUserMessageDetector(projectName, detector, accountName);
     logger_1.logger.debug(`[UserMessageDetector:${projectName}] Started user message detection`);
 }

package/dist/services/cdpConnectionPool.js

@@ -4,15 +4,15 @@ exports.CdpConnectionPool = void 0;
 const logger_1 = require("../utils/logger");
 const pathUtils_1 = require("../utils/pathUtils");
 const cdpService_1 = require("./cdpService");
+function buildConnectionKey(projectName, accountName) {
+    return `${accountName}::${projectName}`;
+}
 /**
- * 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.
+ * Pool that manages independent CdpService instances per workspace/account pair.
  */
 class CdpConnectionPool {
     connections = new Map();
+    workspaceToAccount = new Map();
     approvalDetectors = new Map();
     errorPopupDetectors = new Map();
     planningDetectors = new Map();
@@ -23,245 +23,172 @@ class CdpConnectionPool {
     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) {
+    resolveAccountName(projectName, accountName, explicitSelection = false) {
+        if (explicitSelection) {
+            return accountName;
+        }
+        if (accountName !== 'default')
+            return accountName;
+        return this.workspaceToAccount.get(projectName) || accountName;
+    }
+    async getOrConnect(workspacePath, selection) {
         const projectName = this.extractProjectName(workspacePath);
-        // Return existing connection if available
-        const existing = this.connections.get(projectName);
+        const explicitSelection = typeof selection?.name === 'string';
+        const accountName = selection?.name || this.workspaceToAccount.get(projectName) || 'default';
+        const effectiveAccount = this.resolveAccountName(projectName, accountName, explicitSelection);
+        const key = buildConnectionKey(projectName, effectiveAccount);
+        const existing = this.connections.get(key);
         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(projectName);
+        const pending = this.connectingPromises.get(key);
         if (pending) {
             return pending;
         }
-        // Start a new connection
-        const connectPromise = this.createAndConnect(workspacePath, projectName);
-        this.connectingPromises.set(projectName, connectPromise);
+        const connectPromise = this.createAndConnect(workspacePath, projectName, effectiveAccount);
+        this.connectingPromises.set(key, connectPromise);
         try {
-            const cdp = await connectPromise;
-            return cdp;
+            return await connectPromise;
         }
         finally {
-            this.connectingPromises.delete(projectName);
+            this.connectingPromises.delete(key);
+            this.workspaceToAccount.set(projectName, effectiveAccount);
         }
     }
-    /**
-     * Get a connected CdpService (read-only).
-     * Returns null if not connected.
-     */
-    getConnected(projectName) {
-        const cdp = this.connections.get(projectName);
+    getConnected(projectName, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        const cdp = this.connections.get(buildConnectionKey(projectName, effectiveAccount));
         if (cdp && cdp.isConnected()) {
             return cdp;
         }
         return null;
     }
-    /**
-     * Disconnect the specified workspace.
-     */
-    disconnectWorkspace(projectName) {
-        const cdp = this.connections.get(projectName);
+    disconnectWorkspace(projectName, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        const key = buildConnectionKey(projectName, effectiveAccount);
+        const cdp = this.connections.get(key);
         if (cdp) {
             cdp.disconnect().catch((err) => {
-                logger_1.logger.error(`[CdpConnectionPool] Error while disconnecting ${projectName}:`, err);
+                logger_1.logger.error(`[CdpConnectionPool] Error while disconnecting ${key}:`, err);
             });
-            this.connections.delete(projectName);
-        }
-        const detector = this.approvalDetectors.get(projectName);
-        if (detector) {
-            detector.stop();
-            this.approvalDetectors.delete(projectName);
-        }
-        const errorPopupDetector = this.errorPopupDetectors.get(projectName);
-        if (errorPopupDetector) {
-            errorPopupDetector.stop();
-            this.errorPopupDetectors.delete(projectName);
-        }
-        const planningDetector = this.planningDetectors.get(projectName);
-        if (planningDetector) {
-            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();
-            this.userMessageDetectors.delete(projectName);
-        }
+            this.connections.delete(key);
+        }
+        this.approvalDetectors.get(key)?.stop();
+        this.approvalDetectors.delete(key);
+        this.errorPopupDetectors.get(key)?.stop();
+        this.errorPopupDetectors.delete(key);
+        this.planningDetectors.get(key)?.stop();
+        this.planningDetectors.delete(key);
+        this.runCommandDetectors.get(key)?.stop();
+        this.runCommandDetectors.delete(key);
+        this.userMessageDetectors.get(key)?.stop();
+        this.userMessageDetectors.delete(key);
     }
-    /**
-     * Disconnect all workspace connections.
-     */
     disconnectAll() {
-        for (const projectName of [...this.connections.keys()]) {
-            this.disconnectWorkspace(projectName);
-        }
-    }
-    /**
-     * Register an approval detector for a workspace.
-     */
-    registerApprovalDetector(projectName, detector) {
-        // Stop existing detector
-        const existing = this.approvalDetectors.get(projectName);
-        if (existing && existing.isActive()) {
-            existing.stop();
-        }
-        this.approvalDetectors.set(projectName, detector);
-    }
-    /**
-     * Get the approval detector for a workspace.
-     */
-    getApprovalDetector(projectName) {
-        return this.approvalDetectors.get(projectName);
-    }
-    /**
-     * Register an error popup detector for a workspace.
-     */
-    registerErrorPopupDetector(projectName, detector) {
-        // Stop existing detector
-        const existing = this.errorPopupDetectors.get(projectName);
-        if (existing && existing.isActive()) {
-            existing.stop();
-        }
-        this.errorPopupDetectors.set(projectName, detector);
-    }
-    /**
-     * Get the error popup detector for a workspace.
-     */
-    getErrorPopupDetector(projectName) {
-        return this.errorPopupDetectors.get(projectName);
-    }
-    /**
-     * Register a planning detector for a workspace.
-     */
-    registerPlanningDetector(projectName, detector) {
-        // Stop existing detector
-        const existing = this.planningDetectors.get(projectName);
-        if (existing && existing.isActive()) {
-            existing.stop();
-        }
-        this.planningDetectors.set(projectName, detector);
-    }
-    /**
-     * Get the planning detector for a workspace.
-     */
-    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.
-     */
-    registerUserMessageDetector(projectName, detector) {
-        const existing = this.userMessageDetectors.get(projectName);
-        if (existing && existing.isActive()) {
-            existing.stop();
-        }
-        this.userMessageDetectors.set(projectName, detector);
+        for (const key of [...this.connections.keys()]) {
+            const [accountName, projectName] = key.split('::');
+            this.disconnectWorkspace(projectName, accountName);
+        }
+    }
+    registerApprovalDetector(projectName, detector, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        const key = buildConnectionKey(projectName, effectiveAccount);
+        this.approvalDetectors.get(key)?.stop();
+        this.approvalDetectors.set(key, detector);
+    }
+    getApprovalDetector(projectName, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        return this.approvalDetectors.get(buildConnectionKey(projectName, effectiveAccount));
+    }
+    registerErrorPopupDetector(projectName, detector, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        const key = buildConnectionKey(projectName, effectiveAccount);
+        this.errorPopupDetectors.get(key)?.stop();
+        this.errorPopupDetectors.set(key, detector);
+    }
+    getErrorPopupDetector(projectName, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        return this.errorPopupDetectors.get(buildConnectionKey(projectName, effectiveAccount));
+    }
+    registerPlanningDetector(projectName, detector, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        const key = buildConnectionKey(projectName, effectiveAccount);
+        this.planningDetectors.get(key)?.stop();
+        this.planningDetectors.set(key, detector);
+    }
+    getPlanningDetector(projectName, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        return this.planningDetectors.get(buildConnectionKey(projectName, effectiveAccount));
+    }
+    registerRunCommandDetector(projectName, detector, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        const key = buildConnectionKey(projectName, effectiveAccount);
+        this.runCommandDetectors.get(key)?.stop();
+        this.runCommandDetectors.set(key, detector);
+    }
+    getRunCommandDetector(projectName, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        return this.runCommandDetectors.get(buildConnectionKey(projectName, effectiveAccount));
+    }
+    registerUserMessageDetector(projectName, detector, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        const key = buildConnectionKey(projectName, effectiveAccount);
+        this.userMessageDetectors.get(key)?.stop();
+        this.userMessageDetectors.set(key, detector);
+    }
+    getUserMessageDetector(projectName, accountName = 'default') {
+        const effectiveAccount = this.resolveAccountName(projectName, accountName);
+        return this.userMessageDetectors.get(buildConnectionKey(projectName, effectiveAccount));
+    }
+    setPreferredAccountForWorkspace(workspacePath, accountName) {
+        const projectName = this.extractProjectName(workspacePath);
+        this.workspaceToAccount.set(projectName, accountName);
     }
-    /**
-     * Get the user message detector for a workspace.
-     */
-    getUserMessageDetector(projectName) {
-        return this.userMessageDetectors.get(projectName);
+    getPreferredAccountForWorkspace(workspacePath) {
+        const projectName = this.extractProjectName(workspacePath);
+        return this.workspaceToAccount.get(projectName) ?? null;
     }
-    /**
-     * 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);
-            }
+        const active = new Set();
+        for (const [key, cdp] of this.connections) {
+            if (!cdp.isConnected())
+                continue;
+            const [, projectName] = key.split('::');
+            active.add(projectName || key);
         }
-        return active;
+        return [...active];
     }
-    /**
-     * Extract the project name from a workspace path.
-     */
     extractProjectName(workspacePath) {
         return (0, pathUtils_1.extractProjectNameFromPath)(workspacePath) || workspacePath;
     }
-    /**
-     * Create a new CdpService and connect to the workspace.
-     */
-    async createAndConnect(workspacePath, projectName) {
-        // Disconnect old connection if exists
-        const old = this.connections.get(projectName);
+    async createAndConnect(workspacePath, projectName, accountName) {
+        const key = buildConnectionKey(projectName, accountName);
+        const old = this.connections.get(key);
         if (old) {
             await old.disconnect().catch(() => { });
-            this.connections.delete(projectName);
+            this.connections.delete(key);
         }
-        const cdp = new cdpService_1.CdpService(this.cdpOptions);
-        // Auto-cleanup on disconnect
-        cdp.on('disconnected', () => {
-            logger_1.logger.error(`[CdpConnectionPool] Workspace "${projectName}" disconnected`);
-            // Only remove from Map when reconnection fails
-            // (CdpService attempts reconnection internally, so we don't remove here)
+        const cdp = new cdpService_1.CdpService({
+            ...this.cdpOptions,
+            accountName,
         });
         cdp.on('reconnectFailed', () => {
-            logger_1.logger.error(`[CdpConnectionPool] Reconnection failed for workspace "${projectName}". Removing from pool`);
-            this.connections.delete(projectName);
-            const detector = this.approvalDetectors.get(projectName);
-            if (detector) {
-                detector.stop();
-                this.approvalDetectors.delete(projectName);
-            }
-            const errorDetector = this.errorPopupDetectors.get(projectName);
-            if (errorDetector) {
-                errorDetector.stop();
-                this.errorPopupDetectors.delete(projectName);
-            }
-            const planDetector = this.planningDetectors.get(projectName);
-            if (planDetector) {
-                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();
-                this.userMessageDetectors.delete(projectName);
-            }
+            logger_1.logger.error(`[CdpConnectionPool] Reconnection failed for workspace "${key}". Removing from pool`);
+            this.connections.delete(key);
+            this.approvalDetectors.get(key)?.stop();
+            this.approvalDetectors.delete(key);
+            this.errorPopupDetectors.get(key)?.stop();
+            this.errorPopupDetectors.delete(key);
+            this.planningDetectors.get(key)?.stop();
+            this.planningDetectors.delete(key);
+            this.runCommandDetectors.get(key)?.stop();
+            this.runCommandDetectors.delete(key);
+            this.userMessageDetectors.get(key)?.stop();
+            this.userMessageDetectors.delete(key);
         });
-        // Connect to the workspace
         await cdp.discoverAndConnectForWorkspace(workspacePath);
-        this.connections.set(projectName, cdp);
+        this.connections.set(key, cdp);
         return cdp;
     }
 }