@jackwener/opencli 1.3.3 → 1.4.1

package/src/clis/xueqiu/search.yaml

@@ -48,7 +48,8 @@ pipeline:
       exchange: ${{ item.exchange }}
       price: ${{ item.price }}
       changePercent: ${{ item.changePercent }}
+      url: ${{ item.url }}
       
   - limit: ${{ args.limit }}
 
-columns: [symbol, name, exchange, price, changePercent]
+columns: [symbol, name, exchange, price, changePercent, url]

package/src/clis/yahoo-finance/quote.ts

@@ -1,6 +1,5 @@
 /**
  * Yahoo Finance stock quote — multi-strategy API fallback.
- * Source: bb-sites/yahoo-finance/quote.js
  */
 import { cli, Strategy } from '../../registry.js';
 

package/src/clis/youtube/channel.ts

@@ -0,0 +1,155 @@
+/**
+ * YouTube channel — get channel info and recent videos via InnerTube API.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+
+cli({
+  site: 'youtube',
+  name: 'channel',
+  description: 'Get YouTube channel info and recent videos',
+  domain: 'www.youtube.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'Channel ID (UCxxxx) or handle (@name)' },
+    { name: 'limit', type: 'int', default: 10, help: 'Max recent videos (max 30)' },
+  ],
+  columns: ['field', 'value'],
+  func: async (page, kwargs) => {
+    const channelId = String(kwargs.id);
+    const limit = Math.min(kwargs.limit || 10, 30);
+    await page.goto('https://www.youtube.com');
+    await page.wait(2);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const channelId = ${JSON.stringify(channelId)};
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        // Resolve handle to browseId if needed
+        let browseId = channelId;
+        if (channelId.startsWith('@')) {
+          const resolveResp = await fetch('/youtubei/v1/navigation/resolve_url?key=' + apiKey + '&prettyPrint=false', {
+            method: 'POST', credentials: 'include',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({context, url: 'https://www.youtube.com/' + channelId})
+          });
+          if (resolveResp.ok) {
+            const resolveData = await resolveResp.json();
+            browseId = resolveData.endpoint?.browseEndpoint?.browseId || channelId;
+          }
+        }
+
+        // Fetch channel data
+        const resp = await fetch('/youtubei/v1/browse?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, browseId})
+        });
+        if (!resp.ok) return {error: 'Channel API returned HTTP ' + resp.status};
+        const data = await resp.json();
+
+        // Channel metadata
+        const metadata = data.metadata?.channelMetadataRenderer || {};
+        const header = data.header?.pageHeaderRenderer || data.header?.c4TabbedHeaderRenderer || {};
+
+        // Subscriber count from header
+        let subscriberCount = '';
+        try {
+          const rows = header.content?.pageHeaderViewModel?.metadata?.contentMetadataViewModel?.metadataRows || [];
+          for (const row of rows) {
+            for (const part of (row.metadataParts || [])) {
+              const text = part.text?.content || '';
+              if (text.includes('subscriber')) subscriberCount = text;
+            }
+          }
+        } catch {}
+        // Fallback for old c4TabbedHeaderRenderer format
+        if (!subscriberCount && header.subscriberCountText?.simpleText) {
+          subscriberCount = header.subscriberCountText.simpleText;
+        }
+
+        // Extract recent videos from Home tab
+        const tabs = data.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
+        const homeTab = tabs.find(t => t.tabRenderer?.selected);
+        const recentVideos = [];
+
+        if (homeTab) {
+          const sections = homeTab.tabRenderer?.content?.sectionListRenderer?.contents || [];
+          for (const section of sections) {
+            for (const shelf of (section.itemSectionRenderer?.contents || [])) {
+              for (const item of (shelf.shelfRenderer?.content?.horizontalListRenderer?.items || [])) {
+                // New lockupViewModel format
+                const lvm = item.lockupViewModel;
+                if (lvm && lvm.contentType === 'LOCKUP_CONTENT_TYPE_VIDEO' && recentVideos.length < limit) {
+                  const meta = lvm.metadata?.lockupMetadataViewModel;
+                  const rows = meta?.metadata?.contentMetadataViewModel?.metadataRows || [];
+                  const viewsAndTime = (rows[0]?.metadataParts || []).map(p => p.text?.content).filter(Boolean).join(' | ');
+                  let duration = '';
+                  for (const ov of (lvm.contentImage?.thumbnailViewModel?.overlays || [])) {
+                    for (const b of (ov.thumbnailBottomOverlayViewModel?.badges || [])) {
+                      if (b.thumbnailBadgeViewModel?.text) duration = b.thumbnailBadgeViewModel.text;
+                    }
+                  }
+                  recentVideos.push({
+                    title: meta?.title?.content || '',
+                    duration,
+                    views: viewsAndTime,
+                    url: 'https://www.youtube.com/watch?v=' + lvm.contentId,
+                  });
+                }
+                // Legacy gridVideoRenderer format
+                if (item.gridVideoRenderer && recentVideos.length < limit) {
+                  const v = item.gridVideoRenderer;
+                  recentVideos.push({
+                    title: v.title?.runs?.[0]?.text || v.title?.simpleText || '',
+                    duration: v.thumbnailOverlays?.[0]?.thumbnailOverlayTimeStatusRenderer?.text?.simpleText || '',
+                    views: (v.shortViewCountText?.simpleText || '') + (v.publishedTimeText?.simpleText ? ' | ' + v.publishedTimeText.simpleText : ''),
+                    url: 'https://www.youtube.com/watch?v=' + v.videoId,
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        return {
+          name: metadata.title || '',
+          channelId: metadata.externalId || browseId,
+          handle: metadata.vanityChannelUrl?.split('/').pop() || '',
+          description: (metadata.description || '').substring(0, 500),
+          subscribers: subscriberCount,
+          url: metadata.channelUrl || 'https://www.youtube.com/channel/' + browseId,
+          keywords: metadata.keywords || '',
+          recentVideos,
+        };
+      })()
+    `);
+
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to fetch channel data');
+    if ((data as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+
+    const result = data as Record<string, unknown>;
+    const videos = result.recentVideos as Array<Record<string, string>> | undefined;
+    delete result.recentVideos;
+
+    // Channel info as field/value pairs + recent videos as table
+    const rows = Object.entries(result).map(([field, value]) => ({
+      field,
+      value: String(value),
+    }));
+
+    if (videos && videos.length > 0) {
+      rows.push({ field: '---', value: '--- Recent Videos ---' });
+      for (const v of videos) {
+        rows.push({ field: v.title, value: `${v.duration} | ${v.views} | ${v.url}` });
+      }
+    }
+
+    return rows;
+  },
+});

package/src/clis/youtube/comments.ts

@@ -0,0 +1,97 @@
+/**
+ * YouTube comments — get video comments via InnerTube API.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { parseVideoId } from './utils.js';
+
+cli({
+  site: 'youtube',
+  name: 'comments',
+  description: 'Get YouTube video comments',
+  domain: 'www.youtube.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'url', required: true, positional: true, help: 'YouTube video URL or video ID' },
+    { name: 'limit', type: 'int', default: 20, help: 'Max comments (max 100)' },
+  ],
+  columns: ['rank', 'author', 'text', 'likes', 'replies', 'time'],
+  func: async (page, kwargs) => {
+    const videoId = parseVideoId(kwargs.url);
+    const limit = Math.min(kwargs.limit || 20, 100);
+    await page.goto(`https://www.youtube.com/watch?v=${videoId}`);
+    await page.wait(3);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const videoId = ${JSON.stringify(videoId)};
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        // Step 1: Get comment continuation token
+        let continuationToken = null;
+
+        // Try from current page ytInitialData
+        if (window.ytInitialData) {
+          const results = window.ytInitialData.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+          const commentSection = results.find(i => i.itemSectionRenderer?.targetId === 'comments-section');
+          continuationToken = commentSection?.itemSectionRenderer?.contents?.[0]?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+        }
+
+        // Fallback: fetch via next API
+        if (!continuationToken) {
+          const nextResp = await fetch('/youtubei/v1/next?key=' + apiKey + '&prettyPrint=false', {
+            method: 'POST', credentials: 'include',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({context, videoId})
+          });
+          if (!nextResp.ok) return {error: 'Failed to get video data: HTTP ' + nextResp.status};
+          const nextData = await nextResp.json();
+          const results = nextData.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+          const commentSection = results.find(i => i.itemSectionRenderer?.targetId === 'comments-section');
+          continuationToken = commentSection?.itemSectionRenderer?.contents?.[0]?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+        }
+
+        if (!continuationToken) return {error: 'No comment section found — comments may be disabled'};
+
+        // Step 2: Fetch comments
+        const commentResp = await fetch('/youtubei/v1/next?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, continuation: continuationToken})
+        });
+        if (!commentResp.ok) return {error: 'Failed to fetch comments: HTTP ' + commentResp.status};
+        const commentData = await commentResp.json();
+
+        // Parse from frameworkUpdates (new ViewModel format)
+        const mutations = commentData.frameworkUpdates?.entityBatchUpdate?.mutations || [];
+        const commentEntities = mutations.filter(m => m.payload?.commentEntityPayload);
+
+        return commentEntities.slice(0, limit).map((m, i) => {
+          const p = m.payload.commentEntityPayload;
+          const props = p.properties || {};
+          const author = p.author || {};
+          const toolbar = p.toolbar || {};
+          return {
+            rank: i + 1,
+            author: author.displayName || '',
+            text: (props.content?.content || '').substring(0, 300),
+            likes: toolbar.likeCountNotliked || '0',
+            replies: toolbar.replyCount || '0',
+            time: props.publishedTime || '',
+          };
+        });
+      })()
+    `);
+
+    if (!Array.isArray(data)) {
+      const errMsg = data && typeof data === 'object' ? String((data as Record<string, unknown>).error || '') : '';
+      if (errMsg) throw new CommandExecutionError(errMsg);
+      return [];
+    }
+    return data;
+  },
+});

package/src/clis/youtube/search.ts

@@ -1,6 +1,5 @@
 /**
  * YouTube search — innertube API via browser session.
- * Source: bb-sites/youtube/search.js
  */
 import { cli, Strategy } from '../../registry.js';
 

