chrome-ai-bridge 1.0.7 → 1.0.8

package/build/src/download-manager.js

@@ -0,0 +1,181 @@
+/**
+ * @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;
+    }
+    /**
+     * Start monitoring downloads using CDP events
+     */
+    async startMonitoring() {
+        if (this.isMonitoring) {
+            return;
+        }
+        // Create CDP session
+        this.cdpSession = await this.page.createCDPSession();
+        // 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;
+    }
+    /**
+     * 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/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. ' +
@@ -280,81 +228,121 @@ export const askGeminiImage = defineTool({
                 response.appendResponseLine('❌ 画像生成タイムアウト (3分)');
                 return;
             }
-            // Try to download the image
+            // 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();
+                // Listen for progress updates
+                downloadManager.on('progress', (percent, filename) => {
+                    if (percent % 25 === 0) {
+                        response.appendResponseLine(`📥 ダウンロード中... ${percent}% (${filename})`);
+                    }
+                });
+                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.8",
   "description": "MCP server bridging Chrome browser and AI assistants (ChatGPT, Gemini). Browser automation + AI consultation.",
   "type": "module",
   "bin": "./scripts/cli.mjs",