@jackwener/opencli 1.6.9 → 1.6.10

package/dist/clis/xueqiu/watchlist.js

@@ -0,0 +1,45 @@
+import { cli } from '@jackwener/opencli/registry';
+cli({
+    site: 'xueqiu',
+    name: 'watchlist',
+    description: '获取雪球自选股/模拟组合股票列表',
+    domain: 'xueqiu.com',
+    browser: true,
+    args: [
+        {
+            name: 'pid',
+            default: '-1',
+            help: '分组ID：-1=全部(默认) -4=模拟 -5=沪深 -6=美股 -7=港股 -10=实盘 0=持仓（通过 xueqiu groups 获取）',
+        },
+        { name: 'limit', type: 'int', default: 100, help: '默认 100' },
+    ],
+    columns: ['symbol', 'name', 'price', 'changePercent'],
+    pipeline: [
+        { navigate: 'https://xueqiu.com' },
+        { evaluate: `(async () => {
+  const pid = \${{ args.pid | json }} || '-1';
+  const resp = await fetch(\`https://stock.xueqiu.com/v5/stock/portfolio/stock/list.json?size=100&category=1&pid=\${encodeURIComponent(pid)}\`, {credentials: 'include'});
+  if (!resp.ok) throw new Error('HTTP ' + resp.status + ' Hint: Not logged in?');
+  const d = await resp.json();
+  if (!d.data || !d.data.stocks) throw new Error('获取失败，可能未登录');
+
+  return d.data.stocks.map(s => ({
+    symbol: s.symbol,
+    name: s.name,
+    price: s.current,
+    change: s.chg,
+    changePercent: s.percent != null ? s.percent.toFixed(2) + '%' : null,
+    volume: s.volume,
+    url: 'https://xueqiu.com/S/' + s.symbol
+  }));
+})()
+` },
+        { map: {
+                symbol: '${{ item.symbol }}',
+                name: '${{ item.name }}',
+                price: '${{ item.price }}',
+                changePercent: '${{ item.changePercent }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/zhihu/hot.d.ts

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

package/dist/clis/zhihu/hot.js

@@ -0,0 +1,43 @@
+import { cli } from '@jackwener/opencli/registry';
+cli({
+    site: 'zhihu',
+    name: 'hot',
+    description: '知乎热榜',
+    domain: 'www.zhihu.com',
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
+    ],
+    columns: ['rank', 'title', 'heat', 'answers'],
+    pipeline: [
+        { navigate: 'https://www.zhihu.com' },
+        { evaluate: `(async () => {
+  const res = await fetch('https://www.zhihu.com/api/v3/feed/topstory/hot-lists/total?limit=50', {
+    credentials: 'include'
+  });
+  const text = await res.text();
+  const d = JSON.parse(
+    text.replace(/("id"\\s*:\\s*)(\\d{16,})/g, '$1"$2"')
+  );
+  return (d?.data || []).map((item) => {
+    const t = item.target || {};
+    const questionId = t.id == null ? '' : String(t.id);
+    return {
+      title: t.title,
+      url: 'https://www.zhihu.com/question/' + questionId,
+      answer_count: t.answer_count,
+      follower_count: t.follower_count,
+      heat: item.detail_text || '',
+    };
+  });
+})()
+` },
+        { map: {
+                rank: '${{ index + 1 }}',
+                title: '${{ item.title }}',
+                heat: '${{ item.heat }}',
+                answers: '${{ item.answer_count }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/zhihu/search.d.ts

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

package/dist/clis/zhihu/search.js

@@ -0,0 +1,52 @@
+import { cli } from '@jackwener/opencli/registry';
+cli({
+    site: 'zhihu',
+    name: 'search',
+    description: '知乎搜索',
+    domain: 'www.zhihu.com',
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Search query' },
+        { name: 'limit', type: 'int', default: 10, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'type', 'author', 'votes', 'url'],
+    pipeline: [
+        { navigate: 'https://www.zhihu.com' },
+        { evaluate: `(async () => {
+  const strip = (html) => (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').replace(/<em>/g, '').replace(/<\\/em>/g, '').trim();
+  const keyword = \${{ args.query | json }};
+  const limit = \${{ args.limit }};
+  const res = await fetch('https://www.zhihu.com/api/v4/search_v3?q=' + encodeURIComponent(keyword) + '&t=general&offset=0&limit=' + limit, {
+    credentials: 'include'
+  });
+  const d = await res.json();
+  return (d?.data || [])
+    .filter(item => item.type === 'search_result')
+    .map(item => {
+      const obj = item.object || {};
+      const q = obj.question || {};
+      return {
+        type: obj.type,
+        title: strip(obj.title || q.name || ''),
+        excerpt: strip(obj.excerpt || '').substring(0, 100),
+        author: obj.author?.name || '',
+        votes: obj.voteup_count || 0,
+        url: obj.type === 'answer'
+          ? 'https://www.zhihu.com/question/' + q.id + '/answer/' + obj.id
+          : obj.type === 'article'
+          ? 'https://zhuanlan.zhihu.com/p/' + obj.id
+          : 'https://www.zhihu.com/question/' + obj.id,
+      };
+    });
+})()
+` },
+        { map: {
+                rank: '${{ index + 1 }}',
+                title: '${{ item.title }}',
+                type: '${{ item.type }}',
+                author: '${{ item.author }}',
+                votes: '${{ item.votes }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

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

@@ -7,6 +7,9 @@ import type { BrowserSessionInfo } from '../types.js';
 export interface DaemonCommand {
     id: string;
     action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'insert-text' | 'bind-current' | 'network-capture-start' | 'network-capture-read' | 'cdp';
+    /** Target page identity (targetId). Cross-layer contract — preferred over tabId. */
+    page?: string;
+    /** @deprecated Legacy tab ID — use `page` (targetId) instead. */
     tabId?: number;
     code?: string;
     workspace?: string;
@@ -35,6 +38,8 @@ export interface DaemonResult {
     ok: boolean;
     data?: unknown;
     error?: string;
+    /** Page identity (targetId) — present on page-scoped command responses */
+    page?: string;
 }
 export interface DaemonStatus {
     ok: boolean;
@@ -71,11 +76,17 @@ export declare function requestDaemonShutdown(opts?: {
     timeout?: number;
 }): Promise<boolean>;
 /**
- * Send a command to the daemon and wait for a result.
- * Retries up to 4 times: network errors retry at 500ms,
- * transient extension errors retry at 1500ms.
+ * Send a command to the daemon and return the result data.
  */
 export declare function sendCommand(action: DaemonCommand['action'], params?: Omit<DaemonCommand, 'id' | 'action'>): Promise<unknown>;
+/**
+ * Like sendCommand, but returns both data and page identity (targetId).
+ * Use this for page-scoped commands where the caller needs the page identity.
+ */
+export declare function sendCommandFull(action: DaemonCommand['action'], params?: Omit<DaemonCommand, 'id' | 'action'>): Promise<{
+    data: unknown;
+    page?: string;
+}>;
 export declare function listSessions(): Promise<BrowserSessionInfo[]>;
 export declare function bindCurrentTab(workspace: string, opts?: {
     matchDomain?: string;

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

@@ -5,7 +5,7 @@
  */
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { sleep } from '../utils.js';
-import { isTransientBrowserError } from './errors.js';
+import { classifyBrowserError } from './errors.js';
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
 const OPENCLI_HEADERS = { 'X-OpenCLI': '1' };
@@ -61,14 +61,17 @@ export async function requestDaemonShutdown(opts) {
     }
 }
 /**
- * Send a command to the daemon and wait for a result.
- * Retries up to 4 times: network errors retry at 500ms,
- * transient extension errors retry at 1500ms.
+ * Internal: send a command to the daemon with retry logic.
+ * Returns the raw DaemonResult. All retry policy lives here — callers
+ * (sendCommand, sendCommandFull) only shape the return value.
+ *
+ * Retries up to 4 times:
+ * - Network errors (TypeError, AbortError): retry at 500ms
+ * - Transient browser errors: retry at the delay suggested by classifyBrowserError()
  */
-export async function sendCommand(action, params = {}) {
+async function sendCommandRaw(action, params) {
     const maxRetries = 4;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        // Generate a fresh ID per attempt to avoid daemon-side duplicate detection
         const id = generateId();
         const command = { id, action, ...params };
         try {
@@ -80,29 +83,42 @@ export async function sendCommand(action, params = {}) {
             });
             const result = (await res.json());
             if (!result.ok) {
-                // Check if error is a transient extension issue worth retrying
-                if (isTransientBrowserError(new Error(result.error ?? '')) && attempt < maxRetries) {
-                    // Longer delay for extension recovery (service worker restart)
-                    await sleep(1500);
+                const advice = classifyBrowserError(new Error(result.error ?? ''));
+                if (advice.retryable && attempt < maxRetries) {
+                    await sleep(advice.delayMs);
                     continue;
                 }
                 throw new Error(result.error ?? 'Daemon command failed');
             }
-            return result.data;
+            return result;
         }
         catch (err) {
-            const isRetryable = err instanceof TypeError // fetch network error
+            const isNetworkError = err instanceof TypeError
                 || (err instanceof Error && err.name === 'AbortError');
-            if (isRetryable && attempt < maxRetries) {
+            if (isNetworkError && attempt < maxRetries) {
                 await sleep(500);
                 continue;
             }
             throw err;
         }
     }
-    // Unreachable — the loop always returns or throws
     throw new Error('sendCommand: max retries exhausted');
 }
+/**
+ * Send a command to the daemon and return the result data.
+ */
+export async function sendCommand(action, params = {}) {
+    const result = await sendCommandRaw(action, params);
+    return result.data;
+}
+/**
+ * Like sendCommand, but returns both data and page identity (targetId).
+ * Use this for page-scoped commands where the caller needs the page identity.
+ */
+export async function sendCommandFull(action, params = {}) {
+    const result = await sendCommandRaw(action, params);
+    return { data: result.data, page: result.page };
+}
 export async function listSessions() {
     const result = await sendCommand('sessions');
     return Array.isArray(result) ? result : [];

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

@@ -24,11 +24,12 @@ describe('waitForCaptureJs', () => {
     });
     it('resolves "captured" when __opencli_xhr is populated before deadline', async () => {
         const g = globalThis;
-        g.__opencli_xhr = [];
+        const captured = [];
+        g.__opencli_xhr = captured;
         g.window = g; // stub window for Node eval
         const code = waitForCaptureJs(1000);
         const promise = eval(code);
-        g.__opencli_xhr.push({ data: 'test' });
+        captured.push({ data: 'test' });
         await expect(promise).resolves.toBe('captured');
         delete g.__opencli_xhr;
         delete g.window;

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

@@ -6,7 +6,32 @@
  */
 import { BrowserConnectError, type BrowserConnectKind } from '../errors.js';
 /**
- * Check if an error message indicates a transient browser error worth retrying.
+ * Unified browser error classification.
+ *
+ * All transient error detection lives here — daemon-client, pipeline executor,
+ * and page retry logic all use this single system instead of maintaining
+ * separate pattern lists.
+ */
+/** Error category — determines which layer should retry. */
+export type BrowserErrorKind = 'extension-transient' | 'target-navigation' | 'non-retryable';
+/** How the caller should handle the error. */
+export interface RetryAdvice {
+    /** Error category — callers use this to decide whether *they* should retry. */
+    kind: BrowserErrorKind;
+    /** Whether the error is transient and worth retrying. */
+    retryable: boolean;
+    /** Suggested delay before retry (ms). */
+    delayMs: number;
+}
+/**
+ * Classify a browser error and return retry advice.
+ *
+ * Single source of truth for "is this error transient?" across all layers.
+ */
+export declare function classifyBrowserError(err: unknown): RetryAdvice;
+/**
+ * Check if an error is a transient browser error worth retrying.
+ * Convenience wrapper around classifyBrowserError().
  */
 export declare function isTransientBrowserError(err: unknown): boolean;
 export type ConnectFailureKind = BrowserConnectKind;

package/dist/src/browser/errors.js

@@ -7,24 +7,57 @@
 import { BrowserConnectError } from '../errors.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 /**
- * Transient browser error patterns — shared across daemon-client, pipeline executor,
- * and page retry logic. These errors indicate temporary conditions (extension restart,
- * service worker cycle, tab navigation) that are worth retrying.
+ * Extension/daemon transient patterns — service worker restarts, attach races,
+ * tab closure, daemon hiccups. These warrant a longer retry delay (~1500ms)
+ * because the extension needs time to recover.
  */
-const TRANSIENT_ERROR_PATTERNS = [
+const EXTENSION_TRANSIENT_PATTERNS = [
     'Extension disconnected',
     'Extension not connected',
     'attach failed',
     'no longer exists',
     'CDP connection',
     'Daemon command failed',
+    'No window with id',
 ];
 /**
- * Check if an error message indicates a transient browser error worth retrying.
+ * CDP target navigation patterns — SPA client-side redirects can invalidate the
+ * CDP target after chrome.tabs reports 'complete'. These warrant a shorter retry
+ * delay (~200ms) because the new document is usually available quickly.
+ */
+const TARGET_NAVIGATION_PATTERNS = [
+    'Inspected target navigated or closed',
+];
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Classify a browser error and return retry advice.
+ *
+ * Single source of truth for "is this error transient?" across all layers.
+ */
+export function classifyBrowserError(err) {
+    const msg = errorMessage(err);
+    // Extension/daemon transient errors — longer recovery time
+    if (EXTENSION_TRANSIENT_PATTERNS.some(p => msg.includes(p))) {
+        return { kind: 'extension-transient', retryable: true, delayMs: 1500 };
+    }
+    // CDP target navigation errors — shorter recovery time
+    if (TARGET_NAVIGATION_PATTERNS.some(p => msg.includes(p))) {
+        return { kind: 'target-navigation', retryable: true, delayMs: 200 };
+    }
+    // CDP protocol error with target context (e.g., -32000 "target closed")
+    if (msg.includes('-32000') && msg.toLowerCase().includes('target')) {
+        return { kind: 'target-navigation', retryable: true, delayMs: 200 };
+    }
+    return { kind: 'non-retryable', retryable: false, delayMs: 0 };
+}
+/**
+ * Check if an error is a transient browser error worth retrying.
+ * Convenience wrapper around classifyBrowserError().
  */
 export function isTransientBrowserError(err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return TRANSIENT_ERROR_PATTERNS.some(pattern => msg.includes(pattern));
+    return classifyBrowserError(err).retryable;
 }
 export function formatBrowserConnectError(kind, detail) {
     switch (kind) {

package/dist/src/browser/errors.test.d.ts

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

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

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import { classifyBrowserError, isTransientBrowserError } from './errors.js';
+describe('classifyBrowserError', () => {
+    it('classifies extension transient errors with 1500ms delay', () => {
+        for (const msg of [
+            'Extension disconnected',
+            'Extension not connected',
+            'attach failed',
+            'no longer exists',
+            'CDP connection reset',
+            'Daemon command failed',
+            'No window with id: 123',
+        ]) {
+            const advice = classifyBrowserError(new Error(msg));
+            expect(advice.kind, `expected "${msg}" → extension-transient`).toBe('extension-transient');
+            expect(advice.retryable).toBe(true);
+            expect(advice.delayMs).toBe(1500);
+        }
+    });
+    it('classifies CDP target navigation errors with 200ms delay', () => {
+        const advice = classifyBrowserError(new Error('Inspected target navigated or closed'));
+        expect(advice.kind).toBe('target-navigation');
+        expect(advice.retryable).toBe(true);
+        expect(advice.delayMs).toBe(200);
+    });
+    it('classifies CDP -32000 target errors with 200ms delay', () => {
+        const advice = classifyBrowserError(new Error('{"code":-32000,"message":"Target closed"}'));
+        expect(advice.kind).toBe('target-navigation');
+        expect(advice.retryable).toBe(true);
+        expect(advice.delayMs).toBe(200);
+    });
+    it('returns non-retryable for unrelated errors', () => {
+        for (const msg of ['Permission denied', 'malformed exec payload', 'SyntaxError']) {
+            const advice = classifyBrowserError(new Error(msg));
+            expect(advice.kind).toBe('non-retryable');
+            expect(advice.retryable).toBe(false);
+        }
+    });
+    it('handles non-Error values', () => {
+        expect(classifyBrowserError('Extension disconnected').kind).toBe('extension-transient');
+        expect(classifyBrowserError(42).kind).toBe('non-retryable');
+    });
+});
+describe('isTransientBrowserError (convenience wrapper)', () => {
+    it('returns true for transient errors', () => {
+        expect(isTransientBrowserError(new Error('No window with id: 123'))).toBe(true);
+    });
+    it('returns false for non-transient errors', () => {
+        expect(isTransientBrowserError(new Error('Permission denied'))).toBe(false);
+    });
+});

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

@@ -4,30 +4,31 @@
  * All browser operations are ultimately 'exec' (JS evaluation via CDP)
  * plus a few native Chrome Extension APIs (tabs, cookies, navigate).
  *
- * IMPORTANT: After goto(), we remember the tabId returned by the navigate
- * action and pass it to all subsequent commands. This avoids the issue
- * where resolveTabId() in the extension picks a chrome:// or
- * chrome-extension:// tab that can't be debugged.
+ * IMPORTANT: After goto(), we remember the page identity (targetId) returned
+ * by the navigate action and pass it to all subsequent commands. This ensures
+ * page-scoped operations target the correct page without guessing.
  */
 import type { BrowserCookie, ScreenshotOptions } from '../types.js';
 import { BasePage } from './base-page.js';
-export declare function isRetryableSettleError(err: unknown): boolean;
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export declare class Page extends BasePage {
     private readonly workspace;
     constructor(workspace?: string);
-    /** Active tab ID, set after navigate and used in all subsequent commands */
-    private _tabId;
+    /** Active page identity (targetId), set after navigate and used in all subsequent commands */
+    private _page;
     /** Helper: spread workspace into command params */
     private _wsOpt;
-    /** Helper: spread workspace + tabId into command params */
+    /** Helper: spread workspace + page identity into command params */
     private _cmdOpts;
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
     }): Promise<void>;
+    /** Get the active page identity (targetId) */
+    getActivePage(): string | undefined;
+    /** @deprecated Use getActivePage() instead */
     getActiveTabId(): number | undefined;
     evaluate(js: string): Promise<unknown>;
     getCookies(opts?: {

package/dist/src/browser/page.js

@@ -4,22 +4,17 @@
  * All browser operations are ultimately 'exec' (JS evaluation via CDP)
  * plus a few native Chrome Extension APIs (tabs, cookies, navigate).
  *
- * IMPORTANT: After goto(), we remember the tabId returned by the navigate
- * action and pass it to all subsequent commands. This avoids the issue
- * where resolveTabId() in the extension picks a chrome:// or
- * chrome-extension:// tab that can't be debugged.
+ * IMPORTANT: After goto(), we remember the page identity (targetId) returned
+ * by the navigate action and pass it to all subsequent commands. This ensures
+ * page-scoped operations target the correct page without guessing.
  */
-import { sendCommand } from './daemon-client.js';
+import { sendCommand, sendCommandFull } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
 import { saveBase64ToFile } from '../utils.js';
 import { generateStealthJs } from './stealth.js';
 import { waitForDomStableJs } from './dom-helpers.js';
 import { BasePage } from './base-page.js';
-export function isRetryableSettleError(err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return message.includes('Inspected target navigated or closed')
-        || (message.includes('-32000') && message.toLowerCase().includes('target'));
-}
+import { classifyBrowserError } from './errors.js';
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
@@ -29,27 +24,27 @@ export class Page extends BasePage {
         super();
         this.workspace = workspace;
     }
-    /** Active tab ID, set after navigate and used in all subsequent commands */
-    _tabId;
+    /** Active page identity (targetId), set after navigate and used in all subsequent commands */
+    _page;
     /** Helper: spread workspace into command params */
     _wsOpt() {
         return { workspace: this.workspace };
     }
-    /** Helper: spread workspace + tabId into command params */
+    /** Helper: spread workspace + page identity into command params */
     _cmdOpts() {
         return {
             workspace: this.workspace,
-            ...(this._tabId !== undefined && { tabId: this._tabId }),
+            ...(this._page !== undefined && { page: this._page }),
         };
     }
     async goto(url, options) {
-        const result = await sendCommand('navigate', {
+        const result = await sendCommandFull('navigate', {
             url,
             ...this._cmdOpts(),
         });
-        // Remember the tabId and URL for subsequent calls
-        if (result?.tabId) {
-            this._tabId = result.tabId;
+        // Remember the page identity (targetId) for subsequent calls
+        if (result.page) {
+            this._page = result.page;
         }
         this._lastUrl = url;
         // Inject stealth + settle in a single round-trip instead of two sequential exec calls.
@@ -65,17 +60,18 @@ export class Page extends BasePage {
                 await sendCommand('exec', combinedOpts);
             }
             catch (err) {
-                if (!isRetryableSettleError(err))
+                const advice = classifyBrowserError(err);
+                // Only settle-retry on target navigation (SPA client-side redirects).
+                // Extension/daemon errors are already retried by sendCommandRaw —
+                // retrying them here would silently swallow real failures.
+                if (advice.kind !== 'target-navigation')
                     throw err;
-                // SPA client-side redirects can invalidate the CDP target after
-                // chrome.tabs reports 'complete'. Wait briefly for the new document
-                // to load, then retry the settle probe once.
                 try {
-                    await new Promise((r) => setTimeout(r, 200));
+                    await new Promise((r) => setTimeout(r, advice.delayMs));
                     await sendCommand('exec', combinedOpts);
                 }
                 catch (retryErr) {
-                    if (!isRetryableSettleError(retryErr))
+                    if (classifyBrowserError(retryErr).kind !== 'target-navigation')
                         throw retryErr;
                 }
             }
@@ -93,8 +89,13 @@ export class Page extends BasePage {
             }
         }
     }
+    /** Get the active page identity (targetId) */
+    getActivePage() {
+        return this._page;
+    }
+    /** @deprecated Use getActivePage() instead */
     getActiveTabId() {
-        return this._tabId;
+        return undefined;
     }
     async evaluate(js) {
         const code = wrapForEval(js);
@@ -102,9 +103,10 @@ export class Page extends BasePage {
             return await sendCommand('exec', { code, ...this._cmdOpts() });
         }
         catch (err) {
-            if (!isRetryableSettleError(err))
+            const advice = classifyBrowserError(err);
+            if (advice.kind !== 'target-navigation')
                 throw err;
-            await new Promise((resolve) => setTimeout(resolve, 200));
+            await new Promise((resolve) => setTimeout(resolve, advice.delayMs));
             return sendCommand('exec', { code, ...this._cmdOpts() });
         }
     }
@@ -121,7 +123,7 @@ export class Page extends BasePage {
             // Window may already be closed or daemon may be down
         }
         finally {
-            this._tabId = undefined;
+            this._page = undefined;
             this._lastUrl = null;
         }
     }
@@ -130,9 +132,9 @@ export class Page extends BasePage {
         return Array.isArray(result) ? result : [];
     }
     async selectTab(index) {
-        const result = await sendCommand('tabs', { op: 'select', index, ...this._wsOpt() });
-        if (result?.selected)
-            this._tabId = result.selected;
+        const result = await sendCommandFull('tabs', { op: 'select', index, ...this._wsOpt() });
+        if (result.page)
+            this._page = result.page;
     }
     /**
      * Capture a screenshot via CDP Page.captureScreenshot.