@jackwener/opencli 1.5.6 → 1.5.8

package/dist/clis/notebooklm/history.test.js

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockListNotebooklmHistoryViaRpc, mockGetNotebooklmPageState, mockRequireNotebooklmSession, } = vi.hoisted(() => ({
+    mockListNotebooklmHistoryViaRpc: vi.fn(),
+    mockGetNotebooklmPageState: vi.fn(),
+    mockRequireNotebooklmSession: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        getNotebooklmPageState: mockGetNotebooklmPageState,
+        listNotebooklmHistoryViaRpc: mockListNotebooklmHistoryViaRpc,
+        requireNotebooklmSession: mockRequireNotebooklmSession,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './history.js';
+describe('notebooklm history', () => {
+    const history = getRegistry().get('notebooklm/history');
+    beforeEach(() => {
+        mockListNotebooklmHistoryViaRpc.mockReset();
+        mockGetNotebooklmPageState.mockReset();
+        mockRequireNotebooklmSession.mockReset();
+        mockRequireNotebooklmSession.mockResolvedValue(undefined);
+        mockGetNotebooklmPageState.mockResolvedValue({
+            url: 'https://notebooklm.google.com/notebook/nb-demo',
+            title: 'Browser Automation',
+            hostname: 'notebooklm.google.com',
+            kind: 'notebook',
+            notebookId: 'nb-demo',
+            loginRequired: false,
+            notebookCount: 1,
+        });
+    });
+    it('lists notebook history threads from the browser rpc', async () => {
+        mockListNotebooklmHistoryViaRpc.mockResolvedValue([
+            {
+                notebook_id: 'nb-demo',
+                thread_id: '28e0f2cb-4591-45a3-a661-7653666f7c78',
+                item_count: 0,
+                preview: 'Summarize this notebook',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'rpc',
+            },
+        ]);
+        const result = await history.func({}, {});
+        expect(result).toEqual([
+            {
+                notebook_id: 'nb-demo',
+                thread_id: '28e0f2cb-4591-45a3-a661-7653666f7c78',
+                item_count: 0,
+                preview: 'Summarize this notebook',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'rpc',
+            },
+        ]);
+    });
+});

package/dist/clis/notebooklm/list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/notebooklm/list.js

@@ -0,0 +1,35 @@
+import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { ensureNotebooklmHome, listNotebooklmLinks, listNotebooklmViaRpc, readCurrentNotebooklm, requireNotebooklmSession, } from './utils.js';
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'list',
+    description: 'List NotebookLM notebooks via in-page batchexecute RPC in the current logged-in session',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['title', 'id', 'is_owner', 'created_at', 'source', 'url'],
+    func: async (page) => {
+        const currentFallback = await readCurrentNotebooklm(page).catch(() => null);
+        await ensureNotebooklmHome(page);
+        await requireNotebooklmSession(page);
+        try {
+            const rpcRows = await listNotebooklmViaRpc(page);
+            if (rpcRows.length > 0)
+                return rpcRows;
+        }
+        catch (error) {
+            if (error instanceof AuthRequiredError)
+                throw error;
+        }
+        const domRows = await listNotebooklmLinks(page);
+        if (domRows.length > 0)
+            return domRows;
+        if (currentFallback)
+            return [currentFallback];
+        return [];
+    },
+});

package/dist/clis/notebooklm/note-list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/notebooklm/note-list.js

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { EmptyResultError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { ensureNotebooklmNotebookBinding, getNotebooklmPageState, listNotebooklmNotesFromPage, requireNotebooklmSession, } from './utils.js';
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'note-list',
+    aliases: ['notes-list'],
+    description: 'List saved notes from the Studio panel of the current NotebookLM notebook',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['title', 'created_at', 'source', 'url'],
+    func: async (page) => {
+        await ensureNotebooklmNotebookBinding(page);
+        await requireNotebooklmSession(page);
+        const state = await getNotebooklmPageState(page);
+        if (state.kind !== 'notebook') {
+            throw new EmptyResultError('opencli notebooklm note-list', 'Open a specific NotebookLM notebook tab first, then retry.');
+        }
+        const rows = await listNotebooklmNotesFromPage(page);
+        if (rows.length > 0)
+            return rows;
+        throw new EmptyResultError('opencli notebooklm note-list', 'No NotebookLM notes are visible in the Studio panel. Reload the notebook page or close the note editor and retry.');
+    },
+});

