@jackwener/opencli 1.5.6 → 1.5.7

package/src/clis/instagram/download.ts

@@ -0,0 +1,286 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { ArgumentError, AuthRequiredError, CliError, CommandExecutionError, EXIT_CODES } from '../../errors.js';
+import { httpDownload } from '../../download/index.js';
+import type { IPage } from '../../types.js';
+
+const INSTAGRAM_GRAPHQL_DOC_ID = '8845758582119845';
+const INSTAGRAM_GRAPHQL_APP_ID = '936619743392459';
+const INSTAGRAM_HOST_SUFFIX = 'instagram.com';
+const SUPPORTED_KINDS = new Set(['p', 'reel', 'tv']);
+
+export interface InstagramMediaTarget {
+  kind: 'p' | 'reel' | 'tv';
+  shortcode: string;
+  canonicalUrl: string;
+}
+
+interface InstagramPageMediaItem {
+  type: 'image' | 'video';
+  url: string;
+}
+
+interface InstagramFetchResult {
+  ok: boolean;
+  shortcode?: string;
+  owner?: string;
+  items?: InstagramPageMediaItem[];
+  errorCode?: string;
+  error?: string;
+}
+
+interface DownloadedMediaItem extends InstagramPageMediaItem {
+  filename: string;
+}
+
+function displayPath(filePath: string): string {
+  const home = os.homedir();
+  return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}
+
+
+export function parseInstagramMediaTarget(input: string): InstagramMediaTarget {
+  const raw = String(input || '').trim();
+  if (!raw) {
+    throw new ArgumentError(
+      'Instagram URL is required',
+      'Expected https://www.instagram.com/p/... or https://www.instagram.com/reel/...',
+    );
+  }
+
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new ArgumentError(
+      `Invalid Instagram URL: ${raw}`,
+      'Expected https://www.instagram.com/p/<shortcode>/ or /reel/<shortcode>/',
+    );
+  }
+
+  if (!['http:', 'https:'].includes(url.protocol)) {
+    throw new ArgumentError(`Unsupported URL protocol: ${url.protocol}`);
+  }
+
+  const host = url.hostname.toLowerCase();
+  if (host !== INSTAGRAM_HOST_SUFFIX && !host.endsWith(`.${INSTAGRAM_HOST_SUFFIX}`)) {
+    throw new ArgumentError(`Unsupported host: ${host}`, 'Only instagram.com URLs are supported');
+  }
+
+  const segments = url.pathname.split('/').filter(Boolean);
+  let kind: string | undefined;
+  let shortcode: string | undefined;
+
+  if (segments.length >= 2 && SUPPORTED_KINDS.has(segments[0]!)) {
+    kind = segments[0];
+    shortcode = segments[1];
+  } else if (segments.length >= 3 && SUPPORTED_KINDS.has(segments[1]!)) {
+    kind = segments[1];
+    shortcode = segments[2];
+  }
+
+  if (!kind || !shortcode) {
+    throw new ArgumentError(
+      `Unsupported Instagram media URL: ${raw}`,
+      'Only /p/<shortcode>/, /reel/<shortcode>/, and /tv/<shortcode>/ links are supported',
+    );
+  }
+
+  return {
+    kind: kind as 'p' | 'reel' | 'tv',
+    shortcode,
+    canonicalUrl: `https://www.instagram.com/${kind}/${shortcode}/`,
+  };
+}
+
+export function buildInstagramDownloadItems(shortcode: string, items: InstagramPageMediaItem[]): DownloadedMediaItem[] {
+  return items
+    .filter((item) => item?.url)
+    .map((item, index) => {
+      const fallbackExt = item.type === 'video' ? '.mp4' : '.jpg';
+      let ext = fallbackExt;
+
+      try {
+        const pathname = new URL(item.url).pathname;
+        const candidateExt = path.extname(pathname).toLowerCase();
+        if (candidateExt && candidateExt.length <= 8) ext = candidateExt;
+      } catch {
+        ext = fallbackExt;
+      }
+
+      return {
+        type: item.type,
+        url: item.url,
+        filename: `${shortcode}_${String(index + 1).padStart(2, '0')}${ext}`,
+      };
+    });
+}
+
+export function buildInstagramFetchScript(shortcode: string): string {
+  return `
+    (async () => {
+      const shortcode = ${JSON.stringify(shortcode)};
+      const docId = ${JSON.stringify(INSTAGRAM_GRAPHQL_DOC_ID)};
+      const variables = {
+        shortcode,
+        fetch_tagged_user_count: null,
+        hoisted_comment_id: null,
+        hoisted_reply_id: null,
+      };
+      const url = 'https://www.instagram.com/graphql/query/?doc_id=' + docId + '&variables=' + encodeURIComponent(JSON.stringify(variables));
+      const res = await fetch(url, {
+        credentials: 'include',
+        headers: {
+          'Accept': 'application/json,text/plain,*/*',
+          'X-IG-App-ID': ${JSON.stringify(INSTAGRAM_GRAPHQL_APP_ID)},
+        },
+      });
+      const rawText = await res.text();
+
+      let data = null;
+      try {
+        data = rawText ? JSON.parse(rawText) : null;
+      } catch {
+        return {
+          ok: false,
+          errorCode: 'COMMAND_EXEC',
+          error: 'Instagram returned non-JSON content while fetching media metadata',
+        };
+      }
+
+      const message = typeof data?.message === 'string' ? data.message : '';
+      const lowered = (message || '').toLowerCase();
+
+      if (!res.ok) {
+        if (res.status === 401 || res.status === 403 || data?.require_login) {
+          return { ok: false, errorCode: 'AUTH_REQUIRED', error: message || ('HTTP ' + res.status) };
+        }
+        if (res.status === 429) {
+          return { ok: false, errorCode: 'RATE_LIMITED', error: message || 'HTTP 429' };
+        }
+        if (res.status === 404 || res.status === 410) {
+          return { ok: false, errorCode: 'PRIVATE_OR_UNAVAILABLE', error: message || ('HTTP ' + res.status) };
+        }
+        return { ok: false, errorCode: 'COMMAND_EXEC', error: message || ('HTTP ' + res.status) };
+      }
+
+      if (data?.require_login) {
+        return { ok: false, errorCode: 'AUTH_REQUIRED', error: message || 'Instagram login required' };
+      }
+      if (lowered.includes('wait a few minutes') || lowered.includes('rate')) {
+        return { ok: false, errorCode: 'RATE_LIMITED', error: message || 'Instagram rate limit triggered' };
+      }
+
+      const media = data?.data?.xdt_shortcode_media;
+      if (!media) {
+        return {
+          ok: false,
+          errorCode: 'PRIVATE_OR_UNAVAILABLE',
+          error: message || 'Post may be private, unavailable, or inaccessible to the current browser session',
+        };
+      }
+
+      const nodes = Array.isArray(media?.edge_sidecar_to_children?.edges) && media.edge_sidecar_to_children.edges.length > 0
+        ? media.edge_sidecar_to_children.edges.map((edge) => edge?.node).filter(Boolean)
+        : [media];
+
+      const items = nodes
+        .map((node) => ({
+          type: node?.is_video ? 'video' : 'image',
+          url: String(node?.is_video ? (node?.video_url || '') : (node?.display_url || '')),
+        }))
+        .filter((item) => item.url);
+
+      return {
+        ok: true,
+        shortcode: media.shortcode || shortcode,
+        owner: media?.owner?.username || '',
+        items,
+      };
+    })()
+  `;
+}
+
+function ensurePage(page: IPage | null): IPage {
+  if (!page) throw new CommandExecutionError('Browser session required');
+  return page;
+}
+
+function normalizeFetchResult(result: unknown): InstagramFetchResult {
+  if (!result || typeof result !== 'object') {
+    throw new CommandExecutionError('Failed to fetch Instagram media metadata');
+  }
+  return result as InstagramFetchResult;
+}
+
+function handleFetchFailure(result: InstagramFetchResult): never {
+  const message = result.error || 'Instagram media fetch failed';
+
+  if (result.errorCode === 'AUTH_REQUIRED') {
+    throw new AuthRequiredError('instagram.com', message);
+  }
+  if (result.errorCode === 'RATE_LIMITED') {
+    throw new CliError(
+      'RATE_LIMITED',
+      message,
+      'Wait a few minutes and retry, or switch to a browser session with a warmer Instagram login state.',
+      EXIT_CODES.TEMPFAIL,
+    );
+  }
+  if (result.errorCode === 'PRIVATE_OR_UNAVAILABLE') {
+    throw new CommandExecutionError(message, 'Open the post in a logged-in browser session and retry');
+  }
+
+  throw new CommandExecutionError(message);
+}
+
+async function downloadInstagramMedia(items: DownloadedMediaItem[], outputDir: string): Promise<void> {
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  for (const item of items) {
+    const destPath = path.join(outputDir, item.filename);
+    const result = await httpDownload(item.url, destPath, {
+      timeout: item.type === 'video' ? 120000 : 60000,
+    });
+
+    if (!result.success) {
+      throw new CommandExecutionError(`Failed to download ${item.filename}: ${result.error || 'unknown error'}`);
+    }
+  }
+}
+
+cli({
+  site: 'instagram',
+  name: 'download',
+  description: 'Download images and videos from Instagram posts and reels',
+  domain: 'www.instagram.com',
+  strategy: Strategy.COOKIE,
+  navigateBefore: false,
+  args: [
+    { name: 'url', positional: true, required: true, help: 'Instagram post / reel / tv URL' },
+    { name: 'path', default: path.join(os.homedir(), 'Downloads', 'Instagram'), help: 'Download directory' },
+  ],
+  func: async (page, kwargs) => {
+    const browserPage = ensurePage(page);
+    const target = parseInstagramMediaTarget(String(kwargs.url ?? ''));
+    const outputRoot = String(kwargs.path ?? path.join(os.homedir(), 'Downloads', 'Instagram'));
+
+    await browserPage.goto(target.canonicalUrl);
+
+    const fetchResult = normalizeFetchResult(await browserPage.evaluate(buildInstagramFetchScript(target.shortcode)));
+    if (!fetchResult.ok) handleFetchFailure(fetchResult);
+
+    const shortcode = fetchResult.shortcode || target.shortcode;
+    const mediaItems = buildInstagramDownloadItems(shortcode, fetchResult.items || []);
+    if (mediaItems.length === 0) {
+      throw new CommandExecutionError('No downloadable media found');
+    }
+
+    const savedDir = path.join(outputRoot, shortcode);
+    await downloadInstagramMedia(mediaItems, savedDir);
+    console.log(`📁 saved: ${displayPath(savedDir)}`);
+    return null;
+  },
+});