package/src/clis/youtube/transcript.ts

@@ -17,6 +17,7 @@ import {
   type RawSegment,
   type Chapter,
 } from './transcript-group.js';
+import { CommandExecutionError, EmptyResultError } from '../../errors.js';
 
 cli({
   site: 'youtube',
@@ -91,10 +92,10 @@ cli({
     `);
 
     if (!captionData || typeof captionData === 'string') {
-      throw new Error(`Failed to get caption info: ${typeof captionData === 'string' ? captionData : 'null response'}`);
+      throw new CommandExecutionError(`Failed to get caption info: ${typeof captionData === 'string' ? captionData : 'null response'}`);
     }
     if (captionData.error) {
-      throw new Error(`${captionData.error}${captionData.available ? ' (available: ' + captionData.available.join(', ') + ')' : ''}`);
+      throw new CommandExecutionError(`${captionData.error}${captionData.available ? ' (available: ' + captionData.available.join(', ') + ')' : ''}`);
     }
 
     // Warn if --lang was specified but not matched
@@ -176,10 +177,10 @@ cli({
     `);
 
     if (!Array.isArray(segments)) {
-      throw new Error((segments as any)?.error || 'Failed to parse caption segments');
+      throw new CommandExecutionError((segments as any)?.error || 'Failed to parse caption segments');
     }
     if (segments.length === 0) {
-      throw new Error('No caption segments found');
+      throw new EmptyResultError('youtube transcript');
     }
 
     // Step 3: Fetch chapters (for grouped mode)

package/src/clis/youtube/video.ts

@@ -3,6 +3,7 @@
  */
 import { cli, Strategy } from '../../registry.js';
 import { parseVideoId } from './utils.js';
+import { CommandExecutionError } from '../../errors.js';
 
 cli({
   site: 'youtube',
@@ -104,8 +105,8 @@ cli({
       })()
     `);
 
-    if (!data || typeof data !== 'object') throw new Error('Failed to extract video metadata from page');
-    if (data.error) throw new Error(data.error);
+    if (!data || typeof data !== 'object') throw new CommandExecutionError('Failed to extract video metadata from page');
+    if (data.error) throw new CommandExecutionError(data.error);
 
     // Return as field/value pairs for table display
     return Object.entries(data).map(([field, value]) => ({

package/src/clis/zhihu/search.yaml

@@ -52,7 +52,8 @@ pipeline:
       type: ${{ item.type }}
       author: ${{ item.author }}
       votes: ${{ item.votes }}
+      url: ${{ item.url }}
 
   - limit: ${{ args.limit }}
 
-columns: [rank, title, type, author, votes]
+columns: [rank, title, type, author, votes, url]

package/src/daemon.ts

@@ -64,13 +64,14 @@ function readBody(req: IncomingMessage): Promise<string> {
   return new Promise((resolve, reject) => {
     const chunks: Buffer[] = [];
     let size = 0;
+    let aborted = false;
     req.on('data', (c: Buffer) => {
       size += c.length;
-      if (size > MAX_BODY) { req.destroy(); reject(new Error('Body too large')); return; }
+      if (size > MAX_BODY) { aborted = true; req.destroy(); reject(new Error('Body too large')); return; }
       chunks.push(c);
     });
-    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-    req.on('error', reject);
+    req.on('end', () => { if (!aborted) resolve(Buffer.concat(chunks).toString('utf-8')); });
+    req.on('error', (err) => { if (!aborted) reject(err); });
   });
 }
 
@@ -271,7 +272,7 @@ httpServer.listen(PORT, '127.0.0.1', () => {
 httpServer.on('error', (err: NodeJS.ErrnoException) => {
   if (err.code === 'EADDRINUSE') {
     console.error(`[daemon] Port ${PORT} already in use — another daemon is likely running. Exiting.`);
-    process.exit(0);
+    process.exit(1);
   }
   console.error('[daemon] Server error:', err.message);
   process.exit(1);

package/src/discovery.ts

@@ -20,31 +20,10 @@ import type { ManifestEntry } from './build-manifest.js';
 
 /** Plugins directory: ~/.opencli/plugins/ */
 export const PLUGINS_DIR = path.join(os.homedir(), '.opencli', 'plugins');
-const CLI_MODULE_PATTERN = /\bcli\s*\(/;
+/** Matches files that register commands via cli() or lifecycle hooks */
+const PLUGIN_MODULE_PATTERN = /\b(?:cli|onStartup|onBeforeExecute|onAfterExecute)\s*\(/;
 
-interface YamlArgDefinition {
-  type?: string;
-  default?: unknown;
-  required?: boolean;
-  positional?: boolean;
-  description?: string;
-  help?: string;
-  choices?: string[];
-}
-
-interface YamlCliDefinition {
-  site?: string;
-  name?: string;
-  description?: string;
-  domain?: string;
-  strategy?: string;
-  browser?: boolean;
-  args?: Record<string, YamlArgDefinition>;
-  columns?: string[];
-  pipeline?: Record<string, unknown>[];
-  timeout?: number;
-  navigateBefore?: boolean | string;
-}
+import type { YamlCliDefinition } from './yaml-schema.js';
 
 function parseStrategy(rawStrategy: string | undefined, fallback: Strategy = Strategy.COOKIE): Strategy {
   if (!rawStrategy) return fallback;
@@ -52,9 +31,7 @@ function parseStrategy(rawStrategy: string | undefined, fallback: Strategy = Str
   return Strategy[key] ?? fallback;
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from './utils.js';
 
 /**
  * Discover and register CLI commands.
@@ -66,12 +43,12 @@ export async function discoverClis(...dirs: string[]): Promise<void> {
     const manifestPath = path.resolve(dir, '..', 'cli-manifest.json');
     try {
       await fs.promises.access(manifestPath);
-      await loadFromManifest(manifestPath, dir);
-      continue; // Skip filesystem scan for this directory
+      const loaded = await loadFromManifest(manifestPath, dir);
+      if (loaded) continue; // Skip filesystem scan only when manifest is usable
     } catch {
-      // Fallback: runtime filesystem scan (development)
-      await discoverClisFromFs(dir);
+      // Fall through to filesystem scan
     }
+    await discoverClisFromFs(dir);
   }
 }
 
@@ -80,7 +57,7 @@ export async function discoverClis(...dirs: string[]): Promise<void> {
  * YAML pipelines are inlined — zero YAML parsing at runtime.
  * TS modules are deferred — loaded lazily on first execution.
  */
-async function loadFromManifest(manifestPath: string, clisDir: string): Promise<void> {
+async function loadFromManifest(manifestPath: string, clisDir: string): Promise<boolean> {
   try {
     const raw = await fs.promises.readFile(manifestPath, 'utf-8');
     const manifest = JSON.parse(raw) as ManifestEntry[];
@@ -126,8 +103,10 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
         registerCommand(cmd);
       }
     }
+    return true;
   } catch (err) {
     log.warn(`Failed to load manifest ${manifestPath}: ${getErrorMessage(err)}`);
+    return false;
   }
 }
 
@@ -136,7 +115,6 @@ async function loadFromManifest(manifestPath: string, clisDir: string): Promise<
  */
 async function discoverClisFromFs(dir: string): Promise<void> {
   try { await fs.promises.access(dir); } catch { return; }
-  const promises: Promise<unknown>[] = [];
   const entries = await fs.promises.readdir(dir, { withFileTypes: true });
   
   const sitePromises = entries
@@ -269,7 +247,7 @@ async function discoverPluginDir(dir: string, site: string): Promise<void> {
 async function isCliModule(filePath: string): Promise<boolean> {
   try {
     const source = await fs.promises.readFile(filePath, 'utf-8');
-    return CLI_MODULE_PATTERN.test(source);
+    return PLUGIN_MODULE_PATTERN.test(source);
   } catch (err) {
     log.warn(`Failed to inspect module ${filePath}: ${getErrorMessage(err)}`);
     return false;

package/src/doctor.ts

@@ -10,6 +10,7 @@ import { DEFAULT_DAEMON_PORT } from './constants.js';
 import { checkDaemonStatus } from './browser/discover.js';
 import { BrowserBridge } from './browser/index.js';
 import { listSessions } from './browser/daemon-client.js';
+import { getErrorMessage } from './errors.js';
 
 export type DoctorOptions = {
   fix?: boolean;
@@ -46,8 +47,8 @@ export async function checkConnectivity(opts?: { timeout?: number }): Promise<Co
     await page.evaluate('1 + 1');
     await mcp.close();
     return { ok: true, durationMs: Date.now() - start };
-  } catch (err: any) {
-    return { ok: false, error: err?.message ?? String(err), durationMs: Date.now() - start };
+  } catch (err) {
+    return { ok: false, error: getErrorMessage(err), durationMs: Date.now() - start };
   }
 }
 

package/src/download/index.test.ts

@@ -1,5 +1,29 @@
-import { describe, expect, it } from 'vitest';
-import { formatCookieHeader, resolveRedirectUrl } from './index.js';
+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 { formatCookieHeader, httpDownload, resolveRedirectUrl } from './index.js';
+
+const servers: http.Server[] = [];
+
+afterEach(async () => {
+  await Promise.all(servers.map((server) => new Promise<void>((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve()));
+  })));
+  servers.length = 0;
+});
+
+async function startServer(handler: http.RequestListener, hostname = '127.0.0.1'): Promise<string> {
+  const server = http.createServer(handler);
+  servers.push(server);
+  await new Promise<void>((resolve) => server.listen(0, hostname, resolve));
+  const address = server.address();
+  if (!address || typeof address === 'string') {
+    throw new Error('Failed to start test server');
+  }
+  return `http://${hostname}:${address.port}`;
+}
 
 describe('download helpers', () => {
   it('resolves relative redirects against the original URL', () => {
@@ -13,4 +37,71 @@ describe('download helpers', () => {
       { name: 'ct0', value: 'def', domain: 'example.com' },
     ])).toBe('sid=abc; ct0=def');
   });
+
+  it('fails after exceeding the redirect limit', async () => {
+    const baseUrl = await startServer((_req, res) => {
+      res.statusCode = 302;
+      res.setHeader('Location', '/loop');
+      res.end();
+    });
+
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+    const destPath = path.join(tempDir, 'file.txt');
+    const result = await httpDownload(`${baseUrl}/loop`, destPath, { maxRedirects: 2 });
+
+    expect(result).toEqual({
+      success: false,
+      size: 0,
+      error: 'Too many redirects (> 2)',
+    });
+    expect(fs.existsSync(destPath)).toBe(false);
+  });
+
+  it('does not forward cookies across cross-domain redirects', async () => {
+    let forwardedCookie: string | undefined;
+    const targetUrl = await startServer((req, res) => {
+      forwardedCookie = req.headers.cookie;
+      res.statusCode = 200;
+      res.end('ok');
+    }, 'localhost');
+
+    const redirectUrl = await startServer((_req, res) => {
+      res.statusCode = 302;
+      res.setHeader('Location', targetUrl);
+      res.end();
+    });
+
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+    const destPath = path.join(tempDir, 'redirect.txt');
+    const result = await httpDownload(`${redirectUrl}/start`, destPath, { cookies: 'sid=abc' });
+
+    expect(result).toEqual({ success: true, size: 2 });
+    expect(forwardedCookie).toBeUndefined();
+    expect(fs.readFileSync(destPath, 'utf8')).toBe('ok');
+  });
+
+  it('does not forward cookie headers across cross-domain redirects', async () => {
+    let forwardedCookie: string | undefined;
+    const targetUrl = await startServer((req, res) => {
+      forwardedCookie = req.headers.cookie;
+      res.statusCode = 200;
+      res.end('ok');
+    }, 'localhost');
+
+    const redirectUrl = await startServer((_req, res) => {
+      res.statusCode = 302;
+      res.setHeader('Location', targetUrl);
+      res.end();
+    });
+
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-download-'));
+    const destPath = path.join(tempDir, 'redirect-header.txt');
+    const result = await httpDownload(`${redirectUrl}/start`, destPath, {
+      headers: { Cookie: 'sid=header-cookie' },
+    });
+
+    expect(result).toEqual({ success: true, size: 2 });
+    expect(forwardedCookie).toBeUndefined();
+    expect(fs.readFileSync(destPath, 'utf8')).toBe('ok');
+  });
 });