package/dist/clis/notebooklm/note-list.test.d.ts

@@ -0,0 +1 @@
+import './note-list.js';

package/dist/clis/notebooklm/note-list.test.js

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockListNotebooklmNotesFromPage, mockGetNotebooklmPageState, mockRequireNotebooklmSession } = vi.hoisted(() => ({
+    mockListNotebooklmNotesFromPage: vi.fn(),
+    mockGetNotebooklmPageState: vi.fn(),
+    mockRequireNotebooklmSession: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        getNotebooklmPageState: mockGetNotebooklmPageState,
+        listNotebooklmNotesFromPage: mockListNotebooklmNotesFromPage,
+        requireNotebooklmSession: mockRequireNotebooklmSession,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './note-list.js';
+describe('notebooklm note-list', () => {
+    const command = getRegistry().get('notebooklm/note-list');
+    beforeEach(() => {
+        mockListNotebooklmNotesFromPage.mockReset();
+        mockGetNotebooklmPageState.mockReset();
+        mockRequireNotebooklmSession.mockReset();
+        mockRequireNotebooklmSession.mockResolvedValue(undefined);
+        mockGetNotebooklmPageState.mockResolvedValue({
+            url: 'https://notebooklm.google.com/notebook/nb-demo',
+            title: 'Browser Automation',
+            hostname: 'notebooklm.google.com',
+            kind: 'notebook',
+            notebookId: 'nb-demo',
+            loginRequired: false,
+            notebookCount: 1,
+        });
+    });
+    it('lists notebook notes from the Studio panel', async () => {
+        mockListNotebooklmNotesFromPage.mockResolvedValue([
+            {
+                notebook_id: 'nb-demo',
+                title: '新建笔记',
+                created_at: '6 分钟前',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'studio-list',
+            },
+        ]);
+        const result = await command.func({}, {});
+        expect(result).toEqual([
+            {
+                notebook_id: 'nb-demo',
+                title: '新建笔记',
+                created_at: '6 分钟前',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'studio-list',
+            },
+        ]);
+    });
+});

package/dist/clis/notebooklm/notes-get.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/notebooklm/notes-get.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '../../registry.js';
+import { EmptyResultError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { ensureNotebooklmNotebookBinding, findNotebooklmNoteRow, getNotebooklmPageState, listNotebooklmNotesFromPage, readNotebooklmVisibleNoteFromPage, requireNotebooklmSession, } from './utils.js';
+function matchesNoteTitle(title, query) {
+    const needle = query.trim().toLowerCase();
+    if (!needle)
+        return false;
+    const normalized = title.trim().toLowerCase();
+    return normalized === needle || normalized.includes(needle);
+}
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'notes-get',
+    description: 'Get one note from the current NotebookLM notebook by title from the visible note editor',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'note',
+            positional: true,
+            required: true,
+            help: 'Note title or id from the current notebook',
+        },
+    ],
+    columns: ['title', 'content', 'source', 'url'],
+    func: async (page, kwargs) => {
+        await ensureNotebooklmNotebookBinding(page);
+        await requireNotebooklmSession(page);
+        const state = await getNotebooklmPageState(page);
+        if (state.kind !== 'notebook') {
+            throw new EmptyResultError('opencli notebooklm notes-get', 'Open a specific NotebookLM notebook tab first, then retry.');
+        }
+        const query = typeof kwargs.note === 'string' ? kwargs.note : String(kwargs.note ?? '');
+        const visible = await readNotebooklmVisibleNoteFromPage(page);
+        if (visible && matchesNoteTitle(visible.title, query))
+            return [visible];
+        const rows = await listNotebooklmNotesFromPage(page);
+        const listed = findNotebooklmNoteRow(rows, query);
+        if (listed) {
+            throw new EmptyResultError('opencli notebooklm notes-get', `Note "${query}" is listed in Studio, but opencli currently reads note content only from the visible note editor. Open that note in NotebookLM, then retry.`);
+        }
+        throw new EmptyResultError('opencli notebooklm notes-get', `Note "${query}" was not found in the current notebook.`);
+    },
+});

package/dist/clis/notebooklm/notes-get.test.d.ts

