lazy-gravity 0.1.0 → 0.2.0

package/dist/services/cdpConnectionPool.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpConnectionPool = void 0;
 const logger_1 = require("../utils/logger");
+const pathUtils_1 = require("../utils/pathUtils");
 const cdpService_1 = require("./cdpService");
 /**
  * Pool that manages independent CdpService instances per workspace.
@@ -15,6 +16,7 @@ class CdpConnectionPool {
     approvalDetectors = new Map();
     errorPopupDetectors = new Map();
     planningDetectors = new Map();
+    userMessageDetectors = new Map();
     connectingPromises = new Map();
     cdpOptions;
     constructor(cdpOptions = {}) {
@@ -29,36 +31,36 @@ class CdpConnectionPool {
      * @returns Connected CdpService
      */
     async getOrConnect(workspacePath) {
-        const dirName = this.extractDirName(workspacePath);
+        const projectName = this.extractProjectName(workspacePath);
         // Return existing connection if available
-        const existing = this.connections.get(dirName);
+        const existing = this.connections.get(projectName);
         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);
+        const pending = this.connectingPromises.get(projectName);
         if (pending) {
             return pending;
         }
         // Start a new connection
-        const connectPromise = this.createAndConnect(workspacePath, dirName);
-        this.connectingPromises.set(dirName, connectPromise);
+        const connectPromise = this.createAndConnect(workspacePath, projectName);
+        this.connectingPromises.set(projectName, connectPromise);
         try {
             const cdp = await connectPromise;
             return cdp;
         }
         finally {
-            this.connectingPromises.delete(dirName);
+            this.connectingPromises.delete(projectName);
         }
     }
     /**
      * Get a connected CdpService (read-only).
      * Returns null if not connected.
      */
