@jackwener/opencli 1.5.1 → 1.5.3

package/src/clis/weread/shelf.ts

@@ -1,7 +1,159 @@
 import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
 import type { IPage } from '../../types.js';
 import { fetchPrivateApi } from './utils.js';
 
+const WEREAD_DOMAIN = 'weread.qq.com';
+const WEREAD_SHELF_URL = `https://${WEREAD_DOMAIN}/web/shelf`;
+
+interface ShelfRow {
+  title: string;
+  author: string;
+  progress: string;
+  bookId: string;
+}
+
+interface WebShelfRawBook {
+  bookId?: string;
+  title?: string;
+  author?: string;
+}
+
+interface WebShelfIndexEntry {
+  bookId?: string;
+  idx?: number;
+  role?: string;
+}
+
+interface WebShelfSnapshot {
+  cacheFound: boolean;
+  rawBooks: WebShelfRawBook[];
+  shelfIndexes: WebShelfIndexEntry[];
+}
+
+function normalizeShelfLimit(limit: number): number {
+  if (!Number.isFinite(limit)) return 0;
+  return Math.max(0, Math.trunc(limit));
+}
+
+function normalizePrivateApiRows(data: any, limit: number): ShelfRow[] {
+  const books: any[] = data?.books ?? [];
+  return books.slice(0, limit).map((item: any) => ({
+    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: WebShelfSnapshot, limit: number): ShelfRow[] {
+  if (limit <= 0) return [];
+
+  const bookById = new Map<string, WebShelfRawBook>();
+  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,
+      } satisfies ShelfRow;
+    })
+    .filter((item): item is ShelfRow => 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: IPage): Promise<WebShelfSnapshot> {
+  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 as Partial<WebShelfSnapshot>;
+  return {
+    cacheFound: snapshot.cacheFound === true,
+    rawBooks: Array.isArray(snapshot.rawBooks) ? snapshot.rawBooks : [],
+    shelfIndexes: Array.isArray(snapshot.shelfIndexes) ? snapshot.shelfIndexes : [],
+  };
+}
+
 cli({
   site: 'weread',
   name: 'shelf',
@@ -13,14 +165,22 @@ cli({
   ],
   columns: ['title', 'author', 'progress', 'bookId'],
   func: async (page: IPage, args) => {
-    const data = await fetchPrivateApi(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
-    const books: any[] = data?.books ?? [];
-    return books.slice(0, Number(args.limit)).map((item: any) => ({
-      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/src/clis/weread/utils.ts

@@ -12,11 +12,16 @@ import type { BrowserCookie, IPage } from '../../types.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: BrowserCookie[]): string {
   return cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join('; ');
 }
 
+function isAuthErrorResponse(resp: Response, data: any): boolean {
+  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).
@@ -78,7 +83,7 @@ export async function fetchPrivateApi(page: IPage, path: string, params?: Record
     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/src/clis/xiaohongshu/comments.test.ts

@@ -26,6 +26,7 @@ function createPageMock(evaluateResult: any): IPage {
     getInterceptedRequests: vi.fn().mockResolvedValue([]),
     getCookies: vi.fn().mockResolvedValue([]),
     screenshot: vi.fn().mockResolvedValue(''),
+    waitForCapture: vi.fn().mockResolvedValue(undefined),
   };
 }
 

package/src/clis/xiaohongshu/creator-note-detail.test.ts

@@ -33,6 +33,7 @@ function createPageMock(evaluateResult: any): IPage {
     getInterceptedRequests: vi.fn().mockResolvedValue([]),
     getCookies: vi.fn().mockResolvedValue([]),
     screenshot: vi.fn().mockResolvedValue(''),
+    waitForCapture: vi.fn().mockResolvedValue(undefined),
   };
 }
 

package/src/clis/xiaohongshu/creator-notes.test.ts

@@ -37,6 +37,7 @@ function createPageMock(evaluateResult: any, interceptedRequests: any[] = []): I
     getInterceptedRequests,
     getCookies: vi.fn().mockResolvedValue([]),
     screenshot: vi.fn().mockResolvedValue(''),
+    waitForCapture: vi.fn().mockResolvedValue(undefined),
   };
 }
 

package/src/clis/xiaohongshu/publish.test.ts

@@ -36,6 +36,7 @@ function createPageMock(evaluateResults: any[]): IPage {
     getInterceptedRequests: vi.fn().mockResolvedValue([]),
     getCookies: vi.fn().mockResolvedValue([]),
     screenshot: vi.fn().mockResolvedValue(''),
+    waitForCapture: vi.fn().mockResolvedValue(undefined),
   };
 }
 

package/src/clis/xiaohongshu/search.test.ts

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

package/src/daemon.ts

@@ -198,6 +198,7 @@ const wss = new WebSocketServer({
 wss.on('connection', (ws: WebSocket) => {
   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;

package/src/doctor.ts

@@ -95,11 +95,15 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
     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 {

package/src/download/index.test.ts

@@ -2,13 +2,14 @@ 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: http.Server[] = [];
 const tempDirs: string[] = [];
 
 afterEach(async () => {
+  vi.unstubAllEnvs();
   await Promise.all(servers.map((server) => new Promise<void>((resolve, reject) => {
     server.close((err) => (err ? reject(err) : resolve()));
   })));
@@ -114,4 +115,21 @@ 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/src/download/index.ts

@@ -5,16 +5,16 @@
 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 type { ReadableStream as WebReadableStream } from 'node:stream/web';
 import { pipeline } from 'node:stream/promises';
 import { URL } from 'node:url';
 import type { ProgressBar } from './progress.js';
 import { isBinaryInstalled } from '../external.js';
 import type { BrowserCookie } from '../types.js';
 import { getErrorMessage } from '../errors.js';
+import { fetchWithNodeNetwork } from '../node-network.js';
 
 export type { BrowserCookie } from '../types.js';
 
@@ -89,9 +89,6 @@ export async function httpDownload(
   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: Record<string, string> = {
       '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,
@@ -118,37 +115,52 @@ export async function httpDownload(
       }
     };
 
-    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) {
@@ -160,26 +172,23 @@ export async function httpDownload(
 
         try {
           await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
-          await pipeline(response, progressStream, fs.createWriteStream(tempPath));
+          await pipeline(
+            Readable.fromWeb(response.body as unknown as WebReadableStream),
+            progressStream,
+            fs.createWriteStream(tempPath),
+          );
           await fs.promises.rename(tempPath, destPath);
           finish({ success: true, size: received });
         } catch (err) {
           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) });
+      }
+    })();
   });
 }
 

package/src/execution.ts

@@ -19,8 +19,7 @@ import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook, type HookContext } 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<string>();
 
@@ -186,13 +185,6 @@ export async function executeCommand(
           '  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) => {
@@ -200,14 +192,14 @@ export async function executeCommand(
         if (preNavUrl) {
           const skip = await isAlreadyOnDomain(page, preNavUrl);
           if (skip) {
-            if (debug) console.error(`[pre-nav] Already on target domain, skipping navigation`);
+            if (debug) log.debug('[pre-nav] Already on target domain, skipping navigation');
           } else {
             try {
               // goto() already includes smart DOM-settle detection (waitForDomStable).
               // No additional fixed sleep needed.
               await page.goto(preNavUrl);
             } catch (err) {
-              if (debug) console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+              if (debug) log.debug(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
             }
           }
         }

package/src/extension-manifest-regression.test.ts

@@ -0,0 +1,17 @@
+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) as {
+      permissions?: string[];
+      host_permissions?: string[];
+    };
+
+    expect(manifest.permissions).toContain('cookies');
+    expect(manifest.host_permissions).toContain('<all_urls>');
+  });
+});

package/src/main.ts

@@ -20,8 +20,11 @@ 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/src/node-network.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+
+import { decideProxy, hasProxyEnv } from './node-network.js';
+
+describe('node network proxy decisions', () => {
+  it('detects common proxy env variables', () => {
+    expect(hasProxyEnv({ https_proxy: 'http://127.0.0.1:7897' })).toBe(true);
+    expect(hasProxyEnv({ HTTP_PROXY: 'http://proxy.example:8080' })).toBe(true);
+    expect(hasProxyEnv({})).toBe(false);
+  });
+
+  it('routes external https traffic through https_proxy', () => {
+    const decision = decideProxy(
+      new URL('https://www.v2ex.com/api/topics/latest.json'),
+      { https_proxy: 'http://127.0.0.1:7897' },
+    );
+
+    expect(decision).toEqual({
+      mode: 'proxy',
+      proxyUrl: 'http://127.0.0.1:7897',
+    });
+  });
+
+  it('falls back to HTTP_PROXY for https traffic when HTTPS_PROXY is absent', () => {
+    const decision = decideProxy(
+      new URL('https://www.v2ex.com/api/topics/latest.json'),
+      { HTTP_PROXY: 'http://127.0.0.1:7897' },
+    );
+
+    expect(decision).toEqual({
+      mode: 'proxy',
+      proxyUrl: 'http://127.0.0.1:7897',
+    });
+  });
+
+  it('bypasses proxies for loopback addresses', () => {
+    const env = { https_proxy: 'http://127.0.0.1:7897', http_proxy: 'http://127.0.0.1:7897' };
+
+    expect(decideProxy(new URL('http://127.0.0.1:19825/status'), env)).toEqual({ mode: 'direct' });
+    expect(decideProxy(new URL('http://localhost:19825/status'), env)).toEqual({ mode: 'direct' });
+    expect(decideProxy(new URL('http://[::1]:19825/status'), env)).toEqual({ mode: 'direct' });
+  });
+
+  it('honors NO_PROXY domain matches', () => {
+    const decision = decideProxy(
+      new URL('https://api.example.com/v1/items'),
+      {
+        https_proxy: 'http://127.0.0.1:7897',
+        no_proxy: '.example.com',
+      },
+    );
+
+    expect(decision).toEqual({ mode: 'direct' });
+  });
+
+  it('supports wildcard-style NO_PROXY subdomain entries', () => {
+    const decision = decideProxy(
+      new URL('https://api.example.com/v1/items'),
+      {
+        https_proxy: 'http://127.0.0.1:7897',
+        no_proxy: '*.example.com',
+      },
+    );
+
+    expect(decision).toEqual({ mode: 'direct' });
+  });
+
+  it('matches NO_PROXY entries that rely on the default URL port', () => {
+    const env = { https_proxy: 'http://127.0.0.1:7897', http_proxy: 'http://127.0.0.1:7897' };
+
+    expect(decideProxy(
+      new URL('https://example.com/'),
+      { ...env, NO_PROXY: 'example.com:443' },
+    )).toEqual({ mode: 'direct' });
+
+    expect(decideProxy(
+      new URL('http://example.com/health'),
+      { ...env, NO_PROXY: 'example.com:80' },
+    )).toEqual({ mode: 'direct' });
+  });
+
+  it('falls back to ALL_PROXY when protocol-specific settings are absent', () => {
+    const decision = decideProxy(
+      new URL('http://example.net/data'),
+      { ALL_PROXY: 'socks5://127.0.0.1:1080' },
+    );
+
+    expect(decision).toEqual({
+      mode: 'proxy',
+      proxyUrl: 'socks5://127.0.0.1:1080',
+    });
+  });
+});