@jackwener/opencli 1.5.5 → 1.5.7

package/src/clis/notebooklm/history.test.ts

@@ -0,0 +1,70 @@
+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<typeof import('./utils.js')>('./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!({} as any, {});
+
+    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/src/clis/notebooklm/history.ts

@@ -0,0 +1,36 @@
+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,
+  listNotebooklmHistoryViaRpc,
+  requireNotebooklmSession,
+} from './utils.js';
+
+cli({
+  site: NOTEBOOKLM_SITE,
+  name: 'history',
+  description: 'List NotebookLM conversation history threads in the current notebook',
+  domain: NOTEBOOKLM_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [],
+  columns: ['thread_id', 'item_count', 'preview', 'source', 'notebook_id', '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 history',
+        'Open a specific NotebookLM notebook tab first, then retry.',
+      );
+    }
+
+    const rows = await listNotebooklmHistoryViaRpc(page);
+    return rows;
+  },
+});

package/src/clis/notebooklm/list.ts

@@ -0,0 +1,40 @@
+import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError } from '../../errors.js';
+import type { IPage } from '../../types.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: IPage) => {
+    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/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');
+    }
+  });
+});