notebooklm-mcp-ultimate 2.3.0 → 2.3.2

package/dist/session/browser-session.js

@@ -13,7 +13,8 @@
  * Based on the Python implementation from browser_session.py
  */
 import { humanType, randomDelay } from "../utils/stealth-utils.js";
-import { waitForLatestAnswer, snapshotAllResponses, } from "../utils/page-utils.js";
+import { waitForLatestAnswer, snapshotAllResponses, extractCSRFFromPage, } from "../utils/page-utils.js";
+import { csrfManager } from "../api/csrf-manager.js";
 import { CONFIG } from "../config.js";
 import { log } from "../utils/logger.js";
 import { RateLimitError } from "../errors.js";
@@ -67,13 +68,16 @@ export class BrowserSession {
                 }
             }
             log.success(`  ✅ Created new page`);
+            // Set iPad Mini viewport for NotebookLM responsive UI
+            await this.page.setViewportSize({ width: 768, height: 1024 });
             // Navigate to notebook
             log.info(`  🌐 Navigating to: ${this.notebookUrl}`);
             await this.page.goto(this.notebookUrl, {
                 waitUntil: "domcontentloaded",
                 timeout: CONFIG.browserTimeout,
             });
-            // Wait for page to stabilize
+            // Wait for Angular to finish rendering (use load instead of networkidle to avoid timeout)
+            await this.page.waitForLoadState('load').catch(() => { });
             await randomDelay(2000, 3000);
             // Check if we need to login
             const isAuthenticated = await this.authManager.validateCookiesExpiry(this.context);