package/src/clis/notebooklm/bind-current.test.ts

@@ -0,0 +1,43 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockBindCurrentTab } = vi.hoisted(() => ({
+  mockBindCurrentTab: vi.fn(),
+}));
+
+vi.mock('../../browser/daemon-client.js', () => ({
+  bindCurrentTab: mockBindCurrentTab,
+}));
+
+import { getRegistry } from '../../registry.js';
+import './bind-current.js';
+
+describe('notebooklm bind-current', () => {
+  const command = getRegistry().get('notebooklm/bind-current');
+
+  beforeEach(() => {
+    mockBindCurrentTab.mockReset();
+  });
+
+  it('binds the current notebook tab into site:notebooklm', async () => {
+    mockBindCurrentTab.mockResolvedValue({
+      workspace: 'site:notebooklm',
+      tabId: 123,
+      title: 'Bound Notebook',
+      url: 'https://notebooklm.google.com/notebook/nb-live',
+    });
+
+    const result = await command!.func!({} as any, {});
+
+    expect(mockBindCurrentTab).toHaveBeenCalledWith('site:notebooklm', {
+      matchDomain: 'notebooklm.google.com',
+      matchPathPrefix: '/notebook/',
+    });
+    expect(result).toEqual([{
+      workspace: 'site:notebooklm',
+      tab_id: 123,
+      notebook_id: 'nb-live',
+      title: 'Bound Notebook',
+      url: 'https://notebooklm.google.com/notebook/nb-live',
+    }]);
+  });
+});

