@jackwener/opencli 1.7.11 → 1.7.13

package/clis/chatwise/composer.test.js

@@ -0,0 +1,186 @@
+import { JSDOM } from 'jsdom';
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, TimeoutError } from '@jackwener/opencli/errors';
+import {
+    buildChatwiseInjectTextJs,
+    buildChatwiseMessageCountJs,
+    buildChatwiseResponseAfterJs,
+    requirePositiveTimeout,
+    scoreChatwiseComposerCandidate,
+    selectBestChatwiseComposer,
+} from './utils.js';
+import { askCommand } from './ask.js';
+
+function candidate(overrides = {}) {
+    return {
+        index: 0,
+        hidden: false,
+        role: 'textbox',
+        classes: 'cm-content cm-lineWrapping',
+        editorClasses: 'cm-editor',
+        ariaLabel: '',
+        placeholder: '',
+        text: '',
+        rect: { y: 0, h: 30 },
+        ...overrides,
+    };
+}
+
+function runBrowserScript(html, script) {
+    const dom = new JSDOM(html, { url: 'app://chatwise.local/', runScripts: 'outside-only' });
+    Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetWidth', { configurable: true, get: () => 400 });
+    Object.defineProperty(dom.window.HTMLElement.prototype, 'offsetHeight', { configurable: true, get: () => 32 });
+    dom.window.HTMLElement.prototype.getClientRects = () => [{ length: 1 }];
+    dom.window.document.execCommand = () => false;
+    return { dom, result: dom.window.eval(script) };
+}
+
+function makePage(evaluateResults = []) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) evaluate.mockResolvedValueOnce(result);
+    evaluate.mockResolvedValue(null);
+    return {
+        evaluate,
+        wait: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+    };
+}
+
+describe('chatwise composer selection', () => {
+    it('prefers the main composer over auxiliary contenteditable editors', () => {
+        const mainComposer = candidate({
+            index: 0,
+            placeholder: 'placeholder Enter a message here, press ⏎ to send',
+            rect: { y: 860, h: 32 },
+        });
+        const optionalDescription = candidate({
+            index: 1,
+            placeholder: 'placeholder Optional description',
+            editorClasses: 'cm-editor simple-editor',
+            rect: { y: 400, h: 32 },
+        });
+        const userContext = candidate({
+            index: 2,
+            text: '# User Context Document',
+            editorClasses: 'cm-editor simple-editor',
+            rect: { y: 460, h: 1200 },
+        });
+
+        expect(scoreChatwiseComposerCandidate(mainComposer, 900)).toBeGreaterThan(
+            scoreChatwiseComposerCandidate(optionalDescription, 900),
+        );
+        expect(scoreChatwiseComposerCandidate(mainComposer, 900)).toBeGreaterThan(
+            scoreChatwiseComposerCandidate(userContext, 900),
+        );
+
+        expect(selectBestChatwiseComposer([
+            optionalDescription,
+            userContext,
+            mainComposer,
+        ], 900)?.index).toBe(0);
+    });
+
+    it('rejects hidden or low-confidence candidates instead of injecting into the wrong editor', () => {
+        expect(selectBestChatwiseComposer([
+            candidate({
+                index: 0,
+                hidden: true,
+                placeholder: 'Enter a message here, press ⏎ to send',
+                rect: { y: 860, h: 32 },
+            }),
+        ], 900)).toBeNull();
+
+        expect(selectBestChatwiseComposer([
+            candidate({
+                index: 1,
+                placeholder: 'Optional description',
+                editorClasses: 'cm-editor simple-editor',
+                rect: { y: 860, h: 32 },
+            }),
+            candidate({
+                index: 2,
+                text: '# User Context Document',
+                editorClasses: 'cm-editor simple-editor',
+                rect: { y: 870, h: 32 },
+            }),
+        ], 900)).toBeNull();
+    });
+
+    it('injects text into the scored main composer instead of the last contenteditable', () => {
+        const html = `
+          <div class="cm-editor simple-editor">
+            <div class="cm-placeholder">Optional description</div>
+            <div id="optional" contenteditable="true" role="textbox"></div>
+          </div>
+          <div class="cm-editor">
+            <div class="cm-placeholder">Enter a message here, press ⏎ to send</div>
+            <div id="main" class="cm-content" contenteditable="true" role="textbox"></div>
+          </div>
+          <div class="cm-editor simple-editor">
+            <div id="context" contenteditable="true" role="textbox"># User Context Document</div>
+          </div>
+        `;
+
+        const { dom, result } = runBrowserScript(html, buildChatwiseInjectTextJs('hello'));
+
+        expect(result).toBe(true);
+        expect(dom.window.document.querySelector('#main')?.textContent).toBe('hello');
+        expect(dom.window.document.querySelector('#optional')?.textContent).toBe('');
+        expect(dom.window.document.querySelector('#context')?.textContent).toBe('# User Context Document');
+    });
+
+    it('fails injection when only auxiliary editors are present', () => {
+        const html = `
+          <div class="cm-editor simple-editor">
+            <div class="cm-placeholder">Optional description</div>
+            <div id="optional" contenteditable="true" role="textbox"></div>
+          </div>
+          <div class="cm-editor simple-editor">
+            <div id="context" contenteditable="true" role="textbox"># User Context Document</div>
+          </div>
+        `;
+
+        const { dom, result } = runBrowserScript(html, buildChatwiseInjectTextJs('hello'));
+
+        expect(result).toBe(false);
+        expect(dom.window.document.querySelector('#optional')?.textContent).toBe('');
+        expect(dom.window.document.querySelector('#context')?.textContent).toBe('# User Context Document');
+    });
+
+    it('reads only real message wrapper content after the previous count', () => {
+        const html = `
+          <div class="group/message">old message</div>
+          <div class="timestamp">12:00</div>
+          <div class="group/message">new assistant answer</div>
+        `;
+
+        expect(runBrowserScript(html, buildChatwiseMessageCountJs()).result).toBe(2);
+        expect(runBrowserScript(html, buildChatwiseResponseAfterJs(1, 'user prompt')).result).toBe('new assistant answer');
+    });
+
+    it('does not treat the user prompt wrapper as an assistant response', () => {
+        const html = `
+          <div class="group/message">old message</div>
+          <div class="group/message">user prompt</div>
+        `;
+
+        expect(runBrowserScript(html, buildChatwiseResponseAfterJs(1, 'user prompt')).result).toBeNull();
+    });
+
+    it('validates timeout explicitly', () => {
+        expect(requirePositiveTimeout(30)).toBe(30);
+        expect(() => requirePositiveTimeout('30')).toThrow(ArgumentError);
+        expect(() => requirePositiveTimeout(0)).toThrow(ArgumentError);
+    });
+
+    it('fails fast when ask times out instead of returning a System success row', async () => {
+        const page = makePage([
+            1,
+            true,
+            null,
+        ]);
+
+        await expect(askCommand.func(page, { text: 'hello', timeout: 1 }))
+            .rejects.toBeInstanceOf(TimeoutError);
+    });
+});