@@ -106,6 +110,17 @@ export class BrowserSession {
             // Wait for NotebookLM interface to load
             log.info(`  ⏳ Waiting for NotebookLM interface...`);
             await this.waitForNotebookLMReady();
+            // Extract CSRF token from browser and set on API client
+            // This ensures API calls use the same session as the browser
+            if (this.page) {
+                const csrfToken = await extractCSRFFromPage(this.page);
+                if (csrfToken) {
+                    csrfManager.setCachedToken(csrfToken);
+                    // Also save CSRF to disk for cold-start API usage
+                    await this.authManager.saveCSRFToken(csrfToken);
+                    log.success(`  🔑 CSRF token synced to API client`);
+                }
+            }
             this.initialized = true;
             this.updateActivity();
             log.success(`✅ Session ${this.sessionId} initialized successfully`);
@@ -137,7 +152,7 @@ export class BrowserSession {
             // PRIMARY: Exact Python selector - textarea.query-box-input
             log.info("  ⏳ Waiting for chat input (textarea.query-box-input)...");
             await this.page.waitForSelector("textarea.query-box-input", {
-                timeout: 10000, // Python uses 10s timeout
+                timeout: 15000, // Extended for headless tests
                 state: "visible", // ONLY check visibility (NO disabled check!)
             });
             log.success("  ✅ Chat input ready!");
@@ -145,10 +160,12 @@ export class BrowserSession {
         catch {
             // Fix 5: Try multiple locale-agnostic fallback selectors instead of German-only
             const fallbackSelectors = [
+                'textarea[aria-label="Query box"]', // Exact aria-label (verified)
+                'textarea[placeholder="Start typing..."]', // Exact placeholder (verified)
+                'textarea[placeholder*="Start typing"]', // Partial match
+                'textarea.mat-mdc-autocomplete-trigger', // Material autocomplete
                 'textarea[aria-label*="query"]', // English partial
                 'textarea[aria-label*="question"]', // English
-                'textarea[aria-label*="Ask"]', // English
-                'textarea[aria-label="Feld für Anfragen"]', // German (original)
                 'textarea[role="textbox"]', // Generic fallback
             ];
             let found = false;
@@ -599,6 +616,824 @@ export class BrowserSession {
             throw error;
         }
     }
+    /**
+     * Add a text source to the notebook via browser UI
+     *
+     * @param title - Title for the source
+     * @param content - Text content to add
+     * @param sendProgress - Optional progress callback
+     * @returns true if source was added successfully
+     */
+    async addTextSourceViaUI(title, content, sendProgress) {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`📝 [${this.sessionId}] Adding text source via UI: "${title}"`);
+        try {
+            const page = this.page;
+            await sendProgress?.("Opening source panel...", 1, 6);
+            // Dismiss any overlay/modal that might block clicks (e.g., new notebook onboarding)
+            const overlay = page.locator('.cdk-overlay-backdrop-showing');
+            if (await overlay.isVisible({ timeout: 1000 }).catch(() => false)) {
+                log.info("  🔄 Dismissing overlay modal...");
+                await page.keyboard.press('Escape');
+                await randomDelay(500, 800);
+            }
+            // Click on Sources tab first (iPad Mini viewport uses role="tab")
+            const sourcesTab = page.locator('[role="tab"]:has-text("Sources")').first();
+            if (await sourcesTab.isVisible({ timeout: 3000 })) {
+                await sourcesTab.click();
+                await randomDelay(500, 800);
+            }
+            // Click the "Add sources" button (found via debug: button:has-text("Add sources"))
+            const addSourceSelectors = [
+                'button:has-text("Add sources")', // Primary - found via debug
+                'button[aria-label*="Add source"]',
+                'button[aria-label*="add source"]',
+                '[data-tooltip*="Add source"]',
+                'button.add-source-button',
+            ];
+            let addButtonClicked = false;
+            for (const sel of addSourceSelectors) {
+                try {
+                    const btn = page.locator(sel).first();
+                    if (await btn.isVisible({ timeout: 2000 })) {
+                        await btn.click();
+                        addButtonClicked = true;
+                        log.info(`  ✅ Clicked add source button: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!addButtonClicked) {
+                // Try keyboard shortcut or alternative approach
+                log.warning("  ⚠️  Could not find add source button, trying alternative...");
+                // Some UIs use a menu - try clicking on Sources header
+                const sourcesHeader = page.locator('text="Sources"').first();
+                if (await sourcesHeader.isVisible({ timeout: 2000 })) {
+                    await sourcesHeader.click();
+                    await randomDelay(500, 1000);
+                }
+            }
+            await randomDelay(1000, 1500);
+            await sendProgress?.("Selecting text source option...", 2, 5);
+            // Select "Copied text" or "Paste text" option
+            const textOptionSelectors = [
+                'button:has-text("Copied text")', // Primary option
+                'button:has-text("Paste text")', // Alternative
+                '[role="menuitem"]:has-text("Copied text")',
+                '[role="menuitem"]:has-text("Paste text")',
+                'button:has-text("Text")', // Generic fallback
+            ];
+            let textOptionClicked = false;
+            for (const sel of textOptionSelectors) {
+                try {
+                    const opt = page.locator(sel).first();
+                    if (await opt.isVisible({ timeout: 2000 })) {
+                        await opt.click();
+                        textOptionClicked = true;
+                        log.info(`  ✅ Selected text source option: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!textOptionClicked) {
+                throw new Error("Could not find text source option in menu");
+            }
+            await randomDelay(1000, 1500);
+            await sendProgress?.("Filling in source details...", 3, 5);
+            // Fill in the title field
+            const titleInputSelectors = [
+                'input[placeholder*="title"]',
+                'input[placeholder*="Title"]',
+                'input[aria-label*="title"]',
+                'input[aria-label*="Title"]',
+                'input[placeholder*="name"]',
+                // German
+                'input[placeholder*="Titel"]',
+                // Generic - first input in dialog
+                '[role="dialog"] input:first-of-type',
+            ];
+            for (const sel of titleInputSelectors) {
+                try {
+                    const input = page.locator(sel).first();
+                    if (await input.isVisible({ timeout: 2000 })) {
+                        await input.fill(title);
+                        log.info(`  ✅ Filled title: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Fill in the content field (textarea)
+            const contentSelectors = [
+                'textarea[placeholder*="Paste"]',
+                'textarea[placeholder*="paste"]',
+                'textarea[placeholder*="content"]',
+                'textarea[aria-label*="content"]',
+                'textarea[aria-label*="text"]',
+                // German
+                'textarea[placeholder*="Einfügen"]',
+                // Generic - textarea in dialog
+                '[role="dialog"] textarea',
+            ];
+            for (const sel of contentSelectors) {
+                try {
+                    const textarea = page.locator(sel).first();
+                    if (await textarea.isVisible({ timeout: 2000 })) {
+                        await textarea.fill(content);
+                        log.info(`  ✅ Filled content: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            await randomDelay(500, 1000);
+            await sendProgress?.("Submitting source...", 4, 5);
+            // Click submit/insert button
+            const submitSelectors = [
+                'button:has-text("Insert")',
+                'button:has-text("Add")',
+                'button:has-text("Save")',
+                'button:has-text("Submit")',
+                // German
+                'button:has-text("Einfügen")',
+                'button:has-text("Hinzufügen")',
+                // Generic primary button in dialog
+                '[role="dialog"] button[type="submit"]',
+                '[role="dialog"] button.primary',
+            ];
+            let submitted = false;
+            for (const sel of submitSelectors) {
+                try {
+                    const btn = page.locator(sel).first();
+                    if (await btn.isVisible({ timeout: 2000 })) {
+                        await btn.click();
+                        submitted = true;
+                        log.info(`  ✅ Clicked submit: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!submitted) {
+                throw new Error("Could not find submit button");
+            }
+            // Wait for source to be processed
+            await randomDelay(2000, 3000);
+            await sendProgress?.("Source added, waiting for processing...", 5, 5);
+            this.updateActivity();
+            log.success(`✅ [${this.sessionId}] Text source added via UI: "${title}"`);
+            return true;
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to add text source via UI: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Add a file source to the notebook via browser UI
+     *
+     * @param filePath - Local file path to upload
+     * @param sendProgress - Optional progress callback
+     * @returns true if source was added successfully
+     */
+    async addFileSourceViaUI(filePath, sendProgress) {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`📁 [${this.sessionId}] Adding file source via UI: "${filePath}"`);
+        try {
+            const page = this.page;
+            await sendProgress?.("Opening source panel...", 1, 6);
+            // Dismiss any overlay/modal that might block clicks (e.g., new notebook onboarding)
+            const overlay = page.locator('.cdk-overlay-backdrop-showing');
+            if (await overlay.isVisible({ timeout: 1000 }).catch(() => false)) {
+                log.info("  🔄 Dismissing overlay modal...");
+                await page.keyboard.press('Escape');
+                await randomDelay(500, 800);
+            }
+            // Click on Sources tab first (iPad Mini viewport uses role="tab")
+            const sourcesTab = page.locator('[role="tab"]:has-text("Sources")').first();
+            if (await sourcesTab.isVisible({ timeout: 3000 })) {
+                await sourcesTab.click();
+                await randomDelay(500, 800);
+            }
+            // Click add source button
+            const addBtn = page.locator('button:has-text("Add sources"), button[aria-label*="Add source"]').first();
+            await addBtn.click({ timeout: 5000 });
+            await randomDelay(1000, 1500);
+            await sendProgress?.("Selecting file upload option...", 2, 6);
+            // Select file upload option
+            const fileOptionSelectors = [
+                'button:has-text("Upload")',
+                'button:has-text("File")',
+                '[role="menuitem"]:has-text("Upload")',
+                '[role="menuitem"]:has-text("File")',
+            ];
+            let selected = false;
+            for (const sel of fileOptionSelectors) {
+                try {
+                    const opt = page.locator(sel).first();
+                    if (await opt.isVisible({ timeout: 2000 })) {
+                        await opt.click();
+                        log.info(`  ✅ Selected file option: ${sel}`);
+                        selected = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!selected) {
+                throw new Error("Could not find file upload option");
+            }
+            await randomDelay(1500, 2000);
+            await sendProgress?.("Selecting file...", 3, 4);
+            // Look for the file input or a button that triggers file chooser
+            // NotebookLM may show a drag-drop area with a "browse" link or hidden file input
+            const fileInputSelectors = [
+                'input[type="file"]',
+                '.cdk-overlay-pane input[type="file"]',
+                '[role="dialog"] input[type="file"]',
+            ];
+            let fileInput = null;
+            for (const sel of fileInputSelectors) {
+                try {
+                    const input = page.locator(sel).first();
+                    // File inputs are often hidden, so just check if it exists
+                    if (await input.count() > 0) {
+                        fileInput = input;
+                        log.info(`  ✅ Found file input: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (fileInput) {
+                // Direct file input - use setInputFiles
+                await fileInput.setInputFiles(filePath);
+                log.info(`  ✅ File set via input: ${filePath}`);
+            }
+            else {
+                // Try clicking a browse/choose button with file chooser
+                const browseSelectors = [
+                    'button:has-text("browse")',
+                    'button:has-text("Browse")',
+                    'button:has-text("Choose")',
+                    'a:has-text("browse")',
+                    '.cdk-overlay-pane button',
+                ];
+                let clicked = false;
+                for (const sel of browseSelectors) {
+                    try {
+                        const [fileChooser] = await Promise.all([
+                            page.waitForEvent('filechooser', { timeout: 5000 }),
+                            page.locator(sel).first().click({ timeout: 2000 })
+                        ]);
+                        await fileChooser.setFiles(filePath);
+                        log.info(`  ✅ File selected via chooser: ${filePath}`);
+                        clicked = true;
+                        break;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!clicked) {
+                    throw new Error("Could not find file input or browse button");
+                }
+            }
+            await sendProgress?.("Processing upload...", 4, 4);
+            await randomDelay(3000, 5000); // File upload takes time
+            this.updateActivity();
+            log.success(`✅ [${this.sessionId}] File source added via UI: "${filePath}"`);
+            return true;
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to add file source via UI: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Add a URL source to the notebook via browser UI
+     *
+     * @param url - URL to add as source
+     * @param sendProgress - Optional progress callback
+     * @returns true if source was added successfully
+     */
+    async addURLSourceViaUI(url, sendProgress) {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`🔗 [${this.sessionId}] Adding URL source via UI: "${url}"`);
+        try {
+            const page = this.page;
+            await sendProgress?.("Opening source panel...", 1, 5);
+            // Dismiss any overlay/modal that might block clicks (e.g., new notebook onboarding)
+            const overlay = page.locator('.cdk-overlay-backdrop-showing');
+            if (await overlay.isVisible({ timeout: 1000 }).catch(() => false)) {
+                log.info("  🔄 Dismissing overlay modal...");
+                await page.keyboard.press('Escape');
+                await randomDelay(500, 800);
+            }
+            // Click on Sources tab first (iPad Mini viewport uses role="tab")
+            const sourcesTab = page.locator('[role="tab"]:has-text("Sources")').first();
+            if (await sourcesTab.isVisible({ timeout: 3000 })) {
+                await sourcesTab.click();
+                await randomDelay(500, 800);
+            }
+            // Click add source button
+            const addBtn = page.locator('button:has-text("Add sources"), button[aria-label*="Add source"]').first();
+            await addBtn.click({ timeout: 5000 });
+            await randomDelay(1000, 1500);
+            await sendProgress?.("Selecting website option...", 2, 5);
+            // Select website/URL option
+            const urlOptionSelectors = [
+                'button:has-text("Websites")',
+                'button:has-text("Website")',
+                '[role="menuitem"]:has-text("Websites")',
+                '[role="menuitem"]:has-text("Website")',
+            ];
+            for (const sel of urlOptionSelectors) {
+                try {
+                    const opt = page.locator(sel).first();
+                    if (await opt.isVisible({ timeout: 2000 })) {
+                        await opt.click();
+                        log.info(`  ✅ Selected URL option: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            await randomDelay(1500, 2000);
+            await sendProgress?.("Entering URL...", 3, 4);
+            // Fill URL textarea - NotebookLM uses textarea with "Paste any links" placeholder
+            const urlTextareaSelectors = [
+                'textarea[placeholder*="Paste any links"]',
+                'textarea[placeholder*="Paste"]',
+                '.cdk-overlay-pane textarea',
+                '[role="dialog"] textarea',
+            ];
+            let filled = false;
+            for (const sel of urlTextareaSelectors) {
+                try {
+                    const textarea = page.locator(sel).first();
+                    if (await textarea.isVisible({ timeout: 1500 })) {
+                        await textarea.fill(url);
+                        log.info(`  ✅ Filled URL: ${sel}`);
+                        filled = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!filled) {
+                throw new Error("Could not find URL textarea");
+            }
+            await randomDelay(500, 1000);
+            await sendProgress?.("Submitting...", 4, 4);
+            // Submit - look in dialog context
+            const submitSelectors = [
+                '.cdk-overlay-pane button:has-text("Insert")',
+                '[role="dialog"] button:has-text("Insert")',
+                'button:has-text("Insert")',
+            ];
+            for (const sel of submitSelectors) {
+                try {
+                    const btn = page.locator(sel).first();
+                    if (await btn.isVisible({ timeout: 1500 })) {
+                        await btn.click();
+                        log.info(`  ✅ Clicked submit: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Wait for dialog to close
+            await page.waitForSelector('textarea[placeholder*="Paste any links"]', {
+                state: 'hidden',
+                timeout: 30000
+            }).catch(() => { });
+            await randomDelay(2000, 3000);
+            // Verify source was added by checking source count
+            const sourceCount = await page.locator('.source-item, [data-source-id], mat-list-item').count();
+            const sourceAdded = sourceCount > 0;
+            this.updateActivity();
+            if (sourceAdded) {
+                log.success(`✅ [${this.sessionId}] URL source added via UI: "${url}" (${sourceCount} sources)`);
+                return true;
+            }
+            else {
+                log.warning(`⚠️ [${this.sessionId}] Source may not have been added: "${url}"`);
+                return true; // Still return true as click succeeded, source might be processing
+            }
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to add URL source via UI: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Add a YouTube source to the notebook via browser UI
+     *
+     * @param youtubeUrl - YouTube video URL
+     * @param sendProgress - Optional progress callback
+     * @returns true if source was added successfully
+     */
+    async addYouTubeSourceViaUI(youtubeUrl, sendProgress) {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`🎥 [${this.sessionId}] Adding YouTube source via UI: "${youtubeUrl}"`);
+        try {
+            const page = this.page;
+            await sendProgress?.("Opening source panel...", 1, 6);
+            // Dismiss any overlay/modal that might block clicks (e.g., new notebook onboarding)
+            const overlay = page.locator('.cdk-overlay-backdrop-showing');
+            if (await overlay.isVisible({ timeout: 1000 }).catch(() => false)) {
+                log.info("  🔄 Dismissing overlay modal...");
+                await page.keyboard.press('Escape');
+                await randomDelay(500, 800);
+            }
+            // Click on Sources tab first (iPad Mini viewport uses role="tab")
+            const sourcesTab = page.locator('[role="tab"]:has-text("Sources")').first();
+            if (await sourcesTab.isVisible({ timeout: 3000 })) {
+                await sourcesTab.click();
+                await randomDelay(500, 800);
+            }
+            // Click add source button
+            const addBtn = page.locator('button:has-text("Add sources"), button[aria-label*="Add source"]').first();
+            await addBtn.click({ timeout: 5000 });
+            await randomDelay(1000, 1500);
+            await sendProgress?.("Selecting Website/YouTube option...", 2, 6);
+            // Select Website option - opens "Website and YouTube URLs" dialog
+            const urlOptionSelectors = [
+                'button:has-text("Website")',
+                '[role="menuitem"]:has-text("Website")',
+                'button:has-text("Link")',
+                'button:has-text("URL")',
+                'button:has-text("YouTube")',
+                '[role="menuitem"]:has-text("YouTube")',
+            ];
+            let selected = false;
+            for (const sel of urlOptionSelectors) {
+                try {
+                    const opt = page.locator(sel).first();
+                    if (await opt.isVisible({ timeout: 2000 })) {
+                        await opt.click();
+                        log.info(`  ✅ Selected URL option: ${sel}`);
+                        selected = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!selected) {
+                throw new Error("Could not find Website/YouTube source option");
+            }
+            await randomDelay(2000, 2500); // Wait for dialog to fully render
+            await sendProgress?.("Entering YouTube URL...", 3, 4);
+            // Fill URL textarea - NotebookLM uses textarea with "Paste any links" placeholder
+            const urlTextareaSelectors = [
+                'textarea[placeholder*="Paste any links"]',
+                'textarea[placeholder*="Paste"]',
+                'textarea[placeholder*="paste"]',
+                'textarea[placeholder*="link"]',
+                'textarea[placeholder*="URL"]',
+                '.cdk-overlay-pane textarea',
+                '[role="dialog"] textarea',
+            ];
+            let filled = false;
+            for (const sel of urlTextareaSelectors) {
+                try {
+                    const textarea = page.locator(sel).first();
+                    if (await textarea.isVisible({ timeout: 1500 })) {
+                        await textarea.fill(youtubeUrl);
+                        log.info(`  ✅ Filled YouTube URL: ${sel}`);
+                        filled = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!filled) {
+                throw new Error("Could not find URL textarea");
+            }
+            await randomDelay(500, 1000);
+            await sendProgress?.("Submitting...", 4, 4);
+            // Submit - look in dialog context first
+            const submitSelectors = [
+                '.cdk-overlay-pane button:has-text("Insert")',
+                '.cdk-overlay-pane button:has-text("Add")',
+                '[role="dialog"] button:has-text("Insert")',
+                '[role="dialog"] button:has-text("Add")',
+                'button:has-text("Insert")',
+                'button:has-text("Add")',
+                'button[type="submit"]',
+            ];
+            let submitted = false;
+            for (const sel of submitSelectors) {
+                try {
+                    const btn = page.locator(sel).first();
+                    if (await btn.isVisible({ timeout: 1500 })) {
+                        await btn.click();
+                        log.info(`  ✅ Clicked submit: ${sel}`);
+                        submitted = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!submitted) {
+                log.warning('  ⚠️  Submit button not found, dialog may have auto-submitted');
+            }
+            await randomDelay(3000, 4000); // YouTube processing takes longer
+            this.updateActivity();
+            log.success(`✅ [${this.sessionId}] YouTube source added via UI: "${youtubeUrl}"`);
+            return true;
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to add YouTube source via UI: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Search the web for new sources and add them to the notebook
+     *
+     * @param query - Search query
+     * @param sendProgress - Optional progress callback
+     * @returns true if search was submitted successfully
+     */
+    async searchWebForSourcesViaUI(query, sendProgress) {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`🔍 [${this.sessionId}] Searching web for sources: "${query}"`);
+        try {
+            const page = this.page;
+            await sendProgress?.("Opening search panel...", 1, 3);
+            // Find the search input in the sources panel
+            const searchInputSelectors = [
+                'input[placeholder*="Search the web"]',
+                'input[placeholder*="Search"]',
+                'input[aria-label*="Search"]',
+                '.sources-panel input[type="text"]',
+            ];
+            let searchInput = null;
+            for (const sel of searchInputSelectors) {
+                try {
+                    const input = page.locator(sel).first();
+                    if (await input.isVisible({ timeout: 2000 })) {
+                        searchInput = input;
+                        log.info(`  ✅ Found search input: ${sel}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!searchInput) {
+                throw new Error("Could not find web search input");
+            }
+            await sendProgress?.("Entering search query...", 2, 3);
+            // Fill the search query
+            await searchInput.fill(query);
+            await randomDelay(500, 1000);
+            await sendProgress?.("Submitting search...", 3, 3);
+            // Click the submit button (arrow icon)
+            const submitSelectors = [
+                'button[aria-label*="Search"]',
+                'button[aria-label*="Submit"]',
+                'button:has(mat-icon:has-text("arrow_forward"))',
+                'button:has(span:has-text("arrow_forward"))',
+                '.sources-panel button[type="submit"]',
+            ];
+            let submitted = false;
+            for (const sel of submitSelectors) {
+                try {
+                    const btn = page.locator(sel).first();
+                    if (await btn.isVisible({ timeout: 1500 })) {
+                        await btn.click();
+                        log.info(`  ✅ Clicked search submit: ${sel}`);
+                        submitted = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!submitted) {
+                // Try pressing Enter as fallback
+                await searchInput.press('Enter');
+                log.info(`  ✅ Pressed Enter to submit search`);
+            }
+            await randomDelay(3000, 5000); // Wait for search results
+            this.updateActivity();
+            log.success(`✅ [${this.sessionId}] Web search submitted: "${query}"`);
+            return true;
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to search web for sources: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * List sources in the notebook via browser UI
+     *
+     * @returns Array of source objects with title and id
+     */
+    async listSourcesViaUI() {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`📚 [${this.sessionId}] Listing sources via UI...`);
+        try {
+            const page = this.page;
+            // Click on Sources tab first (iPad Mini viewport uses role="tab")
+            const sourcesTab = page.locator('[role="tab"]:has-text("Sources")').first();
+            if (await sourcesTab.isVisible({ timeout: 5000 })) {
+                await sourcesTab.click();
+                await randomDelay(1000, 1500);
+            }
+            // Use JS evaluation to get source titles (most reliable method)
+            // Sources have button.source-stretched-button with aria-label containing the title
+            const sourceData = await page.evaluate(`
+        Array.from(document.querySelectorAll('button[aria-label]'))
+          .filter(b => b.classList.contains('source-stretched-button'))
+          .map(b => ({
+            title: b.getAttribute('aria-label') || '',
+            id: b.closest('[draggable]')?.querySelector('[id*="source"]')?.id || undefined
+          }))
+          .filter(s => s.title.length > 0)
+      `);
+            log.success(`✅ [${this.sessionId}] Found ${sourceData.length} sources via UI`);
+            this.updateActivity();
+            return sourceData;
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to list sources via UI: ${error}`);
+            return [];
+        }
+    }
+    /**
+     * Delete a source by title via browser UI
+     *
+     * @param sourceTitle - The title/name of the source to delete
+     * @param sendProgress - Optional progress callback
+     * @returns true if source was deleted successfully
+     */
+    async deleteSourceViaUI(sourceTitle, sendProgress) {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`🗑️  [${this.sessionId}] Deleting source via UI: ${sourceTitle}`);
+        try {
+            const page = this.page;
+            // Click on Sources tab first
+            const sourcesTab = page.locator('[role="tab"]:has-text("Sources")').first();
+            if (await sourcesTab.isVisible({ timeout: 5000 })) {
+                await sourcesTab.click();
+                await randomDelay(1000, 1500);
+            }
+            // Find the source button by aria-label (title)
+            const sourceButton = page.locator(`button.source-stretched-button[aria-label="${sourceTitle}"]`).first();
+            if (!await sourceButton.isVisible({ timeout: 5000 })) {
+                log.error(`❌ [${this.sessionId}] Source not found: ${sourceTitle}`);
+                return false;
+            }
+            // Find the more button (⋮) in the same source container
+            // IDs are like: source-item-more-button-{uuid}
+            const sourceContainer = sourceButton.locator('xpath=ancestor::*[@draggable="true"]').first();
+            const moreButton = sourceContainer.locator('[id^="source-item-more-button"], button[aria-label*="More"], button[aria-label*="more"], [aria-haspopup="menu"]').first();
+            if (await moreButton.isVisible({ timeout: 3000 })) {
+                await moreButton.click();
+                log.info(`  ✅ Clicked more button for: ${sourceTitle}`);
+                await randomDelay(500, 800);
+            }
+            else {
+                // Fallback: hover to reveal more button
+                await sourceButton.hover();
+                await randomDelay(500, 800);
+                const hoverMoreBtn = sourceContainer.locator('[id^="source-item-more-button"], button[aria-label*="More"]').first();
+                if (await hoverMoreBtn.isVisible({ timeout: 2000 })) {
+                    await hoverMoreBtn.click();
+                    await randomDelay(500, 800);
+                }
+                else {
+                    log.error(`❌ [${this.sessionId}] More button not found`);
+                    return false;
+                }
+            }
+            // Click "Delete" from the menu
+            const deleteMenuItem = page.locator('[role="menuitem"]:has-text("Delete"), button:has-text("Delete")').first();
+            if (await deleteMenuItem.isVisible({ timeout: 3000 })) {
+                await deleteMenuItem.click();
+                log.info(`  ✅ Clicked Delete menu item`);
+                await randomDelay(500, 800);
+                // Confirm deletion if dialog appears
+                const confirmBtn = page.locator('button:has-text("Delete"):not([role="menuitem"])').first();
+                if (await confirmBtn.isVisible({ timeout: 3000 })) {
+                    await confirmBtn.click();
+                    log.info(`  ✅ Confirmed deletion`);
+                    await randomDelay(1000, 1500);
+                }
+                log.success(`✅ [${this.sessionId}] Source deleted: ${sourceTitle}`);
+                if (sendProgress)
+                    await sendProgress(`✅ Source deleted: ${sourceTitle}`);
+                this.updateActivity();
+                return true;
+            }
+            log.error(`❌ [${this.sessionId}] Delete menu item not found`);
+            return false;
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to delete source via UI: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Get source details by clicking on it via browser UI
+     *
+     * @param sourceTitle - The title/name of the source
+     * @returns Source details object or null if not found
+     */
+    async getSourceDetailsViaUI(sourceTitle) {
+        if (!this.page || !this.initialized) {
+            throw new Error("Session not initialized");
+        }
+        log.info(`📄 [${this.sessionId}] Getting source details via UI: ${sourceTitle}`);
+        try {
+            const page = this.page;
+            // Click on Sources tab first
+            const sourcesTab = page.locator('[role="tab"]:has-text("Sources")').first();
+            if (await sourcesTab.isVisible({ timeout: 5000 })) {
+                await sourcesTab.click();
+                await randomDelay(1000, 1500);
+            }
+            // Find and click the source to open details panel
+            const sourceButton = page.locator(`button.source-stretched-button[aria-label="${sourceTitle}"]`).first();
+            if (!await sourceButton.isVisible({ timeout: 5000 })) {
+                log.error(`❌ [${this.sessionId}] Source not found: ${sourceTitle}`);
+                return null;
+            }
+            await sourceButton.click();
+            await randomDelay(1500, 2000);
+            // Scrape details from the source panel
+            const details = await page.evaluate(`
+        (() => {
+          // Look for source detail panel elements
+          const titleEl = document.querySelector('[class*="source-title"], [class*="sourceTitle"], h2, h3');
+          const typeEl = document.querySelector('[class*="source-type"], [class*="sourceType"]');
+          const dateEl = document.querySelector('[class*="date"], time');
+          const summaryEl = document.querySelector('[class*="summary"], [class*="description"], p');
+
+          return {
+            title: titleEl?.textContent?.trim() || '${sourceTitle}',
+            type: typeEl?.textContent?.trim() || undefined,
+            addedDate: dateEl?.textContent?.trim() || undefined,
+            summary: summaryEl?.textContent?.trim() || undefined
+          };
+        })()
+      `);
+            log.success(`✅ [${this.sessionId}] Got source details: ${sourceTitle}`);
+            this.updateActivity();
+            return details;
+        }
+        catch (error) {
+            log.error(`❌ [${this.sessionId}] Failed to get source details via UI: ${error}`);
+            return null;
+        }
+    }
     /**
      * Close the session
      */