@jackwener/opencli 1.5.5 → 1.5.7

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');
+        }
+    });
+});

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

@@ -0,0 +1,87 @@
+export declare const NOTEBOOKLM_SITE = "notebooklm";
+export declare const NOTEBOOKLM_DOMAIN = "notebooklm.google.com";
+export declare const NOTEBOOKLM_HOME_URL = "https://notebooklm.google.com/";
+export type NotebooklmPageKind = 'notebook' | 'home' | 'unknown';
+export interface NotebooklmPageState {
+    url: string;
+    title: string;
+    hostname: string;
+    kind: NotebooklmPageKind;
+    notebookId: string;
+    loginRequired: boolean;
+    notebookCount: number;
+}
+export interface NotebooklmRow {
+    id: string;
+    title: string;
+    url: string;
+    source: 'current-page' | 'home-links' | 'rpc';
+    is_owner?: boolean;
+    created_at?: string | null;
+}
+export interface NotebooklmSourceRow {
+    id: string;
+    notebook_id: string;
+    title: string;
+    url: string;
+    source: 'current-page' | 'rpc';
+    type?: string | null;
+    type_code?: number | null;
+    size?: number | null;
+    created_at?: string | null;
+    updated_at?: string | null;
+}
+export interface NotebooklmSourceFulltextRow {
+    source_id: string;
+    notebook_id: string;
+    title: string;
+    kind?: string | null;
+    content: string;
+    char_count: number;
+    url?: string | null;
+    source: 'rpc';
+}
+export interface NotebooklmSourceGuideRow {
+    source_id: string;
+    notebook_id: string;
+    title: string;
+    type?: string | null;
+    summary: string;
+    keywords: string[];
+    source: 'rpc';
+}
+export interface NotebooklmNotebookDetailRow extends NotebooklmRow {
+    emoji?: string | null;
+    source_count?: number | null;
+    updated_at?: string | null;
+}
+export interface NotebooklmHistoryRow {
+    thread_id: string;
+    notebook_id: string;
+    item_count: number;
+    preview?: string | null;
+    url: string;
+    source: 'rpc';
+}
+export interface NotebooklmNoteRow {
+    notebook_id: string;
+    title: string;
+    created_at?: string | null;
+    url: string;
+    source: 'studio-list';
+}
+export interface NotebooklmSummaryRow {
+    notebook_id: string;
+    title: string;
+    summary: string;
+    url: string;
+    source: 'summary-dom' | 'rpc';
+}
+export interface NotebooklmNoteDetailRow {
+    notebook_id: string;
+    id?: string | null;
+    title: string;
+    content: string;
+    url: string;
+    source: 'studio-editor';
+}

package/dist/clis/notebooklm/shared.js

@@ -0,0 +1,3 @@
+export const NOTEBOOKLM_SITE = 'notebooklm';
+export const NOTEBOOKLM_DOMAIN = 'notebooklm.google.com';
+export const NOTEBOOKLM_HOME_URL = 'https://notebooklm.google.com/';

package/dist/clis/notebooklm/source-fulltext.d.ts

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

package/dist/clis/notebooklm/source-fulltext.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '../../registry.js';
+import { EmptyResultError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { ensureNotebooklmNotebookBinding, findNotebooklmSourceRow, getNotebooklmPageState, getNotebooklmSourceFulltextViaRpc, listNotebooklmSourcesFromPage, listNotebooklmSourcesViaRpc, requireNotebooklmSession, } from './utils.js';
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'source-fulltext',
+    description: 'Get the extracted fulltext for one source in the currently opened NotebookLM notebook',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'source',
+            positional: true,
+            required: true,
+            help: 'Source id or title from the current notebook',
+        },
+    ],
+    columns: ['title', 'kind', 'char_count', 'url', 'source'],
+    func: async (page, kwargs) => {
+        await ensureNotebooklmNotebookBinding(page);
+        await requireNotebooklmSession(page);
+        const state = await getNotebooklmPageState(page);
+        if (state.kind !== 'notebook') {
+            throw new EmptyResultError('opencli notebooklm source-fulltext', 'Open a specific NotebookLM notebook tab first, then retry.');
+        }
+        const rpcRows = await listNotebooklmSourcesViaRpc(page).catch(() => []);
+        const rows = rpcRows.length > 0 ? rpcRows : await listNotebooklmSourcesFromPage(page);
+        if (rows.length === 0) {
+            throw new EmptyResultError('opencli notebooklm source-fulltext', 'No NotebookLM sources were found on the current page.');
+        }
+        const query = typeof kwargs.source === 'string' ? kwargs.source : String(kwargs.source ?? '');
+        const matched = findNotebooklmSourceRow(rows, query);
+        if (!matched) {
+            throw new EmptyResultError('opencli notebooklm source-fulltext', `Source "${query}" was not found in the current notebook.`);
+        }
+        const fulltext = await getNotebooklmSourceFulltextViaRpc(page, matched.id).catch(() => null);
+        if (fulltext)
+            return [fulltext];
+        throw new EmptyResultError('opencli notebooklm source-fulltext', `NotebookLM fulltext was not available for source "${matched.title}".`);
+    },
+});

