chrome-ai-bridge 1.0.8 → 1.0.9

package/build/src/download-manager.js

@@ -16,8 +16,62 @@ export class DownloadManager extends EventEmitter {
         this.page = page;
         this.downloadDir = downloadDir;
     }
+    /**
+     * Handle downloadWillBegin event
+     */
+    handleDownloadWillBegin = (event) => {
+        const info = {
+            guid: event.guid,
+            url: event.url,
+            suggestedFilename: event.suggestedFilename,
+            state: 'inProgress',
+            receivedBytes: 0,
+            totalBytes: 0,
+        };
+        this.pendingDownloads.set(event.guid, info);
+        this.emit('started', event.suggestedFilename);
+    };
+    /**
+     * Handle downloadProgress event
+     */
+    handleDownloadProgress = (event) => {
+        const info = this.pendingDownloads.get(event.guid);
+        if (!info)
+            return;
+        info.receivedBytes = event.receivedBytes;
+        info.totalBytes = event.totalBytes;
+        info.state = event.state;
+        // Emit progress
+        if (event.totalBytes > 0) {
+            const percent = Math.round((event.receivedBytes / event.totalBytes) * 100);
+            this.emit('progress', percent, info.suggestedFilename);
+        }
+        // Handle completion
+        if (event.state === 'completed') {
+            // Construct the final path
+            const finalPath = `${this.downloadDir}/${info.suggestedFilename}`;
+            info.resolvedPath = finalPath;
+            this.emit('completed', finalPath);
+            // Resolve any waiting promises
+            const resolver = this.downloadPromiseResolvers.get(event.guid);
+            if (resolver) {
+                resolver.resolve(finalPath);
+                this.downloadPromiseResolvers.delete(event.guid);
+            }
+        }
+        else if (event.state === 'canceled') {
+            this.emit('canceled', info.suggestedFilename);
+            const resolver = this.downloadPromiseResolvers.get(event.guid);
+            if (resolver) {
+                resolver.reject(new Error('Download canceled'));
+                this.downloadPromiseResolvers.delete(event.guid);
+            }
+        }
+    };
     /**
      * Start monitoring downloads using CDP events
+     * Event handlers are registered immediately after CDP session creation
+     * to prevent race conditions
      */
     async startMonitoring() {
         if (this.isMonitoring) {
@@ -25,59 +79,16 @@ export class DownloadManager extends EventEmitter {
         }
         // Create CDP session
         this.cdpSession = await this.page.createCDPSession();
+        // Register event handlers IMMEDIATELY after CDP session creation
+        // This prevents race condition where events could be missed
+        this.cdpSession.on('Browser.downloadWillBegin', this.handleDownloadWillBegin);
+        this.cdpSession.on('Browser.downloadProgress', this.handleDownloadProgress);
         // Enable download events
         await this.cdpSession.send('Browser.setDownloadBehavior', {
             behavior: 'allowAndName',
             downloadPath: this.downloadDir,
             eventsEnabled: true,
         });
-        // Listen for download events
-        this.cdpSession.on('Browser.downloadWillBegin', (event) => {
-            const info = {
-                guid: event.guid,
-                url: event.url,
-                suggestedFilename: event.suggestedFilename,
-                state: 'inProgress',
-                receivedBytes: 0,
-                totalBytes: 0,
-            };
-            this.pendingDownloads.set(event.guid, info);
-            this.emit('started', event.suggestedFilename);
-        });
-        this.cdpSession.on('Browser.downloadProgress', (event) => {
-            const info = this.pendingDownloads.get(event.guid);
-            if (!info)
-                return;
-            info.receivedBytes = event.receivedBytes;
-            info.totalBytes = event.totalBytes;
-            info.state = event.state;
-            // Emit progress
-            if (event.totalBytes > 0) {
-                const percent = Math.round((event.receivedBytes / event.totalBytes) * 100);
-                this.emit('progress', percent, info.suggestedFilename);
-            }
-            // Handle completion
-            if (event.state === 'completed') {
-                // Construct the final path
-                const finalPath = `${this.downloadDir}/${info.suggestedFilename}`;
-                info.resolvedPath = finalPath;
-                this.emit('completed', finalPath);
-                // Resolve any waiting promises
-                const resolver = this.downloadPromiseResolvers.get(event.guid);
-                if (resolver) {
-                    resolver.resolve(finalPath);
-                    this.downloadPromiseResolvers.delete(event.guid);
-                }
-            }
-            else if (event.state === 'canceled') {
-                this.emit('canceled', info.suggestedFilename);
-                const resolver = this.downloadPromiseResolvers.get(event.guid);
-                if (resolver) {
-                    resolver.reject(new Error('Download canceled'));
-                    this.downloadPromiseResolvers.delete(event.guid);
-                }
-            }
-        });
         this.isMonitoring = true;
     }
     /**

package/build/src/selectors/gemini.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.0.0",
-  "lastUpdated": "2025-11-27",
+  "version": "1.1.0",
+  "lastUpdated": "2025-01-24",
   "description": "Selectors for Gemini web interface",
   "elements": {
     "editor": {
@@ -16,6 +16,17 @@
     "response": {
       "css": "model-response",
       "description": "Response container"
+    },
+    "downloadButton": {
+      "ax": {
+        "ariaDescribedByContains": ["フルサイズ", "ダウンロード", "Download"]
+      },
+      "text": ["フルサイズの画像をダウンロード", "Download full-size image"],
+      "description": "Download button for generated images"
+    },
+    "generatedImage": {
+      "css": "img[src*='blob:'], img[src*='generated']",
+      "description": "Generated image element"
     }
   },
   "placeholders": {

package/build/src/tools/gemini-image.js

@@ -188,46 +188,69 @@ export const askGeminiImage = defineTool({
                 response.appendResponseLine('⚠️ 送信ボタンが見つかりません (Enterキーを試行)');
             }
             response.appendResponseLine('🎨 画像生成中... (1-2分かかることがあります)');
-            // Wait for image generation to complete
-            // Look for generated image or download button
+            // Wait for image generation using MutationObserver for instant detection
             const startTime = Date.now();
             const maxWaitTime = 180000; // 3 minutes
-            let imageFound = false;
-            while (Date.now() - startTime < maxWaitTime) {
-                await new Promise(resolve => setTimeout(resolve, 2000));
-                const status = await page.evaluate(() => {
-                    // Check for generated image
-                    const images = document.querySelectorAll('img[src*="blob:"], img[src*="generated"]');
-                    // Check for download button or menu
-                    const downloadButtons = Array.from(document.querySelectorAll('button, [role="menuitem"]'));
-                    const hasDownload = downloadButtons.some(b => b.textContent?.includes('ダウンロード') ||
-                        b.textContent?.includes('Download') ||
-                        b.getAttribute('aria-label')?.includes('download') ||
-                        b.getAttribute('aria-label')?.includes('ダウンロード'));
-                    // Check if still generating
-                    const isGenerating = document.body.innerText.includes('生成中') ||
-                        document.body.innerText.includes('Generating') ||
-                        document.querySelector('[role="progressbar"]') !== null;
-                    return {
-                        imageCount: images.length,
-                        hasDownload,
-                        isGenerating,
+            const imageFound = await page.evaluate((maxWait) => {
+                return new Promise(resolve => {
+                    // Check if image already exists (immediate return)
+                    const checkCompletion = () => {
+                        // Check for generated image
+                        const images = document.querySelectorAll('img[src*="blob:"], img[src*="generated"]');
+                        // Check for download button with various detection methods
+                        const buttons = Array.from(document.querySelectorAll('button, [role="menuitem"]'));
+                        const hasDownload = buttons.some(b => {
+                            const text = b.textContent || '';
+                            const ariaLabel = b.getAttribute('aria-label') || '';
+                            const describedBy = b.getAttribute('aria-describedby');
+                            let desc = '';
+                            if (describedBy) {
+                                const descEl = document.getElementById(describedBy);
+                                desc = descEl?.textContent || '';
+                            }
+                            return (text.includes('ダウンロード') ||
+                                text.includes('Download') ||
+                                text.includes('フルサイズ') ||
+                                ariaLabel.toLowerCase().includes('download') ||
+                                desc.includes('フルサイズ') ||
+                                desc.includes('ダウンロード'));
+                        });
+                        if (images.length > 0 || hasDownload) {
+                            return true;
+                        }
+                        return false;
                     };
+                    // Initial check
+                    if (checkCompletion()) {
+                        resolve(true);
+                        return;
+                    }
+                    // Set up MutationObserver for instant detection
+                    const observer = new MutationObserver(() => {
+                        if (checkCompletion()) {
+                            observer.disconnect();
+                            clearTimeout(timeoutId);
+                            resolve(true);
+                        }
+                    });
+                    observer.observe(document.body, {
+                        childList: true,
+                        subtree: true,
+                        attributes: true,
+                        attributeFilter: ['src', 'aria-label', 'aria-describedby'],
+                    });
+                    // Timeout fallback
+                    const timeoutId = setTimeout(() => {
+                        observer.disconnect();
+                        resolve(false);
+                    }, maxWait);
                 });
-                if (status.imageCount > 0 || status.hasDownload) {
-                    imageFound = true;
-                    response.appendResponseLine(`✅ 画像生成完了 (${Math.floor((Date.now() - startTime) / 1000)}秒)`);
-                    break;
-                }
-                if (!status.isGenerating && Date.now() - startTime > 30000) {
-                    // Not generating and no image after 30s - might have failed
-                    response.appendResponseLine('⚠️ 生成中インジケータが消えました...');
-                }
-            }
+            }, maxWaitTime);
             if (!imageFound) {
                 response.appendResponseLine('❌ 画像生成タイムアウト (3分)');
                 return;
             }
+            response.appendResponseLine(`✅ 画像生成完了 (${Math.floor((Date.now() - startTime) / 1000)}秒)`);
             // Try to download the image using CDP-based download manager
             response.appendResponseLine('📥 画像をダウンロード中...');
             // Set up download manager with CDP events
@@ -235,10 +258,18 @@ export const askGeminiImage = defineTool({
             const downloadManager = new DownloadManager(page, userDownloadsDir);
             try {
                 await downloadManager.startMonitoring();
-                // Listen for progress updates
+                // Track reported progress to ensure threshold-based reporting
+                let lastReportedThreshold = 0;
+                // Listen for progress updates with threshold-based reporting
+                // This ensures 25%, 50%, 75%, 100% are always reported even if progress jumps
                 downloadManager.on('progress', (percent, filename) => {
-                    if (percent % 25 === 0) {
-                        response.appendResponseLine(`📥 ダウンロード中... ${percent}% (${filename})`);
+                    // Calculate the next threshold to report (25, 50, 75, 100)
+                    const thresholds = [25, 50, 75, 100];
+                    for (const threshold of thresholds) {
+                        if (percent >= threshold && lastReportedThreshold < threshold) {
+                            response.appendResponseLine(`📥 ダウンロード中... ${threshold}% (${filename})`);
+                            lastReportedThreshold = threshold;
+                        }
                     }
                 });
                 downloadManager.on('started', (filename) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "MCP server bridging Chrome browser and AI assistants (ChatGPT, Gemini). Browser automation + AI consultation.",
   "type": "module",
   "bin": "./scripts/cli.mjs",