@jackwener/opencli 1.7.16 → 1.7.18

package/clis/xiaohongshu/notifications.js

@@ -1,23 +1,11 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-cli({
-    site: 'xiaohongshu',
-    name: 'notifications',
-    access: 'read',
-    description: '小红书通知 (mentions/likes/connections)',
-    domain: 'www.xiaohongshu.com',
-    strategy: Strategy.INTERCEPT,
-    browser: true,
-    args: [
-        {
-            name: 'type',
-            default: 'mentions',
-            help: 'Notification type: mentions, likes, or connections',
-        },
-        { name: 'limit', type: 'int', default: 20, help: 'Number of notifications to return' },
-    ],
-    columns: ['rank', 'user', 'action', 'content', 'note', 'time'],
-    pipeline: [
-        { navigate: 'https://www.xiaohongshu.com/notification' },
+/**
+ * Build the notifications pipeline for the given web host. Exported so the
+ * rednote adapter can register the same pipeline against www.rednote.com.
+ */
+export function buildNotificationsPipeline(webHost) {
+    return [
+        { navigate: `https://${webHost}/notification` },
         { tap: {
                 store: 'notification',
                 action: 'getNotification',
@@ -35,5 +23,24 @@ cli({
                 time: '${{ item.time }}',
             } },
         { limit: '${{ args.limit | default(20) }}' },
+    ];
+}
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'notifications',
+    access: 'read',
+    description: '小红书通知 (mentions/likes/connections)',
+    domain: 'www.xiaohongshu.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        {
+            name: 'type',
+            default: 'mentions',
+            help: 'Notification type: mentions, likes, or connections',
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of notifications to return' },
     ],
+    columns: ['rank', 'user', 'action', 'content', 'note', 'time'],
+    pipeline: buildNotificationsPipeline('www.xiaohongshu.com'),
 });

package/clis/xiaohongshu/search.js

@@ -52,37 +52,19 @@ export function stripXhsAuthorDateSuffix(value) {
     const stripped = text.replace(/\s*(?:\d{1,2}天前|\d+小时前|\d+分钟前|\d+秒前|刚刚|昨天|前天|\d+周前|\d+个月前|\d{1,2}-\d{1,2}|\d{4}-\d{1,2}-\d{1,2})$/u, '').trim();
     return stripped || text;
 }
-cli({
-    site: 'xiaohongshu',
-    name: 'search',
-    access: 'read',
-    description: '搜索小红书笔记',
-    domain: 'www.xiaohongshu.com',
-    strategy: Strategy.COOKIE,
-    navigateBefore: false,
-    args: [
-        { name: 'query', required: true, positional: true, help: 'Search keyword' },
-        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
-    ],
-    columns: ['rank', 'title', 'author', 'likes', 'published_at', 'url'],
-    func: async (page, kwargs) => {
-        const keyword = encodeURIComponent(kwargs.query);
-        await page.goto(`https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
-        // Wait for search results to render (or login wall to appear).
-        // Uses MutationObserver to resolve as soon as content appears,
-        // instead of a fixed delay + blind retry.
-        const waitResult = await page.evaluate(WAIT_FOR_CONTENT_JS);
-        if (waitResult === 'login_wall') {
-            throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
-        }
-        // Scroll a couple of times to load more results
-        await page.autoScroll({ times: 2 });
-        const payload = await page.evaluate(`
+/**
+ * Build the search-result extraction IIFE. The web host is baked into the
+ * `normalizeUrl` fallback so relative `/explore/...` hrefs resolve to a full
+ * URL on the calling site. Exported so the rednote adapter can call it with
+ * `www.rednote.com` without duplicating the selector logic.
+ */
+export function buildSearchExtractJs(webHost) {
+    return `
       (() => {
         const normalizeUrl = (href) => {
           if (!href) return '';
           if (href.startsWith('http://') || href.startsWith('https://')) return href;
-          if (href.startsWith('/')) return 'https://www.xiaohongshu.com' + href;
+          if (href.startsWith('/')) return 'https://${webHost}' + href;
           return '';
         };
 
@@ -131,7 +113,34 @@ cli({
 
         return results;
       })()
-    `);
+    `;
+}
+export const command = cli({
+    site: 'xiaohongshu',
+    name: 'search',
+    access: 'read',
+    description: '搜索小红书笔记',
+    domain: 'www.xiaohongshu.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Search keyword' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+    ],
+    columns: ['rank', 'title', 'author', 'likes', 'published_at', 'url'],
+    func: async (page, kwargs) => {
+        const keyword = encodeURIComponent(kwargs.query);
+        await page.goto(`https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
+        // Wait for search results to render (or login wall to appear).
+        // Uses MutationObserver to resolve as soon as content appears,
+        // instead of a fixed delay + blind retry.
+        const waitResult = await page.evaluate(WAIT_FOR_CONTENT_JS);
+        if (waitResult === 'login_wall') {
+            throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
+        }
+        // Scroll a couple of times to load more results
+        await page.autoScroll({ times: 2 });
+        const payload = await page.evaluate(buildSearchExtractJs('www.xiaohongshu.com'));
         const data = Array.isArray(payload) ? payload : [];
         return data
             .filter((item) => item.title)

package/clis/xiaohongshu/user-helpers.js

@@ -27,12 +27,17 @@ export function flattenXhsNoteGroups(noteGroups) {
     }
     return notes;
 }
-export function buildXhsNoteUrl(userId, noteId, xsecToken) {
+/**
+ * Build a signed user-profile note URL on the given web host (defaults to
+ * `www.xiaohongshu.com`). The rednote adapter passes `'www.rednote.com'` so
+ * the same builder works for both sites.
+ */
+export function buildXhsNoteUrl(userId, noteId, xsecToken, webHost = 'www.xiaohongshu.com') {
     const cleanUserId = toCleanString(userId);
     const cleanNoteId = toCleanString(noteId);
     if (!cleanUserId || !cleanNoteId)
         return '';
-    const url = new URL(`https://www.xiaohongshu.com/user/profile/${cleanUserId}/${cleanNoteId}`);
+    const url = new URL(`https://${webHost}/user/profile/${cleanUserId}/${cleanNoteId}`);
     const cleanToken = toCleanString(xsecToken);
     if (cleanToken) {
         url.searchParams.set('xsec_token', cleanToken);
@@ -40,7 +45,11 @@ export function buildXhsNoteUrl(userId, noteId, xsecToken) {
     }
     return url.toString();
 }
-export function extractXhsUserNotes(snapshot, fallbackUserId) {
+/**
+ * Normalise a Pinia user-store snapshot into CLI rows. `webHost` is forwarded
+ * to `buildXhsNoteUrl` so the resulting URLs point at the calling site.
+ */
+export function extractXhsUserNotes(snapshot, fallbackUserId, webHost = 'www.xiaohongshu.com') {
     const notes = flattenXhsNoteGroups(snapshot.noteGroups);
     const rows = [];
     const seen = new Set();
@@ -62,7 +71,7 @@ export function extractXhsUserNotes(snapshot, fallbackUserId) {
             type: toCleanString(noteCard.type),
             likes,
             cover,
-            url: buildXhsNoteUrl(userId || fallbackUserId, noteId, xsecToken),
+            url: buildXhsNoteUrl(userId || fallbackUserId, noteId, xsecToken, webHost),
         });
     }
     return rows;

package/clis/xiaohongshu/user-helpers.test.js

@@ -20,6 +20,9 @@ describe('buildXhsNoteUrl', () => {
     it('includes xsec token when available', () => {
         expect(buildXhsNoteUrl('user123', 'note456', 'token789')).toBe('https://www.xiaohongshu.com/user/profile/user123/note456?xsec_token=token789&xsec_source=pc_user');
     });
+    it('emits a rednote URL when webHost is overridden', () => {
+        expect(buildXhsNoteUrl('user123', 'note456', 'token789', 'www.rednote.com')).toBe('https://www.rednote.com/user/profile/user123/note456?xsec_token=token789&xsec_source=pc_user');
+    });
 });
 describe('extractXhsUserNotes', () => {
     it('normalizes grouped note cards into CLI rows', () => {
@@ -96,4 +99,21 @@ describe('extractXhsUserNotes', () => {
         expect(rows).toHaveLength(1);
         expect(rows[0]?.title).toBe('keep me');
     });
+    it('emits rednote-hosted URLs when webHost is overridden', () => {
+        const rows = extractXhsUserNotes({
+            noteGroups: [
+                [
+                    {
+                        xsecToken: 'tok',
+                        noteCard: {
+                            noteId: 'note-red',
+                            displayTitle: 'rednote note',
+                            user: { userId: 'user-red' },
+                        },
+                    },
+                ],
+            ],
+        }, 'fallback-user', 'www.rednote.com');
+        expect(rows[0]?.url).toBe('https://www.rednote.com/user/profile/user-red/note-red?xsec_token=tok&xsec_source=pc_user');
+    });
 });

package/clis/xiaohongshu/user.js

@@ -1,7 +1,10 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { extractXhsUserNotes, normalizeXhsUserId } from './user-helpers.js';
-async function readUserSnapshot(page) {
-    return await page.evaluate(`
+/**
+ * Host-agnostic IIFE that snapshots the user profile's Pinia store. Exported
+ * so the rednote adapter can reuse it without copying the safeClone block.
+ */
+export const USER_SNAPSHOT_JS = `
     (() => {
       const safeClone = (value) => {
         try {
@@ -17,9 +20,11 @@ async function readUserSnapshot(page) {
         pageData: safeClone(userStore.userPageData?._value || userStore.userPageData || {}),
       };
     })()
-  `);
+  `;
+async function readUserSnapshot(page) {
+    return await page.evaluate(USER_SNAPSHOT_JS);
 }
-cli({
+export const command = cli({
     site: 'xiaohongshu',
     name: 'user',
     access: 'read',

package/clis/youtube/transcript.js

@@ -86,12 +86,37 @@ cli({
             console.error(`Warning: --lang "${captionData.requestedLang}" not found. Using "${captionData.language}" instead. Available: ${captionData.available.join(', ')}`);
         }
         // Step 2: Fetch caption XML and parse segments
+        // Ensure caption URL requests srv3 XML format — YouTube may return empty
+        // responses when no explicit format is specified.
+        const originalCaptionUrl = captionData.captionUrl;
+        let captionUrl = originalCaptionUrl;
+        if (!/[&?]fmt=/.test(originalCaptionUrl)) {
+            captionUrl = originalCaptionUrl + (originalCaptionUrl.includes('?') ? '&' : '?') + 'fmt=srv3';
+        }
         const segments = await page.evaluate(`
       (async () => {
-        const resp = await fetch(${JSON.stringify(captionData.captionUrl)});
-        const xml = await resp.text();
+        async function fetchCaptionXml(url) {
+          const resp = await fetch(url);
+          if (!resp.ok) return { error: 'Caption URL returned HTTP ' + resp.status };
+          return { xml: await resp.text() || '' };
+        }
+
+        const primaryUrl = ${JSON.stringify(captionUrl)};
+        const originalUrl = ${JSON.stringify(originalCaptionUrl)};
+        let result = await fetchCaptionXml(primaryUrl);
+        if (result.error) return result;
+
+        // If srv3 format returned an empty successful body, retry with the
+        // original URL. Do not hide HTTP/non-OK failures behind fallback.
+        if (!result.xml.length && originalUrl !== primaryUrl) {
+          result = await fetchCaptionXml(originalUrl);
+          if (result.error) {
+            return result;
+          }
+        }
+        const xml = result.xml;
 
-        if (!xml?.length) {
+        if (!xml.length) {
           return { error: 'Caption URL returned empty response' };
         }
 

package/clis/youtube/transcript.test.js

@@ -1,11 +1,37 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './transcript.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const transcriptSource = readFileSync(resolve(__dirname, 'transcript.js'), 'utf8');
 
+function createPageMock(captionUrl) {
+    const page = {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(),
+    };
+    page.evaluate
+        .mockResolvedValueOnce({
+        captionUrl,
+        language: 'en',
+        kind: 'manual',
+        available: ['en'],
+        requestedLang: null,
+        langMatched: false,
+        langPrefixMatched: false,
+    })
+        .mockResolvedValue([{ start: 1, end: 3, text: 'hello & world' }]);
+    return page;
+}
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+
 describe('youtube transcript source contract', () => {
     it('gets caption tracks from watch page bootstrap data, not Android InnerTube', () => {
         expect(transcriptSource).toContain("fetch('/watch?v='");
@@ -14,4 +40,67 @@ describe('youtube transcript source contract', () => {
         expect(transcriptSource).not.toContain('/youtubei/v1/player');
         expect(transcriptSource).not.toContain("clientName: 'ANDROID'");
     });
+
+    it('normalizes caption URL to request srv3 XML format', () => {
+        expect(transcriptSource).toContain('fmt=srv3');
+    });
+
+    it('checks HTTP status before reading caption response body', () => {
+        expect(transcriptSource).toContain('resp.ok');
+    });
+});
+
+describe('youtube transcript caption fetch', () => {
+    const command = getRegistry().get('youtube/transcript');
+
+    it('requests srv3 when the caption track URL has no explicit format', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
+
+        const rows = await command.func(page, { url: 'abc', mode: 'raw' });
+
+        expect(page.evaluate.mock.calls[1][0]).toContain('const primaryUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=srv3"');
+        expect(page.evaluate.mock.calls[1][0]).toContain('const originalUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en"');
+        expect(rows).toEqual([{ index: 1, start: '1.00s', end: '3.00s', text: 'hello & world' }]);
+    });
+
+    it('does not override an existing caption format', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt');
+
+        await command.func(page, { url: 'abc', mode: 'raw' });
+
+        expect(page.evaluate.mock.calls[1][0]).toContain('const primaryUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt"');
+        expect(page.evaluate.mock.calls[1][0]).toContain('const originalUrl = "https://www.youtube.com/api/timedtext?v=abc&lang=en&fmt=vtt"');
+    });
+
+    it('falls back to the original URL only after an empty successful srv3 response', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
+
+        await command.func(page, { url: 'abc', mode: 'raw' });
+
+        const script = page.evaluate.mock.calls[1][0];
+        expect(script).toContain('if (!result.xml.length && originalUrl !== primaryUrl)');
+        expect(script).toContain('result = await fetchCaptionXml(originalUrl)');
+        expect(script).toContain('if (result.error) {');
+    });
+
+    it('fails typed on caption HTTP errors instead of falling back silently', async () => {
+        const page = createPageMock('https://www.youtube.com/api/timedtext?v=abc&lang=en');
+        page.evaluate.mockReset();
+        page.evaluate
+            .mockResolvedValueOnce({
+            captionUrl: 'https://www.youtube.com/api/timedtext?v=abc&lang=en',
+            language: 'en',
+            kind: 'manual',
+            available: ['en'],
+            requestedLang: null,
+            langMatched: false,
+            langPrefixMatched: false,
+        })
+            .mockResolvedValueOnce({ error: 'Caption URL returned HTTP 503' });
+
+        await expect(command.func(page, { url: 'abc', mode: 'raw' })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('HTTP 503'),
+        });
+    });
 });

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,10 +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, opts.windowMode);
+            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,11 +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;
@@ -38,10 +38,8 @@ export interface DaemonCommand {
     cdpParams?: Record<string, unknown>;
     /** Window foreground/background policy for owned Browser Bridge containers. */
     windowMode?: 'foreground' | 'background';
-    /** Custom idle timeout in seconds for this workspace session. Overrides the default. */
+    /** 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

@@ -146,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/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');