@jackwener/opencli 1.5.1 → 1.5.3

package/dist/clis/twitter/like.js

@@ -15,7 +15,7 @@ cli({
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter like');
         await page.goto(kwargs.url);
-        await page.wait(5); // Wait for tweet to load completely
+        await page.wait({ selector: '[data-testid="primaryColumn"]' }); // Wait for tweet to load completely
         const result = await page.evaluate(`(async () => {
         try {
             // Poll for the tweet to render

package/dist/clis/twitter/notifications.js

@@ -22,7 +22,7 @@ cli({
         window.history.pushState({}, '', '/notifications');
         window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
     }`);
-        await page.wait(5);
+        await page.waitForCapture(5);
         // Verify SPA navigation succeeded
         const currentUrl = await page.evaluate('() => window.location.pathname');
         if (currentUrl !== '/notifications') {

package/dist/clis/twitter/profile.js

@@ -18,7 +18,7 @@ cli({
         // If no username, detect the logged-in user
         if (!username) {
             await page.goto('https://x.com/home');
-            await page.wait(5);
+            await page.wait({ selector: '[data-testid="primaryColumn"]' });
             const href = await page.evaluate(`() => {
         const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
         return link ? link.getAttribute('href') : null;

package/dist/clis/twitter/reply-dm.js

@@ -24,7 +24,7 @@ cli({
         let sentCount = 0;
         // Step 1: Navigate to messages to get conversation list
         await page.goto('https://x.com/messages');
-        await page.wait(5);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
         // Step 2: Collect conversations with scroll-to-load
         const needed = maxSend + 10; // extra buffer for skips
         const convList = await page.evaluate(`(async () => {

package/dist/clis/twitter/reply.js

@@ -17,7 +17,7 @@ cli({
             throw new CommandExecutionError('Browser session required for twitter reply');
         // 1. Navigate to the tweet page
         await page.goto(kwargs.url);
-        await page.wait(5); // Wait for the react application to hydrate
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
         // 2. Automate typing the reply and clicking reply
         const result = await page.evaluate(`(async () => {
         try {

package/dist/clis/twitter/search.js

@@ -17,7 +17,7 @@ async function navigateToSearch(page, query, filter) {
         window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
       })()
     `);
-        await page.wait(5);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
         lastPath = String(await page.evaluate('() => window.location.pathname') || '');
         if (lastPath.startsWith('/search')) {
             return;

package/dist/clis/twitter/unblock.js

@@ -16,7 +16,7 @@ cli({
             throw new CommandExecutionError('Browser session required for twitter unblock');
         const username = kwargs.username.replace(/^@/, '');
         await page.goto(`https://x.com/${username}`);
-        await page.wait(5);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
         const result = await page.evaluate(`(async () => {
         try {
             let attempts = 0;

package/dist/clis/twitter/unbookmark.js

@@ -15,7 +15,7 @@ cli({
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter unbookmark');
         await page.goto(kwargs.url);
-        await page.wait(5);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
         const result = await page.evaluate(`(async () => {
         try {
             let attempts = 0;

package/dist/clis/twitter/unfollow.js

@@ -16,7 +16,7 @@ cli({
             throw new CommandExecutionError('Browser session required for twitter unfollow');
         const username = kwargs.username.replace(/^@/, '');
         await page.goto(`https://x.com/${username}`);
-        await page.wait(5);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
         const result = await page.evaluate(`(async () => {
         try {
             let attempts = 0;

package/dist/clis/v2ex/hot.yaml

@@ -3,7 +3,7 @@ name: hot
 description: V2EX 热门话题
 domain: www.v2ex.com
 strategy: public
-browser: true
+browser: false
 
 args:
   limit:
@@ -12,22 +12,8 @@ args:
     description: Number of topics
 
 pipeline:
-  - navigate: https://www.v2ex.com/
-
-  - evaluate: |
-      (async () => {
-        const response = await fetch('/api/topics/hot.json', {
-          credentials: 'include',
-          headers: {
-            accept: 'application/json, text/plain, */*',
-            'x-requested-with': 'XMLHttpRequest',
-          },
-        });
-        if (!response.ok) {
-          throw new Error(`V2EX hot API request failed: ${response.status}`);
-        }
-        return await response.json();
-      })()
+  - fetch:
+      url: https://www.v2ex.com/api/topics/hot.json
 
   - map:
       rank: ${{ index + 1 }}

package/dist/clis/weread/shelf.js

@@ -1,5 +1,120 @@
 import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
 import { fetchPrivateApi } from './utils.js';
+const WEREAD_DOMAIN = 'weread.qq.com';
+const WEREAD_SHELF_URL = `https://${WEREAD_DOMAIN}/web/shelf`;
+function normalizeShelfLimit(limit) {
+    if (!Number.isFinite(limit))
+        return 0;
+    return Math.max(0, Math.trunc(limit));
+}
+function normalizePrivateApiRows(data, limit) {
+    const books = data?.books ?? [];
+    return books.slice(0, limit).map((item) => ({
+        title: item.bookInfo?.title ?? item.title ?? '',
+        author: item.bookInfo?.author ?? item.author ?? '',
+        // TODO: readingProgress field name from community docs, verify with real API response
+        progress: item.readingProgress != null ? `${item.readingProgress}%` : '-',
+        bookId: item.bookId ?? item.bookInfo?.bookId ?? '',
+    }));
+}
+function normalizeWebShelfRows(snapshot, limit) {
+    if (limit <= 0)
+        return [];
+    const bookById = new Map();
+    for (const book of snapshot.rawBooks) {
+        const bookId = String(book?.bookId || '').trim();
+        if (!bookId)
+            continue;
+        bookById.set(bookId, book);
+    }
+    const orderedBookIds = snapshot.shelfIndexes
+        .filter((entry) => String(entry?.role || 'book') === 'book')
+        .sort((left, right) => Number(left?.idx ?? Number.MAX_SAFE_INTEGER) - Number(right?.idx ?? Number.MAX_SAFE_INTEGER))
+        .map((entry) => String(entry?.bookId || '').trim())
+        .filter(Boolean);
+    const fallbackOrder = snapshot.rawBooks
+        .map((book) => String(book?.bookId || '').trim())
+        .filter(Boolean);
+    const orderedUniqueBookIds = Array.from(new Set([
+        ...orderedBookIds,
+        ...fallbackOrder,
+    ]));
+    return orderedUniqueBookIds
+        .map((bookId) => {
+        const book = bookById.get(bookId);
+        if (!book)
+            return null;
+        return {
+            title: String(book.title || '').trim(),
+            author: String(book.author || '').trim(),
+            progress: '-',
+            bookId,
+        };
+    })
+        .filter((item) => Boolean(item && (item.title || item.bookId)))
+        .slice(0, limit);
+}
+/**
+ * Read the structured shelf cache from the web shelf page.
+ * The page hydrates localStorage with raw book data plus shelf ordering.
+ */
+async function loadWebShelfSnapshot(page) {
+    await page.goto(WEREAD_SHELF_URL);
+    const cookies = await page.getCookies({ domain: WEREAD_DOMAIN });
+    const currentVid = String(cookies.find((cookie) => cookie.name === 'wr_vid')?.value || '').trim();
+    if (!currentVid) {
+        return { cacheFound: false, rawBooks: [], shelfIndexes: [] };
+    }
+    const rawBooksKey = `shelf:rawBooks:${currentVid}`;
+    const shelfIndexesKey = `shelf:shelfIndexes:${currentVid}`;
+    const result = await page.evaluate(`
+    (() => new Promise((resolve) => {
+      const deadline = Date.now() + 5000;
+      const rawBooksKey = ${JSON.stringify(rawBooksKey)};
+      const shelfIndexesKey = ${JSON.stringify(shelfIndexesKey)};
+
+      const readJson = (raw) => {
+        if (typeof raw !== 'string') return null;
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return null;
+        }
+      };
+
+      const poll = () => {
+        const rawBooksRaw = localStorage.getItem(rawBooksKey);
+        const shelfIndexesRaw = localStorage.getItem(shelfIndexesKey);
+        const rawBooks = readJson(rawBooksRaw);
+        const shelfIndexes = readJson(shelfIndexesRaw);
+        const cacheFound = Array.isArray(rawBooks);
+
+        if (cacheFound || Date.now() >= deadline) {
+          resolve({
+            cacheFound,
+            rawBooks: Array.isArray(rawBooks) ? rawBooks : [],
+            shelfIndexes: Array.isArray(shelfIndexes) ? shelfIndexes : [],
+          });
+          return;
+        }
+
+        setTimeout(poll, 100);
+      };
+
+      poll();
+    }))
+  `);
+    if (!result || typeof result !== 'object') {
+        return { cacheFound: false, rawBooks: [], shelfIndexes: [] };
+    }
+    const snapshot = result;
+    return {
+        cacheFound: snapshot.cacheFound === true,
+        rawBooks: Array.isArray(snapshot.rawBooks) ? snapshot.rawBooks : [],
+        shelfIndexes: Array.isArray(snapshot.shelfIndexes) ? snapshot.shelfIndexes : [],
+    };
+}
 cli({
     site: 'weread',
     name: 'shelf',
@@ -11,14 +126,22 @@ cli({
     ],
     columns: ['title', 'author', 'progress', 'bookId'],
     func: async (page, args) => {
-        const data = await fetchPrivateApi(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
-        const books = data?.books ?? [];
-        return books.slice(0, Number(args.limit)).map((item) => ({
-            title: item.bookInfo?.title ?? item.title ?? '',
-            author: item.bookInfo?.author ?? item.author ?? '',
-            // TODO: readingProgress field name from community docs, verify with real API response
-            progress: item.readingProgress != null ? `${item.readingProgress}%` : '-',
-            bookId: item.bookId ?? item.bookInfo?.bookId ?? '',
-        }));
+        const limit = normalizeShelfLimit(Number(args.limit));
+        if (limit <= 0)
+            return [];
+        try {
+            const data = await fetchPrivateApi(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
+            return normalizePrivateApiRows(data, limit);
+        }
+        catch (error) {
+            if (!(error instanceof CliError) || error.code !== 'AUTH_REQUIRED') {
+                throw error;
+            }
+            const snapshot = await loadWebShelfSnapshot(page);
+            if (!snapshot.cacheFound) {
+                throw error;
+            }
+            return normalizeWebShelfRows(snapshot, limit);
+        }
     },
 });

package/dist/clis/weread/utils.js

@@ -9,9 +9,13 @@ import { CliError } from '../../errors.js';
 const WEB_API = 'https://weread.qq.com/web';
 const API = 'https://i.weread.qq.com';
 const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+const WEREAD_AUTH_ERRCODES = new Set([-2010, -2012]);
 function buildCookieHeader(cookies) {
     return cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join('; ');
 }
+function isAuthErrorResponse(resp, data) {
+    return resp.status === 401 || WEREAD_AUTH_ERRCODES.has(Number(data?.errcode));
+}
 /**
  * Fetch a public WeRead web endpoint (Node.js direct fetch).
  * Used by search and ranking commands (browser: false).
@@ -69,7 +73,7 @@ export async function fetchPrivateApi(page, path, params) {
     catch {
         throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
     }
-    if (resp.status === 401 || data?.errcode === -2010) {
+    if (isAuthErrorResponse(resp, data)) {
         throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
     }
     if (!resp.ok) {

package/dist/clis/xiaohongshu/comments.test.js

@@ -24,6 +24,7 @@ function createPageMock(evaluateResult) {
         getInterceptedRequests: vi.fn().mockResolvedValue([]),
         getCookies: vi.fn().mockResolvedValue([]),
         screenshot: vi.fn().mockResolvedValue(''),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
     };
 }
 describe('xiaohongshu comments', () => {

package/dist/clis/xiaohongshu/creator-note-detail.test.js

@@ -30,6 +30,7 @@ function createPageMock(evaluateResult) {
         getInterceptedRequests: vi.fn().mockResolvedValue([]),
         getCookies: vi.fn().mockResolvedValue([]),
         screenshot: vi.fn().mockResolvedValue(''),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
     };
 }
 describe('xiaohongshu creator-note-detail', () => {

package/dist/clis/xiaohongshu/creator-notes.test.js

@@ -33,6 +33,7 @@ function createPageMock(evaluateResult, interceptedRequests = []) {
         getInterceptedRequests,
         getCookies: vi.fn().mockResolvedValue([]),
         screenshot: vi.fn().mockResolvedValue(''),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
     };
 }
 describe('xiaohongshu creator-notes', () => {

package/dist/clis/xiaohongshu/publish.test.js

@@ -31,6 +31,7 @@ function createPageMock(evaluateResults) {
         getInterceptedRequests: vi.fn().mockResolvedValue([]),
         getCookies: vi.fn().mockResolvedValue([]),
         screenshot: vi.fn().mockResolvedValue(''),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
     };
 }
 describe('xiaohongshu publish', () => {

package/dist/clis/xiaohongshu/search.test.js

@@ -28,6 +28,7 @@ function createPageMock(evaluateResults) {
         getInterceptedRequests: vi.fn().mockResolvedValue([]),
         getCookies: vi.fn().mockResolvedValue([]),
         screenshot: vi.fn().mockResolvedValue(''),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
     };
 }
 describe('xiaohongshu search', () => {

package/dist/daemon.js

@@ -175,6 +175,7 @@ const wss = new WebSocketServer({
 wss.on('connection', (ws) => {
     console.error('[daemon] Extension connected');
     extensionWs = ws;
+    extensionVersion = null; // cleared until hello message arrives
     // ── Heartbeat: ping every 15s, close if 2 pongs missed ──
     let missedPongs = 0;
     const heartbeatInterval = setInterval(() => {

package/dist/doctor.js

@@ -65,9 +65,13 @@ export async function runBrowserDoctor(opts = {}) {
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
-    if (status.extensionVersion && opts.cliVersion && status.extensionVersion !== opts.cliVersion) {
-        issues.push(`Extension version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
-            '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
+    if (status.extensionVersion && opts.cliVersion) {
+        const extMajor = status.extensionVersion.split('.')[0];
+        const cliMajor = opts.cliVersion.split('.')[0];
+        if (extMajor !== cliMajor) {
+            issues.push(`Extension major version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
+                '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
+        }
     }
     return {
         cliVersion: opts.cliVersion,

package/dist/download/index.js

@@ -4,14 +4,13 @@
 import { spawn } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as https from 'node:https';
-import * as http from 'node:http';
 import * as os from 'node:os';
-import { Transform } from 'node:stream';
+import { Readable, Transform } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { URL } from 'node:url';
 import { isBinaryInstalled } from '../external.js';
 import { getErrorMessage } from '../errors.js';
+import { fetchWithNodeNetwork } from '../node-network.js';
 /** Check if yt-dlp is available in PATH. */
 export function checkYtdlp() {
     return isBinaryInstalled('yt-dlp');
@@ -61,8 +60,6 @@ export function requiresYtdlp(url) {
 export async function httpDownload(url, destPath, options = {}, redirectCount = 0) {
     const { cookies, headers = {}, timeout = 30000, onProgress, maxRedirects = 10 } = options;
     return new Promise((resolve) => {
-        const parsedUrl = new URL(url);
-        const protocol = parsedUrl.protocol === 'https:' ? https : http;
         const requestHeaders = {
             'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
             ...headers,
@@ -86,30 +83,43 @@ export async function httpDownload(url, destPath, options = {}, redirectCount =
                 // Ignore cleanup errors so the original failure is preserved.
             }
         };
-        const request = protocol.get(url, { headers: requestHeaders, timeout }, (response) => {
-            void (async () => {
+        void (async () => {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout);
+            try {
+                const response = await fetchWithNodeNetwork(url, {
+                    headers: requestHeaders,
+                    signal: controller.signal,
+                    redirect: 'manual',
+                });
+                clearTimeout(timer);
                 // Handle redirects before creating any file handles.
-                if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-                    response.resume();
-                    if (redirectCount >= maxRedirects) {
-                        finish({ success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` });
+                if (response.status >= 300 && response.status < 400) {
+                    const location = response.headers.get('location');
+                    if (location) {
+                        if (redirectCount >= maxRedirects) {
+                            finish({ success: false, size: 0, error: `Too many redirects (> ${maxRedirects})` });
+                            return;
+                        }
+                        const redirectUrl = resolveRedirectUrl(url, location);
+                        const originalHost = new URL(url).hostname;
+                        const redirectHost = new URL(redirectUrl).hostname;
+                        const redirectOptions = originalHost === redirectHost
+                            ? options
+                            : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
+                        finish(await httpDownload(redirectUrl, destPath, redirectOptions, redirectCount + 1));
                         return;
                     }
-                    const redirectUrl = resolveRedirectUrl(url, response.headers.location);
-                    const originalHost = new URL(url).hostname;
-                    const redirectHost = new URL(redirectUrl).hostname;
-                    const redirectOptions = originalHost === redirectHost
-                        ? options
-                        : { ...options, cookies: undefined, headers: stripCookieHeaders(options.headers) };
-                    finish(await httpDownload(redirectUrl, destPath, redirectOptions, redirectCount + 1));
+                }
+                if (response.status !== 200) {
+                    finish({ success: false, size: 0, error: `HTTP ${response.status}` });
                     return;
                 }
-                if (response.statusCode !== 200) {
-                    response.resume();
-                    finish({ success: false, size: 0, error: `HTTP ${response.statusCode}` });
+                if (!response.body) {
+                    finish({ success: false, size: 0, error: 'Empty response body' });
                     return;
                 }
-                const totalSize = parseInt(response.headers['content-length'] || '0', 10);
+                const totalSize = parseInt(response.headers.get('content-length') || '0', 10);
                 let received = 0;
                 const progressStream = new Transform({
                     transform(chunk, _encoding, callback) {
@@ -121,7 +131,7 @@ export async function httpDownload(url, destPath, options = {}, redirectCount =
                 });
                 try {
                     await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
-                    await pipeline(response, progressStream, fs.createWriteStream(tempPath));
+                    await pipeline(Readable.fromWeb(response.body), progressStream, fs.createWriteStream(tempPath));
                     await fs.promises.rename(tempPath, destPath);
                     finish({ success: true, size: received });
                 }
@@ -129,17 +139,13 @@ export async function httpDownload(url, destPath, options = {}, redirectCount =
                     await cleanupTempFile();
                     finish({ success: false, size: 0, error: getErrorMessage(err) });
                 }
-            })();
-        });
-        request.on('error', (err) => {
-            void (async () => {
+            }
+            catch (err) {
+                clearTimeout(timer);
                 await cleanupTempFile();
-                finish({ success: false, size: 0, error: err.message });
-            })();
-        });
-        request.on('timeout', () => {
-            request.destroy(new Error('Timeout'));
-        });
+                finish({ success: false, size: 0, error: err instanceof Error ? err.message : String(err) });
+            }
+        })();
     });
 }
 export function resolveRedirectUrl(currentUrl, location) {

package/dist/download/index.test.js

@@ -2,11 +2,12 @@ import * as fs from 'node:fs';
 import * as http from 'node:http';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import { formatCookieHeader, httpDownload, resolveRedirectUrl } from './index.js';
 const servers = [];
 const tempDirs = [];
 afterEach(async () => {
+    vi.unstubAllEnvs();
     await Promise.all(servers.map((server) => new Promise((resolve, reject) => {
         server.close((err) => (err ? reject(err) : resolve()));
     })));
@@ -101,4 +102,17 @@ describe('download helpers', { retry: process.platform === 'win32' ? 2 : 0 }, ()
         expect(forwardedCookie).toBeUndefined();
         expect(fs.readFileSync(destPath, 'utf8')).toBe('ok');
     });
+    it('bypasses proxy settings for loopback downloads', async () => {
+        vi.stubEnv('HTTP_PROXY', 'http://127.0.0.1:9');
+        const baseUrl = await startServer((_req, res) => {
+            res.statusCode = 200;
+            res.end('ok');
+        });
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
+        const destPath = path.join(tempDir, 'loopback.txt');
+        const result = await httpDownload(`${baseUrl}/ok`, destPath);
+        expect(result).toEqual({ success: true, size: 2 });
+        expect(fs.readFileSync(destPath, 'utf8')).toBe('ok');
+    });
 });

package/dist/execution.js

@@ -17,8 +17,7 @@ import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
 import { checkDaemonStatus } from './browser/discover.js';
-import { PKG_VERSION } from './version.js';
-import chalk from 'chalk';
+import { log } from './logger.js';
 const _loadedModules = new Set();
 export function coerceAndValidateArgs(cmdArgs, kwargs) {
     const result = { ...kwargs };
@@ -161,10 +160,6 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                     '  2. chrome://extensions → Developer Mode → Load unpacked\n' +
                     '  Then run: opencli doctor');
             }
-            // ── Version mismatch: warn but don't block ──
-            if (status.extensionVersion && status.extensionVersion !== PKG_VERSION) {
-                process.stderr.write(chalk.yellow(`⚠  Extension v${status.extensionVersion} ≠ CLI v${PKG_VERSION} — consider updating the extension.\n`));
-            }
             ensureRequiredEnv(cmd);
             const BrowserFactory = getBrowserFactory();
             result = await browserSession(BrowserFactory, async (page) => {
@@ -173,7 +168,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                     const skip = await isAlreadyOnDomain(page, preNavUrl);
                     if (skip) {
                         if (debug)
-                            console.error(`[pre-nav] Already on target domain, skipping navigation`);
+                            log.debug('[pre-nav] Already on target domain, skipping navigation');
                     }
                     else {
                         try {
@@ -183,7 +178,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                         }
                         catch (err) {
                             if (debug)
-                                console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+                                log.debug(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
                         }
                     }
                 }

package/dist/extension-manifest-regression.test.d.ts

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

package/dist/extension-manifest-regression.test.js

@@ -0,0 +1,12 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { describe, expect, it } from 'vitest';
+describe('extension manifest regression', () => {
+    it('keeps host permissions required by chrome.cookies.getAll', async () => {
+        const manifestPath = path.resolve(process.cwd(), 'extension', 'manifest.json');
+        const raw = await fs.readFile(manifestPath, 'utf8');
+        const manifest = JSON.parse(raw);
+        expect(manifest.permissions).toContain('cookies');
+        expect(manifest.host_permissions).toContain('<all_urls>');
+    });
+});

package/dist/main.js

@@ -19,7 +19,9 @@ import { discoverClis, discoverPlugins } from './discovery.js';
 import { getCompletions } from './completion.js';
 import { runCli } from './cli.js';
 import { emitHook } from './hooks.js';
+import { installNodeNetwork } from './node-network.js';
 import { registerUpdateNoticeOnExit, checkForUpdateBackground } from './update-check.js';
+installNodeNetwork();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const BUILTIN_CLIS = path.resolve(__dirname, 'clis');

package/dist/node-network.d.ts

@@ -0,0 +1,10 @@
+import { type Dispatcher } from 'undici';
+export interface ProxyDecision {
+    mode: 'direct' | 'proxy';
+    proxyUrl?: string;
+}
+export declare function hasProxyEnv(env?: NodeJS.ProcessEnv): boolean;
+export declare function decideProxy(url: URL, env?: NodeJS.ProcessEnv): ProxyDecision;
+export declare function getDispatcherForUrl(url: URL, env?: NodeJS.ProcessEnv): Dispatcher;
+export declare function fetchWithNodeNetwork(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export declare function installNodeNetwork(): void;