publishport-opencli 1.8.4-pp.1

package/clis/cnki/search.js

@@ -0,0 +1,61 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
+cli({
+    site: 'cnki',
+    name: 'search',
+    access: 'read',
+    description: '中国知网论文搜索（海外版）',
+    domain: 'oversea.cnki.net',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'query', positional: true, required: true, help: '搜索关键词' },
+        { name: 'limit', type: 'int', default: 10, help: '返回结果数量 (max 20)' },
+    ],
+    columns: ['rank', 'title', 'authors', 'journal', 'date', 'url'],
+    navigateBefore: false,
+    func: async (page, kwargs) => {
+        const limit = clampInt(kwargs.limit, 10, 1, 20);
+        const query = requireNonEmptyQuery(kwargs.query);
+        await page.goto(`https://oversea.cnki.net/kns/search?dbcode=CFLS&kw=${encodeURIComponent(query)}&korder=SU`);
+        await page.wait(8);
+        const data = await page.evaluate(`
+      (async () => {
+        const normalize = v => (v || '').replace(/\\s+/g, ' ').trim();
+        for (let i = 0; i < 40; i++) {
+          if (document.querySelector('.result-table-list tbody tr, #gridTable tbody tr')) break;
+          await new Promise(r => setTimeout(r, 500));
+        }
+        const rows = document.querySelectorAll('.result-table-list tbody tr, #gridTable tbody tr');
+        const results = [];
+        for (const row of rows) {
+          const tds = row.querySelectorAll('td');
+          if (tds.length < 5) continue;
+
+          const nameCell = row.querySelector('td.name') || tds[2];
+          const titleEl = nameCell?.querySelector('a');
+          const title = normalize(titleEl?.textContent).replace(/免费$/, '');
+          if (!title) continue;
+
+          let url = titleEl?.getAttribute('href') || '';
+          if (url && !url.startsWith('http')) url = 'https://oversea.cnki.net' + url;
+
+          const authorCell = row.querySelector('td.author') || tds[3];
+          const journalCell = row.querySelector('td.source') || tds[4];
+          const dateCell = row.querySelector('td.date') || tds[5];
+
+          results.push({
+            rank: results.length + 1,
+            title,
+            authors: normalize(authorCell?.textContent),
+            journal: normalize(journalCell?.textContent),
+            date: normalize(dateCell?.textContent),
+            url,
+          });
+          if (results.length >= ${limit}) break;
+        }
+        return results;
+      })()
+    `);
+        return Array.isArray(data) ? data : [];
+    },
+});

package/clis/cnki/search.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+describe('cnki search command', () => {
+    const command = getRegistry().get('cnki/search');
+    it('registers the command', () => {
+        expect(command).toBeDefined();
+        expect(command.site).toBe('cnki');
+        expect(command.name).toBe('search');
+    });
+    it('rejects empty queries before browser navigation', async () => {
+        const page = { goto: async () => undefined };
+        await expect(command.func(page, { query: '   ' })).rejects.toMatchObject({
+            name: 'ArgumentError',
+            code: 'ARGUMENT',
+        });
+    });
+});

package/clis/codex/_actions.js

