@jackwener/opencli 1.7.9 → 1.7.11

package/dist/src/browser/base-page.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { CliError } from '../errors.js';
 import { BasePage } from './base-page.js';
 class TestPage extends BasePage {
@@ -15,6 +15,23 @@ class TestPage extends BasePage {
     async tabs() { return []; }
     async selectTab() { }
 }
+class ActionPage extends BasePage {
+    results = [];
+    scripts = [];
+    nativeType;
+    insertText;
+    nativeKeyPress;
+    async goto() { }
+    async evaluate(js) {
+        this.scripts.push(js);
+        return this.results.shift() ?? null;
+    }
+    async getCookies() { return []; }
+    async screenshot() { return ''; }
+    async tabs() { return []; }
+    async selectTab() { }
+}
+const resolveOk = { ok: true, matches_n: 1, match_level: 'exact' };
 describe('BasePage.fetchJson', () => {
     it('passes a narrow browser-context JSON request and parses the response in Node', async () => {
         const page = new TestPage();
@@ -72,3 +89,46 @@ describe('BasePage.fetchJson', () => {
         });
     });
 });
+describe('BasePage native input routing', () => {
+    it('types rich-editor text via native Input.insertText when available', async () => {
+        const page = new ActionPage();
+        page.nativeType = vi.fn().mockResolvedValue(undefined);
+        page.results = [resolveOk, { ok: true, mode: 'contenteditable' }];
+        await expect(page.typeText('#editor', 'hello')).resolves.toEqual({ matches_n: 1, match_level: 'exact' });
+        expect(page.nativeType).toHaveBeenCalledWith('hello');
+        expect(page.scripts).toHaveLength(2);
+        expect(page.scripts[1]).toContain('nearestContentEditableHost');
+        expect(page.scripts.join('\n')).not.toContain("return 'typed'");
+    });
+    it('keeps the DOM setter fallback when native text insertion is unavailable', async () => {
+        const page = new ActionPage();
+        page.results = [resolveOk, 'typed'];
+        await page.typeText('#q', 'hello');
+        expect(page.scripts).toHaveLength(2);
+        expect(page.scripts[1]).toContain('document.execCommand');
+        expect(page.scripts[1]).toContain("return 'typed'");
+    });
+    it('falls back to DOM typing if native text insertion fails', async () => {
+        const page = new ActionPage();
+        page.nativeType = vi.fn().mockRejectedValue(new Error('native failed'));
+        page.results = [resolveOk, { ok: true, mode: 'input' }, 'typed'];
+        await page.typeText('#q', 'hello');
+        expect(page.nativeType).toHaveBeenCalledWith('hello');
+        expect(page.scripts).toHaveLength(3);
+        expect(page.scripts[2]).toContain("return 'typed'");
+    });
+    it('presses key chords through native CDP key events when available', async () => {
+        const page = new ActionPage();
+        page.nativeKeyPress = vi.fn().mockResolvedValue(undefined);
+        await page.pressKey('Control+a');
+        expect(page.nativeKeyPress).toHaveBeenCalledWith('a', ['Ctrl']);
+        expect(page.scripts).toHaveLength(0);
+    });
+    it('falls back to synthetic keyboard events with parsed modifiers', async () => {
+        const page = new ActionPage();
+        await page.pressKey('Meta+N');
+        expect(page.scripts).toHaveLength(1);
+        expect(page.scripts[0]).toContain('key: "N"');
+        expect(page.scripts[0]).toContain('metaKey: true');
+    });
+});

package/dist/src/browser/bridge.d.ts

@@ -20,8 +20,6 @@ export declare class BrowserBridge implements IBrowserFactory {
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;
-    /** Poll until daemon is fully stopped (port released). */
-    private _waitForDaemonStop;
     /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
     private _pollUntilReady;
 }

package/dist/src/browser/bridge.js

@@ -1,16 +1,13 @@
 /**
  * Browser session manager — auto-spawns daemon and provides IPage.
  */
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
 import { Page } from './page.js';
 import { getDaemonHealth, requestDaemonShutdown } from './daemon-client.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { BrowserConnectError } from '../errors.js';
 import { PKG_VERSION } from '../version.js';
 import { resolveProfileContextId } from './profile.js';
+import { resolveDaemonLaunchSpec, spawnDaemonProcess, waitForDaemonStop } from './daemon-lifecycle.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
@@ -82,7 +79,7 @@ export class BrowserBridge {
                     process.stderr.write(`⚠️  Stale daemon detected (${reason}). Restarting...\n`);
                 }
                 const shutdownAccepted = await requestDaemonShutdown();
-                const portReleased = shutdownAccepted && await this._waitForDaemonStop(3000);
+                const portReleased = shutdownAccepted && await waitForDaemonStop(3000);
                 if (!portReleased) {
                     // Stale daemon replacement failed — don't blindly spawn on an occupied port
                     throw new BrowserConnectError('Stale daemon could not be replaced', `A stale daemon (${reason}) is running but did not shut down.\n` +
@@ -115,24 +112,10 @@ export class BrowserBridge {
             }
         }
         // No daemon — spawn one
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const parentDir = path.resolve(__dirname, '..');
-        const daemonTs = path.join(parentDir, 'daemon.ts');
-        const daemonJs = path.join(parentDir, 'daemon.js');
-        const isTs = fs.existsSync(daemonTs);
-        const daemonPath = isTs ? daemonTs : daemonJs;
         if (process.env.OPENCLI_VERBOSE || process.stderr.isTTY) {
             process.stderr.write('⏳ Starting daemon...\n');
         }
-        const spawnArgs = isTs
-            ? [process.execPath, '--import', 'tsx/esm', daemonPath]
-            : [process.execPath, daemonPath];
-        this._daemonProc = spawn(spawnArgs[0], spawnArgs.slice(1), {
-            detached: true,
-            stdio: 'ignore',
-            env: { ...process.env },
-        });
-        this._daemonProc.unref();
+        this._daemonProc = spawnDaemonProcess();
         // Wait for daemon + extension
         if (await this._pollUntilReady(timeoutMs, contextId))
             return;
@@ -152,18 +135,7 @@ export class BrowserBridge {
                 '  1. Download: https://github.com/jackwener/opencli/releases\n' +
                 '  2. Open chrome://extensions → Developer Mode → Load unpacked', 'extension-not-connected');
         }
-        throw new BrowserConnectError('Failed to start opencli daemon', `Try running manually:\n  node ${daemonPath}\nMake sure port ${DEFAULT_DAEMON_PORT} is available.`, 'daemon-not-running');
-    }
-    /** Poll until daemon is fully stopped (port released). */
-    async _waitForDaemonStop(timeoutMs) {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, 200));
-            const h = await getDaemonHealth();
-            if (h.state === 'stopped')
-                return true;
-        }
-        return false;
+        throw new BrowserConnectError('Failed to start opencli daemon', `Try running manually:\n  node ${resolveDaemonLaunchSpec().scriptPath}\nMake sure port ${DEFAULT_DAEMON_PORT} is available.`, 'daemon-not-running');
     }
     /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
     async _pollUntilReady(timeoutMs, contextId) {

package/dist/src/browser/cdp.js

@@ -317,6 +317,54 @@ class CDPPage extends BasePage {
     async selectTab(_target) {
         // Not supported in direct CDP mode
     }
+    async cdp(method, params = {}) {
+        return this.bridge.send(method, params);
+    }
+    async nativeClick(x, y) {
+        await this.cdp('Input.dispatchMouseEvent', {
+            type: 'mousePressed',
+            x,
+            y,
+            button: 'left',
+            clickCount: 1,
+        });
+        await this.cdp('Input.dispatchMouseEvent', {
+            type: 'mouseReleased',
+            x,
+            y,
+            button: 'left',
+            clickCount: 1,
+        });
+    }
+    async nativeType(text) {
+        await this.cdp('Input.insertText', { text });
+    }
+    async insertText(text) {
+        await this.nativeType(text);
+    }
+    async nativeKeyPress(key, modifiers = []) {
+        let modifierFlags = 0;
+        for (const mod of modifiers) {
+            if (mod === 'Alt')
+                modifierFlags |= 1;
+            if (mod === 'Ctrl' || mod === 'Control')
+                modifierFlags |= 2;
+            if (mod === 'Meta')
+                modifierFlags |= 4;
+            if (mod === 'Shift')
+                modifierFlags |= 8;
+        }
+        await this.cdp('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key,
+            modifiers: modifierFlags,
+        });
+        await this.cdp('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key,
+            modifiers: modifierFlags,
+        });
+    }
 }
 function isCookie(value) {
     return isRecord(value)

package/dist/src/browser/cdp.test.js

@@ -49,4 +49,27 @@ describe('CDPBridge cookies', () => {
             { name: 'exact', value: '2', domain: 'example.com' },
         ]);
     });