@@ -0,0 +1 @@
+import './notes-get.js';

package/dist/clis/notebooklm/notes-get.test.js

@@ -0,0 +1,72 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockListNotebooklmNotesFromPage, mockReadNotebooklmVisibleNoteFromPage, mockGetNotebooklmPageState, mockRequireNotebooklmSession, } = vi.hoisted(() => ({
+    mockListNotebooklmNotesFromPage: vi.fn(),
+    mockReadNotebooklmVisibleNoteFromPage: vi.fn(),
+    mockGetNotebooklmPageState: vi.fn(),
+    mockRequireNotebooklmSession: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        listNotebooklmNotesFromPage: mockListNotebooklmNotesFromPage,
+        readNotebooklmVisibleNoteFromPage: mockReadNotebooklmVisibleNoteFromPage,
+        getNotebooklmPageState: mockGetNotebooklmPageState,
+        requireNotebooklmSession: mockRequireNotebooklmSession,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './notes-get.js';
+describe('notebooklm notes-get', () => {
+    const command = getRegistry().get('notebooklm/notes-get');
+    beforeEach(() => {
+        mockListNotebooklmNotesFromPage.mockReset();
+        mockReadNotebooklmVisibleNoteFromPage.mockReset();
+        mockGetNotebooklmPageState.mockReset();
+        mockRequireNotebooklmSession.mockReset();
+        mockRequireNotebooklmSession.mockResolvedValue(undefined);
+        mockGetNotebooklmPageState.mockResolvedValue({
+            url: 'https://notebooklm.google.com/notebook/nb-demo',
+            title: 'Browser Automation',
+            hostname: 'notebooklm.google.com',
+            kind: 'notebook',
+            notebookId: 'nb-demo',
+            loginRequired: false,
+            notebookCount: 1,
+        });
+    });
+    it('returns the currently visible note editor content when the title matches', async () => {
+        mockReadNotebooklmVisibleNoteFromPage.mockResolvedValue({
+            notebook_id: 'nb-demo',
+            title: '新建笔记',
+            content: '第一段\\n第二段',
+            url: 'https://notebooklm.google.com/notebook/nb-demo',
+            source: 'studio-editor',
+        });
+        const result = await command.func({}, { note: '新建笔记' });
+        expect(result).toEqual([
+            {
+                notebook_id: 'nb-demo',
+                title: '新建笔记',
+                content: '第一段\\n第二段',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'studio-editor',
+            },
+        ]);
+    });
+    it('explains the current visible-note limitation when the target note is listed but not open', async () => {
+        mockReadNotebooklmVisibleNoteFromPage.mockResolvedValue(null);
+        mockListNotebooklmNotesFromPage.mockResolvedValue([
+            {
+                notebook_id: 'nb-demo',
+                title: '新建笔记',
+                created_at: '6 分钟前',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'studio-list',
+            },
+        ]);
+        await expect(command.func({}, { note: '新建笔记' })).rejects.toMatchObject({
+            hint: expect.stringMatching(/currently reads note content only from the visible note editor/i),
+        });
+    });
+});

package/dist/clis/notebooklm/rpc.d.ts

@@ -0,0 +1,36 @@
+import type { IPage } from '../../types.js';
+export type NotebooklmPageAuth = {
+    csrfToken: string;
+    sessionId: string;
+    sourcePath: string;
+};
+export type NotebooklmFetchResponse = {
+    ok: boolean;
+    status: number;
+    body: string;
+    finalUrl: string;
+};
+export type NotebooklmRpcCallResult = {
+    auth: NotebooklmPageAuth;
+    url: string;
+    requestBody: string;
+    response: NotebooklmFetchResponse;
+    result: unknown;
+};
+export declare function extractNotebooklmPageAuthFromHtml(html: string, sourcePath?: string, preferredTokens?: {
+    csrfToken?: string;
+    sessionId?: string;
+}): NotebooklmPageAuth;
+export declare function getNotebooklmPageAuth(page: IPage): Promise<NotebooklmPageAuth>;
+export declare function buildNotebooklmRpcBody(rpcId: string, params: unknown[] | Record<string, unknown> | null, csrfToken: string): string;
+export declare function stripNotebooklmAntiXssi(rawBody: string): string;
+export declare function parseNotebooklmChunkedResponse(rawBody: string): unknown[];
+export declare function extractNotebooklmRpcResult(rawBody: string, rpcId: string): unknown;
+export declare function fetchNotebooklmInPage(page: IPage, url: string, options?: {
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: string;
+}): Promise<NotebooklmFetchResponse>;
+export declare function callNotebooklmRpc(page: IPage, rpcId: string, params: unknown[] | Record<string, unknown> | null, options?: {
+    hl?: string;
+}): Promise<NotebooklmRpcCallResult>;

package/dist/clis/notebooklm/rpc.js

@@ -0,0 +1,189 @@
+import { AuthRequiredError, CliError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN } from './shared.js';
+export function extractNotebooklmPageAuthFromHtml(html, sourcePath = '/', preferredTokens) {
+    const csrfMatch = html.match(/"SNlM0e":"([^"]+)"/);
+    const sessionMatch = html.match(/"FdrFJe":"([^"]+)"/);
+    const csrfToken = preferredTokens?.csrfToken?.trim() || (csrfMatch ? csrfMatch[1] : '');
+    const sessionId = preferredTokens?.sessionId?.trim() || (sessionMatch ? sessionMatch[1] : '');
+    if (!csrfToken || !sessionId) {
+        throw new CliError('NOTEBOOKLM_TOKENS', 'NotebookLM page tokens were not found in the current page HTML', 'Open the NotebookLM notebook page in Chrome, wait for it to finish loading, then retry with --verbose if it still fails.');
+    }
+    return { csrfToken, sessionId, sourcePath: sourcePath || '/' };
+}
+async function probeNotebooklmPageAuth(page) {
+    const raw = await page.evaluate(`(() => {
+    const wiz = window.WIZ_global_data || {};
+    const html = document.documentElement.innerHTML;
+    return {
+      html,
+      sourcePath: location.pathname || '/',
+      readyState: document.readyState || '',
+      csrfToken: typeof wiz.SNlM0e === 'string' ? wiz.SNlM0e : '',
+      sessionId: typeof wiz.FdrFJe === 'string' ? wiz.FdrFJe : '',
+    };
+  })()`);
+    return {
+        html: String(raw?.html ?? ''),
+        sourcePath: String(raw?.sourcePath ?? '/'),
+        readyState: String(raw?.readyState ?? ''),
+        csrfToken: String(raw?.csrfToken ?? ''),
+        sessionId: String(raw?.sessionId ?? ''),
+    };
+}
+export async function getNotebooklmPageAuth(page) {
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const probe = await probeNotebooklmPageAuth(page);
+        try {
+            return extractNotebooklmPageAuthFromHtml(probe.html, probe.sourcePath, { csrfToken: probe.csrfToken, sessionId: probe.sessionId });
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === 0 && typeof page.wait === 'function') {
+                await page.wait(0.5).catch(() => undefined);
+                continue;
+            }
+        }
+    }
+    throw lastError;
+}
+export function buildNotebooklmRpcBody(rpcId, params, csrfToken) {
+    const rpcRequest = [[[rpcId, JSON.stringify(params), null, 'generic']]];
+    return `f.req=${encodeURIComponent(JSON.stringify(rpcRequest))}&at=${encodeURIComponent(csrfToken)}&`;
+}
+export function stripNotebooklmAntiXssi(rawBody) {
+    if (!rawBody.startsWith(")]}'"))
+        return rawBody;
+    return rawBody.replace(/^\)\]\}'\r?\n/, '');
+}
+export function parseNotebooklmChunkedResponse(rawBody) {
+    const cleaned = stripNotebooklmAntiXssi(rawBody).trim();
+    if (!cleaned)
+        return [];
+    const lines = cleaned.split('\n');
+    const chunks = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        if (/^\d+$/.test(line)) {
+            const nextLine = lines[i + 1];
+            if (!nextLine)
+                continue;
+            try {
+                chunks.push(JSON.parse(nextLine));
+            }
+            catch {
+                // Ignore malformed chunks and keep scanning.
+            }
+            i += 1;
+            continue;
+        }
+        if (line.startsWith('[')) {
+            try {
+                chunks.push(JSON.parse(line));
+            }
+            catch {
+                // Ignore malformed chunks and keep scanning.
+            }
+        }
+    }
+    return chunks;
+}
+export function extractNotebooklmRpcResult(rawBody, rpcId) {
+    const chunks = parseNotebooklmChunkedResponse(rawBody);
+    for (const chunk of chunks) {
+        if (!Array.isArray(chunk))
+            continue;
+        const items = Array.isArray(chunk[0]) ? chunk : [chunk];
+        for (const item of items) {
+            if (!Array.isArray(item) || item.length < 1)
+                continue;
+            if (item[0] === 'er') {
+                const errorCode = typeof item[2] === 'number'
+                    ? item[2]
+                    : typeof item[5] === 'number'
+                        ? item[5]
+                        : null;
+                if (errorCode === 401 || errorCode === 403) {
+                    throw new AuthRequiredError(NOTEBOOKLM_DOMAIN, `NotebookLM RPC returned auth error (${errorCode})`);
+                }
+                throw new CliError('NOTEBOOKLM_RPC', `NotebookLM RPC failed${errorCode ? ` (code=${errorCode})` : ''}`, 'Retry from an already logged-in NotebookLM session, or inspect the raw response with debug logging.');
+            }
+            if (item[0] === 'wrb.fr' && item[1] === rpcId) {
+                const payload = item[2];
+                if (typeof payload === 'string') {
+                    try {
+                        return JSON.parse(payload);
+                    }
+                    catch {
+                        return payload;
+                    }
+                }
+                return payload;
+            }
+        }
+    }
+    return null;
+}
+export async function fetchNotebooklmInPage(page, url, options = {}) {
+    const method = options.method ?? 'GET';
+    const headers = options.headers ?? {};
+    const body = options.body ?? '';
+    const raw = await page.evaluate(`(async () => {
+    const request = {
+      url: ${JSON.stringify(url)},
+      method: ${JSON.stringify(method)},
+      headers: ${JSON.stringify(headers)},
+      body: ${JSON.stringify(body)},
+    };
+
+    const response = await fetch(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.method === 'GET' ? undefined : request.body,
+      credentials: 'include',
+    });
+
+    return {
+      ok: response.ok,
+      status: response.status,
+      body: await response.text(),
+      finalUrl: response.url,
+    };
+  })()`);
+    return {
+        ok: Boolean(raw?.ok),
+        status: Number(raw?.status ?? 0),
+        body: String(raw?.body ?? ''),
+        finalUrl: String(raw?.finalUrl ?? url),
+    };
+}
+export async function callNotebooklmRpc(page, rpcId, params, options = {}) {
+    const auth = await getNotebooklmPageAuth(page);
+    const requestBody = buildNotebooklmRpcBody(rpcId, params, auth.csrfToken);
+    const url = `https://${NOTEBOOKLM_DOMAIN}/_/LabsTailwindUi/data/batchexecute` +
+        `?rpcids=${rpcId}&source-path=${encodeURIComponent(auth.sourcePath)}` +
+        `&hl=${encodeURIComponent(options.hl ?? 'en')}` +
+        `&f.sid=${encodeURIComponent(auth.sessionId)}&rt=c`;
+    const response = await fetchNotebooklmInPage(page, url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+        },
+        body: requestBody,
+    });
+    if (response.status === 401 || response.status === 403) {
+        throw new AuthRequiredError(NOTEBOOKLM_DOMAIN, `NotebookLM RPC returned auth error (${response.status})`);
+    }
+    if (!response.ok) {
+        throw new CliError('NOTEBOOKLM_RPC', `NotebookLM RPC request failed with HTTP ${response.status}`, 'Retry from the NotebookLM home page in an already logged-in Chrome session.');
+    }
+    return {
+        auth,
+        url,
+        requestBody,
+        response,
+        result: extractNotebooklmRpcResult(response.body, rpcId),
+    };
+}

