chrome-ai-bridge 1.0.7 → 1.0.9

package/build/src/download-manager.js

@@ -0,0 +1,192 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { EventEmitter } from 'events';
+export class DownloadManager extends EventEmitter {
+    cdpSession = null;
+    downloadDir;
+    page;
+    pendingDownloads = new Map();
+    downloadPromiseResolvers = new Map();
+    isMonitoring = false;
+    constructor(page, downloadDir) {
+        super();
+        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) {
+            return;
+        }
+        // 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,
+        });
+        this.isMonitoring = true;
+    }
+    /**
+     * Wait for any download to complete
+     * @param timeoutMs Timeout in milliseconds
+     * @returns Path to the downloaded file
+     */
+    async waitForDownload(timeoutMs = 60000) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Download timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            // Check if there's already a pending download
+            const existingDownload = Array.from(this.pendingDownloads.values()).find(d => d.state === 'inProgress');
+            const handleCompletion = (filepath) => {
+                clearTimeout(timeoutId);
+                this.off('completed', handleCompletion);
+                this.off('canceled', handleCancellation);
+                resolve(filepath);
+            };
+            const handleCancellation = (filename) => {
+                clearTimeout(timeoutId);
+                this.off('completed', handleCompletion);
+                this.off('canceled', handleCancellation);
+                reject(new Error(`Download canceled: ${filename}`));
+            };
+            this.on('completed', handleCompletion);
+            this.on('canceled', handleCancellation);
+            // If a download is already completed, resolve immediately
+            const completedDownload = Array.from(this.pendingDownloads.values()).find(d => d.state === 'completed' && d.resolvedPath);
+            if (completedDownload?.resolvedPath) {
+                clearTimeout(timeoutId);
+                this.off('completed', handleCompletion);
+                this.off('canceled', handleCancellation);
+                resolve(completedDownload.resolvedPath);
+            }
+        });
+    }
+    /**
+     * Wait for a specific download by GUID
+     */
+    async waitForSpecificDownload(guid, timeoutMs = 60000) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.downloadPromiseResolvers.delete(guid);
+                reject(new Error(`Download timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            // Check if already completed
+            const info = this.pendingDownloads.get(guid);
+            if (info?.state === 'completed' && info.resolvedPath) {
+                clearTimeout(timeoutId);
+                resolve(info.resolvedPath);
+                return;
+            }
+            this.downloadPromiseResolvers.set(guid, {
+                resolve: (path) => {
+                    clearTimeout(timeoutId);
+                    resolve(path);
+                },
+                reject: (err) => {
+                    clearTimeout(timeoutId);
+                    reject(err);
+                },
+            });
+        });
+    }
+    /**
+     * Get current pending downloads
+     */
+    getPendingDownloads() {
+        return Array.from(this.pendingDownloads.values()).filter(d => d.state === 'inProgress');
+    }
+    /**
+     * Clear download history
+     */
+    clearHistory() {
+        this.pendingDownloads.clear();
+    }
+    /**
+     * Release resources
+     */
+    async dispose() {
+        if (this.cdpSession) {
+            try {
+                // Reset download behavior to default
+                await this.cdpSession.send('Browser.setDownloadBehavior', {
+                    behavior: 'default',
+                });
+                await this.cdpSession.detach();
+            }
+            catch {
+                // Ignore errors during cleanup
+            }
+            this.cdpSession = null;
+        }
+        this.isMonitoring = false;
+        this.pendingDownloads.clear();
+        this.downloadPromiseResolvers.clear();
+        this.removeAllListeners();
+    }
+}

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

@@ -9,6 +9,7 @@ import os from 'node:os';
 import { Jimp } from 'jimp';
 import z from 'zod';
 import { GEMINI_CONFIG } from '../config.js';
+import { DownloadManager } from '../download-manager.js';
 import { getLoginStatus, waitForLoginStatus, LoginStatus, } from '../login-helper.js';
 import { ToolCategories } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
@@ -84,59 +85,6 @@ async function cropWatermark(inputPath, outputPath, margin = DEFAULT_CROP_MARGIN
     await image.write(outputPath);
     return { width: newWidth, height: newHeight };
 }
-/**
- * Wait for download to complete and return the file path
- * Looks for new image files (png, jpg, jpeg) in the download directory
- */
-async function waitForDownload(downloadDir, timeoutMs = 60000) {
-    const startTime = Date.now();
-    const checkInterval = 1000; // Check every second
-    // Get initial files with their mtimes
-    const initialFiles = new Map();
-    try {
-        const files = await fs.promises.readdir(downloadDir);
-        for (const f of files) {
-            if (/\.(png|jpg|jpeg)$/i.test(f)) {
-                const stat = await fs.promises.stat(path.join(downloadDir, f));
-                initialFiles.set(f, stat.mtime.getTime());
-            }
-        }
-    }
-    catch {
-        // Directory might not exist, continue
-    }
-    while (Date.now() - startTime < timeoutMs) {
-        await new Promise(resolve => setTimeout(resolve, checkInterval));
-        try {
-            const currentFiles = await fs.promises.readdir(downloadDir);
-            for (const f of currentFiles) {
-                // Only check image files
-                if (!/\.(png|jpg|jpeg)$/i.test(f))
-                    continue;
-                // Skip incomplete downloads
-                if (f.endsWith('.crdownload') || f.endsWith('.tmp'))
-                    continue;
-                const filePath = path.join(downloadDir, f);
-                const stat = await fs.promises.stat(filePath);
-                const mtime = stat.mtime.getTime();
-                // Check if this is a new file or modified after we started
-                const initialMtime = initialFiles.get(f);
-                if (!initialMtime || mtime > initialMtime) {
-                    // Verify file is complete (size > 0 and not growing)
-                    await new Promise(resolve => setTimeout(resolve, 500));
-                    const stat2 = await fs.promises.stat(filePath);
-                    if (stat2.size > 0 && stat2.size === stat.size) {
-                        return filePath;
-                    }
-                }
-            }
-        }
-        catch {
-            // Continue on error
-        }
-    }
-    throw new Error(`Download timeout after ${timeoutMs}ms`);
-}
 export const askGeminiImage = defineTool({
     name: 'ask_gemini_image',
     description: 'Generate image using Gemini (Nano Banana / 3 Preview) via browser. ' +
@@ -240,121 +188,192 @@ 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;
             }
-            // Try to download the image
+            response.appendResponseLine(`✅ 画像生成完了 (${Math.floor((Date.now() - startTime) / 1000)}秒)`);
+            // Try to download the image using CDP-based download manager
             response.appendResponseLine('📥 画像をダウンロード中...');
-            // Click download button - Gemini uses "フルサイズの画像をダウンロード" button
-            const downloadClicked = await page.evaluate(() => {
-                const buttons = Array.from(document.querySelectorAll('button'));
-                // Look for "フルサイズの画像をダウンロード" or "フルサイズでダウンロード" button
-                const downloadBtn = buttons.find(b => {
-                    const text = b.textContent || '';
-                    const ariaLabel = b.getAttribute('aria-label') || '';
-                    const description = b.getAttribute('aria-describedby')
-                        ? document.getElementById(b.getAttribute('aria-describedby'))?.textContent || ''
-                        : '';
-                    return (text.includes('フルサイズ') ||
-                        text.includes('ダウンロード') ||
-                        ariaLabel.includes('ダウンロード') ||
-                        ariaLabel.includes('download') ||
-                        description.includes('フルサイズ') ||
-                        description.includes('ダウンロード'));
-                });
-                if (downloadBtn) {
-                    downloadBtn.click();
-                    return true;
-                }
-                return false;
-            });
-            if (!downloadClicked) {
-                response.appendResponseLine('⚠️ ダウンロードボタンが見つかりません');
-                response.appendResponseLine('ヒント: ブラウザで画像を右クリックして保存してください');
-                return;
-            }
-            // Wait for download to start (Gemini shows progress bar)
-            response.appendResponseLine('⏳ ダウンロード処理を待機中...');
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            // Wait for download to complete - check user's Downloads folder
+            // Set up download manager with CDP events
             const userDownloadsDir = path.join(os.homedir(), 'Downloads');
-            let downloadedPath;
+            const downloadManager = new DownloadManager(page, userDownloadsDir);
             try {
-                downloadedPath = await waitForDownload(userDownloadsDir, 60000); // 60 seconds
-                response.appendResponseLine(`✅ ダウンロード完了: ${path.basename(downloadedPath)}`);
-            }
-            catch (error) {
-                response.appendResponseLine('❌ ダウンロード待機タイムアウト (60秒)');
-                response.appendResponseLine('ヒント: ブラウザで画像を右クリックして「画像を保存」してください');
-                return;
-            }
-            // Ensure output directory exists
-            const outputDir = path.dirname(outputPath);
-            await fs.promises.mkdir(outputDir, { recursive: true });
-            // Crop watermark or copy directly
-            if (skipCrop) {
-                await fs.promises.copyFile(downloadedPath, outputPath);
-                response.appendResponseLine(`📄 画像保存（クロップなし）: ${outputPath}`);
-            }
-            else {
-                response.appendResponseLine(`✂️ ウォーターマークをクロップ中 (margin: ${cropMargin}px)...`);
+                await downloadManager.startMonitoring();
+                // 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) => {
+                    // 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) => {
+                    response.appendResponseLine(`📥 ダウンロード開始: ${filename}`);
+                });
+                // Click download button - Gemini uses "フルサイズの画像をダウンロード" button
+                // Improved selector: prioritize aria-describedby for more reliable detection
+                const downloadClicked = await page.evaluate(() => {
+                    const buttons = Array.from(document.querySelectorAll('button'));
+                    // First, try to find button with aria-describedby pointing to "フルサイズ"
+                    let downloadBtn = buttons.find(b => {
+                        const describedBy = b.getAttribute('aria-describedby');
+                        if (describedBy) {
+                            const descEl = document.getElementById(describedBy);
+                            const desc = descEl?.textContent || '';
+                            return desc.includes('フルサイズ') || desc.includes('ダウンロード');
+                        }
+                        return false;
+                    });
+                    // Fallback: look for text/aria-label containing download keywords
+                    if (!downloadBtn) {
+                        downloadBtn = buttons.find(b => {
+                            const text = b.textContent || '';
+                            const ariaLabel = b.getAttribute('aria-label') || '';
+                            // Avoid "Cancel download" buttons
+                            const lowerText = text.toLowerCase();
+                            const lowerLabel = ariaLabel.toLowerCase();
+                            if (lowerText.includes('cancel') || lowerLabel.includes('cancel') ||
+                                lowerText.includes('キャンセル') || lowerLabel.includes('キャンセル')) {
+                                return false;
+                            }
+                            return (text.includes('フルサイズ') ||
+                                text.includes('ダウンロード') ||
+                                ariaLabel.includes('ダウンロード') ||
+                                ariaLabel.includes('download'));
+                        });
+                    }
+                    if (downloadBtn) {
+                        downloadBtn.click();
+                        return true;
+                    }
+                    return false;
+                });
+                if (!downloadClicked) {
+                    response.appendResponseLine('⚠️ ダウンロードボタンが見つかりません');
+                    response.appendResponseLine('ヒント: ブラウザで画像を右クリックして保存してください');
+                    return;
+                }
+                // Wait for download to complete using CDP events (more reliable than file polling)
+                response.appendResponseLine('⏳ CDP経由でダウンロード完了を待機中...');
+                let downloadedPath;
                 try {
-                    const { width, height } = await cropWatermark(downloadedPath, outputPath, cropMargin);
-                    response.appendResponseLine(`✅ クロップ完了: ${width}x${height}px → ${outputPath}`);
+                    downloadedPath = await downloadManager.waitForDownload(60000); // 60 seconds
+                    response.appendResponseLine(`✅ ダウンロード完了: ${path.basename(downloadedPath)}`);
+                }
+                catch (downloadError) {
+                    const errMsg = downloadError instanceof Error ? downloadError.message : String(downloadError);
+                    if (errMsg.includes('timeout')) {
+                        response.appendResponseLine('❌ ダウンロードタイムアウト (60秒)');
+                        response.appendResponseLine('💡 ヒント: ブラウザで画像を右クリックして「画像を保存」してください');
+                    }
+                    else if (errMsg.includes('canceled')) {
+                        response.appendResponseLine('❌ ダウンロードがキャンセルされました');
+                    }
+                    else {
+                        response.appendResponseLine(`❌ ダウンロードエラー: ${errMsg}`);
+                    }
+                    return;
                 }
-                catch (error) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    response.appendResponseLine(`⚠️ クロップ失敗: ${msg}`);
-                    response.appendResponseLine('元の画像をそのまま保存します...');
+                // Ensure output directory exists
+                const outputDir = path.dirname(outputPath);
+                await fs.promises.mkdir(outputDir, { recursive: true });
+                // Crop watermark or copy directly
+                if (skipCrop) {
                     await fs.promises.copyFile(downloadedPath, outputPath);
+                    response.appendResponseLine(`📄 画像保存（クロップなし）: ${outputPath}`);
                 }
+                else {
+                    response.appendResponseLine(`✂️ ウォーターマークをクロップ中 (margin: ${cropMargin}px)...`);
+                    try {
+                        const { width, height } = await cropWatermark(downloadedPath, outputPath, cropMargin);
+                        response.appendResponseLine(`✅ クロップ完了: ${width}x${height}px → ${outputPath}`);
+                    }
+                    catch (cropError) {
+                        const msg = cropError instanceof Error ? cropError.message : String(cropError);
+                        response.appendResponseLine(`⚠️ クロップ失敗: ${msg}`);
+                        response.appendResponseLine('元の画像をそのまま保存します...');
+                        await fs.promises.copyFile(downloadedPath, outputPath);
+                    }
+                }
+                // Cleanup temp file
+                try {
+                    await fs.promises.unlink(downloadedPath);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+                response.appendResponseLine('\n🎉 画像生成完了!');
+                response.appendResponseLine(`📁 出力: ${outputPath}`);
             }
-            // Cleanup temp file
-            try {
-                await fs.promises.unlink(downloadedPath);
-            }
-            catch {
-                // Ignore cleanup errors
+            finally {
+                // Ensure download manager is always disposed
+                await downloadManager.dispose();
             }
-            response.appendResponseLine('\n🎉 画像生成完了!');
-            response.appendResponseLine(`📁 出力: ${outputPath}`);
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "1.0.7",
+  "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",