chrome-ai-bridge 1.0.6 → 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,30 +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
- */
-async function waitForDownload(downloadDir, timeoutMs = 60000) {
-    const startTime = Date.now();
-    const checkInterval = 500;
-    // Get initial files
-    const initialFiles = new Set(await fs.promises.readdir(downloadDir));
-    while (Date.now() - startTime < timeoutMs) {
-        await new Promise(resolve => setTimeout(resolve, checkInterval));
-        const currentFiles = await fs.promises.readdir(downloadDir);
-        const newFiles = currentFiles.filter(f => !initialFiles.has(f) &&
-            !f.endsWith('.crdownload') &&
-            !f.endsWith('.tmp'));
-        if (newFiles.length > 0) {
-            // Return the newest file (by modification time)
-            const filePaths = newFiles.map(f => path.join(downloadDir, f));
-            const stats = await Promise.all(filePaths.map(async (p) => ({ path: p, mtime: (await fs.promises.stat(p)).mtime })));
-            stats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-            return stats[0].path;
-        }
-    }
-    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. ' +
@@ -140,15 +117,6 @@ export const askGeminiImage = defineTool({
     handler: async (request, response, context) => {
         const { prompt, outputPath, cropMargin = DEFAULT_CROP_MARGIN, skipCrop = false, } = request.params;
         const page = await getOrCreateGeminiPage(context);
-        // Set up download directory
-        const downloadDir = path.join(os.tmpdir(), 'gemini-image-downloads');
-        await fs.promises.mkdir(downloadDir, { recursive: true });
-        // Configure download behavior
-        const client = await page.createCDPSession();
-        await client.send('Page.setDownloadBehavior', {
-            behavior: 'allow',
-            downloadPath: downloadDir,
-        });
         try {
             response.appendResponseLine('Geminiに接続中...');
             // Navigate to Gemini
@@ -260,83 +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('📥 画像をダウンロード中...');
-            // Method 1: Click download button
-            const downloadClicked = await page.evaluate(() => {
-                // Look for three-dot menu or download button on the image
-                const buttons = Array.from(document.querySelectorAll('button, [role="menuitem"]'));
-                // First try direct download button
-                let downloadBtn = buttons.find(b => b.textContent?.includes('ダウンロード') ||
-                    b.textContent?.includes('Download'));
-                if (downloadBtn) {
-                    downloadBtn.click();
-                    return 'direct';
-                }
-                // Try three-dot menu on generated images
-                const moreButtons = buttons.filter(b => b.getAttribute('aria-label')?.includes('more') ||
-                    b.getAttribute('aria-label')?.includes('その他') ||
-                    b.querySelector('mat-icon[data-mat-icon-name="more_vert"]'));
-                if (moreButtons.length > 0) {
-                    // Click the last one (likely the image menu)
-                    moreButtons[moreButtons.length - 1].click();
-                    return 'menu-opened';
-                }
-                return null;
-            });
-            if (downloadClicked === 'menu-opened') {
-                // Wait for menu to open and click download
-                await new Promise(resolve => setTimeout(resolve, 500));
-                await page.evaluate(() => {
-                    const menuItems = Array.from(document.querySelectorAll('[role="menuitem"], button'));
-                    const downloadItem = menuItems.find(item => item.textContent?.includes('ダウンロード') ||
-                        item.textContent?.includes('Download'));
-                    if (downloadItem) {
-                        downloadItem.click();
+            // Set up download manager with CDP events
+            const userDownloadsDir = path.join(os.homedir(), 'Downloads');
+            const downloadManager = new DownloadManager(page, userDownloadsDir);
+            try {
+                await downloadManager.startMonitoring();
+                // Listen for progress updates
+                downloadManager.on('progress', (percent, filename) => {
+                    if (percent % 25 === 0) {
+                        response.appendResponseLine(`📥 ダウンロード中... ${percent}% (${filename})`);
                     }
                 });
-            }
-            // Wait for download to complete
-            let downloadedPath;
-            try {
-                downloadedPath = await waitForDownload(downloadDir, 30000);
-                response.appendResponseLine(`✅ ダウンロード完了: ${path.basename(downloadedPath)}`);
-            }
-            catch (error) {
-                response.appendResponseLine('❌ ダウンロード待機タイムアウト');
-                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)...`);
+                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.6",
+  "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",