@pan-sec/notebooklm-mcp 2026.2.11 → 2026.3.0

package/dist/notebook-creation/source-manager.js

@@ -7,7 +7,9 @@ import * as fs from "fs";
 import * as path from "path";
 import { log } from "../utils/logger.js";
 import { randomDelay, humanType } from "../utils/stealth-utils.js";
-import { NOTEBOOKLM_SELECTORS } from "./selectors.js";
+import { findElement, getSelectors } from "./selectors.js";
+const STANDARD_SOURCE_PROCESSING_TIMEOUT_MS = 30000;
+const LENIENT_SOURCE_PROCESSING_TIMEOUT_MS = 60000;
 export class SourceManager {
     authManager;
     contextManager;
@@ -42,6 +44,7 @@ export class SourceManager {
             await page.waitForTimeout(2000);
             // Extract source information from the page
             const sources = await page.evaluate(() => {
+                const browser = globalThis;
                 const results = [];
                 // Look for source items in the sidebar/sources panel
                 // Common patterns in NotebookLM:
@@ -56,8 +59,7 @@ export class SourceManager {
                     '.sources-list > *',
                 ];
                 for (const selector of sourceSelectors) {
-                    // @ts-expect-error - DOM types
-                    const items = document.querySelectorAll(selector);
+                    const items = Array.from(browser.document.querySelectorAll(selector));
                     for (let i = 0; i < items.length; i++) {
                         const item = items[i];
                         const text = item.textContent?.trim() || "";
@@ -125,27 +127,50 @@ export class SourceManager {
             try {
                 await page.waitForLoadState('networkidle', { timeout: 15000 });
             }
-            catch {
+            catch (err) {
+                log.debug(`source-manager: waiting for network idle after page load: ${err instanceof Error ? err.message : String(err)}`);
                 log.warning("  Network idle timeout, continuing...");
             }
             await randomDelay(3000, 4000);
             // Check page state
             const pageState = await page.evaluate(() => {
-                // @ts-expect-error - DOM types in evaluate
-                const addSourceBtn = document.querySelector('button[aria-label="Add source"]');
-                // @ts-expect-error - window in evaluate
-                return { hasAddSourceBtn: !!addSourceBtn, windowWidth: window.innerWidth };
+                const browser = globalThis;
+                const addSourceBtn = browser.document.querySelector('button[aria-label="Add source"]');
+                return { hasAddSourceBtn: !!addSourceBtn, windowWidth: browser.window.innerWidth };
             });
             log.dim(`  Page state: width=${pageState.windowWidth}, addSourceBtn=${pageState.hasAddSourceBtn}`);
             // Check if source dialog is already open (new/empty notebooks may auto-open it)
             const dialogAlreadyOpen = await page.evaluate(() => {
-                // Check for dropzone (file upload area) - most reliable indicator
-                // @ts-expect-error - DOM types
-                const dropzone = document.querySelector('.dropzone__file-dialog-button, span[xapscottyuploadertrigger]');
-                // Check for source type options in dialog
-                // @ts-expect-error - DOM types
-                const sourceOptions = document.querySelector('[aria-label="Upload sources from your computer"]');
-                return !!(dropzone || sourceOptions);
+                const browser = globalThis;
+                const asElements = (selector) => Array.from(browser.document.querySelectorAll(selector));
+                const dropzone = browser.document.querySelector('.dropzone__file-dialog-button, span[xapscottyuploadertrigger]');
+                if (dropzone && dropzone.offsetParent !== null)
+                    return true;
+                const sourceOptions = browser.document.querySelector('[aria-label="Upload sources from your computer"]');
+                if (sourceOptions && sourceOptions.offsetParent !== null)
+                    return true;
+                const textArea = browser.document.querySelector('textarea.text-area, textarea[class*="text-area"], textarea.mat-mdc-form-field-textarea-control');
+                if (textArea && textArea.offsetParent !== null)
+                    return true;
+                const chips = asElements("mat-chip, mat-chip-option, [mat-chip-option], button, span");
+                for (const chip of chips) {
+                    if (chip.offsetParent === null)
+                        continue;
+                    const text = chip.textContent?.trim() || "";
+                    if (text.includes("Copied text") || text.includes("Website") || text.includes("Upload")) {
+                        return true;
+                    }
+                }
+                const dialogs = asElements("mat-dialog-container, [role=\"dialog\"], .cdk-overlay-pane");
+                for (const dialog of dialogs) {
+                    if (dialog.offsetParent === null)
+                        continue;
+                    const text = dialog.textContent?.trim() || "";
+                    if (text.includes("Copied text") || text.includes("Website") || text.includes("Upload")) {
+                        return true;
+                    }
+                }
+                return false;
             });
             if (dialogAlreadyOpen) {
                 log.info("  📋 Source dialog already open");
@@ -184,10 +209,9 @@ export class SourceManager {
                 await randomDelay(1500, 2000);
                 // Verify dialog opened
                 const dialogOpened = await page.evaluate(() => {
-                    // @ts-expect-error - DOM types
-                    const dropzone = document.querySelector('.dropzone__file-dialog-button, span[xapscottyuploadertrigger]');
-                    // @ts-expect-error - DOM types
-                    const sourceOptions = document.querySelector('[aria-label="Upload sources from your computer"]');
+                    const browser = globalThis;
+                    const dropzone = browser.document.querySelector('.dropzone__file-dialog-button, span[xapscottyuploadertrigger]');
+                    const sourceOptions = browser.document.querySelector('[aria-label="Upload sources from your computer"]');
                     return !!(dropzone || sourceOptions);
                 });
                 if (!dialogOpened) {
@@ -248,14 +272,14 @@ export class SourceManager {
             const sourceIndex = parseInt(indexMatch[1], 10);
             // Find and click on the source to select it
             const clicked = await page.evaluate((index) => {
+                const browser = globalThis;
                 const sourceSelectors = [
                     'mat-list-item',
                     '[class*="source-item"]',
                     '[role="listitem"]',
                 ];
                 for (const selector of sourceSelectors) {
-                    // @ts-expect-error - DOM types
-                    const items = document.querySelectorAll(selector);
+                    const items = Array.from(browser.document.querySelectorAll(selector));
                     if (items.length > index) {
                         // Look for delete button within the item or select it
                         const item = items[index];
@@ -279,6 +303,7 @@ export class SourceManager {
                 // Look for delete button in toolbar or context menu
                 await randomDelay(500, 800);
                 const deleted = await page.evaluate(() => {
+                    const browser = globalThis;
                     // Look for delete button that appeared after selection
                     const deleteSelectors = [
                         'button[aria-label*="delete" i]',
@@ -287,8 +312,7 @@ export class SourceManager {
                         '[class*="trash"]',
                     ];
                     for (const selector of deleteSelectors) {
-                        // @ts-expect-error - DOM types
-                        const btn = document.querySelector(selector);
+                        const btn = browser.document.querySelector(selector);
                         if (btn && btn.offsetParent !== null) {
                             btn.click();
                             return true;
@@ -303,9 +327,9 @@ export class SourceManager {
             // Confirm deletion if dialog appears
             await randomDelay(500, 800);
             await page.evaluate(() => {
+                const browser = globalThis;
                 // Look for confirm button in dialog
-                // @ts-expect-error - DOM types
-                const buttons = document.querySelectorAll("button");
+                const buttons = Array.from(browser.document.querySelectorAll("button"));
                 for (const btn of buttons) {
                     const text = btn.textContent?.toLowerCase() || "";
                     if (text.includes("delete") || text.includes("remove") || text.includes("confirm")) {
@@ -340,16 +364,15 @@ export class SourceManager {
     async addUrlSourceInternal(page, url) {
         // Click URL/Website source type option — prefer locale-independent signals
         const urlOptionClicked = await page.evaluate(() => {
+            const browser = globalThis;
             // Primary: data/value attribute (locale-independent)
-            // @ts-expect-error - DOM types
-            const byData = document.querySelector('[data-source-type="url"], [value="url"], mat-chip[value="url"]');
+            const byData = browser.document.querySelector('[data-source-type="url"], [value="url"], mat-chip[value="url"]');
             if (byData) {
                 byData.click();
                 return true;
             }
             // Fallback: text/aria match ("URL" is the same word in most languages)
-            // @ts-expect-error - DOM types
-            const buttons = document.querySelectorAll("button, [role='button'], mat-chip");
+            const buttons = Array.from(browser.document.querySelectorAll("button, [role='button'], mat-chip"));
             for (const btn of buttons) {
                 const text = btn.textContent?.toLowerCase() || "";
                 const aria = btn.getAttribute("aria-label")?.toLowerCase() || "";
@@ -381,13 +404,17 @@ export class SourceManager {
     async addTextSourceInternal(page, text, _title) {
         // Click text/paste option
         const textOptionClicked = await page.evaluate(() => {
-            // @ts-expect-error - DOM types
-            const buttons = document.querySelectorAll("button, [role='button'], mat-chip");
+            const browser = globalThis;
+            const buttons = Array.from(browser.document.querySelectorAll("button, [role='button'], mat-chip, mat-chip-option, [mat-chip-option]"));
             for (const btn of buttons) {
                 const btnText = btn.textContent?.toLowerCase() || "";
                 const aria = btn.getAttribute("aria-label")?.toLowerCase() || "";
-                if (btnText.includes("copied text") || btnText.includes("paste") || btnText.includes("text") ||
-                    aria.includes("copied") || aria.includes("paste")) {
+                const combined = `${btnText} ${aria}`;
+                if (combined.includes("search the web") || combined.includes("discover sources")) {
+                    continue;
+                }
+                if (btnText.includes("copied text") || btnText.includes("paste as text") ||
+                    aria.includes("copied") || aria.includes("paste as text")) {
                     btn.click();
                     return true;
                 }
@@ -398,16 +425,19 @@ export class SourceManager {
             throw new Error("Could not find text/paste source option");
         }
         await randomDelay(800, 1200);
-        // Fill text area
-        const textArea = await page.$(NOTEBOOKLM_SELECTORS.textInput.primary);
+        const activeSelector = await this.findValidTextInputSelectorOnPage(page);
+        if (!activeSelector) {
+            throw new Error("Could not find text input area");
+        }
+        const textArea = await page.$(activeSelector);
         if (!textArea) {
             throw new Error("Could not find text input area");
         }
         // Use clipboard for large text
         if (text.length > 500) {
             await page.evaluate((t) => {
-                // @ts-expect-error - navigator available in browser context
-                navigator.clipboard.writeText(t);
+                const browser = globalThis;
+                browser.navigator.clipboard.writeText(t);
             }, text);
             await textArea.focus();
             await page.keyboard.down("Control");
@@ -415,28 +445,26 @@ export class SourceManager {
             await page.keyboard.up("Control");
         }
         else {
-            await humanType(page, NOTEBOOKLM_SELECTORS.textInput.primary, text);
+            await humanType(page, activeSelector, text);
         }
         await randomDelay(500, 800);
         // Click Insert button — prefer locale-independent selectors
         const insertClicked = await page.evaluate(() => {
+            const browser = globalThis;
             // Primary: type=submit (locale-independent)
-            // @ts-expect-error - DOM types
-            const submitBtn = document.querySelector("button[type='submit']:not([disabled])");
+            const submitBtn = browser.document.querySelector("button[type='submit']:not([disabled])");
             if (submitBtn && submitBtn.offsetParent !== null) {
                 submitBtn.click();
                 return true;
             }
             // Secondary: primary color class (locale-independent NotebookLM convention)
-            // @ts-expect-error - DOM types
-            const primaryBtn = document.querySelector("button.button-color--primary:not([disabled])");
+            const primaryBtn = browser.document.querySelector("button.button-color--primary:not([disabled])");
             if (primaryBtn && primaryBtn.offsetParent !== null) {
                 primaryBtn.click();
                 return true;
             }
             // Fallback: text match (English only)
-            // @ts-expect-error - DOM types
-            const buttons = document.querySelectorAll("button");
+            const buttons = Array.from(browser.document.querySelectorAll("button"));
             for (const btn of buttons) {
                 const text = btn.textContent?.toLowerCase() || "";
                 if (text.includes("insert") || text.includes("add") || text.includes("submit")) {
@@ -450,6 +478,35 @@ export class SourceManager {
             throw new Error("Could not find Insert button");
         }
     }
+    async findValidTextInputSelectorOnPage(page) {
+        for (const selector of getSelectors("textInput")) {
+            try {
+                const state = await page.evaluate((targetSelector) => {
+                    const browser = globalThis;
+                    const textarea = browser.document.querySelector(targetSelector);
+                    if (!textarea || textarea.offsetParent === null) {
+                        return { matches: false };
+                    }
+                    const aria = textarea.getAttribute("aria-label")?.toLowerCase() || "";
+                    const placeholder = textarea.getAttribute("placeholder")?.toLowerCase() || "";
+                    const className = textarea.className?.toLowerCase() || "";
+                    const haystack = `${aria} ${placeholder} ${className}`;
+                    return {
+                        matches: !haystack.includes("discover sources") &&
+                            !haystack.includes("search the web") &&
+                            !haystack.includes("query-box"),
+                    };
+                }, selector);
+                if (state.matches) {
+                    return selector;
+                }
+            }
+            catch (err) {
+                log.debug(`source-manager: validating standalone text source input selector: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return null;
+    }
     /**
      * Internal: Add file source
      * December 2025: NotebookLM creates a hidden input[type="file"] AFTER clicking
@@ -550,15 +607,14 @@ export class SourceManager {
     /**
      * Wait for source processing to complete
      */
-    async waitForSourceProcessing(page, timeoutMs = 30000) {
+    async waitForSourceProcessing(page, timeoutMs = STANDARD_SOURCE_PROCESSING_TIMEOUT_MS) {
         const startTime = Date.now();
         while (Date.now() - startTime < timeoutMs) {
             const isProcessing = await page.evaluate(() => {
+                const browser = globalThis;
                 // Look for processing indicators
-                // @ts-expect-error - DOM types
-                const progressBar = document.querySelector('[role="progressbar"]');
-                // @ts-expect-error - DOM types
-                const spinner = document.querySelector('[class*="spinner"], [class*="loading"]');
+                const progressBar = browser.document.querySelector('[role="progressbar"]');
+                const spinner = browser.document.querySelector('[class*="spinner"], [class*="loading"]');
                 return !!(progressBar || spinner);
             });
             if (!isProcessing) {
@@ -576,11 +632,621 @@ export class SourceManager {
             try {
                 await this.page.close();
             }
-            catch {
+            catch (err) {
+                log.debug(`source-manager: closing page: ${err instanceof Error ? err.message : String(err)}`);
                 // Ignore close errors
             }
             this.page = null;
         }
     }
 }
+export class NotebookCreationSourceManager {
+    getPage;
+    constructor(getPage) {
+        this.getPage = getPage;
+    }
+    async addSource(source) {
+        const page = this.requirePage();
+        const expectedNotebookUrl = page.url();
+        log.info(`📍 Current notebook URL: ${expectedNotebookUrl}`);
+        const dialogAlreadyOpen = await this.isSourceDialogOpen();
+        log.info(`📋 Source dialog already open: ${dialogAlreadyOpen}`);
+        if (!dialogAlreadyOpen) {
+            await this.clickAddSource();
+            const currentUrl = page.url();
+            if (!currentUrl.includes("/notebook/") ||
+                (expectedNotebookUrl.includes("/notebook/") &&
+                    !currentUrl.includes(expectedNotebookUrl.split("/notebook/")[1]?.split("?")[0] || ""))) {
+                log.error(`❌ URL changed unexpectedly! Expected: ${expectedNotebookUrl}, Got: ${currentUrl}`);
+                throw new Error("Navigation error: accidentally navigated away from notebook. This may indicate clicking wrong button.");
+            }
+        }
+        else {
+            log.info("📋 Source dialog already open - skipping clickAddSource");
+        }
+        switch (source.type) {
+            case "url":
+                await this.addUrlSource(source.value);
+                break;
+            case "text":
+                await this.addTextSource(source.value, source.title);
+                break;
+            case "file":
+                await this.addFileSource(source.value);
+                break;
+            default:
+                throw new Error(`Unknown source type: ${source.type}`);
+        }
+        log.info(`📍 URL after adding source: ${page.url()}`);
+    }
+    getSourceDescription(source) {
+        switch (source.type) {
+            case "url":
+                try {
+                    const url = new URL(source.value);
+                    return `URL: ${url.hostname}`;
+                }
+                catch (err) {
+                    log.debug(`source-manager: parsing source URL in getSourceDescription: ${err instanceof Error ? err.message : String(err)}`);
+                    return `URL: ${source.value.slice(0, 50)}`;
+                }
+            case "text":
+                return source.title || `Text: ${source.value.slice(0, 30)}...`;
+            case "file":
+                return `File: ${path.basename(source.value)}`;
+            default:
+                return "Unknown source";
+        }
+    }
+    requirePage() {
+        const page = this.getPage();
+        if (!page)
+            throw new Error("Page not initialized");
+        return page;
+    }
+    async isSourceDialogOpen() {
+        const page = this.getPage();
+        if (!page)
+            return false;
+        const dialogIndicators = await page.evaluate(() => {
+            const browser = globalThis;
+            const dialogs = Array.from(browser.document.querySelectorAll("mat-dialog-container"));
+            for (const d of dialogs) {
+                if (d.offsetParent !== null && d.textContent?.trim()) {
+                    return { open: true, reason: "dialog_container_visible" };
+                }
+            }
+            const chipGroup = browser.document.querySelector("mat-chip-listbox, mat-chip-group, mat-chip-set");
+            if (chipGroup && chipGroup.offsetParent !== null) {
+                return { open: true, reason: "chip_group_visible" };
+            }
+            const dropzones = Array.from(browser.document.querySelectorAll('.dropzone, [class*="dropzone"]'));
+            if (dropzones.length > 0) {
+                for (const dz of dropzones) {
+                    if (dz.offsetParent !== null) {
+                        return { open: true, reason: "dropzone_visible" };
+                    }
+                }
+            }
+            const uploadBtn = browser.document.querySelector('button[class*="upload"], input[type="file"]');
+            if (uploadBtn && uploadBtn.offsetParent !== null) {
+                return { open: true, reason: "upload_button_visible" };
+            }
+            return { open: false };
+        });
+        log.info(`📋 isSourceDialogOpen check: ${JSON.stringify(dialogIndicators)}`);
+        return dialogIndicators.open;
+    }
+    async clickAddSource() {
+        const page = this.requirePage();
+        log.info("📎 Clicking 'Add source' button...");
+        const debugEnabled = process.env.DEBUG === "true";
+        if (debugEnabled) {
+            log.dim(`  Current URL: ${page.url()}`);
+        }
+        await randomDelay(2000, 3000);
+        if (debugEnabled) {
+            const buttonsInfo = await page.evaluate(() => {
+                const browser = globalThis;
+                const buttons = Array.from(browser.document.querySelectorAll('button, [role="button"]'));
+                const info = [];
+                for (const btn of buttons) {
+                    const text = btn.textContent?.trim().substring(0, 50) || "";
+                    const aria = btn.getAttribute("aria-label") || "";
+                    const cls = btn.className?.substring(0, 50) || "";
+                    const visible = btn.offsetParent !== null;
+                    if (aria.toLowerCase().includes("add") || aria.toLowerCase().includes("create") ||
+                        text.toLowerCase().includes("add") || text.toLowerCase().includes("create") ||
+                        cls.toLowerCase().includes("add") || cls.toLowerCase().includes("create")) {
+                        info.push({ text, aria, class: cls, visible });
+                    }
+                }
+                return info;
+            });
+            log.dim(`  Buttons found: ${JSON.stringify(buttonsInfo, null, 2)}`);
+        }
+        try {
+            let addSourceLocator = page.locator('button[aria-label="Add source"]');
+            let count = await addSourceLocator.count();
+            log.info(`  Method 1a: Found ${count} button(s) with aria-label="Add source"`);
+            if (count === 0) {
+                addSourceLocator = page.locator('button[aria-label="Add sources"]');
+                count = await addSourceLocator.count();
+                log.info(`  Method 1b: Found ${count} button(s) with aria-label="Add sources"`);
+            }
+            if (count > 0 && await addSourceLocator.first().isVisible()) {
+                await addSourceLocator.first().click();
+                await randomDelay(800, 1500);
+                log.success("✅ Clicked 'Add source' button (locator)");
+                return;
+            }
+        }
+        catch (e) {
+            log.info(`  Locator approach failed: ${e}`);
+        }
+        try {
+            const classLocator = page.locator('button.add-source-button');
+            const count = await classLocator.count();
+            log.info(`  Method 2: Found ${count} button(s) with class add-source-button`);
+            if (count > 0 && await classLocator.first().isVisible()) {
+                await classLocator.first().click();
+                await randomDelay(800, 1500);
+                log.success("✅ Clicked 'Add source' button (class)");
+                return;
+            }
+        }
+        catch (e) {
+            log.info(`  Class selector failed: ${e}`);
+        }
+        try {
+            const clicked = await page.evaluate(() => {
+                const browser = globalThis;
+                const elements = Array.from(browser.document.querySelectorAll('button, [role="button"]'));
+                for (const el of elements) {
+                    const elText = el.textContent?.trim().toLowerCase() || "";
+                    const ariaLabel = el.getAttribute("aria-label")?.toLowerCase() || "";
+                    const className = el.className?.toLowerCase() || "";
+                    if (ariaLabel.includes("create") || className.includes("create-notebook") ||
+                        elText.includes("create") || elText.includes("add note") ||
+                        className.includes("add-note")) {
+                        continue;
+                    }
+                    if (ariaLabel === "add source" || ariaLabel.includes("add source") ||
+                        elText.includes("add source") || className.includes("add-source")) {
+                        el.click();
+                        return { clicked: true, aria: ariaLabel, text: elText.substring(0, 30) };
+                    }
+                }
+                return { clicked: false };
+            });
+            if (clicked.clicked) {
+                await randomDelay(800, 1500);
+                if (process.env.DEBUG === "true") {
+                    log.debug(`source-manager: clicked add-source JS fallback (aria/text lengths: ${String(clicked.aria ?? "").length}/${String(clicked.text ?? "").length})`);
+                }
+                log.success("✅ Clicked 'Add source' button (JS fallback)");
+                return;
+            }
+        }
+        catch (err) {
+            log.debug(`source-manager: clicking 'Add source' button via JS fallback: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        log.warning("⚠️ Add source button not found, waiting and retrying...");
+        await randomDelay(3000, 4000);
+        try {
+            let addSourceLocator = page.locator('button[aria-label="Add source"]');
+            let count = await addSourceLocator.count();
+            log.info(`  Retry: Found ${count} button(s) with aria-label="Add source"`);
+            if (count === 0) {
+                addSourceLocator = page.locator('button[aria-label="Add sources"]');
+                count = await addSourceLocator.count();
+                log.info(`  Retry: Found ${count} button(s) with aria-label="Add sources"`);
+            }
+            if (count > 0 && await addSourceLocator.first().isVisible()) {
+                await addSourceLocator.first().click();
+                await randomDelay(800, 1500);
+                log.success("✅ Clicked 'Add source' button (retry)");
+                return;
+            }
+        }
+        catch (e) {
+            log.info(`  Retry failed: ${e}`);
+        }
+        throw new Error("Could not find 'Add source' button after retry");
+    }
+    async addUrlSource(url) {
+        const page = this.requirePage();
+        log.info(`🔗 Adding URL source: ${url}`);
+        await this.clickSourceTypeByText(["Website", "webWebsite", "Link", "Discover sources"]);
+        await randomDelay(500, 1000);
+        const selectors = getSelectors("urlInput");
+        for (const selector of selectors) {
+            try {
+                const input = await page.$(selector);
+                if (input && await input.isVisible()) {
+                    await humanType(page, selector, url, { withTypos: false });
+                    await randomDelay(500, 1000);
+                    await this.clickSubmitButton();
+                    await this.waitForSourceProcessing({ mode: "strict" });
+                    return;
+                }
+            }
+            catch (err) {
+                log.debug(`source-manager: entering URL into source input selector: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        throw new Error("Could not find URL input field");
+    }
+    async addTextSource(text, title) {
+        const page = this.requirePage();
+        log.info(`📝 Adding text source${title ? `: ${title}` : ""}`);
+        let clickedBySelector = false;
+        for (const selector of getSelectors("textSourceOption")) {
+            try {
+                const option = await page.$(selector);
+                if (option && await option.isVisible()) {
+                    await option.click();
+                    clickedBySelector = true;
+                    log.success(`✅ Clicked text source option via selector: ${selector}`);
+                    break;
+                }
+            }
+            catch (err) {
+                log.debug(`source-manager: clicking text source option selector: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        if (!clickedBySelector) {
+            await this.clickSourceTypeByText(["Copied text", "Paste as text", "Paste"]);
+        }
+        await randomDelay(2000, 2500);
+        const activeSelector = await this.findValidTextInputSelector(page);
+        const textarea = activeSelector ? await page.$(activeSelector) : null;
+        if (!textarea || !activeSelector) {
+            const visibleOptions = await this.getVisibleSourceOptions(page);
+            log.warning(`⚠️ Visible source options after text-source click: ${JSON.stringify(visibleOptions)}`);
+            const visibleTextareas = await this.getVisibleTextareas(page);
+            log.warning(`⚠️ Visible textareas after text-source click: ${JSON.stringify(visibleTextareas)}`);
+            throw new Error("Could not find text input area");
+        }
+        const isVisible = await textarea.isVisible().catch(() => false);
+        if (!isVisible) {
+            await randomDelay(1000, 1500);
+        }
+        await textarea.click();
+        await randomDelay(200, 400);
+        if (text.length > 500) {
+            await page.evaluate((clipboardText) => {
+                const browser = globalThis;
+                browser.navigator.clipboard.writeText(clipboardText);
+            }, text);
+            await page.keyboard.press("Control+V");
+        }
+        else {
+            await humanType(page, activeSelector, text, { withTypos: false });
+        }
+        await page.evaluate(({ selector, value }) => {
+            const browser = globalThis;
+            const textarea = browser.document.querySelector(selector);
+            if (!textarea)
+                return false;
+            textarea.focus();
+            if (typeof textarea.value === "string") {
+                textarea.value = value;
+            }
+            else {
+                textarea.textContent = value;
+            }
+            textarea.dispatchEvent(new browser.Event("input", { bubbles: true }));
+            textarea.dispatchEvent(new browser.Event("change", { bubbles: true }));
+            return true;
+        }, { selector: activeSelector, value: text });
+        await randomDelay(500, 1000);
+        const textState = await page.evaluate(({ selector }) => {
+            const browser = globalThis;
+            const textarea = browser.document.querySelector(selector);
+            const buttons = Array.from(browser.document.querySelectorAll("button")).map((button) => ({
+                text: button.textContent?.trim() || "",
+                disabled: button.getAttribute("disabled") !== null || button.getAttribute("aria-disabled") === "true",
+            }));
+            return {
+                textLength: typeof textarea?.value === "string"
+                    ? textarea.value.length
+                    : (textarea?.textContent?.length || 0),
+                textareaClass: textarea?.className || "",
+                textareaAria: textarea?.getAttribute?.("aria-label") || "",
+                textareaPlaceholder: textarea?.getAttribute?.("placeholder") || "",
+                visibleDialogs: Array.from(browser.document.querySelectorAll("[role='dialog'], mat-dialog-container, .cdk-overlay-pane"))
+                    .filter((dialog) => dialog.offsetParent !== null)
+                    .map((dialog) => (dialog.textContent || "").trim().slice(0, 200))
+                    .filter((text) => text.length > 0)
+                    .slice(0, 4),
+                buttons: buttons.filter((button) => button.text.length > 0).slice(0, 12),
+            };
+        }, { selector: activeSelector });
+        log.info(`🧪 Text source state before insert: ${JSON.stringify(textState)}`);
+        await this.clickInsertButton();
+        await this.waitForSourceProcessing({ mode: "lenient" });
+    }
+    async addFileSource(filePath) {
+        const page = this.requirePage();
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+        if (!fs.existsSync(absolutePath)) {
+            throw new Error(`File not found: ${absolutePath}`);
+        }
+        log.info(`📁 Adding file source: ${path.basename(absolutePath)}`);
+        await randomDelay(500, 1000);
+        try {
+            const chooseFileLocator = page.locator('span.dropzone__file-dialog-button');
+            if (await chooseFileLocator.count() > 0 && await chooseFileLocator.first().isVisible()) {
+                await chooseFileLocator.first().click();
+                await page.waitForSelector('input[type="file"]', { timeout: 5000, state: 'attached' });
+                await randomDelay(200, 400);
+                await page.locator('input[type="file"]').first().setInputFiles(absolutePath);
+                log.success("  ✅ File uploaded via Playwright click + setInputFiles");
+                await randomDelay(1000, 2000);
+                await this.waitForSourceProcessing({ mode: "lenient" });
+                return;
+            }
+            const xapscottyLocator = page.locator('[xapscottyuploadertrigger]');
+            if (await xapscottyLocator.count() > 0 && await xapscottyLocator.first().isVisible()) {
+                await xapscottyLocator.first().click();
+                await page.waitForSelector('input[type="file"]', { timeout: 5000, state: 'attached' });
+                await randomDelay(200, 400);
+                await page.locator('input[type="file"]').first().setInputFiles(absolutePath);
+                log.success("  ✅ File uploaded via xapscotty click + setInputFiles");
+                await randomDelay(1000, 2000);
+                await this.waitForSourceProcessing({ mode: "lenient" });
+                return;
+            }
+            const uploadBtnLocator = page.locator('button[class*="upload"], button[aria-label="Upload sources from your computer"]');
+            if (await uploadBtnLocator.count() > 0 && await uploadBtnLocator.first().isVisible()) {
+                await uploadBtnLocator.first().click();
+                await page.waitForSelector('input[type="file"]', { timeout: 5000, state: 'attached' });
+                await randomDelay(200, 400);
+                await page.locator('input[type="file"]').first().setInputFiles(absolutePath);
+                log.success("  ✅ File uploaded via upload button click + setInputFiles");
+                await randomDelay(1000, 2000);
+                await this.waitForSourceProcessing({ mode: "lenient" });
+                return;
+            }
+        }
+        catch (e) {
+            log.info(`  Playwright click approach: ${e}`);
+        }
+        try {
+            const fileChooserPromise = page.waitForEvent('filechooser', { timeout: 5000 });
+            const chooseFileLocator = page.locator('span.dropzone__file-dialog-button');
+            if (await chooseFileLocator.count() > 0) {
+                await chooseFileLocator.first().click();
+            }
+            const fileChooser = await fileChooserPromise;
+            await fileChooser.setFiles(absolutePath);
+            log.success("  ✅ File uploaded via filechooser event");
+            await randomDelay(1000, 2000);
+            await this.waitForSourceProcessing({ mode: "lenient" });
+            return;
+        }
+        catch (e) {
+            log.info(`  Filechooser approach: ${e}`);
+        }
+        try {
+            const fileInputLocator = page.locator('input[type="file"]');
+            if (await fileInputLocator.count() > 0) {
+                await fileInputLocator.first().setInputFiles(absolutePath);
+                log.success("  ✅ File uploaded via existing locator");
+                await randomDelay(1000, 2000);
+                await this.waitForSourceProcessing({ mode: "lenient" });
+                return;
+            }
+        }
+        catch (e) {
+            log.info(`  Existing locator attempt: ${e}`);
+        }
+        throw new Error("Could not upload file - all methods failed. NotebookLM may be using an unsupported upload method.");
+    }
+    async clickSourceTypeByText(textPatterns) {
+        const page = this.requirePage();
+        for (const pattern of textPatterns) {
+            try {
+                const clicked = await page.evaluate((searchText) => {
+                    const browser = globalThis;
+                    const elements = Array.from(browser.document.querySelectorAll('button, [role="button"], mat-chip, mat-chip-option, [mat-chip-option]'));
+                    for (const el of elements) {
+                        const text = el.textContent?.trim() || "";
+                        const aria = el.getAttribute("aria-label")?.trim() || "";
+                        const haystack = `${text} ${aria}`.toLowerCase();
+                        if (haystack.includes("search the web") || haystack.includes("discover sources")) {
+                            continue;
+                        }
+                        if ((text === searchText || haystack.includes(searchText.toLowerCase())) &&
+                            el.offsetParent !== null) {
+                            el.click();
+                            return true;
+                        }
+                    }
+                    return false;
+                }, pattern);
+                if (clicked) {
+                    log.success(`✅ Clicked source type: ${pattern}`);
+                    await randomDelay(800, 1200);
+                    return;
+                }
+            }
+            catch (err) {
+                log.debug(`source-manager: clicking source type tab via text pattern: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        const visibleOptions = await this.getVisibleSourceOptions(this.requirePage());
+        log.warning(`⚠️ Could not find source type: ${textPatterns.join(", ")} — visible: ${JSON.stringify(visibleOptions)}`);
+    }
+    async findValidTextInputSelector(page) {
+        for (const selector of getSelectors("textInput")) {
+            try {
+                const state = await page.evaluate((targetSelector) => {
+                    const browser = globalThis;
+                    const textarea = browser.document.querySelector(targetSelector);
+                    if (!textarea || textarea.offsetParent === null) {
+                        return { matches: false, rejected: "missing" };
+                    }
+                    const aria = textarea.getAttribute("aria-label")?.toLowerCase() || "";
+                    const placeholder = textarea.getAttribute("placeholder")?.toLowerCase() || "";
+                    const className = textarea.className?.toLowerCase() || "";
+                    const haystack = `${aria} ${placeholder} ${className}`;
+                    if (haystack.includes("discover sources") ||
+                        haystack.includes("search the web") ||
+                        haystack.includes("query-box")) {
+                        return { matches: false, rejected: haystack };
+                    }
+                    return { matches: true, rejected: "" };
+                }, selector);
+                if (state.matches) {
+                    return selector;
+                }
+            }
+            catch (err) {
+                log.debug(`source-manager: validating text source input selector: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return null;
+    }
+    async getVisibleSourceOptions(page) {
+        try {
+            return await page.evaluate(() => {
+                const browser = globalThis;
+                return Array.from(browser.document.querySelectorAll('button, [role="button"], mat-chip, mat-chip-option, [mat-chip-option]'))
+                    .map((el) => el)
+                    .filter((el) => el.offsetParent !== null)
+                    .map((el) => `${el.textContent?.trim() || ""} ${el.getAttribute("aria-label") || ""}`.trim())
+                    .filter((text) => text.length > 0)
+                    .slice(0, 20);
+            });
+        }
+        catch (err) {
+            log.debug(`source-manager: collecting visible source options: ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    async getVisibleTextareas(page) {
+        try {
+            return await page.evaluate(() => {
+                const browser = globalThis;
+                return Array.from(browser.document.querySelectorAll("textarea"))
+                    .map((el) => el)
+                    .filter((el) => el.offsetParent !== null)
+                    .map((el) => ({
+                    selector: `textarea.${el.className?.replace(/\s+/g, ".")}` || "textarea",
+                    aria: el.getAttribute("aria-label") || "",
+                    placeholder: el.getAttribute("placeholder") || "",
+                    classes: el.className || "",
+                }));
+            });
+        }
+        catch (err) {
+            log.debug(`source-manager: collecting visible textareas: ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    async clickSubmitButton() {
+        const page = this.requirePage();
+        const selectors = getSelectors("submitButton");
+        for (const selector of selectors) {
+            try {
+                const element = await page.$(selector);
+                if (element && await element.isVisible()) {
+                    await element.click();
+                    return;
+                }
+            }
+            catch (err) {
+                log.debug(`source-manager: clicking submit button selector: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        await page.keyboard.press("Enter");
+    }
+    async clickInsertButton() {
+        const page = this.requirePage();
+        const clicked = await page.evaluate(() => {
+            const browser = globalThis;
+            const submitBtn = browser.document.querySelector("button[type='submit']:not([disabled])");
+            if (submitBtn && submitBtn.offsetParent !== null) {
+                submitBtn.click();
+                return true;
+            }
+            const primaryBtn = browser.document.querySelector("button.button-color--primary:not([disabled])");
+            if (primaryBtn && primaryBtn.offsetParent !== null) {
+                primaryBtn.click();
+                return true;
+            }
+            const buttons = Array.from(browser.document.querySelectorAll("button"));
+            for (const btn of buttons) {
+                const text = btn.textContent?.trim() || "";
+                if (text === "Insert" || text.toLowerCase() === "insert") {
+                    btn.click();
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (clicked) {
+            log.success("✅ Clicked 'Insert' button");
+            return;
+        }
+        log.warning("⚠️ 'Insert' button not found, trying submit button");
+        await this.clickSubmitButton();
+    }
+    async waitForSourceProcessing(options = { mode: "strict" }) {
+        const page = this.requirePage();
+        log.info("⏳ Waiting for source processing...");
+        if (options.mode === "lenient") {
+            await randomDelay(3000, 4000);
+            const dialogStillOpen = await this.isSourceDialogOpen();
+            if (!dialogStillOpen) {
+                log.success("✅ Source dialog closed - assuming success");
+                return;
+            }
+            await this.throwIfSourceErrorAlert(page);
+            await randomDelay(2000, 3000);
+            log.success("✅ Source processing appears complete");
+            return;
+        }
+        const timeout = LENIENT_SOURCE_PROCESSING_TIMEOUT_MS;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            const successElement = await findElement(page, "successIndicator");
+            if (successElement) {
+                log.success("✅ Source processed successfully");
+                return;
+            }
+            const errorElement = await findElement(page, "errorMessage");
+            if (errorElement) {
+                const errorText = (await errorElement.innerText?.()) ||
+                    "Unknown error";
+                throw new Error(`Source processing failed: ${errorText}`);
+            }
+            const processingElement = await findElement(page, "processingIndicator");
+            if (!processingElement) {
+                await randomDelay(1000, 1500);
+                return;
+            }
+            await page.waitForTimeout(1000);
+        }
+        log.warning("⚠️ Source processing timeout - continuing anyway");
+    }
+    async throwIfSourceErrorAlert(page) {
+        const hasError = await page.evaluate(() => {
+            const browser = globalThis;
+            const alerts = Array.from(browser.document.querySelectorAll('[role="alert"]'));
+            for (const alert of alerts) {
+                const text = alert.textContent?.toLowerCase() || "";
+                if (text.includes("error") || text.includes("failed") || text.includes("invalid") || text.includes("unable")) {
+                    return text.substring(0, 100);
+                }
+            }
+            return null;
+        });
+        if (hasError) {
+            throw new Error(`Source processing failed: ${hasError}`);
+        }
+    }
+}
 //# sourceMappingURL=source-manager.js.map