@jackwener/opencli 1.7.8 → 1.7.10

package/clis/zlibrary/utils.js

@@ -0,0 +1,136 @@
+/**
+ * Z-Library adapter utilities.
+ */
+
+import { ArgumentError } from '@jackwener/opencli/errors';
+
+const ZLIBRARY_DOMAIN = 'z-library.im';
+const ZLIBRARY_ORIGIN = `https://${ZLIBRARY_DOMAIN}`;
+const ZLIBRARY_ALLOWED_HOSTS = new Set([
+  ZLIBRARY_DOMAIN,
+  `www.${ZLIBRARY_DOMAIN}`,
+]);
+
+export function normalizeZlibraryBookUrl(input) {
+  const raw = String(input || '').trim();
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new ArgumentError('Z-Library book URL must be a valid http(s) URL', `Example: ${ZLIBRARY_ORIGIN}/book/...`);
+  }
+  if (!['http:', 'https:'].includes(url.protocol) || !ZLIBRARY_ALLOWED_HOSTS.has(url.hostname)) {
+    throw new ArgumentError(
+      `Unsupported Z-Library URL host: ${url.hostname}`,
+      `Pass a book URL under ${ZLIBRARY_DOMAIN}, for example ${ZLIBRARY_ORIGIN}/book/...`,
+    );
+  }
+  return url.toString();
+}
+
+/**
+ * Build a Z-Library search URL.
+ * Z-Library uses /s/<url-encoded-query> for search.
+ */
+export function buildSearchUrl(query) {
+  const normalized = String(query || '').trim();
+  if (!normalized) {
+    throw new ArgumentError('zlibrary search query cannot be empty');
+  }
+  return `${ZLIBRARY_ORIGIN}/s/${encodeURIComponent(normalized)}`;
+}
+
+/**
+ * Extract book title from page context.
+ * Tries z-bookcard shadow DOM first, then falls back to page title.
+ */
+export async function extractBookTitle(page) {
+  const title = await page.evaluate(`
+      (() => {
+        const card = document.querySelector('z-bookcard');
+        if (card && card.shadowRoot) {
+          const el = card.shadowRoot.querySelector('[class*="title"], h1, a');
+          if (el) return el.textContent.trim().split('\\n')[0].trim();
+        }
+        return document.title.replace(/\\s*[-|].*$/, '').trim();
+      })()
+    `);
+  return String(title || '').trim();
+}
+
+/**
+ * Extract available download formats from book page.
+ * Clicks the three-dot menu to reveal download options.
+ * NOTE: Z-Library download links redirect through /dl/<hash> URLs.
+ * These require browser cookies and may not produce direct file downloads
+ * in OpenCLI's browser automation. For actual file downloading,
+ * consider using Playwright's download event handling instead.
+ */
+export async function extractFormats(page) {
+  // Click three-dot menu if present
+  await page.evaluate(`
+      (() => {
+        const btn = document.querySelector(
+          'button[aria-label*="more" i], [class*="dots" i], [class*="more" i]'
+        );
+        if (btn) btn.click();
+      })()
+    `);
+  // Wait for menu
+  await page.wait({ time: 3 });
+
+  const formats = await page.evaluate(`
+      JSON.stringify((() => {
+        const res = { pdf: '', epub: '' };
+        document.querySelectorAll('a[href]').forEach(a => {
+          const h = a.href || '';
+          const t = (a.textContent || '').toUpperCase();
+          if (h.includes('/dl/') && t.includes('PDF')) res.pdf = h;
+          if (h.includes('/dl/') && t.includes('EPUB')) res.epub = h;
+        });
+        return res;
+      })())
+    `);
+  return JSON.parse(formats);
+}
+
+/**
+ * Extract book cards from search results page.
+ *
+ * Z-Library renders search results as <z-bookcard> custom elements.
+ * Each card contains the book title, author, and a link to the book page.
+ * The link is inside a shadow DOM that can be queried with card.shadowRoot.
+ *
+ * This approach was validated on 2026-04-28 against z-library.im.
+ */
+export async function extractSearchResults(page, limit) {
+  const raw = await page.evaluate(`
+    JSON.stringify(
+      Array.from(document.querySelectorAll('z-bookcard'))
+        .slice(0, ${limit})
+        .map((card, index) => {
+          const text = card.textContent.trim();
+          const lines = text.split('\\n').map(l => l.trim()).filter(Boolean);
+          const title = lines[0] || '';
+          const author = lines[1] || '';
+          let url = '';
+          try {
+            if (card.shadowRoot) {
+              const link = card.shadowRoot.querySelector('a');
+              if (link) url = link.href || '';
+            }
+          } catch(e) {}
+          return { rank: index + 1, title, author, url };
+        })
+        .filter(item => item.url && item.title)
+    )
+  `);
+
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+export { ZLIBRARY_DOMAIN, ZLIBRARY_ORIGIN };

package/dist/src/adapter-source.d.ts

@@ -0,0 +1,11 @@
+import type { InternalCliCommand } from './registry.js';
+/**
+ * Resolve the editable source file path for an adapter.
+ *
+ * Priority:
+ * 1. cmd.source (set for FS-scanned JS and manifest lazy-loaded JS)
+ * 2. cmd._modulePath (set for manifest lazy-loaded JS)
+ *
+ * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
+ */
+export declare function resolveAdapterSourcePath(cmd: InternalCliCommand): string | undefined;

package/dist/src/adapter-source.js

@@ -0,0 +1,24 @@
+import * as fs from 'node:fs';
+/**
+ * Resolve the editable source file path for an adapter.
+ *
+ * Priority:
+ * 1. cmd.source (set for FS-scanned JS and manifest lazy-loaded JS)
+ * 2. cmd._modulePath (set for manifest lazy-loaded JS)
+ *
+ * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
+ */
+export function resolveAdapterSourcePath(cmd) {
+    const candidates = [];
+    if (cmd.source && !cmd.source.startsWith('manifest:')) {
+        candidates.push(cmd.source);
+    }
+    if (cmd._modulePath) {
+        candidates.push(cmd._modulePath);
+    }
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return candidates[0];
+}

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

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { resolveAdapterSourcePath } from './adapter-source.js';
+function makeCmd(overrides = {}) {
+    return {
+        site: 'test-site',
+        name: 'test-cmd',
+        description: 'test',
+        args: [],
+        ...overrides,
+    };
+}
+describe('resolveAdapterSourcePath', () => {
+    it('returns source when it is a real file path (not manifest:)', () => {
+        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.js' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.js');
+    });
+    it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
+        const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/clis/arxiv/search.js' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/pkg/clis/arxiv/search.js');
+    });
+    it('returns undefined when only manifest: pseudo-path and no _modulePath', () => {
+        const cmd = makeCmd({ source: 'manifest:test/cmd' });
+        expect(resolveAdapterSourcePath(cmd)).toBeUndefined();
+    });
+    it('returns _modulePath when it is the only path available', () => {
+        const cmd = makeCmd({ _modulePath: '/project/clis/site/cmd.js' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/project/clis/site/cmd.js');
+    });
+});

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