package/dist/clis/notebooklm/rpc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/notebooklm/rpc.test.js

@@ -0,0 +1,105 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AuthRequiredError } from '../../errors.js';
+import { buildNotebooklmRpcBody, extractNotebooklmRpcResult, getNotebooklmPageAuth, parseNotebooklmChunkedResponse, } from './rpc.js';
+describe('notebooklm rpc transport', () => {
+    it('extracts auth tokens from the page html via page evaluation', async () => {
+        const page = {
+            evaluate: vi.fn(async (script) => {
+                expect(script).toContain('document.documentElement.innerHTML');
+                return {
+                    html: '<html>"SNlM0e":"csrf-123","FdrFJe":"sess-456"</html>',
+                    sourcePath: '/',
+                };
+            }),
+        };
+        await expect(getNotebooklmPageAuth(page)).resolves.toEqual({
+            csrfToken: 'csrf-123',
+            sessionId: 'sess-456',
+            sourcePath: '/',
+        });
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+    });
+    it('falls back to WIZ_global_data tokens when html regex data is missing', async () => {
+        const page = {
+            evaluate: vi.fn(async () => ({
+                html: '<html><body>NotebookLM</body></html>',
+                sourcePath: '/notebook/nb-demo',
+                readyState: 'complete',
+                csrfToken: 'csrf-wiz',
+                sessionId: 'sess-wiz',
+            })),
+        };
+        await expect(getNotebooklmPageAuth(page)).resolves.toEqual({
+            csrfToken: 'csrf-wiz',
+            sessionId: 'sess-wiz',
+            sourcePath: '/notebook/nb-demo',
+        });
+    });
+    it('retries token extraction once when the first probe returns no tokens', async () => {
+        const page = {
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({
+                html: '<html><body>Loading…</body></html>',
+                sourcePath: '/notebook/nb-demo',
+                readyState: 'interactive',
+                csrfToken: '',
+                sessionId: '',
+            })
+                .mockResolvedValueOnce({
+                html: '<html>"SNlM0e":"csrf-123","FdrFJe":"sess-456"</html>',
+                sourcePath: '/notebook/nb-demo',
+                readyState: 'complete',
+                csrfToken: '',
+                sessionId: '',
+            }),
+            wait: vi.fn(async () => undefined),
+        };
+        await expect(getNotebooklmPageAuth(page)).resolves.toEqual({
+            csrfToken: 'csrf-123',
+            sessionId: 'sess-456',
+            sourcePath: '/notebook/nb-demo',
+        });
+        expect(page.evaluate).toHaveBeenCalledTimes(2);
+    });
+    it('builds the rpc body with the expected notebooklm payload shape', () => {
+        const body = buildNotebooklmRpcBody('wXbhsf', [null, 1, null, [2]], 'csrf-123');
+        expect(body).toContain('f.req=');
+        expect(body).toContain('at=csrf-123');
+        expect(body.endsWith('&')).toBe(true);
+        expect(decodeURIComponent(body)).toContain('"[null,1,null,[2]]"');
+    });
+    it('parses chunked batchexecute responses into json chunks', () => {
+        const raw = `)]}'\n107\n[["wrb.fr","wXbhsf","[[[\\\"Notebook One\\\",null,\\\"nb1\\\",null,null,[null,false,null,null,null,[1704067200]]]]]"]]`;
+        const chunks = parseNotebooklmChunkedResponse(raw);
+        expect(chunks).toHaveLength(1);
+        expect(Array.isArray(chunks[0])).toBe(true);
+        expect(chunks[0]).toEqual([
+            [
+                'wrb.fr',
+                'wXbhsf',
+                '[[["Notebook One",null,"nb1",null,null,[null,false,null,null,null,[1704067200]]]]]',
+            ],
+        ]);
+    });
+    it('extracts the rpc payload from wrb.fr responses', () => {
+        const raw = `)]}'\n107\n[["wrb.fr","wXbhsf","[[[\\\"Notebook One\\\",null,\\\"nb1\\\",null,null,[null,false,null,null,null,[1704067200]]]]]"]]`;
+        const result = extractNotebooklmRpcResult(raw, 'wXbhsf');
+        expect(result).toEqual([
+            [
+                ['Notebook One', null, 'nb1', null, null, [null, false, null, null, null, [1704067200]]],
+            ],
+        ]);
+    });
+    it('classifies auth errors as AuthRequiredError', () => {
+        const raw = `)]}'\n25\n[["er",null,null,null,null,401,"generic"]]`;
+        expect(() => extractNotebooklmRpcResult(raw, 'wXbhsf')).toThrow(AuthRequiredError);
+        try {
+            extractNotebooklmRpcResult(raw, 'wXbhsf');
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(AuthRequiredError);
+            expect(error.domain).toBe('notebooklm.google.com');
+            expect(error.code).toBe('AUTH_REQUIRED');
+        }
+    });
+});