@@ -0,0 +1,270 @@
+// Shared helpers for Codex conversation management (pin/unpin/archive/rename).
+//
+// Codex App exposes 8 actions via the "Chat actions" header dropdown on the
+// currently-active chat. We use that path because it's the only one that
+// works regardless of window visibility:
+//
+//   - The per-row sidebar buttons (Pin chat / Archive chat) are React
+//     hover-only — they're LAZILY MOUNTED only when the row is hovered,
+//     AND only when `document.visibilityState === 'visible'`. When the
+//     Codex window is hidden / minimized, even programmatic mouseenter
+//     won't surface them.
+//
+//   - The Chat actions menu mounts its items on click, doesn't care about
+//     window visibility, and supports all the operations we need:
+//       Unpin chat  ⌥⌘P     (or "Pin chat" when not pinned)
+//       Rename chat ⌥⌘R
+//       Archive chat ⇧⌘A
+//       Open side chat, Copy, Fork, Add automation…, Open in new window
+//
+// Caveat: this means each action targets the ACTIVE chat. We select the
+// target first via openCodexConversation (using --project / --conversation
+// / --index / --thread-id), then trigger the menu and click.
+
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    collectCodexProjectsFromDocument,
+    conversationSelectionArgs,
+    hasConversationTarget,
+    openCodexConversation,
+} from './sidebar.js';
+
+export { conversationSelectionArgs };
+
+export function unwrapEvaluateResult(result) {
+    if (result && typeof result === 'object' && 'data' in result && 'session' in result) {
+        return result.data;
+    }
+    return result;
+}
+
+function cleanText(value) {
+    return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function sameProject(a, b) {
+    const left = cleanText(a).toLowerCase();
+    const right = cleanText(b).toLowerCase();
+    return !left || !right || left === right;
+}
+
+export function findCodexConversation(projects, ref) {
+    if (!Array.isArray(projects)) {
+        return null;
+    }
+    for (const project of projects) {
+        for (const conversation of project.conversations || []) {
+            if (ref.threadId && conversation.threadId === ref.threadId) {
+                return { project, conversation };
+            }
+            if (!ref.threadId
+                && ref.conversation
+                && cleanText(conversation.title) === cleanText(ref.conversation)
+                && sameProject(project.project, ref.project)) {
+                return { project, conversation };
+            }
+        }
+    }
+    return null;
+}
+
+export function findActiveCodexConversation(projects) {
+    const active = [];
+    for (const project of projects || []) {
+        for (const conversation of project.conversations || []) {
+            if (conversation.active) {
+                active.push({ project, conversation });
+            }
+        }
+    }
+    return active.length === 1 ? active[0] : null;
+}
+
+export async function readConversationProjects(page) {
+    const projects = unwrapEvaluateResult(await page.evaluate(`(${collectCodexProjectsFromDocument.toString()})()`));
+    if (!Array.isArray(projects)) {
+        throw new CommandExecutionError('Codex sidebar extraction returned an invalid payload.');
+    }
+    return projects;
+}
+
+export async function resolveActionConversation(page, kwargs) {
+    const selected = await openCodexConversation(page, kwargs);
+    const projects = await readConversationProjects(page);
+    const resolved = selected
+        ? findCodexConversation(projects, selected)
+        : findActiveCodexConversation(projects);
+    if (!resolved) {
+        const hint = hasConversationTarget(kwargs)
+            ? 'The selected Codex conversation was not visible after selection.'
+            : 'Pass --project/--conversation/--index/--thread-id, or keep the active conversation visible in the sidebar.';
+        throw new CommandExecutionError('Could not resolve a stable Codex conversation identity.', hint);
+    }
+    if (!resolved.conversation.threadId) {
+        throw new CommandExecutionError(
+            'Could not resolve a stable Codex conversation identity.',
+            'The selected sidebar row is missing its Codex thread id; selectors may have drifted.',
+        );
+    }
+    return {
+        project: resolved.project.project,
+        projectPath: resolved.project.projectPath,
+        conversation: resolved.conversation.title,
+        threadId: resolved.conversation.threadId,
+        pinned: resolved.conversation.pinned,
+        index: resolved.conversation.index,
+    };
+}
+
+function conversationRefForError(ref) {
+    return ref.threadId || `${ref.project || '(unknown project)'}/${ref.conversation || '(unknown conversation)'}`;
+}
+
+/**
+ * Open the "Chat actions" header menu on the currently-active chat and
+ * click the menu item whose visible text matches one of `labelOptions`.
+ *
+ * Single-evaluate so the menu stays mounted while we click — and uses
+ * the full pointer-event chain because radix's menu trigger only responds
+ * to pointerdown/up sequences, not bare .click().
+ *
+ * Returns { ok, clicked? , reason?, detail? }.
+ */
+export async function clickChatActionsMenuItem(page, labelOptions) {
+    const labelsJson = JSON.stringify(labelOptions);
+
+    const result = unwrapEvaluateResult(await page.evaluate(`(async () => {
+    const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+    const labels = ${labelsJson};
+
+    const trigger = document.querySelector('button[aria-label="Chat actions"]');
+    if (!(trigger instanceof HTMLButtonElement)) {
+      return { ok: false, reason: 'Chat actions button not found in the chat header.' };
+    }
+
+    // Radix listens to pointer events — bare .click() is silently ignored.
+    const rect = trigger.getBoundingClientRect();
+    const init = {
+      bubbles: true, cancelable: true, button: 0, buttons: 1,
+      clientX: Math.round(rect.left + rect.width / 2),
+      clientY: Math.round(rect.top + rect.height / 2),
+    };
+    trigger.dispatchEvent(new PointerEvent('pointerdown', { ...init, pointerType: 'mouse' }));
+    trigger.dispatchEvent(new MouseEvent('mousedown', init));
+    trigger.dispatchEvent(new PointerEvent('pointerup', { ...init, pointerType: 'mouse' }));
+    trigger.dispatchEvent(new MouseEvent('mouseup', init));
+    trigger.dispatchEvent(new MouseEvent('click', init));
+
+    // Poll for menu items to mount (typically < 300ms).
+    let menuItems = [];
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      await wait(75);
+      menuItems = Array.from(document.querySelectorAll('[role="menuitem"]'))
+        .filter((it) => it instanceof HTMLElement && it.offsetParent);
+      if (menuItems.length) break;
+    }
+    if (!menuItems.length) {
+      return { ok: false, reason: 'Chat actions menu did not open after pointer click.' };
+    }
+
+    // Match by label — menu items render as "<label><kbd>shortcut</kbd>" so
+    // we compare the leading text (innerText through the first newline /
+    // kbd boundary).
+    function leadingText(el) {
+      const clone = el.cloneNode(true);
+      clone.querySelectorAll('kbd').forEach((k) => k.remove());
+      return (clone.textContent || '').trim();
+    }
+
+    let target = null;
+    for (const item of menuItems) {
+      const text = leadingText(item);
+      for (const label of labels) {
+        if (text === label || text.startsWith(label)) {
+          target = item;
+          break;
+        }
+      }
+      if (target) break;
+    }
+
+    if (!target) {
+      const visible = menuItems.map(leadingText);
+      // Close the menu so it doesn't stay open as a side effect.
+      document.body.click();
+      return {
+        ok: false,
+        reason: 'No menu item matched the requested label.',
+        detail: 'wanted=' + JSON.stringify(labels) + ' visible=' + JSON.stringify(visible),
+      };
+    }
+
+    // Defer click to a microtask so the eval response returns BEFORE the
+    // action triggers a re-render that could swallow our reply.
+    const matchedLabel = leadingText(target);
+    Promise.resolve().then(() => { try { target.click(); } catch {} });
+    return { ok: true, clicked: matchedLabel };
+  })()`));
+
+    return result || { ok: false, reason: 'Empty result from page.evaluate.' };
+}
+
+/**
+ * Convenience wrapper that selects the target first, then clicks the menu.
+ */
+export async function selectAndClickAction(page, kwargs, labelOptions) {
+    const selected = await resolveActionConversation(page, kwargs);
+    await page.wait(0.4);
+    const result = await clickChatActionsMenuItem(page, labelOptions);
+    if (!result.ok) {
+        const detail = result.detail ? ` ${result.detail}` : '';
+        throw new CommandExecutionError(
+            `${result.reason || 'Failed to perform action.'}${detail}`,
+            'Make sure Codex Desktop is running and the target conversation is selectable.',
+        );
+    }
+    return { ...result, selected };
+}
+
+export async function waitForConversationPostcondition(page, ref, predicate, description, timeoutMs = 4000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastMatch = null;
+    while (Date.now() < deadline) {
+        const projects = await readConversationProjects(page);
+        lastMatch = findCodexConversation(projects, ref);
+        if (predicate(lastMatch)) {
+            return lastMatch;
+        }
+        await page.wait(0.2);
+    }
+    throw new CommandExecutionError(
+        `Codex ${description} was not verified for ${conversationRefForError(ref)}.`,
+        'The UI action may have failed or the sidebar selectors may have drifted.',
+    );
+}
+
+export async function setConversationPinned(page, kwargs, desiredPinned) {
+    const selected = await resolveActionConversation(page, kwargs);
+    if (selected.pinned === desiredPinned) {
+        return { status: desiredPinned ? 'already-pinned' : 'already-unpinned', selected };
+    }
+    const action = await selectAndClickAction(page, kwargs, [desiredPinned ? 'Pin chat' : 'Unpin chat']);
+    await waitForConversationPostcondition(
+        page,
+        action.selected,
+        match => match?.conversation?.pinned === desiredPinned,
+        desiredPinned ? 'pin' : 'unpin',
+    );
+    return { status: desiredPinned ? 'pinned' : 'unpinned', selected: action.selected };
+}
+
+export async function archiveConversation(page, kwargs) {
+    const selected = await selectAndClickAction(page, kwargs, ['Archive chat']);
+    await waitForConversationPostcondition(
+        page,
+        selected.selected,
+        match => !match,
+        'archive',
+    );
+    return { status: 'archived', selected: selected.selected };
+}

package/clis/codex/archive.js

@@ -0,0 +1,37 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { archiveConversation, conversationSelectionArgs, resolveActionConversation } from './_actions.js';
+
+cli({
+    site: 'codex',
+    name: 'archive',
+    access: 'write',
+    description: 'Archive (Codex\'s term for delete) the selected conversation via the Chat actions header menu. No confirmation in UI — pass --yes to actually archive.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'yes', type: 'boolean', default: false, help: 'Actually archive (default: dry-run preview)' },
+        ...conversationSelectionArgs,
+    ],
+    columns: ['status', 'thread_id', 'project', 'conversation'],
+    func: async (page, kwargs) => {
+        const yes = kwargs.yes === true || kwargs.yes === 'true' || kwargs.yes === '1';
+        if (!yes) {
+            // Resolve target so the dry-run still names what WOULD be archived.
+            const selected = await resolveActionConversation(page, kwargs);
+            return [{
+                status: 'dry-run',
+                thread_id: selected.threadId,
+                project: selected.project,
+                conversation: selected.conversation,
+            }];
+        }
+        const result = await archiveConversation(page, kwargs);
+        return [{
+            status: result.status,
+            thread_id: result.selected.threadId,
+            project: result.selected.project,
+            conversation: result.selected.conversation,
+        }];
+    },
+});

