@jackwener/opencli 1.4.1 → 1.5.0

package/dist/clis/xiaohongshu/publish.js

@@ -57,14 +57,22 @@ async function injectImages(page, images) {
     (async () => {
       const images = ${payload};
 
-      // Prefer image/* file inputs; fall back to the first available input.
+      // Only use image-capable file inputs. Do not fall back to a generic uploader,
+      // otherwise we can accidentally feed images into the video upload flow.
       const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
       const input = inputs.find(el => {
         const accept = el.getAttribute('accept') || '';
-        return accept.includes('image') || accept.includes('.jpg') || accept.includes('.png');
-      }) || inputs[0];
+        return (
+          accept.includes('image') ||
+          accept.includes('.jpg') ||
+          accept.includes('.jpeg') ||
+          accept.includes('.png') ||
+          accept.includes('.gif') ||
+          accept.includes('.webp')
+        );
+      });
 
-      if (!input) return { ok: false, count: 0, error: 'No file input found on page' };
+      if (!input) return { ok: false, count: 0, error: 'No image file input found on page' };
 
       const dt = new DataTransfer();
       for (const img of images) {
@@ -141,6 +149,99 @@ async function fillField(page, selectors, text, fieldName) {
         throw new Error(`Could not find ${fieldName} input. Debug screenshot: /tmp/xhs_publish_${fieldName}_debug.png`);
     }
 }
+async function selectImageTextTab(page) {
+    const result = await page.evaluate(`
+    () => {
+      const isVisible = (el) => {
+        if (!el || el.offsetParent === null) return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const selector = 'button, [role="tab"], [role="button"], a, label, div, span, li';
+      const nodes = Array.from(document.querySelectorAll(selector));
+      const targets = ['上传图文', '图文', '图片'];
+
+      for (const target of targets) {
+        for (const node of nodes) {
+          if (!isVisible(node)) continue;
+          const text = normalize(node.innerText || node.textContent || '');
+          if (!text || text.includes('视频')) continue;
+          if (text === target || text.startsWith(target) || text.includes(target)) {
+            const clickable = node.closest('button, [role="tab"], [role="button"], a, label') || node;
+            clickable.click();
+            return { ok: true, target, text };
+          }
+        }
+      }
+
+      const visibleTexts = [];
+      for (const node of nodes) {
+        if (!isVisible(node)) continue;
+        const text = normalize(node.innerText || node.textContent || '');
+        if (!text || text.length > 20) continue;
+        visibleTexts.push(text);
+        if (visibleTexts.length >= 20) break;
+      }
+      return { ok: false, visibleTexts };
+    }
+  `);
+    if (result?.ok) {
+        await page.wait({ time: 1 });
+    }
+    return result;
+}
+async function inspectPublishSurface(page) {
+    return page.evaluate(`
+    () => {
+      const text = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim();
+      const hasTitleInput = !!Array.from(document.querySelectorAll('input, textarea')).find((el) => {
+        if (!el || el.offsetParent === null) return false;
+        const placeholder = (el.getAttribute('placeholder') || '').trim();
+        const cls = el.className ? String(el.className) : '';
+        const maxLength = Number(el.getAttribute('maxlength') || 0);
+        return (
+          placeholder.includes('标题') ||
+          /title/i.test(placeholder) ||
+          /title/i.test(cls) ||
+          maxLength === 20
+        );
+      });
+      const hasImageInput = !!Array.from(document.querySelectorAll('input[type="file"]')).find((el) => {
+        const accept = el.getAttribute('accept') || '';
+        return (
+          accept.includes('image') ||
+          accept.includes('.jpg') ||
+          accept.includes('.jpeg') ||
+          accept.includes('.png') ||
+          accept.includes('.gif') ||
+          accept.includes('.webp')
+        );
+      });
+      return {
+        hasTitleInput,
+        hasImageInput,
+        hasVideoSurface: text.includes('拖拽视频到此处点击上传') || text.includes('上传视频'),
+      };
+    }
+  `);
+}
+async function waitForImageTextSurface(page, maxWaitMs = 5_000) {
+    const pollMs = 500;
+    const maxAttempts = Math.max(1, Math.ceil(maxWaitMs / pollMs));
+    let surface = await inspectPublishSurface(page);
+    for (let i = 0; i < maxAttempts; i++) {
+        if (surface.hasTitleInput || surface.hasImageInput || !surface.hasVideoSurface) {
+            return surface;
+        }
+        if (i < maxAttempts - 1) {
+            await page.wait({ time: pollMs / 1_000 });
+            surface = await inspectPublishSurface(page);
+        }
+    }
+    return surface;
+}
 cli({
     site: 'xiaohongshu',
     name: 'publish',
@@ -189,21 +290,16 @@ cli({
                 'Re-capture browser login via: opencli xiaohongshu creator-profile');
         }
         // ── Step 2: Select 图文 (image+text) note type if tabs are present ─────────
-        const tabClicked = await page.evaluate(`
-      () => {
-        const allEls = document.querySelectorAll('[class*="tab"], [class*="note-type"], [class*="type-item"]');
-        for (const el of allEls) {
-          const text = el.innerText || el.textContent || '';
-          if ((text.includes('图文') || text.includes('图片')) && el.offsetParent !== null) {
-            el.click();
-            return true;
-          }
+        const tabResult = await selectImageTextTab(page);
+        const surface = await waitForImageTextSurface(page, tabResult?.ok ? 5_000 : 2_000);
+        if (!surface.hasTitleInput && !surface.hasImageInput && surface.hasVideoSurface) {
+            await page.screenshot({ path: '/tmp/xhs_publish_tab_debug.png' });
+            const detail = tabResult?.ok
+                ? `clicked "${tabResult.text}"`
+                : `visible candidates: ${(tabResult?.visibleTexts || []).join(' | ') || 'none'}`;
+            throw new Error('Still on the video publish page after trying to select 图文. ' +
+                `Details: ${detail}. Debug screenshot: /tmp/xhs_publish_tab_debug.png`);
         }
-        return false;
-      }
-    `);
-        if (tabClicked)
-            await page.wait({ time: 1 });
         // ── Step 3: Upload images ──────────────────────────────────────────────────
         if (imageData.length > 0) {
             const upload = await injectImages(page, imageData);

package/dist/clis/xiaohongshu/publish.test.d.ts

@@ -0,0 +1 @@
+import './publish.js';

package/dist/clis/xiaohongshu/publish.test.js

@@ -0,0 +1,119 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './publish.js';
+function createPageMock(evaluateResults) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        getCookies: vi.fn().mockResolvedValue([]),
+        screenshot: vi.fn().mockResolvedValue(''),
+    };
+}
+describe('xiaohongshu publish', () => {
+    it('selects the image-text tab and publishes successfully', async () => {
+        const cmd = getRegistry().get('xiaohongshu/publish');
+        expect(cmd?.func).toBeTypeOf('function');
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-xhs-publish-'));
+        const imagePath = path.join(tempDir, 'demo.jpg');
+        fs.writeFileSync(imagePath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+        const page = createPageMock([
+            'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+            { ok: true, target: '上传图文', text: '上传图文' },
+            { hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+            { ok: true, count: 1 },
+            false,
+            { ok: true, sel: 'input[maxlength="20"]' },
+            { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+            true,
+            'https://creator.xiaohongshu.com/publish/success',
+            '发布成功',
+        ]);
+        const result = await cmd.func(page, {
+            title: 'DeepSeek别乱问',
+            content: '一篇真实一点的小红书正文',
+            images: imagePath,
+            topics: '',
+            draft: false,
+        });
+        const evaluateCalls = page.evaluate.mock.calls.map((args) => String(args[0]));
+        expect(evaluateCalls.some((code) => code.includes("const targets = ['上传图文', '图文', '图片']"))).toBe(true);
+        expect(evaluateCalls.some((code) => code.includes("No image file input found on page"))).toBe(true);
+        expect(result).toEqual([
+            {
+                status: '✅ 发布成功',
+                detail: '"DeepSeek别乱问" · 1张图片 · 发布成功',
+            },
+        ]);
+    });
+    it('fails early with a clear error when still on the video page', async () => {
+        const cmd = getRegistry().get('xiaohongshu/publish');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+            { ok: false, visibleTexts: ['上传视频', '上传图文'] },
+            { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+            { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+            { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+            { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+        ]);
+        await expect(cmd.func(page, {
+            title: 'DeepSeek别乱问',
+            content: '一篇真实一点的小红书正文',
+            topics: '',
+            draft: false,
+        })).rejects.toThrow('Still on the video publish page after trying to select 图文');
+        expect(page.screenshot).toHaveBeenCalledWith({ path: '/tmp/xhs_publish_tab_debug.png' });
+    });
+    it('waits for the image-text surface to appear after clicking the tab', async () => {
+        const cmd = getRegistry().get('xiaohongshu/publish');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+            { ok: true, target: '上传图文', text: '上传图文' },
+            { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+            { hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+            { ok: true, sel: 'input[maxlength="20"]' },
+            { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+            true,
+            'https://creator.xiaohongshu.com/publish/success',
+            '发布成功',
+        ]);
+        const result = await cmd.func(page, {
+            title: '延迟切换也能过',
+            content: '图文页切换慢一点也继续等',
+            topics: '',
+            draft: false,
+        });
+        expect(page.wait.mock.calls).toContainEqual([{ time: 0.5 }]);
+        expect(result).toEqual([
+            {
+                status: '✅ 发布成功',
+                detail: '"延迟切换也能过" · 无图 · 发布成功',
+            },
+        ]);
+    });
+});

package/dist/commanderAdapter.d.ts

@@ -11,6 +11,7 @@
  */
 import { Command } from 'commander';
 import { type CliCommand } from './registry.js';
+export declare function normalizeArgValue(argType: string | undefined, value: unknown, name: string): unknown;
 /**
  * Register a single CliCommand as a Commander subcommand.
  */

package/dist/commanderAdapter.js

@@ -14,14 +14,30 @@ import { fullName, getRegistry } from './registry.js';
 import { formatRegistryHelpText } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { executeCommand } from './execution.js';
-import { CliError, ERROR_ICONS, getErrorMessage } from './errors.js';
+import { CliError, ERROR_ICONS, getErrorMessage, BrowserConnectError, AuthRequiredError, TimeoutError, SelectorError, EmptyResultError, ArgumentError, AdapterLoadError, CommandExecutionError, } from './errors.js';
+import { checkDaemonStatus } from './browser/discover.js';
+export function normalizeArgValue(argType, value, name) {
+    if (argType !== 'bool')
+        return value;
+    if (typeof value === 'boolean')
+        return value;
+    if (value == null || value === '')
+        return false;
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'true')
+        return true;
+    if (normalized === 'false')
+        return false;
+    throw new CliError('ARGUMENT', `"${name}" must be either "true" or "false".`);
+}
 /**
  * Register a single CliCommand as a Commander subcommand.
  */
 export function registerCommandToProgram(siteCmd, cmd) {
     if (siteCmd.commands.some((c) => c.name() === cmd.name))
         return;
-    const subCmd = siteCmd.command(cmd.name).description(cmd.description);
+    const deprecatedSuffix = cmd.deprecated ? ' [deprecated]' : '';
+    const subCmd = siteCmd.command(cmd.name).description(`${cmd.description}${deprecatedSuffix}`);
     // Register positional args first, then named options
     const positionalArgs = [];
     for (const arg of cmd.args) {
@@ -48,27 +64,32 @@ export function registerCommandToProgram(siteCmd, cmd) {
         const actionOpts = actionArgs[positionalArgs.length] ?? {};
         const optionsRecord = typeof actionOpts === 'object' && actionOpts !== null ? actionOpts : {};
         const startTime = Date.now();
-        // ── Collect kwargs ──────────────────────────────────────────────────
-        const kwargs = {};
-        for (let i = 0; i < positionalArgs.length; i++) {
-            const v = actionArgs[i];
-            if (v !== undefined)
-                kwargs[positionalArgs[i].name] = v;
-        }
-        for (const arg of cmd.args) {
-            if (arg.positional)
-                continue;
-            const camelName = arg.name.replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
-            const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
-            if (v !== undefined)
-                kwargs[arg.name] = v;
-        }
         // ── Execute + render ────────────────────────────────────────────────
         try {
+            // ── Collect kwargs ────────────────────────────────────────────────
+            const kwargs = {};
+            for (let i = 0; i < positionalArgs.length; i++) {
+                const v = actionArgs[i];
+                if (v !== undefined)
+                    kwargs[positionalArgs[i].name] = v;
+            }
+            for (const arg of cmd.args) {
+                if (arg.positional)
+                    continue;
+                const camelName = arg.name.replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
+                const v = optionsRecord[arg.name] ?? optionsRecord[camelName];
+                if (v !== undefined)
+                    kwargs[arg.name] = normalizeArgValue(arg.type, v, arg.name);
+            }
             const verbose = optionsRecord.verbose === true;
             const format = typeof optionsRecord.format === 'string' ? optionsRecord.format : 'table';
             if (verbose)
                 process.env.OPENCLI_VERBOSE = '1';
+            if (cmd.deprecated) {
+                const message = typeof cmd.deprecated === 'string' ? cmd.deprecated : `${fullName(cmd)} is deprecated.`;
+                const replacement = cmd.replacedBy ? ` Use ${cmd.replacedBy} instead.` : '';
+                console.error(chalk.yellow(`Deprecated: ${message}${replacement}`));
+            }
             const result = await executeCommand(cmd, kwargs, verbose);
             if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
                 console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
@@ -84,22 +105,148 @@ export function registerCommandToProgram(siteCmd, cmd) {
             });
         }
         catch (err) {
-            if (err instanceof CliError) {
-                const icon = ERROR_ICONS[err.code] ?? '⚠️';
-                console.error(chalk.red(`${icon} ${err.message}`));
-                if (err.hint)
-                    console.error(chalk.yellow(`→ ${err.hint}`));
-            }
-            else if (optionsRecord.verbose === true && err instanceof Error && err.stack) {
-                console.error(chalk.red(err.stack));
-            }
-            else {
-                console.error(chalk.red(`Error: ${getErrorMessage(err)}`));
-            }
+            await renderError(err, fullName(cmd), optionsRecord.verbose === true);
             process.exitCode = 1;
         }
     });
 }
+// ── Error rendering ──────────────────────────────────────────────────────────
+const ISSUES_URL = 'https://github.com/jackwener/opencli/issues';
+/** Pattern-based classifier for untyped errors thrown by adapters. */
+function classifyGenericError(msg) {
+    const m = msg.toLowerCase();
+    if (/not logged in|login required|please log in|未登录|请先登录|authentication required|cookie expired/.test(m))
+        return 'auth';
+    // Match "HTTP 404", "status: 500", "status 403", bare "404 Not Found", etc.
+    if (/\b(status[: ]+)?[45]\d{2}\b|http[/ ][45]\d{2}/.test(m))
+        return 'http';
+    if (/not found|未找到|could not find|no .+ found/.test(m))
+        return 'not-found';
+    return 'other';
+}
+/** Render a status line for BrowserConnectError based on real-time or kind-derived state. */
+function renderBridgeStatus(running, extensionConnected) {
+    const ok = chalk.green('✓');
+    const fail = chalk.red('✗');
+    console.error(`  Daemon    ${running ? ok : fail} ${running ? 'running' : 'not running'}`);
+    console.error(`  Extension ${extensionConnected ? ok : fail} ${extensionConnected ? 'connected' : 'not connected'}`);
+    console.error();
+    if (!running) {
+        console.error(chalk.yellow('  Run the command again — daemon should auto-start.'));
+        console.error(chalk.dim('  Still failing? Run: opencli doctor'));
+    }
+    else if (!extensionConnected) {
+        console.error(chalk.yellow('  Install the Browser Bridge extension to continue:'));
+        console.error(chalk.dim('    1. Download from github.com/jackwener/opencli/releases'));
+        console.error(chalk.dim('    2. chrome://extensions → Enable Developer Mode → Load unpacked'));
+    }
+    else {
+        console.error(chalk.yellow('  Connection failed despite extension being active.'));
+        console.error(chalk.dim('  Try reloading the extension, or run: opencli doctor'));
+    }
+}
+async function renderError(err, cmdName, verbose) {
+    // ── BrowserConnectError: real-time diagnosis, kind as fallback ────────
+    if (err instanceof BrowserConnectError) {
+        console.error(chalk.red('🔌 Browser Bridge not connected'));
+        console.error();
+        try {
+            // 300ms matches execution.ts — localhost responds in <50ms when running.
+            const status = await checkDaemonStatus({ timeout: 300 });
+            renderBridgeStatus(status.running, status.extensionConnected);
+        }
+        catch (_statusErr) {
+            // checkDaemonStatus itself failed — derive best-guess state from kind.
+            const running = err.kind !== 'daemon-not-running';
+            const extensionConnected = err.kind === 'command-failed';
+            renderBridgeStatus(running, extensionConnected);
+        }
+        return;
+    }
+    // ── AuthRequiredError ─────────────────────────────────────────────────
+    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.`}`));
+        return;
+    }
+    // ── TimeoutError ──────────────────────────────────────────────────────
+    if (err instanceof TimeoutError) {
+        console.error(chalk.red(`⏱  ${err.message}`));
+        console.error(chalk.yellow('→ Try again, or raise the limit:'));
+        console.error(chalk.dim(`    OPENCLI_BROWSER_COMMAND_TIMEOUT=60 ${cmdName}`));
+        return;
+    }
+    // ── SelectorError / EmptyResultError: likely outdated adapter ─────────
+    if (err instanceof SelectorError || err instanceof EmptyResultError) {
+        const icon = ERROR_ICONS[err.code] ?? '⚠️';
+        console.error(chalk.red(`${icon} ${err.message}`));
+        console.error(chalk.yellow('→ The page structure may have changed — this adapter may be outdated.'));
+        console.error(chalk.dim(`  Debug:  ${cmdName} --verbose`));
+        console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        return;
+    }
+    // ── ArgumentError ─────────────────────────────────────────────────────
+    if (err instanceof ArgumentError) {
+        console.error(chalk.red(`❌ ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── AdapterLoadError ──────────────────────────────────────────────────
+    if (err instanceof AdapterLoadError) {
+        console.error(chalk.red(`📦 ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── CommandExecutionError ─────────────────────────────────────────────
+    if (err instanceof CommandExecutionError) {
+        console.error(chalk.red(`💥 ${err.message}`));
+        if (err.hint) {
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        }
+        else {
+            console.error(chalk.dim(`  Add --verbose for details, or report: ${ISSUES_URL}`));
+        }
+        return;
+    }
+    // ── Other typed CliError (fallback for future codes) ──────────────────
+    if (err instanceof CliError) {
+        const icon = ERROR_ICONS[err.code] ?? '⚠️';
+        console.error(chalk.red(`${icon} ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
+        return;
+    }
+    // ── Generic Error from adapters: classify by message pattern ──────────
+    const msg = getErrorMessage(err);
+    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.'));
+        return;
+    }
+    if (kind === 'http') {
+        console.error(chalk.red(`🌐 ${msg}`));
+        console.error(chalk.yellow('→ Check your login status, or the site may be temporarily unavailable.'));
+        return;
+    }
+    if (kind === 'not-found') {
+        console.error(chalk.red(`📭 ${msg}`));
+        console.error(chalk.yellow('→ The resource was not found. The adapter or page structure may have changed.'));
+        console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        return;
+    }
+    // ── Unknown error: show stack in verbose mode ─────────────────────────
+    if (verbose && err instanceof Error && err.stack) {
+        console.error(chalk.red(err.stack));
+    }
+    else {
+        console.error(chalk.red(`💥 Unexpected error: ${msg}`));
+        console.error(chalk.dim(`  Run with --verbose for details, or report: ${ISSUES_URL}`));
+    }
+}
 /**
  * Register all commands from the registry onto a Commander program.
  */

package/dist/commanderAdapter.test.d.ts

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

package/dist/commanderAdapter.test.js

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
+    mockExecuteCommand: vi.fn(),
+    mockRenderOutput: vi.fn(),
+}));
+vi.mock('./execution.js', () => ({
+    executeCommand: mockExecuteCommand,
+}));
+vi.mock('./output.js', () => ({
+    render: mockRenderOutput,
+}));
+import { registerCommandToProgram } from './commanderAdapter.js';
+describe('commanderAdapter arg passing', () => {
+    const cmd = {
+        site: 'paperreview',
+        name: 'submit',
+        description: 'Submit a PDF',
+        browser: false,
+        args: [
+            { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
+            { name: 'dry-run', type: 'bool', default: false, help: 'Validate only' },
+            { name: 'prepare-only', type: 'bool', default: false, help: 'Prepare only' },
+        ],
+        func: vi.fn(),
+    };
+    beforeEach(() => {
+        mockExecuteCommand.mockReset();
+        mockExecuteCommand.mockResolvedValue([]);
+        mockRenderOutput.mockReset();
+        delete process.env.OPENCLI_VERBOSE;
+        process.exitCode = undefined;
+    });
+    it('passes bool flag values through to executeCommand for coercion', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'false']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.pdf).toBe('./paper.pdf');
+        expect(kwargs).toHaveProperty('dry-run');
+    });
+    it('passes valueless bool flags as true to executeCommand', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--prepare-only']);
+        expect(mockExecuteCommand).toHaveBeenCalled();
+        const kwargs = mockExecuteCommand.mock.calls[0][1];
+        expect(kwargs.pdf).toBe('./paper.pdf');
+        expect(kwargs['prepare-only']).toBe(true);
+    });
+    it('rejects invalid bool values before calling executeCommand', async () => {
+        const program = new Command();
+        const siteCmd = program.command('paperreview');
+        registerCommandToProgram(siteCmd, cmd);
+        await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'maybe']);
+        // normalizeArgValue validates bools eagerly; executeCommand should not be reached
+        expect(mockExecuteCommand).not.toHaveBeenCalled();
+    });
+});

package/dist/daemon.js

@@ -25,6 +25,7 @@ const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_P
 const IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
+let extensionVersion = null;
 const pending = new Map();
 let idleTimer = null;
 const LOG_BUFFER_SIZE = 200;
@@ -103,6 +104,7 @@ async function handleRequest(req, res) {
         jsonResponse(res, 200, {
             ok: true,
             extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
+            extensionVersion,
             pending: pending.size,
         });
         return;
@@ -195,6 +197,11 @@ wss.on('connection', (ws) => {
     ws.on('message', (data) => {
         try {
             const msg = JSON.parse(data.toString());
+            // Handle hello message from extension (version handshake)
+            if (msg.type === 'hello') {
+                extensionVersion = typeof msg.version === 'string' ? msg.version : null;
+                return;
+            }
             // Handle log messages from extension
             if (msg.type === 'log') {
                 const prefix = msg.level === 'error' ? '❌' : msg.level === 'warn' ? '⚠️' : '📋';
@@ -219,6 +226,7 @@ wss.on('connection', (ws) => {
         clearInterval(heartbeatInterval);
         if (extensionWs === ws) {
             extensionWs = null;
+            extensionVersion = null;
             // Reject all pending requests since the extension is gone
             for (const [id, p] of pending) {
                 clearTimeout(p.timer);
@@ -229,8 +237,16 @@ wss.on('connection', (ws) => {
     });
     ws.on('error', () => {
         clearInterval(heartbeatInterval);
-        if (extensionWs === ws)
+        if (extensionWs === ws) {
             extensionWs = null;
+            extensionVersion = null;
+            // Reject pending requests in case 'close' does not follow this 'error'
+            for (const [, p] of pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error('Extension disconnected'));
+            }
+            pending.clear();
+        }
     });
 });
 // ─── Start ───────────────────────────────────────────────────────────