@roomi-fields/notebooklm-mcp 1.3.6 → 1.5.1

package/dist/content/content-manager.js

@@ -0,0 +1,3841 @@
+/**
+ * Content Manager
+ *
+ * Handles NotebookLM content operations:
+ * - Source/document upload
+ * - Content generation (audio, briefing, study guides, etc.)
+ * - Content listing and download
+ *
+ * Uses Playwright to interact with NotebookLM's web interface.
+ */
+import path from 'path';
+import { existsSync } from 'fs';
+import { randomDelay, realisticClick, humanType } from '../utils/stealth-utils.js';
+import { log } from '../utils/logger.js';
+import { CONFIG } from '../config.js';
+import { waitForLatestAnswer, snapshotAllResponses, isErrorMessage } from '../utils/page-utils.js';
+import { setLocale, tAll } from '../i18n/index.js';
+// Initialize i18n with configured locale
+setLocale(CONFIG.uiLocale);
+/**
+ * Build selectors for all supported locales
+ * @param template Selector template with {text} placeholder
+ * @param category i18n category (e.g., 'tabs', 'buttons')
+ * @param key i18n key within the category
+ * @returns Array of selectors for all locales
+ */
+function i18nSelectors(template, category, key) {
+    const texts = tAll(category, key);
+    return texts.map((text) => template.replace('{text}', text));
+}
+import { ContentGenerator } from './content-generator.js';
+// Note: UI selectors are defined inline in methods for better maintainability
+// as NotebookLM's UI may change frequently
+export class ContentManager {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    // ============================================================================
+    // Source/Document Upload
+    // ============================================================================
+    /**
+     * Add a source to the current notebook
+     */
+    async addSource(input) {
+        log.info(`📄 Adding source: ${input.type}`);
+        // CRITICAL: Capture initial URL BEFORE any action
+        // NotebookLM may redirect when clicking "Add source" button!
+        const initialUrl = this.page.url();
+        const expectedNotebookUuid = initialUrl.match(/notebook\/([a-f0-9-]+)/)?.[1];
+        log.info(`  🎯 Target notebook UUID: ${expectedNotebookUuid || 'NOT FOUND'}`);
+        try {
+            // Click "Add source" button
+            await this.clickAddSource();
+            // Wait for upload dialog
+            await this.waitForUploadDialog();
+            // Select upload type and upload (pass expectedNotebookUuid for redirect detection)
+            switch (input.type) {
+                case 'file':
+                    return await this.uploadFile(input, expectedNotebookUuid);
+                case 'url':
+                    return await this.uploadUrl(input, expectedNotebookUuid);
+                case 'text':
+                    return await this.uploadText(input, expectedNotebookUuid);
+                case 'google_drive':
+                    return await this.uploadGoogleDrive(input, expectedNotebookUuid);
+                case 'youtube':
+                    return await this.uploadYouTube(input, expectedNotebookUuid);
+                default:
+                    return { success: false, error: `Unsupported source type: ${input.type}` };
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`❌ Failed to add source: ${errorMsg}`);
+            return { success: false, error: errorMsg };
+        }
+    }
+    /**
+     * Click the "Add source" button
+     */
+    async clickAddSource() {
+        // First, ensure we're on the Sources panel (left panel)
+        await this.ensureSourcesPanel();
+        // Wait for panel to be ready (increased for reliability)
+        await randomDelay(800, 1200);
+        // Check if a dialog is already open and close it first
+        try {
+            const existingDialog = this.page.locator('[role="dialog"]');
+            if (await existingDialog.isVisible({ timeout: 500 })) {
+                log.info('  ⚠️ Dialog already open, closing first...');
+                await this.page.keyboard.press('Escape');
+                await randomDelay(500, 800);
+            }
+        }
+        catch {
+            // No existing dialog, continue
+        }
+        const addSourceSelectors = [
+            // NotebookLM current UI (Dec 2024) - aria-label based (most reliable)
+            'button[aria-label="Add source"]',
+            'button[aria-label="Ajouter une source"]', // French
+            'button[aria-label*="Add source"]',
+            'button[aria-label*="Ajouter une source"]',
+            'button[aria-label*="add source" i]',
+            // Icon button with "add" icon specifically
+            'button:has(mat-icon:has-text("add"))',
+            'button:has(mat-icon:has-text("add_circle"))',
+            // Text-based patterns (bilingual via i18n)
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'addSource'),
+            // FAB buttons (floating action button for adding)
+            'button.mat-fab',
+            'button.mat-mini-fab',
+            // REMOVED generic selectors that match ANY icon button
+        ];
+        log.info(`  🔍 Looking for Add source button...`);
+        for (const selector of addSourceSelectors) {
+            try {
+                const button = this.page.locator(selector).first();
+                if (await button.isVisible({ timeout: 1000 })) {
+                    log.info(`  ✅ Found add source button: ${selector}`);
+                    await realisticClick(this.page, selector, true);
+                    await randomDelay(500, 1000);
+                    return;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Fallback: Try to find any button with "add" aria-label
+        log.info(`  🔍 Trying fallback: buttons with add-related aria-label...`);
+        try {
+            const addButtons = await this.page.locator('button[aria-label]').all();
+            for (const btn of addButtons) {
+                const ariaLabel = await btn.getAttribute('aria-label');
+                if (ariaLabel && /add|ajouter|upload|source/i.test(ariaLabel)) {
+                    if (await btn.isVisible()) {
+                        log.info(`  ✅ Found add button via fallback: aria-label="${ariaLabel}"`);
+                        await btn.click();
+                        await randomDelay(500, 1000);
+                        return;
+                    }
+                }
+            }
+        }
+        catch {
+            // Continue to debug
+        }
+        // Debug: log page content to help identify the correct selector
+        await this.debugPageContent();
+        throw new Error('Could not find "Add source" button');
+    }
+    /**
+     * Ensure we're on the Sources panel
+     */
+    async ensureSourcesPanel() {
+        log.info(`  📑 Ensuring Sources panel is active...`);
+        // First, close any open dialogs that might be blocking
+        try {
+            const openDialog = this.page.locator('[role="dialog"]');
+            if (await openDialog.isVisible({ timeout: 500 })) {
+                log.info(`  ⚠️ Closing blocking dialog first...`);
+                await this.page.keyboard.press('Escape');
+                await randomDelay(300, 500);
+            }
+        }
+        catch {
+            /* no dialog */
+        }
+        const sourcesTabSelectors = [
+            // NotebookLM current UI (Dec 2024) - MDC tabs (bilingual FR/EN via i18n)
+            ...i18nSelectors('div.mdc-tab:has-text("{text}")', 'tabs', 'sources'),
+            ...i18nSelectors('.mat-mdc-tab:has-text("{text}")', 'tabs', 'sources'),
+            ...i18nSelectors('[role="tab"]:has-text("{text}")', 'tabs', 'sources'),
+            // First tab in the tab list (Sources is typically first)
+            '.mat-mdc-tab-list .mdc-tab:first-child',
+        ];
+        for (const selector of sourcesTabSelectors) {
+            try {
+                const tab = this.page.locator(selector).first();
+                if (await tab.isVisible({ timeout: 2000 })) {
+                    // Check if already selected using multiple methods
+                    const isSelected = await tab.getAttribute('aria-selected');
+                    const hasActiveClass = (await tab.getAttribute('class'))?.includes('mdc-tab--active');
+                    if (isSelected !== 'true' && !hasActiveClass) {
+                        log.info(`  📑 Clicking Sources tab: ${selector}`);
+                        // Use shorter timeout and force click if needed
+                        await tab.click({ timeout: 5000 });
+                        await randomDelay(500, 1000);
+                    }
+                    else {
+                        log.info(`  ✅ Sources tab already active`);
+                    }
+                    return;
+                }
+            }
+            catch (e) {
+                log.warning(`  ⚠️ Selector failed: ${selector} - ${e}`);
+                continue;
+            }
+        }
+        // Sources panel might already be visible or not use tabs
+        log.info(`  ℹ️ No Sources tab found, assuming already on sources panel`);
+        // Take debug screenshot to help identify the correct selectors
+        try {
+            const screenshotPath = path.join(CONFIG.dataDir, 'debug-sources-panel.png');
+            await this.page.screenshot({ path: screenshotPath, fullPage: true });
+            log.info(`  📸 Debug screenshot saved: ${screenshotPath}`);
+            // Log all tab elements to help find the correct selector
+            const allTabs = await this.page.locator('[role="tab"], .mdc-tab, .mat-tab-label').all();
+            log.info(`  🔍 Found ${allTabs.length} tab-like elements:`);
+            for (let i = 0; i < Math.min(allTabs.length, 10); i++) {
+                const tab = allTabs[i];
+                const text = await tab.textContent();
+                const ariaLabel = await tab.getAttribute('aria-label');
+                const classes = await tab.getAttribute('class');
+                log.info(`    Tab[${i}]: text="${text?.trim()}", aria="${ariaLabel}", class="${classes?.substring(0, 50)}..."`);
+            }
+        }
+        catch (e) {
+            log.warning(`  ⚠️ Could not capture debug info: ${e}`);
+        }
+    }
+    /**
+     * Debug helper to log page content for selector debugging
+     */
+    async debugPageContent() {
+        try {
+            // Log all buttons on the page
+            const buttons = await this.page.locator('button').all();
+            log.info(`  🔍 DEBUG: Found ${buttons.length} buttons on page`);
+            for (let i = 0; i < Math.min(buttons.length, 10); i++) {
+                const btn = buttons[i];
+                const ariaLabel = await btn.getAttribute('aria-label');
+                const text = await btn.textContent();
+                const classes = await btn.getAttribute('class');
+                log.info(`  🔍 Button[${i}]: aria="${ariaLabel}", text="${text?.trim()}", class="${classes}"`);
+            }
+            // Take a screenshot for debugging
+            const screenshotPath = path.join(CONFIG.dataDir, 'debug-add-source.png');
+            await this.page.screenshot({ path: screenshotPath, fullPage: true });
+            log.info(`  📸 Debug screenshot saved: ${screenshotPath}`);
+        }
+        catch (e) {
+            log.warning(`  ⚠️ Debug failed: ${e}`);
+        }
+    }
+    /**
+     * Wait for upload dialog to appear
+     */
+    async waitForUploadDialog() {
+        const dialogSelectors = [
+            '[role="dialog"]',
+            '.upload-dialog',
+            '.modal',
+            '[data-dialog="upload"]',
+        ];
+        for (const selector of dialogSelectors) {
+            try {
+                await this.page.waitForSelector(selector, { state: 'visible', timeout: 5000 });
+                log.info(`  ✅ Upload dialog appeared`);
+                return;
+            }
+            catch {
+                continue;
+            }
+        }
+        // Dialog might not be a separate element - continue anyway
+        log.info(`  ℹ️ No explicit dialog, continuing with upload...`);
+    }
+    /**
+     * Upload a local file
+     */
+    async uploadFile(input, expectedNotebookUuid) {
+        if (!input.filePath) {
+            return { success: false, error: 'File path is required' };
+        }
+        // Path traversal protection: resolve and validate the path
+        const resolvedPath = path.resolve(input.filePath);
+        const allowedDir = path.resolve(CONFIG.dataDir);
+        // Allow files from dataDir or current working directory
+        const cwd = path.resolve(process.cwd());
+        const isAllowed = resolvedPath.startsWith(allowedDir) || resolvedPath.startsWith(cwd);
+        if (!isAllowed) {
+            log.warning(`  ⚠️ Path traversal attempt blocked: ${input.filePath}`);
+            return {
+                success: false,
+                error: 'File path not allowed: must be within data directory or current working directory',
+            };
+        }
+        if (!existsSync(resolvedPath)) {
+            return { success: false, error: `File not found: ${input.filePath}` };
+        }
+        log.info(`  📁 Uploading file: ${path.basename(resolvedPath)}`);
+        try {
+            // Click on file upload option (bilingual via i18n)
+            const fileTypeSelectors = [
+                ...i18nSelectors('button:has-text("{text}")', 'sourceTypes', 'uploadFiles'),
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'upload'),
+                '[data-type="file"]',
+            ];
+            for (const selector of fileTypeSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 1000 })) {
+                        await btn.click();
+                        await randomDelay(300, 500);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Find file input and upload
+            const fileInput = await this.page.waitForSelector('input[type="file"]', {
+                state: 'attached',
+                timeout: 5000,
+            });
+            if (!fileInput) {
+                throw new Error('File input not found');
+            }
+            await fileInput.setInputFiles(input.filePath);
+            log.info(`  ✅ File selected`);
+            // Wait for upload to start
+            await randomDelay(1000, 2000);
+            // Click upload/confirm button
+            await this.clickUploadButton();
+            // Wait for processing
+            const result = await this.waitForSourceProcessing(input.title || path.basename(input.filePath), undefined, expectedNotebookUuid);
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `File upload failed: ${errorMsg}` };
+        }
+    }
+    /**
+     * Upload from URL
+     */
+    async uploadUrl(input, expectedNotebookUuid) {
+        if (!input.url) {
+            return { success: false, error: 'URL is required' };
+        }
+        log.info(`  🌐 Adding URL: ${input.url}`);
+        try {
+            // Click on URL/Website option (bilingual selectors)
+            const urlTypeSelectors = [
+                ...i18nSelectors('button:has-text("{text}")', 'sourceTypes', 'website'),
+                ...i18nSelectors('button:has-text("{text}")', 'sourceTypes', 'link'),
+                ...i18nSelectors('button:has-text("{text}")', 'sourceTypes', 'url'),
+                '[data-type="url"]',
+                '[aria-label*="website"]',
+                '[aria-label*="URL"]',
+            ];
+            log.info(`  🔍 Looking for URL option...`);
+            let foundUrlOption = false;
+            for (const selector of urlTypeSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 500 })) {
+                        log.info(`  ✅ Found URL option: ${selector}`);
+                        await btn.click();
+                        await randomDelay(300, 500);
+                        foundUrlOption = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!foundUrlOption) {
+                log.info(`  ℹ️ No URL option button found, looking for input directly`);
+                // DEBUG: List all visible buttons in the page
+                try {
+                    const buttons = await this.page.locator('button').all();
+                    log.info(`  🔍 DEBUG: Found ${buttons.length} buttons total`);
+                    for (let i = 0; i < Math.min(buttons.length, 15); i++) {
+                        const btn = buttons[i];
+                        const visible = await btn.isVisible().catch(() => false);
+                        if (visible) {
+                            const text = await btn.textContent().catch(() => '');
+                            const ariaLabel = await btn.getAttribute('aria-label').catch(() => '');
+                            log.info(`  🔍 Button[${i}]: text="${text?.trim()}", aria="${ariaLabel}"`);
+                        }
+                    }
+                }
+                catch (e) {
+                    log.warning(`  ⚠️ Could not list buttons: ${e}`);
+                }
+            }
+            // Wait for input to appear after clicking option
+            await randomDelay(500, 1000);
+            // Find URL input (can be input OR textarea) - bilingual selectors
+            log.info(`  🔍 Looking for URL input...`);
+            const urlInputSelectors = [
+                // i18n placeholder selectors
+                ...i18nSelectors('input[placeholder*="{text}"]', 'placeholders', 'pasteUrl'),
+                ...i18nSelectors('textarea[placeholder*="{text}"]', 'placeholders', 'pasteUrl'),
+                ...i18nSelectors('input[placeholder*="{text}"]', 'placeholders', 'enterUrl'),
+                ...i18nSelectors('textarea[placeholder*="{text}"]', 'placeholders', 'enterUrl'),
+                ...i18nSelectors('input[placeholder*="{text}"]', 'placeholders', 'pasteLinks'),
+                ...i18nSelectors('textarea[placeholder*="{text}"]', 'placeholders', 'pasteLinks'),
+                // URL/http generic selectors (work in both languages)
+                'input[placeholder*="URL"]',
+                'textarea[placeholder*="URL"]',
+                'input[placeholder*="url"]',
+                'textarea[placeholder*="url"]',
+                'input[placeholder*="http"]',
+                'textarea[placeholder*="http"]',
+                'input[name="url"]',
+                'input[type="url"]',
+                // Fallback dialog selectors
+                '[role="dialog"] input[type="text"]',
+                '[role="dialog"] input:not([type="hidden"])',
+                '[role="dialog"] textarea',
+                '.mat-dialog-content input',
+                '.mat-dialog-content textarea',
+                '.mdc-dialog__content input',
+                '.mdc-dialog__content textarea',
+            ];
+            let urlInput = null;
+            for (const selector of urlInputSelectors) {
+                try {
+                    const input = this.page.locator(selector).first();
+                    if (await input.isVisible({ timeout: 500 })) {
+                        urlInput = input;
+                        log.info(`  ✅ Found URL input: ${selector}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Fallback: find any visible input or textarea in the dialog
+            if (!urlInput) {
+                log.info(`  🔍 Trying fallback: any visible input/textarea in dialog...`);
+                try {
+                    // Try inputs first
+                    const allInputs = await this.page.locator('[role="dialog"] input').all();
+                    for (const input of allInputs) {
+                        if (await input.isVisible()) {
+                            urlInput = input;
+                            const placeholder = await input.getAttribute('placeholder');
+                            log.info(`  ✅ Found input via fallback: placeholder="${placeholder}"`);
+                            break;
+                        }
+                    }
+                    // Try textareas if no input found
+                    if (!urlInput) {
+                        const allTextareas = await this.page.locator('[role="dialog"] textarea').all();
+                        for (const textarea of allTextareas) {
+                            if (await textarea.isVisible()) {
+                                urlInput = textarea;
+                                const placeholder = await textarea.getAttribute('placeholder');
+                                log.info(`  ✅ Found textarea via fallback: placeholder="${placeholder}"`);
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            // Debug: list all inputs/textareas if still not found
+            if (!urlInput) {
+                log.warning(`  ⚠️ URL input not found, listing dialog elements...`);
+                try {
+                    const inputs = await this.page
+                        .locator('[role="dialog"] input, [role="dialog"] textarea')
+                        .all();
+                    for (let i = 0; i < inputs.length; i++) {
+                        const el = inputs[i];
+                        const tag = await el.evaluate((e) => e.tagName?.toLowerCase() || 'unknown');
+                        const type = await el.getAttribute('type');
+                        const placeholder = await el.getAttribute('placeholder');
+                        const visible = await el.isVisible();
+                        log.info(`  🔍 Element[${i}]: tag=${tag}, type="${type}", placeholder="${placeholder}", visible=${visible}`);
+                    }
+                }
+                catch (e) {
+                    log.warning(`  ⚠️ Could not list dialog elements: ${e}`);
+                }
+                throw new Error('URL input not found');
+            }
+            await urlInput.fill(input.url);
+            log.info(`  ✅ URL entered`);
+            await randomDelay(300, 500);
+            // Click add/upload button
+            log.info(`  🔍 Looking for upload button...`);
+            await this.clickUploadButton();
+            // Wait for processing
+            const result = await this.waitForSourceProcessing(input.title || input.url, undefined, expectedNotebookUuid);
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `URL upload failed: ${errorMsg}` };
+        }
+    }
+    /**
+     * Upload text content
+     */
+    async uploadText(input, expectedNotebookUuid) {
+        if (!input.text) {
+            return { success: false, error: 'Text content is required' };
+        }
+        log.info(`  📝 Adding text content (${input.text.length} chars)`);
+        try {
+            // Click on paste text option (bilingual FR/EN via i18n)
+            const textTypeSelectors = [
+                // Span element with pasted text label
+                ...i18nSelectors('span:has-text("{text}")', 'sourceTypes', 'pastedText'),
+                ...i18nSelectors(':has-text("{text}")', 'sourceTypes', 'pastedText'),
+                // Parent of the span (clickable area)
+                ...i18nSelectors('*:has(> span:has-text("{text}"))', 'sourceTypes', 'pastedText'),
+                // Generic fallbacks
+                'span:has-text("Paste text")',
+                ':has-text("Paste text")',
+                '[data-type="text"]',
+            ];
+            log.info(`  🔍 Looking for paste text option...`);
+            let foundTextOption = false;
+            // Debug: Log all clickable elements in the dialog
+            try {
+                const dialogButtons = await this.page
+                    .locator('[role="dialog"] button, [role="dialog"] [role="button"], [role="dialog"] a')
+                    .all();
+                log.info(`  🔍 DEBUG: Found ${dialogButtons.length} clickable elements in dialog`);
+                for (let i = 0; i < Math.min(dialogButtons.length, 15); i++) {
+                    const btn = dialogButtons[i];
+                    const text = await btn.textContent();
+                    log.info(`    Element[${i}]: "${text?.trim()}"`);
+                }
+            }
+            catch (e) {
+                log.warning(`  ⚠️ Could not debug dialog elements: ${e}`);
+            }
+            for (const selector of textTypeSelectors) {
+                try {
+                    log.info(`  🔍 Trying selector: ${selector}`);
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 2000 })) {
+                        log.info(`  ✅ Found text option: ${selector}`);
+                        await btn.click();
+                        await randomDelay(500, 1000);
+                        foundTextOption = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!foundTextOption) {
+                log.warning(`  ⚠️ No text option found - this will likely fail!`);
+                // Take screenshot for debugging
+                try {
+                    const screenshotPath = path.join(CONFIG.dataDir, 'debug-text-option-not-found.png');
+                    await this.page.screenshot({ path: screenshotPath });
+                    log.info(`  📸 Debug screenshot: ${screenshotPath}`);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            // Find text input - must be in the dialog, not the chat input
+            log.info(`  🔍 Looking for text input in dialog...`);
+            // Wait for the paste dialog to fully appear
+            await randomDelay(500, 800);
+            // Try to find textarea specifically in the dialog context
+            const textInputSelectors = [
+                '[role="dialog"] textarea',
+                '.mat-dialog-container textarea',
+                '.mdc-dialog textarea',
+                // Fallback to any visible textarea that's not the chat input
+                'textarea:not(.query-box-input)',
+            ];
+            let textInput = null;
+            for (const selector of textInputSelectors) {
+                try {
+                    const el = await this.page.waitForSelector(selector, {
+                        state: 'visible',
+                        timeout: 3000,
+                    });
+                    if (el) {
+                        log.info(`  ✅ Found text input with: ${selector}`);
+                        textInput = el;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!textInput) {
+                // Debug: list all textareas on page
+                const allTextareas = await this.page.locator('textarea').all();
+                log.warning(`  ⚠️ Found ${allTextareas.length} textareas on page`);
+                for (let i = 0; i < Math.min(allTextareas.length, 3); i++) {
+                    const cls = await allTextareas[i].getAttribute('class');
+                    const placeholder = await allTextareas[i].getAttribute('placeholder');
+                    log.info(`    textarea[${i}]: class="${cls}", placeholder="${placeholder}"`);
+                }
+                throw new Error('Text input not found in dialog');
+            }
+            await textInput.fill(input.text);
+            log.info(`  ✅ Text entered (${input.text.length} chars)`);
+            // Set title if provided
+            log.info(`  🔍 Looking for title input...`);
+            if (input.title) {
+                const titleSelectors = [
+                    'input[placeholder*="title"]',
+                    'input[placeholder*="Title"]',
+                    'input[placeholder*="name"]',
+                    'input[placeholder*="Name"]',
+                    'input[name="title"]',
+                    '[role="dialog"] input[type="text"]:not([readonly])',
+                ];
+                let titleSet = false;
+                for (const selector of titleSelectors) {
+                    try {
+                        const titleInput = this.page.locator(selector).first();
+                        if (await titleInput.isVisible({ timeout: 500 })) {
+                            await titleInput.fill(input.title);
+                            log.info(`  ✅ Title set: ${input.title} (via ${selector})`);
+                            titleSet = true;
+                            break;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!titleSet) {
+                    log.warning(`  ⚠️ Title input NOT found - source will have default name`);
+                    // Debug: list all inputs in dialog
+                    try {
+                        const allInputs = await this.page.locator('[role="dialog"] input').all();
+                        log.info(`  🔍 DEBUG: Found ${allInputs.length} inputs in dialog`);
+                        for (let i = 0; i < Math.min(allInputs.length, 5); i++) {
+                            const inp = allInputs[i];
+                            const type = await inp.getAttribute('type');
+                            const placeholder = await inp.getAttribute('placeholder');
+                            log.info(`    input[${i}]: type="${type}", placeholder="${placeholder}"`);
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+            await randomDelay(300, 500);
+            // DEBUG: Take screenshot before clicking upload button
+            try {
+                const screenshotPath = path.join(CONFIG.dataDir, 'debug-before-insert.png');
+                await this.page.screenshot({ path: screenshotPath });
+                log.info(`  📸 Debug screenshot saved: ${screenshotPath}`);
+            }
+            catch (e) {
+                log.warning(`  ⚠️ Could not take debug screenshot: ${e}`);
+            }
+            // DEBUG: Check if the "Insert" button is enabled (bilingual via i18n)
+            try {
+                const insertBtnSelectors = i18nSelectors('button:has-text("{text}")', 'buttons', 'insert');
+                for (const sel of insertBtnSelectors) {
+                    const btn = this.page.locator(sel).first();
+                    if (await btn.isVisible({ timeout: 500 })) {
+                        const isDisabled = await btn.isDisabled();
+                        const ariaDisabled = await btn.getAttribute('aria-disabled');
+                        const classList = await btn.getAttribute('class');
+                        log.info(`  🔍 Button "${sel}" - disabled: ${isDisabled}, aria-disabled: ${ariaDisabled}`);
+                        log.info(`  🔍 Button classes: ${classList}`);
+                        break;
+                    }
+                }
+            }
+            catch (e) {
+                log.warning(`  ⚠️ Could not check button state: ${e}`);
+            }
+            // Get first few words of text for later verification (NotebookLM uses text content as title)
+            const textPreview = input.text.slice(0, 30).trim();
+            log.info(`  📝 Text preview for verification: "${textPreview}..."`);
+            // Click add button
+            log.info(`  🔍 Looking for upload button...`);
+            await this.clickUploadButton();
+            // Wait for processing - NotebookLM names pasted text sources "Texte collé" in French or "Pasted text"
+            // We'll look for either the expected name or "Texte collé"
+            // Pass initialUuid to detect notebook redirection
+            const result = await this.waitForSourceProcessing(input.title || 'Texte collé', textPreview, expectedNotebookUuid);
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Text upload failed: ${errorMsg}` };
+        }
+    }
+    /**
+     * Upload from Google Drive
+     */
+    async uploadGoogleDrive(input, expectedNotebookUuid) {
+        if (!input.url) {
+            return { success: false, error: 'Google Drive URL is required' };
+        }
+        log.info(`  📂 Adding Google Drive source: ${input.url}`);
+        // Similar to URL upload but with Google Drive specific handling
+        return await this.uploadUrl({ ...input, type: 'url' }, expectedNotebookUuid);
+    }
+    /**
+     * Upload YouTube video
+     */
+    async uploadYouTube(input, expectedNotebookUuid) {
+        if (!input.url) {
+            return { success: false, error: 'YouTube URL is required' };
+        }
+        log.info(`  🎬 Adding YouTube video: ${input.url}`);
+        try {
+            // Wait for dialog to be fully ready
+            await randomDelay(500, 800);
+            // Click on YouTube option with expanded selectors
+            const ytSelectors = [
+                'button:has-text("YouTube")',
+                '[data-type="youtube"]',
+                'button[aria-label*="YouTube"]',
+                '[role="button"]:has-text("YouTube")',
+                // Material design buttons
+                '.mat-button:has-text("YouTube")',
+                '.mdc-button:has-text("YouTube")',
+                // List items that might be clickable
+                '[role="listitem"]:has-text("YouTube")',
+                '[role="option"]:has-text("YouTube")',
+                // Generic clickable elements with YouTube text
+                '[class*="option"]:has-text("YouTube")',
+                '[class*="source-type"]:has-text("YouTube")',
+            ];
+            let youtubeClicked = false;
+            for (const selector of ytSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 1500 })) {
+                        log.info(`  ✅ Found YouTube option: ${selector}`);
+                        await btn.click();
+                        await randomDelay(500, 800);
+                        youtubeClicked = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!youtubeClicked) {
+                log.warning('  ⚠️ Could not click YouTube option, trying to proceed anyway...');
+            }
+            // Enter YouTube URL (can be input or textarea)
+            await randomDelay(500, 1000);
+            const ytInputSelectors = [
+                // French placeholders
+                'input[placeholder*="Collez"]',
+                'textarea[placeholder*="Collez"]',
+                'input[placeholder*="YouTube"]',
+                'textarea[placeholder*="YouTube"]',
+                // English placeholders
+                'input[placeholder*="youtube" i]',
+                'textarea[placeholder*="youtube" i]',
+                'input[placeholder*="URL"]',
+                'textarea[placeholder*="URL"]',
+                'input[placeholder*="Paste"]',
+                'textarea[placeholder*="Paste"]',
+                '[role="dialog"] input[type="text"]',
+                '[role="dialog"] textarea',
+            ];
+            let urlInput = null;
+            log.info(`  🔍 Looking for YouTube URL input...`);
+            for (const selector of ytInputSelectors) {
+                try {
+                    const input = this.page.locator(selector).first();
+                    if (await input.isVisible({ timeout: 500 })) {
+                        urlInput = input;
+                        log.info(`  ✅ Found YouTube input: ${selector}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Fallback: any visible input/textarea in dialog
+            if (!urlInput) {
+                log.info(`  🔍 Trying fallback for YouTube input...`);
+                try {
+                    const allInputs = await this.page
+                        .locator('[role="dialog"] input, [role="dialog"] textarea')
+                        .all();
+                    for (const input of allInputs) {
+                        if (await input.isVisible()) {
+                            urlInput = input;
+                            const placeholder = await input.getAttribute('placeholder');
+                            log.info(`  ✅ Found via fallback: placeholder="${placeholder}"`);
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+            if (!urlInput) {
+                throw new Error('YouTube URL input not found');
+            }
+            await urlInput.fill(input.url);
+            log.info(`  ✅ YouTube URL entered`);
+            await randomDelay(500, 1000);
+            await this.clickUploadButton();
+            const result = await this.waitForSourceProcessing(input.title || 'YouTube video', undefined, expectedNotebookUuid);
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `YouTube upload failed: ${errorMsg}` };
+        }
+    }
+    /**
+     * Click the upload/add button
+     */
+    async clickUploadButton() {
+        const uploadBtnSelectors = [
+            // Primary action buttons (most likely) - bilingual via i18n
+            ...i18nSelectors('button.mdc-button--raised:has-text("{text}")', 'buttons', 'insert'),
+            ...i18nSelectors('button.mat-flat-button:has-text("{text}")', 'buttons', 'insert'),
+            ...i18nSelectors('button[color="primary"]:has-text("{text}")', 'buttons', 'insert'),
+            // Generic text patterns (bilingual via i18n)
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'insert'),
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'add'),
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'upload'),
+            'button:has-text("Import")',
+            'button:has-text("Save")',
+            'button:has-text("Submit")',
+            // Form submit
+            'button[type="submit"]',
+            // Dialog actions
+            '[role="dialog"] button:not(:has-text("Cancel")):not(:has-text("Close"))',
+            '.mat-dialog-actions button:not(:has-text("Cancel"))',
+            '.mdc-dialog__actions button:not(:has-text("Cancel"))',
+        ];
+        for (const selector of uploadBtnSelectors) {
+            try {
+                const btn = this.page.locator(selector).first();
+                if (await btn.isVisible({ timeout: 500 })) {
+                    log.info(`  ✅ Found upload button: ${selector}`);
+                    await btn.click();
+                    log.info(`  ✅ Clicked upload button`);
+                    return;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Debug: list all buttons in dialog
+        log.warning(`  ⚠️ No upload button found, listing dialog buttons...`);
+        try {
+            const dialogButtons = await this.page.locator('[role="dialog"] button').all();
+            for (let i = 0; i < Math.min(dialogButtons.length, 5); i++) {
+                const text = await dialogButtons[i].textContent();
+                log.info(`  🔍 Dialog button[${i}]: "${text?.trim()}"`);
+            }
+        }
+        catch {
+            // ignore
+        }
+        // Try pressing Enter as fallback
+        log.info(`  ⌨️ Pressing Enter as fallback`);
+        await this.page.keyboard.press('Enter');
+    }
+    /**
+     * Wait for source to finish processing
+     * @param sourceName The name we expect the source to have
+     * @param _textPreview Optional first words of text (for text sources - NotebookLM may use this as name)
+     * @param expectedNotebookUuid Optional UUID of the notebook we expect to be on (to detect redirects)
+     */
+    async waitForSourceProcessing(sourceName, _textPreview, expectedNotebookUuid) {
+        log.info(`  ⏳ Waiting for source processing: ${sourceName}`);
+        const timeout = 90000; // 1.5 minutes (sources can take time)
+        const startTime = Date.now();
+        // First, wait a bit for the dialog to close (indicates upload started)
+        await randomDelay(2000, 3000);
+        while (Date.now() - startTime < timeout) {
+            // Check for errors in the dialog or page
+            const errorSelectors = [
+                '.error-message',
+                '[role="alert"]:has-text("error")',
+                '[role="alert"]:has-text("Error")',
+                '.mdc-snackbar--error',
+                '[class*="error"]',
+            ];
+            for (const errorSelector of errorSelectors) {
+                try {
+                    const errorEl = this.page.locator(errorSelector).first();
+                    if (await errorEl.isVisible({ timeout: 500 })) {
+                        const errorText = await errorEl.textContent();
+                        return { success: false, error: errorText || 'Upload failed', status: 'failed' };
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Check if dialog is still open (might mean still processing)
+            const dialogSelectors = ['[role="dialog"]', '.mat-dialog-container', '.mdc-dialog'];
+            let dialogVisible = false;
+            for (const dialogSelector of dialogSelectors) {
+                try {
+                    const dialog = this.page.locator(dialogSelector).first();
+                    if (await dialog.isVisible({ timeout: 500 })) {
+                        dialogVisible = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // If dialog closed, check if source appears in the sources list
+            if (!dialogVisible) {
+                log.info(`  ℹ️ Dialog closed, checking for source in list...`);
+                // CRITICAL: Verify we're still on the correct notebook after dialog closes
+                // NotebookLM sometimes redirects to a NEW notebook when adding text sources!
+                const currentUrl = this.page.url();
+                log.info(`  🔍 Current URL: ${currentUrl}`);
+                // Check if URL changed (different notebook UUID)
+                const currentUuid = currentUrl.match(/notebook\/([a-f0-9-]+)/)?.[1];
+                log.info(`  🆔 Current UUID: ${currentUuid || 'NOT FOUND'}`);
+                log.info(`  🆔 Expected UUID: ${expectedNotebookUuid || 'NOT PROVIDED'}`);
+                if (currentUuid && expectedNotebookUuid && currentUuid !== expectedNotebookUuid) {
+                    log.error(`  ❌ NOTEBOOK MISMATCH! NotebookLM redirected to a different notebook!`);
+                    log.error(`  ❌ Expected: ${expectedNotebookUuid}`);
+                    log.error(`  ❌ Got: ${currentUuid}`);
+                    // Navigate back to the correct notebook and try to add source properly
+                    log.warning(`  ⚠️ This is a known NotebookLM behavior - text sources may create new notebooks`);
+                    // Return failure with clear error message
+                    return {
+                        success: false,
+                        error: `NotebookLM redirected to a different notebook (${currentUuid}) instead of the target (${expectedNotebookUuid}). This happens when NotebookLM creates a new notebook for pasted text. The source was added to an 'Untitled notebook' instead.`,
+                        status: 'failed',
+                    };
+                }
+                // Try to get notebook title for logging
+                try {
+                    const titleSelectors = ['h1', '[class*="notebook-title"]', '[class*="title"]'];
+                    for (const sel of titleSelectors) {
+                        try {
+                            const titleEl = this.page.locator(sel).first();
+                            if (await titleEl.isVisible({ timeout: 500 })) {
+                                const title = await titleEl.textContent();
+                                if (title && title.length < 100) {
+                                    log.info(`  📓 Notebook title: "${title.trim()}"`);
+                                    break;
+                                }
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    /* ignore */
+                }
+                // Take screenshot after dialog closed
+                try {
+                    const screenshotPath = path.join(CONFIG.dataDir, 'debug-after-insert.png');
+                    await this.page.screenshot({ path: screenshotPath });
+                    log.info(`  📸 Debug screenshot (after click): ${screenshotPath}`);
+                }
+                catch {
+                    /* ignore */
+                }
+                await randomDelay(1000, 2000);
+                // METHOD 1: Look for pasted text source in the SOURCES PANEL specifically (not anywhere on page)
+                // Use more specific selectors to avoid matching dialog content
+                // Support both French ("Texte collé") and English ("Pasted text") UI via i18n
+                const pastedTextSelectors = [
+                    // Sources panel specific selectors (bilingual via i18n)
+                    ...i18nSelectors('mat-checkbox:has-text("{text}")', 'sourceNames', 'pastedText'),
+                    ...i18nSelectors('[class*="source"]:has-text("{text}")', 'sourceNames', 'pastedText'),
+                    ...i18nSelectors(':has-text("{text}"):not([role="dialog"])', 'sourceNames', 'pastedText'),
+                ];
+                // Get localized pasted text names for detection
+                const pastedTextNames = tAll('sourceNames', 'pastedText');
+                for (const selector of pastedTextSelectors) {
+                    try {
+                        const el = this.page.locator(selector).first();
+                        if (await el.isVisible({ timeout: 1000 })) {
+                            log.success(`  ✅ Found pasted text source: ${selector}`);
+                            // Detect source name from selector - find which locale's text is in the selector
+                            const detectedName = pastedTextNames.find((name) => selector.includes(name)) || pastedTextNames[0];
+                            return { success: true, sourceName: detectedName, status: 'ready' };
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                // METHOD 2: Check for source in the sources panel by name
+                const sourceListSelectors = [
+                    // Source items that might contain our source
+                    `[class*="source"]:has-text("${sourceName}")`,
+                    `[class*="Source"]:has-text("${sourceName}")`,
+                    // Generic list items
+                    '.source-list-item',
+                    '[class*="source-item"]',
+                    '[class*="SourceItem"]',
+                    // Material list
+                    'mat-list-item',
+                    '.mat-list-item',
+                    // By count change (sources list exists)
+                    '[class*="sources"]',
+                ];
+                // Try to find the specific source by name
+                for (const selector of sourceListSelectors.slice(0, 2)) {
+                    // Only name-based selectors
+                    try {
+                        const el = this.page.locator(selector).first();
+                        if (await el.isVisible({ timeout: 500 })) {
+                            log.success(`  ✅ Source added successfully: ${sourceName}`);
+                            return { success: true, sourceName, status: 'ready' };
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                // Wait a bit more and try again - sources can take time to appear
+                log.info(`  ⏳ Source not found yet, waiting 5 more seconds...`);
+                await randomDelay(4000, 6000);
+                // Try again for pasted text source with different variations
+                for (const selector of pastedTextSelectors) {
+                    try {
+                        const el = this.page.locator(selector).first();
+                        if (await el.isVisible({ timeout: 1000 })) {
+                            log.success(`  ✅ Found pasted text source after wait: ${selector}`);
+                            // Detect source name from selector - find which locale's text is in the selector
+                            const detectedName = pastedTextNames.find((name) => selector.includes(name)) || pastedTextNames[0];
+                            return { success: true, sourceName: detectedName, status: 'ready' };
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                // Try one more time to find the source by name
+                try {
+                    const sourceByName = this.page
+                        .locator(`[class*="source"]:has-text("${sourceName}")`)
+                        .first();
+                    if (await sourceByName.isVisible({ timeout: 2000 })) {
+                        log.success(`  ✅ Source found after wait: ${sourceName}`);
+                        return { success: true, sourceName, status: 'ready' };
+                    }
+                }
+                catch {
+                    /* ignore */
+                }
+                // If still not found, this is a failure - don't assume success
+                log.warning(`  ⚠️ Dialog closed but source not found in list - upload likely failed`);
+                return {
+                    success: false,
+                    sourceName,
+                    error: 'Source not found after upload - dialog closed but source not visible in list',
+                    status: 'failed',
+                };
+            }
+            // Still in dialog - check for processing indicators
+            const processingSelectors = [
+                '.loading',
+                '.spinner',
+                '[class*="loading"]',
+                '[class*="processing"]',
+                'mat-progress-bar',
+                'mat-spinner',
+                '.mdc-linear-progress',
+            ];
+            let isProcessing = false;
+            for (const procSelector of processingSelectors) {
+                try {
+                    const proc = this.page.locator(procSelector).first();
+                    if (await proc.isVisible({ timeout: 500 })) {
+                        isProcessing = true;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (isProcessing) {
+                log.info(`  ⏳ Still processing...`);
+            }
+            await this.page.waitForTimeout(2000);
+        }
+        return { success: false, error: 'Timeout waiting for source processing', status: 'failed' };
+    }
+    // ============================================================================
+    // Chat-Based Content Generation (New UI - Dec 2024)
+    // ============================================================================
+    /**
+     * Send a message in the chat interface (without waiting for response)
+     * This is the new way to generate content in NotebookLM
+     * Uses the same typing and submission approach as ask_question for reliability
+     */
+    async sendChatMessage(message) {
+        log.info(`  💬 Sending chat message: "${message.substring(0, 50)}..."`);
+        // Find the chat input (same approach as BrowserSession.findChatInput)
+        const chatInputSelectors = [
+            'textarea.query-box-input', // PRIMARY - same as Python implementation
+            'textarea[aria-label*="query"]',
+            'textarea[aria-label*="Zone de requête"]',
+        ];
+        let inputSelector = null;
+        for (const selector of chatInputSelectors) {
+            try {
+                const input = await this.page.waitForSelector(selector, {
+                    state: 'visible',
+                    timeout: 3000,
+                });
+                if (input) {
+                    inputSelector = selector;
+                    log.info(`  ✅ Found chat input: ${selector}`);
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!inputSelector) {
+            throw new Error('Chat input not found');
+        }
+        // Clear any existing text first
+        const inputEl = await this.page.$(inputSelector);
+        if (inputEl) {
+            await inputEl.click();
+            await this.page.keyboard.press('Control+A');
+            await this.page.keyboard.press('Backspace');
+            await randomDelay(200, 400);
+        }
+        // Type the message with human-like behavior (same as BrowserSession.askQuestion)
+        log.info(`  ⌨️ Typing message with human-like behavior...`);
+        await humanType(this.page, inputSelector, message, {
+            withTypos: false, // No typos for prompts to avoid confusion
+            wpm: 150, // Faster typing for long prompts
+        });
+        // Small pause before submitting
+        await randomDelay(500, 1000);
+        // Submit with Enter key (same as BrowserSession.askQuestion)
+        log.info(`  📤 Submitting message...`);
+        await this.page.keyboard.press('Enter');
+        // Small pause after submit
+        await randomDelay(1000, 1500);
+        log.info(`  ✅ Message sent`);
+    }
+    /**
+     * Wait for generated content to appear in chat
+     * Uses the same proven approach as /ask endpoint (waitForLatestAnswer with full timeout)
+     */
+    async waitForGeneratedContent(contentType, timeoutMs = 600000) {
+        log.info(`  ⏳ Waiting for ${contentType} response (up to ${timeoutMs / 60000} minutes)...`);
+        // Scroll to bottom to ensure we see all messages
+        await this.scrollChatToBottom();
+        // Snapshot existing chat responses to ignore them
+        const existingChatResponses = await snapshotAllResponses(this.page);
+        log.info(`  📊 Ignoring ${existingChatResponses.length} existing chat responses`);
+        // Use the same proven logic as /ask endpoint - wait for new chat response
+        const response = await waitForLatestAnswer(this.page, {
+            question: '', // Empty question since we already sent the message
+            timeoutMs: timeoutMs,
+            pollIntervalMs: 2000, // Poll every 2 seconds
+            ignoreTexts: existingChatResponses,
+            debug: true, // Enable debug to see what's happening
+        });
+        // Check if response is an error message from NotebookLM
+        if (response && isErrorMessage(response)) {
+            log.error(`  ❌ NotebookLM returned an error: "${response}"`);
+            throw new Error(`NotebookLM error: ${response}`);
+        }
+        if (response && response.length > 50) {
+            log.success(`  ✅ Content received (${response.length} chars)`);
+            return { source: 'chat', content: response };
+        }
+        throw new Error(`Timeout waiting for ${contentType} generation after ${timeoutMs / 1000}s`);
+    }
+    /**
+     * Scroll chat container to bottom to ensure latest messages are visible
+     */
+    async scrollChatToBottom() {
+        try {
+            // Try multiple selectors for the chat container
+            const chatContainerSelectors = [
+                '.chat-scroll-container',
+                '.messages-container',
+                '[class*="scroll"]',
+                '.query-container',
+            ];
+            for (const selector of chatContainerSelectors) {
+                const container = await this.page.$(selector);
+                if (container) {
+                    await container.evaluate((el) => {
+                        el.scrollTop = el.scrollHeight;
+                    });
+                    log.debug(`  📜 Scrolled chat to bottom using ${selector}`);
+                    return;
+                }
+            }
+            // Fallback: scroll the whole page
+            await this.page.evaluate(`window.scrollTo(0, document.body.scrollHeight)`);
+            log.debug(`  📜 Scrolled page to bottom (fallback)`);
+        }
+        catch (error) {
+            log.debug(`  ⚠️ Could not scroll: ${error}`);
+        }
+    }
+    // ============================================================================
+    // Content Generation
+    // ============================================================================
+    /**
+     * Generate content (audio overview, presentation, report)
+     *
+     * Supported content types:
+     * - audio_overview: Uses real Studio UI buttons for audio podcast generation
+     * - video: Uses generic ContentGenerator for video generation (with format, language, style options)
+     * - infographic: Uses generic ContentGenerator for infographic generation (with format options)
+     * - presentation: Uses generic ContentGenerator for slides generation (with format options)
+     * - report: Uses generic ContentGenerator for briefing document generation (with format options)
+     * - data_table: Uses generic ContentGenerator for data table generation (with format options)
+     *
+     * NOTE: Other content types (study_guide, faq, timeline, table_of_contents)
+     * were removed because they only sent chat prompts instead of clicking actual
+     * NotebookLM Studio buttons.
+     */
+    async generateContent(input) {
+        log.info(`🎨 Generating content: ${input.type}`);
+        try {
+            if (input.type === 'audio_overview') {
+                return await this.generateAudioOverview(input);
+            }
+            // Use generic ContentGenerator for all other supported types
+            if (input.type === 'video' ||
+                input.type === 'infographic' ||
+                input.type === 'presentation' ||
+                input.type === 'report' ||
+                input.type === 'data_table') {
+                return await this.generateGenericContent(input);
+            }
+            // Unsupported content type
+            return {
+                success: false,
+                contentType: input.type,
+                error: `Unsupported content type: ${input.type}. Supported types: 'audio_overview', 'video', 'infographic', 'presentation', 'report', 'data_table'.`,
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`❌ Content generation failed: ${errorMsg}`);
+            return { success: false, contentType: input.type, error: errorMsg };
+        }
+    }
+    /**
+     * Generate content using the generic ContentGenerator
+     *
+     * This method handles all content types except audio_overview:
+     * - video: With format (brief/explainer), language, and visual style options
+     * - infographic: With format (horizontal/vertical) and language options
+     * - presentation: With format (overview/detailed) and language options
+     * - report: With format (summary/detailed) and language options
+     * - data_table: With format (simple/detailed) and language options
+     *
+     * @param input Content generation input with all options
+     * @returns Content generation result
+     */
+    async generateGenericContent(input) {
+        log.info(`🎨 Generating ${input.type} via ContentGenerator...`);
+        try {
+            const generator = new ContentGenerator(this.page);
+            const result = await generator.generate(input);
+            if (result.success) {
+                log.success(`  ✅ ${input.type} generated successfully`);
+            }
+            else {
+                log.error(`  ❌ ${input.type} generation failed: ${result.error}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ ${input.type} generation failed: ${errorMsg}`);
+            return {
+                success: false,
+                contentType: input.type,
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Generate Audio Overview (podcast)
+     *
+     * NOTE (Dec 2024): NotebookLM UI has changed significantly.
+     * Audio generation now works via chat requests or may require specific UI interaction.
+     * This method attempts both approaches.
+     */
+    async generateAudioOverview(input) {
+        log.info(`🎙️ Generating Audio Overview...`);
+        try {
+            // First, check Studio for existing audio or audio generation button
+            await this.navigateToStudio();
+            await this.page.waitForTimeout(1000);
+            // Check if audio already exists
+            const existingAudio = await this.page.$('audio, .audio-player, [class*="audio-overview"]');
+            if (existingAudio) {
+                log.info(`  ℹ️ Audio Overview already exists`);
+                return {
+                    success: true,
+                    contentType: 'audio_overview',
+                    status: 'ready',
+                };
+            }
+            // Try to find audio generation button in Studio
+            const audioSelectors = [
+                'button:has-text("Audio")',
+                'button:has-text("Generate audio")',
+                'button:has-text("Générer")',
+                'button[aria-label*="audio" i]',
+                '[class*="audio"] button',
+                'button:has(mat-icon:has-text("mic"))',
+                'button:has(mat-icon:has-text("podcast"))',
+            ];
+            for (const selector of audioSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 1000 })) {
+                        log.info(`  ✅ Found audio button: ${selector}`);
+                        // Add custom instructions if provided
+                        if (input.customInstructions) {
+                            await this.addCustomInstructions(input.customInstructions);
+                        }
+                        await btn.click();
+                        log.info(`  ✅ Started audio generation`);
+                        // Wait for generation
+                        return await this.waitForAudioGeneration();
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Fallback: Try chat-based approach
+            log.info(`  ℹ️ No audio button found, trying chat-based approach...`);
+            await this.navigateToDiscussion();
+            let prompt = 'Create an audio overview (Deep Dive podcast) for this notebook. Generate a conversational podcast script that covers the main topics from all sources.';
+            if (input.customInstructions) {
+                prompt += `\n\nCustom instructions: ${input.customInstructions}`;
+            }
+            await this.sendChatMessage(prompt);
+            const result = await this.waitForGeneratedContent('audio_overview', 600000);
+            if (result.content && result.content.length > 100) {
+                log.success(`  ✅ Audio overview script generated via ${result.source}`);
+                return {
+                    success: true,
+                    contentType: 'audio_overview',
+                    status: 'ready',
+                    textContent: result.content,
+                };
+            }
+            throw new Error('Could not generate audio overview - button not found and chat approach failed');
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, contentType: 'audio_overview', error: errorMsg };
+        }
+    }
+    // NOTE: generateBriefingDoc, generateStudyGuide, generateTimeline, generateFAQ,
+    // generateTOC, and generateDocumentContent methods were removed because they
+    // only sent chat prompts instead of clicking actual NotebookLM Studio buttons.
+    // Only audio_overview uses real UI interaction.
+    /**
+     * Generate Presentation/Slides using the generic ContentGenerator
+     *
+     * This uses the generic content generation architecture that:
+     * 1. Navigates to Studio panel
+     * 2. Looks for presentation/slides button
+     * 3. Falls back to chat-based generation if button not found
+     *
+     * @param input Content generation input with optional custom instructions
+     * @returns Content generation result
+     */
+    async generatePresentation(input) {
+        log.info(`📊 Generating Presentation/Slides...`);
+        try {
+            // Use the generic ContentGenerator for presentation generation
+            const generator = new ContentGenerator(this.page);
+            const result = await generator.generate({
+                type: 'presentation',
+                customInstructions: input.customInstructions,
+                sources: input.sources,
+                language: input.language,
+                presentationStyle: input.presentationStyle,
+                presentationLength: input.presentationLength,
+            });
+            if (result.success) {
+                log.success(`  ✅ Presentation generated successfully`);
+            }
+            else {
+                log.error(`  ❌ Presentation generation failed: ${result.error}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Presentation generation failed: ${errorMsg}`);
+            return {
+                success: false,
+                contentType: 'presentation',
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Generate Report/Briefing Document using the generic ContentGenerator
+     *
+     * Creates a comprehensive briefing document (2,000-3,000 words) that summarizes
+     * key findings, insights, and recommendations from notebook sources.
+     * Can be exported as PDF or DOCX format.
+     *
+     * This uses the generic content generation architecture that:
+     * 1. Navigates to Studio panel
+     * 2. Looks for briefing/report button
+     * 3. Falls back to chat-based generation if button not found
+     *
+     * @param input Content generation input with optional custom instructions
+     * @returns Content generation result with text content
+     */
+    async generateReport(input) {
+        log.info(`📄 Generating Report/Briefing Document...`);
+        try {
+            // Use the generic ContentGenerator for report generation
+            const generator = new ContentGenerator(this.page);
+            const result = await generator.generate({
+                type: 'report',
+                customInstructions: input.customInstructions,
+                sources: input.sources,
+                language: input.language,
+                reportFormat: input.reportFormat,
+            });
+            if (result.success) {
+                log.success(`  ✅ Report generated successfully`);
+            }
+            else {
+                log.error(`  ❌ Report generation failed: ${result.error}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Report generation failed: ${errorMsg}`);
+            return {
+                success: false,
+                contentType: 'report',
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Generate Infographic using the generic ContentGenerator
+     *
+     * Creates a visual infographic from the notebook sources.
+     * Supports two formats:
+     * - horizontal (16:9): Landscape format for presentations/displays
+     * - vertical (9:16): Portrait format for social media/mobile
+     *
+     * This uses the generic content generation architecture that:
+     * 1. Navigates to Studio panel
+     * 2. Looks for infographic button
+     * 3. Falls back to chat-based generation if button not found
+     *
+     * @param input Content generation input with optional custom instructions and format
+     * @returns Content generation result
+     */
+    async generateInfographic(input) {
+        log.info(`Generating Infographic...`);
+        try {
+            // Use the generic ContentGenerator for infographic generation
+            const generator = new ContentGenerator(this.page);
+            const result = await generator.generate({
+                type: 'infographic',
+                customInstructions: input.customInstructions,
+                sources: input.sources,
+                language: input.language,
+                infographicFormat: input.infographicFormat,
+            });
+            if (result.success) {
+                log.success(`  Infographic generated successfully`);
+            }
+            else {
+                log.error(`  Infographic generation failed: ${result.error}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  Infographic generation failed: ${errorMsg}`);
+            return {
+                success: false,
+                contentType: 'infographic',
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Generate a Data Table using the generic ContentGenerator
+     *
+     * Creates a structured table that organizes key information from notebook sources.
+     * The generated table can be exported as CSV or Excel format.
+     *
+     * @param input Content generation input with optional custom instructions
+     * @returns Content generation result with table data
+     */
+    async generateDataTable(input) {
+        log.info(`Generating Data Table...`);
+        try {
+            // Use the generic ContentGenerator for data table generation
+            const generator = new ContentGenerator(this.page);
+            const result = await generator.generate({
+                type: 'data_table',
+                customInstructions: input.customInstructions,
+                sources: input.sources,
+                language: input.language,
+                // Note: data_table has no format options - exports to Google Sheets
+            });
+            if (result.success) {
+                log.success(`  ✅ Data Table generated successfully`);
+            }
+            else {
+                log.error(`  ❌ Data Table generation failed: ${result.error}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Data Table generation failed: ${errorMsg}`);
+            return {
+                success: false,
+                contentType: 'data_table',
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Generate a Video using the generic ContentGenerator
+     *
+     * Creates a video summary that visually explains the main topics from notebook sources.
+     * Video generation may take several minutes depending on content complexity.
+     *
+     * Supported formats:
+     * - brief: Short video summary (2-3 minutes)
+     * - explainer: Detailed explanation video (5-10 minutes)
+     *
+     * This uses the generic content generation architecture that:
+     * 1. Navigates to Studio panel
+     * 2. Looks for video generation button
+     * 3. Falls back to chat-based generation if button not found
+     *
+     * @param input Content generation input with optional custom instructions and format
+     * @returns Content generation result with video data
+     */
+    async generateVideo(input) {
+        log.info(`🎬 Generating Video...`);
+        try {
+            // Use the generic ContentGenerator for video generation
+            const generator = new ContentGenerator(this.page);
+            const result = await generator.generate({
+                type: 'video',
+                customInstructions: input.customInstructions,
+                sources: input.sources,
+                language: input.language,
+                videoFormat: input.videoFormat,
+            });
+            if (result.success) {
+                log.success(`  ✅ Video generated successfully`);
+            }
+            else {
+                log.error(`  ❌ Video generation failed: ${result.error}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Video generation failed: ${errorMsg}`);
+            return {
+                success: false,
+                contentType: 'video',
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Navigate to Discussion panel (chat)
+     */
+    async navigateToDiscussion() {
+        const discussionSelectors = [
+            'div.mdc-tab:has-text("Discussion")',
+            '.mat-mdc-tab:has-text("Discussion")',
+            '[role="tab"]:has-text("Discussion")',
+            'div.mdc-tab >> text=Discussion',
+        ];
+        for (const selector of discussionSelectors) {
+            try {
+                const el = this.page.locator(selector).first();
+                if (await el.isVisible({ timeout: 2000 })) {
+                    // Check if already selected
+                    const isActive = (await el.getAttribute('aria-selected')) === 'true' ||
+                        (await el.getAttribute('class'))?.includes('mdc-tab--active');
+                    if (!isActive) {
+                        await el.click();
+                        await randomDelay(500, 800);
+                        log.info(`  ✅ Clicked Discussion tab`);
+                    }
+                    else {
+                        log.info(`  ✅ Discussion tab already active`);
+                    }
+                    return;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Quick check if there's any chat content visible (might already be on Discussion)
+        try {
+            const chatContent = this.page
+                .locator('[class*="chat"], [class*="discussion"], [class*="message"]')
+                .first();
+            if (await chatContent.isVisible({ timeout: 1000 })) {
+                log.info(`  ℹ️ Discussion content appears accessible`);
+                return;
+            }
+        }
+        catch {
+            // Continue to error
+        }
+        // Fail-fast: throw error if Discussion tab not found
+        throw new Error('Discussion tab not found - notebook may not have a chat history');
+    }
+    /**
+     * Navigate to Studio panel
+     */
+    async navigateToStudio() {
+        // Updated selectors based on current NotebookLM UI (Dec 2024)
+        // The tabs are: Sources | Discussion | Studio
+        // Tab class: mdc-tab mat-mdc-tab mat-focus-indicator
+        const studioSelectors = [
+            // Material Design tabs (bilingual FR/EN via i18n)
+            ...i18nSelectors('div.mdc-tab:has-text("{text}")', 'tabs', 'studio'),
+            ...i18nSelectors('.mat-mdc-tab:has-text("{text}")', 'tabs', 'studio'),
+            ...i18nSelectors('[role="tab"]:has-text("{text}")', 'tabs', 'studio'),
+            ...i18nSelectors('div.mdc-tab >> text={text}', 'tabs', 'studio'),
+            '.notebook-guide', // Legacy fallback
+        ];
+        for (const selector of studioSelectors) {
+            try {
+                const el = this.page.locator(selector).first();
+                if (await el.isVisible({ timeout: 2000 })) {
+                    // Check if already selected
+                    const isActive = (await el.getAttribute('aria-selected')) === 'true' ||
+                        (await el.getAttribute('class'))?.includes('mdc-tab--active');
+                    if (!isActive) {
+                        await el.click();
+                        await randomDelay(800, 1200);
+                        log.info(`  ✅ Clicked Studio tab`);
+                    }
+                    else {
+                        log.info(`  ✅ Studio tab already active`);
+                    }
+                    return;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Try clicking by finding the tab list and clicking the third tab
+        try {
+            const tabList = this.page.locator('.mat-mdc-tab-list .mdc-tab').nth(2); // Studio is 3rd tab (0-indexed)
+            if (await tabList.isVisible({ timeout: 1000 })) {
+                await tabList.click();
+                await randomDelay(800, 1200);
+                log.info(`  ✅ Studio tab accessed via tab list`);
+                return;
+            }
+        }
+        catch {
+            // Continue to fallback
+        }
+        log.warning(`  ⚠️ Could not find Studio tab, content generation may fail`);
+    }
+    /**
+     * Add custom instructions for content generation
+     */
+    async addCustomInstructions(instructions) {
+        const instructionSelectors = [
+            'textarea[placeholder*="instruction"]',
+            'textarea[placeholder*="focus"]',
+            'textarea[placeholder*="custom"]',
+            '.custom-instructions textarea',
+        ];
+        for (const selector of instructionSelectors) {
+            try {
+                const textarea = await this.page.$(selector);
+                if (textarea && (await textarea.isVisible())) {
+                    await textarea.fill(instructions);
+                    log.info(`  ✅ Custom instructions added`);
+                    return;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    /**
+     * Wait for audio generation to complete
+     */
+    async waitForAudioGeneration() {
+        log.info(`  ⏳ Waiting for audio generation (this may take several minutes)...`);
+        const timeout = 600000; // 10 minutes
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            // Check for errors
+            const errorEl = await this.page.$('.error-message, [role="alert"]:has-text("error")');
+            if (errorEl) {
+                const errorText = await errorEl.textContent();
+                return {
+                    success: false,
+                    contentType: 'audio_overview',
+                    error: errorText || 'Audio generation failed',
+                    status: 'failed',
+                };
+            }
+            // Check for audio player (generation complete)
+            const audioPlayer = await this.page.$('audio, .audio-player, [data-component="audio-player"]');
+            if (audioPlayer) {
+                log.success(`  ✅ Audio Overview generated!`);
+                return { success: true, contentType: 'audio_overview', status: 'ready' };
+            }
+            // Check progress
+            const progressEl = await this.page.$('[role="progressbar"], .progress-bar');
+            if (progressEl) {
+                const progress = await progressEl.getAttribute('aria-valuenow');
+                if (progress) {
+                    log.info(`  ⏳ Generation progress: ${progress}%`);
+                }
+            }
+            await this.page.waitForTimeout(5000);
+        }
+        return {
+            success: false,
+            contentType: 'audio_overview',
+            error: 'Timeout waiting for audio generation',
+            status: 'failed',
+        };
+    }
+    // ============================================================================
+    // Content Listing & Download
+    // ============================================================================
+    /**
+     * Get overview of notebook content (sources and generated content)
+     */
+    async getContentOverview() {
+        log.info(`📋 Getting notebook content overview...`);
+        const sources = await this.listSources();
+        const generatedContent = await this.listGeneratedContent();
+        const hasAudioOverview = generatedContent.some((c) => c.type === 'audio_overview');
+        return {
+            sources,
+            generatedContent,
+            sourceCount: sources.length,
+            hasAudioOverview,
+        };
+    }
+    /**
+     * List all sources in the notebook
+     */
+    async listSources() {
+        const sources = [];
+        try {
+            // First ensure Sources panel is active
+            await this.ensureSourcesPanel();
+            await randomDelay(500, 800);
+            // Try to find source names by looking at the actual text content visible on page
+            // NotebookLM shows source names in spans/divs - look for text that looks like file names
+            const seenNames = new Set();
+            // Method 1: Look for elements with PDF-like text using Playwright locators
+            try {
+                // Find all elements containing .pdf text
+                const pdfElements = await this.page.locator('text=/\\.pdf/i').all();
+                if (pdfElements.length > 0) {
+                    log.info(`  📚 Found ${pdfElements.length} PDF elements`);
+                    for (const el of pdfElements) {
+                        try {
+                            const text = await el.textContent();
+                            if (text && text.length > 10 && !seenNames.has(text.trim())) {
+                                seenNames.add(text.trim());
+                                sources.push({
+                                    id: `source-${sources.length}`,
+                                    name: text.trim(),
+                                    type: 'document',
+                                    status: 'ready',
+                                });
+                            }
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+                // Also look for elements with [Author] format (brackets)
+                if (sources.length === 0) {
+                    const bracketElements = await this.page.locator('text=/\\[.+\\]/').all();
+                    if (bracketElements.length > 0) {
+                        log.info(`  📚 Found ${bracketElements.length} bracketed elements`);
+                        for (const el of bracketElements) {
+                            try {
+                                const text = await el.textContent();
+                                if (text && text.length > 10 && !seenNames.has(text.trim())) {
+                                    // Skip UI elements
+                                    if (/^(Sources|Discussion|Studio|Sélectionner)/i.test(text.trim()))
+                                        continue;
+                                    seenNames.add(text.trim());
+                                    sources.push({
+                                        id: `source-${sources.length}`,
+                                        name: text.trim(),
+                                        type: 'document',
+                                        status: 'ready',
+                                    });
+                                }
+                            }
+                            catch {
+                                continue;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                log.warning(`  ⚠️ Text scan failed: ${error}`);
+            }
+            // Method 2: If no sources found, try looking at specific source list selectors
+            if (sources.length === 0) {
+                log.info(`  🔍 Trying alternative source selectors...`);
+                // Look for any element that contains source text
+                const sourceTextSelectors = [
+                    '.source-item-name',
+                    '.source-name',
+                    '[class*="source-item"] span:not(mat-icon)',
+                    '[class*="source"] span.mdc-list-item__primary-text',
+                    'mat-list-item span',
+                ];
+                for (const selector of sourceTextSelectors) {
+                    try {
+                        const elements = await this.page.$$(selector);
+                        if (elements.length > 0) {
+                            log.info(`  📄 Found ${elements.length} elements with ${selector}`);
+                            for (const el of elements) {
+                                const text = (await el.textContent())?.trim();
+                                if (text && text.length > 5 && !seenNames.has(text)) {
+                                    // Skip icon text
+                                    if (text.match(/^(drive_pdf|markdown|more_vert|check)/i))
+                                        continue;
+                                    seenNames.add(text);
+                                    sources.push({
+                                        id: `source-${sources.length}`,
+                                        name: text,
+                                        type: 'document',
+                                        status: 'ready',
+                                    });
+                                }
+                            }
+                            if (sources.length > 0)
+                                break;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            log.warning(`  ⚠️ Could not list sources: ${error}`);
+        }
+        return sources;
+    }
+    /**
+     * Delete a source from the current notebook
+     *
+     * @param input - Either sourceId or sourceName to identify the source to delete
+     * @returns Result indicating success or failure
+     */
+    async deleteSource(input) {
+        const { sourceId, sourceName } = input;
+        if (!sourceId && !sourceName) {
+            return { success: false, error: 'Either sourceId or sourceName is required' };
+        }
+        log.info(`🗑️ Deleting source: ${sourceId || sourceName}`);
+        try {
+            // First, ensure we're on the Sources panel
+            await this.ensureSourcesPanel();
+            await randomDelay(500, 800);
+            // Find the source element
+            const sourceElement = await this.findSourceElement(sourceId, sourceName);
+            if (!sourceElement) {
+                return {
+                    success: false,
+                    error: `Source not found: ${sourceId || sourceName}`,
+                };
+            }
+            // Get the source name for logging before deletion
+            let deletedSourceName = sourceName;
+            if (!deletedSourceName) {
+                try {
+                    deletedSourceName = await sourceElement.$eval('.source-name, .title, [class*="name"], [class*="title"]', (e) => e.textContent?.trim() || 'Unknown');
+                }
+                catch {
+                    deletedSourceName = sourceId || 'Unknown';
+                }
+            }
+            // Click on the source to select it
+            await sourceElement.click();
+            await randomDelay(300, 500);
+            // Open the source menu (3-dot menu or right-click)
+            const menuOpened = await this.openSourceMenu(sourceElement);
+            if (!menuOpened) {
+                // Try right-click as fallback
+                log.info(`  🔍 Trying right-click on source...`);
+                await sourceElement.click({ button: 'right' });
+                await randomDelay(300, 500);
+            }
+            // Click delete option
+            const deleteClicked = await this.clickDeleteOption();
+            if (!deleteClicked) {
+                return {
+                    success: false,
+                    error: 'Could not find delete option in menu',
+                };
+            }
+            // Confirm deletion if prompted
+            await this.confirmDeletion();
+            // Wait for source to be removed
+            await randomDelay(1000, 2000);
+            // Verify deletion by checking if source is still present
+            const stillExists = await this.findSourceElement(sourceId, sourceName);
+            if (stillExists) {
+                return {
+                    success: false,
+                    error: 'Source deletion may have failed - source still appears in list',
+                };
+            }
+            log.success(`  ✅ Source deleted: ${deletedSourceName}`);
+            return {
+                success: true,
+                sourceId: sourceId,
+                sourceName: deletedSourceName,
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`❌ Failed to delete source: ${errorMsg}`);
+            return { success: false, error: errorMsg };
+        }
+    }
+    /**
+     * Find a source element by ID or name
+     */
+    async findSourceElement(sourceId, sourceName
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        log.info(`  🔍 Finding source: id="${sourceId}", name="${sourceName}"`);
+        // METHOD 1: Direct text search (most reliable for NotebookLM)
+        if (sourceName) {
+            const directSelectors = [
+                // Try to find element containing the source name text
+                `:has-text("${sourceName}")`,
+                `text="${sourceName}"`,
+                `text=/.*${sourceName}.*/i`,
+            ];
+            for (const selector of directSelectors) {
+                try {
+                    const el = this.page.locator(selector).first();
+                    if (await el.isVisible({ timeout: 1000 })) {
+                        log.info(`  ✅ Found source via direct text: ${selector}`);
+                        return await el.elementHandle();
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        // METHOD 2: Look within sources panel structure
+        const sourceItemSelectors = [
+            // NotebookLM current UI structure (checkboxes with labels)
+            'mat-checkbox',
+            '[class*="checkbox"]',
+            // Standard list items
+            '.source-item',
+            '[data-item="source"]',
+            '.sources-list-item',
+            '[class*="source-list"] > div',
+            '[class*="source-list"] > li',
+            'mat-list-item',
+            '.mat-list-item',
+            '[role="listitem"]',
+        ];
+        for (const selector of sourceItemSelectors) {
+            try {
+                const elements = await this.page.$$(selector);
+                log.info(`  🔍 Checking ${elements.length} elements with selector: ${selector}`);
+                for (const el of elements) {
+                    // Check by data-id attribute
+                    if (sourceId) {
+                        const dataId = await el.getAttribute('data-id');
+                        if (dataId === sourceId) {
+                            log.info(`  ✅ Found source by data-id`);
+                            return el;
+                        }
+                    }
+                    // Check by name/title text content
+                    if (sourceName) {
+                        const textContent = await el.textContent();
+                        if (textContent && textContent.toLowerCase().includes(sourceName.toLowerCase())) {
+                            log.info(`  ✅ Found source by text content: "${textContent.slice(0, 50)}..."`);
+                            return el;
+                        }
+                        // Also check specific name/title elements
+                        try {
+                            const nameText = await el.$eval('.source-name, .title, [class*="name"], [class*="title"], label, span', (e) => e.textContent?.trim() || '');
+                            if (nameText.toLowerCase().includes(sourceName.toLowerCase())) {
+                                log.info(`  ✅ Found source by inner text: "${nameText}"`);
+                                return el;
+                            }
+                        }
+                        catch {
+                            // Element doesn't have a name/title child
+                        }
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Take debug screenshot
+        try {
+            const screenshotPath = path.join(CONFIG.dataDir, 'debug-find-source-failed.png');
+            await this.page.screenshot({ path: screenshotPath });
+            log.info(`  📸 Debug screenshot saved: ${screenshotPath}`);
+        }
+        catch {
+            /* ignore */
+        }
+        log.warning(`  ⚠️ Source not found: ${sourceId || sourceName}`);
+        return null;
+    }
+    /**
+     * Open the source menu (3-dot menu)
+     */
+    async openSourceMenu(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sourceElement) {
+        const menuButtonSelectors = [
+            // Material Design 3-dot menu button
+            'button:has(mat-icon:has-text("more_vert"))',
+            'button:has(mat-icon:has-text("more_horiz"))',
+            'button[aria-label*="menu" i]',
+            'button[aria-label*="options" i]',
+            'button[aria-label*="actions" i]',
+            'button[aria-label*="More" i]',
+            'button[aria-label*="Plus" i]',
+            '.mat-mdc-icon-button:has(mat-icon)',
+            '[class*="menu-button"]',
+            '[class*="more-button"]',
+            '[data-action="menu"]',
+            // Generic icon buttons that might be the menu
+            'button.mat-icon-button',
+            'button.mdc-icon-button',
+        ];
+        // First, try to find the menu button within the source element
+        for (const selector of menuButtonSelectors) {
+            try {
+                const menuBtn = await sourceElement.$(selector);
+                if (menuBtn) {
+                    const isVisible = await menuBtn.isVisible();
+                    if (isVisible) {
+                        log.info(`  ✅ Found menu button: ${selector}`);
+                        await menuBtn.click();
+                        await randomDelay(300, 500);
+                        return true;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Hover over the source to reveal hidden menu button
+        log.info(`  🔍 Hovering to reveal menu button...`);
+        await sourceElement.hover();
+        await randomDelay(500, 800);
+        // Try again after hover
+        for (const selector of menuButtonSelectors) {
+            try {
+                const menuBtn = await sourceElement.$(selector);
+                if (menuBtn) {
+                    const isVisible = await menuBtn.isVisible();
+                    if (isVisible) {
+                        log.info(`  ✅ Found menu button after hover: ${selector}`);
+                        await menuBtn.click();
+                        await randomDelay(300, 500);
+                        return true;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    /**
+     * Click the delete option in the menu
+     */
+    async clickDeleteOption() {
+        const deleteSelectors = [
+            // Menu item selectors (bilingual FR/EN via i18n)
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'delete'),
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'remove'),
+            ...i18nSelectors('[role="menuitem"]:has-text("{text}")', 'buttons', 'delete'),
+            ...i18nSelectors('[role="menuitem"]:has-text("{text}")', 'buttons', 'remove'),
+            ...i18nSelectors('mat-menu-item:has-text("{text}")', 'buttons', 'delete'),
+            ...i18nSelectors('.mat-menu-item:has-text("{text}")', 'buttons', 'delete'),
+            // With icons
+            'button:has(mat-icon:has-text("delete"))',
+            '[role="menuitem"]:has(mat-icon:has-text("delete"))',
+            'mat-menu-item:has(mat-icon:has-text("delete"))',
+            // Aria labels
+            'button[aria-label*="Delete" i]',
+            'button[aria-label*="Remove" i]',
+            'button[aria-label*="Supprimer" i]',
+            // Generic patterns
+            '[data-action="delete"]',
+            '[class*="delete"]',
+        ];
+        // Wait for menu to appear
+        await randomDelay(300, 500);
+        for (const selector of deleteSelectors) {
+            try {
+                const deleteBtn = this.page.locator(selector).first();
+                if (await deleteBtn.isVisible({ timeout: 500 })) {
+                    log.info(`  ✅ Found delete option: ${selector}`);
+                    await deleteBtn.click();
+                    await randomDelay(300, 500);
+                    return true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Debug: list menu items
+        log.warning(`  ⚠️ Delete option not found, listing menu items...`);
+        try {
+            const menuItems = await this.page.$$('[role="menuitem"], .mat-menu-item, mat-menu-item');
+            for (let i = 0; i < Math.min(menuItems.length, 5); i++) {
+                const text = await menuItems[i].textContent();
+                log.info(`  🔍 Menu item[${i}]: "${text?.trim()}"`);
+            }
+        }
+        catch {
+            // ignore
+        }
+        return false;
+    }
+    /**
+     * Confirm deletion if a confirmation dialog appears
+     */
+    async confirmDeletion() {
+        const confirmSelectors = [
+            // Confirmation buttons (bilingual via i18n)
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'confirm'),
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'yes'),
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'delete'),
+            'button:has-text("OK")',
+            // Dialog confirm buttons
+            '[role="dialog"] button.mat-primary',
+            '[role="dialog"] button[color="primary"]',
+            '[role="dialog"] button.mdc-button--raised',
+            '.mat-dialog-actions button:not(:has-text("Cancel")):not(:has-text("Annuler"))',
+            '.mdc-dialog__actions button:not(:has-text("Cancel")):not(:has-text("Annuler"))',
+            // Aria patterns
+            'button[aria-label*="Confirm" i]',
+            'button[aria-label*="Delete" i]',
+        ];
+        // Wait a moment for dialog to appear
+        await randomDelay(500, 800);
+        // Check if a confirmation dialog is visible
+        const dialogSelectors = ['[role="dialog"]', '.mat-dialog-container', '.mdc-dialog'];
+        let dialogVisible = false;
+        for (const dialogSelector of dialogSelectors) {
+            try {
+                const dialog = this.page.locator(dialogSelector).first();
+                if (await dialog.isVisible({ timeout: 500 })) {
+                    dialogVisible = true;
+                    log.info(`  📋 Confirmation dialog detected`);
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!dialogVisible) {
+            log.info(`  ℹ️ No confirmation dialog detected`);
+            return;
+        }
+        // Click confirm button
+        for (const selector of confirmSelectors) {
+            try {
+                const confirmBtn = this.page.locator(selector).first();
+                if (await confirmBtn.isVisible({ timeout: 500 })) {
+                    log.info(`  ✅ Clicking confirm: ${selector}`);
+                    await confirmBtn.click();
+                    await randomDelay(300, 500);
+                    return;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        log.warning(`  ⚠️ No confirm button found, pressing Enter as fallback`);
+        await this.page.keyboard.press('Enter');
+    }
+    /**
+     * List all generated content
+     */
+    async listGeneratedContent() {
+        const content = [];
+        try {
+            // Check for audio overview
+            const audioPlayer = await this.page.$('audio, .audio-player');
+            if (audioPlayer) {
+                content.push({
+                    id: 'audio-overview',
+                    type: 'audio_overview',
+                    name: 'Audio Overview',
+                    status: 'ready',
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            // Note: We only list audio_overview content now since other content types
+            // (briefing_doc, study_guide, etc.) were removed as they were fake implementations.
+            // Any notes in the Studio panel would have been created by the user directly in NotebookLM.
+        }
+        catch (error) {
+            log.warning(`  ⚠️ Could not list generated content: ${error}`);
+        }
+        return content;
+    }
+    /**
+     * Download generated content (audio, video, infographic)
+     *
+     * For media content types that produce downloadable files:
+     * - audio_overview: WAV audio file
+     * - video: MP4 video file
+     * - infographic: PNG image file
+     *
+     * Note: Text-based content (report, presentation, data_table) is returned
+     * directly in the generation response, not as downloadable files.
+     *
+     * @param contentType Type of content to download
+     * @param outputPath Optional path to save the file
+     * @returns Download result with file path
+     */
+    async downloadContent(contentType, outputPath) {
+        log.info(`📥 Downloading ${contentType}...`);
+        // Handle Google export types (presentation -> Google Slides, data_table -> Google Sheets)
+        if (contentType === 'presentation') {
+            return await this.exportPresentationToGoogleSlides();
+        }
+        if (contentType === 'data_table') {
+            return await this.exportDataTableToGoogleSheets();
+        }
+        // Report is truly text-based with no export option
+        if (contentType === 'report') {
+            return {
+                success: false,
+                error: `Content type 'report' is text-based and returned in the generation response. No file download available.`,
+            };
+        }
+        try {
+            // Navigate to the appropriate content panel
+            const panelConfig = this.getContentPanelConfig(contentType);
+            await this.navigateToContentPanel(panelConfig);
+            // Find and click download button
+            const downloadBtn = await this.findDownloadButton();
+            if (!downloadBtn) {
+                // For audio, try to get source URL directly
+                if (contentType === 'audio_overview') {
+                    const audioSrc = await this.getAudioSourceUrl();
+                    if (audioSrc) {
+                        return { success: true, filePath: audioSrc, mimeType: 'audio/wav' };
+                    }
+                }
+                throw new Error('Download button not found');
+            }
+            // Set up download handling and click
+            const downloadPromise = this.page.waitForEvent('download', { timeout: 60000 });
+            await downloadBtn.click();
+            const download = await downloadPromise;
+            // Save the file
+            const suggestedName = download.suggestedFilename();
+            const savePath = outputPath || path.join(CONFIG.dataDir, suggestedName);
+            await download.saveAs(savePath);
+            // Determine MIME type
+            const mimeTypes = {
+                audio_overview: 'audio/wav',
+                video: 'video/mp4',
+                infographic: 'image/png',
+            };
+            log.success(`  ✅ ${contentType} downloaded: ${savePath}`);
+            return {
+                success: true,
+                filePath: savePath,
+                mimeType: mimeTypes[contentType] || 'application/octet-stream',
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Download failed: ${errorMsg}` };
+        }
+    }
+    /**
+     * Get panel configuration for a content type
+     */
+    getContentPanelConfig(contentType) {
+        const configs = {
+            audio_overview: {
+                tabSelectors: [
+                    '[role="tab"]:has-text("Audio Overview")',
+                    '[role="tab"]:has-text("Audio")',
+                    'button:has-text("Audio Overview")',
+                    '[aria-label*="Audio"]',
+                ],
+                cardSelectors: [
+                    '.audio-overview-card',
+                    '[data-type="audio"]',
+                    'button:has-text("Deep Dive")',
+                ],
+            },
+            video: {
+                tabSelectors: [
+                    '[role="tab"]:has-text("Video")',
+                    'button:has-text("Video")',
+                    '[aria-label*="Video"]',
+                ],
+                cardSelectors: ['.video-card', '[data-type="video"]', 'video'],
+            },
+            infographic: {
+                tabSelectors: [
+                    '[role="tab"]:has-text("Infographic")',
+                    'button:has-text("Infographic")',
+                    '[aria-label*="Infographic"]',
+                ],
+                cardSelectors: [
+                    '.infographic-card',
+                    '[data-type="infographic"]',
+                    'img[class*="infographic"]',
+                ],
+            },
+            presentation: {
+                tabSelectors: [
+                    '[role="tab"]:has-text("Presentation")',
+                    '[role="tab"]:has-text("Slides")',
+                    '[role="tab"]:has-text("Diaporama")',
+                    'button:has-text("Presentation")',
+                    'button:has-text("Slides")',
+                    '[aria-label*="Presentation"]',
+                    '[aria-label*="Slides"]',
+                ],
+                cardSelectors: [
+                    '.presentation-card',
+                    '.slides-card',
+                    '[data-type="presentation"]',
+                    '[data-type="slides"]',
+                ],
+            },
+            data_table: {
+                tabSelectors: [
+                    '[role="tab"]:has-text("Data Table")',
+                    '[role="tab"]:has-text("Table")',
+                    '[role="tab"]:has-text("Tableau")',
+                    'button:has-text("Data Table")',
+                    'button:has-text("Table")',
+                    '[aria-label*="Table"]',
+                    '[aria-label*="Data"]',
+                ],
+                cardSelectors: [
+                    '.data-table-card',
+                    '.table-card',
+                    '[data-type="data_table"]',
+                    '[data-type="table"]',
+                ],
+            },
+        };
+        return configs[contentType] || { tabSelectors: [], cardSelectors: [] };
+    }
+    /**
+     * Navigate to content panel
+     */
+    async navigateToContentPanel(config) {
+        // Try to click tab
+        for (const selector of config.tabSelectors) {
+            try {
+                const tab = this.page.locator(selector).first();
+                if (await tab.isVisible({ timeout: 500 })) {
+                    await tab.click();
+                    await randomDelay(500, 1000);
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Try to click card
+        for (const selector of config.cardSelectors) {
+            try {
+                const card = this.page.locator(selector).first();
+                if (await card.isVisible({ timeout: 500 })) {
+                    await card.click();
+                    await randomDelay(500, 1000);
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    /**
+     * Find download button on the page
+     */
+    async findDownloadButton() {
+        const downloadSelectors = [
+            'button:has(mat-icon:has-text("download"))',
+            'button:has(mat-icon:has-text("file_download"))',
+            'button:has(mat-icon:has-text("get_app"))',
+            'button[aria-label*="Download"]',
+            'button[aria-label*="Télécharger"]',
+            'button[aria-label*="download"]',
+            // Text-based patterns (bilingual via i18n)
+            ...i18nSelectors('button:has-text("{text}")', 'buttons', 'download'),
+            'a[download]',
+            '.download-button',
+            '[data-action="download"]',
+        ];
+        for (const selector of downloadSelectors) {
+            try {
+                const btn = this.page.locator(selector).first();
+                if (await btn.isVisible({ timeout: 500 })) {
+                    log.info(`  ✅ Found download button: ${selector}`);
+                    return btn;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get audio source URL directly from audio element
+     */
+    async getAudioSourceUrl() {
+        try {
+            const audioEl = await this.page.$('audio');
+            if (audioEl) {
+                const src = await audioEl.getAttribute('src');
+                if (src) {
+                    log.info(`  ✅ Audio source URL found: ${src}`);
+                    return src;
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        return null;
+    }
+    /**
+     * Download audio content
+     * @deprecated Use downloadContent('audio_overview', outputPath) instead
+     */
+    async downloadAudio(outputPath) {
+        log.info(`📥 Downloading audio...`);
+        try {
+            // First, navigate to the Audio Overview panel/tab
+            log.info(`  📑 Looking for Audio Overview panel...`);
+            const audioTabSelectors = [
+                '[role="tab"]:has-text("Audio Overview")',
+                '[role="tab"]:has-text("Audio")',
+                'button:has-text("Audio Overview")',
+                'button:has-text("Audio")',
+                '[aria-label*="Audio"]',
+            ];
+            for (const selector of audioTabSelectors) {
+                try {
+                    const tab = this.page.locator(selector).first();
+                    if (await tab.isVisible({ timeout: 500 })) {
+                        log.info(`  ✅ Found Audio tab: ${selector}`);
+                        await tab.click();
+                        await randomDelay(500, 1000);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Look for Audio Overview card/section and click it if needed
+            const audioCardSelectors = [
+                '.audio-overview-card',
+                '[data-type="audio"]',
+                'button:has-text("Deep Dive")',
+                'button:has-text("Conversation")',
+            ];
+            for (const selector of audioCardSelectors) {
+                try {
+                    const card = this.page.locator(selector).first();
+                    if (await card.isVisible({ timeout: 500 })) {
+                        log.info(`  ✅ Found Audio card: ${selector}`);
+                        await card.click();
+                        await randomDelay(500, 1000);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // First try to open a menu (NotebookLM often has download in a three-dot menu)
+            const menuTriggerSelectors = [
+                'button:has(mat-icon:has-text("more_vert"))',
+                'button:has(mat-icon:has-text("more_horiz"))',
+                'button[aria-label*="More"]',
+                'button[aria-label*="Options"]',
+                'button[aria-label*="Menu"]',
+                'button[aria-label*="plus"]',
+                '.mat-mdc-menu-trigger',
+                '[aria-haspopup="menu"]',
+            ];
+            for (const menuSelector of menuTriggerSelectors) {
+                try {
+                    const menuBtn = this.page.locator(menuSelector).first();
+                    if (await menuBtn.isVisible({ timeout: 300 })) {
+                        log.info(`  🔍 Opening menu: ${menuSelector}`);
+                        await menuBtn.click();
+                        await randomDelay(300, 500);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Find download button (either direct or in menu) - bilingual via i18n
+            const downloadSelectors = [
+                // Menu item patterns (if menu was opened)
+                ...i18nSelectors('[role="menuitem"]:has-text("{text}")', 'buttons', 'download'),
+                ...i18nSelectors('mat-menu-item:has-text("{text}")', 'buttons', 'download'),
+                '.mat-mdc-menu-item:has-text("Download")',
+                // Material Design icon buttons
+                'button:has(mat-icon:has-text("download"))',
+                'button:has(mat-icon:has-text("file_download"))',
+                'button:has(mat-icon:has-text("get_app"))',
+                // Aria labels
+                'button[aria-label*="Download"]',
+                'button[aria-label*="Télécharger"]',
+                'button[aria-label*="download"]',
+                // Text patterns (bilingual via i18n)
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'download'),
+                // Icon buttons near audio
+                '.audio-controls button:has(mat-icon)',
+                '.audio-player button:has(mat-icon)',
+                // Generic download patterns
+                'a[download]',
+                '.download-button',
+                '[data-action="download"]',
+            ];
+            let downloadBtn = null;
+            for (const selector of downloadSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 500 })) {
+                        downloadBtn = btn;
+                        log.info(`  ✅ Found download button: ${selector}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!downloadBtn) {
+                // Try to get audio source directly from audio element
+                log.info(`  🔍 No download button, looking for audio element...`);
+                const audioEl = await this.page.$('audio');
+                if (audioEl) {
+                    const src = await audioEl.getAttribute('src');
+                    if (src) {
+                        log.info(`  ✅ Audio source URL found: ${src}`);
+                        return {
+                            success: true,
+                            filePath: src,
+                            mimeType: 'audio/wav',
+                        };
+                    }
+                }
+                // Debug: list all buttons in the panel
+                log.warning(`  ⚠️ Download button not found, listing panel buttons...`);
+                try {
+                    const buttons = await this.page.locator('button').all();
+                    for (let i = 0; i < Math.min(buttons.length, 10); i++) {
+                        const text = await buttons[i].textContent();
+                        const aria = await buttons[i].getAttribute('aria-label');
+                        log.info(`  🔍 Button[${i}]: text="${text?.trim()}", aria="${aria}"`);
+                    }
+                }
+                catch {
+                    /* ignore */
+                }
+                throw new Error('Download button not found');
+            }
+            // Set up download handling
+            const downloadPromise = this.page.waitForEvent('download', { timeout: 30000 });
+            await downloadBtn.click();
+            const download = await downloadPromise;
+            const suggestedName = download.suggestedFilename();
+            const savePath = outputPath || path.join(CONFIG.dataDir, suggestedName);
+            await download.saveAs(savePath);
+            log.success(`  ✅ Audio downloaded: ${savePath}`);
+            return {
+                success: true,
+                filePath: savePath,
+                mimeType: 'audio/wav',
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Download failed: ${errorMsg}` };
+        }
+    }
+    /**
+     * Export presentation to Google Slides
+     * Finds and clicks the "Open in Slides" button to get the Google Slides URL
+     */
+    async exportPresentationToGoogleSlides() {
+        log.info(`  📤 Exporting presentation to Google Slides...`);
+        try {
+            // Navigate to presentation panel
+            const panelConfig = this.getContentPanelConfig('presentation');
+            await this.navigateToContentPanel(panelConfig);
+            // Look for "Open in Slides" or similar export button
+            const exportSelectors = [
+                'button:has-text("Open in Slides")',
+                'button:has-text("Ouvrir dans Slides")',
+                'button:has-text("Export to Slides")',
+                'button:has-text("Google Slides")',
+                'a[href*="docs.google.com/presentation"]',
+                'button[aria-label*="Slides"]',
+                'button[aria-label*="slides"]',
+                'button:has(mat-icon:has-text("slideshow"))',
+                // Also look for download as PDF option
+                'button:has-text("Download PDF")',
+                'button:has-text("Télécharger PDF")',
+            ];
+            for (const selector of exportSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 1000 })) {
+                        log.info(`  ✅ Found export button: ${selector}`);
+                        // Check if it's a direct link
+                        const href = await btn.getAttribute('href');
+                        if (href && href.includes('docs.google.com/presentation')) {
+                            log.success(`  ✅ Google Slides URL found: ${href}`);
+                            return {
+                                success: true,
+                                googleSlidesUrl: href,
+                                mimeType: 'application/vnd.google-apps.presentation',
+                            };
+                        }
+                        // Click the button and wait for navigation or new tab
+                        const [newPage] = await Promise.all([
+                            this.page
+                                .context()
+                                .waitForEvent('page', { timeout: 10000 })
+                                .catch(() => null),
+                            btn.click(),
+                        ]);
+                        if (newPage) {
+                            const newUrl = newPage.url();
+                            await newPage.close();
+                            if (newUrl.includes('docs.google.com/presentation')) {
+                                log.success(`  ✅ Google Slides URL: ${newUrl}`);
+                                return {
+                                    success: true,
+                                    googleSlidesUrl: newUrl,
+                                    mimeType: 'application/vnd.google-apps.presentation',
+                                };
+                            }
+                        }
+                        // Check current page URL
+                        await randomDelay(2000, 3000);
+                        const currentUrl = this.page.url();
+                        if (currentUrl.includes('docs.google.com/presentation')) {
+                            log.success(`  ✅ Navigated to Google Slides: ${currentUrl}`);
+                            return {
+                                success: true,
+                                googleSlidesUrl: currentUrl,
+                                mimeType: 'application/vnd.google-apps.presentation',
+                            };
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            return {
+                success: false,
+                error: 'Could not find Google Slides export button. The presentation may not be ready or the export feature is not available.',
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Export to Google Slides failed: ${errorMsg}` };
+        }
+    }
+    /**
+     * Export data table to Google Sheets
+     * Finds and clicks the "Open in Sheets" button to get the Google Sheets URL
+     */
+    async exportDataTableToGoogleSheets() {
+        log.info(`  📤 Exporting data table to Google Sheets...`);
+        try {
+            // Navigate to data table panel
+            const panelConfig = this.getContentPanelConfig('data_table');
+            await this.navigateToContentPanel(panelConfig);
+            // Look for "Open in Sheets" or similar export button
+            const exportSelectors = [
+                'button:has-text("Open in Sheets")',
+                'button:has-text("Ouvrir dans Sheets")',
+                'button:has-text("Export to Sheets")',
+                'button:has-text("Google Sheets")',
+                'a[href*="docs.google.com/spreadsheets"]',
+                'button[aria-label*="Sheets"]',
+                'button[aria-label*="sheets"]',
+                'button:has(mat-icon:has-text("table_chart"))',
+                'button:has(mat-icon:has-text("grid_on"))',
+            ];
+            for (const selector of exportSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 1000 })) {
+                        log.info(`  ✅ Found export button: ${selector}`);
+                        // Check if it's a direct link
+                        const href = await btn.getAttribute('href');
+                        if (href && href.includes('docs.google.com/spreadsheets')) {
+                            log.success(`  ✅ Google Sheets URL found: ${href}`);
+                            return {
+                                success: true,
+                                googleSheetsUrl: href,
+                                mimeType: 'application/vnd.google-apps.spreadsheet',
+                            };
+                        }
+                        // Click the button and wait for navigation or new tab
+                        const [newPage] = await Promise.all([
+                            this.page
+                                .context()
+                                .waitForEvent('page', { timeout: 10000 })
+                                .catch(() => null),
+                            btn.click(),
+                        ]);
+                        if (newPage) {
+                            const newUrl = newPage.url();
+                            await newPage.close();
+                            if (newUrl.includes('docs.google.com/spreadsheets')) {
+                                log.success(`  ✅ Google Sheets URL: ${newUrl}`);
+                                return {
+                                    success: true,
+                                    googleSheetsUrl: newUrl,
+                                    mimeType: 'application/vnd.google-apps.spreadsheet',
+                                };
+                            }
+                        }
+                        // Check current page URL
+                        await randomDelay(2000, 3000);
+                        const currentUrl = this.page.url();
+                        if (currentUrl.includes('docs.google.com/spreadsheets')) {
+                            log.success(`  ✅ Navigated to Google Sheets: ${currentUrl}`);
+                            return {
+                                success: true,
+                                googleSheetsUrl: currentUrl,
+                                mimeType: 'application/vnd.google-apps.spreadsheet',
+                            };
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            return {
+                success: false,
+                error: 'Could not find Google Sheets export button. The data table may not be ready or the export feature is not available.',
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return { success: false, error: `Export to Google Sheets failed: ${errorMsg}` };
+        }
+    }
+    // ============================================================================
+    // Notes Management
+    // ============================================================================
+    /**
+     * Create a note in the NotebookLM Studio panel
+     *
+     * Notes are user-created annotations that appear in the notebook's Studio panel.
+     * They allow you to save research findings, summaries, or key insights.
+     *
+     * @param input Note input with title and content
+     * @returns NoteResult with success status
+     */
+    async createNote(input) {
+        log.info(`📝 Creating note: "${input.title}"`);
+        try {
+            // Step 1: Navigate to Studio panel where notes are managed
+            await this.navigateToStudio();
+            await randomDelay(500, 1000);
+            // Step 2: Look for "Add note" or "+" button in the Studio panel (bilingual via i18n)
+            const addNoteSelectors = [
+                // Primary selectors for Add Note button (bilingual via i18n)
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'addNote'),
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'newNote'),
+                // Icon button patterns
+                'button[aria-label*="Add note"]',
+                'button[aria-label*="add note" i]',
+                'button[aria-label*="Ajouter"]',
+                'button[aria-label*="New note"]',
+                // Material Design patterns
+                'button:has(mat-icon:has-text("add"))',
+                'button:has(mat-icon:has-text("note_add"))',
+                'button:has(mat-icon:has-text("post_add"))',
+                '.mat-mdc-icon-button[aria-label*="note" i]',
+                '.mat-mdc-icon-button[aria-label*="add" i]',
+                // Studio panel specific
+                '[class*="studio"] button:has(mat-icon:has-text("add"))',
+                '[class*="notes"] button:has(mat-icon:has-text("add"))',
+                // Generic add patterns in notes section
+                '.notes-section button',
+                '.note-list button.add',
+                '[data-testid*="add-note"]',
+                '[data-action="add-note"]',
+            ];
+            let addButtonFound = false;
+            for (const selector of addNoteSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 1000 })) {
+                        log.info(`  ✅ Found Add note button: ${selector}`);
+                        await realisticClick(this.page, selector, true);
+                        addButtonFound = true;
+                        await randomDelay(500, 1000);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!addButtonFound) {
+                // Debug: log available buttons
+                log.warning(`  ⚠️ Add note button not found, checking available elements...`);
+                await this.debugStudioElements();
+                return {
+                    success: false,
+                    error: 'Could not find Add note button in Studio panel',
+                    status: 'failed',
+                };
+            }
+            // Step 3: Wait for note editor dialog/panel to appear
+            await randomDelay(500, 1000);
+            // Step 4: Find and fill the title input
+            const titleSelectors = [
+                // Common title input patterns
+                'input[placeholder*="Title"]',
+                'input[placeholder*="title"]',
+                'input[placeholder*="Titre"]',
+                'input[placeholder*="titre"]',
+                'input[placeholder*="Note title"]',
+                'input[name="title"]',
+                'input[aria-label*="title" i]',
+                // Material Design inputs
+                '.mat-form-field input',
+                'mat-form-field input',
+                // Dialog/modal specific
+                '[role="dialog"] input[type="text"]:first-of-type',
+                '.note-editor input:first-of-type',
+                '.note-form input:first-of-type',
+                // Generic text input in note context
+                '[class*="note"] input[type="text"]',
+            ];
+            let titleInput = null;
+            for (const selector of titleSelectors) {
+                try {
+                    const input = this.page.locator(selector).first();
+                    if (await input.isVisible({ timeout: 1000 })) {
+                        titleInput = input;
+                        log.info(`  ✅ Found title input: ${selector}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (titleInput) {
+                await titleInput.fill(input.title);
+                log.info(`  ✅ Title entered: "${input.title}"`);
+                await randomDelay(300, 500);
+            }
+            else {
+                log.warning(`  ⚠️ Title input not found, proceeding without title`);
+            }
+            // Step 5: Find and fill the content textarea
+            const contentSelectors = [
+                // Textarea patterns
+                'textarea[placeholder*="content"]',
+                'textarea[placeholder*="Content"]',
+                'textarea[placeholder*="note"]',
+                'textarea[placeholder*="Note"]',
+                'textarea[placeholder*="Contenu"]',
+                'textarea[placeholder*="Write"]',
+                'textarea[placeholder*="write"]',
+                'textarea[name="content"]',
+                'textarea[aria-label*="content" i]',
+                'textarea[aria-label*="note" i]',
+                // Material Design
+                '.mat-form-field textarea',
+                'mat-form-field textarea',
+                // Dialog/modal specific
+                '[role="dialog"] textarea',
+                '.note-editor textarea',
+                '.note-form textarea',
+                // Rich text editor patterns
+                '[contenteditable="true"]',
+                '.ProseMirror',
+                '.ql-editor',
+                // Generic textarea in note context
+                '[class*="note"] textarea',
+            ];
+            let contentInput = null;
+            for (const selector of contentSelectors) {
+                try {
+                    const input = this.page.locator(selector).first();
+                    if (await input.isVisible({ timeout: 1000 })) {
+                        contentInput = input;
+                        log.info(`  ✅ Found content input: ${selector}`);
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (contentInput) {
+                // Check if it's a contenteditable element
+                const isContentEditable = await contentInput.getAttribute('contenteditable');
+                if (isContentEditable === 'true') {
+                    await contentInput.click();
+                    await this.page.keyboard.type(input.content);
+                }
+                else {
+                    await contentInput.fill(input.content);
+                }
+                log.info(`  ✅ Content entered (${input.content.length} chars)`);
+                await randomDelay(300, 500);
+            }
+            else {
+                log.warning(`  ⚠️ Content input not found`);
+                return {
+                    success: false,
+                    error: 'Could not find content input field',
+                    status: 'failed',
+                };
+            }
+            // Step 6: Save the note by clicking Save/Done button (bilingual via i18n)
+            const saveSelectors = [
+                // Primary save buttons (bilingual via i18n)
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'save'),
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'done'),
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'create'),
+                ...i18nSelectors('button:has-text("{text}")', 'buttons', 'add'),
+                // Icon buttons
+                'button:has(mat-icon:has-text("check"))',
+                'button:has(mat-icon:has-text("save"))',
+                'button:has(mat-icon:has-text("done"))',
+                // Submit button
+                'button[type="submit"]',
+                // Material Design primary button
+                'button.mat-flat-button',
+                'button.mdc-button--raised',
+                'button[color="primary"]',
+                // Dialog actions
+                '[role="dialog"] button:not(:has-text("Cancel")):not(:has-text("Annuler"))',
+                '.mat-dialog-actions button:not(:has-text("Cancel"))',
+                '.mdc-dialog__actions button:not(:has-text("Cancel"))',
+            ];
+            let saveButtonFound = false;
+            for (const selector of saveSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 500 })) {
+                        log.info(`  ✅ Found save button: ${selector}`);
+                        // Check if button is enabled before clicking
+                        const isEnabled = await btn.isEnabled();
+                        log.info(`  ℹ️ Button enabled: ${isEnabled}`);
+                        // Use force click with short timeout to avoid blocking
+                        await btn.click({ force: true, timeout: 5000 });
+                        log.info(`  ✅ Clicked save button`);
+                        saveButtonFound = true;
+                        // Wait for dialog to close (max 5 seconds - faster feedback)
+                        try {
+                            await this.page.waitForSelector('[role="dialog"]', {
+                                state: 'hidden',
+                                timeout: 5000,
+                            });
+                            log.info(`  ✅ Dialog closed after save`);
+                        }
+                        catch {
+                            // Dialog might not close - that's okay, we clicked
+                            log.info(`  ⚠️ Dialog still visible after click`);
+                        }
+                        await randomDelay(300, 500);
+                        break;
+                    }
+                }
+                catch (e) {
+                    log.debug(`  ℹ️ Selector ${selector} failed: ${e}`);
+                    continue;
+                }
+            }
+            if (!saveButtonFound) {
+                // Try pressing Enter as fallback
+                log.info(`  ⌨️ No save button found, pressing Enter as fallback`);
+                await this.page.keyboard.press('Enter');
+                // Wait for dialog to close
+                try {
+                    await this.page.waitForSelector('[role="dialog"]', { state: 'hidden', timeout: 10000 });
+                }
+                catch {
+                    // Continue anyway
+                }
+                await randomDelay(500, 1000);
+            }
+            // Step 7: Verify note was created by checking for its presence
+            await randomDelay(1000, 2000);
+            // Look for the note in the list
+            const noteVerifySelectors = [
+                `[class*="note"]:has-text("${input.title.substring(0, 20)}")`,
+                `.note-item:has-text("${input.title.substring(0, 20)}")`,
+                `[data-note-title="${input.title}"]`,
+            ];
+            for (const selector of noteVerifySelectors) {
+                try {
+                    const note = this.page.locator(selector).first();
+                    if (await note.isVisible({ timeout: 2000 })) {
+                        log.success(`  ✅ Note created successfully: "${input.title}"`);
+                        return {
+                            success: true,
+                            noteTitle: input.title,
+                            status: 'created',
+                        };
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // If we can't verify but no errors occurred, assume success
+            log.success(`  ✅ Note creation completed: "${input.title}"`);
+            return {
+                success: true,
+                noteTitle: input.title,
+                status: 'created',
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Note creation failed: ${errorMsg}`);
+            return {
+                success: false,
+                error: errorMsg,
+                status: 'failed',
+            };
+        }
+    }
+    /**
+     * Debug helper to log Studio panel elements
+     */
+    async debugStudioElements() {
+        try {
+            // Log all buttons in the Studio panel
+            const studioButtons = await this.page
+                .locator('[class*="studio"] button, [class*="Studio"] button')
+                .all();
+            log.info(`  🔍 DEBUG: Found ${studioButtons.length} buttons in Studio panel`);
+            for (let i = 0; i < Math.min(studioButtons.length, 10); i++) {
+                const btn = studioButtons[i];
+                const ariaLabel = await btn.getAttribute('aria-label');
+                const text = await btn.textContent();
+                const classes = await btn.getAttribute('class');
+                log.info(`  🔍 Button[${i}]: aria="${ariaLabel}", text="${text?.trim()}", class="${classes?.substring(0, 50)}"`);
+            }
+            // Also check for any visible buttons on the page
+            const allButtons = await this.page.locator('button').all();
+            log.info(`  🔍 Total buttons on page: ${allButtons.length}`);
+        }
+        catch (e) {
+            log.warning(`  ⚠️ Debug failed: ${e}`);
+        }
+    }
+    // ============================================================================
+    // Save Chat to Note
+    // ============================================================================
+    /**
+     * Save the current chat/discussion to a note
+     *
+     * This method extracts all messages from the NotebookLM chat/discussion panel
+     * and creates a note with the chat summary.
+     *
+     * @param input Optional input with custom title
+     * @returns SaveChatToNoteResult with success status and message count
+     */
+    async saveChatToNote(input = {}) {
+        const title = input.title || 'Chat Summary';
+        log.info(`💬 Saving chat to note: "${title}"`);
+        // Overall timeout for the entire operation (60 seconds)
+        const OPERATION_TIMEOUT = 60000;
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error('Save chat to note timed out after 60 seconds')), OPERATION_TIMEOUT);
+        });
+        try {
+            // Wrap the operation with a timeout
+            return await Promise.race([this.performSaveChatToNote(title), timeoutPromise]);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Failed to save chat to note: ${errorMsg}`);
+            return {
+                success: false,
+                noteTitle: title,
+                status: 'failed',
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Internal method to perform the save chat to note operation
+     */
+    async performSaveChatToNote(title) {
+        try {
+            // Step 1: Navigate to Discussion panel to access chat messages
+            await this.navigateToDiscussion();
+            await randomDelay(500, 1000);
+            // Step 2: Extract chat messages (with shorter timeout for individual ops)
+            const chatMessages = await this.extractChatMessages();
+            if (chatMessages.length === 0) {
+                return {
+                    success: false,
+                    noteTitle: title,
+                    status: 'failed',
+                    error: 'No chat messages found to save',
+                };
+            }
+            log.info(`  📊 Extracted ${chatMessages.length} messages from chat`);
+            // Step 3: Format messages into note content
+            const noteContent = this.formatChatAsNote(chatMessages, title);
+            // Step 4: Create the note using existing createNote method
+            const noteResult = await this.createNote({
+                title,
+                content: noteContent,
+            });
+            if (noteResult.success) {
+                log.success(`  ✅ Chat saved to note: "${title}" (${chatMessages.length} messages)`);
+                return {
+                    success: true,
+                    noteTitle: title,
+                    status: 'created',
+                    messageCount: chatMessages.length,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    noteTitle: title,
+                    status: 'failed',
+                    error: noteResult.error || 'Failed to create note',
+                };
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Failed to save chat to note: ${errorMsg}`);
+            return {
+                success: false,
+                noteTitle: title,
+                status: 'failed',
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Extract chat messages from the Discussion panel
+     *
+     * @returns Array of message objects with role (user/assistant) and content
+     */
+    async extractChatMessages() {
+        const messages = [];
+        try {
+            // Selectors for user messages (questions)
+            const userMessageSelectors = [
+                // NotebookLM user message patterns
+                '.user-message',
+                '[data-role="user"]',
+                '[class*="user-message"]',
+                '[class*="user_message"]',
+                '.chat-message.user',
+                '.message.user',
+                // Material Design chat patterns
+                '.mat-chat-user-message',
+                '.mdc-chat-user-message',
+                // Generic patterns
+                '[data-message-role="user"]',
+                '[data-sender="user"]',
+            ];
+            // Selectors for AI messages (responses)
+            const aiMessageSelectors = [
+                // NotebookLM AI response patterns
+                '.ai-message',
+                '.assistant-message',
+                '[data-role="assistant"]',
+                '[data-role="model"]',
+                '[class*="ai-message"]',
+                '[class*="assistant-message"]',
+                '[class*="model-message"]',
+                '.chat-message.assistant',
+                '.chat-message.ai',
+                '.message.assistant',
+                // Material Design patterns
+                '.mat-chat-ai-message',
+                '.mdc-chat-ai-message',
+                // Generic patterns
+                '[data-message-role="assistant"]',
+                '[data-message-role="model"]',
+                '[data-sender="assistant"]',
+                '[data-sender="model"]',
+                // Markdown response container (common in NotebookLM)
+                '.response-container',
+                '.markdown-body',
+                '[class*="response"]',
+            ];
+            // Try to find all message containers in order
+            const allMessageSelectors = [
+                // Combined message container patterns
+                '.chat-message',
+                '.message-item',
+                '[class*="message-container"]',
+                '.messages-list > div',
+                '.chat-scroll-container > div',
+                '[role="listitem"]',
+                // NotebookLM specific patterns
+                '[class*="chat"] [class*="message"]',
+                '[class*="discussion"] [class*="message"]',
+            ];
+            // First, try to find all messages in sequence
+            for (const containerSelector of allMessageSelectors) {
+                try {
+                    const messageContainers = await this.page.locator(containerSelector).all();
+                    if (messageContainers.length > 0) {
+                        log.info(`  🔍 Found ${messageContainers.length} message containers with: ${containerSelector}`);
+                        for (const container of messageContainers) {
+                            if (!(await container.isVisible()))
+                                continue;
+                            const text = await container.textContent();
+                            if (!text || text.trim().length === 0)
+                                continue;
+                            // Determine if user or AI message based on class/attributes
+                            const classes = (await container.getAttribute('class')) || '';
+                            const role = (await container.getAttribute('data-role')) ||
+                                (await container.getAttribute('data-sender')) ||
+                                '';
+                            const isUser = /user|human|question/i.test(classes) || /user|human/i.test(role);
+                            const isAI = /ai|assistant|model|response|answer/i.test(classes) ||
+                                /assistant|model/i.test(role);
+                            if (isUser) {
+                                messages.push({ role: 'user', content: text.trim() });
+                            }
+                            else if (isAI) {
+                                messages.push({ role: 'assistant', content: text.trim() });
+                            }
+                        }
+                        if (messages.length > 0) {
+                            break;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Fallback: Try to extract user and AI messages separately
+            if (messages.length === 0) {
+                log.info(`  🔍 Trying fallback: separate user/AI message extraction...`);
+                // Extract user messages
+                for (const selector of userMessageSelectors) {
+                    try {
+                        const userMsgs = await this.page.locator(selector).all();
+                        for (const msg of userMsgs) {
+                            if (await msg.isVisible()) {
+                                const text = await msg.textContent();
+                                if (text && text.trim().length > 0) {
+                                    messages.push({ role: 'user', content: text.trim() });
+                                }
+                            }
+                        }
+                        if (messages.length > 0)
+                            break;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                // Extract AI messages
+                for (const selector of aiMessageSelectors) {
+                    try {
+                        const aiMsgs = await this.page.locator(selector).all();
+                        for (const msg of aiMsgs) {
+                            if (await msg.isVisible()) {
+                                const text = await msg.textContent();
+                                if (text && text.trim().length > 0) {
+                                    // Check if we already have this message (to avoid duplicates)
+                                    const exists = messages.some((m) => m.content === text.trim());
+                                    if (!exists) {
+                                        messages.push({ role: 'assistant', content: text.trim() });
+                                    }
+                                }
+                            }
+                        }
+                        if (messages.filter((m) => m.role === 'assistant').length > 0)
+                            break;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            // Last resort: Use snapshotAllResponses utility for AI responses
+            if (messages.filter((m) => m.role === 'assistant').length === 0) {
+                log.info(`  🔍 Using snapshotAllResponses for AI messages...`);
+                const aiResponses = await snapshotAllResponses(this.page);
+                for (const response of aiResponses) {
+                    if (response && response.trim().length > 0) {
+                        messages.push({ role: 'assistant', content: response.trim() });
+                    }
+                }
+            }
+            log.info(`  📊 Total extracted: ${messages.filter((m) => m.role === 'user').length} user, ${messages.filter((m) => m.role === 'assistant').length} AI messages`);
+        }
+        catch (error) {
+            log.warning(`  ⚠️ Error extracting chat messages: ${error}`);
+        }
+        return messages;
+    }
+    /**
+     * Format extracted chat messages as a note
+     *
+     * @param messages Array of chat messages
+     * @param title Note title
+     * @returns Formatted note content
+     */
+    formatChatAsNote(messages, title) {
+        const lines = [];
+        lines.push(`# ${title}`);
+        lines.push('');
+        lines.push(`*Saved from NotebookLM chat on ${new Date().toLocaleString()}*`);
+        lines.push('');
+        lines.push('---');
+        lines.push('');
+        for (const msg of messages) {
+            if (msg.role === 'user') {
+                lines.push(`**User:**`);
+                lines.push(msg.content);
+                lines.push('');
+            }
+            else {
+                lines.push(`**NotebookLM:**`);
+                lines.push(msg.content);
+                lines.push('');
+            }
+        }
+        lines.push('---');
+        lines.push(`*${messages.length} messages total*`);
+        return lines.join('\n');
+    }
+    // ============================================================================
+    // Note to Source Conversion
+    // ============================================================================
+    /**
+     * Convert a note to a source document in NotebookLM
+     *
+     * This feature allows users to convert an existing note into a source,
+     * making the note content available for RAG queries. The method:
+     * 1. Finds the note by title or ID in the Studio panel
+     * 2. Attempts to use NotebookLM's native "Convert to source" feature if available
+     * 3. Falls back to extracting note content and creating a text source if not
+     *
+     * @param input Note identification (title or ID)
+     * @returns NoteToSourceResult with source information
+     */
+    async convertNoteToSource(input) {
+        const { noteTitle, noteId } = input;
+        log.info(`📄 Converting note to source: "${noteTitle || noteId}"`);
+        try {
+            // Step 1: Navigate to Studio panel where notes are located
+            await this.navigateToStudio();
+            await randomDelay(500, 1000);
+            // Step 2: Find the note in the Studio panel
+            const noteElement = await this.findNoteElement(noteTitle, noteId);
+            if (!noteElement) {
+                return {
+                    success: false,
+                    error: `Note not found: "${noteTitle || noteId}"`,
+                };
+            }
+            log.info(`  ✅ Found note: "${noteTitle || noteId}"`);
+            // Step 3: Click on the note to select it
+            await noteElement.click();
+            await randomDelay(300, 500);
+            // Step 4: Try to find and use native "Convert to source" or "Add to sources" option
+            const nativeConversionSuccess = await this.tryNativeNoteToSourceConversion(noteElement);
+            if (nativeConversionSuccess) {
+                log.success(`  ✅ Note converted to source using native feature`);
+                return {
+                    success: true,
+                    sourceName: noteTitle || noteId,
+                };
+            }
+            // Step 5: Fallback - Extract note content and create a text source
+            log.info(`  ℹ️ Native conversion not available, using fallback (extract + add as text source)`);
+            const noteContent = await this.extractNoteContent(noteElement, noteTitle);
+            if (!noteContent) {
+                return {
+                    success: false,
+                    error: 'Could not extract note content for conversion',
+                };
+            }
+            // Create a text source with the note content
+            const sourceTitle = `[Note] ${noteTitle || 'Converted Note'}`;
+            const sourceResult = await this.addSource({
+                type: 'text',
+                text: noteContent,
+                title: sourceTitle,
+            });
+            if (sourceResult.success) {
+                log.success(`  ✅ Note converted to source: "${sourceTitle}"`);
+                return {
+                    success: true,
+                    sourceId: sourceResult.sourceId,
+                    sourceName: sourceResult.sourceName || sourceTitle,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    error: sourceResult.error || 'Failed to create source from note content',
+                };
+            }
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            log.error(`  ❌ Note to source conversion failed: ${errorMsg}`);
+            return {
+                success: false,
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Find a note element in the Studio panel by title or ID
+     */
+    async findNoteElement(noteTitle, noteId
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        // Selectors for note items in the Studio panel
+        const noteItemSelectors = [
+            '.note-item',
+            '[data-item="note"]',
+            '.notes-list-item',
+            '[class*="note-list"] > div',
+            '[class*="note-list"] > li',
+            '[class*="Note"] > div',
+            '[class*="notes"] > div',
+            'mat-list-item:has([class*="note"])',
+            '.mat-list-item:has([class*="note"])',
+            '[role="listitem"]:has([class*="note"])',
+            // Studio panel specific
+            '[class*="studio"] [class*="card"]',
+            '[class*="Studio"] [class*="card"]',
+        ];
+        for (const selector of noteItemSelectors) {
+            try {
+                const elements = await this.page.$$(selector);
+                for (const el of elements) {
+                    // Check by data-id attribute
+                    if (noteId) {
+                        const dataId = await el.getAttribute('data-id');
+                        if (dataId === noteId) {
+                            return el;
+                        }
+                        const dataNote = await el.getAttribute('data-note-id');
+                        if (dataNote === noteId) {
+                            return el;
+                        }
+                    }
+                    // Check by title text content
+                    if (noteTitle) {
+                        const textContent = await el.textContent();
+                        if (textContent && textContent.toLowerCase().includes(noteTitle.toLowerCase())) {
+                            return el;
+                        }
+                        // Also check specific title elements
+                        try {
+                            const titleText = await el.$eval('.note-title, .title, [class*="title"], [class*="name"], h3, h4', (e) => e.textContent?.trim() || '');
+                            if (titleText.toLowerCase().includes(noteTitle.toLowerCase())) {
+                                return el;
+                            }
+                        }
+                        catch {
+                            // Element doesn't have a title child
+                        }
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Fallback: look for any card or item with matching text
+        try {
+            const searchText = noteTitle || noteId || '';
+            const fallbackSelectors = [
+                `[class*="note"]:has-text("${searchText.substring(0, 30)}")`,
+                `[class*="card"]:has-text("${searchText.substring(0, 30)}")`,
+                `:has-text("${searchText.substring(0, 30)}")`,
+            ];
+            for (const selector of fallbackSelectors) {
+                try {
+                    const el = await this.page.$(selector);
+                    if (el) {
+                        return el;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch {
+            // Ignore fallback errors
+        }
+        return null;
+    }
+    /**
+     * Try to use NotebookLM's native "Convert to source" or "Add to sources" feature
+     */
+    async tryNativeNoteToSourceConversion(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    noteElement) {
+        // First, try to find a menu button on the note
+        const menuOpened = await this.openNoteMenu(noteElement);
+        if (menuOpened) {
+            // Look for "Convert to source", "Add to sources", or similar options
+            const convertSelectors = [
+                // English patterns
+                'button:has-text("Convert to source")',
+                'button:has-text("Add to sources")',
+                'button:has-text("Make source")',
+                'button:has-text("Save as source")',
+                '[role="menuitem"]:has-text("Convert to source")',
+                '[role="menuitem"]:has-text("Add to sources")',
+                '[role="menuitem"]:has-text("source")',
+                'mat-menu-item:has-text("source")',
+                // French patterns
+                'button:has-text("Convertir en source")',
+                'button:has-text("Ajouter aux sources")',
+                '[role="menuitem"]:has-text("source")',
+                // Icon patterns
+                'button:has(mat-icon:has-text("add_to_drive"))',
+                'button:has(mat-icon:has-text("file_copy"))',
+                '[role="menuitem"]:has(mat-icon:has-text("add"))',
+            ];
+            for (const selector of convertSelectors) {
+                try {
+                    const btn = this.page.locator(selector).first();
+                    if (await btn.isVisible({ timeout: 500 })) {
+                        log.info(`  ✅ Found native convert option: ${selector}`);
+                        await btn.click();
+                        await randomDelay(1000, 2000);
+                        // Wait for potential confirmation or processing
+                        await this.waitForSourceProcessing('Note');
+                        return true;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Close menu if convert option wasn't found
+            await this.page.keyboard.press('Escape');
+            await randomDelay(200, 400);
+        }
+        // Also check for a direct "Convert" or "Add to sources" button on the note itself
+        const directButtonSelectors = [
+            'button:has-text("Convert")',
+            'button:has-text("Add to sources")',
+            'button[aria-label*="source" i]',
+            'button[aria-label*="convert" i]',
+        ];
+        for (const selector of directButtonSelectors) {
+            try {
+                const btn = await noteElement.$(selector);
+                if (btn && (await btn.isVisible())) {
+                    log.info(`  ✅ Found direct convert button on note: ${selector}`);
+                    await btn.click();
+                    await randomDelay(1000, 2000);
+                    await this.waitForSourceProcessing('Note');
+                    return true;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    /**
+     * Open the menu for a note element
+     */
+    async openNoteMenu(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    noteElement) {
+        const menuButtonSelectors = [
+            // Material Design 3-dot menu button
+            'button:has(mat-icon:has-text("more_vert"))',
+            'button:has(mat-icon:has-text("more_horiz"))',
+            'button[aria-label*="menu" i]',
+            'button[aria-label*="options" i]',
+            'button[aria-label*="actions" i]',
+            'button[aria-label*="More" i]',
+            'button[aria-label*="Plus" i]',
+            '.mat-mdc-icon-button:has(mat-icon)',
+            '[class*="menu-button"]',
+            '[class*="more-button"]',
+            '[data-action="menu"]',
+            // Generic icon buttons
+            'button.mat-icon-button',
+            'button.mdc-icon-button',
+        ];
+        // First, try to find the menu button within the note element
+        for (const selector of menuButtonSelectors) {
+            try {
+                const menuBtn = await noteElement.$(selector);
+                if (menuBtn) {
+                    const isVisible = await menuBtn.isVisible();
+                    if (isVisible) {
+                        log.info(`  ✅ Found note menu button: ${selector}`);
+                        await menuBtn.click();
+                        await randomDelay(300, 500);
+                        return true;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Hover over the note to reveal hidden menu button
+        log.info(`  🔍 Hovering to reveal note menu button...`);
+        await noteElement.hover();
+        await randomDelay(500, 800);
+        // Try again after hover
+        for (const selector of menuButtonSelectors) {
+            try {
+                const menuBtn = await noteElement.$(selector);
+                if (menuBtn) {
+                    const isVisible = await menuBtn.isVisible();
+                    if (isVisible) {
+                        log.info(`  ✅ Found note menu button after hover: ${selector}`);
+                        await menuBtn.click();
+                        await randomDelay(300, 500);
+                        return true;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Try right-click as last resort
+        try {
+            await noteElement.click({ button: 'right' });
+            await randomDelay(300, 500);
+            // Check if a context menu appeared
+            const contextMenu = await this.page.$('[role="menu"], .mat-menu-panel, .mdc-menu');
+            if (contextMenu) {
+                log.info(`  ✅ Opened context menu via right-click`);
+                return true;
+            }
+        }
+        catch {
+            // Ignore right-click errors
+        }
+        return false;
+    }
+    /**
+     * Extract the content of a note for fallback conversion
+     */
+    async extractNoteContent(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    noteElement, noteTitle) {
+        try {
+            // Method 1: Click the note to open it and extract content
+            await noteElement.click();
+            await randomDelay(500, 1000);
+            // Look for expanded note content
+            const contentSelectors = [
+                // Note body/content areas
+                '.note-content',
+                '.note-body',
+                '[class*="note-content"]',
+                '[class*="noteContent"]',
+                '[class*="note-body"]',
+                // Expanded card content
+                '[class*="expanded"] [class*="content"]',
+                '[class*="detail"] [class*="content"]',
+                // Text areas in note view
+                '.note-text',
+                '[class*="text-content"]',
+                // ProseMirror or other rich text editors
+                '.ProseMirror',
+                '[contenteditable="true"]',
+                // Generic content areas
+                'article',
+                '.content',
+                '[role="article"]',
+            ];
+            for (const selector of contentSelectors) {
+                try {
+                    const contentEl = await this.page.$(selector);
+                    if (contentEl && (await contentEl.isVisible())) {
+                        const content = await contentEl.textContent();
+                        if (content && content.trim().length > 10) {
+                            log.info(`  ✅ Extracted note content from: ${selector}`);
+                            // Format the content with the note title
+                            const formattedContent = noteTitle
+                                ? `# ${noteTitle}\n\n${content.trim()}`
+                                : content.trim();
+                            return formattedContent;
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            // Method 2: Try to extract from the note element itself
+            const elementContent = await noteElement.textContent();
+            if (elementContent && elementContent.trim().length > 20) {
+                log.info(`  ✅ Extracted note content from element`);
+                const formattedContent = noteTitle
+                    ? `# ${noteTitle}\n\n${elementContent.trim()}`
+                    : elementContent.trim();
+                return formattedContent;
+            }
+            // Method 3: Look for inner HTML content
+            try {
+                const innerContent = await noteElement.$eval('div, p, span', (el) => el.textContent?.trim() || '');
+                if (innerContent && innerContent.length > 20) {
+                    log.info(`  ✅ Extracted note content from inner elements`);
+                    const formattedContent = noteTitle ? `# ${noteTitle}\n\n${innerContent}` : innerContent;
+                    return formattedContent;
+                }
+            }
+            catch {
+                // Ignore extraction errors
+            }
+            log.warning(`  ⚠️ Could not extract note content`);
+            return null;
+        }
+        catch (error) {
+            log.warning(`  ⚠️ Error extracting note content: ${error}`);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=content-manager.js.map