-    getConnected(workspaceDirName) {
-        const cdp = this.connections.get(workspaceDirName);
+    getConnected(projectName) {
+        const cdp = this.connections.get(projectName);
         if (cdp && cdp.isConnected()) {
             return cdp;
         }
@@ -67,88 +69,109 @@ class CdpConnectionPool {
     /**
      * Disconnect the specified workspace.
      */
-    disconnectWorkspace(workspaceDirName) {
-        const cdp = this.connections.get(workspaceDirName);
+    disconnectWorkspace(projectName) {
+        const cdp = this.connections.get(projectName);
         if (cdp) {
             cdp.disconnect().catch((err) => {
-                logger_1.logger.error(`[CdpConnectionPool] Error while disconnecting ${workspaceDirName}:`, err);
+                logger_1.logger.error(`[CdpConnectionPool] Error while disconnecting ${projectName}:`, err);
             });
-            this.connections.delete(workspaceDirName);
+            this.connections.delete(projectName);
         }
-        const detector = this.approvalDetectors.get(workspaceDirName);
+        const detector = this.approvalDetectors.get(projectName);
         if (detector) {
             detector.stop();
-            this.approvalDetectors.delete(workspaceDirName);
+            this.approvalDetectors.delete(projectName);
         }
-        const errorPopupDetector = this.errorPopupDetectors.get(workspaceDirName);
+        const errorPopupDetector = this.errorPopupDetectors.get(projectName);
         if (errorPopupDetector) {
             errorPopupDetector.stop();
-            this.errorPopupDetectors.delete(workspaceDirName);
+            this.errorPopupDetectors.delete(projectName);
         }
-        const planningDetector = this.planningDetectors.get(workspaceDirName);
+        const planningDetector = this.planningDetectors.get(projectName);
         if (planningDetector) {
             planningDetector.stop();
-            this.planningDetectors.delete(workspaceDirName);
+            this.planningDetectors.delete(projectName);
+        }
+        const userMsgDetector = this.userMessageDetectors.get(projectName);
+        if (userMsgDetector) {
+            userMsgDetector.stop();
+            this.userMessageDetectors.delete(projectName);
         }
     }
     /**
      * Disconnect all workspace connections.
      */
     disconnectAll() {
-        for (const dirName of [...this.connections.keys()]) {
-            this.disconnectWorkspace(dirName);
+        for (const projectName of [...this.connections.keys()]) {
+            this.disconnectWorkspace(projectName);
         }
     }
     /**
      * Register an approval detector for a workspace.
      */
-    registerApprovalDetector(workspaceDirName, detector) {
+    registerApprovalDetector(projectName, detector) {
         // Stop existing detector
-        const existing = this.approvalDetectors.get(workspaceDirName);
+        const existing = this.approvalDetectors.get(projectName);
         if (existing && existing.isActive()) {
             existing.stop();
         }
-        this.approvalDetectors.set(workspaceDirName, detector);
+        this.approvalDetectors.set(projectName, detector);
     }
     /**
      * Get the approval detector for a workspace.
      */
-    getApprovalDetector(workspaceDirName) {
-        return this.approvalDetectors.get(workspaceDirName);
+    getApprovalDetector(projectName) {
+        return this.approvalDetectors.get(projectName);
     }
     /**
      * Register an error popup detector for a workspace.
      */
-    registerErrorPopupDetector(workspaceDirName, detector) {
+    registerErrorPopupDetector(projectName, detector) {
         // Stop existing detector
-        const existing = this.errorPopupDetectors.get(workspaceDirName);
+        const existing = this.errorPopupDetectors.get(projectName);
         if (existing && existing.isActive()) {
             existing.stop();
         }
-        this.errorPopupDetectors.set(workspaceDirName, detector);
+        this.errorPopupDetectors.set(projectName, detector);
     }
     /**
      * Get the error popup detector for a workspace.
      */
-    getErrorPopupDetector(workspaceDirName) {
-        return this.errorPopupDetectors.get(workspaceDirName);
+    getErrorPopupDetector(projectName) {
+        return this.errorPopupDetectors.get(projectName);
     }
     /**
      * Register a planning detector for a workspace.
      */
-    registerPlanningDetector(workspaceDirName, detector) {
+    registerPlanningDetector(projectName, detector) {
         // Stop existing detector
-        const existing = this.planningDetectors.get(workspaceDirName);
+        const existing = this.planningDetectors.get(projectName);
         if (existing && existing.isActive()) {
             existing.stop();
         }
-        this.planningDetectors.set(workspaceDirName, detector);
+        this.planningDetectors.set(projectName, detector);
     }
     /**
      * Get the planning detector for a workspace.
      */
-    getPlanningDetector(workspaceDirName) {
-        return this.planningDetectors.get(workspaceDirName);
+    getPlanningDetector(projectName) {
+        return this.planningDetectors.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);
+    }
+    /**
+     * Get the user message detector for a workspace.
+     */
+    getUserMessageDetector(projectName) {
+        return this.userMessageDetectors.get(projectName);
     }
     /**
      * Return a list of workspace names with active connections.
@@ -163,50 +186,55 @@ class CdpConnectionPool {
         return active;
     }
     /**
-     * Extract the directory name from a workspace path.
+     * Extract the project name from a workspace path.
      */
-    extractDirName(workspacePath) {
-        return workspacePath.split('/').filter(Boolean).pop() || workspacePath;
+    extractProjectName(workspacePath) {
+        return (0, pathUtils_1.extractProjectNameFromPath)(workspacePath) || workspacePath;
     }
     /**
      * Create a new CdpService and connect to the workspace.
      */
-    async createAndConnect(workspacePath, dirName) {
+    async createAndConnect(workspacePath, projectName) {
         // Disconnect old connection if exists
-        const old = this.connections.get(dirName);
+        const old = this.connections.get(projectName);
         if (old) {
             await old.disconnect().catch(() => { });
-            this.connections.delete(dirName);
+            this.connections.delete(projectName);
         }
         const cdp = new cdpService_1.CdpService(this.cdpOptions);
         // Auto-cleanup on disconnect
         cdp.on('disconnected', () => {
-            logger_1.logger.error(`[CdpConnectionPool] Workspace "${dirName}" 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)
         });
         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);
+            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(dirName);
+                this.approvalDetectors.delete(projectName);
             }
-            const errorDetector = this.errorPopupDetectors.get(dirName);
+            const errorDetector = this.errorPopupDetectors.get(projectName);
             if (errorDetector) {
                 errorDetector.stop();
-                this.errorPopupDetectors.delete(dirName);
+                this.errorPopupDetectors.delete(projectName);
             }
-            const planDetector = this.planningDetectors.get(dirName);
+            const planDetector = this.planningDetectors.get(projectName);
             if (planDetector) {
                 planDetector.stop();
-                this.planningDetectors.delete(dirName);
+                this.planningDetectors.delete(projectName);
+            }
+            const userMsgDetector = this.userMessageDetectors.get(projectName);
+            if (userMsgDetector) {
+                userMsgDetector.stop();
+                this.userMessageDetectors.delete(projectName);
             }
         });
         // Connect to the workspace
         await cdp.discoverAndConnectForWorkspace(workspacePath);
-        this.connections.set(dirName, cdp);
+        this.connections.set(projectName, cdp);
         return cdp;
     }
 }

package/dist/services/cdpService.js

@@ -42,6 +42,7 @@ const cdpPorts_1 = require("../utils/cdpPorts");
 const events_1 = require("events");
 const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
+const pathUtils_1 = require("../utils/pathUtils");
 const ws_1 = __importDefault(require("ws"));
 /** Antigravity UI DOM selector constants */
 const SELECTORS = {
@@ -251,19 +252,19 @@ class CdpService extends events_1.EventEmitter {
      * @returns true on successful connection
      */
     async discoverAndConnectForWorkspace(workspacePath) {
-        const workspaceDirName = workspacePath.split('/').filter(Boolean).pop() || '';
+        const projectName = (0, pathUtils_1.extractProjectNameFromPath)(workspacePath);
         this.currentWorkspacePath = workspacePath;
         // Re-validate existing connection before skipping reconnect.
-        if (this.isConnectedFlag && this.currentWorkspaceName === workspaceDirName) {
-            const stillMatched = await this.verifyCurrentWorkspace(workspaceDirName, workspacePath);
+        if (this.isConnectedFlag && this.currentWorkspaceName === projectName) {
+            const stillMatched = await this.verifyCurrentWorkspace(projectName, workspacePath);
             if (stillMatched) {
                 return true;
             }
-            logger_1.logger.warn(`[CdpService] Workspace mismatch detected while reusing connection (expected="${workspaceDirName}"). Reconnecting...`);
+            logger_1.logger.warn(`[CdpService] Workspace mismatch detected while reusing connection (expected="${projectName}"). Reconnecting...`);
         }
         this.isSwitchingWorkspace = true;
         try {
-            return await this._discoverAndConnectForWorkspaceImpl(workspacePath, workspaceDirName);
+            return await this._discoverAndConnectForWorkspaceImpl(workspacePath, projectName);
         }
         finally {
             this.isSwitchingWorkspace = false;
@@ -272,7 +273,7 @@ class CdpService extends events_1.EventEmitter {
     /**
      * Verify whether the currently attached page still represents the expected workspace.
      */
-    async verifyCurrentWorkspace(workspaceDirName, workspacePath) {
+    async verifyCurrentWorkspace(projectName, workspacePath) {
         if (!this.ws || this.ws.readyState !== ws_1.default.OPEN || !this.isConnectedFlag) {
             return false;
         }
@@ -282,17 +283,17 @@ class CdpService extends events_1.EventEmitter {
                 returnByValue: true,
             });
             const liveTitle = String(titleResult?.result?.value || '');
-            if (liveTitle.includes(workspaceDirName)) {
-                this.currentWorkspaceName = workspaceDirName;
+            if (liveTitle.toLowerCase().includes(projectName.toLowerCase())) {
+                this.currentWorkspaceName = projectName;
                 return true;
             }
         }
         catch {
             // Fall through to folder-path probe.
         }
-        return this.probeWorkspaceFolderPath(workspaceDirName, workspacePath);
+        return this.probeWorkspaceFolderPath(projectName, workspacePath);
     }
-    async _discoverAndConnectForWorkspaceImpl(workspacePath, workspaceDirName) {
+    async _discoverAndConnectForWorkspaceImpl(workspacePath, projectName) {
         // Scan all ports to collect workbench pages
         let pages = [];
         let respondingPort = null;
@@ -316,7 +317,7 @@ class CdpService extends events_1.EventEmitter {
         }
         if (respondingPort === null) {
             // Launch Antigravity if no port responds
-            return this.launchAndConnectWorkspace(workspacePath, workspaceDirName);
+            return this.launchAndConnectWorkspace(workspacePath, projectName);
         }
         // Filter workbench pages only (exclude Launchpad, Manager, iframe, worker)
         const workbenchPages = pages.filter((t) => t.type === 'page' &&
@@ -324,38 +325,38 @@ class CdpService extends events_1.EventEmitter {
             !t.title?.includes('Launchpad') &&
             !t.url?.includes('workbench-jetski-agent') &&
             t.url?.includes('workbench'));
-        logger_1.logger.info(`[CdpService] Searching for workspace "${workspaceDirName}" (port=${respondingPort})... ${workbenchPages.length} workbench pages:`);
+        logger_1.logger.debug(`[CdpService] Searching for workspace "${projectName}" (port=${respondingPort})... ${workbenchPages.length} workbench pages:`);
         for (const p of workbenchPages) {
-            logger_1.logger.info(`  - title="${p.title}" url=${p.url}`);
+            logger_1.logger.debug(`  - title="${p.title}" url=${p.url}`);
         }
         // 1. Title match (fast path)
-        const titleMatch = workbenchPages.find((t) => t.title?.includes(workspaceDirName));
+        const titleMatch = workbenchPages.find((t) => t.title?.includes(projectName));
         if (titleMatch) {
-            return this.connectToPage(titleMatch, workspaceDirName);
+            return this.connectToPage(titleMatch, projectName);
         }
         // 2. Title match failed -> CDP probe (connect to each page and check document.title)
-        logger_1.logger.info(`[CdpService] Title match failed. Searching via CDP probe...`);
-        const probeResult = await this.probeWorkbenchPages(workbenchPages, workspaceDirName, workspacePath);
+        logger_1.logger.debug(`[CdpService] Title match failed. Searching via CDP probe...`);
+        const probeResult = await this.probeWorkbenchPages(workbenchPages, projectName, workspacePath);
         if (probeResult) {
             return true;
         }
         // 3. If not found by probe either, launch a new window
-        return this.launchAndConnectWorkspace(workspacePath, workspaceDirName);
+        return this.launchAndConnectWorkspace(workspacePath, projectName);
     }
     /**
      * Connect to the specified page (skip if already connected).
      */
-    async connectToPage(page, workspaceDirName) {
+    async connectToPage(page, projectName) {
         // No reconnection needed if already connected to the same URL
         if (this.isConnectedFlag && this.targetUrl === page.webSocketDebuggerUrl) {
-            this.currentWorkspaceName = workspaceDirName;
+            this.currentWorkspaceName = projectName;
             return true;
         }
         this.disconnectQuietly();
         this.targetUrl = page.webSocketDebuggerUrl;
         await this.connect();
-        this.currentWorkspaceName = workspaceDirName;
-        logger_1.logger.info(`[CdpService] Connected to workspace "${workspaceDirName}"`);
+        this.currentWorkspaceName = projectName;
+        logger_1.logger.debug(`[CdpService] Connected to workspace "${projectName}"`);
         return true;
     }
     /**
@@ -365,10 +366,10 @@ class CdpService extends events_1.EventEmitter {
      * If the title is "Untitled (Workspace)", verify workspace folder path via CDP.
      *
      * @param workbenchPages List of workbench pages
-     * @param workspaceDirName Workspace directory name
+     * @param projectName Workspace directory name
      * @param workspacePath Full workspace path (for folder path matching)
      */
-    async probeWorkbenchPages(workbenchPages, workspaceDirName, workspacePath) {
+    async probeWorkbenchPages(workbenchPages, projectName, workspacePath) {
         for (const page of workbenchPages) {
             try {
                 // Temporarily connect to retrieve document.title
@@ -379,15 +380,17 @@ class CdpService extends events_1.EventEmitter {
                     expression: 'document.title',
                     returnByValue: true,
                 });
-                const liveTitle = result?.result?.value || '';
-                if (liveTitle.includes(workspaceDirName)) {
-                    this.currentWorkspaceName = workspaceDirName;
-                    logger_1.logger.info(`[CdpService] Probe success: detected "${workspaceDirName}"`);
+                const liveTitle = String(result?.result?.value || '');
+                const normalizedLiveTitle = liveTitle.toLowerCase();
+                const normalizedProject = projectName.toLowerCase();
+                if (normalizedLiveTitle.includes(normalizedProject)) {
+                    this.currentWorkspaceName = projectName;
+                    logger_1.logger.debug(`[CdpService] Probe success: detected "${projectName}"`);
                     return true;
                 }
                 // If title is "Untitled (Workspace)", verify by folder path
-                if (liveTitle.includes('Untitled') && workspacePath) {
-                    const folderMatch = await this.probeWorkspaceFolderPath(workspaceDirName, workspacePath);
+                if (normalizedLiveTitle.includes('untitled') && workspacePath) {
+                    const folderMatch = await this.probeWorkspaceFolderPath(projectName, workspacePath);
                     if (folderMatch) {
                         return true;
                     }
@@ -410,7 +413,7 @@ class CdpService extends events_1.EventEmitter {
      * 2. Check folder path display in DOM
      * 3. Get workspace info from window.location.hash, etc.
      */
-    async probeWorkspaceFolderPath(workspaceDirName, workspacePath) {
+    async probeWorkspaceFolderPath(projectName, workspacePath) {
         try {
             // Instead of DOM/document.title, check folder parameter in page URL or
             // folder name in explorer view
@@ -445,10 +448,13 @@ class CdpService extends events_1.EventEmitter {
             const value = res?.result?.value;
             if (value?.found && value?.value) {
                 const detectedValue = value.value;
-                if (detectedValue.includes(workspaceDirName) ||
-                    detectedValue.includes(workspacePath)) {
-                    this.currentWorkspaceName = workspaceDirName;
-                    logger_1.logger.info(`[CdpService] Folder path match success: "${workspaceDirName}"`);
+                const normalizedDetected = detectedValue.toLowerCase();
+                const normalizedProject = projectName.toLowerCase();
+                const normalizedWorkspace = workspacePath.toLowerCase();
+                if (normalizedDetected.includes(normalizedProject) ||
+                    normalizedDetected.includes(normalizedWorkspace)) {
+                    this.currentWorkspaceName = projectName;
+                    logger_1.logger.debug(`[CdpService] Folder path match success: "${projectName}"`);
                     return true;
                 }
             }
@@ -457,10 +463,11 @@ class CdpService extends events_1.EventEmitter {
                 expression: 'window.location.href',
                 returnByValue: true,
             });
-            const pageUrl = urlResult?.result?.value || '';
-            if (pageUrl.includes(encodeURIComponent(workspacePath)) || pageUrl.includes(workspaceDirName)) {
-                this.currentWorkspaceName = workspaceDirName;
-                logger_1.logger.info(`[CdpService] URL parameter match success: "${workspaceDirName}"`);
+            const pageUrl = (urlResult?.result?.value || '').toLowerCase();
+            const normalizedWorkspaceUri = encodeURIComponent(workspacePath).toLowerCase();
+            if (pageUrl.includes(normalizedWorkspaceUri) || pageUrl.includes(projectName.toLowerCase())) {
+                this.currentWorkspaceName = projectName;
+                logger_1.logger.debug(`[CdpService] URL parameter match success: "${projectName}"`);
                 return true;
             }
         }
@@ -472,19 +479,24 @@ class CdpService extends events_1.EventEmitter {
     /**
      * Launch Antigravity and wait for a new workbench page to appear, then connect.
      */
-    async launchAndConnectWorkspace(workspacePath, workspaceDirName) {
+    async launchAndConnectWorkspace(workspacePath, projectName) {
         // Open as folder using Antigravity CLI (not as workspace mode).
         // `open -a Antigravity` may open as workspace, resulting in title "Untitled (Workspace)".
         // CLI --new-window opens as folder, immediately reflecting directory name in title.
-        const antigravityCli = '/Applications/Antigravity.app/Contents/Resources/app/bin/antigravity';
-        logger_1.logger.info(`[CdpService] Launching Antigravity: ${antigravityCli} --new-window ${workspacePath}`);
+        const antigravityCli = (0, pathUtils_1.getAntigravityCliPath)();
+        logger_1.logger.debug(`[CdpService] Launching Antigravity: ${antigravityCli} --new-window ${workspacePath}`);
         try {
             await this.runCommand(antigravityCli, ['--new-window', workspacePath]);
         }
         catch (error) {
-            // Fall back to open -a if CLI not found
-            logger_1.logger.warn(`[CdpService] CLI launch failed, falling back to open -a: ${error?.message || String(error)}`);
-            await this.runCommand('open', ['-a', 'Antigravity', workspacePath]);
+            // Fall back to open -a if CLI not found (macOS only)
+            logger_1.logger.warn(`[CdpService] CLI launch failed, falling back to open -a (if macOS): ${error?.message || String(error)}`);
+            if (process.platform === 'darwin') {
+                await this.runCommand('open', ['-a', 'Antigravity', workspacePath]);
+            }
+            else {
+                throw error;
+            }
         }
         // Poll until a new workbench page appears (max 30 seconds)
         const maxWaitMs = 30000;
@@ -524,12 +536,12 @@ class CdpService extends events_1.EventEmitter {
                 !t.url?.includes('workbench-jetski-agent') &&
                 t.url?.includes('workbench'));
             // Title match
-            const titleMatch = workbenchPages.find((t) => t.title?.includes(workspaceDirName));
+            const titleMatch = workbenchPages.find((t) => t.title?.toLowerCase().includes(projectName.toLowerCase()));
             if (titleMatch) {
-                return this.connectToPage(titleMatch, workspaceDirName);
+                return this.connectToPage(titleMatch, projectName);
             }
             // CDP probe (also check folder path if title is not updated)
-            const probeResult = await this.probeWorkbenchPages(workbenchPages, workspaceDirName, workspacePath);
+            const probeResult = await this.probeWorkbenchPages(workbenchPages, projectName, workspacePath);
             if (probeResult) {
                 return true;
             }
@@ -539,12 +551,12 @@ class CdpService extends events_1.EventEmitter {
                 const newUntitledPages = workbenchPages.filter((t) => !knownPageIds.has(t.id) &&
                     (t.title?.includes('Untitled') || t.title === ''));
                 if (newUntitledPages.length === 1) {
-                    logger_1.logger.info(`[CdpService] New Untitled page detected. Connecting as "${workspaceDirName}" (page.id=${newUntitledPages[0].id})`);
-                    return this.connectToPage(newUntitledPages[0], workspaceDirName);
+                    logger_1.logger.debug(`[CdpService] New Untitled page detected. Connecting as "${projectName}" (page.id=${newUntitledPages[0].id})`);
+                    return this.connectToPage(newUntitledPages[0], projectName);
                 }
             }
         }
-        throw new Error(`Workbench page for workspace "${workspaceDirName}" not found within ${maxWaitMs / 1000} seconds`);
+        throw new Error(`Workbench page for workspace "${projectName}" not found within ${maxWaitMs / 1000} seconds`);
     }
     async runCommand(command, args) {
         await new Promise((resolve, reject) => {
@@ -698,6 +710,46 @@ class CdpService extends events_1.EventEmitter {
         }
         return { ok: false, error: 'Chat input field not found' };
     }
+    /**
+     * Select all text in the focused input and delete it to ensure a clean state.
+     * Uses Meta+A (select all) then Backspace (delete) via CDP key events.
+     */
+    async clearInputField() {
+        // Meta+A to select all content
+        await this.call('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key: 'a',
+            code: 'KeyA',
+            modifiers: 4, // Meta (Cmd on macOS)
+            windowsVirtualKeyCode: 65,
+            nativeVirtualKeyCode: 65,
+        });
+        await this.call('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key: 'a',
+            code: 'KeyA',
+            modifiers: 4,
+            windowsVirtualKeyCode: 65,
+            nativeVirtualKeyCode: 65,
+        });
+        // Backspace to delete selected content
+        await this.call('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key: 'Backspace',
+            code: 'Backspace',
+            windowsVirtualKeyCode: 8,
+            nativeVirtualKeyCode: 8,
+        });
+        await this.call('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key: 'Backspace',
+            code: 'Backspace',
+            windowsVirtualKeyCode: 8,
+            nativeVirtualKeyCode: 8,
+        });
+        // Wait for DOM to settle
+        await new Promise(r => setTimeout(r, 50));
+    }
     /**
      * Send Enter key to submit the message.
      */
@@ -846,6 +898,8 @@ class CdpService extends events_1.EventEmitter {
         if (!focusResult.ok) {
             return { ok: false, error: focusResult.error || 'Chat input field not found' };
         }
+        // Clear any existing text in the input field before injecting
+        await this.clearInputField();
         // 1. Input text via CDP Input.insertText
         await this.call('Input.insertText', { text });
         await new Promise(r => setTimeout(r, 200));
@@ -864,6 +918,8 @@ class CdpService extends events_1.EventEmitter {
         if (!focusResult.ok) {
             return { ok: false, error: focusResult.error || 'Chat input field not found' };
         }
+        // Clear any existing text in the input field before injecting
+        await this.clearInputField();
         const attachResult = await this.attachImageFiles(imageFilePaths, focusResult.contextId);
         if (!attachResult.ok) {
             return { ok: false, error: attachResult.error || 'Failed to attach images' };
@@ -1055,6 +1111,48 @@ class CdpService extends events_1.EventEmitter {
             return [];
         }
     }
+    /**
+     * Get the currently selected mode from the Antigravity UI.
+     * Reads the mode toggle button text and maps it back to internal mode name.
+     *
+     * @returns Internal mode name (e.g., 'fast', 'plan') or null if not found
+     */
+    async getCurrentMode() {
+        if (!this.isConnectedFlag || !this.ws) {
+            return null;
+        }
+        const expression = '(() => {'
+            + ' const uiNameMap = { fast: "Fast", plan: "Planning" };'
+            + ' const knownModes = Object.values(uiNameMap).map(n => n.toLowerCase());'
+            + ' const reverseMap = {};'
+            + ' Object.entries(uiNameMap).forEach(([k, v]) => { reverseMap[v.toLowerCase()] = k; });'
+            + ' const allBtns = Array.from(document.querySelectorAll("button"));'
+            + ' const visibleBtns = allBtns.filter(b => b.offsetParent !== null);'
+            + ' const modeToggleBtn = visibleBtns.find(b => {'
+            + '   const text = (b.textContent || "").trim().toLowerCase();'
+            + '   const hasChevron = b.querySelector("svg[class*=\\"chevron\\"]");'
+            + '   return knownModes.some(m => text === m) && hasChevron;'
+            + ' });'
+            + ' if (!modeToggleBtn) return null;'
+            + ' const currentModeText = (modeToggleBtn.textContent || "").trim().toLowerCase();'
+            + ' return reverseMap[currentModeText] || null;'
+            + '})()';
+        try {
+            const contextId = this.getPrimaryContextId();
+            const callParams = {
+                expression,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            if (contextId !== null)
+                callParams.contextId = contextId;
+            const res = await this.call('Runtime.evaluate', callParams);
+            return res?.result?.value || null;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Operate Antigravity UI mode dropdown to switch to the specified mode.
      * Two-step approach: