@jackwener/opencli 1.8.0 → 1.8.1

package/clis/notebooklm/utils.js

@@ -1,6 +1,6 @@
-import { AuthRequiredError, CliError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, CliError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_HOME_URL, } from './shared.js';
-import { callNotebooklmRpc, getNotebooklmPageAuth, } from './rpc.js';
+import { callNotebooklmRpc, getNotebooklmPageAuth, unwrapNotebooklmEvaluateResult, } from './rpc.js';
 export { buildNotebooklmRpcBody, extractNotebooklmRpcResult, fetchNotebooklmInPage, getNotebooklmPageAuth, parseNotebooklmChunkedResponse, stripNotebooklmAntiXssi, } from './rpc.js';
 const NOTEBOOKLM_LIST_RPC_ID = 'wXbhsf';
 const NOTEBOOKLM_NOTEBOOK_DETAIL_RPC_ID = 'rLM1Ne';
@@ -13,28 +13,61 @@ function unwrapNotebooklmSingletonResult(result) {
     }
     return current;
 }
+export function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 export function parseNotebooklmIdFromUrl(url) {
     const match = url.match(/\/notebook\/([^/?#]+)/);
     return match?.[1] ?? '';
 }
+const NOTEBOOK_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function ensureNotebookUuid(candidate) {
+    if (!NOTEBOOK_UUID_RE.test(candidate)) {
+        throw new CliError('NOTEBOOKLM_INVALID_NOTEBOOK', `NotebookLM notebook id "${candidate}" is not a valid UUID`, 'Pass a notebook id from `opencli notebooklm list` or a full notebook URL like https://notebooklm.google.com/notebook/<uuid>.');
+    }
+    return candidate;
+}
 export function parseNotebooklmNotebookTarget(value) {
     const normalized = value.trim();
     if (!normalized) {
         throw new CliError('NOTEBOOKLM_INVALID_NOTEBOOK', 'NotebookLM notebook id is required', 'Pass a notebook id from `opencli notebooklm list` or a full notebook URL.');
     }
     if (/^https?:\/\//i.test(normalized)) {
+        let parsed;
+        try {
+            parsed = new URL(normalized);
+        }
+        catch {
+            throw new CliError('NOTEBOOKLM_INVALID_NOTEBOOK', 'NotebookLM notebook URL is invalid', 'Pass a full NotebookLM notebook URL like https://notebooklm.google.com/notebook/<uuid>.');
+        }
+        if (parsed.protocol !== 'https:' || parsed.hostname !== NOTEBOOKLM_DOMAIN || parsed.username || parsed.password || parsed.port) {
+            throw new CliError('NOTEBOOKLM_INVALID_NOTEBOOK', 'NotebookLM notebook URL must be a canonical https://notebooklm.google.com URL', 'Pass a notebook id from `opencli notebooklm list` or a full NotebookLM notebook URL.');
+        }
         const notebookId = parseNotebooklmIdFromUrl(normalized);
-        if (notebookId)
-            return notebookId;
-        throw new CliError('NOTEBOOKLM_INVALID_NOTEBOOK', 'NotebookLM notebook URL is invalid', 'Pass a full NotebookLM notebook URL like https://notebooklm.google.com/notebook/<id>.');
+        if (!notebookId) {
+            throw new CliError('NOTEBOOKLM_INVALID_NOTEBOOK', 'NotebookLM notebook URL is invalid', 'Pass a full NotebookLM notebook URL like https://notebooklm.google.com/notebook/<uuid>.');
+        }
+        return ensureNotebookUuid(notebookId);
     }
     const pathMatch = normalized.match(/(?:^|\/)notebook\/([^/?#]+)/);
     if (pathMatch?.[1])
-        return pathMatch[1];
-    return normalized;
+        return ensureNotebookUuid(pathMatch[1]);
+    return ensureNotebookUuid(normalized);
+}
+export function getNotebooklmAuthuser() {
+    const v = process.env.OPENCLI_NOTEBOOKLM_AUTHUSER;
+    return typeof v === 'string' && /^\d+$/.test(v) ? v : '';
+}
+export function requireNotebooklmExecute(value, action) {
+    if (value !== true) {
+        throw new ArgumentError(`Refusing to ${action}: pass --execute to perform this NotebookLM write`);
+    }
 }
 export function buildNotebooklmNotebookUrl(notebookId) {
-    return new URL(`/notebook/${encodeURIComponent(notebookId)}`, NOTEBOOKLM_HOME_URL).toString();
+    const u = new URL(`/notebook/${encodeURIComponent(notebookId)}`, NOTEBOOKLM_HOME_URL);
+    const authuser = getNotebooklmAuthuser();
+    if (authuser) u.searchParams.set('authuser', authuser);
+    return u.toString();
 }
 export function classifyNotebooklmPage(url) {
     try {
@@ -401,6 +434,42 @@ export async function getNotebooklmDetailViaRpc(page) {
     const rpc = await callNotebooklmRpc(page, NOTEBOOKLM_NOTEBOOK_DETAIL_RPC_ID, [state.notebookId, null, [2], null, 0]);
     return parseNotebooklmNotebookDetailResult(rpc.result);
 }
+export async function getNotebooklmNotebookDetailById(page, notebookId) {
+    const rpc = await callNotebooklmRpc(page, NOTEBOOKLM_NOTEBOOK_DETAIL_RPC_ID, [notebookId, null, [2], null, 0]);
+    return { detail: parseNotebooklmNotebookDetailResult(rpc.result), sources: parseNotebooklmSourceListResult(rpc.result) };
+}
+export async function verifyNotebooklmNotebookExists(page, notebookId, action) {
+    try {
+        const { detail } = await getNotebooklmNotebookDetailById(page, notebookId);
+        if (!detail || detail.id !== notebookId) {
+            throw new CommandExecutionError(`NotebookLM ${action} succeeded but the notebook ${notebookId} was not found in the post-write verification`);
+        }
+        return detail;
+    }
+    catch (error) {
+        if (error instanceof AuthRequiredError || error instanceof CommandExecutionError)
+            throw error;
+        throw new CommandExecutionError(`NotebookLM ${action} post-write verification failed: ${error?.message || error}`);
+    }
+}
+export async function verifyNotebooklmSourceAdded(page, notebookId, sourceId, action) {
+    try {
+        const { detail, sources } = await getNotebooklmNotebookDetailById(page, notebookId);
+        if (!detail || detail.id !== notebookId) {
+            throw new CommandExecutionError(`NotebookLM ${action} succeeded but the notebook ${notebookId} was not found in the post-write verification`);
+        }
+        const matched = sources.find((s) => s.id === sourceId);
+        if (!matched) {
+            throw new CommandExecutionError(`NotebookLM ${action} succeeded but source ${sourceId} did not appear in the notebook's source list`);
+        }
+        return matched;
+    }
+    catch (error) {
+        if (error instanceof AuthRequiredError || error instanceof CommandExecutionError)
+            throw error;
+        throw new CommandExecutionError(`NotebookLM ${action} post-write verification failed: ${error?.message || error}`);
+    }
+}
 export async function listNotebooklmSourcesViaRpc(page) {
     const state = await getNotebooklmPageState(page);
     if (state.kind !== 'notebook' || !state.notebookId)
@@ -434,7 +503,7 @@ export async function listNotebooklmNotesFromPage(page) {
     const state = await getNotebooklmPageState(page);
     if (state.kind !== 'notebook' || !state.notebookId)
         return [];
-    const raw = await page.evaluate(`(() => {
+    const raw = unwrapNotebooklmEvaluateResult(await page.evaluate(`(() => {
     return Array.from(document.querySelectorAll('artifact-library-note')).map((node) => {
       const titleNode = node.querySelector('.artifact-title');
       return {
@@ -442,7 +511,7 @@ export async function listNotebooklmNotesFromPage(page) {
         text: (node.innerText || node.textContent || '').replace(/\\s+/g, ' ').trim(),
       };
     });
-  })()`);
+  })()`));
     if (!Array.isArray(raw) || raw.length === 0)
         return [];
     return parseNotebooklmNoteListRawRows(raw, state.notebookId, state.url || `https://${NOTEBOOKLM_DOMAIN}/notebook/${state.notebookId}`);
@@ -451,13 +520,13 @@ export async function readNotebooklmSummaryFromPage(page) {
     const state = await getNotebooklmPageState(page);
     if (state.kind !== 'notebook' || !state.notebookId)
         return null;
-    const raw = await page.evaluate(`(() => {
+    const raw = unwrapNotebooklmEvaluateResult(await page.evaluate(`(() => {
     const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
     const title = normalize(document.querySelector('.notebook-title, h1, [data-testid="notebook-title"]')?.textContent || document.title || '');
     const summaryNode = document.querySelector('.notebook-summary, .summary-content, [class*="summary"]');
     const summary = normalize(summaryNode?.textContent || '');
     return { title, summary };
-  })()`);
+  })()`));
     return parseNotebooklmSummaryRawRow(raw, state.notebookId, state.url || `https://${NOTEBOOKLM_DOMAIN}/notebook/${state.notebookId}`);
 }
 export async function getNotebooklmSummaryViaRpc(page) {
@@ -499,7 +568,7 @@ export async function readNotebooklmVisibleNoteFromPage(page) {
     const state = await getNotebooklmPageState(page);
     if (state.kind !== 'notebook' || !state.notebookId)
         return null;
-    const raw = await page.evaluate(`(() => {
+    const raw = unwrapNotebooklmEvaluateResult(await page.evaluate(`(() => {
     const normalizeText = (value) => (value || '').replace(/\\u00a0/g, ' ').replace(/\\r\\n/g, '\\n').trim();
     const titleNode = document.querySelector('.note-header__editable-title');
     const title = titleNode instanceof HTMLInputElement || titleNode instanceof HTMLTextAreaElement
@@ -516,7 +585,7 @@ export async function readNotebooklmVisibleNoteFromPage(page) {
       title: normalizeText(title),
       content: normalizeText(content),
     };
-  })()`);
+  })()`));
     return parseNotebooklmVisibleNoteRawRow(raw, state.notebookId, state.url || `https://${NOTEBOOKLM_DOMAIN}/notebook/${state.notebookId}`);
 }
 export async function ensureNotebooklmHome(page) {
@@ -526,11 +595,18 @@ export async function ensureNotebooklmHome(page) {
     const currentKind = currentUrl ? classifyNotebooklmPage(currentUrl) : 'unknown';
     if (currentKind === 'home')
         return;
-    await page.goto(NOTEBOOKLM_HOME_URL);
-    await page.wait(2);
+    const authuser = getNotebooklmAuthuser();
+    const target = authuser ? `${NOTEBOOKLM_HOME_URL}?authuser=${encodeURIComponent(authuser)}` : NOTEBOOKLM_HOME_URL;
+    try {
+        await page.goto(target);
+        await page.wait(2);
+    }
+    catch (error) {
+        throw new CommandExecutionError(`Failed to open NotebookLM home: ${error?.message || error}`);
+    }
 }
 export async function getNotebooklmPageState(page) {
-    const raw = await page.evaluate(`(() => {
+    const raw = unwrapNotebooklmEvaluateResult(await page.evaluate(`(() => {
     const url = window.location.href;
     const title = document.title || '';
     const hostname = window.location.hostname || '';
@@ -557,7 +633,7 @@ export async function getNotebooklmPageState(page) {
       .reduce((count, href, index, list) => list.indexOf(href) === index ? count + 1 : count, 0);
 
     return { url, title, hostname, kind, notebookId, loginRequired, notebookCount, path };
-  })()`);
+  })()`));
     const state = {
         url: String(raw?.url ?? ''),
         title: normalizeNotebooklmTitle(raw?.title, 'NotebookLM'),
@@ -582,7 +658,7 @@ export async function getNotebooklmPageState(page) {
     return state;
 }
 export async function readCurrentNotebooklm(page) {
-    const raw = await page.evaluate(`(() => {
+    const raw = unwrapNotebooklmEvaluateResult(await page.evaluate(`(() => {
     const url = window.location.href;
     const match = url.match(/\\/notebook\\/([^/?#]+)/);
     if (!match) return null;
@@ -595,7 +671,7 @@ export async function readCurrentNotebooklm(page) {
       url,
       source: 'current-page',
     };
-  })()`);
+  })()`));
     if (!raw)
         return null;
     return {
@@ -608,7 +684,7 @@ export async function readCurrentNotebooklm(page) {
     };
 }
 export async function listNotebooklmLinks(page) {
-    const raw = await page.evaluate(`(() => {
+    const raw = unwrapNotebooklmEvaluateResult(await page.evaluate(`(() => {
     const rows = [];
     const seen = new Set();
 
@@ -656,7 +732,7 @@ export async function listNotebooklmLinks(page) {
     }
 
     return rows;
-  })()`);
+  })()`));
     if (!Array.isArray(raw))
         return [];
     return raw
@@ -671,7 +747,7 @@ export async function listNotebooklmLinks(page) {
         .filter((row) => row.id && row.url);
 }
 export async function listNotebooklmSourcesFromPage(page) {
-    const raw = await page.evaluate(`(() => {
+    const raw = unwrapNotebooklmEvaluateResult(await page.evaluate(`(() => {
     const notebookMatch = window.location.href.match(/\\/notebook\\/([^/?#]+)/);
     const notebookId = notebookMatch ? notebookMatch[1] : '';
     if (!notebookId) return [];
@@ -721,7 +797,7 @@ export async function listNotebooklmSourcesFromPage(page) {
       });
     }
     return rows;
-  })()`);
+  })()`));
     if (!Array.isArray(raw))
         return [];
     return raw.filter((row) => row.id && row.title);

package/clis/notebooklm/utils.test.js

@@ -1,6 +1,40 @@
 import { describe, expect, it } from 'vitest';
-import { buildNotebooklmRpcBody, classifyNotebooklmPage, extractNotebooklmHistoryPreview, extractNotebooklmRpcResult, getNotebooklmPageState, normalizeNotebooklmTitle, parseNotebooklmHistoryThreadIdsResult, parseNotebooklmIdFromUrl, parseNotebooklmListResult, parseNotebooklmNoteListRawRows, parseNotebooklmNotebookDetailResult, parseNotebooklmSourceFulltextResult, parseNotebooklmSourceGuideResult, parseNotebooklmSourceListResult, } from './utils.js';
+import { buildNotebooklmRpcBody, classifyNotebooklmPage, extractNotebooklmHistoryPreview, extractNotebooklmRpcResult, getNotebooklmPageState, isPlainObject, normalizeNotebooklmTitle, parseNotebooklmHistoryThreadIdsResult, parseNotebooklmIdFromUrl, parseNotebooklmListResult, parseNotebooklmNoteListRawRows, parseNotebooklmNotebookDetailResult, parseNotebooklmNotebookTarget, parseNotebooklmSourceFulltextResult, parseNotebooklmSourceGuideResult, parseNotebooklmSourceListResult, } from './utils.js';
+import { CliError } from '@jackwener/opencli/errors';
 describe('notebooklm utils', () => {
+    it('isPlainObject distinguishes objects from arrays / null / primitives', () => {
+        expect(isPlainObject({})).toBe(true);
+        expect(isPlainObject({ a: 1 })).toBe(true);
+        expect(isPlainObject([])).toBe(false);
+        expect(isPlainObject(null)).toBe(false);
+        expect(isPlainObject('x')).toBe(false);
+        expect(isPlainObject(0)).toBe(false);
+    });
+    it('parseNotebooklmNotebookTarget accepts canonical uuid input', () => {
+        const id = '17e2b882-aaaa-bbbb-cccc-abcdef012345';
+        expect(parseNotebooklmNotebookTarget(id)).toBe(id);
+    });
+    it('parseNotebooklmNotebookTarget accepts a notebook url with uuid', () => {
+        const id = '17e2b882-aaaa-bbbb-cccc-abcdef012345';
+        expect(parseNotebooklmNotebookTarget(`https://notebooklm.google.com/notebook/${id}?pli=1`)).toBe(id);
+    });
+    it('parseNotebooklmNotebookTarget rejects non-uuid bare ids', () => {
+        expect(() => parseNotebooklmNotebookTarget('nb-demo')).toThrow(CliError);
+    });
+    it('parseNotebooklmNotebookTarget rejects malformed notebook urls', () => {
+        expect(() => parseNotebooklmNotebookTarget('https://notebooklm.google.com/notebook/not-a-uuid')).toThrow(CliError);
+    });
+    it('parseNotebooklmNotebookTarget rejects off-domain or non-canonical notebook urls', () => {
+        const id = '17e2b882-aaaa-bbbb-cccc-abcdef012345';
+        expect(() => parseNotebooklmNotebookTarget(`https://evil.test/notebook/${id}`)).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget(`http://notebooklm.google.com/notebook/${id}`)).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget(`https://notebooklm.google.com:444/notebook/${id}`)).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget(`https://user:notsecret@notebooklm.google.com/notebook/${id}`)).toThrow(CliError);
+    });
+    it('parseNotebooklmNotebookTarget rejects empty input', () => {
+        expect(() => parseNotebooklmNotebookTarget('')).toThrow(CliError);
+        expect(() => parseNotebooklmNotebookTarget('   ')).toThrow(CliError);
+    });
     it('parses notebook id from a notebook url', () => {
         expect(parseNotebooklmIdFromUrl('https://notebooklm.google.com/notebook/abc-123')).toBe('abc-123');
     });
@@ -387,4 +421,29 @@ describe('notebooklm utils', () => {
             notebookCount: 0,
         });
     });
+    it('reads page state through Browser Bridge evaluate envelopes', async () => {
+        const page = {
+            evaluate: async () => ({
+                session: 'site:notebooklm:abc',
+                data: {
+                    url: 'https://notebooklm.google.com/notebook/nb-demo',
+                    title: 'Demo Notebook - NotebookLM',
+                    hostname: 'notebooklm.google.com',
+                    kind: 'notebook',
+                    notebookId: 'nb-demo',
+                    loginRequired: false,
+                    notebookCount: 0,
+                },
+            }),
+        };
+        await expect(getNotebooklmPageState(page)).resolves.toEqual({
+            url: 'https://notebooklm.google.com/notebook/nb-demo',
+            title: 'Demo Notebook - NotebookLM',
+            hostname: 'notebooklm.google.com',
+            kind: 'notebook',
+            notebookId: 'nb-demo',
+            loginRequired: false,
+            notebookCount: 0,
+        });
+    });
 });

package/clis/notebooklm/write-note.js

@@ -0,0 +1,103 @@
+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, parseNotebooklmNotebookTarget, requireNotebooklmExecute, requireNotebooklmSession } from './utils.js';
+
+const NOTEBOOKLM_CREATE_NOTE_RPC_ID = 'CYK0Xb';
+const NOTEBOOKLM_MUTATE_NOTE_RPC_ID = 'cYAfTb';
+const MAX_TITLE_LEN = 200;
+const MAX_CONTENT_LEN = 1_000_000;
+const NOTE_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 parseNoteTitle(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 parseNoteContent(value) {
+    const content = String(value ?? '');
+    if (!content) throw new ArgumentError('--content is required');
+    if (content.length > MAX_CONTENT_LEN) {
+        throw new ArgumentError(`--content exceeds ${MAX_CONTENT_LEN} characters; split into smaller notes.`);
+    }
+    return content;
+}
+
+export function buildCreateNoteShellArgs(projectId) {
+    return [projectId, '', [1], null, 'New Note', null, [2]];
+}
+
+export function buildMutateNoteArgs(projectId, noteId, content, title) {
+    return [projectId, noteId, [[[content, title, [], 0]]], [2]];
+}
+
+function toExcludedUuidSet(excludedIds) {
+    return new Set(excludedIds.map((id) => String(id ?? '').toLowerCase()).filter(Boolean));
+}
+
+export function parseNoteIdFromResult(result, excludedIds = []) {
+    const excluded = toExcludedUuidSet(excludedIds);
+    if (typeof result === 'string') return NOTE_UUID_RE.test(result) && !excluded.has(result.toLowerCase()) ? result : '';
+    const stack = [result];
+    while (stack.length) {
+        const node = stack.shift();
+        if (typeof node === 'string') {
+            if (NOTE_UUID_RE.test(node) && !excluded.has(node.toLowerCase())) return node;
+            continue;
+        }
+        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: 'write-note',
+    access: 'write',
+    description: 'Create a Studio note in an existing NotebookLM notebook with the given title and Markdown content',
+    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: 'title', required: true, help: 'Note title (1-200 chars)' },
+        { name: 'content', required: true, help: 'Note body as Markdown' },
+        { name: 'execute', type: 'boolean', help: 'Actually create the remote NotebookLM note' },
+    ],
+    columns: ['notebook_id', 'note_id', 'title', 'notebook_url'],
+    func: async (page, kwargs) => {
+        const notebookId = parseNotebooklmNotebookTarget(String(kwargs.notebook ?? ''));
+        const title = parseNoteTitle(kwargs.title);
+        const content = parseNoteContent(kwargs.content);
+        requireNotebooklmExecute(kwargs.execute, 'create a NotebookLM note');
+        await ensureNotebooklmHome(page);
+        await requireNotebooklmSession(page);
+        const shellRpc = await callNotebooklmRpc(page, NOTEBOOKLM_CREATE_NOTE_RPC_ID, buildCreateNoteShellArgs(notebookId));
+        const noteId = parseNoteIdFromResult(shellRpc.result, [notebookId]);
+        if (!noteId) {
+            throw new CommandExecutionError('NotebookLM CreateNote RPC returned no note id');
+        }
+        await callNotebooklmRpc(page, NOTEBOOKLM_MUTATE_NOTE_RPC_ID, buildMutateNoteArgs(notebookId, noteId, content, title));
+        return [{
+            notebook_id: notebookId,
+            note_id: noteId,
+            title,
+            notebook_url: buildNotebooklmNotebookUrl(notebookId),
+        }];
+    },
+});
+
+export const __test__ = {
+    parseNoteTitle,
+    parseNoteContent,
+    buildCreateNoteShellArgs,
+    buildMutateNoteArgs,
+    parseNoteIdFromResult,
+};

package/clis/notebooklm/write-note.test.js

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './write-note.js';
+
+const { parseNoteTitle, parseNoteContent, buildCreateNoteShellArgs, buildMutateNoteArgs, parseNoteIdFromResult } = __test__;
+
+describe('notebooklm write-note', () => {
+    it('parseNoteTitle accepts 1-200 char titles', () => {
+        expect(parseNoteTitle('Note A')).toBe('Note A');
+        expect(parseNoteTitle('  spaced  ')).toBe('spaced');
+        expect(parseNoteTitle('x'.repeat(200))).toHaveLength(200);
+    });
+
+    it('parseNoteTitle rejects empty / too-long titles', () => {
+        expect(() => parseNoteTitle('')).toThrow(ArgumentError);
+        expect(() => parseNoteTitle('   ')).toThrow(ArgumentError);
+        expect(() => parseNoteTitle('x'.repeat(201))).toThrow(ArgumentError);
+    });
+
+    it('parseNoteContent accepts non-empty content', () => {
+        expect(parseNoteContent('# heading\n\nbody')).toBe('# heading\n\nbody');
+    });
+
+    it('parseNoteContent rejects empty content', () => {
+        expect(() => parseNoteContent('')).toThrow(ArgumentError);
+        expect(() => parseNoteContent(undefined)).toThrow(ArgumentError);
+    });
+
+    it('buildCreateNoteShellArgs matches the HAR-verified wire format', () => {
+        expect(buildCreateNoteShellArgs('nb-123')).toEqual([
+            'nb-123', '', [1], null, 'New Note', null, [2],
+        ]);
+    });
+
+    it('buildMutateNoteArgs puts content before title in the inner tuple', () => {
+        expect(buildMutateNoteArgs('nb-123', 'note-7', 'body content', 'title-x')).toEqual([
+            'nb-123', 'note-7', [[['body content', 'title-x', [], 0]]], [2],
+        ]);
+    });
+
+    it('parseNoteIdFromResult walks the tree for the note-id UUID', () => {
+        const id = '0312fc89-075e-4b3a-810d-141fc8d5af6d';
+        expect(parseNoteIdFromResult([[[ [id] ]]])).toBe(id);
+        expect(parseNoteIdFromResult({ shell: { noteId: id } })).toBe(id);
+    });
+
+    it('parseNoteIdFromResult ignores non-UUID strings', () => {
+        expect(parseNoteIdFromResult([ 'project-id', 'not-a-uuid' ])).toBe('');
+        expect(parseNoteIdFromResult(null)).toBe('');
+        expect(parseNoteIdFromResult([])).toBe('');
+    });
+
+    it('parseNoteIdFromResult skips the input notebook id before selecting the created note id', () => {
+        const notebookId = '17e2b882-6a01-4c6c-9262-0738dfa2abee';
+        const noteId = '0312fc89-075e-4b3a-810d-141fc8d5af6d';
+        expect(parseNoteIdFromResult([notebookId, [[noteId]]], [notebookId])).toBe(noteId);
+    });
+
+    it('refuses to create a remote note without --execute', async () => {
+        const command = getRegistry().get('notebooklm/write-note');
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, {
+            notebook: '17e2b882-6a01-4c6c-9262-0738dfa2abee',
+            title: 'Draft note',
+            content: 'body',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});

package/clis/pixiv/detail.js

@@ -1,4 +1,21 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { pixivFetch } from './utils.js';
+
+function requireIllustBody(body, id) {
+    if (!body || Array.isArray(body) || typeof body !== 'object') {
+        throw new CommandExecutionError(`Pixiv illustration ${id} returned malformed detail payload`);
+    }
+    const illustId = String(body.illustId ?? '').trim();
+    const title = String(body.illustTitle ?? '').trim();
+    const userName = String(body.userName ?? '').trim();
+    const userId = String(body.userId ?? '').trim();
+    if (!/^\d+$/.test(illustId) || illustId !== id || !title || !userName || !/^\d+$/.test(userId)) {
+        throw new CommandExecutionError(`Pixiv illustration ${id} returned malformed detail payload`);
+    }
+    return { ...body, illustId, illustTitle: title, userName, userId };
+}
+
 cli({
     site: 'pixiv',
     name: 'detail',
@@ -6,7 +23,6 @@ cli({
     description: 'View illustration details (tags, stats, URLs)',
     domain: 'www.pixiv.net',
     strategy: Strategy.COOKIE,
-    browser: true,
     args: [
         { name: 'id', required: true, positional: true, help: 'Illustration ID' },
     ],
@@ -23,37 +39,28 @@ cli({
         'created',
         'url',
     ],
-    pipeline: [
-        { navigate: 'https://www.pixiv.net' },
-        { evaluate: `(async () => {
-  const id = \${{ args.id | json }};
-  const res = await fetch(
-    'https://www.pixiv.net/ajax/illust/' + id,
-    { credentials: 'include' }
-  );
-  if (!res.ok) {
-    if (res.status === 401 || res.status === 403) throw new Error('Authentication required — please log in to Pixiv in Chrome');
-    if (res.status === 404) throw new Error('Illustration not found: ' + id);
-    throw new Error('Pixiv request failed (HTTP ' + res.status + ')');
-  }
-  const data = await res.json();
-  const b = data?.body;
-  if (!b) throw new Error('Illustration not found');
-  return [{
-    illust_id: b.illustId,
-    title: b.illustTitle,
-    author: b.userName,
-    user_id: b.userId,
-    type: b.illustType === 0 ? 'illust' : b.illustType === 1 ? 'manga' : b.illustType === 2 ? 'ugoira' : String(b.illustType),
-    pages: b.pageCount,
-    bookmarks: b.bookmarkCount,
-    likes: b.likeCount,
-    views: b.viewCount,
-    tags: (b.tags?.tags || []).map(t => t.tag).join(', '),
-    created: b.createDate?.split('T')[0] || '',
-    url: 'https://www.pixiv.net/artworks/' + b.illustId
-  }];
-})()
-` },
-    ],
+    func: async (page, kwargs) => {
+        const id = String(kwargs.id ?? '');
+        if (!/^\d+$/.test(id)) {
+            throw new ArgumentError(`Invalid illustration ID: ${id}`, 'Example: opencli pixiv detail 123456');
+        }
+        const body = await pixivFetch(page, `/ajax/illust/${id}`, {
+            notFoundMsg: `Illustration not found: ${id}`,
+        });
+        const b = requireIllustBody(body, id);
+        return [{
+            illust_id: b.illustId,
+            title: b.illustTitle,
+            author: b.userName,
+            user_id: b.userId,
+            type: b.illustType === 0 ? 'illust' : b.illustType === 1 ? 'manga' : b.illustType === 2 ? 'ugoira' : String(b.illustType),
+            pages: b.pageCount,
+            bookmarks: b.bookmarkCount,
+            likes: b.likeCount,
+            views: b.viewCount,
+            tags: (b.tags?.tags || []).map(t => t.tag).join(', '),
+            created: b.createDate?.split('T')[0] || '',
+            url: `https://www.pixiv.net/artworks/${b.illustId}`,
+        }];
+    },
 });