+    it('exposes native input helpers on direct CDP pages', async () => {
+        vi.stubEnv('OPENCLI_CDP_ENDPOINT', 'ws://127.0.0.1:9222/devtools/page/1');
+        const bridge = new CDPBridge();
+        const send = vi.spyOn(bridge, 'send').mockResolvedValue({});
+        const page = await bridge.connect();
+        send.mockClear();
+        expect(page.nativeType).toBeTypeOf('function');
+        expect(page.nativeKeyPress).toBeTypeOf('function');
+        expect(page.nativeClick).toBeTypeOf('function');
+        expect(page.cdp).toBeTypeOf('function');
+        await page.nativeType('hello');
+        await page.nativeKeyPress('a', ['Ctrl']);
+        await page.nativeClick(10, 20);
+        await page.cdp('Page.getLayoutMetrics', {});
+        expect(send.mock.calls).toEqual([
+            ['Input.insertText', { text: 'hello' }],
+            ['Input.dispatchKeyEvent', { type: 'keyDown', key: 'a', modifiers: 2 }],
+            ['Input.dispatchKeyEvent', { type: 'keyUp', key: 'a', modifiers: 2 }],
+            ['Input.dispatchMouseEvent', { type: 'mousePressed', x: 10, y: 20, button: 'left', clickCount: 1 }],
+            ['Input.dispatchMouseEvent', { type: 'mouseReleased', x: 10, y: 20, button: 'left', clickCount: 1 }],
+            ['Page.getLayoutMetrics', {}],
+        ]);
+    });
 });