package/clis/codex/ask.js

@@ -0,0 +1,78 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, selectorError } from '@jackwener/opencli/errors';
+import { conversationSelectionArgs, openCodexConversation } from './sidebar.js';
+export const askCommand = cli({
+    site: 'codex',
+    name: 'ask',
+    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', type: 'int', required: false, help: 'Max seconds to wait for response (default: 60)', default: 60 },
+        ...conversationSelectionArgs,
+    ],
+    columns: ['Role', 'Project', 'Conversation', 'Text'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        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() {
+        const turns = document.querySelectorAll('[data-content-search-turn-key]');
+        return turns.length;
+      })()
+    `);
+        // Inject and send
+        const injected = await page.evaluate(`
+      (function(text) {
+        const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'));
+        const composer = editables.length > 0 ? editables[editables.length - 1] : document.querySelector('textarea');
+        if (!composer) return false;
+        composer.focus();
+        document.execCommand('insertText', false, text);
+        return true;
+      })(${JSON.stringify(text)})
+    `);
+        if (!injected)
+            throw selectorError('Codex input element');
+        await page.wait(0.5);
+        await page.pressKey('Enter');
+        // Poll for new content
+        const pollInterval = 3;
+        const maxPolls = Math.ceil(timeout / pollInterval);
+        let response = '';
+        for (let i = 0; i < maxPolls; i++) {
+            await page.wait(pollInterval);
+            const result = await page.evaluate(`
+        (function(prevLen) {
+          const turns = document.querySelectorAll('[data-content-search-turn-key]');
+          if (turns.length <= prevLen) return null;
+          const lastTurn = turns[turns.length - 1];
+          const text = lastTurn.innerText || lastTurn.textContent;
+          return text ? text.trim() : null;
+        })(${beforeLen})
+      `);
+            if (result) {
+                response = result;
+                break;
+            }
+        }
+        if (!response) {
+            return [
+                { 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', Project: selected?.project || '', Conversation: selected?.conversation || '', Text: text },
+            { Role: 'Assistant', Project: selected?.project || '', Conversation: selected?.conversation || '', Text: response },
+        ];
+    },
+});

package/clis/codex/dump.js

@@ -0,0 +1,2 @@
+import { makeDumpCommand } from '../_shared/desktop-commands.js';
+export const dumpCommand = makeDumpCommand('codex');

package/clis/codex/export.js

@@ -0,0 +1,38 @@
+import * as fs from 'node:fs';
+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,
+    browser: true,
+    args: [
+        { name: 'output', required: false, help: 'Output file (default: /tmp/codex-export.md)' },
+    ],
+    columns: ['Status', 'File', 'Messages'],
+    func: async (page, kwargs) => {
+        const outputPath = kwargs.output || '/tmp/codex-export.md';
+        const md = await page.evaluate(`
+      (function() {
+        const turns = document.querySelectorAll('[data-content-search-turn-key]');
+        if (turns.length > 0) {
+          return Array.from(turns).map((t, i) => '## Turn ' + (i + 1) + '\\n\\n' + (t.innerText || t.textContent).trim()).join('\\n\\n---\\n\\n');
+        }
+        
+        const main = document.querySelector('main, [role="main"], [role="log"]');
+        if (main) return main.innerText || main.textContent;
+        return document.body.innerText;
+      })()
+    `);
+        fs.writeFileSync(outputPath, '# Codex Conversation Export\\n\\n' + md);
+        return [
+            {
+                Status: 'Success',
+                File: outputPath,
+                Messages: md.split('## Turn').length - 1,
+            },
+        ];
+    },
+});

package/clis/codex/extract-diff.js

@@ -0,0 +1,45 @@
+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,
+    browser: true,
+    columns: ['File', 'Diff'],
+    func: async (page) => {
+        const diffs = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Assuming diffs are rendered with standard diff classes or monaco difference editors
+        const diffBlocks = document.querySelectorAll('.diff-editor, .monaco-diff-editor, [data-testid="diff-view"]');
+        
+        diffBlocks.forEach((block, index) => {
+            // Very roughly scrape text representing additions/deletions mapped from the inner wrapper
+            results.push({
+                File: block.getAttribute('data-filename') || \`DiffBlock_\${index+1}\`,
+                Diff: block.innerText || block.textContent
+            });
+        });
+
+        // If no structured diffs found, try to find any code blocks labeled as patches
+        if (results.length === 0) {
+            const codeBlocks = document.querySelectorAll('pre code.language-diff, pre code.language-patch');
+            codeBlocks.forEach((code, index) => {
+                results.push({
+                    File: \`Patch_\${index+1}\`,
+                    Diff: code.innerText || code.textContent
+                });
+            });
+        }
+        
+        return results;
+      })()
+    `);
+        if (diffs.length === 0) {
+            return [{ File: 'No diffs found', Diff: 'Try running opencli codex send "/review" first' }];
+        }
+        return diffs;
+    },
+});

package/clis/codex/history.js

@@ -0,0 +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',
+    access: 'read',
+    description: 'List visible Codex conversation threads grouped by project',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    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 rows;
+    },
+});