@jackwener/opencli 1.7.22 → 1.8.1

package/clis/notebooklm/add-source.js

@@ -0,0 +1,269 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { callNotebooklmRpc } from './rpc.js';
+import { buildNotebooklmNotebookUrl, ensureNotebooklmHome, getNotebooklmAuthuser, parseNotebooklmNotebookTarget, requireNotebooklmExecute, requireNotebooklmSession, verifyNotebooklmSourceAdded } from './utils.js';
+
+const NOTEBOOKLM_ADD_SOURCES_RPC_ID = 'izAoDd';
+const NOTEBOOKLM_ADD_FILE_SOURCE_RPC_ID = 'o4cbdc';
+const MAX_TEXT_SOURCE_BYTES = 10 * 1024 * 1024;
+const MAX_FILE_SOURCE_BYTES = 50 * 1024 * 1024;
+const SOURCE_UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+
+const MIME_BY_EXT = {
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.markdown': 'text/markdown',
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.csv': 'text/csv',
+    '.json': 'application/json',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.doc': 'application/msword',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.epub': 'application/epub+zip',
+    '.mp3': 'audio/mpeg',
+    '.m4a': 'audio/mp4',
+    '.wav': 'audio/wav',
+};
+
+export function inferMimeType(filename, override) {
+    if (override) return String(override);
+    const ext = path.extname(filename).toLowerCase();
+    return MIME_BY_EXT[ext] || 'application/octet-stream';
+}
+
+export function readFileForUpload(filePath) {
+    const abs = path.resolve(filePath);
+    let stat;
+    try {
+        stat = fs.statSync(abs);
+    } catch {
+        throw new ArgumentError(`--file path does not exist: ${filePath}`);
+    }
+    if (!stat.isFile()) {
+        throw new ArgumentError(`--file path is not a regular file: ${filePath}`);
+    }
+    if (stat.size > MAX_FILE_SOURCE_BYTES) {
+        throw new ArgumentError(`--file exceeds ${MAX_FILE_SOURCE_BYTES} bytes (got ${stat.size}); use a smaller file or upload via the NotebookLM UI for now.`);
+    }
+    const buf = fs.readFileSync(abs);
+    return { base64: buf.toString('base64'), filename: path.basename(abs), size: stat.size };
+}
+
+export function buildRegisterFileSourceArgs(projectId, filename) {
+    return [
+        [[filename]],
+        projectId,
+        [2],
+        [1, null, null, null, null, null, null, null, null, null, [1]],
+    ];
+}
+
+export function parseSourceUrl(value) {
+    const url = String(value ?? '').trim();
+    if (!url) return '';
+    let parsed;
+    try {
+        parsed = new URL(url);
+    } catch {
+        throw new ArgumentError(`Invalid source URL: "${url}"`, 'URL must be a valid http:// or https:// URL.');
+    }
+    if ((parsed.protocol !== 'http:' && parsed.protocol !== 'https:') || !parsed.hostname) {
+        throw new ArgumentError(`Invalid source URL: "${url}"`, 'URL must start with http:// or https://.');
+    }
+    return parsed.toString();
+}
+
+export function parseSourceText(value) {
+    if (value === undefined || value === null) return null;
+    const text = String(value);
+    if (!text.trim()) throw new ArgumentError('--content must not be empty');
+    if (text.length > MAX_TEXT_SOURCE_BYTES) {
+        throw new ArgumentError(`--content exceeds ${MAX_TEXT_SOURCE_BYTES} bytes; split into smaller sources or upload as a file.`);
+    }
+    return text;
+}
+
+export function parseSourceTitle(value, fallback) {
+    const title = String(value ?? '').trim();
+    return title || fallback;
+}
+
+export function buildAddSourceFromUrlArgs(projectId, url) {
+    return [[[null, null, [url]]], projectId];
+}
+
+export function buildAddSourceFromTextArgs(projectId, title, content) {
+    return [[[null, [title, content], null, 2]], projectId];
+}
+
+function toExcludedUuidSet(excludedIds) {
+    return new Set(excludedIds.map((id) => String(id ?? '').toLowerCase()).filter(Boolean));
+}
+
+export function parseAddSourceResult(result, excludedIds = []) {
+    const excluded = toExcludedUuidSet(excludedIds);
+    if (typeof result === 'string') return SOURCE_UUID_RE.test(result) && !excluded.has(result.toLowerCase()) ? result : '';
+    if (!Array.isArray(result) && (typeof result !== 'object' || result === null)) return '';
+    const stack = [result];
+    while (stack.length) {
+        const node = stack.shift();
+        if (typeof node === 'string') {
+            if (SOURCE_UUID_RE.test(node) && !excluded.has(node.toLowerCase())) return node;
+            continue;
+        }
+        if (Array.isArray(node)) {
+            for (const child of node) stack.push(child);
+            continue;
+        }
+        if (node && typeof node === 'object') {
+            for (const value of Object.values(node)) stack.push(value);
+        }
+    }
+    return '';
+}
+
+async function uploadFileViaDriveResumable(page, projectId, sourceId, filename, base64, size) {
+    const authuser = getNotebooklmAuthuser() || '0';
+    const metadataJson = `{"PROJECT_ID":${JSON.stringify(projectId)},"SOURCE_NAME":${JSON.stringify(filename)},"SOURCE_ID":${JSON.stringify(sourceId)}}`;
+    const script = String.raw`(async () => {
+    try {
+      const initRes = await fetch(${JSON.stringify('https://notebooklm.google.com/upload/_/?authuser=' + authuser)}, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
+          'X-Goog-Upload-Command': 'start',
+          'X-Goog-Upload-Protocol': 'resumable',
+          'X-Goog-Upload-Header-Content-Length': ${JSON.stringify(String(size))},
+          'X-Goog-AuthUser': ${JSON.stringify(authuser)},
+        },
+        body: ${JSON.stringify(metadataJson)},
+      });
+      if (!initRes.ok) {
+        const status = initRes.headers.get('X-Goog-Upload-Status') || '';
+        const text = (await initRes.text()).slice(0, 400);
+        return { error: 'init failed HTTP ' + initRes.status + (status ? ' upload-status=' + status : '') + (text ? ' body=' + text : '') };
+      }
+      const uploadURL = initRes.headers.get('X-Goog-Upload-Url') || initRes.headers.get('x-goog-upload-url');
+      if (!uploadURL) return { error: 'no X-Goog-Upload-URL header in init response' };
+      // Decode base64 to Uint8Array for binary PUT
+      const bin = atob(${JSON.stringify(base64)});
+      const bytes = new Uint8Array(bin.length);
+      for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+      const uploadRes = await fetch(uploadURL, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
+          'X-Goog-Upload-Command': 'upload, finalize',
+          'X-Goog-Upload-Offset': '0',
+          'X-Goog-AuthUser': ${JSON.stringify(authuser)},
+        },
+        body: bytes,
+      });
+      if (!uploadRes.ok) {
+        const status = uploadRes.headers.get('X-Goog-Upload-Status') || '';
+        const text = (await uploadRes.text()).slice(0, 400);
+        return { error: 'upload failed HTTP ' + uploadRes.status + (status ? ' upload-status=' + status : '') + (text ? ' body=' + text : '') };
+      }
+      return { ok: true, status: uploadRes.status };
+    } catch (e) {
+      return { error: 'upload exception: ' + ((e && e.message) || String(e)) };
+    }
+  })()`;
+    const raw = await page.evaluate(script);
+    const result = raw && typeof raw === 'object' && 'data' in raw && 'session' in raw ? raw.data : raw;
+    if (!result || result.error) {
+        throw new CommandExecutionError('NotebookLM file upload failed: ' + (result?.error || 'unknown error'));
+    }
+    return result;
+}
+
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'add-source',
+    access: 'write',
+    description: 'Add a URL, text, or local file source to an existing NotebookLM notebook',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'notebook', positional: true, required: true, help: 'Notebook id from `notebooklm list` or full notebook URL' },
+        { name: 'url', help: 'Source URL to add (http/https). Pass exactly one of --url, --content, --file.' },
+        { name: 'content', help: 'Raw text content to add as a Text source (max 10 MB).' },
+        { name: 'file', help: `Local file path to upload as a source (max ${MAX_FILE_SOURCE_BYTES} bytes; pdf / txt / md / html / docx / etc.). Uses Google Drive's 3-step resumable upload protocol.` },
+        { name: 'title', help: 'Title for the text source (default "Text Source"). Ignored for --url and --file.' },
+        { name: 'mime-type', help: 'Override the auto-detected MIME type when --file is given.' },
+        { name: 'execute', type: 'boolean', help: 'Actually add the remote source to the NotebookLM notebook' },
+    ],
+    columns: ['notebook_id', 'source_id', 'kind', 'identifier', 'notebook_url'],
+    func: async (page, kwargs) => {
+        const notebookId = parseNotebooklmNotebookTarget(String(kwargs.notebook ?? ''));
+        const url = parseSourceUrl(kwargs.url);
+        const content = parseSourceText(kwargs.content);
+        const filePath = typeof kwargs.file === 'string' && kwargs.file.trim() ? kwargs.file.trim() : '';
+        const modes = [url ? 'url' : '', content !== null ? 'text' : '', filePath ? 'file' : ''].filter(Boolean);
+        if (modes.length === 0) {
+            throw new ArgumentError('Pass exactly one of --url <url>, --content <text>, or --file <path>');
+        }
+        if (modes.length > 1) {
+            throw new ArgumentError('Pass exactly one of --url, --content, --file (got: ' + modes.join(' + ') + ')');
+        }
+        requireNotebooklmExecute(kwargs.execute, 'add a NotebookLM source');
+        const title = parseSourceTitle(kwargs.title, 'Text Source');
+        await ensureNotebooklmHome(page);
+        await requireNotebooklmSession(page);
+        if (filePath) {
+            const file = readFileForUpload(filePath);
+            const mime = inferMimeType(file.filename, kwargs['mime-type']);
+            const registerRpc = await callNotebooklmRpc(page, NOTEBOOKLM_ADD_FILE_SOURCE_RPC_ID, buildRegisterFileSourceArgs(notebookId, file.filename));
+            const sourceId = parseAddSourceResult(registerRpc.result, [notebookId]);
+            if (!sourceId) {
+                throw new CommandExecutionError('NotebookLM AddFileSource (o4cbdc) RPC returned no source id; cannot start file upload.');
+            }
+            await uploadFileViaDriveResumable(page, notebookId, sourceId, file.filename, file.base64, file.size);
+            await verifyNotebooklmSourceAdded(page, notebookId, sourceId, 'add-source --file');
+            return [{
+                notebook_id: notebookId,
+                source_id: sourceId,
+                kind: 'file',
+                identifier: `${file.filename} (${mime}, ${file.size} bytes)`,
+                notebook_url: buildNotebooklmNotebookUrl(notebookId),
+            }];
+        }
+        const args = url
+            ? buildAddSourceFromUrlArgs(notebookId, url)
+            : buildAddSourceFromTextArgs(notebookId, title, content);
+        const rpc = await callNotebooklmRpc(page, NOTEBOOKLM_ADD_SOURCES_RPC_ID, args);
+        const sourceId = parseAddSourceResult(rpc.result, [notebookId]);
+        if (!sourceId) {
+            throw new CommandExecutionError('NotebookLM AddSources RPC returned no source id; verify the input reaches the NotebookLM backend.');
+        }
+        await verifyNotebooklmSourceAdded(page, notebookId, sourceId, `add-source --${url ? 'url' : 'content'}`);
+        return [{
+            notebook_id: notebookId,
+            source_id: sourceId,
+            kind: url ? 'url' : 'text',
+            identifier: url || title,
+            notebook_url: buildNotebooklmNotebookUrl(notebookId),
+        }];
+    },
+});
+
+export const __test__ = {
+    parseSourceUrl,
+    parseSourceText,
+    parseSourceTitle,
+    inferMimeType,
+    buildAddSourceFromUrlArgs,
+    buildAddSourceFromTextArgs,
+    buildRegisterFileSourceArgs,
+    readFileForUpload,
+    parseAddSourceResult,
+};

