@jackwener/opencli 1.5.5 → 1.5.7

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

package/src/clis/notebooklm/shared.ts

@@ -0,0 +1,98 @@
+export const NOTEBOOKLM_SITE = 'notebooklm';
+export const NOTEBOOKLM_DOMAIN = 'notebooklm.google.com';
+export 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/src/clis/notebooklm/source-fulltext.test.ts

@@ -0,0 +1,123 @@
+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<typeof import('./utils.js')>('./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!({} as any, { 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!({} as any, { source: '粘贴的文字' });
+
+    expect(result).toEqual([
+      expect.objectContaining({
+        source_id: 'src-1',
+        title: '粘贴的文字',
+        content: '第一段\n第二段',
+      }),
+    ]);
+  });
+});

package/src/clis/notebooklm/source-fulltext.ts

@@ -0,0 +1,69 @@
+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,
+  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: IPage, 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/src/clis/notebooklm/source-get.test.ts

@@ -0,0 +1,100 @@
+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<typeof import('./utils.js')>('./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!({} as any, { 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!({} as any, { 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',
+      },
+    ]);
+  });
+});