@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/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/vendor/opencli/dist/clis/notebooklm/list.d.ts

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

package/vendor/opencli/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/vendor/opencli/dist/clis/notebooklm/note-list.d.ts

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

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

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+import { EmptyResultError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { 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 requireNotebooklmSession(page);
+        const state = await getNotebooklmPageState(page);
+        if (state.kind !== 'notebook') {
+            throw new EmptyResultError('opencli notebooklm note-list', 'No NotebookLM notebook is open in the automation workspace. Run `opencli notebooklm open <notebook>` first.');
+        }
+        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/vendor/opencli/dist/clis/notebooklm/note-list.test.d.ts

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

package/vendor/opencli/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/vendor/opencli/dist/clis/notebooklm/notes-get.d.ts

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

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

@@ -0,0 +1,46 @@
+import { cli, Strategy } from '../../registry.js';
+import { EmptyResultError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { 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 requireNotebooklmSession(page);
+        const state = await getNotebooklmPageState(page);
+        if (state.kind !== 'notebook') {
+            throw new EmptyResultError('opencli notebooklm notes-get', 'No NotebookLM notebook is open in the automation workspace. Run `opencli notebooklm open <notebook>` first.');
+        }
+        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/vendor/opencli/dist/clis/notebooklm/notes-get.test.d.ts

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

package/vendor/opencli/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/vendor/opencli/dist/clis/notebooklm/open.d.ts

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

package/vendor/opencli/dist/clis/notebooklm/open.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError, EmptyResultError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { buildNotebooklmNotebookUrl, getNotebooklmPageState, parseNotebooklmNotebookTarget, readCurrentNotebooklm, requireNotebooklmSession, } from './utils.js';
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'open',
+    aliases: ['select'],
+    description: 'Open one NotebookLM notebook in the automation workspace by id or URL',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'notebook',
+            positional: true,
+            required: true,
+            help: 'Notebook id from list output, or a full NotebookLM notebook URL',
+        },
+    ],
+    columns: ['id', 'title', 'url', 'source'],
+    func: async (page, kwargs) => {
+        const notebookId = parseNotebooklmNotebookTarget(String(kwargs.notebook ?? ''));
+        await page.goto(buildNotebooklmNotebookUrl(notebookId));
+        await page.wait(2);
+        await requireNotebooklmSession(page);
+        const state = await getNotebooklmPageState(page);
+        if (state.kind !== 'notebook') {
+            throw new CliError('NOTEBOOKLM_OPEN_FAILED', `NotebookLM notebook "${notebookId}" did not open in the automation workspace`, 'Run `opencli notebooklm list -f json` first and pass a valid notebook id.');
+        }
+        if (state.notebookId !== notebookId) {
+            console.warn(`[notebooklm open] expected notebook "${notebookId}" but page reports "${state.notebookId}"; continuing`);
+        }
+        const current = await readCurrentNotebooklm(page);
+        if (!current) {
+            throw new EmptyResultError('opencli notebooklm open', 'NotebookLM notebook metadata was not found after navigation.');
+        }
+        return [current];
+    },
+});

package/vendor/opencli/dist/clis/notebooklm/open.test.d.ts

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

package/vendor/opencli/dist/clis/notebooklm/open.test.js

@@ -0,0 +1,63 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockGetNotebooklmPageState, mockReadCurrentNotebooklm, mockRequireNotebooklmSession, } = vi.hoisted(() => ({
+    mockGetNotebooklmPageState: vi.fn(),
+    mockReadCurrentNotebooklm: vi.fn(),
+    mockRequireNotebooklmSession: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        getNotebooklmPageState: mockGetNotebooklmPageState,
+        readCurrentNotebooklm: mockReadCurrentNotebooklm,
+        requireNotebooklmSession: mockRequireNotebooklmSession,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './open.js';
+describe('notebooklm open', () => {
+    const command = getRegistry().get('notebooklm/open');
+    beforeEach(() => {
+        mockGetNotebooklmPageState.mockReset();
+        mockReadCurrentNotebooklm.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,
+        });
+        mockReadCurrentNotebooklm.mockResolvedValue({
+            id: 'nb-demo',
+            title: 'Browser Automation',
+            url: 'https://notebooklm.google.com/notebook/nb-demo',
+            source: 'current-page',
+        });
+    });
+    it('opens a notebook by id in the automation workspace', async () => {
+        const page = {
+            goto: vi.fn(async () => { }),
+            wait: vi.fn(async () => { }),
+        };
+        const result = await command.func(page, { notebook: 'nb-demo' });
+        expect(page.goto).toHaveBeenCalledWith('https://notebooklm.google.com/notebook/nb-demo');
+        expect(result).toEqual([{
+                id: 'nb-demo',
+                title: 'Browser Automation',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'current-page',
+            }]);
+    });
+    it('accepts a full notebook url', async () => {
+        const page = {
+            goto: vi.fn(async () => { }),
+            wait: vi.fn(async () => { }),
+        };
+        await command.func(page, { notebook: 'https://notebooklm.google.com/notebook/nb-demo?pli=1' });
+        expect(page.goto).toHaveBeenCalledWith('https://notebooklm.google.com/notebook/nb-demo');
+    });
+});

package/vendor/opencli/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/vendor/opencli/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/vendor/opencli/dist/clis/notebooklm/rpc.test.d.ts

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