@jackwener/opencli 1.5.6 → 1.5.8

package/src/clis/notebooklm/note-list.test.ts

@@ -0,0 +1,64 @@
+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<typeof import('./utils.js')>('./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!({} as any, {});
+
+    expect(result).toEqual([
+      {
+        notebook_id: 'nb-demo',
+        title: '新建笔记',
+        created_at: '6 分钟前',
+        url: 'https://notebooklm.google.com/notebook/nb-demo',
+        source: 'studio-list',
+      },
+    ]);
+  });
+});

package/src/clis/notebooklm/note-list.ts

@@ -0,0 +1,42 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.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: IPage) => {
+    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/src/clis/notebooklm/notes-get.test.ts

@@ -0,0 +1,88 @@
+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<typeof import('./utils.js')>('./utils.js');
+  return {
+    ...actual,
+    listNotebooklmNotesFromPage: mockListNotebooklmNotesFromPage,
+    readNotebooklmVisibleNoteFromPage: mockReadNotebooklmVisibleNoteFromPage,
+    getNotebooklmPageState: mockGetNotebooklmPageState,
+    requireNotebooklmSession: mockRequireNotebooklmSession,
+  };
+});
+
+import { getRegistry } from '../../registry.js';
+import { CliError } from '../../errors.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!({} as any, { 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!({} as any, { note: '新建笔记' })).rejects.toMatchObject({
+      hint: expect.stringMatching(/currently reads note content only from the visible note editor/i),
+    } satisfies Partial<CliError>);
+  });
+});

package/src/clis/notebooklm/notes-get.ts

@@ -0,0 +1,67 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.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: string, query: string): boolean {
+  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: IPage, 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/src/clis/notebooklm/rpc.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AuthRequiredError } from '../../errors.js';
+import type { IPage } from '../../types.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: string) => {
+        expect(script).toContain('document.documentElement.innerHTML');
+        return {
+          html: '<html>"SNlM0e":"csrf-123","FdrFJe":"sess-456"</html>',
+          sourcePath: '/',
+        };
+      }),
+    } as unknown as IPage;
+
+    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',
+      })),
+    } as unknown as IPage;
+
+    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),
+    } as unknown as IPage;
+
+    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 as AuthRequiredError).domain).toBe('notebooklm.google.com');
+      expect((error as AuthRequiredError).code).toBe('AUTH_REQUIRED');
+    }
+  });
+});

package/src/clis/notebooklm/rpc.ts

@@ -0,0 +1,286 @@
+import { AuthRequiredError, CliError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+import { NOTEBOOKLM_DOMAIN } from './shared.js';
+
+export type NotebooklmPageAuth = {
+  csrfToken: string;
+  sessionId: string;
+  sourcePath: string;
+};
+
+type NotebooklmAuthProbe = {
+  html: string;
+  sourcePath: string;
+  readyState: string;
+  csrfToken: string;
+  sessionId: 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 function extractNotebooklmPageAuthFromHtml(
+  html: string,
+  sourcePath: string = '/',
+  preferredTokens?: { csrfToken?: string; sessionId?: string },
+): NotebooklmPageAuth {
+  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: IPage): Promise<NotebooklmAuthProbe> {
+  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 : '',
+    };
+  })()`) as Partial<NotebooklmAuthProbe> | null;
+
+  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: IPage): Promise<NotebooklmPageAuth> {
+  let lastError: unknown;
+  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: string,
+  params: unknown[] | Record<string, unknown> | null,
+  csrfToken: string,
+): string {
+  const rpcRequest = [[[rpcId, JSON.stringify(params), null, 'generic']]];
+  return `f.req=${encodeURIComponent(JSON.stringify(rpcRequest))}&at=${encodeURIComponent(csrfToken)}&`;
+}
+
+export function stripNotebooklmAntiXssi(rawBody: string): string {
+  if (!rawBody.startsWith(")]}'")) return rawBody;
+  return rawBody.replace(/^\)\]\}'\r?\n/, '');
+}
+
+export function parseNotebooklmChunkedResponse(rawBody: string): unknown[] {
+  const cleaned = stripNotebooklmAntiXssi(rawBody).trim();
+  if (!cleaned) return [];
+
+  const lines = cleaned.split('\n');
+  const chunks: unknown[] = [];
+
+  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: string, rpcId: string): unknown {
+  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: IPage,
+  url: string,
+  options: {
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: string;
+  } = {},
+): Promise<NotebooklmFetchResponse> {
+  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,
+    };
+  })()`) as Partial<NotebooklmFetchResponse> | null;
+
+  return {
+    ok: Boolean(raw?.ok),
+    status: Number(raw?.status ?? 0),
+    body: String(raw?.body ?? ''),
+    finalUrl: String(raw?.finalUrl ?? url),
+  };
+}
+
+export async function callNotebooklmRpc(
+  page: IPage,
+  rpcId: string,
+  params: unknown[] | Record<string, unknown> | null,
+  options: {
+    hl?: string;
+  } = {},
+): Promise<NotebooklmRpcCallResult> {
+  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),
+  };
+}