package/clis/chatwise/export.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const exportCommand = cli({
     site: 'chatwise',
     name: 'export',
+    access: 'read',
     description: 'Export the current ChatWise conversation to a Markdown file',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/chatwise/history.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const historyCommand = cli({
     site: 'chatwise',
     name: 'history',
+    access: 'read',
     description: 'List conversation history in ChatWise sidebar',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/chatwise/model.js

@@ -3,6 +3,7 @@ import { selectorError } from '@jackwener/opencli/errors';
 export const modelCommand = cli({
     site: 'chatwise',
     name: 'model',
+    access: 'read',
     description: 'Get or switch the active AI model in ChatWise',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/chatwise/read.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const readCommand = cli({
     site: 'chatwise',
     name: 'read',
+    access: 'read',
     description: 'Read the current ChatWise conversation history',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/chatwise/send.js

@@ -1,8 +1,10 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { selectorError } from '@jackwener/opencli/errors';
+import { buildChatwiseInjectTextJs } from './utils.js';
 export const sendCommand = cli({
     site: 'chatwise',
     name: 'send',
+    access: 'write',
     description: 'Send a message to the active ChatWise conversation',
     domain: 'localhost',
     strategy: Strategy.UI,
@@ -11,30 +13,7 @@ export const sendCommand = cli({
     columns: ['Status', 'InjectedText'],
     func: async (page, kwargs) => {
         const text = kwargs.text;
-        const injected = await page.evaluate(`
-      (function(text) {
-        // ChatWise input can be textarea or contenteditable
-        let composer = document.querySelector('textarea');
-        if (!composer) {
-          const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'));
-          composer = editables.length > 0 ? editables[editables.length - 1] : null;
-        }
-
-        if (!composer) return false;
-
-        composer.focus();
-        
-        if (composer.tagName === 'TEXTAREA') {
-          // For textarea, set value and dispatch input event
-          const nativeInputValueSetter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set;
-          nativeInputValueSetter.call(composer, text);
-          composer.dispatchEvent(new Event('input', { bubbles: true }));
-        } else {
-          document.execCommand('insertText', false, text);
-        }
-        return true;
-      })(${JSON.stringify(text)})
-    `);
+        const injected = await page.evaluate(buildChatwiseInjectTextJs(text));
         if (!injected)
             throw selectorError('ChatWise input element');
         await page.wait(0.5);

package/clis/chatwise/utils.js

@@ -0,0 +1,143 @@
+import { ArgumentError } from '@jackwener/opencli/errors';
+
+export const MESSAGE_WRAPPER_SELECTOR = '[class*="group/message"]';
+export const MIN_COMPOSER_SCORE = 120;
+
+export function requirePositiveTimeout(value) {
+    const timeout = value;
+    if (!Number.isInteger(timeout) || timeout <= 0) {
+        throw new ArgumentError('--timeout must be a positive integer (seconds)');
+    }
+    return timeout;
+}
+
+export function scoreChatwiseComposerCandidate(candidate, viewportHeight = 0) {
+    if (candidate.hidden) return -1000;
+
+    let score = 0;
+    const normalizedRole = String(candidate.role || '').toLowerCase();
+    if (normalizedRole === 'textbox') score += 10;
+
+    const normalizedClasses = `${candidate.classes || ''} ${candidate.editorClasses || ''} ${candidate.ariaLabel || ''}`.toLowerCase();
+    if (normalizedClasses.includes('cm-content')) score += 20;
+    if (normalizedClasses.includes('cm-editor')) score += 30;
+    if (normalizedClasses.includes('simple-editor')) score -= 140;
+
+    const searchableText = `${candidate.placeholder || ''} ${candidate.ariaLabel || ''} ${candidate.text || ''}`.toLowerCase();
+    if (searchableText.includes('enter a message here')) score += 220;
+    if (searchableText.includes('press ⏎ to send')) score += 80;
+    if (searchableText.includes('press enter to send')) score += 80;
+    if (searchableText.includes('message')) score += 20;
+    if (searchableText.includes('optional description')) score -= 140;
+    if (searchableText.includes('user context document')) score -= 220;
+
+    if (viewportHeight > 0 && candidate.rect) {
+        const bottom = candidate.rect.y + candidate.rect.h;
+        const distanceFromBottom = Math.abs(viewportHeight - bottom);
+        score += Math.max(0, 80 - distanceFromBottom / 8);
+    }
+
+    return score;
+}
+
+export function selectBestChatwiseComposer(candidates, viewportHeight = 0, minScore = MIN_COMPOSER_SCORE) {
+    if (!Array.isArray(candidates) || candidates.length === 0) return null;
+    const best = [...candidates]
+        .sort((left, right) => {
+            const delta = scoreChatwiseComposerCandidate(right, viewportHeight)
+                - scoreChatwiseComposerCandidate(left, viewportHeight);
+            return delta !== 0 ? delta : left.index - right.index;
+        })[0] ?? null;
+    if (!best || scoreChatwiseComposerCandidate(best, viewportHeight) < minScore) return null;
+    return best;
+}
+
+export function buildChatwiseInjectTextJs(text) {
+    const scoreFn = scoreChatwiseComposerCandidate.toString();
+    const selectFn = selectBestChatwiseComposer.toString();
+    const textJs = JSON.stringify(String(text ?? ''));
+
+    return `
+      (function(text) {
+        const scoreChatwiseComposerCandidate = ${scoreFn};
+        const selectBestChatwiseComposer = ${selectFn};
+        const MIN_COMPOSER_SCORE = ${MIN_COMPOSER_SCORE};
+
+        const composers = Array.from(document.querySelectorAll([
+          'textarea[aria-label*="message" i]',
+          'textarea[placeholder*="message" i]',
+          '[contenteditable="true"][role="textbox"]',
+          '[contenteditable="true"]'
+        ].join(',')));
+        const candidates = composers.map((el, index) => {
+          const rect = el.getBoundingClientRect();
+          const editor = el.closest('.cm-editor');
+          const placeholderEl = editor?.querySelector('.cm-placeholder');
+          return {
+            index,
+            hidden: !(el.offsetWidth || el.offsetHeight || el.getClientRects().length),
+            role: el.getAttribute('role'),
+            classes: el.className || '',
+            editorClasses: editor?.className || '',
+            ariaLabel: el.getAttribute('aria-label') || '',
+            placeholder: placeholderEl?.getAttribute('aria-label') || placeholderEl?.textContent || el.getAttribute('placeholder') || '',
+            text: (el.textContent || '').trim(),
+            rect: { y: rect.y, h: rect.height },
+          };
+        });
+
+        const best = selectBestChatwiseComposer(candidates, window.innerHeight, MIN_COMPOSER_SCORE);
+        if (!best) return false;
+
+        const composer = composers[best.index];
+        composer.focus();
+
+        if (composer.tagName === 'TEXTAREA') {
+          const setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')?.set;
+          if (setter) setter.call(composer, text);
+          else composer.value = text;
+          composer.dispatchEvent(new Event('input', { bubbles: true }));
+          return true;
+        }
+
+        const selection = window.getSelection();
+        const range = document.createRange();
+        range.selectNodeContents(composer);
+        selection?.removeAllRanges();
+        selection?.addRange(range);
+
+        const inserted = document.execCommand?.('insertText', false, text);
+        if (!inserted) {
+          composer.textContent = text;
+        }
+        composer.dispatchEvent(new Event('input', { bubbles: true }));
+        return true;
+      })(${textJs})
+    `;
+}
+
+export function buildChatwiseMessageCountJs() {
+    return `
+      (function() {
+        return Array.from(document.querySelectorAll(${JSON.stringify(MESSAGE_WRAPPER_SELECTOR)}))
+          .map(node => (node.innerText || node.textContent || '').trim())
+          .filter(Boolean)
+          .length;
+      })()
+    `;
+}
+
+export function buildChatwiseResponseAfterJs(previousCount, userText) {
+    return `
+      (function(previousCount, userText) {
+        const messages = Array.from(document.querySelectorAll(${JSON.stringify(MESSAGE_WRAPPER_SELECTOR)}))
+          .map(node => (node.innerText || node.textContent || '').trim())
+          .filter(Boolean);
+        if (messages.length <= previousCount) return null;
+        const fresh = messages.slice(previousCount)
+          .filter(text => text && text !== userText);
+        if (fresh.length === 0) return null;
+        return fresh[fresh.length - 1];
+      })(${Number(previousCount) || 0}, ${JSON.stringify(String(userText ?? ''))})
+    `;
+}

package/clis/claude/ask.js

@@ -9,12 +9,13 @@ import {
 export const askCommand = cli({
     site: 'claude',
     name: 'ask',
+    access: 'write',
     description: 'Send a prompt to Claude and get the response',
     domain: CLAUDE_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
-    timeoutSeconds: 180,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
         { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response' },

package/clis/claude/detail.js

@@ -5,10 +5,12 @@ import { CLAUDE_DOMAIN, getVisibleMessages, ensureClaudeLogin, requireConversati
 export const detailCommand = cli({
     site: 'claude',
     name: 'detail',
+    access: 'read',
     description: 'Open a Claude conversation by ID and read its messages',
     domain: CLAUDE_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'id', positional: true, required: true, help: 'Conversation ID (UUID from /chat/<id>)' },

package/clis/claude/history.js

@@ -5,10 +5,12 @@ import { CLAUDE_DOMAIN, getConversationList, ensureClaudeLogin, requirePositiveI
 export const historyCommand = cli({
     site: 'claude',
     name: 'history',
+    access: 'read',
     description: 'List conversation history from Claude /recents',
     domain: CLAUDE_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show' },

package/clis/claude/new.js

@@ -4,10 +4,12 @@ import { CLAUDE_DOMAIN, CLAUDE_URL, ensureClaudeComposer } from './utils.js';
 export const newCommand = cli({
     site: 'claude',
     name: 'new',
+    access: 'read',
     description: 'Start a new conversation in Claude',
     domain: CLAUDE_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Status'],

package/clis/claude/read.js

@@ -5,10 +5,12 @@ import { CLAUDE_DOMAIN, ensureOnClaude, getVisibleMessages, ensureClaudeLogin }
 export const readCommand = cli({
     site: 'claude',
     name: 'read',
+    access: 'read',
     description: 'Read the current Claude conversation',
     domain: CLAUDE_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Index', 'Role', 'Text'],

package/clis/claude/send.js

@@ -5,10 +5,12 @@ import { CLAUDE_DOMAIN, CLAUDE_URL, ensureOnClaude, sendMessage, parseBoolFlag,
 export const sendCommand = cli({
     site: 'claude',
     name: 'send',
+    access: 'write',
     description: 'Send a prompt to Claude without waiting for the response',
     domain: CLAUDE_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },

package/clis/claude/status.js

@@ -4,10 +4,12 @@ import { CLAUDE_DOMAIN, ensureOnClaude, getPageState } from './utils.js';
 export const statusCommand = cli({
     site: 'claude',
     name: 'status',
+    access: 'read',
     description: 'Check Claude page availability and login state',
     domain: CLAUDE_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     args: [],
     columns: ['Status', 'Login', 'Url'],

package/clis/cnki/search.js

@@ -3,6 +3,7 @@ import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
 cli({
     site: 'cnki',
     name: 'search',
+    access: 'read',
     description: '中国知网论文搜索（海外版）',
     domain: 'oversea.cnki.net',
     strategy: Strategy.COOKIE,

package/clis/codex/ask.js

@@ -1,20 +1,27 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { selectorError } from '@jackwener/opencli/errors';
+import { ArgumentError, selectorError } from '@jackwener/opencli/errors';
+import { conversationSelectionArgs, openCodexConversation } from './sidebar.js';
 export const askCommand = cli({
     site: 'codex',
     name: 'ask',
-    description: 'Send a prompt and wait for the AI response (send + wait + read)',
+    access: 'write',
+    description: 'Send a prompt to the current or selected Codex conversation and wait for the AI response',
     domain: 'localhost',
     strategy: Strategy.UI,
     browser: true,
     args: [
         { name: 'text', required: true, positional: true, help: 'Prompt to send' },
-        { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 60)', default: '60' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait for response (default: 60)', default: 60 },
+        ...conversationSelectionArgs,
     ],
-    columns: ['Role', 'Text'],
+    columns: ['Role', 'Project', 'Conversation', 'Text'],
     func: async (page, kwargs) => {
         const text = kwargs.text;
-        const timeout = parseInt(kwargs.timeout, 10) || 60;
+        const timeout = kwargs.timeout;
+        if (!Number.isInteger(timeout) || timeout < 1) {
+            throw new ArgumentError('--timeout must be a positive integer (seconds)');
+        }
+        const selected = await openCodexConversation(page, kwargs);
         // Snapshot the current content length before sending
         const beforeLen = await page.evaluate(`
       (function() {
@@ -59,13 +66,13 @@ export const askCommand = cli({
         }
         if (!response) {
             return [
-                { Role: 'User', Text: text },
-                { Role: 'System', Text: `No response within ${timeout}s. The agent may still be working.` },
+                { Role: 'User', Project: selected?.project || '', Conversation: selected?.conversation || '', Text: text },
+                { Role: 'System', Project: selected?.project || '', Conversation: selected?.conversation || '', Text: `No response within ${timeout}s. The agent may still be working.` },
             ];
         }
         return [
-            { Role: 'User', Text: text },
-            { Role: 'Assistant', Text: response },
+            { Role: 'User', Project: selected?.project || '', Conversation: selected?.conversation || '', Text: text },
+            { Role: 'Assistant', Project: selected?.project || '', Conversation: selected?.conversation || '', Text: response },
         ];
     },
 });

package/clis/codex/export.js

@@ -3,6 +3,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const exportCommand = cli({
     site: 'codex',
     name: 'export',
+    access: 'read',
     description: 'Export the current Codex conversation to a Markdown file',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/codex/extract-diff.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const extractDiffCommand = cli({
     site: 'codex',
     name: 'extract-diff',
+    access: 'read',
     description: 'Extract visual code review diff patches from Codex',
     domain: 'localhost',
     strategy: Strategy.UI,

package/clis/codex/history.js

@@ -1,43 +1,27 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { flattenCodexProjects, readCodexProjects } from './sidebar.js';
 export const historyCommand = cli({
     site: 'codex',
     name: 'history',
-    description: 'List recent conversation threads in Codex',
+    access: 'read',
+    description: 'List visible Codex conversation threads grouped by project',
     domain: 'localhost',
     strategy: Strategy.UI,
     browser: true,
-    args: [],
-    columns: ['Index', 'Title'],
-    func: async (page) => {
-        const items = await page.evaluate(`
-      (function() {
-        const results = [];
-        // Codex thread list items
-        const entries = document.querySelectorAll('[data-testid*="thread"], [class*="thread-list"] a, [role="listbox"] [role="option"]');
-        
-        entries.forEach((item, i) => {
-          const title = (item.textContent || item.innerText || '').trim().substring(0, 100);
-          if (title) results.push({ Index: i + 1, Title: title });
-        });
-        
-        // Fallback: sidebar/nav links
-        if (results.length === 0) {
-          const nav = document.querySelector('nav, [role="navigation"], aside');
-          if (nav) {
-            const links = nav.querySelectorAll('a, button');
-            links.forEach((link, i) => {
-              const text = (link.textContent || '').trim().substring(0, 100);
-              if (text && text.length > 3) results.push({ Index: i + 1, Title: text });
-            });
-          }
+    args: [
+        { name: 'project', required: false, help: 'Filter by project label or path' },
+        { name: 'limit', required: false, help: 'Max conversations per project' },
+    ],
+    columns: ['Project', 'Index', 'Title', 'Updated', 'Active'],
+    func: async (page, kwargs) => {
+        const projects = await readCodexProjects(page);
+        const rows = flattenCodexProjects(projects, kwargs);
+        if (rows.length === 0) {
+            throw new EmptyResultError('codex history', kwargs.project
+                ? `No Codex conversations were visible for project "${kwargs.project}".`
+                : 'No Codex conversations were visible. Open the Codex sidebar and retry.');
         }
-        
-        return results;
-      })()
-    `);
-        if (items.length === 0) {
-            return [{ Index: 0, Title: 'No threads found. Try opening the thread list first.' }];
-        }
-        return items;
+        return rows;
     },
 });

package/clis/codex/model.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 export const modelCommand = cli({
     site: 'codex',
     name: 'model',
+    access: 'read',
     description: 'Get or switch the currently active AI model in Codex Desktop',
     domain: 'localhost',
     strategy: Strategy.UI,