@jackwener/opencli 1.7.3 → 1.7.4

package/dist/src/browser/target-resolver.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { resolveTargetJs } from './target-resolver.js';
+/**
+ * Tests for the target resolver JS generator.
+ *
+ * Since resolveTargetJs() produces JS strings for browser evaluate(),
+ * we test the generated JS by running it in a simulated DOM-like context
+ * and verifying the structure of the output.
+ */
+describe('resolveTargetJs', () => {
+    it('generates JS that returns structured resolution for numeric ref', () => {
+        const js = resolveTargetJs('12');
+        expect(js).toContain('data-opencli-ref');
+        expect(js).toContain('__opencli_ref_identity');
+        expect(js).toContain('"12"');
+    });
+    it('generates JS that handles CSS selector input', () => {
+        const js = resolveTargetJs('#submit-btn');
+        expect(js).toContain('querySelectorAll');
+        expect(js).toContain('"#submit-btn"');
+    });
+    it('generates JS with stale_ref detection for numeric refs', () => {
+        const js = resolveTargetJs('5');
+        expect(js).toContain('stale_ref');
+        expect(js).toContain('__opencli_ref_identity');
+    });
+    it('generates JS with ambiguity detection for CSS selectors', () => {
+        const js = resolveTargetJs('.btn');
+        expect(js).toContain('ambiguous');
+        expect(js).toContain('candidates');
+    });
+    it('generates JS that rejects unrecognized input', () => {
+        const js = resolveTargetJs('???');
+        expect(js).toContain('not_found');
+        expect(js).toContain('Cannot parse target');
+    });
+    it('escapes ref value safely', () => {
+        const js = resolveTargetJs('"; alert(1); "');
+        // JSON.stringify should handle escaping
+        expect(js).not.toContain('alert(1); "');
+        expect(js).toContain('\\"');
+    });
+});

package/dist/src/browser.test.js

@@ -112,13 +112,15 @@ describe('BrowserBridge state', () => {
         bridge._state = 'closing';
         await expect(bridge.connect()).rejects.toThrow('Session is closing');
     });
