chrome-ai-bridge 1.0.4 → 1.0.6

package/build/node_modules/chrome-devtools-frontend/front_end/models/annotations/AnnotationRepository.js

@@ -0,0 +1,163 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import * as GreenDev from '../greendev/greendev.js';
+import { AnnotationType } from './AnnotationType.js';
+export class AnnotationRepository {
+    static #instance = null;
+    static #hasRepliedGreenDevDisabled = false;
+    static #hasShownFlagWarning = false;
+    #events = new Common.ObjectWrapper.ObjectWrapper();
+    #annotationData = [];
+    #nextId = 0;
+    static instance() {
+        if (!AnnotationRepository.#instance) {
+            AnnotationRepository.#instance = new AnnotationRepository();
+        }
+        return AnnotationRepository.#instance;
+    }
+    static annotationsEnabled() {
+        const enabled = GreenDev.Prototypes.instance().isEnabled('aiAnnotations');
+        // TODO(finnur): Fix race when Repository is created before feature flags have been set properly.
+        if (!enabled) {
+            this.#hasRepliedGreenDevDisabled = true;
+        }
+        else if (this.#hasRepliedGreenDevDisabled && !this.#hasShownFlagWarning) {
+            console.warn('Flag controlling GreenDev has flipped from false to true. ' +
+                'Only some callers will expect GreenDev to be enabled, which can lead to unexpected results.');
+            this.#hasShownFlagWarning = true;
+        }
+        return Boolean(enabled);
+    }
+    addEventListener(eventType, listener, thisObject) {
+        if (!AnnotationRepository.annotationsEnabled()) {
+            console.warn('Received request to add event listener with annotations disabled');
+        }
+        return this.#events.addEventListener(eventType, listener, thisObject);
+    }
+    getAnnotationDataByType(type) {
+        if (!AnnotationRepository.annotationsEnabled()) {
+            console.warn('Received query for annotation types with annotations disabled');
+            return [];
+        }
+        const annotations = this.#annotationData.filter(annotation => annotation.type === type);
+        return annotations;
+    }
+    getAnnotationDataById(id) {
+        if (!AnnotationRepository.annotationsEnabled()) {
+            console.warn('Received query for annotation type with annotations disabled');
+            return undefined;
+        }
+        return this.#annotationData.find(annotation => annotation.id === id);
+    }
+    #getExistingAnnotation(type, anchor) {
+        const annotations = this.getAnnotationDataByType(type);
+        const annotation = annotations.find(annotation => {
+            if (typeof anchor === 'string') {
+                return annotation.lookupId === anchor;
+            }
+            switch (type) {
+                case AnnotationType.ELEMENT_NODE: {
+                    const elementAnnotation = annotation;
+                    return elementAnnotation.anchor === anchor;
+                }
+                case AnnotationType.NETWORK_REQUEST_SUBPANEL_HEADERS: {
+                    const networkRequestDetailsAnnotation = annotation;
+                    return networkRequestDetailsAnnotation.anchor === anchor;
+                }
+                default:
+                    console.warn('[AnnotationRepository] Unknown AnnotationType', type);
+                    return false;
+            }
+        });
+        return annotation;
+    }
+    #updateExistingAnnotationLabel(label, type, anchor) {
+        const annotation = this.#getExistingAnnotation(type, anchor);
+        if (annotation) {
+            // TODO(finnur): This should work for annotations that have not been displayed yet,
+            // but we need to also notify the AnnotationManager for those that have been shown.
+            annotation.message = label;
+            return true;
+        }
+        return false;
+    }
+    addElementsAnnotation(label, anchor, anchorToString) {
+        if (!AnnotationRepository.annotationsEnabled()) {
+            console.warn('Received annotation registration with annotations disabled');
+            return;
+        }
+        if (this.#updateExistingAnnotationLabel(label, AnnotationType.ELEMENT_NODE, anchor)) {
+            return;
+        }
+        const annotationData = {
+            id: this.#nextId++,
+            type: AnnotationType.ELEMENT_NODE,
+            message: label,
+            lookupId: typeof anchor === 'string' ? anchor : '',
+            anchor: typeof anchor !== 'string' ? anchor : undefined,
+            anchorToString,
+        };
+        this.#annotationData.push(annotationData);
+        // eslint-disable-next-line no-console
+        console.log('[AnnotationRepository] Added element annotation:', label, {
+            annotationData,
+            annotations: this.#annotationData.length,
+        });
+        this.#events.dispatchEventToListeners("AnnotationAdded" /* Events.ANNOTATION_ADDED */, annotationData);
+    }
+    addNetworkRequestAnnotation(label, anchor, anchorToString) {
+        if (!AnnotationRepository.annotationsEnabled()) {
+            console.warn('Received annotation registration with annotations disabled');
+            return;
+        }
+        // We only need to update the NETWORK_REQUEST_SUBPANEL_HEADERS because the
+        // NETWORK_REQUEST Annotation has no meaningful label.
+        if (this.#updateExistingAnnotationLabel(label, AnnotationType.NETWORK_REQUEST_SUBPANEL_HEADERS, anchor)) {
+            return;
+        }
+        const annotationData = {
+            id: this.#nextId++,
+            type: AnnotationType.NETWORK_REQUEST,
+            message: '',
+            lookupId: typeof anchor === 'string' ? anchor : '',
+            anchor: typeof anchor !== 'string' ? anchor : undefined,
+            anchorToString,
+        };
+        this.#annotationData.push(annotationData);
+        // eslint-disable-next-line no-console
+        console.log('[AnnotationRepository] Added annotation:', label, {
+            annotationData,
+            annotations: this.#annotationData.length,
+        });
+        this.#events.dispatchEventToListeners("AnnotationAdded" /* Events.ANNOTATION_ADDED */, annotationData);
+        const annotationDetailsData = {
+            id: this.#nextId++,
+            type: AnnotationType.NETWORK_REQUEST_SUBPANEL_HEADERS,
+            message: label,
+            lookupId: typeof anchor === 'string' ? anchor : '',
+            anchor: typeof anchor !== 'string' ? anchor : undefined,
+            anchorToString,
+        };
+        this.#annotationData.push(annotationDetailsData);
+        this.#events.dispatchEventToListeners("AnnotationAdded" /* Events.ANNOTATION_ADDED */, annotationDetailsData);
+    }
+    deleteAllAnnotations() {
+        this.#annotationData = [];
+        this.#events.dispatchEventToListeners("AllAnnotationsDeleted" /* Events.ALL_ANNOTATIONS_DELETED */);
+        // eslint-disable-next-line no-console
+        console.log('[AnnotationRepository] Deleting all annotations');
+    }
+    deleteAnnotation(id) {
+        const index = this.#annotationData.findIndex(annotation => annotation.id === id);
+        if (index === -1) {
+            console.warn(`[AnnotationRepository] Could not find annotation with id ${id}`);
+            return;
+        }
+        this.#annotationData.splice(index, 1);
+        this.#events.dispatchEventToListeners("AnnotationDeleted" /* Events.ANNOTATION_DELETED */, { id });
+        // eslint-disable-next-line no-console
+        console.log(`[AnnotationRepository] Deleted annotation with id ${id}`);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/annotations/AnnotationType.js

@@ -0,0 +1,10 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export var AnnotationType;
+(function (AnnotationType) {
+    AnnotationType[AnnotationType["ELEMENT_NODE"] = 0] = "ELEMENT_NODE";
+    AnnotationType[AnnotationType["STYLE_RULE"] = 1] = "STYLE_RULE";
+    AnnotationType[AnnotationType["NETWORK_REQUEST"] = 2] = "NETWORK_REQUEST";
+    AnnotationType[AnnotationType["NETWORK_REQUEST_SUBPANEL_HEADERS"] = 3] = "NETWORK_REQUEST_SUBPANEL_HEADERS";
+})(AnnotationType || (AnnotationType = {}));

package/build/node_modules/chrome-devtools-frontend/front_end/models/annotations/annotations.js

@@ -0,0 +1,5 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export * from './AnnotationRepository.js';
+export * from './AnnotationType.js';

package/build/node_modules/chrome-devtools-frontend/front_end/models/greendev/Prototypes.js

@@ -0,0 +1,33 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
+let instance = null;
+export class Prototypes {
+    constructor() {
+    }
+    static instance() {
+        if (instance) {
+            return instance;
+        }
+        instance = new Prototypes();
+        return instance;
+    }
+    /**
+     * Returns true if the specific setting is turned on AND the GreenDev flag is enabled
+     */
+    isEnabled(setting) {
+        const greendevFlagEnabled = Boolean(Root.Runtime.hostConfig.devToolsGreenDevUi?.enabled);
+        return greendevFlagEnabled && this.settings()[setting].get();
+    }
+    settings() {
+        const settings = Common.Settings.Settings.instance();
+        const inDevToolsFloaty = settings.createSetting('greendev-in-devtools-floaty-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const inlineWidgets = settings.createSetting('greendev-inline-widgets-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const aiAnnotations = settings.createSetting('greendev-ai-annotations-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const artifactViewer = settings.createSetting('greendev-artifact-viewer-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const copyToGemini = settings.createSetting('greendev-copy-to-gemini-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        return { inDevToolsFloaty, inlineWidgets, aiAnnotations, artifactViewer, copyToGemini };
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/greendev/greendev.js

@@ -0,0 +1,4 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export * from './Prototypes.js';

package/build/src/tools/chatgpt-web.js

@@ -256,7 +256,7 @@ export const askChatGPTWeb = defineTool({
                     response.appendResponseLine(`既存のプロジェクトチャットを使用: ${latestSession.url}`);
                 }
                 else {
-                    response.appendResponseLine('既存チャットが見つかりませんでした。新規作成します。');
+                    response.appendResponseLine('📝 新規チャットを作成します');
                     isNewChat = true;
                 }
             }

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

@@ -0,0 +1,352 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { Jimp } from 'jimp';
+import z from 'zod';
+import { GEMINI_CONFIG } from '../config.js';
+import { getLoginStatus, waitForLoginStatus, LoginStatus, } from '../login-helper.js';
+import { ToolCategories } from './categories.js';
+import { defineTool } from './ToolDefinition.js';
+/**
+ * Default crop margin in pixels (will be adjusted based on actual watermark size)
+ */
+const DEFAULT_CROP_MARGIN = 80;
+/**
+ * Navigate with retry logic
+ */
+async function navigateWithRetry(page, url, options = { waitUntil: 'networkidle2', maxRetries: 3 }) {
+    const { waitUntil, maxRetries = 3 } = options;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            await page.goto(url, { waitUntil, timeout: 30000 });
+            return;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            const isRetryable = lastError.message.includes('ERR_ABORTED') ||
+                lastError.message.includes('net::ERR_');
+            if (!isRetryable || attempt === maxRetries) {
+                throw lastError;
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+        }
+    }
+    throw lastError;
+}
+/**
+ * Find or create a dedicated Gemini tab
+ */
+async function getOrCreateGeminiPage(context) {
+    await context.createPagesSnapshot();
+    const pages = context.getPages();
+    for (const page of pages) {
+        const url = page.url();
+        if (url.includes('gemini.google.com')) {
+            await page.bringToFront();
+            return page;
+        }
+    }
+    const newPage = await context.newPage();
+    return newPage;
+}
+/**
+ * Enhance prompt for better watermark cropping
+ * Adds composition requirements to center the subject and use solid background
+ */
+function enhancePromptForCropping(prompt) {
+    const compositionRequirements = `
+
+Composition requirements:
+- Center the main subject with generous padding on all sides (at least 15% margin from edges)
+- Use a clean, solid background color
+- Ensure no important elements touch the image edges, especially the bottom-right corner`;
+    return prompt + compositionRequirements;
+}
+/**
+ * Crop image to remove watermark (uniform crop from all sides)
+ */
+async function cropWatermark(inputPath, outputPath, margin = DEFAULT_CROP_MARGIN) {
+    const image = await Jimp.read(inputPath);
+    const { width, height } = image;
+    // Crop from all sides
+    const newWidth = width - margin * 2;
+    const newHeight = height - margin * 2;
+    if (newWidth <= 0 || newHeight <= 0) {
+        throw new Error(`Image too small to crop: ${width}x${height} with margin ${margin}`);
+    }
+    image.crop({ x: margin, y: margin, w: newWidth, h: newHeight });
+    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. ' +
+        'Automatically crops watermark from edges. ' +
+        'Rate limit: ~2 images/day for free users.',
+    annotations: {
+        category: ToolCategories.NAVIGATION_AUTOMATION,
+        readOnlyHint: false,
+    },
+    schema: {
+        prompt: z
+            .string()
+            .describe('Image generation prompt. Use natural language descriptions. ' +
+            'Structure: [Subject + Adjectives] doing [Action] in [Location/Context]. ' +
+            '[Composition/Camera Angle]. [Lighting/Atmosphere]. [Style/Media]. ' +
+            'HEX color codes like "#9F2B68" are supported.'),
+        outputPath: z
+            .string()
+            .describe('Output file path for the generated image. ' +
+            'Will be cropped to remove watermark. Example: /tmp/generated-image.png'),
+        cropMargin: z
+            .number()
+            .optional()
+            .describe(`Pixels to crop from each edge to remove watermark. Default: ${DEFAULT_CROP_MARGIN}`),
+        skipCrop: z
+            .boolean()
+            .optional()
+            .describe('Skip watermark cropping (keep original image). Default: false'),
+    },
+    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
+            await navigateWithRetry(page, GEMINI_CONFIG.BASE_URL + 'app', {
+                waitUntil: 'networkidle2',
+            });
+            // Wait for UI to stabilize
+            try {
+                await Promise.race([
+                    page.waitForSelector('button[aria-label*="Account"], button[aria-label*="アカウント"]', { timeout: 10000 }),
+                    page.waitForSelector('[role="textbox"]', { timeout: 10000 }),
+                ]);
+            }
+            catch {
+                response.appendResponseLine('⚠️ UI安定化待機タイムアウト（続行）');
+            }
+            // Check login
+            const loginStatus = await getLoginStatus(page, 'gemini');
+            if (loginStatus === LoginStatus.NEEDS_LOGIN) {
+                response.appendResponseLine('\n❌ Geminiへのログインが必要です');
+                response.appendResponseLine('📱 ブラウザでGoogleアカウントにログインしてください');
+                const finalStatus = await waitForLoginStatus(page, 'gemini', 120000, msg => response.appendResponseLine(msg));
+                if (finalStatus !== LoginStatus.LOGGED_IN) {
+                    response.appendResponseLine('❌ ログインタイムアウト');
+                    return;
+                }
+            }
+            response.appendResponseLine('✅ ログイン確認完了');
+            // Enhance prompt for better cropping
+            const enhancedPrompt = enhancePromptForCropping(prompt);
+            response.appendResponseLine('プロンプトを送信中...');
+            // Input enhanced prompt
+            const questionSent = await page.evaluate(promptText => {
+                const clearElement = (el) => {
+                    while (el.firstChild) {
+                        el.removeChild(el.firstChild);
+                    }
+                };
+                const textbox = document.querySelector('[role="textbox"]');
+                if (textbox) {
+                    textbox.focus();
+                    clearElement(textbox);
+                    textbox.textContent = promptText;
+                    textbox.dispatchEvent(new Event('input', { bubbles: true }));
+                    return true;
+                }
+                return false;
+            }, enhancedPrompt);
+            if (!questionSent) {
+                response.appendResponseLine('❌ 入力欄が見つかりません');
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+            // Click send button
+            const sent = await page.evaluate(() => {
+                const buttons = Array.from(document.querySelectorAll('button'));
+                const sendButton = buttons.find(b => b.textContent?.includes('プロンプトを送信') ||
+                    b.textContent?.includes('送信') ||
+                    b.getAttribute('aria-label')?.includes('送信') ||
+                    b.getAttribute('aria-label')?.includes('Send'));
+                if (sendButton && !sendButton.disabled) {
+                    sendButton.click();
+                    return true;
+                }
+                return false;
+            });
+            if (!sent) {
+                await page.keyboard.press('Enter');
+                response.appendResponseLine('⚠️ 送信ボタンが見つかりません (Enterキーを試行)');
+            }
+            response.appendResponseLine('🎨 画像生成中... (1-2分かかることがあります)');
+            // Wait for image generation to complete
+            // Look for generated image or download button
+            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,
+                    };
+                });
+                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('⚠️ 生成中インジケータが消えました...');
+                }
+            }
+            if (!imageFound) {
+                response.appendResponseLine('❌ 画像生成タイムアウト (3分)');
+                return;
+            }
+            // Try to download the image
+            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();
+                    }
+                });
+            }
+            // 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)...`);
+                try {
+                    const { width, height } = await cropWatermark(downloadedPath, outputPath, cropMargin);
+                    response.appendResponseLine(`✅ クロップ完了: ${width}x${height}px → ${outputPath}`);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    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}`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            if (msg.includes('Target closed') || msg.includes('Session closed')) {
+                response.appendResponseLine('❌ ブラウザ接続が切れました');
+                response.appendResponseLine('→ MCPサーバーを再起動してください');
+            }
+            else {
+                response.appendResponseLine(`❌ エラー: ${msg}`);
+            }
+        }
+    },
+});

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

@@ -304,6 +304,10 @@ export const askGeminiWeb = defineTool({
                 return;
             }
             await new Promise(resolve => setTimeout(resolve, 500));
+            // 質問送信前に model-response 要素数を記録（ChatGPTと同じカウント方式）
+            const initialModelResponseCount = await page.evaluate(() => {
+                return document.querySelectorAll('model-response').length;
+            });
             // Click send button - look for "プロンプトを送信" or similar
             const sent = await page.evaluate(() => {
                 const buttons = Array.from(document.querySelectorAll('button'));
@@ -405,9 +409,17 @@ export const askGeminiWeb = defineTool({
                     });
                     return !!stopButton;
                 });
-                // Stop button/icon disappeared = generation complete
+                // Stop button/icon disappeared = check if new message appeared
                 if (!hasStopIndicator) {
-                    break;
+                    // 追加: model-response 要素数が増えたか確認（ChatGPTと同じ方式）
+                    const currentModelResponseCount = await page.evaluate(() => {
+                        return document.querySelectorAll('model-response').length;
+                    });
+                    if (currentModelResponseCount > initialModelResponseCount) {
+                        // ストップボタン消滅 AND 新規メッセージ出現で完了
+                        break;
+                    }
+                    // メッセージ数が増えていなければ、まだ待機続行
                 }
                 if (Date.now() - startTime > 180000) {
                     // 3 mins timeout
@@ -415,19 +427,24 @@ export const askGeminiWeb = defineTool({
                     break;
                 }
             }
-            // Get the final response content
-            const responseText = await page.evaluate(() => {
+            // Get the final response content (新規に追加された model-response のみを取得)
+            const responseText = await page.evaluate(initialCount => {
                 // Get content from model-response elements
                 const modelResponses = Array.from(document.querySelectorAll('model-response'));
+                if (modelResponses.length > initialCount) {
+                    // 新規に追加された model-response を取得（ChatGPTと同じ方式）
+                    const newResponse = modelResponses[initialCount];
+                    return newResponse.textContent?.trim() || '';
+                }
+                // Fallback: get the last model response if any
                 if (modelResponses.length > 0) {
-                    // Get the last model response
                     const lastResponse = modelResponses[modelResponses.length - 1];
                     return lastResponse.textContent?.trim() || '';
                 }
                 // Fallback: get text from main area
                 const main = document.querySelector('main');
                 return main?.innerText.slice(-5000) || '';
-            });
+            }, initialModelResponseCount);
             response.appendResponseLine('✅ 回答完了');
             // Always save/update session (not just for new chats)
             const chatUrl = page.url();

package/build/src/tools/optional-tools.js

@@ -4,12 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import * as chatgptWebTools from './chatgpt-web.js';
+import * as geminiImageTools from './gemini-image.js';
 import * as geminiWebTools from './gemini-web.js';
 /**
  * All optional (web-llm) tools as an array.
  */
 export const optionalTools = [
     ...Object.values(chatgptWebTools),
+    ...Object.values(geminiImageTools),
     ...Object.values(geminiWebTools),
 ];
 /**
@@ -61,9 +63,9 @@ export function getOptionalToolCount() {
  * Metadata about optional tools for documentation.
  */
 export const WEB_LLM_TOOLS_INFO = {
-    disclaimer: 'Web-LLM tools (ask_chatgpt_web, ask_gemini_web) are experimental and best-effort. ' +
+    disclaimer: 'Web-LLM tools (ask_chatgpt_web, ask_gemini_web, ask_gemini_image) are experimental and best-effort. ' +
         'They depend on specific website UIs and may break when those UIs change. ' +
         'For production use, consider using official APIs instead.',
     disableEnvVar: 'MCP_DISABLE_WEB_LLM',
-    tools: ['ask_chatgpt_web', 'ask_gemini_web'],
+    tools: ['ask_chatgpt_web', 'ask_gemini_image', 'ask_gemini_web'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-ai-bridge",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "MCP server bridging Chrome browser and AI assistants (ChatGPT, Gemini). Browser automation + AI consultation.",
   "type": "module",
   "bin": "./scripts/cli.mjs",
@@ -59,6 +59,7 @@
     "@modelcontextprotocol/sdk": "1.18.1",
     "archiver": "^7.0.1",
     "debug": "4.4.3",
+    "jimp": "^1.6.0",
     "puppeteer": "^24.31.0",
     "yargs": "18.0.0"
   },