package/clis/notebooklm/add-source.test.js

@@ -0,0 +1,97 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './add-source.js';
+
+const {
+    parseSourceUrl,
+    parseSourceText,
+    parseSourceTitle,
+    buildAddSourceFromUrlArgs,
+    buildAddSourceFromTextArgs,
+    parseAddSourceResult,
+} = __test__;
+
+describe('notebooklm add-source', () => {
+    it('parseSourceUrl accepts http and https URLs', () => {
+        expect(parseSourceUrl('https://en.wikipedia.org/wiki/Reti_Opening'))
+            .toBe('https://en.wikipedia.org/wiki/Reti_Opening');
+        expect(parseSourceUrl('  http://example.com/page  ')).toBe('http://example.com/page');
+    });
+
+    it('parseSourceUrl returns empty string for unset, rejects bad schemes', () => {
+        expect(parseSourceUrl('')).toBe('');
+        expect(parseSourceUrl(undefined)).toBe('');
+        expect(parseSourceUrl('   ')).toBe('');
+        expect(() => parseSourceUrl('ftp://example.com')).toThrow(ArgumentError);
+        expect(() => parseSourceUrl('javascript:alert(1)')).toThrow(ArgumentError);
+        expect(() => parseSourceUrl('https://')).toThrow(ArgumentError);
+    });
+
+    it('parseSourceText returns the content for non-empty, null for unset', () => {
+        expect(parseSourceText('hello body')).toBe('hello body');
+        expect(parseSourceText(undefined)).toBeNull();
+        expect(parseSourceText(null)).toBeNull();
+    });
+
+    it('parseSourceText rejects whitespace-only and oversized content', () => {
+        expect(() => parseSourceText('   ')).toThrow(ArgumentError);
+        expect(() => parseSourceText('x'.repeat(10 * 1024 * 1024 + 1))).toThrow(ArgumentError);
+    });
+
+    it('parseSourceTitle trims and falls back to the default label', () => {
+        expect(parseSourceTitle('Custom title', 'Text Source')).toBe('Custom title');
+        expect(parseSourceTitle('   ', 'Text Source')).toBe('Text Source');
+        expect(parseSourceTitle(undefined, 'Text Source')).toBe('Text Source');
+    });
+
+    it('buildAddSourceFromUrlArgs wraps the url in the expected nested shape', () => {
+        const args = buildAddSourceFromUrlArgs('nb-123', 'https://example.com/a');
+        expect(args).toEqual([[[null, null, ['https://example.com/a']]], 'nb-123']);
+    });
+
+    it('buildAddSourceFromTextArgs uses the text inner tuple with source-type 2', () => {
+        const args = buildAddSourceFromTextArgs('nb-123', 'My Title', 'paragraph one');
+        expect(args).toEqual([[[null, ['My Title', 'paragraph one'], null, 2]], 'nb-123']);
+    });
+
+    it('parseAddSourceResult finds the source-id UUID anywhere in the wrapped result', () => {
+        const id = 'af732fa4-01c2-4de4-9d0a-933f2c29ee1e';
+        expect(parseAddSourceResult([[[ [id] ]]])).toBe(id);
+        expect(parseAddSourceResult([ 'project', null, [[id, 'title']] ])).toBe(id);
+        expect(parseAddSourceResult({ project: { sources: [{ sourceId: { sourceId: id } }] } })).toBe(id);
+    });
+
+    it('parseAddSourceResult returns the first UUID when several appear', () => {
+        const a = '11111111-1111-4111-8111-111111111111';
+        const b = '22222222-2222-4222-8222-222222222222';
+        expect(parseAddSourceResult([[[ [a], [b] ]]])).toBe(a);
+    });
+
+    it('parseAddSourceResult skips known input ids before selecting the new source id', () => {
+        const notebookId = '17e2b882-6a01-4c6c-9262-0738dfa2abee';
+        const sourceId = 'af732fa4-01c2-4de4-9d0a-933f2c29ee1e';
+        expect(parseAddSourceResult([notebookId, [[sourceId, 'title']]], [notebookId])).toBe(sourceId);
+    });
+
+    it('parseAddSourceResult ignores non-UUID strings', () => {
+        expect(parseAddSourceResult([ 'project-id', 'not-a-uuid', 'still-not' ])).toBe('');
+    });
+
+    it('parseAddSourceResult returns empty string for unparseable shapes', () => {
+        expect(parseAddSourceResult(null)).toBe('');
+        expect(parseAddSourceResult({})).toBe('');
+        expect(parseAddSourceResult([])).toBe('');
+        expect(parseAddSourceResult([[]])).toBe('');
+    });
+
+    it('refuses to add a remote source without --execute', async () => {
+        const command = getRegistry().get('notebooklm/add-source');
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, {
+            notebook: '17e2b882-6a01-4c6c-9262-0738dfa2abee',
+            content: 'source body',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});

package/clis/notebooklm/create.js

@@ -0,0 +1,76 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { callNotebooklmRpc } from './rpc.js';
+import { buildNotebooklmNotebookUrl, ensureNotebooklmHome, requireNotebooklmExecute, requireNotebooklmSession, verifyNotebooklmNotebookExists } from './utils.js';
+
+const NOTEBOOKLM_CREATE_PROJECT_RPC_ID = 'CCqFvf';
+const DEFAULT_EMOJI = '📒';
+const MAX_TITLE_LEN = 200;
+const NOTEBOOK_UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+
+export function parseCreateTitle(value) {
+    const title = String(value ?? '').trim();
+    if (!title) throw new ArgumentError('<title> is required');
+    if (title.length > MAX_TITLE_LEN) {
+        throw new ArgumentError(`Title must be at most ${MAX_TITLE_LEN} characters (got ${title.length})`);
+    }
+    return title;
+}
+
+export function parseCreateEmoji(value) {
+    const emoji = String(value ?? '').trim();
+    if (!emoji) return DEFAULT_EMOJI;
+    return emoji;
+}
+
+export function parseCreateProjectResult(result) {
+    let current = result;
+    while (Array.isArray(current) && current.length === 1 && Array.isArray(current[0])) {
+        current = current[0];
+    }
+    const id = Array.isArray(current)
+        ? (typeof current[2] === 'string' && current[2])
+            || (typeof current[0] === 'string' && current[0])
+            || ''
+        : '';
+    return typeof id === 'string' && NOTEBOOK_UUID_RE.test(id) ? id : '';
+}
+
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'create',
+    access: 'write',
+    description: 'Create a new NotebookLM notebook with the given title',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'title', positional: true, required: true, help: 'Notebook title (1-200 chars)' },
+        { name: 'emoji', help: `Notebook emoji icon (default ${DEFAULT_EMOJI})` },
+        { name: 'execute', type: 'boolean', help: 'Actually create the remote NotebookLM notebook' },
+    ],
+    columns: ['id', 'title', 'emoji', 'url'],
+    func: async (page, kwargs) => {
+        const title = parseCreateTitle(kwargs.title);
+        const emoji = parseCreateEmoji(kwargs.emoji);
+        requireNotebooklmExecute(kwargs.execute, 'create a NotebookLM notebook');
+        await ensureNotebooklmHome(page);
+        await requireNotebooklmSession(page);
+        const rpc = await callNotebooklmRpc(page, NOTEBOOKLM_CREATE_PROJECT_RPC_ID, [title, emoji]);
+        const notebookId = parseCreateProjectResult(rpc.result);
+        if (!notebookId) {
+            throw new CommandExecutionError('NotebookLM CreateProject RPC returned no notebook id');
+        }
+        await verifyNotebooklmNotebookExists(page, notebookId, 'create');
+        return [{
+            id: notebookId,
+            title,
+            emoji,
+            url: buildNotebooklmNotebookUrl(notebookId),
+        }];
+    },
+});
+
+export const __test__ = { parseCreateTitle, parseCreateEmoji, parseCreateProjectResult };