package/dist/src/browser/daemon-lifecycle.d.ts

@@ -0,0 +1,23 @@
+import { type ChildProcess } from 'node:child_process';
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+import { type DaemonStatus } from './daemon-client.js';
+export interface DaemonLaunchSpec {
+    binary: string;
+    args: string[];
+    scriptPath: string;
+}
+export interface DaemonRestartResult {
+    previousStatus: DaemonStatus | null;
+    status: DaemonStatus | null;
+    stopped: boolean;
+    spawned: boolean;
+}
+export declare function resolveDaemonLaunchSpec(): DaemonLaunchSpec;
+export declare function spawnDaemonProcess(): ChildProcess;
+export declare function waitForDaemonStop(timeoutMs: number): Promise<boolean>;
+export declare function waitForDaemonStatus(timeoutMs: number): Promise<DaemonStatus | null>;
+export declare function restartDaemon(opts?: {
+    stopTimeoutMs?: number;
+    startTimeoutMs?: number;
+}): Promise<DaemonRestartResult>;
+export { DEFAULT_DAEMON_PORT };

package/dist/src/browser/daemon-lifecycle.js

@@ -0,0 +1,67 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
+import { fetchDaemonStatus, getDaemonHealth, requestDaemonShutdown } from './daemon-client.js';
+export function resolveDaemonLaunchSpec() {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const parentDir = path.resolve(__dirname, '..');
+    const daemonTs = path.join(parentDir, 'daemon.ts');
+    const daemonJs = path.join(parentDir, 'daemon.js');
+    const isTs = fs.existsSync(daemonTs);
+    const scriptPath = isTs ? daemonTs : daemonJs;
+    return {
+        binary: process.execPath,
+        args: isTs ? ['--import', 'tsx/esm', scriptPath] : [scriptPath],
+        scriptPath,
+    };
+}
+export function spawnDaemonProcess() {
+    const launch = resolveDaemonLaunchSpec();
+    const proc = spawn(launch.binary, launch.args, {
+        detached: true,
+        stdio: 'ignore',
+        env: { ...process.env },
+    });
+    proc.unref();
+    return proc;
+}
+export async function waitForDaemonStop(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        await sleep(200);
+        const h = await getDaemonHealth();
+        if (h.state === 'stopped')
+            return true;
+    }
+    return false;
+}
+export async function waitForDaemonStatus(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const status = await fetchDaemonStatus({ timeout: Math.min(1000, Math.max(100, deadline - Date.now())) });
+        if (status)
+            return status;
+        await sleep(200);
+    }
+    return null;
+}
+export async function restartDaemon(opts = {}) {
+    const previousStatus = await fetchDaemonStatus();
+    let stopped = previousStatus === null;
+    if (previousStatus) {
+        const shutdownAccepted = await requestDaemonShutdown();
+        stopped = shutdownAccepted && await waitForDaemonStop(opts.stopTimeoutMs ?? 3000);
+        if (!stopped) {
+            return { previousStatus, status: previousStatus, stopped: false, spawned: false };
+        }
+    }
+    spawnDaemonProcess();
+    const status = await waitForDaemonStatus(opts.startTimeoutMs ?? 5000);
+    return { previousStatus, status, stopped, spawned: true };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export { DEFAULT_DAEMON_PORT };

package/dist/src/browser/daemon-version.d.ts

@@ -0,0 +1,4 @@
+import type { DaemonStatus } from './daemon-client.js';
+export declare function isDaemonStale(status: Pick<DaemonStatus, 'daemonVersion'> | null | undefined, cliVersion?: string): boolean;
+export declare function formatDaemonVersion(status: Pick<DaemonStatus, 'daemonVersion'> | null | undefined): string;
+export declare function staleDaemonIssue(status: Pick<DaemonStatus, 'daemonVersion'> | null | undefined, cliVersion: string): string;

package/dist/src/browser/daemon-version.js

@@ -0,0 +1,12 @@
+export function isDaemonStale(status, cliVersion) {
+    if (!status || !cliVersion)
+        return false;
+    return !status.daemonVersion || status.daemonVersion !== cliVersion;
+}
+export function formatDaemonVersion(status) {
+    return status?.daemonVersion ? `v${status.daemonVersion}` : 'version unknown';
+}
+export function staleDaemonIssue(status, cliVersion) {
+    return `Stale daemon detected: daemon ${formatDaemonVersion(status)} != CLI v${cliVersion}.\n` +
+        '  Run: opencli daemon restart';
+}

package/dist/src/browser/dom-helpers.d.ts

@@ -11,7 +11,7 @@ export declare function clickJs(ref: string): string;
  *  Uses native setter for React compat + execCommand for contenteditable. */
 export declare function typeTextJs(ref: string, text: string): string;
 /** Generate JS to press a keyboard key */
-export declare function pressKeyJs(key: string): string;
+export declare function pressKeyJs(key: string, modifiers?: string[]): string;
 /** Generate JS to wait for text to appear in the page */
 export declare function waitForTextJs(text: string, timeoutMs: number): string;
 /** Generate JS for scroll */

package/dist/src/browser/dom-helpers.js

@@ -80,12 +80,24 @@ export function typeTextJs(ref, text) {
   `;
 }
 /** Generate JS to press a keyboard key */
-export function pressKeyJs(key) {
+export function pressKeyJs(key, modifiers = []) {
+    const hasCtrl = modifiers.includes('Ctrl') || modifiers.includes('Control');
+    const hasAlt = modifiers.includes('Alt');
+    const hasMeta = modifiers.includes('Meta');
+    const hasShift = modifiers.includes('Shift');
     return `
     (() => {
       const el = document.activeElement || document.body;
-      el.dispatchEvent(new KeyboardEvent('keydown', { key: ${JSON.stringify(key)}, bubbles: true }));
-      el.dispatchEvent(new KeyboardEvent('keyup', { key: ${JSON.stringify(key)}, bubbles: true }));
+      const init = {
+        key: ${JSON.stringify(key)},
+        bubbles: true,
+        ctrlKey: ${hasCtrl},
+        altKey: ${hasAlt},
+        metaKey: ${hasMeta},
+        shiftKey: ${hasShift},
+      };
+      el.dispatchEvent(new KeyboardEvent('keydown', init));
+      el.dispatchEvent(new KeyboardEvent('keyup', init));
       return 'pressed';
     })()
   `;

package/dist/src/browser/page.js

@@ -374,7 +374,7 @@ export class Page extends BasePage {
         for (const mod of modifiers) {
             if (mod === 'Alt')
                 modifierFlags |= 1;
-            if (mod === 'Ctrl')
+            if (mod === 'Ctrl' || mod === 'Control')
                 modifierFlags |= 2;
             if (mod === 'Meta')
                 modifierFlags |= 4;

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

@@ -77,6 +77,14 @@ export declare function clickResolvedJs(): string;
  * Generate JS for type that uses the unified resolver.
  */
 export declare function typeResolvedJs(text: string): string;
+/**
+ * Prepare the resolved element for native CDP Input.insertText.
+ *
+ * This preserves `browser type`'s existing "replace current text" semantics:
+ * focus the editable target, select its current contents, then let CDP insert
+ * real browser text input so rich editors can update their internal state.
+ */
+export declare function prepareNativeTypeResolvedJs(): string;
 /**
  * Generate JS for scrollTo that uses the unified resolver.
  * Assumes resolveTargetJs has been called and __resolved is set.

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

@@ -331,6 +331,81 @@ export function typeResolvedJs(text) {
     })()
   `;
 }
+/**
+ * Prepare the resolved element for native CDP Input.insertText.
+ *
+ * This preserves `browser type`'s existing "replace current text" semantics:
+ * focus the editable target, select its current contents, then let CDP insert
+ * real browser text input so rich editors can update their internal state.
+ */
+export function prepareNativeTypeResolvedJs() {
+    return `
+    (() => {
+      const original = window.__resolved;
+      if (!original) throw new Error('No resolved element');
+
+      function nearestContentEditableHost(el) {
+        let current = el;
+        while (current && current.nodeType === 1) {
+          if (current.hasAttribute && current.hasAttribute('contenteditable')) return current;
+          current = current.parentElement;
+        }
+        return el.isContentEditable ? el : null;
+      }
+
+      const editableHost = original.isContentEditable ? nearestContentEditableHost(original) : null;
+      const inputTypes = new Set(['', 'text', 'search', 'url', 'tel', 'email', 'password']);
+      const isInput = original instanceof HTMLInputElement;
+      const isTextarea = original instanceof HTMLTextAreaElement;
+      const isTextControl = isTextarea || (isInput && inputTypes.has((original.getAttribute('type') || original.type || '').toLowerCase()));
+      const el = editableHost || (isTextControl ? original : null);
+
+      if (!el) {
+        return {
+          ok: false,
+          reason: 'not_editable',
+          tag: original.tagName ? original.tagName.toLowerCase() : '',
+        };
+      }
+
+      window.__resolved = el;
+      el.scrollIntoView({ behavior: 'instant', block: 'center', inline: 'nearest' });
+      try {
+        el.focus({ preventScroll: true });
+      } catch (_) {
+        el.focus();
+      }
+
+      if (editableHost) {
+        const sel = window.getSelection();
+        if (!sel) return { ok: false, reason: 'selection_unavailable', mode: 'contenteditable' };
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        sel.removeAllRanges();
+        sel.addRange(range);
+        return { ok: true, mode: 'contenteditable' };
+      }
+
+      let selected = false;
+      try {
+        if (typeof el.setSelectionRange === 'function') {
+          el.setSelectionRange(0, String(el.value || '').length);
+          selected = true;
+        }
+      } catch (_) {}
+      try {
+        if (!selected && typeof el.select === 'function') {
+          el.select();
+          selected = true;
+        }
+      } catch (_) {}
+
+      return selected
+        ? { ok: true, mode: isTextarea ? 'textarea' : 'input' }
+        : { ok: false, reason: 'selection_unavailable', mode: isTextarea ? 'textarea' : 'input' };
+    })()
+  `;
+}
 /**
  * Generate JS for scrollTo that uses the unified resolver.
  * Assumes resolveTargetJs has been called and __resolved is set.

package/dist/src/browser/verify-fixture.d.ts

@@ -57,3 +57,4 @@ export declare function validateRows(rows: Row[], fixture: Fixture): ValidationF
  * - Object form is expanded to `--key value` pairs.
  */
 export declare function expandFixtureArgs(args: FixtureArgs | undefined): string[];
+export declare function parseSeedArgs(raw: string | undefined): FixtureArgs | undefined;

package/dist/src/browser/verify-fixture.js

@@ -196,6 +196,24 @@ export function expandFixtureArgs(args) {
     }
     return out;
 }
