@jackwener/opencli 1.7.11 → 1.7.13

package/clis/zsxq/groups.js

@@ -3,6 +3,7 @@ import { ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getGroupsFromResponse,
 cli({
     site: 'zsxq',
     name: 'groups',
+    access: 'read',
     description: '列出当前账号加入的星球',
     domain: 'wx.zsxq.com',
     strategy: Strategy.COOKIE,

package/clis/zsxq/search.js

@@ -3,6 +3,7 @@ import { getActiveGroupId, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getGr
 cli({
     site: 'zsxq',
     name: 'search',
+    access: 'read',
     description: '搜索星球内容',
     domain: 'wx.zsxq.com',
     strategy: Strategy.COOKIE,

package/clis/zsxq/topic.js

@@ -4,6 +4,7 @@ import { getActiveGroupId, browserJsonRequest, ensureZsxqAuth, ensureZsxqPage, f
 cli({
     site: 'zsxq',
     name: 'topic',
+    access: 'read',
     description: '获取单个话题详情和评论',
     domain: 'wx.zsxq.com',
     strategy: Strategy.COOKIE,

package/clis/zsxq/topics.js

@@ -3,6 +3,7 @@ import { getActiveGroupId, ensureZsxqAuth, ensureZsxqPage, fetchFirstJson, getTo
 cli({
     site: 'zsxq',
     name: 'topics',
+    access: 'read',
     description: '获取当前星球的话题列表',
     domain: 'wx.zsxq.com',
     strategy: Strategy.COOKIE,

package/dist/src/adapter-source.test.js

@@ -3,7 +3,7 @@ import { resolveAdapterSourcePath } from './adapter-source.js';
 function makeCmd(overrides = {}) {
     return {
         site: 'test-site',
-        name: 'test-cmd',
+        name: 'test-cmd', access: 'read',
         description: 'test',
         args: [],
         ...overrides,

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

@@ -20,8 +20,10 @@ function mkCmd(site, name, domain) {
     return {
         site,
         name,
+        access: 'read',
         description: '',
         domain,
+        browser: false,
         args: [],
     };
 }

package/dist/src/browser/base-page.d.ts

@@ -19,10 +19,19 @@ export interface ResolveSuccess {
      */
     match_level: TargetMatchLevel;
 }
+export interface FillTextResult extends ResolveSuccess {
+    filled: boolean;
+    verified: boolean;
+    expected: string;
+    actual: string;
+    length: number;
+    mode?: 'input' | 'textarea' | 'contenteditable';
+}
 export declare abstract class BasePage implements IPage {
     protected _lastUrl: string | null;
     /** Cached previous snapshot hashes for incremental diff marking */
     private _prevSnapshotHashes;
+    private _cdpTargetMarkerSeq;
     abstract goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
@@ -53,7 +62,16 @@ export declare abstract class BasePage implements IPage {
     protected tryNativeType(text: string): Promise<boolean>;
     /** Uses native CDP key events when the concrete page exposes them. */
     protected tryNativeKeyPress(key: string, modifiers: string[]): Promise<boolean>;
+    /**
+     * Run a DOM-domain CDP command against `window.__resolved`.
+     *
+     * CDP DOM.focus / DOM.scrollIntoViewIfNeeded need a nodeId, while our
+     * resolver stores the live Element in page JS. Bridge the two worlds with a
+     * short-lived marker attribute, then query it through CDP.
+     */
+    protected tryCdpOnResolvedElement(method: 'DOM.focus' | 'DOM.scrollIntoViewIfNeeded'): Promise<boolean>;
     typeText(ref: string, text: string, opts?: ResolveOptions): Promise<ResolveSuccess>;
+    fillText(ref: string, text: string, opts?: ResolveOptions): Promise<FillTextResult>;
     pressKey(key: string): Promise<void>;
     scrollTo(ref: string, opts?: ResolveOptions): Promise<unknown>;
     getFormState(): Promise<Record<string, unknown>>;

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

@@ -10,7 +10,7 @@
  */
 import { generateSnapshotJs, getFormStateJs } from './dom-snapshot.js';
 import { pressKeyJs, waitForTextJs, waitForCaptureJs, waitForSelectorJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
-import { resolveTargetJs, clickResolvedJs, typeResolvedJs, prepareNativeTypeResolvedJs, scrollResolvedJs, } from './target-resolver.js';
+import { resolveTargetJs, clickResolvedJs, typeResolvedJs, prepareNativeTypeResolvedJs, verifyFilledResolvedJs, scrollResolvedJs, } from './target-resolver.js';
 import { TargetError } from './target-errors.js';
 import { CliError } from '../errors.js';
 import { formatSnapshot } from '../snapshotFormatter.js';
@@ -61,6 +61,7 @@ export class BasePage {
     _lastUrl = null;
     /** Cached previous snapshot hashes for incremental diff marking */
     _prevSnapshotHashes = null;
+    _cdpTargetMarkerSeq = 0;
     /**
      * Safely evaluate JS with pre-serialized arguments.
      * Each key in `args` becomes a `const` declaration with JSON-serialized value,
@@ -154,8 +155,9 @@ export class BasePage {
     async click(ref, opts = {}) {
         // Phase 1: Resolve target with fingerprint verification
         const resolved = await runResolve(this, ref, opts);
+        const nativeScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
         // Phase 2: Execute click on resolved element
-        const result = await this.evaluate(clickResolvedJs());
+        const result = await this.evaluate(clickResolvedJs({ skipScroll: nativeScrolled }));
         if (typeof result === 'string' || result == null)
             return resolved;
         if (result.status === 'clicked')
@@ -217,12 +219,78 @@ export class BasePage {
             return false;
         }
     }
+    /**
+     * Run a DOM-domain CDP command against `window.__resolved`.
+     *
+     * CDP DOM.focus / DOM.scrollIntoViewIfNeeded need a nodeId, while our
+     * resolver stores the live Element in page JS. Bridge the two worlds with a
+     * short-lived marker attribute, then query it through CDP.
+     */
+    async tryCdpOnResolvedElement(method) {
+        const cdp = this.cdp;
+        if (typeof cdp !== 'function')
+            return false;
+        const markerAttr = 'data-opencli-cdp-target';
+        const markerValue = `${Date.now().toString(36)}-${++this._cdpTargetMarkerSeq}`;
+        const selector = `[${markerAttr}="${markerValue}"]`;
+        let marked = false;
+        try {
+            const marker = await this.evaluateWithArgs(`
+        (() => {
+          const el = window.__resolved;
+          if (!el || el.nodeType !== 1 || typeof el.setAttribute !== 'function') {
+            return { ok: false };
+          }
+          el.setAttribute(markerAttr, markerValue);
+          return { ok: true };
+        })()
+      `, { markerAttr, markerValue });
+            marked = marker?.ok === true;
+            if (!marked)
+                return false;
+            await cdp.call(this, 'DOM.enable', {}).catch(() => undefined);
+            const doc = await cdp.call(this, 'DOM.getDocument', {});
+            const rootNodeId = doc?.root?.nodeId;
+            if (typeof rootNodeId !== 'number')
+                return false;
+            const query = await cdp.call(this, 'DOM.querySelector', {
+                nodeId: rootNodeId,
+                selector,
+            });
+            const nodeId = query?.nodeId;
+            if (typeof nodeId !== 'number' || nodeId <= 0)
+                return false;
+            await cdp.call(this, method, { nodeId });
+            return true;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            if (marked) {
+                await this.evaluateWithArgs(`
+          (() => {
+            for (const el of document.querySelectorAll(selector)) {
+              el.removeAttribute(markerAttr);
+            }
+          })()
+        `, { selector, markerAttr }).catch(() => undefined);
+            }
+        }
+    }
     async typeText(ref, text, opts = {}) {
         const resolved = await runResolve(this, ref, opts);
         let typed = false;
+        let nativeScrolled = false;
+        let nativeFocused = false;
         if (typeof this.nativeType === 'function' || typeof this.insertText === 'function') {
             try {
-                const preparation = await this.evaluate(prepareNativeTypeResolvedJs());
+                nativeScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
+                nativeFocused = await this.tryCdpOnResolvedElement('DOM.focus');
+                const preparation = await this.evaluate(prepareNativeTypeResolvedJs({
+                    skipScroll: nativeScrolled,
+                    skipFocus: nativeFocused,
+                }));
                 typed = preparation?.ok === true && await this.tryNativeType(text);
             }
             catch {
@@ -235,6 +303,49 @@ export class BasePage {
         }
         return resolved;
     }
+    async fillText(ref, text, opts = {}) {
+        const resolved = await runResolve(this, ref, opts);
+        let nativeScrolled = false;
+        let nativeFocused = false;
+        try {
+            nativeScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
+            nativeFocused = await this.tryCdpOnResolvedElement('DOM.focus');
+        }
+        catch {
+            // CDP focus/scroll is best-effort; DOM preparation below remains authoritative.
+        }
+        const preparation = await this.evaluate(prepareNativeTypeResolvedJs({
+            skipScroll: nativeScrolled,
+            skipFocus: nativeFocused,
+        }));
+        if (preparation?.ok !== true) {
+            throw new TargetError({
+                code: 'not_editable',
+                message: `Target "${ref}" is not a fillable input, textarea, or contenteditable element.`,
+                hint: 'Use `opencli browser state` to pick an editable target, or use `browser type` for keyboard-like interactions.',
+            });
+        }
+        const usedNativeInput = await this.tryNativeType(text);
+        if (!usedNativeInput) {
+            await this.evaluate(typeResolvedJs(text));
+        }
+        let verification = await this.evaluate(verifyFilledResolvedJs(text));
+        if (usedNativeInput && verification?.ok !== true) {
+            await this.evaluate(typeResolvedJs(text));
+            verification = await this.evaluate(verifyFilledResolvedJs(text));
+        }
+        const actual = verification && 'actual' in verification ? verification.actual : '';
+        const mode = verification && 'mode' in verification ? verification.mode : undefined;
+        return {
+            ...resolved,
+            filled: true,
+            verified: verification?.ok === true,
+            expected: text,
+            actual,
+            length: actual.length,
+            ...(mode ? { mode } : {}),
+        };
+    }
     async pressKey(key) {
         const parsed = parseKeyChord(key);
         if (!await this.tryNativeKeyPress(parsed.key, parsed.modifiers)) {
@@ -243,7 +354,8 @@ export class BasePage {
     }
     async scrollTo(ref, opts = {}) {
         const resolved = await runResolve(this, ref, opts);
-        const result = (await this.evaluate(scrollResolvedJs()));
+        const nativeScrolled = await this.tryCdpOnResolvedElement('DOM.scrollIntoViewIfNeeded');
+        const result = (await this.evaluate(scrollResolvedJs({ skipScroll: nativeScrolled })));
         // Fold match_level into the scroll payload so the user-facing envelope
         // carries it the same way click / type do.
         if (result && typeof result === 'object') {

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

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { CliError } from '../errors.js';
 import { BasePage } from './base-page.js';
+import { TargetError } from './target-errors.js';
 class TestPage extends BasePage {
     result;
     args;
@@ -17,15 +18,23 @@ class TestPage extends BasePage {
 }
 class ActionPage extends BasePage {
     results = [];
+    withArgsResults = [];
     scripts = [];
+    withArgs = [];
     nativeType;
     insertText;
     nativeKeyPress;
+    cdp;
     async goto() { }
     async evaluate(js) {
         this.scripts.push(js);
         return this.results.shift() ?? null;
     }
+    async evaluateWithArgs(js, args) {
+        this.scripts.push(js);
+        this.withArgs.push(args);
+        return this.withArgsResults.shift() ?? null;
+    }
     async getCookies() { return []; }
     async screenshot() { return ''; }
     async tabs() { return []; }
@@ -100,6 +109,27 @@ describe('BasePage native input routing', () => {
         expect(page.scripts[1]).toContain('nearestContentEditableHost');
         expect(page.scripts.join('\n')).not.toContain("return 'typed'");
     });
+    it('uses CDP DOM focus and scroll before native text insertion when available', async () => {
+        const page = new ActionPage();
+        page.nativeType = vi.fn().mockResolvedValue(undefined);
+        page.cdp = vi.fn()
+            .mockResolvedValueOnce({})
+            .mockResolvedValueOnce({ root: { nodeId: 1 } })
+            .mockResolvedValueOnce({ nodeId: 7 })
+            .mockResolvedValueOnce({})
+            .mockResolvedValueOnce({})
+            .mockResolvedValueOnce({ root: { nodeId: 1 } })
+            .mockResolvedValueOnce({ nodeId: 7 })
+            .mockResolvedValueOnce({});
+        page.results = [resolveOk, { ok: true, mode: 'input' }];
+        page.withArgsResults = [{ ok: true }, undefined, { ok: true }, undefined];
+        await page.typeText('#q', 'hello');
+        expect(page.cdp).toHaveBeenCalledWith('DOM.scrollIntoViewIfNeeded', { nodeId: 7 });
+        expect(page.cdp).toHaveBeenCalledWith('DOM.focus', { nodeId: 7 });
+        expect(page.nativeType).toHaveBeenCalledWith('hello');
+        expect(page.scripts.at(-1)).toContain('if (false) el.scrollIntoView');
+        expect(page.scripts.at(-1)).toContain('if (false) {');
+    });
     it('keeps the DOM setter fallback when native text insertion is unavailable', async () => {
         const page = new ActionPage();
         page.results = [resolveOk, 'typed'];
@@ -117,6 +147,84 @@ describe('BasePage native input routing', () => {
         expect(page.scripts).toHaveLength(3);
         expect(page.scripts[2]).toContain("return 'typed'");
     });
+    it('fills text through the native input path and verifies the exact value', async () => {
+        const page = new ActionPage();
+        page.nativeType = vi.fn().mockResolvedValue(undefined);
+        page.results = [
+            resolveOk,
+            { ok: true, mode: 'textarea' },
+            { ok: true, actual: 'line1\\n/ / raw', expected: 'line1\\n/ / raw', length: 14, mode: 'textarea' },
+        ];
+        await expect(page.fillText('#message', 'line1\\n/ / raw')).resolves.toEqual({
+            filled: true,
+            verified: true,
+            expected: 'line1\\n/ / raw',
+            actual: 'line1\\n/ / raw',
+            length: 14,
+            matches_n: 1,
+            match_level: 'exact',
+            mode: 'textarea',
+        });
+        expect(page.nativeType).toHaveBeenCalledWith('line1\\n/ / raw');
+        expect(page.scripts).toHaveLength(3);
+        expect(page.scripts[2]).toContain('actual ===');
+    });
+    it('falls back to the DOM setter when native fill insertion is unavailable', async () => {
+        const page = new ActionPage();
+        page.results = [
+            resolveOk,
+            { ok: true, mode: 'input' },
+            'typed',
+            { ok: true, actual: 'hello', expected: 'hello', length: 5, mode: 'input' },
+        ];
+        await expect(page.fillText('#q', 'hello')).resolves.toEqual(expect.objectContaining({
+            filled: true,
+            verified: true,
+            actual: 'hello',
+            mode: 'input',
+        }));
+        expect(page.scripts).toHaveLength(4);
+        expect(page.scripts[2]).toContain("return 'typed'");
+    });
+    it('falls back to DOM fill if native insertion does not verify', async () => {
+        const page = new ActionPage();
+        page.nativeType = vi.fn().mockResolvedValue(undefined);
+        page.results = [
+            resolveOk,
+            { ok: true, mode: 'input' },
+            { ok: false, actual: '', expected: 'hello', length: 0, mode: 'input' },
+            'typed',
+            { ok: true, actual: 'hello', expected: 'hello', length: 5, mode: 'input' },
+        ];
+        await expect(page.fillText('#q', 'hello')).resolves.toEqual(expect.objectContaining({
+            filled: true,
+            verified: true,
+            actual: 'hello',
+        }));
+        expect(page.nativeType).toHaveBeenCalledWith('hello');
+        expect(page.scripts).toHaveLength(5);
+        expect(page.scripts[3]).toContain("return 'typed'");
+    });
+    it('throws a structured not_editable error for non-fillable targets', async () => {
+        const page = new ActionPage();
+        page.results = [resolveOk, { ok: false, reason: 'not_editable', tag: 'button' }];
+        const err = await page.fillText('button', 'hello').catch((error) => error);
+        expect(err).toBeInstanceOf(TargetError);
+        expect(err.code).toBe('not_editable');
+    });
+    it('uses CDP DOM scrollIntoViewIfNeeded before JS click when available', async () => {
+        const page = new ActionPage();
+        page.cdp = vi.fn()
+            .mockResolvedValueOnce({})
+            .mockResolvedValueOnce({ root: { nodeId: 1 } })
+            .mockResolvedValueOnce({ nodeId: 9 })
+            .mockResolvedValueOnce({});
+        page.results = [resolveOk, { status: 'clicked', x: 1, y: 2 }];
+        page.withArgsResults = [{ ok: true }, undefined];
+        await page.click('#save');
+        expect(page.cdp).toHaveBeenCalledWith('DOM.scrollIntoViewIfNeeded', { nodeId: 9 });
+        expect(page.scripts.at(-1)).toContain('if (false) el.scrollIntoView');
+    });
     it('presses key chords through native CDP key events when available', async () => {
         const page = new ActionPage();
         page.nativeKeyPress = vi.fn().mockResolvedValue(undefined);

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

@@ -26,6 +26,7 @@ export declare class CDPBridge implements IBrowserFactory {
         workspace?: string;
         cdpEndpoint?: string;
         contextId?: string;
+        idleTimeout?: number;
     }): Promise<IPage>;
     close(): Promise<void>;
     send(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;

package/dist/src/browser/cdp.js

@@ -202,16 +202,58 @@ class CDPPage extends BasePage {
             : cookies;
     }
     async screenshot(options = {}) {
-        const result = await this.bridge.send('Page.captureScreenshot', {
-            format: options.format ?? 'png',
-            quality: options.format === 'jpeg' ? (options.quality ?? 80) : undefined,
-            captureBeyondViewport: options.fullPage ?? false,
-        });
-        const base64 = isRecord(result) && typeof result.data === 'string' ? result.data : '';
-        if (options.path) {
-            await saveBase64ToFile(base64, options.path);
+        const fullPage = options.fullPage === true;
+        const overrideWidth = options.width && options.width > 0 ? Math.ceil(options.width) : undefined;
+        // height is ignored under fullPage so the captureBeyondViewport path stays unchanged for users who pass --height alongside --full-page.
+        const overrideHeight = !fullPage && options.height && options.height > 0 ? Math.ceil(options.height) : undefined;
+        const needsOverride = overrideWidth !== undefined || overrideHeight !== undefined;
+        if (needsOverride) {
+            if (overrideWidth !== undefined && fullPage) {
+                await this.bridge.send('Emulation.setDeviceMetricsOverride', {
+                    mobile: false,
+                    width: overrideWidth,
+                    height: 0,
+                    deviceScaleFactor: 1,
+                });
+            }
+            let finalWidth = overrideWidth ?? 0;
+            let finalHeight = overrideHeight ?? 0;
+            if (fullPage) {
+                const metrics = await this.bridge.send('Page.getLayoutMetrics');
+                const m = isRecord(metrics) ? metrics : {};
+                const css = isRecord(m.cssContentSize) ? m.cssContentSize : undefined;
+                const fb = isRecord(m.contentSize) ? m.contentSize : undefined;
+                const size = css ?? fb;
+                if (size && typeof size.width === 'number' && typeof size.height === 'number') {
+                    if (finalWidth === 0)
+                        finalWidth = Math.ceil(size.width);
+                    finalHeight = Math.ceil(size.height);
+                }
+            }
+            await this.bridge.send('Emulation.setDeviceMetricsOverride', {
+                mobile: false,
+                width: finalWidth,
+                height: finalHeight,
+                deviceScaleFactor: 1,
+            });
+        }
+        try {
+            const result = await this.bridge.send('Page.captureScreenshot', {
+                format: options.format ?? 'png',
+                quality: options.format === 'jpeg' ? (options.quality ?? 80) : undefined,
+                captureBeyondViewport: !needsOverride && fullPage,
+            });
+            const base64 = isRecord(result) && typeof result.data === 'string' ? result.data : '';
+            if (options.path) {
+                await saveBase64ToFile(base64, options.path);
+            }
+            return base64;
+        }
+        finally {
+            if (needsOverride) {
+                await this.bridge.send('Emulation.clearDeviceMetricsOverride').catch(() => { });
+            }
         }
-        return base64;
     }
     async startNetworkCapture(pattern = '') {
         // Always update the filter pattern
@@ -320,6 +362,12 @@ class CDPPage extends BasePage {
     async cdp(method, params = {}) {
         return this.bridge.send(method, params);
     }
+    async handleJavaScriptDialog(accept, promptText) {
+        await this.cdp('Page.handleJavaScriptDialog', {
+            accept,
+            ...(promptText !== undefined && { promptText }),
+        });
+    }
     async nativeClick(x, y) {
         await this.cdp('Input.dispatchMouseEvent', {
             type: 'mousePressed',

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

@@ -58,10 +58,12 @@ describe('CDPBridge cookies', () => {
         expect(page.nativeType).toBeTypeOf('function');
         expect(page.nativeKeyPress).toBeTypeOf('function');
         expect(page.nativeClick).toBeTypeOf('function');
+        expect(page.handleJavaScriptDialog).toBeTypeOf('function');
         expect(page.cdp).toBeTypeOf('function');
         await page.nativeType('hello');
         await page.nativeKeyPress('a', ['Ctrl']);
         await page.nativeClick(10, 20);
+        await page.handleJavaScriptDialog(true, 'ok');
         await page.cdp('Page.getLayoutMetrics', {});
         expect(send.mock.calls).toEqual([
             ['Input.insertText', { text: 'hello' }],
@@ -69,6 +71,7 @@ describe('CDPBridge cookies', () => {
             ['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.handleJavaScriptDialog', { accept: true, promptText: 'ok' }],
             ['Page.getLayoutMetrics', {}],
         ]);
     });

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

@@ -20,6 +20,10 @@ export interface DaemonCommand {
     format?: 'png' | 'jpeg';
     quality?: number;
     fullPage?: boolean;
+    /** Override viewport width in CSS pixels for screenshot (0 / undefined = use current) */
+    width?: number;
+    /** Override viewport height in CSS pixels for screenshot (0 / undefined = use current; ignored when fullPage) */
+    height?: number;
     /** Local file paths for set-file-input action */
     files?: string[];
     /** CSS selector for file input element (set-file-input action) */

package/dist/src/browser/errors.js

@@ -65,7 +65,7 @@ export function isTransientBrowserError(err) {
 export function formatBrowserConnectError(kind, detail) {
     switch (kind) {
         case 'daemon-not-running':
-            return new BrowserConnectError('Cannot connect to opencli daemon.' + (detail ? `\n\n${detail}` : ''), `The daemon should auto-start. If it keeps failing, make sure port ${DEFAULT_DAEMON_PORT} is available.`, kind);
+            return new BrowserConnectError('Cannot connect to opencli daemon.' + (detail ? `\n\n${detail}` : ''), `Run \`opencli doctor\` to diagnose, or \`opencli daemon restart\` to force a fresh daemon. Default port is ${DEFAULT_DAEMON_PORT}.`, kind);
         case 'extension-not-connected':
             return new BrowserConnectError('Browser Bridge extension is not connected.' + (detail ? `\n\n${detail}` : ''), 'Install the extension from GitHub Releases, then reload.', kind);
         case 'command-failed':

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

@@ -41,7 +41,7 @@ export declare class Page extends BasePage {
         domain?: string;
         url?: string;
     }): Promise<BrowserCookie[]>;
-    /** Close the automation window in the extension */
+    /** Release the current automation tab lease in the extension */
     closeWindow(): Promise<void>;
     tabs(): Promise<unknown[]>;
     newTab(url?: string): Promise<string | undefined>;
@@ -68,6 +68,7 @@ export declare class Page extends BasePage {
     }>>;
     evaluateInFrame(js: string, frameIndex: number): Promise<unknown>;
     cdp(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    handleJavaScriptDialog(accept: boolean, promptText?: string): Promise<void>;
     /** CDP native click fallback — called when JS el.click() fails */
     protected tryNativeClick(x: number, y: number): Promise<boolean>;
     /** Precise click using DOM.getContentQuads/getBoxModel for inline elements */

package/dist/src/browser/page.js

@@ -143,7 +143,7 @@ export class Page extends BasePage {
         const result = await sendCommand('cookies', { ...this._wsOpt(), ...opts });
         return Array.isArray(result) ? result : [];
     }
-    /** Close the automation window in the extension */
+    /** Release the current automation tab lease in the extension */
     async closeWindow() {
         try {
             await sendCommand('close-window', { ...this._wsOpt() });
@@ -205,6 +205,8 @@ export class Page extends BasePage {
             format: options.format,
             quality: options.quality,
             fullPage: options.fullPage,
+            width: options.width,
+            height: options.height,
         });
         if (options.path) {
             await saveBase64ToFile(base64, options.path);
@@ -283,6 +285,12 @@ export class Page extends BasePage {
             ...this._cmdOpts(),
         });
     }
+    async handleJavaScriptDialog(accept, promptText) {
+        await this.cdp('Page.handleJavaScriptDialog', {
+            accept,
+            ...(promptText !== undefined && { promptText }),
+        });
+    }
     /** CDP native click fallback — called when JS el.click() fails */
     async tryNativeClick(x, y) {
         try {

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

@@ -102,6 +102,23 @@ describe('Page network capture compatibility', () => {
         expect(warnMock).toHaveBeenCalledTimes(1);
     });
 });
+describe('Page CDP helpers', () => {
+    beforeEach(() => {
+        sendCommandMock.mockReset();
+        sendCommandFullMock.mockReset();
+        warnMock.mockReset();
+    });
+    it('handles JavaScript dialogs through the CDP passthrough', async () => {
+        sendCommandMock.mockResolvedValueOnce({});
+        const page = new Page('browser:default');
+        await page.handleJavaScriptDialog(true, 'confirm');
+        expect(sendCommandMock).toHaveBeenCalledWith('cdp', expect.objectContaining({
+            workspace: 'browser:default',
+            cdpMethod: 'Page.handleJavaScriptDialog',
+            cdpParams: { accept: true, promptText: 'confirm' },
+        }));
+    });
+});
 describe('Page active target tracking', () => {
     beforeEach(() => {
         sendCommandMock.mockReset();
@@ -199,3 +216,32 @@ describe('Page active target tracking', () => {
         expect(evalCall?.[1]).not.toHaveProperty('page');
     });
 });
+describe('Page.screenshot', () => {
+    beforeEach(() => {
+        sendCommandMock.mockReset();
+        sendCommandFullMock.mockReset();
+        warnMock.mockReset();
+    });
+    it('forwards width / height / fullPage options to the bridge', async () => {
+        sendCommandMock.mockResolvedValueOnce('BASE64');
+        const page = new Page('browser:default');
+        const data = await page.screenshot({ fullPage: true, width: 1080 });
+        expect(data).toBe('BASE64');
+        expect(sendCommandMock).toHaveBeenCalledWith('screenshot', expect.objectContaining({
+            workspace: 'browser:default',
+            fullPage: true,
+            width: 1080,
+        }));
+    });
+    it('omits viewport overrides when none are set', async () => {
+        sendCommandMock.mockResolvedValueOnce('BASE64');
+        const page = new Page('browser:default');
+        await page.screenshot();
+        const call = sendCommandMock.mock.calls.at(-1);
+        expect(call?.[0]).toBe('screenshot');
+        const args = call?.[1];
+        expect(args.width).toBeUndefined();
+        expect(args.height).toBeUndefined();
+        expect(args.fullPage).toBeUndefined();
+    });
+});

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

@@ -15,8 +15,9 @@
  *   - selector_not_found:     0 matches
  *   - selector_ambiguous:     >1 matches for a write op without --nth
  *   - selector_nth_out_of_range: --nth beyond matches_n
+ *   - not_editable:           target exists but cannot accept text input
  */
-export type TargetErrorCode = 'not_found' | 'stale_ref' | 'invalid_selector' | 'selector_not_found' | 'selector_ambiguous' | 'selector_nth_out_of_range';
+export type TargetErrorCode = 'not_found' | 'stale_ref' | 'invalid_selector' | 'selector_not_found' | 'selector_ambiguous' | 'selector_nth_out_of_range' | 'not_editable';
 export interface TargetErrorInfo {
     code: TargetErrorCode;
     message: string;