@jackwener/opencli 1.5.8 → 1.6.0

package/dist/clis/gemini/utils.js

@@ -0,0 +1,463 @@
+export const GEMINI_DOMAIN = 'gemini.google.com';
+export const GEMINI_APP_URL = 'https://gemini.google.com/app';
+const GEMINI_RESPONSE_NOISE_PATTERNS = [
+    /Gemini can make mistakes\.?/gi,
+    /Google Terms/gi,
+    /Google Privacy Policy/gi,
+    /Opens in a new window/gi,
+];
+export function sanitizeGeminiResponseText(value, promptText) {
+    let sanitized = value;
+    for (const pattern of GEMINI_RESPONSE_NOISE_PATTERNS) {
+        sanitized = sanitized.replace(pattern, '');
+    }
+    sanitized = sanitized.trim();
+    const prompt = promptText.trim();
+    if (!prompt)
+        return sanitized;
+    if (sanitized === prompt)
+        return '';
+    for (const separator of ['\n\n', '\n', '\r\n\r\n', '\r\n']) {
+        const prefix = `${prompt}${separator}`;
+        if (sanitized.startsWith(prefix)) {
+            return sanitized.slice(prefix.length).trim();
+        }
+    }
+    return sanitized;
+}
+export function collectGeminiTranscriptAdditions(beforeLines, currentLines, promptText) {
+    const beforeSet = new Set(beforeLines);
+    const additions = currentLines
+        .filter((line) => !beforeSet.has(line))
+        .map((line) => sanitizeGeminiResponseText(line, promptText))
+        .filter((line) => line && line !== promptText);
+    return additions.join('\n').trim();
+}
+function getStateScript() {
+    return `
+    (() => {
+      const signInNode = Array.from(document.querySelectorAll('a, button')).find((node) => {
+        const text = (node.textContent || '').trim().toLowerCase();
+        const aria = (node.getAttribute('aria-label') || '').trim().toLowerCase();
+        const href = node.getAttribute('href') || '';
+        return text === 'sign in'
+          || aria === 'sign in'
+          || href.includes('accounts.google.com/ServiceLogin');
+      });
+
+      const composer = document.querySelector('[aria-label="Enter a prompt for Gemini"], [aria-label*="prompt for Gemini"], .ql-editor[aria-label*="Gemini"], [contenteditable="true"][aria-label*="Gemini"]');
+      const sendButton = document.querySelector('button[aria-label="Send message"]');
+
+      return {
+        url: window.location.href,
+        title: document.title || '',
+        isSignedIn: signInNode ? false : (composer ? true : null),
+        composerLabel: composer?.getAttribute('aria-label') || '',
+        canSend: !!(sendButton && !sendButton.disabled),
+      };
+    })()
+  `;
+}
+function getTranscriptLinesScript() {
+    return `
+    (() => {
+      const clean = (value) => (value || '')
+        .replace(/\\u00a0/g, ' ')
+        .replace(/\\n{3,}/g, '\\n\\n')
+        .trim();
+
+      const main = document.querySelector('main') || document.body;
+      const root = main.cloneNode(true);
+
+      const removableSelectors = [
+        'button',
+        'nav',
+        'header',
+        'footer',
+        '[aria-label="Enter a prompt for Gemini"]',
+        '[aria-label*="prompt for Gemini"]',
+        '.input-area-container',
+        '.input-wrapper',
+        '.textbox-container',
+        '.ql-toolbar',
+        '.send-button',
+        '.main-menu-button',
+        '.sign-in-button',
+      ];
+
+      for (const selector of removableSelectors) {
+        root.querySelectorAll(selector).forEach((node) => node.remove());
+      }
+      root.querySelectorAll('script, style, noscript').forEach((node) => node.remove());
+
+      const stopLines = new Set([
+        'Gemini',
+        'Google Terms',
+        'Google Privacy Policy',
+        'Meet Gemini, your personal AI assistant',
+        'Conversation with Gemini',
+        'Ask Gemini 3',
+        'Write',
+        'Plan',
+        'Research',
+        'Learn',
+        'Fast',
+        'send',
+        'Microphone',
+        'Main menu',
+        'New chat',
+        'Sign in',
+        'Google Terms Opens in a new window',
+        'Google Privacy Policy Opens in a new window',
+      ]);
+
+      const noisyPatterns = [
+        /^Google Terms$/,
+        /^Google Privacy Policy$/,
+        /^Gemini is AI and can make mistakes\.?$/,
+        /^and the$/,
+        /^apply\.$/,
+        /^Opens in a new window$/,
+        /^Open mode picker$/,
+        /^Open upload file menu$/,
+        /^Tools$/,
+      ];
+
+      return clean(root.innerText || root.textContent || '')
+        .split('\\n')
+        .map((line) => clean(line))
+        .filter((line) => line
+          && line.length <= 4000
+          && !stopLines.has(line)
+          && !noisyPatterns.some((pattern) => pattern.test(line)));
+    })()
+  `;
+}
+function getTurnsScript() {
+    return `
+    (() => {
+      const clean = (value) => (value || '')
+        .replace(/\\u00a0/g, ' ')
+        .replace(/\\n{3,}/g, '\\n\\n')
+        .trim();
+
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+
+      const selectors = [
+        '[data-testid*="message"]',
+        '[data-test-id*="message"]',
+        '[class*="message"]',
+        '[class*="conversation-turn"]',
+        '[class*="query-text"]',
+        '[class*="response-text"]',
+      ];
+
+      const roots = selectors.flatMap((selector) => Array.from(document.querySelectorAll(selector)));
+      const unique = roots.filter((el, index, all) => all.indexOf(el) === index).filter(isVisible);
+
+      const turns = unique.map((el) => {
+        const text = clean(el.innerText || el.textContent || '');
+        if (!text) return null;
+
+        const roleAttr = [
+          el.getAttribute('data-message-author-role'),
+          el.getAttribute('data-role'),
+          el.getAttribute('aria-label'),
+          el.getAttribute('class'),
+        ].filter(Boolean).join(' ').toLowerCase();
+
+        let role = '';
+        if (roleAttr.includes('user') || roleAttr.includes('query')) role = 'User';
+        else if (roleAttr.includes('assistant') || roleAttr.includes('model') || roleAttr.includes('response') || roleAttr.includes('gemini')) role = 'Assistant';
+
+        return role ? { Role: role, Text: text } : null;
+      }).filter(Boolean);
+
+      const deduped = [];
+      const seen = new Set();
+      for (const turn of turns) {
+        const key = turn.Role + '::' + turn.Text;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        deduped.push(turn);
+      }
+      return deduped;
+    })()
+  `;
+}
+function fillAndSubmitComposerScript(text) {
+    return `
+    ((inputText) => {
+      const cleanInsert = (el) => {
+        if (!(el instanceof HTMLElement)) throw new Error('Composer is not editable');
+        el.focus();
+        const selection = window.getSelection();
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        range.collapse(false);
+        selection?.removeAllRanges();
+        selection?.addRange(range);
+        el.textContent = '';
+        document.execCommand('insertText', false, inputText);
+        el.dispatchEvent(new InputEvent('input', { bubbles: true, data: inputText, inputType: 'insertText' }));
+      };
+
+      const composer = document.querySelector('[aria-label="Enter a prompt for Gemini"], [aria-label*="prompt for Gemini"], .ql-editor[aria-label*="Gemini"], [contenteditable="true"][aria-label*="Gemini"]');
+      if (!(composer instanceof HTMLElement)) {
+        throw new Error('Could not find Gemini composer');
+      }
+
+      cleanInsert(composer);
+
+      const sendButton = document.querySelector('button[aria-label="Send message"]');
+      if (sendButton instanceof HTMLButtonElement && !sendButton.disabled) {
+        sendButton.click();
+        return 'button';
+      }
+
+      composer.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+      composer.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+      return 'enter';
+    })(${JSON.stringify(text)})
+  `;
+}
+function clickNewChatScript() {
+    return `
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+
+      const candidates = Array.from(document.querySelectorAll('button, a')).filter((node) => {
+        const text = (node.textContent || '').trim().toLowerCase();
+        const aria = (node.getAttribute('aria-label') || '').trim().toLowerCase();
+        return isVisible(node) && (text === 'new chat' || aria === 'new chat');
+      });
+
+      const target = candidates.find((node) => !node.hasAttribute('disabled')) || candidates[0];
+      if (target instanceof HTMLElement) {
+        target.click();
+        return 'clicked';
+      }
+      return 'navigate';
+    })()
+  `;
+}
+function currentUrlScript() {
+    return 'window.location.href';
+}
+export async function isOnGemini(page) {
+    const url = await page.evaluate(currentUrlScript()).catch(() => '');
+    if (typeof url !== 'string' || !url)
+        return false;
+    try {
+        const hostname = new URL(url).hostname;
+        return hostname === GEMINI_DOMAIN || hostname.endsWith(`.${GEMINI_DOMAIN}`);
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureGeminiPage(page) {
+    if (!(await isOnGemini(page))) {
+        await page.goto(GEMINI_APP_URL, { waitUntil: 'load', settleMs: 2500 });
+        await page.wait(1);
+    }
+}
+export async function getGeminiPageState(page) {
+    await ensureGeminiPage(page);
+    return await page.evaluate(getStateScript());
+}
+export async function startNewGeminiChat(page) {
+    await ensureGeminiPage(page);
+    const action = await page.evaluate(clickNewChatScript());
+    if (action === 'navigate') {
+        await page.goto(GEMINI_APP_URL, { waitUntil: 'load', settleMs: 2500 });
+    }
+    await page.wait(1);
+    return action;
+}
+export async function getGeminiVisibleTurns(page) {
+    await ensureGeminiPage(page);
+    const turns = await page.evaluate(getTurnsScript());
+    if (Array.isArray(turns) && turns.length > 0)
+        return turns;
+    const lines = await getGeminiTranscriptLines(page);
+    return lines.map((line) => ({ Role: 'System', Text: line }));
+}
+export async function getGeminiTranscriptLines(page) {
+    await ensureGeminiPage(page);
+    return await page.evaluate(getTranscriptLinesScript());
+}
+export async function sendGeminiMessage(page, text) {
+    await ensureGeminiPage(page);
+    const submittedBy = await page.evaluate(fillAndSubmitComposerScript(text));
+    await page.wait(1);
+    return submittedBy;
+}
+export async function getGeminiVisibleImageUrls(page) {
+    await ensureGeminiPage(page);
+    return await page.evaluate(`
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 32 && rect.height > 32;
+      };
+
+      const imgs = Array.from(document.querySelectorAll('main img')).filter((img) => img instanceof HTMLImageElement && isVisible(img));
+      const urls = [];
+      const seen = new Set();
+
+      for (const img of imgs) {
+        const src = img.currentSrc || img.src || '';
+        const alt = (img.getAttribute('alt') || '').toLowerCase();
+        const width = img.naturalWidth || img.width || 0;
+        const height = img.naturalHeight || img.height || 0;
+        if (!src) continue;
+        if (alt.includes('avatar') || alt.includes('logo') || alt.includes('icon')) continue;
+        if (width < 128 && height < 128) continue;
+        if (seen.has(src)) continue;
+        seen.add(src);
+        urls.push(src);
+      }
+      return urls;
+    })()
+  `);
+}
+export async function waitForGeminiImages(page, beforeUrls, timeoutSeconds) {
+    const beforeSet = new Set(beforeUrls);
+    const pollIntervalSeconds = 3;
+    const maxPolls = Math.max(1, Math.ceil(timeoutSeconds / pollIntervalSeconds));
+    let lastUrls = [];
+    let stableCount = 0;
+    for (let index = 0; index < maxPolls; index += 1) {
+        await page.wait(index === 0 ? 2 : pollIntervalSeconds);
+        const urls = (await getGeminiVisibleImageUrls(page)).filter((url) => !beforeSet.has(url));
+        if (urls.length === 0)
+            continue;
+        const key = urls.join('\n');
+        const prevKey = lastUrls.join('\n');
+        if (key == prevKey)
+            stableCount += 1;
+        else {
+            lastUrls = urls;
+            stableCount = 1;
+        }
+        if (stableCount >= 2 || index === maxPolls - 1)
+            return lastUrls;
+    }
+    return lastUrls;
+}
+export async function exportGeminiImages(page, urls) {
+    await ensureGeminiPage(page);
+    const urlsJson = JSON.stringify(urls);
+    return await page.evaluate(`
+    (async (targetUrls) => {
+      const blobToDataUrl = (blob) => new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => resolve(String(reader.result || ''));
+        reader.onerror = () => reject(new Error('Failed to read blob'));
+        reader.readAsDataURL(blob);
+      });
+
+      const inferMime = (value, fallbackUrl) => {
+        if (value) return value;
+        const lower = String(fallbackUrl || '').toLowerCase();
+        if (lower.includes('.png')) return 'image/png';
+        if (lower.includes('.webp')) return 'image/webp';
+        if (lower.includes('.gif')) return 'image/gif';
+        return 'image/jpeg';
+      };
+
+      const images = Array.from(document.querySelectorAll('main img'));
+      const results = [];
+
+      for (const targetUrl of targetUrls) {
+        const img = images.find((node) => (node.currentSrc || node.src || '') === targetUrl);
+        let dataUrl = '';
+        let mimeType = 'image/jpeg';
+        const width = img?.naturalWidth || img?.width || 0;
+        const height = img?.naturalHeight || img?.height || 0;
+
+        try {
+          if (String(targetUrl).startsWith('data:')) {
+            dataUrl = String(targetUrl);
+            mimeType = (String(targetUrl).match(/^data:([^;]+);/i) || [])[1] || 'image/png';
+          } else {
+            const res = await fetch(String(targetUrl), { credentials: 'include' });
+            if (res.ok) {
+              const blob = await res.blob();
+              mimeType = inferMime(blob.type, targetUrl);
+              dataUrl = await blobToDataUrl(blob);
+            }
+          }
+        } catch {}
+
+        if (!dataUrl && img instanceof HTMLImageElement) {
+          try {
+            const canvas = document.createElement('canvas');
+            canvas.width = img.naturalWidth || img.width;
+            canvas.height = img.naturalHeight || img.height;
+            const ctx = canvas.getContext('2d');
+            if (ctx) {
+              ctx.drawImage(img, 0, 0);
+              dataUrl = canvas.toDataURL('image/png');
+              mimeType = 'image/png';
+            }
+          } catch {}
+        }
+
+        if (dataUrl) {
+          results.push({ url: String(targetUrl), dataUrl, mimeType, width, height });
+        }
+      }
+
+      return results;
+    })(${urlsJson})
+  `);
+}
+export async function waitForGeminiResponse(page, beforeLines, promptText, timeoutSeconds) {
+    const getCandidate = async () => {
+        const turns = await getGeminiVisibleTurns(page);
+        const assistantCandidate = [...turns].reverse().find((turn) => turn.Role === 'Assistant');
+        const visibleCandidate = assistantCandidate
+            ? sanitizeGeminiResponseText(assistantCandidate.Text, promptText)
+            : '';
+        if (visibleCandidate && visibleCandidate !== promptText)
+            return visibleCandidate;
+        const lines = await getGeminiTranscriptLines(page);
+        return collectGeminiTranscriptAdditions(beforeLines, lines, promptText);
+    };
+    const pollIntervalSeconds = 2;
+    const maxPolls = Math.max(1, Math.ceil(timeoutSeconds / pollIntervalSeconds));
+    let lastCandidate = '';
+    let stableCount = 0;
+    for (let index = 0; index < maxPolls; index += 1) {
+        await page.wait(index === 0 ? 1.5 : pollIntervalSeconds);
+        const candidate = await getCandidate();
+        if (!candidate)
+            continue;
+        if (candidate === lastCandidate)
+            stableCount += 1;
+        else {
+            lastCandidate = candidate;
+            stableCount = 1;
+        }
+        if (stableCount >= 2 || index === maxPolls - 1)
+            return candidate;
+    }
+    return lastCandidate;
+}

package/dist/clis/gemini/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/gemini/utils.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { collectGeminiTranscriptAdditions, sanitizeGeminiResponseText } from './utils.js';
+describe('sanitizeGeminiResponseText', () => {
+    it('strips a prompt echo only when it appears as a prefixed block', () => {
+        const prompt = 'Reply with the word opencli';
+        const value = `Reply with the word opencli\n\nopencli`;
+        expect(sanitizeGeminiResponseText(value, prompt)).toBe('opencli');
+    });
+    it('does not strip prompt text that appears later in a legitimate answer', () => {
+        const prompt = 'opencli';
+        const value = 'You asked about opencli, and opencli is the right keyword here.';
+        expect(sanitizeGeminiResponseText(value, prompt)).toBe(value);
+    });
+    it('removes known Gemini footer noise', () => {
+        const value = 'Answer body\nGemini can make mistakes.\nGoogle Terms';
+        expect(sanitizeGeminiResponseText(value, '')).toBe('Answer body');
+    });
+});
+describe('collectGeminiTranscriptAdditions', () => {
+    it('joins multiple new transcript lines instead of keeping only the last line', () => {
+        const before = ['Older answer'];
+        const current = ['Older answer', 'First new line', 'Second new line'];
+        expect(collectGeminiTranscriptAdditions(before, current, '')).toBe('First new line\nSecond new line');
+    });
+    it('filters prompt echoes out of transcript additions', () => {
+        const prompt = 'Tell me a haiku';
+        const before = ['Previous'];
+        const current = ['Previous', 'Tell me a haiku', 'Tell me a haiku\n\nSoft spring rain arrives'];
+        expect(collectGeminiTranscriptAdditions(before, current, prompt)).toBe('Soft spring rain arrives');
+    });
+});

package/dist/clis/notebooklm/compat.test.d.ts

@@ -1,3 +1,3 @@
-import './bind-current.js';
 import './get.js';
 import './note-list.js';
+import './open.js';

package/dist/clis/notebooklm/compat.test.js

@@ -1,11 +1,11 @@
 import { describe, expect, it } from 'vitest';
 import { getRegistry } from '../../registry.js';
-import './bind-current.js';
 import './get.js';
 import './note-list.js';
+import './open.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 select as a compatibility alias for open', () => {
+        expect(getRegistry().get('notebooklm/select')).toBe(getRegistry().get('notebooklm/open'));
     });
     it('registers metadata as a compatibility alias for get', () => {
         expect(getRegistry().get('notebooklm/metadata')).toBe(getRegistry().get('notebooklm/get'));

package/dist/clis/notebooklm/current.js

@@ -1,7 +1,7 @@
 import { cli, Strategy } from '../../registry.js';
 import { EmptyResultError } from '../../errors.js';
 import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
-import { ensureNotebooklmNotebookBinding, getNotebooklmPageState, readCurrentNotebooklm, requireNotebooklmSession } from './utils.js';
+import { getNotebooklmPageState, readCurrentNotebooklm, requireNotebooklmSession } from './utils.js';
 cli({
     site: NOTEBOOKLM_SITE,
     name: 'current',
@@ -13,11 +13,10 @@ cli({
     args: [],
     columns: ['id', 'title', 'url', 'source'],
     func: async (page) => {
-        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.');
+            throw new EmptyResultError('opencli notebooklm current', 'No NotebookLM notebook is open in the automation workspace. Run `opencli notebooklm open <notebook>` first.');
         }
         const current = await readCurrentNotebooklm(page);
         if (!current) {

package/dist/clis/notebooklm/get.js

@@ -1,7 +1,7 @@
 import { cli, Strategy } from '../../registry.js';
 import { EmptyResultError } from '../../errors.js';
 import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
-import { ensureNotebooklmNotebookBinding, getNotebooklmDetailViaRpc, getNotebooklmPageState, readCurrentNotebooklm, requireNotebooklmSession, } from './utils.js';
+import { getNotebooklmDetailViaRpc, getNotebooklmPageState, readCurrentNotebooklm, requireNotebooklmSession, } from './utils.js';
 cli({
     site: NOTEBOOKLM_SITE,
     name: 'get',
@@ -14,11 +14,10 @@ cli({
     args: [],
     columns: ['id', 'title', 'emoji', 'source_count', 'created_at', 'updated_at', 'url', 'source'],
     func: async (page) => {
-        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.');
+            throw new EmptyResultError('opencli notebooklm get', 'No NotebookLM notebook is open in the automation workspace. Run `opencli notebooklm open <notebook>` first.');
         }
         const rpcRow = await getNotebooklmDetailViaRpc(page).catch(() => null);
         if (rpcRow)

package/dist/clis/notebooklm/history.js

@@ -1,7 +1,7 @@
 import { cli, Strategy } from '../../registry.js';
 import { EmptyResultError } from '../../errors.js';
 import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
-import { ensureNotebooklmNotebookBinding, getNotebooklmPageState, listNotebooklmHistoryViaRpc, requireNotebooklmSession, } from './utils.js';
+import { getNotebooklmPageState, listNotebooklmHistoryViaRpc, requireNotebooklmSession, } from './utils.js';
 cli({
     site: NOTEBOOKLM_SITE,
     name: 'history',
@@ -13,11 +13,10 @@ cli({
     args: [],
     columns: ['thread_id', 'item_count', 'preview', 'source', 'notebook_id', 'url'],
     func: async (page) => {
-        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.');
+            throw new EmptyResultError('opencli notebooklm history', 'No NotebookLM notebook is open in the automation workspace. Run `opencli notebooklm open <notebook>` first.');
         }
         const rows = await listNotebooklmHistoryViaRpc(page);
         return rows;

package/dist/clis/notebooklm/note-list.js

@@ -1,7 +1,7 @@
 import { cli, Strategy } from '../../registry.js';
 import { EmptyResultError } from '../../errors.js';
 import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
-import { ensureNotebooklmNotebookBinding, getNotebooklmPageState, listNotebooklmNotesFromPage, requireNotebooklmSession, } from './utils.js';
+import { getNotebooklmPageState, listNotebooklmNotesFromPage, requireNotebooklmSession, } from './utils.js';
 cli({
     site: NOTEBOOKLM_SITE,
     name: 'note-list',
@@ -14,11 +14,10 @@ cli({
     args: [],
     columns: ['title', 'created_at', 'source', 'url'],
     func: async (page) => {
-        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.');
+            throw new EmptyResultError('opencli notebooklm note-list', 'No NotebookLM notebook is open in the automation workspace. Run `opencli notebooklm open <notebook>` first.');
         }
         const rows = await listNotebooklmNotesFromPage(page);
         if (rows.length > 0)

package/dist/clis/notebooklm/notes-get.js

@@ -1,7 +1,7 @@
 import { cli, Strategy } from '../../registry.js';
 import { EmptyResultError } from '../../errors.js';
 import { NOTEBOOKLM_DOMAIN, NOTEBOOKLM_SITE } from './shared.js';
-import { ensureNotebooklmNotebookBinding, findNotebooklmNoteRow, getNotebooklmPageState, listNotebooklmNotesFromPage, readNotebooklmVisibleNoteFromPage, requireNotebooklmSession, } from './utils.js';
+import { findNotebooklmNoteRow, getNotebooklmPageState, listNotebooklmNotesFromPage, readNotebooklmVisibleNoteFromPage, requireNotebooklmSession, } from './utils.js';
 function matchesNoteTitle(title, query) {
     const needle = query.trim().toLowerCase();
     if (!needle)
@@ -27,11 +27,10 @@ cli({
     ],
     columns: ['title', 'content', 'source', 'url'],
     func: async (page, 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.');
+            throw new EmptyResultError('opencli notebooklm notes-get', 'No NotebookLM notebook is open in the automation workspace. Run `opencli notebooklm open <notebook>` first.');
         }
         const query = typeof kwargs.note === 'string' ? kwargs.note : String(kwargs.note ?? '');
         const visible = await readNotebooklmVisibleNoteFromPage(page);

package/dist/clis/notebooklm/open.d.ts

@@ -0,0 +1 @@
+export {};