+export function parseSeedArgs(raw) {
+    if (raw === undefined)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed !== null && typeof parsed === 'object')
+            return parsed;
+        return [parsed];
+    }
+    catch {
+        return [raw];
+    }
+}
 function jsType(v) {
     if (v === null)
         return 'null';

package/dist/src/browser/verify-fixture.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { deriveFixture, expandFixtureArgs, validateRows } from './verify-fixture.js';
+import { deriveFixture, expandFixtureArgs, parseSeedArgs, validateRows } from './verify-fixture.js';
 describe('validateRows', () => {
     it('passes when rows meet all expectations', () => {
         const fixture = {
@@ -159,3 +159,18 @@ describe('expandFixtureArgs', () => {
         ]);
     });
 });
+describe('parseSeedArgs', () => {
+    it('treats plain text as one positional arg', () => {
+        expect(parseSeedArgs('opencli-verify')).toEqual(['opencli-verify']);
+    });
+    it('accepts JSON array seed args', () => {
+        expect(parseSeedArgs('["subject", "--limit", 3]')).toEqual(['subject', '--limit', 3]);
+    });
+    it('accepts JSON object seed args', () => {
+        expect(parseSeedArgs('{"limit":3,"sort":"hot"}')).toEqual({ limit: 3, sort: 'hot' });
+    });
+    it('ignores empty input', () => {
+        expect(parseSeedArgs(undefined)).toBeUndefined();
+        expect(parseSeedArgs('   ')).toBeUndefined();
+    });
+});