@jackwener/opencli 1.7.2 → 1.7.4

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

@@ -0,0 +1,298 @@
+/**
+ * Unified target resolver for browser actions.
+ *
+ * Replaces the ad-hoc 4-strategy fallback in dom-helpers.ts with a
+ * principled resolution pipeline:
+ *
+ * 1. Input classification: numeric → ref path, CSS-like → CSS path
+ * 2. Ref path: lookup by data-opencli-ref, then verify fingerprint
+ * 3. CSS path: querySelectorAll + uniqueness check
+ * 4. Structured errors: stale_ref / ambiguous / not_found
+ *
+ * All JS is generated as strings for page.evaluate() — runs in the browser.
+ */
+/**
+ * Generate JS that resolves a target to a single DOM element.
+ *
+ * Returns a JS expression that evaluates to:
+ *   { ok: true, el: Element }                      — success (el is assigned to `__resolved`)
+ *   { ok: false, code, message, hint, candidates }  — structured error
+ *
+ * The resolved element is stored in `__resolved` for the caller to use.
+ */
+export function resolveTargetJs(ref) {
+    const safeRef = JSON.stringify(ref);
+    return `
+    (() => {
+      const ref = ${safeRef};
+      const identity = window.__opencli_ref_identity || {};
+
+      // ── Classify input ──
+      const isNumeric = /^\\d+$/.test(ref);
+      const isCssLike = !isNumeric && /^[a-zA-Z#.\\[]/.test(ref);
+
+      if (isNumeric) {
+        // ── Ref path ──
+        let el = document.querySelector('[data-opencli-ref="' + ref + '"]');
+        if (!el) el = document.querySelector('[data-ref="' + ref + '"]');
+
+        if (!el) {
+          return {
+            ok: false,
+            code: 'not_found',
+            message: 'ref=' + ref + ' not found in DOM',
+            hint: 'The element may have been removed. Re-run \`opencli browser state\` to get a fresh snapshot.',
+          };
+        }
+
+        // ── Fingerprint verification (identity vector) ──
+        const fp = identity[ref];
+        if (fp) {
+          const tag = el.tagName.toLowerCase();
+          const text = (el.textContent || '').trim().slice(0, 30);
+          const role = el.getAttribute('role') || '';
+          const ariaLabel = el.getAttribute('aria-label') || '';
+          const id = el.id || '';
+          const testId = el.getAttribute('data-testid') || el.getAttribute('data-test') || '';
+
+          // Hard fail: tag must always match
+          const tagMatch = fp.tag === tag;
+
+          // Soft signals: each non-empty stored field that mismatches counts against
+          var mismatches = 0;
+          var checks = 0;
+          if (fp.id) { checks++; if (fp.id !== id) mismatches++; }
+          if (fp.testId) { checks++; if (fp.testId !== testId) mismatches++; }
+          if (fp.ariaLabel) { checks++; if (fp.ariaLabel !== ariaLabel) mismatches++; }
+          if (fp.role) { checks++; if (fp.role !== role) mismatches++; }
+          if (fp.text) {
+            checks++;
+            // Text: allow prefix match (page text can grow), but empty current text never matches
+            if (!text || (!text.startsWith(fp.text) && !fp.text.startsWith(text))) mismatches++;
+          }
+
+          // Stale if tag changed, or if any uniquely identifying field (id/testId) changed,
+          // or if majority of soft signals mismatch
+          var isStale = !tagMatch;
+          if (!isStale && checks > 0) {
+            // id and testId are strong identifiers — any mismatch on these is decisive
+            if (fp.id && fp.id !== id) isStale = true;
+            else if (fp.testId && fp.testId !== testId) isStale = true;
+            // For remaining signals, stale if more than half mismatch
+            else if (mismatches > checks / 2) isStale = true;
+          }
+
+          if (isStale) {
+            return {
+              ok: false,
+              code: 'stale_ref',
+              message: 'ref=' + ref + ' was <' + fp.tag + '>' + (fp.text ? '"' + fp.text + '"' : '')
+                + ' but now points to <' + tag + '>' + (text ? '"' + text.slice(0, 30) + '"' : ''),
+              hint: 'The page has changed since the last snapshot. Re-run \`opencli browser state\` to refresh.',
+            };
+          }
+        }
+
+        window.__resolved = el;
+        return { ok: true };
+      }
+
+      if (isCssLike) {
+        // ── CSS selector path ──
+        let matches;
+        try {
+          matches = document.querySelectorAll(ref);
+        } catch (e) {
+          return {
+            ok: false,
+            code: 'not_found',
+            message: 'Invalid CSS selector: ' + ref,
+            hint: 'Check the selector syntax. Use ref numbers from snapshot for reliable targeting.',
+          };
+        }
+
+        if (matches.length === 0) {
+          return {
+            ok: false,
+            code: 'not_found',
+            message: 'CSS selector "' + ref + '" matched 0 elements',
+            hint: 'The element may not exist or may be hidden. Re-run \`opencli browser state\` to check.',
+          };
+        }
+
+        if (matches.length > 1) {
+          const candidates = [];
+          const limit = Math.min(matches.length, 5);
+          for (let i = 0; i < limit; i++) {
+            const m = matches[i];
+            const tag = m.tagName.toLowerCase();
+            const text = (m.textContent || '').trim().slice(0, 40);
+            const id = m.id ? '#' + m.id : '';
+            candidates.push('<' + tag + id + '>' + (text ? ' "' + text + '"' : ''));
+          }
+          return {
+            ok: false,
+            code: 'ambiguous',
+            message: 'CSS selector "' + ref + '" matched ' + matches.length + ' elements',
+            hint: 'Use a more specific selector, or use ref numbers from \`opencli browser state\` snapshot.',
+            candidates: candidates,
+          };
+        }
+
+        window.__resolved = matches[0];
+        return { ok: true };
+      }
+
+      // ── Unrecognized input ──
+      return {
+        ok: false,
+        code: 'not_found',
+        message: 'Cannot parse target: ' + ref,
+        hint: 'Use a numeric ref from snapshot (e.g. "12") or a CSS selector (e.g. "#submit").',
+      };
+    })()
+  `;
+}
+/**
+ * Generate JS for click that uses the unified resolver.
+ * Assumes resolveTargetJs has been called and __resolved is set.
+ */
+export function clickResolvedJs() {
+    return `
+    (() => {
+      const el = window.__resolved;
+      if (!el) throw new Error('No resolved element');
+      el.scrollIntoView({ behavior: 'instant', block: 'center' });
+      const rect = el.getBoundingClientRect();
+      const x = Math.round(rect.left + rect.width / 2);
+      const y = Math.round(rect.top + rect.height / 2);
+      try {
+        el.click();
+        return { status: 'clicked', x, y, w: Math.round(rect.width), h: Math.round(rect.height) };
+      } catch (e) {
+        return { status: 'js_failed', x, y, w: Math.round(rect.width), h: Math.round(rect.height), error: e.message };
+      }
+    })()
+  `;
+}
+/**
+ * Generate JS for type that uses the unified resolver.
+ */
+export function typeResolvedJs(text) {
+    const safeText = JSON.stringify(text);
+    return `
+    (() => {
+      const el = window.__resolved;
+      if (!el) throw new Error('No resolved element');
+      el.focus();
+      if (el.isContentEditable) {
+        const sel = window.getSelection();
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        sel.removeAllRanges();
+        sel.addRange(range);
+        document.execCommand('delete', false);
+        document.execCommand('insertText', false, ${safeText});
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+      } else {
+        const proto = el instanceof HTMLTextAreaElement
+          ? HTMLTextAreaElement.prototype
+          : HTMLInputElement.prototype;
+        const nativeSetter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+        if (nativeSetter) {
+          nativeSetter.call(el, ${safeText});
+        } else {
+          el.value = ${safeText};
+        }
+        el.dispatchEvent(new Event('input', { bubbles: true }));
+        el.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+      return 'typed';
+    })()
+  `;
+}
+/**
+ * Generate JS for scrollTo that uses the unified resolver.
+ * Assumes resolveTargetJs has been called and __resolved is set.
+ */
+export function scrollResolvedJs() {
+    return `
+    (() => {
+      const el = window.__resolved;
+      if (!el) throw new Error('No resolved element');
+      el.scrollIntoView({ behavior: 'smooth', block: 'center', inline: 'nearest' });
+      return { scrolled: true, tag: el.tagName.toLowerCase(), text: (el.textContent || '').trim().slice(0, 80) };
+    })()
+  `;
+}
+/**
+ * Generate JS to get text content of resolved element.
+ */
+export function getTextResolvedJs() {
+    return `
+    (() => {
+      const el = window.__resolved;
+      if (!el) throw new Error('No resolved element');
+      return el.textContent?.trim() ?? null;
+    })()
+  `;
+}
+/**
+ * Generate JS to get value of resolved input/textarea element.
+ */
+export function getValueResolvedJs() {
+    return `
+    (() => {
+      const el = window.__resolved;
+      if (!el) throw new Error('No resolved element');
+      return el.value ?? null;
+    })()
+  `;
+}
+/**
+ * Generate JS to get all attributes of resolved element.
+ */
+export function getAttributesResolvedJs() {
+    return `
+    (() => {
+      const el = window.__resolved;
+      if (!el) throw new Error('No resolved element');
+      return JSON.stringify(Object.fromEntries([...el.attributes].map(a => [a.name, a.value])));
+    })()
+  `;
+}
+/**
+ * Generate JS to select an option on a resolved <select> element.
+ */
+export function selectResolvedJs(option) {
+    const safeOption = JSON.stringify(option);
+    return `
+    (() => {
+      const el = window.__resolved;
+      if (!el) throw new Error('No resolved element');
+      if (el.tagName !== 'SELECT') return { error: 'Not a <select>' };
+      const match = Array.from(el.options).find(o => o.text.trim() === ${safeOption} || o.value === ${safeOption});
+      if (!match) return { error: 'Option not found', available: Array.from(el.options).map(o => o.text.trim()) };
+      const setter = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, 'value')?.set;
+      if (setter) setter.call(el, match.value); else el.value = match.value;
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return { selected: match.text };
+    })()
+  `;
+}
+/**
+ * Generate JS to check if resolved element is an autocomplete/combobox field.
+ */
+export function isAutocompleteResolvedJs() {
+    return `
+    (() => {
+      const el = window.__resolved;
+      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;
+    })()
+  `;
+}

package/dist/src/browser/target-resolver.test.d.ts

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

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,16 +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 isAutocomplete = await page.evaluate(`
-        (() => {
-          const el = document.querySelector('[data-opencli-ref="${index}"]');
-          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`);
@@ -390,19 +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 result = await page.evaluate(`
-        (function() {
-          var sel = document.querySelector('[data-opencli-ref="${index}"]');
-          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;
@@ -1001,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(() => {