-    it('fails fast when daemon is running but extension is disconnected', async () => {
+    it('fails fast when daemon is running but extension is disconnected (same version)', async () => {
+        const { PKG_VERSION } = await import('./version.js');
         vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
             state: 'no-extension',
             status: {
                 ok: true,
                 pid: 1,
                 uptime: 0,
+                daemonVersion: PKG_VERSION,
                 extensionConnected: false,
                 pending: 0,
                 memoryMB: 0,
@@ -128,6 +130,41 @@ describe('BrowserBridge state', () => {
         const bridge = new BrowserBridge();
         await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Bridge extension not connected');
     });
+    it('attempts stale daemon replacement when daemonVersion is missing', async () => {
+        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
+            state: 'no-extension',
+            status: {
+                ok: true,
+                pid: 1,
+                uptime: 0,
+                extensionConnected: false,
+                pending: 0,
+                memoryMB: 0,
+                port: 0,
+            },
+        });
+        vi.spyOn(daemonClient, 'requestDaemonShutdown').mockResolvedValue(false);
+        const bridge = new BrowserBridge();
+        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Stale daemon could not be replaced');
+    });
+    it('attempts stale daemon replacement when daemonVersion mismatches', async () => {
+        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({
+            state: 'no-extension',
+            status: {
+                ok: true,
+                pid: 1,
+                uptime: 0,
+                daemonVersion: '0.0.1',
+                extensionConnected: false,
+                pending: 0,
+                memoryMB: 0,
+                port: 0,
+            },
+        });
+        vi.spyOn(daemonClient, 'requestDaemonShutdown').mockResolvedValue(false);
+        const bridge = new BrowserBridge();
+        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Stale daemon could not be replaced');
+    });
 });
 describe('stealth anti-detection', () => {
     it('generates non-empty JS string', () => {

package/dist/src/cli.js

@@ -18,8 +18,10 @@ import { PKG_VERSION } from './version.js';
 import { printCompletionScript } from './completion.js';
 import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled } from './external.js';
 import { registerAllCommands } from './commanderAdapter.js';
-import { EXIT_CODES, getErrorMessage } from './errors.js';
-import { daemonStop } from './commands/daemon.js';
+import { EXIT_CODES, getErrorMessage, BrowserConnectError } from './errors.js';
+import { TargetError } from './browser/target-errors.js';
+import { resolveTargetJs, getTextResolvedJs, getValueResolvedJs, getAttributesResolvedJs, selectResolvedJs, isAutocompleteResolvedJs } from './browser/target-resolver.js';
+import { daemonStatus, daemonStop } from './commands/daemon.js';
 import { log } from './logger.js';
 const CLI_FILE = fileURLToPath(import.meta.url);
 /** Create a browser page for browser commands. Uses a dedicated browser workspace for session persistence. */
@@ -249,6 +251,13 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     const browser = program
         .command('browser')
         .description('Browser control — navigate, click, type, extract, wait (no LLM needed)');
+    /** Resolve a ref/CSS target via the unified resolver, throwing TargetError on failure. */
+    async function resolveRef(page, ref) {
+        const resolution = await page.evaluate(resolveTargetJs(ref));
+        if (!resolution.ok) {
+            throw new TargetError(resolution);
+        }
+    }
     /** Wrap browser actions with error handling and optional --json output */
     function browserAction(fn) {
         return async (...args) => {
@@ -257,15 +266,28 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
                 await fn(page, ...args);
             }
             catch (err) {
-                const msg = getErrorMessage(err);
-                if (msg.includes('Extension not connected') || msg.includes('Daemon')) {
-                    log.error(`Browser not connected. Run 'opencli doctor' to diagnose.`);
+                if (err instanceof BrowserConnectError) {
+                    log.error(err.message);
+                    if (err.hint)
+                        log.error(`Hint: ${err.hint}`);
                 }
-                else if (msg.includes('attach failed') || msg.includes('chrome-extension://')) {
-                    log.error(`Browser attach failed — another extension may be interfering. Try disabling 1Password.`);
+                else if (err instanceof TargetError) {
+                    log.error(`[${err.code}] ${err.message}`);
+                    if (err.hint)
+                        log.error(`Hint: ${err.hint}`);
+                    if (err.candidates?.length) {
+                        log.error('Candidates:');
+                        err.candidates.forEach((c, i) => log.error(`  ${i + 1}. ${c}`));
+                    }
                 }
                 else {
-                    log.error(msg);
+                    const msg = getErrorMessage(err);
+                    if (msg.includes('attach failed') || msg.includes('chrome-extension://')) {
+                        log.error(`Browser attach failed — another extension may be interfering. Try disabling 1Password.`);
+                    }
+                    else {
+                        log.error(msg);
+                    }
                 }
                 process.exitCode = EXIT_CODES.GENERIC_ERROR;
             }
@@ -277,7 +299,7 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     browser.command('open').argument('<url>').description('Open URL in automation window')
         .action(browserAction(async (page, url) => {
         // Start session-level capture before navigation (catches initial requests)
-        const hasSessionCapture = await page.startNetworkCapture?.().then(() => true).catch(() => false);
+        const hasSessionCapture = await page.startNetworkCapture?.() ?? false;
         await page.goto(url);
         await page.wait(2);
         // Fallback: inject JS interceptor when session capture is unavailable
@@ -337,12 +359,14 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     }));
     get.command('text').argument('<index>', 'Element index').description('Element text content')
         .action(browserAction(async (page, index) => {
-        const text = await page.evaluate(`((idx) => document.querySelector('[data-opencli-ref="' + idx + '"]')?.textContent?.trim())(${JSON.stringify(String(index))})`);
+        await resolveRef(page, String(index));
+        const text = await page.evaluate(getTextResolvedJs());
         console.log(text ?? '(empty)');
     }));
     get.command('value').argument('<index>', 'Element index').description('Input/textarea value')
         .action(browserAction(async (page, index) => {
-        const val = await page.evaluate(`((idx) => document.querySelector('[data-opencli-ref="' + idx + '"]')?.value)(${JSON.stringify(String(index))})`);
+        await resolveRef(page, String(index));
+        const val = await page.evaluate(getValueResolvedJs());
         console.log(val ?? '(empty)');
     }));
     get.command('html').option('--selector <css>', 'CSS selector scope').description('Page HTML (or scoped)')
@@ -353,7 +377,8 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     }));
     get.command('attributes').argument('<index>', 'Element index').description('Element attributes')
         .action(browserAction(async (page, index) => {
-        const attrs = await page.evaluate(`((idx) => JSON.stringify(Object.fromEntries([...document.querySelector('[data-opencli-ref="' + idx + '"]')?.attributes].map(a=>[a.name,a.value]))))(${JSON.stringify(String(index))})`);
+        await resolveRef(page, String(index));
+        const attrs = await page.evaluate(getAttributesResolvedJs());
         console.log(attrs ?? '{}');
     }));
     // ── Interact ──
@@ -369,17 +394,8 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         await page.wait(0.3);
         await page.typeText(index, text);
         // Detect autocomplete/combobox fields and wait for dropdown suggestions
-        const safeIndex = JSON.stringify(String(index));
-        const isAutocomplete = await page.evaluate(`
-        (() => {
-          const el = document.querySelector('[data-opencli-ref="' + ${safeIndex} + '"]');
-          if (!el) return false;
-          const role = el.getAttribute('role');
-          const ac = el.getAttribute('aria-autocomplete');
-          const list = el.getAttribute('list');
-          return role === 'combobox' || ac === 'list' || ac === 'both' || !!list;
-        })()
-      `);
+        // __resolved is already set by typeText's resolver call
+        const isAutocomplete = await page.evaluate(isAutocompleteResolvedJs());
         if (isAutocomplete) {
             await page.wait(0.4);
             console.log(`Typed "${text}" into autocomplete [${index}] — use state to see suggestions`);
@@ -391,20 +407,8 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     browser.command('select').argument('<index>', 'Element index of <select>').argument('<option>', 'Option text')
         .description('Select dropdown option')
         .action(browserAction(async (page, index, option) => {
-        const safeIdx = JSON.stringify(String(index));
-        const result = await page.evaluate(`
-        (function() {
-          var sel = document.querySelector('[data-opencli-ref="' + ${safeIdx} + '"]');
-          if (!sel || sel.tagName !== 'SELECT') return { error: 'Not a <select>' };
-          var match = Array.from(sel.options).find(o => o.text.trim() === ${JSON.stringify(option)} || o.value === ${JSON.stringify(option)});
-          if (!match) return { error: 'Option not found', available: Array.from(sel.options).map(o => o.text.trim()) };
-          var setter = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, 'value')?.set;
-          if (setter) setter.call(sel, match.value); else sel.value = match.value;
-          sel.dispatchEvent(new Event('input', {bubbles:true}));
-          sel.dispatchEvent(new Event('change', {bubbles:true}));
-          return { selected: match.text };
-        })()
-      `);
+        await resolveRef(page, String(index));
+        const result = await page.evaluate(selectResolvedJs(option));
         if (result?.error) {
             console.error(`Error: ${result.error}${result.available ? ` — Available: ${result.available.join(', ')}` : ''}`);
             process.exitCode = EXIT_CODES.GENERIC_ERROR;
@@ -1003,6 +1007,10 @@ cli({
     });
     // ── Built-in: daemon ──────────────────────────────────────────────────────
     const daemonCmd = program.command('daemon').description('Manage the opencli daemon');
+    daemonCmd
+        .command('status')
+        .description('Show daemon status')
+        .action(async () => { await daemonStatus(); });
     daemonCmd
         .command('stop')
         .description('Stop the daemon')

package/dist/src/commands/daemon.d.ts

@@ -1,5 +1,7 @@
 /**
- * CLI command for daemon lifecycle:
- *   opencli daemon stop — graceful shutdown
+ * CLI commands for daemon lifecycle:
+ *   opencli daemon status — show daemon state
+ *   opencli daemon stop   — graceful shutdown
  */
+export declare function daemonStatus(): Promise<void>;
 export declare function daemonStop(): Promise<void>;

package/dist/src/commands/daemon.js

@@ -1,9 +1,29 @@
 /**
- * CLI command for daemon lifecycle:
- *   opencli daemon stop — graceful shutdown
+ * CLI commands for daemon lifecycle:
+ *   opencli daemon status — show daemon state
+ *   opencli daemon stop   — graceful shutdown
  */
+import { styleText } from 'node:util';
 import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
+import { formatDuration } from '../download/progress.js';
 import { log } from '../logger.js';
+export async function daemonStatus() {
+    const status = await fetchDaemonStatus();
+    if (!status) {
+        console.log(`Daemon: ${styleText('dim', 'not running')}`);
+        return;
+    }
+    const extensionLabel = !status.extensionConnected
+        ? styleText('yellow', 'disconnected')
+        : status.extensionVersion
+            ? `${styleText('green', 'connected')} ${styleText('dim', `(v${status.extensionVersion})`)}`
+            : `${styleText('yellow', 'connected')} ${styleText('dim', '(version unknown)')}`;
+    console.log(`Daemon: ${styleText('green', 'running')} (PID ${status.pid})`);
+    console.log(`Uptime: ${formatDuration(Math.round(status.uptime * 1000))}`);
+    console.log(`Extension: ${extensionLabel}`);
+    console.log(`Memory: ${status.memoryMB} MB`);
+    console.log(`Port: ${status.port}`);
+}
 export async function daemonStop() {
     const status = await fetchDaemonStatus();
     if (!status) {

package/dist/src/commands/daemon.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 const { fetchDaemonStatusMock, requestDaemonShutdownMock, } = vi.hoisted(() => ({
     fetchDaemonStatusMock: vi.fn(),
     requestDaemonShutdownMock: vi.fn(),
@@ -7,7 +7,70 @@ vi.mock('../browser/daemon-client.js', () => ({
     fetchDaemonStatus: fetchDaemonStatusMock,
     requestDaemonShutdown: requestDaemonShutdownMock,
 }));
-import { daemonStop } from './daemon.js';
+import { daemonStatus, daemonStop } from './daemon.js';
+describe('daemonStatus', () => {
+    let stdoutSpy;
+    beforeEach(() => {
+        stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        fetchDaemonStatusMock.mockReset();
+        requestDaemonShutdownMock.mockReset();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('reports "not running" when daemon is unreachable', async () => {
+        fetchDaemonStatusMock.mockResolvedValue(null);
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+    });
+    it('shows daemon info when running', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 12345,
+            uptime: 3661,
+            extensionConnected: true,
+            extensionVersion: '1.6.8',
+            pending: 0,
+            memoryMB: 64,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('v1.6.8'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('64 MB'));
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('19825'));
+    });
+    it('shows disconnected when extension is not connected', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 99,
+            uptime: 120,
+            extensionConnected: false,
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
+    });
+    it('shows version unknown when the connected extension does not report one', async () => {
+        fetchDaemonStatusMock.mockResolvedValue({
+            ok: true,
+            pid: 99,
+            uptime: 120,
+            extensionConnected: true,
+            extensionVersion: undefined,
+            pending: 0,
+            memoryMB: 32,
+            port: 19825,
+        });
+        await daemonStatus();
+        expect(stdoutSpy).toHaveBeenCalledWith(expect.stringContaining('version unknown'));
+    });
+});
 describe('daemonStop', () => {
     let stderrSpy;
     beforeEach(() => {

package/dist/src/daemon.js

@@ -23,6 +23,7 @@ import { WebSocketServer, WebSocket } from 'ws';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { EXIT_CODES } from './errors.js';
 import { log } from './logger.js';
+import { PKG_VERSION } from './version.js';
 const PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 // ─── State ───────────────────────────────────────────────────────────
 let extensionWs = null;
@@ -110,6 +111,7 @@ async function handleRequest(req, res) {
             ok: true,
             pid: process.pid,
             uptime,
+            daemonVersion: PKG_VERSION,
             extensionConnected: extensionWs?.readyState === WebSocket.OPEN,
             extensionVersion,
             extensionCompatRange,

package/dist/src/doctor.d.ts

@@ -18,6 +18,7 @@ export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
     daemonFlaky?: boolean;
+    daemonVersion?: string;
     extensionConnected: boolean;
     extensionFlaky?: boolean;
     extensionVersion?: string;

package/dist/src/doctor.js

@@ -87,6 +87,7 @@ export async function runBrowserDoctor(opts = {}) {
     const sessions = opts.sessions && health.state === 'ready'
         ? await listSessions()
         : undefined;
+    const extensionVersion = health.status?.extensionVersion;
     const issues = [];
     if (daemonFlaky) {
         issues.push('Daemon connectivity is unstable. The live browser test succeeded, but the daemon was no longer running immediately afterward.\n' +
@@ -100,16 +101,33 @@ export async function runBrowserDoctor(opts = {}) {
             'This usually means the Browser Bridge service worker is reconnecting slowly or Chrome suspended it.');
     }
     else if (daemonRunning && !extensionConnected) {
-        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' +
-            '  3. Click "Load unpacked" → select the extension folder');
+        const daemonVersion = health.status?.daemonVersion;
+        const isStale = opts.cliVersion && (!daemonVersion || daemonVersion !== opts.cliVersion);
+        if (isStale) {
+            const reason = daemonVersion
+                ? `daemon v${daemonVersion} ≠ CLI v${opts.cliVersion}`
+                : `daemon predates version reporting, CLI is v${opts.cliVersion}`;
+            issues.push(`Stale daemon detected: ${reason}.\n` +
+                'The daemon was started by an older CLI version and may have missed the extension registration.\n' +
+                '  Quick fix: opencli daemon stop && opencli doctor');
+        }
+        else {
+            issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
+                'If the extension is already installed, try: opencli daemon stop && opencli doctor\n' +
+                'If the extension is not installed:\n' +
+                '  1. Download from https://github.com/jackwener/opencli/releases\n' +
+                '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
+                '  3. Click "Load unpacked" → select the extension folder');
+        }
+    }
+    if (extensionConnected && !extensionVersion) {
+        issues.push('Extension is connected but did not report a version.\n' +
+            '  This usually means an outdated Browser Bridge extension.\n' +
+            '  Reload or reinstall the extension from: https://github.com/jackwener/opencli/releases');
     }
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
-    const extensionVersion = health.status?.extensionVersion;
     const extensionCompatRange = health.status?.extensionCompatRange;
     if (extensionVersion && opts.cliVersion && extensionCompatRange) {
         if (!satisfiesRange(opts.cliVersion, extensionCompatRange)) {
@@ -137,6 +155,7 @@ export async function runBrowserDoctor(opts = {}) {
         cliVersion: opts.cliVersion,
         daemonRunning,
         daemonFlaky,
+        daemonVersion: health.status?.daemonVersion,
         extensionConnected,
         extensionFlaky,
         extensionVersion,
@@ -154,16 +173,20 @@ export function renderBrowserDoctorReport(report) {
         : report.daemonRunning ? styleText('green', '[OK]') : styleText('red', '[MISSING]');
     const daemonLabel = report.daemonFlaky
         ? 'unstable (running during live check, then stopped)'
-        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running';
+        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` + (report.daemonVersion ? ` (v${report.daemonVersion})` : '') : 'not running';
     lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
-    const extIcon = report.extensionFlaky
+    const extIcon = report.extensionFlaky || (report.extensionConnected && !report.extensionVersion)
         ? styleText('yellow', '[WARN]')
         : report.extensionConnected ? styleText('green', '[OK]') : styleText('yellow', '[MISSING]');
     const extUpdateHint = report.extensionVersion && report.latestExtensionVersion && isNewerVersion(report.latestExtensionVersion, report.extensionVersion)
         ? styleText('yellow', ` → v${report.latestExtensionVersion} available`)
         : '';
-    const extVersion = report.extensionVersion ? styleText('dim', ` (v${report.extensionVersion})`) + extUpdateHint : '';
+    const extVersion = !report.extensionConnected
+        ? ''
+        : report.extensionVersion
+            ? styleText('dim', ` (v${report.extensionVersion})`) + extUpdateHint
+            : styleText('dim', ' (version unknown)');
     const extLabel = report.extensionFlaky
         ? 'unstable (connected during live check, then disconnected)'
         : report.extensionConnected ? 'connected' : 'not connected';

package/dist/src/doctor.test.js

@@ -25,10 +25,11 @@ describe('doctor report rendering', () => {
         const text = strip(renderBrowserDoctorReport({
             daemonRunning: true,
             extensionConnected: true,
+            extensionVersion: '1.6.8',
             issues: [],
         }));
         expect(text).toContain('[OK] Daemon: running on port 19825');
-        expect(text).toContain('[OK] Extension: connected');
+        expect(text).toContain('[OK] Extension: connected (v1.6.8)');
         expect(text).toContain('Everything looks good!');
     });
     it('renders MISSING when daemon not running', () => {
@@ -50,6 +51,16 @@ describe('doctor report rendering', () => {
         expect(text).toContain('[OK] Daemon: running on port 19825');
         expect(text).toContain('[MISSING] Extension: not connected');
     });
+    it('renders a warning when the extension version is unknown', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            extensionConnected: true,
+            issues: ['Extension is connected but did not report a version.'],
+        }));
+        expect(text).toContain('[WARN] Extension: connected (version unknown)');
+        expect(text).toContain('Extension is connected but did not report a version.');
+        expect(text).not.toContain('Everything looks good!');
+    });
     it('renders connectivity OK when live test succeeds', () => {
         const text = strip(renderBrowserDoctorReport({
             daemonRunning: true,
@@ -90,12 +101,8 @@ describe('doctor report rendering', () => {
         expect(text).toContain('Daemon connectivity is unstable.');
     });
     it('reports daemon not running when no-live and auto-start fails', async () => {
-        // no-live mode: getDaemonHealth called twice (initial check + final status)
-        // Initial: stopped → triggers auto-start attempt
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
-        // Auto-start fails
         mockConnect.mockRejectedValueOnce(new Error('Could not start daemon'));
-        // Final: still stopped
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
         const report = await runBrowserDoctor({ live: false });
         expect(report.daemonRunning).toBe(false);
@@ -106,12 +113,10 @@ describe('doctor report rendering', () => {
         ]));
     });
     it('reports flapping when live check succeeds but final status shows extension disconnected', async () => {
-        // Live check succeeds
         mockConnect.mockResolvedValueOnce({
             evaluate: vi.fn().mockResolvedValue(2),
         });
         mockClose.mockResolvedValueOnce(undefined);
-        // After live check, getDaemonHealth shows no-extension
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
         const report = await runBrowserDoctor({ live: true });
         expect(report.daemonRunning).toBe(true);
@@ -122,12 +127,10 @@ describe('doctor report rendering', () => {
         ]));
     });
     it('reports daemon flapping when live check succeeds but daemon disappears afterward', async () => {
-        // Live check succeeds
         mockConnect.mockResolvedValueOnce({
             evaluate: vi.fn().mockResolvedValue(2),
         });
         mockClose.mockResolvedValueOnce(undefined);
-        // After live check, getDaemonHealth shows stopped
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
         const report = await runBrowserDoctor({ live: true });
         expect(report.daemonRunning).toBe(false);
@@ -151,14 +154,27 @@ describe('doctor report rendering', () => {
         expect(timeoutSeen).toBe(8);
     });
     it('skips auto-start in no-live mode when daemon is already running', async () => {
-        // no-live mode but daemon already running (no-extension)
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
-        // Final status: same
         mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
         const report = await runBrowserDoctor({ live: false });
-        // Should NOT have tried auto-start since daemon was already running
         expect(mockConnect).not.toHaveBeenCalled();
         expect(report.daemonRunning).toBe(true);
         expect(report.extensionConnected).toBe(false);
     });
+    it('reports an issue when the extension is connected but does not report a version', async () => {
+        const status = {
+            state: 'ready',
+            status: {
+                extensionConnected: true,
+                extensionVersion: undefined,
+            },
+        };
+        mockGetDaemonHealth
+            .mockResolvedValueOnce(status)
+            .mockResolvedValueOnce(status);
+        const report = await runBrowserDoctor({ live: false });
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('did not report a version'),
+        ]));
+    });
 });

package/dist/src/external-clis.yaml

@@ -36,8 +36,8 @@
   homepage: "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli"
   tags: [dingtalk, collaboration, productivity, ai-agent]
   install:
-    mac: "curl -fsSL https://raw.githubusercontent.com/DingTalk-Real-AI/dingtalk-workspace-cli/main/scripts/install.sh | sh"
-    linux: "curl -fsSL https://raw.githubusercontent.com/DingTalk-Real-AI/dingtalk-workspace-cli/main/scripts/install.sh | sh"
+    mac: "npm install -g dingtalk-workspace-cli"
+    linux: "npm install -g dingtalk-workspace-cli"
 
 - name: wecom-cli
   binary: wecom-cli

package/dist/src/logger.d.ts

@@ -15,9 +15,9 @@ export declare const log: {
     warn(msg: string): void;
     /** Error (always shown) */
     error(msg: string): void;
-    /** Verbose output (shown when -v flag, OPENCLI_VERBOSE, or DEBUG=opencli is set) */
+    /** Verbose output (shown when -v flag or OPENCLI_VERBOSE is set) */
     verbose(msg: string): void;
-    /** @deprecated Use log.verbose() instead. Kept as alias for backward compatibility. */
+    /** Alias for verbose output. */
     debug(msg: string): void;
     /** Step-style debug (for pipeline steps, etc.) */
     step(stepNum: number, total: number, op: string, preview?: string): void;

package/dist/src/logger.js

@@ -6,7 +6,7 @@
  */
 import { styleText } from 'node:util';
 function isVerbose() {
-    return !!process.env.OPENCLI_VERBOSE || !!process.env.DEBUG?.includes('opencli');
+    return !!process.env.OPENCLI_VERBOSE;
 }
 export const log = {
     /** Informational message (always shown) */
@@ -29,13 +29,13 @@ export const log = {
     error(msg) {
         process.stderr.write(`${styleText('red', '✖')}  ${msg}\n`);
     },
-    /** Verbose output (shown when -v flag, OPENCLI_VERBOSE, or DEBUG=opencli is set) */
+    /** Verbose output (shown when -v flag or OPENCLI_VERBOSE is set) */
     verbose(msg) {
         if (isVerbose()) {
             process.stderr.write(`${styleText('dim', '[verbose]')} ${msg}\n`);
         }
     },
-    /** @deprecated Use log.verbose() instead. Kept as alias for backward compatibility. */
+    /** Alias for verbose output. */
     debug(msg) {
         this.verbose(msg);
     },

package/dist/src/output.js

@@ -17,12 +17,8 @@ function resolveColumns(rows, opts) {
 export function render(data, opts = {}) {
     let fmt = opts.fmt ?? 'table';
     // Non-TTY auto-downgrade only when format was NOT explicitly passed by user.
-    // Priority: explicit -f (any value) > OUTPUT env var > TTY auto-detect > table
     if (!opts.fmtExplicit) {
-        const envFmt = process.env.OUTPUT?.trim().toLowerCase();
-        if (envFmt)
-            fmt = envFmt;
-        else if (fmt === 'table' && !process.stdout.isTTY)
+        if (fmt === 'table' && !process.stdout.isTTY)
             fmt = 'yaml';
     }
     if (data === null || data === undefined) {