@jackwener/opencli 1.6.1 → 1.6.2

package/dist/clis/yuanbao/ask.test.js

@@ -0,0 +1,124 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AuthRequiredError, CommandExecutionError, TimeoutError } from '../../errors.js';
+import { __test__ } from './ask.js';
+import { askCommand } from './ask.js';
+describe('yuanbao ask helpers', () => {
+    describe('isOnYuanbao', () => {
+        const fakePage = (url) => ({ evaluate: () => url instanceof Error ? Promise.reject(url) : Promise.resolve(url) });
+        it('returns true for yuanbao.tencent.com URLs', async () => {
+            expect(await __test__.isOnYuanbao(fakePage('https://yuanbao.tencent.com/'))).toBe(true);
+            expect(await __test__.isOnYuanbao(fakePage('https://yuanbao.tencent.com/chat/abc'))).toBe(true);
+        });
+        it('returns false for non-yuanbao domains', async () => {
+            expect(await __test__.isOnYuanbao(fakePage('https://example.com/?next=yuanbao.tencent.com'))).toBe(false);
+            expect(await __test__.isOnYuanbao(fakePage('about:blank'))).toBe(false);
+        });
+        it('returns false when evaluate throws', async () => {
+            expect(await __test__.isOnYuanbao(fakePage(new Error('detached')))).toBe(false);
+        });
+    });
+    it('removes echoed prompt prefixes from transcript additions', () => {
+        expect(__test__.sanitizeYuanbaoResponseText('你好\n你好，我是元宝。', '你好')).toBe('你好，我是元宝。');
+    });
+    it('filters transient in-progress assistant placeholders', () => {
+        expect(__test__.sanitizeYuanbaoResponseText('正在搜索资料', '张雪机车相关的股票有哪些？')).toBe('');
+    });
+    it('normalizes boolean flags with explicit defaults', () => {
+        expect(__test__.normalizeBooleanFlag(undefined, true)).toBe(true);
+        expect(__test__.normalizeBooleanFlag(undefined, false)).toBe(false);
+        expect(__test__.normalizeBooleanFlag('true', false)).toBe(true);
+        expect(__test__.normalizeBooleanFlag('1', false)).toBe(true);
+        expect(__test__.normalizeBooleanFlag('yes', false)).toBe(true);
+        expect(__test__.normalizeBooleanFlag('false', true)).toBe(false);
+    });
+    it('ignores baseline lines and echoed prompts when collecting additions', () => {
+        const response = __test__.collectYuanbaoTranscriptAdditions(['旧消息'], ['旧消息', '你好', '你好\n你好，我是元宝。'], '你好');
+        expect(response).toBe('你好，我是元宝。');
+    });
+    it('prefers fresh assistant messages over echoed prompts and older messages', () => {
+        const response = __test__.pickLatestYuanbaoAssistantCandidate(['旧回复', '你好', '你好！我是元宝，由腾讯推出的AI助手。'], 1, '你好');
+        expect(response).toBe('你好！我是元宝，由腾讯推出的AI助手。');
+    });
+    it('converts assistant html tables to markdown tables via turndown', () => {
+        const markdown = __test__.convertYuanbaoHtmlToMarkdown(`
+      <h3>核心产业链概念股一览</h3>
+      <table>
+        <thead>
+          <tr><th>细分赛道</th><th>核心标的</th></tr>
+        </thead>
+        <tbody>
+          <tr><td>光模块</td><td>中际旭创</td></tr>
+        </tbody>
+      </table>
+    `);
+        expect(markdown).toContain('### 核心产业链概念股一览');
+        expect(markdown).toContain('| 细分赛道 | 核心标的 |');
+        expect(markdown).toContain('| --- | --- |');
+        expect(markdown).toContain('| 光模块 | 中际旭创 |');
+    });
+    it('tracks stabilization by incrementing repeats and resetting on changes', () => {
+        expect(__test__.updateStableState('', 0, '第一段')).toEqual({
+            previousText: '第一段',
+            stableCount: 0,
+        });
+        expect(__test__.updateStableState('第一段', 0, '第一段')).toEqual({
+            previousText: '第一段',
+            stableCount: 1,
+        });
+        expect(__test__.updateStableState('第一段', 1, '第二段')).toEqual({
+            previousText: '第二段',
+            stableCount: 0,
+        });
+    });
+});
+function createAskPageMock(overrides = {}) {
+    const currentUrl = overrides.currentUrl ?? 'https://yuanbao.tencent.com/';
+    const hasLoginGate = overrides.hasLoginGate ?? false;
+    const sendResult = overrides.sendResult;
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockImplementation(async (script) => {
+            if (script === 'window.location.href')
+                return currentUrl;
+            if (script.includes('微信扫码登录'))
+                return hasLoginGate;
+            if (script.includes('[dt-button-id="internet_search"]'))
+                return { found: false, enabled: false };
+            if (script.includes('[dt-button-id="deep_think"]'))
+                return { found: false, enabled: false };
+            if (script.includes('.agent-chat__list__item--ai'))
+                return [];
+            if (script.includes('const stopLines = new Set(['))
+                return [];
+            if (script.includes('Failed to insert the prompt into the Yuanbao composer.')) {
+                return sendResult ?? { ok: true, action: 'click' };
+            }
+            throw new Error(`Unexpected evaluate script in test: ${script.slice(0, 80)}`);
+        }),
+    };
+}
+describe('yuanbao ask command', () => {
+    it('throws AuthRequiredError when Yuanbao shows a login gate before sending', async () => {
+        const page = createAskPageMock({ hasLoginGate: true });
+        await expect(askCommand.func(page, { prompt: '你好', timeout: '60', search: true, think: false }))
+            .rejects.toBeInstanceOf(AuthRequiredError);
+    });
+    it('throws CommandExecutionError when the prompt cannot be sent', async () => {
+        const page = createAskPageMock({
+            sendResult: {
+                ok: false,
+                reason: 'Yuanbao composer was not found.',
+            },
+        });
+        await expect(askCommand.func(page, { prompt: '你好', timeout: '60', search: true, think: false }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+    it('throws TimeoutError when no response arrives before timeout', async () => {
+        const page = createAskPageMock({
+            sendResult: { ok: true, action: 'click' },
+        });
+        await expect(askCommand.func(page, { prompt: '你好', timeout: '-1', search: true, think: false }))
+            .rejects.toBeInstanceOf(TimeoutError);
+    });
+});

package/dist/clis/yuanbao/new.d.ts

@@ -0,0 +1 @@
+export declare const newCommand: import("../../registry.js").CliCommand;

package/dist/clis/yuanbao/new.js

@@ -0,0 +1,70 @@
+import { cli, Strategy } from '../../registry.js';
+import { YUANBAO_DOMAIN, YUANBAO_URL, IS_VISIBLE_JS, authRequired, ensureYuanbaoPage, hasLoginGate } from './shared.js';
+async function getCurrentUrl(page) {
+    const result = await page.evaluate('window.location.href').catch(() => '');
+    return typeof result === 'string' ? result : '';
+}
+async function getComposerText(page) {
+    const result = await page.evaluate(`(() => {
+    const composer = document.querySelector('.ql-editor, [contenteditable="true"]');
+    return composer ? (composer.textContent || '').trim() : '';
+  })()`);
+    return typeof result === 'string' ? result.trim() : '';
+}
+async function startNewYuanbaoChat(page) {
+    await ensureYuanbaoPage(page);
+    if (await hasLoginGate(page))
+        return 'blocked';
+    const beforeUrl = await getCurrentUrl(page);
+    const action = await page.evaluate(`(() => {
+    ${IS_VISIBLE_JS}
+
+    const trigger = Array.from(document.querySelectorAll('.yb-common-nav__trigger[data-desc="new-chat"]'))
+      .find((node) => isVisible(node));
+
+    if (trigger instanceof HTMLElement) {
+      trigger.click();
+      return 'clicked';
+    }
+
+    return 'navigate';
+  })()`);
+    if (action === 'navigate') {
+        await page.goto(YUANBAO_URL, { waitUntil: 'load', settleMs: 2500 });
+        await page.wait(1);
+        if (await hasLoginGate(page))
+            return 'blocked';
+        return 'navigate';
+    }
+    await page.wait(1);
+    if (await hasLoginGate(page))
+        return 'blocked';
+    const afterUrl = await getCurrentUrl(page);
+    const composerText = await getComposerText(page);
+    if (afterUrl !== beforeUrl || !composerText)
+        return 'clicked';
+    await page.goto(YUANBAO_URL, { waitUntil: 'load', settleMs: 2500 });
+    await page.wait(1);
+    return 'navigate';
+}
+export const newCommand = cli({
+    site: 'yuanbao',
+    name: 'new',
+    description: 'Start a new conversation in Yuanbao web chat',
+    domain: YUANBAO_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Status', 'Action'],
+    func: async (page) => {
+        const action = await startNewYuanbaoChat(page);
+        if (action === 'blocked') {
+            throw authRequired('Yuanbao opened a login gate instead of starting a new chat.');
+        }
+        return [{
+                Status: 'Success',
+                Action: action === 'navigate' ? 'Reloaded Yuanbao homepage as fallback' : 'Clicked New chat',
+            }];
+    },
+});

package/dist/clis/yuanbao/new.test.d.ts

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

package/dist/clis/yuanbao/new.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AuthRequiredError } from '../../errors.js';
+import { newCommand } from './new.js';
+function createNewPageMock(overrides = {}) {
+    const currentUrl = overrides.currentUrl ?? 'https://yuanbao.tencent.com/';
+    const triggerAction = overrides.triggerAction ?? 'clicked';
+    const hasLoginGate = overrides.hasLoginGate ?? false;
+    const composerText = overrides.composerText ?? '';
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockImplementation(async (script) => {
+            if (script === 'window.location.href')
+                return currentUrl;
+            if (script.includes('微信扫码登录'))
+                return hasLoginGate;
+            if (script.includes('.ql-editor, [contenteditable="true"]'))
+                return composerText;
+            if (script.includes('const trigger = Array.from(document.querySelectorAll'))
+                return triggerAction;
+            throw new Error(`Unexpected evaluate script in test: ${script.slice(0, 80)}`);
+        }),
+    };
+}
+describe('yuanbao new command', () => {
+    it('throws AuthRequiredError when Yuanbao shows a login gate', async () => {
+        const page = createNewPageMock({ hasLoginGate: true });
+        await expect(newCommand.func(page, {})).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+});

package/dist/clis/yuanbao/shared.d.ts

@@ -0,0 +1,13 @@
+import type { IPage } from '../../types.js';
+import { AuthRequiredError } from '../../errors.js';
+export declare const YUANBAO_DOMAIN = "yuanbao.tencent.com";
+export declare const YUANBAO_URL = "https://yuanbao.tencent.com/";
+/**
+ * Reusable visibility check for injected browser scripts.
+ * Embed in page.evaluate strings via `${IS_VISIBLE_JS}`.
+ */
+export declare const IS_VISIBLE_JS = "const isVisible = (node) => {\n  if (!(node instanceof HTMLElement)) return false;\n  const rect = node.getBoundingClientRect();\n  const style = window.getComputedStyle(node);\n  return rect.width > 0\n    && rect.height > 0\n    && style.display !== 'none'\n    && style.visibility !== 'hidden';\n};";
+export declare function authRequired(message: string): AuthRequiredError;
+export declare function isOnYuanbao(page: IPage): Promise<boolean>;
+export declare function ensureYuanbaoPage(page: IPage): Promise<void>;
+export declare function hasLoginGate(page: IPage): Promise<boolean>;

package/dist/clis/yuanbao/shared.js

@@ -0,0 +1,49 @@
+import { AuthRequiredError } from '../../errors.js';
+export const YUANBAO_DOMAIN = 'yuanbao.tencent.com';
+export const YUANBAO_URL = 'https://yuanbao.tencent.com/';
+const SESSION_HINT = 'Likely login/auth/challenge/session issue in the existing yuanbao.tencent.com browser session.';
+/**
+ * Reusable visibility check for injected browser scripts.
+ * Embed in page.evaluate strings via `${IS_VISIBLE_JS}`.
+ */
+export const IS_VISIBLE_JS = `const isVisible = (node) => {
+  if (!(node instanceof HTMLElement)) return false;
+  const rect = node.getBoundingClientRect();
+  const style = window.getComputedStyle(node);
+  return rect.width > 0
+    && rect.height > 0
+    && style.display !== 'none'
+    && style.visibility !== 'hidden';
+};`;
+export function authRequired(message) {
+    return new AuthRequiredError(YUANBAO_DOMAIN, `${message} ${SESSION_HINT}`);
+}
+export async function isOnYuanbao(page) {
+    const url = await page.evaluate('window.location.href').catch(() => '');
+    if (typeof url !== 'string' || !url)
+        return false;
+    try {
+        const hostname = new URL(url).hostname;
+        return hostname === YUANBAO_DOMAIN || hostname.endsWith(`.${YUANBAO_DOMAIN}`);
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureYuanbaoPage(page) {
+    if (!(await isOnYuanbao(page))) {
+        await page.goto(YUANBAO_URL, { waitUntil: 'load', settleMs: 2500 });
+        await page.wait(1);
+    }
+}
+export async function hasLoginGate(page) {
+    const result = await page.evaluate(`(() => {
+    const bodyText = document.body.innerText || '';
+    const hasWechatLoginText = bodyText.includes('微信扫码登录');
+    const hasWechatIframe = Array.from(document.querySelectorAll('iframe'))
+      .some((frame) => (frame.getAttribute('src') || '').includes('open.weixin.qq.com/connect/qrconnect'));
+
+    return hasWechatLoginText || hasWechatIframe;
+  })()`);
+    return Boolean(result);
+}

package/dist/clis/zhihu/question.js

@@ -1,5 +1,14 @@
 import { cli, Strategy } from '../../registry.js';
 import { AuthRequiredError, CliError } from '../../errors.js';
+function stripHtml(html) {
+    return html
+        .replace(/<[^>]+>/g, '')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .trim();
+}
 cli({
     site: 'zhihu',
     name: 'question',
@@ -13,30 +22,32 @@ cli({
     columns: ['rank', 'author', 'votes', 'content'],
     func: async (page, kwargs) => {
         const { id, limit = 5 } = kwargs;
+        const questionId = String(id);
+        if (!/^\d+$/.test(questionId)) {
+            throw new CliError('INVALID_INPUT', 'Question ID must be numeric', 'Example: opencli zhihu question 123456789');
+        }
         const answerLimit = Number(limit);
-        const stripHtml = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
-        // Only fetch answers here. The question detail endpoint is not used by the
-        // current CLI output and can fail independently, which would incorrectly
-        // turn a successful answers response into a login error.
-        const result = await page.evaluate(async ({ questionId, answerLimit }) => {
-            const aResp = await fetch(`https://www.zhihu.com/api/v4/questions/${questionId}/answers?limit=${answerLimit}&offset=0&sort_by=default&include=data[*].content,voteup_count,comment_count,author`, { credentials: 'include' });
-            if (!aResp.ok)
-                return { ok: false, status: aResp.status };
-            const a = await aResp.json();
-            return { ok: true, answers: Array.isArray(a?.data) ? a.data : [] };
-        }, { questionId: String(id), answerLimit });
-        if (!result?.ok) {
-            if (result?.status === 401 || result?.status === 403) {
+        await page.goto(`https://www.zhihu.com/question/${questionId}`);
+        const url = `https://www.zhihu.com/api/v4/questions/${questionId}/answers?limit=${answerLimit}&offset=0&sort_by=default&include=data[*].content,voteup_count,comment_count,author`;
+        const data = await page.evaluate(`
+      (async () => {
+        const r = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+        if (!r.ok) return { __httpError: r.status };
+        return await r.json();
+      })()
+    `);
+        if (!data || data.__httpError) {
+            const status = data?.__httpError;
+            if (status === 401 || status === 403) {
                 throw new AuthRequiredError('www.zhihu.com', 'Failed to fetch question data from Zhihu');
             }
-            throw new CliError('FETCH_ERROR', `Zhihu question answers request failed with HTTP ${result?.status ?? 'unknown'}`, 'Try again later or rerun with -v for more detail');
+            throw new CliError('FETCH_ERROR', status ? `Zhihu question answers request failed (HTTP ${status})` : 'Zhihu question answers request failed', 'Try again later or rerun with -v for more detail');
         }
-        const answers = result.answers.slice(0, answerLimit).map((a, i) => ({
+        return (data.data || []).map((item, i) => ({
             rank: i + 1,
-            author: a.author?.name ?? 'anonymous',
-            votes: a.voteup_count ?? 0,
-            content: stripHtml(a.content ?? '').slice(0, 200),
+            author: item.author?.name || 'anonymous',
+            votes: item.voteup_count || 0,
+            content: stripHtml(item.content || '').substring(0, 200),
         }));
-        return answers;
     },
 });

package/dist/clis/zhihu/question.test.js

@@ -1,27 +1,26 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '../../registry.js';
-import { AuthRequiredError } from '../../errors.js';
+import { AuthRequiredError, CliError } from '../../errors.js';
 import './question.js';
 describe('zhihu question', () => {
-    it('returns answers even when the unused question detail request fails', async () => {
+    it('returns answers from the Zhihu API', async () => {
         const cmd = getRegistry().get('zhihu/question');
         expect(cmd?.func).toBeTypeOf('function');
-        const evaluate = vi.fn().mockImplementation(async (_fn, args) => {
-            expect(args).toEqual({ questionId: '2021881398772981878', answerLimit: 3 });
+        const goto = vi.fn().mockResolvedValue(undefined);
+        const evaluate = vi.fn().mockImplementation(async (js) => {
+            expect(js).toContain('questions/2021881398772981878/answers?limit=3');
+            expect(js).toContain("credentials: 'include'");
             return {
-                ok: true,
-                answers: [
+                data: [
                     {
                         author: { name: 'alice' },
                         voteup_count: 12,
-                        content: '<p>Hello <b>Zhihu</b></p>',
+                        content: 'Hello Zhihu',
                     },
                 ],
             };
         });
-        const page = {
-            evaluate,
-        };
+        const page = { goto, evaluate };
         await expect(cmd.func(page, { id: '2021881398772981878', limit: 3 })).resolves.toEqual([
             {
                 rank: 1,
@@ -30,25 +29,44 @@ describe('zhihu question', () => {
                 content: 'Hello Zhihu',
             },
         ]);
+        expect(goto).toHaveBeenCalledWith('https://www.zhihu.com/question/2021881398772981878');
         expect(evaluate).toHaveBeenCalledTimes(1);
     });
     it('maps auth-like answer failures to AuthRequiredError', async () => {
         const cmd = getRegistry().get('zhihu/question');
-        expect(cmd?.func).toBeTypeOf('function');
         const page = {
-            evaluate: vi.fn().mockResolvedValue({ ok: false, status: 403 }),
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ __httpError: 403 }),
         };
         await expect(cmd.func(page, { id: '2021881398772981878', limit: 3 })).rejects.toBeInstanceOf(AuthRequiredError);
     });
-    it('preserves non-auth fetch failures as CliError instead of login errors', async () => {
+    it('preserves non-auth fetch failures as CliError', async () => {
         const cmd = getRegistry().get('zhihu/question');
-        expect(cmd?.func).toBeTypeOf('function');
         const page = {
-            evaluate: vi.fn().mockResolvedValue({ ok: false, status: 500 }),
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ __httpError: 500 }),
         };
         await expect(cmd.func(page, { id: '2021881398772981878', limit: 3 })).rejects.toMatchObject({
             code: 'FETCH_ERROR',
-            message: 'Zhihu question answers request failed with HTTP 500',
+            message: 'Zhihu question answers request failed (HTTP 500)',
         });
     });
+    it('handles null evaluate response as fetch error', async () => {
+        const cmd = getRegistry().get('zhihu/question');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue(null),
+        };
+        await expect(cmd.func(page, { id: '2021881398772981878', limit: 3 })).rejects.toMatchObject({
+            code: 'FETCH_ERROR',
+            message: 'Zhihu question answers request failed',
+        });
+    });
+    it('rejects non-numeric question IDs', async () => {
+        const cmd = getRegistry().get('zhihu/question');
+        const page = { goto: vi.fn(), evaluate: vi.fn() };
+        await expect(cmd.func(page, { id: "abc'; alert(1); //", limit: 1 })).rejects.toBeInstanceOf(CliError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
 });

package/dist/commanderAdapter.js

@@ -49,7 +49,8 @@ export function registerCommandToProgram(siteCmd, cmd) {
             positionalArgs.push(arg);
         }
         else {
-            const flag = arg.required ? `--${arg.name} <value>` : `--${arg.name} [value]`;
+            const expectsValue = arg.required || arg.valueRequired;
+            const flag = expectsValue ? `--${arg.name} <value>` : `--${arg.name} [value]`;
             if (arg.required)
                 subCmd.requiredOption(flag, arg.help ?? '');
             else if (arg.default != null)
@@ -83,8 +84,10 @@ export function registerCommandToProgram(siteCmd, cmd) {
                 if (v !== undefined)
                     kwargs[arg.name] = normalizeArgValue(arg.type, v, arg.name);
             }
+            cmd.validateArgs?.(kwargs);
             const verbose = optionsRecord.verbose === true;
             let format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
+            const formatExplicit = subCmd.getOptionValueSource('format') === 'cli';
             if (verbose)
                 process.env.OPENCLI_VERBOSE = '1';
             if (cmd.deprecated) {
@@ -97,7 +100,7 @@ export function registerCommandToProgram(siteCmd, cmd) {
                 return;
             }
             const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
-            if (format === 'table' && resolved.defaultFormat) {
+            if (!formatExplicit && format === 'table' && resolved.defaultFormat) {
                 format = resolved.defaultFormat;
             }
             if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
@@ -105,6 +108,7 @@ export function registerCommandToProgram(siteCmd, cmd) {
             }
             renderOutput(result, {
                 fmt: format,
+                fmtExplicit: formatExplicit,
                 columns: resolved.columns,
                 title: `${resolved.site}/${resolved.name}`,
                 elapsed: (Date.now() - startTime) / 1000,
@@ -198,7 +202,7 @@ async function renderError(err, cmdName, verbose) {
     if (err instanceof AuthRequiredError) {
         console.error(chalk.red(`🔒 Not logged in to ${err.domain}`));
         // Respect custom hints set by the adapter; fall back to generic guidance.
-        console.error(chalk.yellow(`→ ${err.hint ?? `Open Chrome and log in to https://${err.domain}, then retry.`}`));
+        console.error(chalk.yellow(`→ ${err.hint ?? `Open Chrome or Chromium and log in to https://${err.domain}, then retry.`}`));
         return;
     }
     // ── TimeoutError ──────────────────────────────────────────────────────
@@ -255,7 +259,7 @@ async function renderError(err, cmdName, verbose) {
     const kind = classifyGenericError(msg);
     if (kind === 'auth') {
         console.error(chalk.red(`🔒 ${msg}`));
-        console.error(chalk.yellow('→ Open Chrome, log in to the target site, then retry.'));
+        console.error(chalk.yellow('→ Open Chrome or Chromium, log in to the target site, then retry.'));
         return;
     }
     if (kind === 'http') {

package/dist/commanderAdapter.test.js

@@ -100,6 +100,48 @@ describe('commanderAdapter boolean alias support', () => {
         expect(kwargs.undo).toBe(false);
     });
 });
+describe('commanderAdapter value-required optional options', () => {
+    const cmd = {
+        site: 'instagram',
+        name: 'post',
+        description: 'Post to Instagram',
+        browser: true,
+        args: [
+            { name: 'image', valueRequired: true, help: 'Single image path' },
+            { name: 'images', valueRequired: true, help: 'Comma-separated image paths' },
+            { name: 'content', positional: true, required: false, help: 'Caption text' },
+        ],
+        validateArgs: (kwargs) => {
+            if (!kwargs.image && !kwargs.images) {
+                throw new Error('media required');
+            }
+        },
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('requires a value when --image is present', async () => {
+        const program = new Command();
+        program.exitOverride();
+        const siteCmd = program.command('instagram');
+        registerCommandToProgram(siteCmd, cmd);
+        await expect(program.parseAsync(['node', 'opencli', 'instagram', 'post', '--image'])).rejects.toMatchObject({ code: 'commander.optionMissingArgument' });
+        expect(mockExecuteCommand).not.toHaveBeenCalled();
+    });
+    it('runs validateArgs before executeCommand so missing media does not dispatch the browser command', async () => {
+        const program = new Command();
+        const siteCmd = program.command('instagram');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'instagram', 'post', 'caption only']);
+        expect(mockExecuteCommand).not.toHaveBeenCalled();
+        expect(process.exitCode).toBeDefined();
+    });
+});
 describe('commanderAdapter command aliases', () => {
     const cmd = {
         site: 'notebooklm',

package/dist/completion.js

@@ -21,7 +21,9 @@ const BUILTIN_COMMANDS = [
     'generate',
     'cascade',
     'doctor',
-    'setup',
+    'plugin',
+    'install',
+    'register',
     'completion',
 ];
 /**

package/dist/completion.test.d.ts

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

package/dist/completion.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest';
+const { mockGetRegistry } = vi.hoisted(() => ({
+    mockGetRegistry: vi.fn(() => new Map([
+        ['github/issues', { site: 'github', name: 'issues' }],
+    ])),
+}));
+vi.mock('./registry.js', () => ({
+    getRegistry: mockGetRegistry,
+}));
+import { getCompletions } from './completion.js';
+describe('getCompletions', () => {
+    it('includes top-level built-ins that are registered outside the site registry', () => {
+        const completions = getCompletions([], 1);
+        expect(completions).toContain('plugin');
+        expect(completions).toContain('install');
+        expect(completions).toContain('register');
+        expect(completions).not.toContain('setup');
+    });
+    it('still includes discovered site names', () => {
+        const completions = getCompletions([], 1);
+        expect(completions).toContain('github');
+    });
+});

package/dist/doctor.js

@@ -55,7 +55,7 @@ export async function runBrowserDoctor(opts = {}) {
         issues.push('Daemon is not running. It should start automatically when you run an opencli browser command.');
     }
     if (status.running && !status.extensionConnected) {
-        issues.push('Daemon is running but the Chrome extension is not connected.\n' +
+        issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
             'Please install the opencli Browser Bridge extension:\n' +
             '  1. Download from https://github.com/jackwener/opencli/releases\n' +
             '  2. Open chrome://extensions/ → Enable Developer Mode\n' +

package/dist/electron-apps.d.ts

@@ -9,6 +9,8 @@ export interface ElectronAppEntry {
     port: number;
     /** macOS process name for detection via pgrep */
     processName: string;
+    /** Candidate executable names inside Contents/MacOS/, tried in order */
+    executableNames?: string[];
     /** macOS bundle ID for path discovery */
     bundleId?: string;
     /** Human-readable name for prompts */

package/dist/electron-apps.js

@@ -15,7 +15,13 @@ export const builtinApps = {
     notion: { port: 9230, processName: 'Notion', bundleId: 'notion.id', displayName: 'Notion' },
     'discord-app': { port: 9232, processName: 'Discord', bundleId: 'com.discord.app', displayName: 'Discord' },
     'doubao-app': { port: 9225, processName: 'Doubao', bundleId: 'com.volcengine.doubao', displayName: 'Doubao' },
-    antigravity: { port: 9234, processName: 'Antigravity', bundleId: 'dev.antigravity.app', displayName: 'Antigravity' },
+    antigravity: {
+        port: 9234,
+        processName: 'Antigravity',
+        executableNames: ['Electron', 'Antigravity'],
+        bundleId: 'dev.antigravity.app',
+        displayName: 'Antigravity',
+    },
     chatgpt: { port: 9236, processName: 'ChatGPT', bundleId: 'com.openai.chat', displayName: 'ChatGPT' },
 };
 /** Merge builtin + user-defined apps. User entries are additive only. */

package/dist/errors.js

@@ -72,7 +72,7 @@ export class ConfigError extends CliError {
 export class AuthRequiredError extends CliError {
     domain;
     constructor(domain, message) {
-        super('AUTH_REQUIRED', message ?? `Not logged in to ${domain}`, `Please open Chrome and log in to https://${domain}`, EXIT_CODES.NOPERM);
+        super('AUTH_REQUIRED', message ?? `Not logged in to ${domain}`, `Please open Chrome or Chromium and log in to https://${domain}`, EXIT_CODES.NOPERM);
         this.domain = domain;
     }
 }