@jackwener/opencli 1.7.4 → 1.7.5

package/dist/src/browser/page.js

@@ -27,9 +27,11 @@ function isUnsupportedNetworkCaptureError(err) {
  */
 export class Page extends BasePage {
     workspace;
-    constructor(workspace = 'default') {
+    _idleTimeout;
+    constructor(workspace = 'default', idleTimeout) {
         super();
         this.workspace = workspace;
+        this._idleTimeout = idleTimeout;
     }
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
     _page;
@@ -37,13 +39,14 @@ export class Page extends BasePage {
     _networkCaptureWarned = false;
     /** Helper: spread workspace into command params */
     _wsOpt() {
-        return { workspace: this.workspace };
+        return { workspace: this.workspace, ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }) };
     }
     /** Helper: spread workspace + page identity into command params */
     _cmdOpts() {
         return {
             workspace: this.workspace,
             ...(this._page !== undefined && { page: this._page }),
+            ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
         };
     }
     async goto(url, options) {
@@ -102,9 +105,10 @@ export class Page extends BasePage {
     getActivePage() {
         return this._page;
     }
-    /** @deprecated Use getActivePage() instead */
-    getActiveTabId() {
-        return undefined;
+    /** Bind this Page instance to a specific page identity (targetId). */
+    setActivePage(page) {
+        this._page = page;
+        this._lastUrl = null;
     }
     _markUnsupportedNetworkCapture() {
         this._networkCaptureUnsupported = true;
@@ -150,10 +154,39 @@ export class Page extends BasePage {
         const result = await sendCommand('tabs', { op: 'list', ...this._wsOpt() });
         return Array.isArray(result) ? result : [];
     }
-    async selectTab(index) {
-        const result = await sendCommandFull('tabs', { op: 'select', index, ...this._wsOpt() });
+    async newTab(url) {
+        const result = await sendCommandFull('tabs', {
+            op: 'new',
+            ...(url !== undefined && { url }),
+            ...this._wsOpt(),
+        });
+        this._lastUrl = null;
+        return result.page;
+    }
+    async closeTab(target) {
+        const params = { op: 'close', ...this._wsOpt() };
+        if (typeof target === 'number')
+            params.index = target;
+        else if (typeof target === 'string')
+            params.page = target;
+        else if (this._page !== undefined)
+            params.page = this._page;
+        const result = await sendCommand('tabs', params);
+        const closedPage = typeof result?.closed === 'string' ? result.closed : undefined;
+        if ((closedPage && closedPage === this._page) || (!closedPage && (target === undefined || target === this._page))) {
+            this._page = undefined;
+            this._lastUrl = null;
+        }
+    }
+    async selectTab(target) {
+        const result = await sendCommandFull('tabs', {
+            op: 'select',
+            ...(typeof target === 'number' ? { index: target } : { page: target }),
+            ...this._wsOpt(),
+        });
         if (result.page)
             this._page = result.page;
+        this._lastUrl = null;
     }
     /**
      * Capture a screenshot via CDP Page.captureScreenshot.
@@ -227,6 +260,14 @@ export class Page extends BasePage {
             throw new Error('insertText returned no inserted flag — command may not be supported by the extension');
         }
     }
+    async frames() {
+        const result = await sendCommand('frames', { ...this._cmdOpts() });
+        return Array.isArray(result) ? result : [];
+    }
+    async evaluateInFrame(js, frameIndex) {
+        const code = wrapForEval(js);
+        return sendCommand('exec', { code, frameIndex, ...this._cmdOpts() });
+    }
     async cdp(method, params = {}) {
         return sendCommand('cdp', {
             cdpMethod: method,

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

@@ -102,3 +102,100 @@ describe('Page network capture compatibility', () => {
         expect(warnMock).toHaveBeenCalledTimes(1);
     });
 });
+describe('Page active target tracking', () => {
+    beforeEach(() => {
+        sendCommandMock.mockReset();
+        sendCommandFullMock.mockReset();
+        warnMock.mockReset();
+    });
+    it('tracks only one active page identity at a time', async () => {
+        sendCommandFullMock
+            .mockResolvedValueOnce({ data: { url: 'https://first.example' }, page: 'page-1' })
+            .mockResolvedValueOnce({ data: { selected: true }, page: 'page-2' });
+        sendCommandMock.mockResolvedValue('ok');
+        const page = new Page('browser:default');
+        await page.goto('https://first.example', { waitUntil: 'none' });
+        expect(page.getActivePage()).toBe('page-1');
+        await page.selectTab(1);
+        expect(page.getActivePage()).toBe('page-2');
+        await page.evaluate('1 + 1');
+        expect(sendCommandMock).toHaveBeenLastCalledWith('exec', expect.objectContaining({
+            workspace: 'browser:default',
+            page: 'page-2',
+        }));
+    });
+    it('allows the caller to bind a specific active page identity explicitly', async () => {
+        sendCommandMock.mockResolvedValue('bound');
+        const page = new Page('browser:default');
+        page.setActivePage?.('page-explicit');
+        await page.evaluate('1 + 1');
+        expect(sendCommandMock).toHaveBeenCalledWith('exec', expect.objectContaining({
+            workspace: 'browser:default',
+            page: 'page-explicit',
+        }));
+    });
+    it('creates a new tab without changing the current active page binding', async () => {
+        sendCommandFullMock
+            .mockResolvedValueOnce({ data: { url: 'https://first.example' }, page: 'page-1' })
+            .mockResolvedValueOnce({
+            data: { url: 'https://second.example' },
+            page: 'page-2',
+        });
+        sendCommandMock.mockResolvedValue('ok');
+        const page = new Page('browser:default');
+        await page.goto('https://first.example', { waitUntil: 'none' });
+        const created = await page.newTab?.('https://second.example');
+        expect(created).toBe('page-2');
+        expect(page.getActivePage()).toBe('page-1');
+        await page.evaluate('1 + 1');
+        expect(sendCommandMock).toHaveBeenLastCalledWith('exec', expect.objectContaining({
+            workspace: 'browser:default',
+            page: 'page-1',
+        }));
+    });
+    it('allows the caller to adopt a new tab explicitly after creation', async () => {
+        sendCommandFullMock.mockResolvedValueOnce({
+            data: { url: 'https://second.example' },
+            page: 'page-2',
+        });
+        const page = new Page('browser:default');
+        const created = await page.newTab?.('https://second.example');
+        expect(created).toBe('page-2');
+        expect(page.getActivePage()).toBeUndefined();
+        page.setActivePage?.(created);
+        expect(page.getActivePage()).toBe('page-2');
+        expect(sendCommandFullMock).toHaveBeenCalledWith('tabs', expect.objectContaining({
+            op: 'new',
+            url: 'https://second.example',
+            workspace: 'browser:default',
+        }));
+    });
+    it('closes a tab by explicit page identity', async () => {
+        sendCommandMock.mockResolvedValueOnce({ closed: 'page-2' });
+        const page = new Page('browser:default');
+        await page.closeTab?.('page-2');
+        expect(sendCommandMock).toHaveBeenCalledWith('tabs', expect.objectContaining({
+            op: 'close',
+            workspace: 'browser:default',
+            page: 'page-2',
+        }));
+    });
+    it('clears the active page binding when closing the selected tab by numeric index', async () => {
+        sendCommandFullMock.mockResolvedValueOnce({ data: { selected: true }, page: 'page-2' });
+        sendCommandMock
+            .mockResolvedValueOnce({ closed: 'page-2' })
+            .mockResolvedValueOnce('ok');
+        const page = new Page('browser:default');
+        await page.selectTab(1);
+        expect(page.getActivePage()).toBe('page-2');
+        await page.closeTab?.(1);
+        expect(page.getActivePage()).toBeUndefined();
+        await page.evaluate('1 + 1');
+        const evalCall = sendCommandMock.mock.calls.at(-1);
+        expect(evalCall?.[0]).toBe('exec');
+        expect(evalCall?.[1]).toEqual(expect.objectContaining({
+            workspace: 'browser:default',
+        }));
+        expect(evalCall?.[1]).not.toHaveProperty('page');
+    });
+});