package/dist/clis/notebooklm/source-fulltext.test.d.ts

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

package/dist/clis/notebooklm/source-fulltext.test.js

@@ -0,0 +1,106 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockListNotebooklmSourcesViaRpc, mockListNotebooklmSourcesFromPage, mockGetNotebooklmSourceFulltextViaRpc, mockGetNotebooklmPageState, mockRequireNotebooklmSession, } = vi.hoisted(() => ({
+    mockListNotebooklmSourcesViaRpc: vi.fn(),
+    mockListNotebooklmSourcesFromPage: vi.fn(),
+    mockGetNotebooklmSourceFulltextViaRpc: vi.fn(),
+    mockGetNotebooklmPageState: vi.fn(),
+    mockRequireNotebooklmSession: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        listNotebooklmSourcesViaRpc: mockListNotebooklmSourcesViaRpc,
+        listNotebooklmSourcesFromPage: mockListNotebooklmSourcesFromPage,
+        getNotebooklmSourceFulltextViaRpc: mockGetNotebooklmSourceFulltextViaRpc,
+        getNotebooklmPageState: mockGetNotebooklmPageState,
+        requireNotebooklmSession: mockRequireNotebooklmSession,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './source-fulltext.js';
+describe('notebooklm source-fulltext', () => {
+    const command = getRegistry().get('notebooklm/source-fulltext');
+    beforeEach(() => {
+        mockListNotebooklmSourcesViaRpc.mockReset();
+        mockListNotebooklmSourcesFromPage.mockReset();
+        mockGetNotebooklmSourceFulltextViaRpc.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 fulltext for a source matched from rpc source rows', async () => {
+        mockListNotebooklmSourcesViaRpc.mockResolvedValue([
+            {
+                id: 'src-1',
+                notebook_id: 'nb-demo',
+                title: '粘贴的文字',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'rpc',
+                type: 'pasted-text',
+            },
+        ]);
+        mockGetNotebooklmSourceFulltextViaRpc.mockResolvedValue({
+            source_id: 'src-1',
+            notebook_id: 'nb-demo',
+            title: '粘贴的文字',
+            kind: 'generated-text',
+            content: '第一段\n第二段',
+            char_count: 7,
+            url: 'https://example.com/source',
+            source: 'rpc',
+        });
+        const result = await command.func({}, { source: 'src-1' });
+        expect(result).toEqual([
+            {
+                source_id: 'src-1',
+                notebook_id: 'nb-demo',
+                title: '粘贴的文字',
+                kind: 'generated-text',
+                content: '第一段\n第二段',
+                char_count: 7,
+                url: 'https://example.com/source',
+                source: 'rpc',
+            },
+        ]);
+    });
+    it('matches by title from dom rows when rpc source list is unavailable', async () => {
+        mockListNotebooklmSourcesViaRpc.mockResolvedValue([]);
+        mockListNotebooklmSourcesFromPage.mockResolvedValue([
+            {
+                id: 'src-1',
+                notebook_id: 'nb-demo',
+                title: '粘贴的文字',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'current-page',
+            },
+        ]);
+        mockGetNotebooklmSourceFulltextViaRpc.mockResolvedValue({
+            source_id: 'src-1',
+            notebook_id: 'nb-demo',
+            title: '粘贴的文字',
+            kind: 'generated-text',
+            content: '第一段\n第二段',
+            char_count: 7,
+            url: 'https://example.com/source',
+            source: 'rpc',
+        });
+        const result = await command.func({}, { source: '粘贴的文字' });
+        expect(result).toEqual([
+            expect.objectContaining({
+                source_id: 'src-1',
+                title: '粘贴的文字',
+                content: '第一段\n第二段',
+            }),
+        ]);
+    });
+});

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

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

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

@@ -0,0 +1,40 @@
+import { cli, Strategy } from '../../registry.js';
+import { EmptyResultError } from '../../errors.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { ensureNotebooklmNotebookBinding, findNotebooklmSourceRow, getNotebooklmPageState, listNotebooklmSourcesFromPage, listNotebooklmSourcesViaRpc, requireNotebooklmSession, } from './utils.js';
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'source-get',
+    description: 'Get one source from the currently opened NotebookLM notebook by id or title',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'source',
+            positional: true,
+            required: true,
+            help: 'Source id or title from the current notebook',
+        },
+    ],
+    columns: ['title', 'id', 'type', 'size', 'created_at', 'updated_at', 'url', 'source'],
+    func: async (page, kwargs) => {
+        await ensureNotebooklmNotebookBinding(page);
+        await requireNotebooklmSession(page);
+        const state = await getNotebooklmPageState(page);
+        if (state.kind !== 'notebook') {
+            throw new EmptyResultError('opencli notebooklm source-get', 'Open a specific NotebookLM notebook tab first, then retry.');
+        }
+        const rpcRows = await listNotebooklmSourcesViaRpc(page).catch(() => []);
+        const rows = rpcRows.length > 0 ? rpcRows : await listNotebooklmSourcesFromPage(page);
+        if (rows.length === 0) {
+            throw new EmptyResultError('opencli notebooklm source-get', 'No NotebookLM sources were found on the current page.');
+        }
+        const query = typeof kwargs.source === 'string' ? kwargs.source : String(kwargs.source ?? '');
+        const matched = findNotebooklmSourceRow(rows, query);
+        if (matched)
+            return [matched];
+        throw new EmptyResultError('opencli notebooklm source-get', `Source "${query}" was not found in the current notebook.`);
+    },
+});

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

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

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

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const { mockListNotebooklmSourcesViaRpc, mockListNotebooklmSourcesFromPage, mockGetNotebooklmPageState, mockRequireNotebooklmSession, } = vi.hoisted(() => ({
+    mockListNotebooklmSourcesViaRpc: vi.fn(),
+    mockListNotebooklmSourcesFromPage: vi.fn(),
+    mockGetNotebooklmPageState: vi.fn(),
+    mockRequireNotebooklmSession: vi.fn(),
+}));
+vi.mock('./utils.js', async () => {
+    const actual = await vi.importActual('./utils.js');
+    return {
+        ...actual,
+        getNotebooklmPageState: mockGetNotebooklmPageState,
+        listNotebooklmSourcesViaRpc: mockListNotebooklmSourcesViaRpc,
+        listNotebooklmSourcesFromPage: mockListNotebooklmSourcesFromPage,
+        requireNotebooklmSession: mockRequireNotebooklmSession,
+    };
+});
+import { getRegistry } from '../../registry.js';
+import './source-get.js';
+describe('notebooklm source-get', () => {
+    const command = getRegistry().get('notebooklm/source-get');
+    beforeEach(() => {
+        mockListNotebooklmSourcesViaRpc.mockReset();
+        mockListNotebooklmSourcesFromPage.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 a source by exact id from rpc results', async () => {
+        mockListNotebooklmSourcesViaRpc.mockResolvedValue([
+            {
+                id: 'src-1',
+                notebook_id: 'nb-demo',
+                title: 'Release Notes',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'rpc',
+                type: 'web',
+            },
+        ]);
+        const result = await command.func({}, { source: 'src-1' });
+        expect(result).toEqual([
+            {
+                id: 'src-1',
+                notebook_id: 'nb-demo',
+                title: 'Release Notes',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'rpc',
+                type: 'web',
+            },
+        ]);
+        expect(mockListNotebooklmSourcesFromPage).not.toHaveBeenCalled();
+    });
+    it('falls back to page results and matches by title when rpc is empty', async () => {
+        mockListNotebooklmSourcesViaRpc.mockResolvedValue([]);
+        mockListNotebooklmSourcesFromPage.mockResolvedValue([
+            {
+                id: 'Meeting Notes',
+                notebook_id: 'nb-demo',
+                title: 'Meeting Notes',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'current-page',
+            },
+        ]);
+        const result = await command.func({}, { source: 'meeting notes' });
+        expect(result).toEqual([
+            {
+                id: 'Meeting Notes',
+                notebook_id: 'nb-demo',
+                title: 'Meeting Notes',
+                url: 'https://notebooklm.google.com/notebook/nb-demo',
+                source: 'current-page',
+            },
+        ]);
+    });
+});