package/src/clis/notebooklm/bind-current.ts

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '../../registry.js';
+import { bindCurrentTab } from '../../browser/daemon-client.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { parseNotebooklmIdFromUrl } from './utils.js';
+
+cli({
+  site: NOTEBOOKLM_SITE,
+  name: 'bind-current',
+  aliases: ['use'],
+  description: 'Bind the current active NotebookLM notebook tab into the site:notebooklm workspace',
+  domain: NOTEBOOKLM_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [],
+  columns: ['workspace', 'tab_id', 'notebook_id', 'title', 'url'],
+  func: async () => {
+    const result = await bindCurrentTab(`site:${NOTEBOOKLM_SITE}`, {
+      matchDomain: NOTEBOOKLM_DOMAIN,
+      matchPathPrefix: '/notebook/',
+    }) as {
+      tabId?: number;
+      workspace?: string;
+      title?: string;
+      url?: string;
+    };
+
+    return [{
+      workspace: result.workspace ?? `site:${NOTEBOOKLM_SITE}`,
+      tab_id: result.tabId ?? null,
+      notebook_id: result.url ? parseNotebooklmIdFromUrl(result.url) : '',
+      title: result.title ?? '',
+      url: result.url ?? '',
+    }];
+  },
+});

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

@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockBindCurrentTab } = vi.hoisted(() => ({
+  mockBindCurrentTab: vi.fn(),
+}));
+
+vi.mock('../../browser/daemon-client.js', () => ({
+  bindCurrentTab: mockBindCurrentTab,
+}));
+
+import { ensureNotebooklmNotebookBinding } from './utils.js';
+
+describe('notebooklm automatic binding', () => {
+  const originalEndpoint = process.env.OPENCLI_CDP_ENDPOINT;
+
+  beforeEach(() => {
+    mockBindCurrentTab.mockReset();
+    if (originalEndpoint === undefined) delete process.env.OPENCLI_CDP_ENDPOINT;
+    else process.env.OPENCLI_CDP_ENDPOINT = originalEndpoint;
+  });
+
+  it('does nothing when the current page is already a notebook page', async () => {
+    const page = {
+      getCurrentUrl: async () => 'https://notebooklm.google.com/notebook/nb-demo',
+    };
+
+    await expect(ensureNotebooklmNotebookBinding(page as any)).resolves.toBe(false);
+    expect(mockBindCurrentTab).not.toHaveBeenCalled();
+  });
+
+  it('best-effort binds a notebook page through the browser bridge when currently on home', async () => {
+    const page = {
+      getCurrentUrl: async () => 'https://notebooklm.google.com/',
+    };
+
+    mockBindCurrentTab.mockResolvedValue({});
+    await expect(ensureNotebooklmNotebookBinding(page as any)).resolves.toBe(true);
+    expect(mockBindCurrentTab).toHaveBeenCalledWith('site:notebooklm', {
+      matchDomain: 'notebooklm.google.com',
+      matchPathPrefix: '/notebook/',
+    });
+  });
+
+  it('skips daemon binding in direct CDP mode', async () => {
+    process.env.OPENCLI_CDP_ENDPOINT = 'ws://127.0.0.1:9222/devtools/page/1';
+    const page = {
+      getCurrentUrl: async () => 'https://notebooklm.google.com/',
+    };
+
+    await expect(ensureNotebooklmNotebookBinding(page as any)).resolves.toBe(false);
+    expect(mockBindCurrentTab).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './bind-current.js';
+import './get.js';
+import './note-list.js';
+
+describe('notebooklm compatibility aliases', () => {
+  it('registers use as a compatibility alias for bind-current', () => {
+    expect(getRegistry().get('notebooklm/use')).toBe(getRegistry().get('notebooklm/bind-current'));
+  });
+
+  it('registers metadata as a compatibility alias for get', () => {
+    expect(getRegistry().get('notebooklm/metadata')).toBe(getRegistry().get('notebooklm/get'));
+  });
+
+  it('registers notes-list as a compatibility alias for note-list', () => {
+    expect(getRegistry().get('notebooklm/notes-list')).toBe(getRegistry().get('notebooklm/note-list'));
+  });
+});

package/src/clis/notebooklm/current.ts

@@ -0,0 +1,38 @@
+import { cli, Strategy } from '../../registry.js';
+import { EmptyResultError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { ensureNotebooklmNotebookBinding, getNotebooklmPageState, readCurrentNotebooklm, requireNotebooklmSession } from './utils.js';
+
+cli({
+  site: NOTEBOOKLM_SITE,
+  name: 'current',
+  description: 'Show metadata for the currently opened NotebookLM notebook tab',
+  domain: NOTEBOOKLM_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [],
+  columns: ['id', 'title', 'url', 'source'],
+  func: async (page: IPage) => {
+    await ensureNotebooklmNotebookBinding(page);
+    await requireNotebooklmSession(page);
+    const state = await getNotebooklmPageState(page);
+    if (state.kind !== 'notebook') {
+      throw new EmptyResultError(
+        'opencli notebooklm current',
+        'Open a specific NotebookLM notebook tab first, then retry.',
+      );
+    }
+
+    const current = await readCurrentNotebooklm(page);
+    if (!current) {
+      throw new EmptyResultError(
+        'opencli notebooklm current',
+        'NotebookLM notebook metadata was not found on the current page.',
+      );
+    }
+
+    return [current];
+  },
+});

package/src/clis/notebooklm/get.ts

@@ -0,0 +1,53 @@
+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,
+  getNotebooklmDetailViaRpc,
+  getNotebooklmPageState,
+  readCurrentNotebooklm,
+  requireNotebooklmSession,
+} from './utils.js';
+
+cli({
+  site: NOTEBOOKLM_SITE,
+  name: 'get',
+  aliases: ['metadata'],
+  description: 'Get rich metadata for the currently opened NotebookLM notebook',
+  domain: NOTEBOOKLM_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [],
+  columns: ['id', 'title', 'emoji', 'source_count', 'created_at', 'updated_at', 'url', 'source'],
+  func: async (page: IPage) => {
+    await ensureNotebooklmNotebookBinding(page);
+    await requireNotebooklmSession(page);
+    const state = await getNotebooklmPageState(page);
+    if (state.kind !== 'notebook') {
+      throw new EmptyResultError(
+        'opencli notebooklm get',
+        'Open a specific NotebookLM notebook tab first, then retry.',
+      );
+    }
+
+    const rpcRow = await getNotebooklmDetailViaRpc(page).catch(() => null);
+    if (rpcRow) return [rpcRow];
+
+    const current = await readCurrentNotebooklm(page);
+    if (!current) {
+      throw new EmptyResultError(
+        'opencli notebooklm get',
+        'NotebookLM notebook metadata was not found on the current page.',
+      );
+    }
+
+    return [{
+      ...current,
+      emoji: null,
+      source_count: null,
+      updated_at: null,
+    }];
+  },
+});

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