@jackwener/opencli 1.7.15 → 1.7.17

package/clis/youtube/unsubscribe.js

@@ -2,7 +2,7 @@
  * YouTube unsubscribe — unsubscribe from a channel via InnerTube subscription API.
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { prepareYoutubeApiPage, SAPISID_HASH_FN, RESOLVE_CHANNEL_HANDLE_FN } from './utils.js';
+import { prepareYoutubeApiPage, readYoutubeSapisid, SAPISID_HASH_FN, RESOLVE_CHANNEL_HANDLE_FN } from './utils.js';
 import { CommandExecutionError, AuthRequiredError } from '@jackwener/opencli/errors';
 
 cli({
@@ -19,6 +19,10 @@ cli({
     func: async (page, kwargs) => {
         const channelInput = String(kwargs.channel);
         await prepareYoutubeApiPage(page);
+        // Read SAPISID directly from the cookie store via CDP — zero document.cookie round-trip
+        const sapisid = await readYoutubeSapisid(page);
+        if (!sapisid)
+            throw new AuthRequiredError('www.youtube.com', 'Not logged in (SAPISID cookie missing)');
         const result = await page.evaluate(`
       (async () => {
         ${SAPISID_HASH_FN}
@@ -28,7 +32,7 @@ cli({
         const context = cfg.INNERTUBE_CONTEXT;
         if (!apiKey || !context) return { error: 'config', message: 'YouTube config not found' };
 
-        const authHash = await getSapisidHash('https://www.youtube.com');
+        const authHash = await getSapisidHash(${JSON.stringify(sapisid)}, 'https://www.youtube.com');
         if (!authHash) return { error: 'auth', message: 'Not logged in (SAPISID cookie missing)' };
 
         ${RESOLVE_CHANNEL_HANDLE_FN}

package/clis/youtube/utils.js

@@ -189,21 +189,13 @@ async function resolveChannelHandle(input, apiKey, context) {
  * Inline SAPISIDHASH helper for use inside page.evaluate() strings.
  * YouTube write APIs (like, subscribe) require:
  *   Authorization: SAPISIDHASH {time}_{SHA1(time + " " + SAPISID + " " + origin)}
+ *
+ * The SAPISID cookie value must be hoisted from the cookie store on the Node side
+ * (via `readYoutubeSapisid(page)`) and passed in here — keeps `crypto.subtle.digest`
+ * (browser Web Crypto) call site, but no `document.cookie` round-trip.
  */
 export const SAPISID_HASH_FN = `
-async function getSapisidHash(origin) {
-  const cookies = document.cookie.split('; ');
-  let sapisid = '';
-  for (const c of cookies) {
-    const eq = c.indexOf('=');
-    if (eq === -1) continue;
-    const name = c.slice(0, eq);
-    const val = c.slice(eq + 1);
-    if (name === '__Secure-3PAPISID' || name === 'SAPISID') {
-      sapisid = val;
-      if (name === '__Secure-3PAPISID') break;
-    }
-  }
+async function getSapisidHash(sapisid, origin) {
   if (!sapisid) return null;
   const time = Math.floor(Date.now() / 1000);
   const msgBuffer = new TextEncoder().encode(time + ' ' + sapisid + ' ' + origin);
@@ -212,3 +204,17 @@ async function getSapisidHash(origin) {
   return 'SAPISIDHASH ' + time + '_' + hashHex;
 }
 `;
+
+/**
+ * Read the YouTube SAPISID cookie via CDP, preferring `__Secure-3PAPISID`
+ * (current first-party cookie) and falling back to the legacy `SAPISID` name.
+ * Returns the cookie value, or null if neither is present.
+ */
+export async function readYoutubeSapisid(page) {
+  const cookies = await page.getCookies({ url: 'https://www.youtube.com' });
+  return (
+    cookies.find((c) => c.name === '__Secure-3PAPISID')?.value
+    || cookies.find((c) => c.name === 'SAPISID')?.value
+    || null
+  );
+}

package/clis/youtube/utils.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { extractJsonAssignmentFromHtml, extractSubscriptionChannel, prepareYoutubeApiPage } from './utils.js';
+import { extractJsonAssignmentFromHtml, extractSubscriptionChannel, prepareYoutubeApiPage, readYoutubeSapisid } from './utils.js';
 describe('youtube utils', () => {
     it('extractJsonAssignmentFromHtml parses bootstrap objects with nested braces in strings', () => {
         const html = `
@@ -34,6 +34,22 @@ describe('youtube utils', () => {
         expect(page.goto).toHaveBeenCalledWith('https://www.youtube.com', { waitUntil: 'none' });
         expect(page.wait).toHaveBeenCalledWith(2);
     });
+    it('readYoutubeSapisid reads URL-scoped cookies and prefers secure SAPISID', async () => {
+        const page = {
+            getCookies: vi.fn().mockResolvedValue([
+                { name: 'SAPISID', value: 'legacy' },
+                { name: '__Secure-3PAPISID', value: 'secure' },
+            ]),
+        };
+        await expect(readYoutubeSapisid(page)).resolves.toBe('secure');
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://www.youtube.com' });
+    });
+    it('readYoutubeSapisid falls back to legacy SAPISID', async () => {
+        const page = {
+            getCookies: vi.fn().mockResolvedValue([{ name: 'SAPISID', value: 'legacy' }]),
+        };
+        await expect(readYoutubeSapisid(page)).resolves.toBe('legacy');
+    });
     it('extractSubscriptionChannel prefers explicit handle and subscriber count fields', () => {
         expect(extractSubscriptionChannel({
             title: { simpleText: 'OpenAI' },

package/clis/yuanbao/ask.js

@@ -305,7 +305,7 @@ export const askCommand = cli({
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     defaultFormat: 'plain',
     args: [

package/clis/yuanbao/detail.js

@@ -18,7 +18,7 @@ cli({
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         {

package/clis/yuanbao/history.js

@@ -17,7 +17,7 @@ cli({
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Max conversations to list (sidebar virtual scroll caps actual count)' },

package/clis/yuanbao/new.js

@@ -55,7 +55,7 @@ export const newCommand = cli({
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [],
     columns: ['Status', 'Action'],

package/clis/yuanbao/read.js

@@ -14,7 +14,7 @@ cli({
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [],
     columns: ['Role', 'Text'],

package/clis/yuanbao/send.js

@@ -18,7 +18,7 @@ cli({
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Prompt to send to Yuanbao' },

package/clis/yuanbao/status.js

@@ -15,7 +15,7 @@ cli({
     domain: YUANBAO_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
-    browserSession: { reuse: 'site' },
+    siteSession: 'persistent',
     navigateBefore: false,
     args: [],
     columns: ['Status', 'Login', 'Model', 'ModelId', 'AgentId', 'SessionId', 'Url'],

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

@@ -14,9 +14,12 @@ export declare class BrowserBridge implements IBrowserFactory {
     get state(): BrowserBridgeState;
     connect(opts?: {
         timeout?: number;
-        workspace?: string;
+        session?: string;
         idleTimeout?: number;
         contextId?: string;
+        windowMode?: 'foreground' | 'background';
+        surface?: 'browser' | 'adapter';
+        siteSession?: 'ephemeral' | 'persistent';
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;

package/dist/src/browser/bridge.js

@@ -32,7 +32,9 @@ export class BrowserBridge {
         try {
             const contextId = opts.contextId ?? resolveProfileContextId();
             await this._ensureDaemon(opts.timeout, contextId);
-            this._page = new Page(opts.workspace, opts.idleTimeout, contextId);
+            if (!opts.session?.trim())
+                throw new Error('Browser session is required');
+            this._page = new Page(opts.session.trim(), opts.idleTimeout, contextId, opts.windowMode, opts.surface, opts.siteSession);
             this._state = 'connected';
             return this._page;
         }

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

@@ -23,10 +23,13 @@ export declare class CDPBridge implements IBrowserFactory {
     private _eventListeners;
     connect(opts?: {
         timeout?: number;
-        workspace?: string;
+        session?: string;
         cdpEndpoint?: string;
         contextId?: string;
         idleTimeout?: number;
+        windowMode?: 'foreground' | 'background';
+        surface?: 'browser' | 'adapter';
+        siteSession?: 'ephemeral' | 'persistent';
     }): Promise<IPage>;
     close(): Promise<void>;
     send(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;

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

@@ -3,20 +3,20 @@
  *
  * Provides a typed send() function that posts a Command and returns a Result.
  */
-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' | 'network-capture-start' | 'network-capture-read' | 'wait-download' | 'cdp' | 'frames';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'set-file-input' | 'insert-text' | 'bind' | 'network-capture-start' | 'network-capture-read' | 'wait-download' | 'cdp' | 'frames';
     /** Target page identity (targetId). Cross-layer contract with the extension. */
     page?: string;
     code?: string;
-    workspace?: string;
+    session?: string;
+    surface?: 'browser' | 'adapter';
+    /** Adapter site session lifecycle. Persistent site sessions do not idle-expire. */
+    siteSession?: 'ephemeral' | 'persistent';
     url?: string;
     op?: string;
     index?: number;
     domain?: string;
-    matchDomain?: string;
-    matchPathPrefix?: string;
     format?: 'png' | 'jpeg';
     quality?: number;
     fullPage?: boolean;
@@ -36,12 +36,10 @@ export interface DaemonCommand {
     timeoutMs?: number;
     cdpMethod?: string;
     cdpParams?: Record<string, unknown>;
-    /** When true, the owned automation container is created in the foreground */
-    windowFocused?: boolean;
-    /** Custom idle timeout in seconds for this workspace session. Overrides the default. */
+    /** Window foreground/background policy for owned Browser Bridge containers. */
+    windowMode?: 'foreground' | 'background';
+    /** Custom idle timeout in seconds for this session. Overrides the default. */
     idleTimeout?: number;
-    /** Explicitly allow navigation inside a borrowed bound tab. */
-    allowBoundNavigation?: boolean;
     /** Frame index for cross-frame operations (0-based, from 'frames' action) */
     frameIndex?: number;
     /** Browser profile/context to route the command to. */
@@ -129,11 +127,6 @@ export declare function sendCommandFull(action: DaemonCommand['action'], params?
     data: unknown;
     page?: string;
 }>;
-export declare function listSessions(opts?: {
-    contextId?: string;
-}): Promise<BrowserSessionInfo[]>;
-export declare function bindTab(workspace: string, opts?: {
-    matchDomain?: string;
-    matchPathPrefix?: string;
+export declare function bindTab(session: string, opts?: {
     contextId?: string;
 }): Promise<unknown>;

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

@@ -89,10 +89,13 @@ async function sendCommandRaw(action, params) {
     const maxRetries = 4;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
         const id = generateId();
-        const wf = process.env.OPENCLI_WINDOW_FOCUSED;
-        const windowFocused = (wf === '1' || wf === 'true') ? true : undefined;
+        const rawWindowMode = process.env.OPENCLI_WINDOW;
+        const envWindowMode = rawWindowMode === 'foreground' || rawWindowMode === 'background'
+            ? rawWindowMode
+            : undefined;
         const contextId = params.contextId ?? resolveProfileContextId();
-        const command = { id, action, ...params, ...(contextId && { contextId }), ...(windowFocused && { windowFocused }) };
+        const windowMode = params.windowMode ?? envWindowMode;
+        const command = { id, action, ...params, ...(contextId && { contextId }), ...(windowMode && { windowMode }) };
         try {
             const res = await requestDaemon('/command', {
                 method: 'POST',
@@ -143,10 +146,6 @@ export async function sendCommandFull(action, params = {}) {
     const result = await sendCommandRaw(action, params);
     return { data: result.data, page: result.page };
 }
-export async function listSessions(opts) {
-    const result = await sendCommand('sessions', { ...(opts?.contextId && { contextId: opts.contextId }) });
-    return Array.isArray(result) ? result : [];
-}
-export async function bindTab(workspace, opts = {}) {
-    return sendCommand('bind', { workspace, ...opts });
+export async function bindTab(session, opts = {}) {
+    return sendCommand('bind', { session, surface: 'browser', ...opts });
 }

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

@@ -144,6 +144,16 @@ describe('daemon-client', () => {
         const body = JSON.parse(String(vi.mocked(fetch).mock.calls[0][1]?.body));
         expect(body.contextId).toBe('work');
     });
+    it('sendCommand uses explicit windowMode before OPENCLI_WINDOW env fallback', async () => {
+        vi.stubEnv('OPENCLI_WINDOW', 'foreground');
+        vi.mocked(fetch).mockResolvedValue({
+            status: 200,
+            json: () => Promise.resolve({ id: 'server', ok: true, data: 'ok' }),
+        });
+        await sendCommand('exec', { code: '1 + 1', windowMode: 'background' });
+        const body = JSON.parse(String(vi.mocked(fetch).mock.calls[0][1]?.body));
+        expect(body.windowMode).toBe('background');
+    });
     it('sendCommand retries with a new id when daemon reports a duplicate pending id', async () => {
         vi.spyOn(Date, 'now').mockReturnValue(1_763_000_000_123);
         const fetchMock = vi.mocked(fetch);

package/dist/src/browser/network-cache.d.ts

@@ -6,7 +6,7 @@
  * stable references to request bodies after running other commands,
  * so every `browser network` call snapshots its results to disk.
  *
- * Layout: <cacheDir>/browser-network/<workspace>.json
+ * Layout: <cacheDir>/browser-network/<session>.json
  * Entries expire after DEFAULT_TTL_MS (24h).
  */
 export declare const DEFAULT_TTL_MS: number;
@@ -29,12 +29,12 @@ export interface CachedNetworkEntry {
 }
 export interface NetworkCacheFile {
     version: 1;
-    workspace: string;
+    session: string;
     savedAt: string;
     entries: CachedNetworkEntry[];
 }
-export declare function getCachePath(workspace: string, baseDir?: string): string;
-export declare function saveNetworkCache(workspace: string, entries: CachedNetworkEntry[], baseDir?: string): void;
+export declare function getCachePath(session: string, baseDir?: string): string;
+export declare function saveNetworkCache(session: string, entries: CachedNetworkEntry[], baseDir?: string): void;
 export interface LoadOptions {
     baseDir?: string;
     ttlMs?: number;
@@ -45,5 +45,5 @@ export interface LoadResult {
     file?: NetworkCacheFile;
     ageMs?: number;
 }
-export declare function loadNetworkCache(workspace: string, opts?: LoadOptions): LoadResult;
+export declare function loadNetworkCache(session: string, opts?: LoadOptions): LoadResult;
 export declare function findEntry(file: NetworkCacheFile, key: string): CachedNetworkEntry | null;

package/dist/src/browser/network-cache.js

@@ -6,7 +6,7 @@
  * stable references to request bodies after running other commands,
  * so every `browser network` call snapshots its results to disk.
  *
- * Layout: <cacheDir>/browser-network/<workspace>.json
+ * Layout: <cacheDir>/browser-network/<session>.json
  * Entries expire after DEFAULT_TTL_MS (24h).
  */
 import * as fs from 'node:fs';
@@ -16,23 +16,23 @@ export const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 function getDefaultCacheDir() {
     return process.env.OPENCLI_CACHE_DIR || path.join(os.homedir(), '.opencli', 'cache');
 }
-export function getCachePath(workspace, baseDir = getDefaultCacheDir()) {
-    const safe = workspace.replace(/[^a-zA-Z0-9_-]+/g, '_');
+export function getCachePath(session, baseDir = getDefaultCacheDir()) {
+    const safe = session.replace(/[^a-zA-Z0-9_-]+/g, '_');
     return path.join(baseDir, 'browser-network', `${safe}.json`);
 }
-export function saveNetworkCache(workspace, entries, baseDir) {
-    const target = getCachePath(workspace, baseDir);
+export function saveNetworkCache(session, entries, baseDir) {
+    const target = getCachePath(session, baseDir);
     fs.mkdirSync(path.dirname(target), { recursive: true });
     const payload = {
         version: 1,
-        workspace,
+        session,
         savedAt: new Date().toISOString(),
         entries,
     };
     fs.writeFileSync(target, JSON.stringify(payload), 'utf-8');
 }
-export function loadNetworkCache(workspace, opts = {}) {
-    const target = getCachePath(workspace, opts.baseDir);
+export function loadNetworkCache(session, opts = {}) {
+    const target = getCachePath(session, opts.baseDir);
     let raw;
     try {
         raw = fs.readFileSync(target, 'utf-8');

package/dist/src/browser/network-cache.test.js

@@ -14,9 +14,9 @@ describe('network-cache', () => {
     afterEach(() => {
         fs.rmSync(baseDir, { recursive: true, force: true });
     });
-    it('sanitizes workspace names into safe filenames', () => {
-        const p = getCachePath('browser:default', baseDir);
-        expect(path.basename(p)).toBe('browser_default.json');
+    it('sanitizes session names into safe filenames', () => {
+        const p = getCachePath('twitter/agent 1', baseDir);
+        expect(path.basename(p)).toBe('twitter_agent_1.json');
     });
     it('round-trips entries through save + load', () => {
         saveNetworkCache('ws', [makeEntry('UserTweets'), makeEntry('UserByScreenName')], baseDir);
@@ -49,7 +49,7 @@ describe('network-cache', () => {
     });
     it('findEntry returns matching entry or null', () => {
         const file = {
-            version: 1, workspace: 'ws', savedAt: new Date().toISOString(),
+            version: 1, session: 'ws', savedAt: new Date().toISOString(),
             entries: [makeEntry('A'), makeEntry('B')],
         };
         expect(findEntry(file, 'B')?.key).toBe('B');

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

@@ -14,22 +14,24 @@ import { BasePage } from './base-page.js';
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export declare class Page extends BasePage {
-    private readonly workspace;
+    private readonly session;
     readonly contextId?: string | undefined;
+    private readonly windowMode?;
+    private readonly surface;
+    private readonly siteSession?;
     private readonly _idleTimeout;
-    constructor(workspace?: string, idleTimeout?: number, contextId?: string | undefined);
+    constructor(session: string, idleTimeout?: number, contextId?: string | undefined, windowMode?: "foreground" | "background" | undefined, surface?: 'browser' | 'adapter', siteSession?: "ephemeral" | "persistent" | undefined);
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
     private _page;
     private _networkCaptureUnsupported;
     private _networkCaptureWarned;
-    /** Helper: spread workspace into command params */
-    private _wsOpt;
-    /** Helper: spread workspace + page identity into command params */
+    /** Helper: spread session into command params */
+    private _sessionOpts;
+    /** Helper: spread session + page identity into command params */
     private _cmdOpts;
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
-        allowBoundNavigation?: boolean;
     }): Promise<void>;
     /** Get the active page identity (targetId) */
     getActivePage(): string | undefined;
@@ -41,7 +43,7 @@ export declare class Page extends BasePage {
         domain?: string;
         url?: string;
     }): Promise<BrowserCookie[]>;
-    /** Release the current automation tab lease in the extension */
+    /** Release the current browser session lease in the extension */
     closeWindow(): Promise<void>;
     tabs(): Promise<unknown[]>;
     newTab(url?: string): Promise<string | undefined>;

package/dist/src/browser/page.js

@@ -26,41 +26,52 @@ function isUnsupportedNetworkCaptureError(err) {
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export class Page extends BasePage {
-    workspace;
+    session;
     contextId;
+    windowMode;
+    surface;
+    siteSession;
     _idleTimeout;
-    constructor(workspace = 'default', idleTimeout, contextId) {
+    constructor(session, idleTimeout, contextId, windowMode, surface = 'browser', siteSession) {
         super();
-        this.workspace = workspace;
+        this.session = session;
         this.contextId = contextId;
+        this.windowMode = windowMode;
+        this.surface = surface;
+        this.siteSession = siteSession;
         this._idleTimeout = idleTimeout;
     }
     /** Active page identity (targetId), set after navigate and used in all subsequent commands */
     _page;
     _networkCaptureUnsupported = false;
     _networkCaptureWarned = false;
-    /** Helper: spread workspace into command params */
-    _wsOpt() {
+    /** Helper: spread session into command params */
+    _sessionOpts() {
         return {
-            workspace: this.workspace,
+            session: this.session,
+            surface: this.surface,
             ...(this.contextId && { contextId: this.contextId }),
             ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
+            ...(this.windowMode && { windowMode: this.windowMode }),
+            ...(this.siteSession && { siteSession: this.siteSession }),
         };
     }
-    /** Helper: spread workspace + page identity into command params */
+    /** Helper: spread session + page identity into command params */
     _cmdOpts() {
         return {
-            workspace: this.workspace,
+            session: this.session,
+            surface: this.surface,
             ...(this.contextId && { contextId: this.contextId }),
             ...(this._page !== undefined && { page: this._page }),
             ...(this._idleTimeout != null && { idleTimeout: this._idleTimeout }),
+            ...(this.windowMode && { windowMode: this.windowMode }),
+            ...(this.siteSession && { siteSession: this.siteSession }),
         };
     }
     async goto(url, options) {
         const result = await sendCommandFull('navigate', {
             url,
             ...this._cmdOpts(),
-            ...(options?.allowBoundNavigation === true && { allowBoundNavigation: true }),
         });
         // Remember the page identity (targetId) for subsequent calls
         if (result.page) {
@@ -140,13 +151,13 @@ export class Page extends BasePage {
         }
     }
     async getCookies(opts = {}) {
-        const result = await sendCommand('cookies', { ...this._wsOpt(), ...opts });
+        const result = await sendCommand('cookies', { ...this._sessionOpts(), ...opts });
         return Array.isArray(result) ? result : [];
     }
-    /** Release the current automation tab lease in the extension */
+    /** Release the current browser session lease in the extension */
     async closeWindow() {
         try {
-            await sendCommand('close-window', { ...this._wsOpt() });
+            await sendCommand('close-window', { ...this._sessionOpts() });
         }
         catch {
             // Window may already be closed or daemon may be down
@@ -159,20 +170,20 @@ export class Page extends BasePage {
         }
     }
     async tabs() {
-        const result = await sendCommand('tabs', { op: 'list', ...this._wsOpt() });
+        const result = await sendCommand('tabs', { op: 'list', ...this._sessionOpts() });
         return Array.isArray(result) ? result : [];
     }
     async newTab(url) {
         const result = await sendCommandFull('tabs', {
             op: 'new',
             ...(url !== undefined && { url }),
-            ...this._wsOpt(),
+            ...this._sessionOpts(),
         });
         this._lastUrl = null;
         return result.page;
     }
     async closeTab(target) {
-        const params = { op: 'close', ...this._wsOpt() };
+        const params = { op: 'close', ...this._sessionOpts() };
         if (typeof target === 'number')
             params.index = target;
         else if (typeof target === 'string')
@@ -190,7 +201,7 @@ export class Page extends BasePage {
         const result = await sendCommandFull('tabs', {
             op: 'select',
             ...(typeof target === 'number' ? { index: target } : { page: target }),
-            ...this._wsOpt(),
+            ...this._sessionOpts(),
         });
         if (result.page)
             this._page = result.page;