package/clis/notebooklm/create.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './create.js';
+
+const { parseCreateTitle, parseCreateEmoji, parseCreateProjectResult } = __test__;
+
+describe('notebooklm create', () => {
+    it('parseCreateTitle trims and accepts 1-200 char titles', () => {
+        expect(parseCreateTitle('hello')).toBe('hello');
+        expect(parseCreateTitle('  spaced  ')).toBe('spaced');
+        expect(parseCreateTitle('x'.repeat(200))).toHaveLength(200);
+    });
+
+    it('parseCreateTitle rejects empty / too-long titles', () => {
+        expect(() => parseCreateTitle('')).toThrow(ArgumentError);
+        expect(() => parseCreateTitle('   ')).toThrow(ArgumentError);
+        expect(() => parseCreateTitle(undefined)).toThrow(ArgumentError);
+        expect(() => parseCreateTitle('x'.repeat(201))).toThrow(ArgumentError);
+    });
+
+    it('parseCreateEmoji defaults to the notebook icon when empty', () => {
+        expect(parseCreateEmoji(undefined)).toBe('📒');
+        expect(parseCreateEmoji('')).toBe('📒');
+        expect(parseCreateEmoji('   ')).toBe('📒');
+    });
+
+    it('parseCreateEmoji passes through user-provided emoji', () => {
+        expect(parseCreateEmoji('🧪')).toBe('🧪');
+        expect(parseCreateEmoji('  🎓 ')).toBe('🎓');
+    });
+
+    it('parseCreateProjectResult extracts the notebook id from the singleton-wrapped RPC result', () => {
+        const result = [[ ['notebook-payload-prefix', null, 'ec806f5b-fe74-4588-8f77-f073b91e9b1e', 'opencli-test', '🧪'] ]];
+        expect(parseCreateProjectResult(result)).toBe('ec806f5b-fe74-4588-8f77-f073b91e9b1e');
+    });
+
+    it('parseCreateProjectResult falls back to a UUID-shaped index 0 when index 2 is missing', () => {
+        const id = 'd0b14aa7-fc0f-44bc-a749-928e27e5fa3b';
+        const result = [id, null];
+        expect(parseCreateProjectResult(result)).toBe(id);
+    });
+
+    it('parseCreateProjectResult returns empty string on malformed or unparseable shapes', () => {
+        expect(parseCreateProjectResult(null)).toBe('');
+        expect(parseCreateProjectResult({})).toBe('');
+        expect(parseCreateProjectResult([])).toBe('');
+        expect(parseCreateProjectResult([null, null, null])).toBe('');
+        expect(parseCreateProjectResult(['some-id', null])).toBe('');
+    });
+
+    it('refuses to create a remote notebook without --execute', async () => {
+        const command = getRegistry().get('notebooklm/create');
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, { title: 'Draft Notebook' })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});

package/clis/notebooklm/generate-audio.js

@@ -0,0 +1,91 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
+import { callNotebooklmRpc } from './rpc.js';
+import { buildNotebooklmNotebookUrl, listNotebooklmSourcesViaRpc, parseNotebooklmNotebookTarget, requireNotebooklmExecute, requireNotebooklmSession } from './utils.js';
+
+const NOTEBOOKLM_CREATE_AUDIO_RPC_ID = 'R7cb6c';
+const AUDIO_OVERVIEW_CONFIG_BLOCK = [2, null, null, [1, null, null, null, null, null, null, null, null, null, [1]], [[1, 4, 2, 3, 6]]];
+const AUDIO_UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+
+function toExcludedUuidSet(excludedIds) {
+    return new Set(excludedIds.map((id) => String(id ?? '').toLowerCase()).filter(Boolean));
+}
+
+export function buildCreateAudioArgs(projectId, sourceIds) {
+    const sourceTuples = sourceIds.map((id) => [[id]]);
+    const sourceTuplesTail = sourceIds.map((id) => [id]);
+    return [
+        AUDIO_OVERVIEW_CONFIG_BLOCK,
+        projectId,
+        [
+            null,
+            null,
+            1,
+            sourceTuples,
+            null,
+            null,
+            [null, [null, null, null, sourceTuplesTail]],
+        ],
+    ];
+}
+
+export function parseAudioIdFromResult(result, excludedIds = []) {
+    const excluded = toExcludedUuidSet(excludedIds);
+    if (typeof result === 'string' && AUDIO_UUID_RE.test(result) && !excluded.has(result.toLowerCase())) return result;
+    const stack = [result];
+    while (stack.length) {
+        const node = stack.shift();
+        if (typeof node === 'string' && AUDIO_UUID_RE.test(node) && !excluded.has(node.toLowerCase())) return node;
+        if (Array.isArray(node)) for (const child of node) stack.push(child);
+        else if (node && typeof node === 'object') for (const v of Object.values(node)) stack.push(v);
+    }
+    return '';
+}
+
+cli({
+    site: NOTEBOOKLM_SITE,
+    name: 'generate-audio',
+    access: 'write',
+    description: 'Trigger an Audio Overview (Deep Dive podcast) generation for a NotebookLM notebook, using all of its sources',
+    domain: NOTEBOOKLM_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'notebook', positional: true, required: true, help: 'Notebook id from `notebooklm list` or full notebook URL' },
+        { name: 'execute', type: 'boolean', help: 'Actually trigger remote NotebookLM audio generation' },
+    ],
+    columns: ['notebook_id', 'audio_id', 'source_count', 'status', 'notebook_url'],
+    func: async (page, kwargs) => {
+        const notebookId = parseNotebooklmNotebookTarget(String(kwargs.notebook ?? ''));
+        requireNotebooklmExecute(kwargs.execute, 'generate NotebookLM audio');
+        try {
+            await page.goto(buildNotebooklmNotebookUrl(notebookId));
+            await page.wait(2);
+        }
+        catch (error) {
+            throw new CommandExecutionError(`Failed to open NotebookLM notebook ${notebookId}: ${error?.message || error}`);
+        }
+        await requireNotebooklmSession(page);
+        const sources = await listNotebooklmSourcesViaRpc(page);
+        const sourceIds = sources.map((s) => s.id).filter((id) => typeof id === 'string' && id);
+        if (sourceIds.length === 0) {
+            throw new EmptyResultError('notebooklm generate-audio', 'The notebook has no sources; add a source before generating an audio overview.');
+        }
+        const rpc = await callNotebooklmRpc(page, NOTEBOOKLM_CREATE_AUDIO_RPC_ID, buildCreateAudioArgs(notebookId, sourceIds));
+        const audioId = parseAudioIdFromResult(rpc.result, [notebookId, ...sourceIds]);
+        if (!audioId) {
+            throw new CommandExecutionError('NotebookLM CreateAudioOverview RPC returned no audio id; server may have rejected the request.');
+        }
+        return [{
+            notebook_id: notebookId,
+            audio_id: audioId,
+            source_count: sourceIds.length,
+            status: 'pending',
+            notebook_url: buildNotebooklmNotebookUrl(notebookId),
+        }];
+    },
+});
+
+export const __test__ = { AUDIO_OVERVIEW_CONFIG_BLOCK, buildCreateAudioArgs, parseAudioIdFromResult };