@@ -8,7 +8,7 @@
  * Subclasses implement the transport-specific methods: goto, evaluate,
  * getCookies, screenshot, tabs, etc.
  */
-import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import type { BrowserCookie, FetchJsonOptions, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
 import { type ResolveOptions, type TargetMatchLevel } from './target-resolver.js';
 export interface ResolveSuccess {
     matches_n: number;
@@ -26,6 +26,7 @@ export declare abstract class BasePage implements IPage {
     abstract goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
+        allowBoundNavigation?: boolean;
     }): Promise<void>;
     abstract evaluate(js: string): Promise<unknown>;
     /**
@@ -37,6 +38,7 @@ export declare abstract class BasePage implements IPage {
      *   page.evaluateWithArgs(`(async () => { return sym; })()`, { sym: userInput })
      */
     evaluateWithArgs(js: string, args: Record<string, unknown>): Promise<unknown>;
+    fetchJson(url: string, opts?: FetchJsonOptions): Promise<unknown>;
     abstract getCookies(opts?: {
         domain?: string;
         url?: string;

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

@@ -12,6 +12,8 @@ import { generateSnapshotJs, getFormStateJs } from './dom-snapshot.js';
 import { pressKeyJs, waitForTextJs, waitForCaptureJs, waitForSelectorJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
 import { resolveTargetJs, clickResolvedJs, typeResolvedJs, scrollResolvedJs, } from './target-resolver.js';
 import { TargetError } from './target-errors.js';
+import { CliError } from '../errors.js';
+import { formatSnapshot } from '../snapshotFormatter.js';
 /**
  * Execute `resolveTargetJs` once, throw structured `TargetError` on failure.
  * Single helper so click/typeText/scrollTo share one resolution pathway,
@@ -30,7 +32,10 @@ async function runResolve(page, ref, opts = {}) {
     }
     return { matches_n: resolution.matches_n, match_level: resolution.match_level };
 }
-import { formatSnapshot } from '../snapshotFormatter.js';
+function previewText(text) {
+    const preview = (text ?? '').replace(/\s+/g, ' ').trim().slice(0, 300);
+    return preview ? `Response preview: ${preview}` : undefined;
+}
 export class BasePage {
     _lastUrl = null;
     /** Cached previous snapshot hashes for incremental diff marking */
@@ -54,6 +59,76 @@ export class BasePage {
             .join('\n');
         return this.evaluate(`${declarations}\n${js}`);
     }
+    async fetchJson(url, opts = {}) {
+        const request = {
+            url,
+            method: opts.method ?? 'GET',
+            headers: opts.headers ?? {},
+            body: opts.body,
+            hasBody: opts.body !== undefined,
+            timeoutMs: opts.timeoutMs ?? 15_000,
+        };
+        const result = await this.evaluateWithArgs(`
+      (async () => {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), request.timeoutMs);
+        try {
+          const headers = { Accept: 'application/json', ...request.headers };
+          const init = {
+            method: request.method,
+            credentials: 'include',
+            headers,
+            signal: ctrl.signal,
+          };
+          if (request.hasBody) {
+            if (!Object.keys(headers).some((key) => key.toLowerCase() === 'content-type')) {
+              headers['Content-Type'] = 'application/json';
+            }
+            init.body = JSON.stringify(request.body);
+          }
+          const resp = await fetch(request.url, init);
+          const text = await resp.text();
+          return {
+            ok: resp.ok,
+            status: resp.status,
+            statusText: resp.statusText,
+            url: resp.url,
+            contentType: resp.headers.get('content-type') || '',
+            text,
+          };
+        } catch (error) {
+          return {
+            ok: false,
+            status: 0,
+            statusText: '',
+            url: request.url,
+            contentType: '',
+            text: '',
+            error: error instanceof Error ? error.message : String(error),
+          };
+        } finally {
+          clearTimeout(timer);
+        }
+      })()
+    `, { request });
+        const targetUrl = result.url || url;
+        if (result.error) {
+            throw new CliError('FETCH_ERROR', `Browser fetch failed for ${targetUrl}: ${result.error}`, 'Check that the page is reachable and the current browser profile has access.');
+        }
+        if (!result.ok) {
+            throw new CliError('FETCH_ERROR', `HTTP ${result.status ?? 0}${result.statusText ? ` ${result.statusText}` : ''} from ${targetUrl}`, previewText(result.text));
+        }
+        const text = result.text ?? '';
+        if (!text.trim())
+            return null;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const contentType = result.contentType ? ` (${result.contentType})` : '';
+            throw new CliError('FETCH_ERROR', `Expected JSON from ${targetUrl}${contentType}`, previewText(text));
+        }
+    }
     // ── Shared DOM helper implementations ──
     async click(ref, opts = {}) {
         // Phase 1: Resolve target with fingerprint verification

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

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

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

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { CliError } from '../errors.js';
+import { BasePage } from './base-page.js';
+class TestPage extends BasePage {
+    result;
+    args;
+    async goto() { }
+    async evaluate() { return null; }
+    async evaluateWithArgs(_js, args) {
+        this.args = args;
+        return this.result;
+    }
+    async getCookies() { return []; }
+    async screenshot() { return ''; }
+    async tabs() { return []; }
+    async selectTab() { }
+}
+describe('BasePage.fetchJson', () => {
+    it('passes a narrow browser-context JSON request and parses the response in Node', async () => {
+        const page = new TestPage();
+        page.result = {
+            ok: true,
+            status: 200,
+            url: 'https://api.example.com/items',
+            contentType: 'application/json',
+            text: '{"items":[1]}',
+        };
+        await expect(page.fetchJson('https://api.example.com/items', {
+            method: 'POST',
+            headers: { 'X-Test': '1' },
+            body: { q: 'opencli' },
+            timeoutMs: 1234,
+        })).resolves.toEqual({ items: [1] });
+        expect(page.args).toEqual({
+            request: {
+                url: 'https://api.example.com/items',
+                method: 'POST',
+                headers: { 'X-Test': '1' },
+                body: { q: 'opencli' },
+                hasBody: true,
+                timeoutMs: 1234,
+            },
+        });
+    });
+    it('throws a CliError for non-JSON responses', async () => {
+        const page = new TestPage();
+        page.result = {
+            ok: true,
+            status: 200,
+            url: 'https://api.example.com/items',
+            contentType: 'text/html',
+            text: '<html>blocked</html>',
+        };
+        const err = await page.fetchJson('https://api.example.com/items').catch((error) => error);
+        expect(err).toBeInstanceOf(CliError);
+        expect(err.code).toBe('FETCH_ERROR');
+        expect(err.message).toContain('Expected JSON');
+        expect(err.hint).toContain('blocked');
+    });
+    it('throws a CliError for browser fetch transport errors', async () => {
+        const page = new TestPage();
+        page.result = {
+            ok: false,
+            status: 0,
+            url: 'https://api.example.com/items',
+            text: '',
+            error: 'The operation was aborted.',
+        };
+        await expect(page.fetchJson('https://api.example.com/items')).rejects.toMatchObject({
+            code: 'FETCH_ERROR',
+            message: expect.stringContaining('The operation was aborted.'),
+        });
+    });
+});

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

@@ -16,11 +16,10 @@ export declare class BrowserBridge implements IBrowserFactory {
         timeout?: number;
         workspace?: string;
         idleTimeout?: number;
+        contextId?: string;
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;
-    /** Poll until daemon is fully stopped (port released). */
-    private _waitForDaemonStop;
     /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
     private _pollUntilReady;
 }

package/dist/src/browser/bridge.js

@@ -1,15 +1,13 @@
 /**
  * Browser session manager — auto-spawns daemon and provides IPage.
  */
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
 import { Page } from './page.js';
 import { getDaemonHealth, requestDaemonShutdown } from './daemon-client.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { BrowserConnectError } from '../errors.js';
 import { PKG_VERSION } from '../version.js';
+import { resolveProfileContextId } from './profile.js';
+import { resolveDaemonLaunchSpec, spawnDaemonProcess, waitForDaemonStop } from './daemon-lifecycle.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
@@ -32,8 +30,9 @@ export class BrowserBridge {
             throw new Error('Session is closed');
         this._state = 'connecting';
         try {
-            await this._ensureDaemon(opts.timeout);
-            this._page = new Page(opts.workspace, opts.idleTimeout);
+            const contextId = opts.contextId ?? resolveProfileContextId();
+            await this._ensureDaemon(opts.timeout, contextId);
+            this._page = new Page(opts.workspace, opts.idleTimeout, contextId);
             this._state = 'connected';
             return this._page;
         }
@@ -51,13 +50,21 @@ export class BrowserBridge {
         this._page = null;
         this._state = 'closed';
     }
-    async _ensureDaemon(timeoutSeconds) {
+    async _ensureDaemon(timeoutSeconds, contextId) {
         const effectiveSeconds = (timeoutSeconds && timeoutSeconds > 0) ? timeoutSeconds : Math.ceil(DAEMON_SPAWN_TIMEOUT / 1000);
         const timeoutMs = effectiveSeconds * 1000;
-        const health = await getDaemonHealth();
+        const health = await getDaemonHealth({ contextId });
         // Fast path: everything ready
         if (health.state === 'ready')
             return;
+        if (health.state === 'profile-required') {
+            throw new BrowserConnectError('Multiple Browser Bridge profiles are connected', 'Select one with --profile <name>, OPENCLI_PROFILE=<name>, or opencli profile use <name>.\n' +
+                'Run opencli profile list to see connected profiles.', 'profile-required');
+        }
+        if (health.state === 'profile-disconnected') {
+            const label = contextId ?? health.status.contextId ?? 'unknown';
+            throw new BrowserConnectError(`Browser profile "${label}" is not connected`, 'Open the matching Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 'profile-disconnected');
+        }
         // Daemon running but no extension
         if (health.state === 'no-extension') {
             // Detect stale daemon: version mismatch OR missing daemonVersion (pre-version daemon)
@@ -72,7 +79,7 @@ export class BrowserBridge {
                     process.stderr.write(`⚠️  Stale daemon detected (${reason}). Restarting...\n`);
                 }
                 const shutdownAccepted = await requestDaemonShutdown();
-                const portReleased = shutdownAccepted && await this._waitForDaemonStop(3000);
+                const portReleased = shutdownAccepted && await waitForDaemonStop(3000);
                 if (!portReleased) {
                     // Stale daemon replacement failed — don't blindly spawn on an occupied port
                     throw new BrowserConnectError('Stale daemon could not be replaced', `A stale daemon (${reason}) is running but did not shut down.\n` +
@@ -86,8 +93,17 @@ export class BrowserBridge {
                     process.stderr.write('⏳ Waiting for Chrome/Chromium extension to connect...\n');
                     process.stderr.write('   Make sure Chrome or Chromium is open and the OpenCLI extension is enabled.\n');
                 }
-                if (await this._pollUntilReady(timeoutMs))
+                if (await this._pollUntilReady(timeoutMs, contextId))
                     return;
+                const finalHealth = await getDaemonHealth({ contextId });
+                if (finalHealth.state === 'profile-required') {
+                    throw new BrowserConnectError('Multiple Browser Bridge profiles are connected', 'Select one with --profile <name>, OPENCLI_PROFILE=<name>, or opencli profile use <name>.\n' +
+                        'Run opencli profile list to see connected profiles.', 'profile-required');
+                }
+                if (finalHealth.state === 'profile-disconnected') {
+                    const label = contextId ?? finalHealth.status.contextId ?? 'unknown';
+                    throw new BrowserConnectError(`Browser profile "${label}" is not connected`, 'Open the matching Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 'profile-disconnected');
+                }
                 throw new BrowserConnectError('Browser Bridge extension not connected', 'Make sure Chrome/Chromium is open and the extension is enabled.\n' +
                     'If the extension is installed, try: opencli daemon stop && opencli doctor\n' +
                     'If not installed:\n' +
@@ -96,28 +112,22 @@ export class BrowserBridge {
             }
         }
         // No daemon — spawn one
-        const __dirname = path.dirname(fileURLToPath(import.meta.url));
-        const parentDir = path.resolve(__dirname, '..');
-        const daemonTs = path.join(parentDir, 'daemon.ts');
-        const daemonJs = path.join(parentDir, 'daemon.js');
-        const isTs = fs.existsSync(daemonTs);
-        const daemonPath = isTs ? daemonTs : daemonJs;
         if (process.env.OPENCLI_VERBOSE || process.stderr.isTTY) {
             process.stderr.write('⏳ Starting daemon...\n');
         }
-        const spawnArgs = isTs
-            ? [process.execPath, '--import', 'tsx/esm', daemonPath]
-            : [process.execPath, daemonPath];
-        this._daemonProc = spawn(spawnArgs[0], spawnArgs.slice(1), {
-            detached: true,
-            stdio: 'ignore',
-            env: { ...process.env },
-        });
-        this._daemonProc.unref();
+        this._daemonProc = spawnDaemonProcess();
         // Wait for daemon + extension
-        if (await this._pollUntilReady(timeoutMs))
+        if (await this._pollUntilReady(timeoutMs, contextId))
             return;
-        const finalHealth = await getDaemonHealth();
+        const finalHealth = await getDaemonHealth({ contextId });
+        if (finalHealth.state === 'profile-required') {
+            throw new BrowserConnectError('Multiple Browser Bridge profiles are connected', 'Select one with --profile <name>, OPENCLI_PROFILE=<name>, or opencli profile use <name>.\n' +
+                'Run opencli profile list to see connected profiles.', 'profile-required');
+        }
+        if (finalHealth.state === 'profile-disconnected') {
+            const label = contextId ?? finalHealth.status.contextId ?? 'unknown';
+            throw new BrowserConnectError(`Browser profile "${label}" is not connected`, 'Open the matching Chrome profile and make sure the OpenCLI extension is enabled, or choose another profile with opencli profile use <name>.', 'profile-disconnected');
+        }
         if (finalHealth.state === 'no-extension') {
             throw new BrowserConnectError('Browser Bridge extension not connected', 'Make sure Chrome/Chromium is open and the extension is enabled.\n' +
                 'If the extension is installed, try: opencli daemon stop && opencli doctor\n' +
@@ -125,25 +135,14 @@ export class BrowserBridge {
                 '  1. Download: https://github.com/jackwener/opencli/releases\n' +
                 '  2. Open chrome://extensions → Developer Mode → Load unpacked', 'extension-not-connected');
         }
-        throw new BrowserConnectError('Failed to start opencli daemon', `Try running manually:\n  node ${daemonPath}\nMake sure port ${DEFAULT_DAEMON_PORT} is available.`, 'daemon-not-running');
-    }
-    /** Poll until daemon is fully stopped (port released). */
-    async _waitForDaemonStop(timeoutMs) {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, 200));
-            const h = await getDaemonHealth();
-            if (h.state === 'stopped')
-                return true;
-        }
-        return false;
+        throw new BrowserConnectError('Failed to start opencli daemon', `Try running manually:\n  node ${resolveDaemonLaunchSpec().scriptPath}\nMake sure port ${DEFAULT_DAEMON_PORT} is available.`, 'daemon-not-running');
     }
     /** Poll getDaemonHealth() until state is 'ready' or deadline is reached. */
-    async _pollUntilReady(timeoutMs) {
+    async _pollUntilReady(timeoutMs, contextId) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             await new Promise(resolve => setTimeout(resolve, 200));
-            const h = await getDaemonHealth();
+            const h = await getDaemonHealth({ contextId });
             if (h.state === 'ready')
                 return true;
         }

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

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

package/dist/src/browser/cdp.js

@@ -229,7 +229,7 @@ class CDPPage extends BasePage {
                     const idx = this._networkEntries.push({
                         url: p.request.url,
                         method: p.request.method,
-                        timestamp: p.timestamp,
+                        timestamp: Date.now(),
                     }) - 1;
                     this._pendingRequests.set(p.requestId, idx);
                 }
@@ -290,7 +290,7 @@ class CDPPage extends BasePage {
             this.bridge.on('Runtime.consoleAPICalled', (params) => {
                 const p = params;
                 const text = (p.args || []).map(a => a.value !== undefined ? String(a.value) : (a.description || '')).join(' ');
-                this._consoleMessages.push({ type: p.type, text, timestamp: p.timestamp });
+                this._consoleMessages.push({ type: p.type, text, timestamp: Date.now() });
                 if (this._consoleMessages.length > 500)
                     this._consoleMessages.shift();
             });
@@ -298,7 +298,7 @@ class CDPPage extends BasePage {
             this.bridge.on('Runtime.exceptionThrown', (params) => {
                 const p = params;
                 const desc = p.exceptionDetails?.exception?.description || p.exceptionDetails?.text || 'Unknown exception';
-                this._consoleMessages.push({ type: 'error', text: desc, timestamp: p.timestamp });
+                this._consoleMessages.push({ type: 'error', text: desc, timestamp: Date.now() });
                 if (this._consoleMessages.length > 500)
                     this._consoleMessages.shift();
             });