package/clis/notebooklm/generate-audio.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './generate-audio.js';
+
+const { AUDIO_OVERVIEW_CONFIG_BLOCK, buildCreateAudioArgs, parseAudioIdFromResult } = __test__;
+
+describe('notebooklm generate-audio', () => {
+    it('AUDIO_OVERVIEW_CONFIG_BLOCK matches the live-captured wire shape', () => {
+        expect(AUDIO_OVERVIEW_CONFIG_BLOCK).toEqual([
+            2, null, null,
+            [1, null, null, null, null, null, null, null, null, null, [1]],
+            [[1, 4, 2, 3, 6]],
+        ]);
+    });
+
+    it('buildCreateAudioArgs matches the byte-perfect wire format captured from the UI', () => {
+        const projectId = '42ad744e-477d-4198-97b6-a9ae6a663165';
+        const sourceId = '7c7666bd-59e1-42ab-879d-bacfe33325eb';
+        expect(buildCreateAudioArgs(projectId, [sourceId])).toEqual([
+            [2, null, null, [1, null, null, null, null, null, null, null, null, null, [1]], [[1, 4, 2, 3, 6]]],
+            projectId,
+            [null, null, 1, [[[sourceId]]], null, null, [null, [null, null, null, [[sourceId]]]]],
+        ]);
+    });
+
+    it('buildCreateAudioArgs threads multiple sources into both the nested and tail blocks', () => {
+        const a = '11111111-1111-4111-8111-111111111111';
+        const b = '22222222-2222-4222-8222-222222222222';
+        const args = buildCreateAudioArgs('pid', [a, b]);
+        expect(args[2][3]).toEqual([[[a]], [[b]]]);
+        expect(args[2][6][1][3]).toEqual([[a], [b]]);
+    });
+
+    it('parseAudioIdFromResult walks the tree for a UUID-shaped audio id', () => {
+        const id = '38da0e55-2360-4d3e-8573-61b5a6c0c219';
+        expect(parseAudioIdFromResult([[id, 'opencli-audio-benjaminliu', 1]])).toBe(id);
+        expect(parseAudioIdFromResult({ result: { audioId: id } })).toBe(id);
+    });
+
+    it('parseAudioIdFromResult ignores non-UUID strings', () => {
+        expect(parseAudioIdFromResult([[null, 'opencli-audio-benjaminliu', 1]])).toBe('');
+        expect(parseAudioIdFromResult({})).toBe('');
+        expect(parseAudioIdFromResult([])).toBe('');
+        expect(parseAudioIdFromResult(null)).toBe('');
+    });
+
+    it('parseAudioIdFromResult skips notebook/source ids before selecting the generated audio id', () => {
+        const notebookId = '17e2b882-6a01-4c6c-9262-0738dfa2abee';
+        const sourceId = '7c7666bd-59e1-42ab-879d-bacfe33325eb';
+        const audioId = '38da0e55-2360-4d3e-8573-61b5a6c0c219';
+        expect(parseAudioIdFromResult([notebookId, [[sourceId]], [audioId]], [notebookId, sourceId])).toBe(audioId);
+    });
+
+    it('refuses to trigger remote audio generation without --execute', async () => {
+        const command = getRegistry().get('notebooklm/generate-audio');
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, {
+            notebook: '17e2b882-6a01-4c6c-9262-0738dfa2abee',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});