@jackwener/opencli 1.5.5 → 1.5.7

package/src/browser.test.ts

@@ -140,7 +140,7 @@ describe('BrowserBridge state', () => {
 
     const mcp = new BrowserBridge();
 
-    await expect(mcp.connect()).rejects.toThrow('Browser Extension is not connected');
+    await expect(mcp.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
   });
 });
 

package/src/build-manifest.test.ts

@@ -84,6 +84,7 @@ describe('manifest helper rules', () => {
         description: 'dynamic command',
         strategy: Strategy.PUBLIC,
         browser: false,
+        aliases: ['metadata'],
         args: [
           {
             name: 'model',
@@ -109,6 +110,7 @@ describe('manifest helper rules', () => {
         domain: 'localhost',
         strategy: 'public',
         browser: false,
+        aliases: ['metadata'],
         args: [
           {
             name: 'model',

package/src/build-manifest.ts

@@ -23,6 +23,7 @@ const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
 export interface ManifestEntry {
   site: string;
   name: string;
+  aliases?: string[];
   description: string;
   domain?: string;
   strategy: string;
@@ -84,6 +85,7 @@ function toManifestEntry(cmd: CliCommand, modulePath: string): ManifestEntry {
   return {
     site: cmd.site,
     name: cmd.name,
+    aliases: cmd.aliases,
     description: cmd.description ?? '',
     domain: cmd.domain,
     strategy: (cmd.strategy ?? 'public').toString().toLowerCase(),
@@ -119,6 +121,9 @@ function scanYaml(filePath: string, site: string): ManifestEntry | null {
       domain: cliDef.domain,
       strategy: strategy.toLowerCase(),
       browser,
+      aliases: isRecord(cliDef) && Array.isArray((cliDef as Record<string, unknown>).aliases)
+        ? ((cliDef as Record<string, unknown>).aliases as unknown[]).filter((value): value is string => typeof value === 'string')
+        : undefined,
       args,
       columns: cliDef.columns,
       pipeline: cliDef.pipeline,
@@ -230,7 +235,7 @@ export async function buildManifest(): Promise<ManifestEntry[]> {
     }
   }
 
-  return [...manifest.values()];
+  return [...manifest.values()].sort((a, b) => a.site.localeCompare(b.site) || a.name.localeCompare(b.name));
 }
 
 async function main(): Promise<void> {

package/src/cli.ts

@@ -16,6 +16,7 @@ import { printCompletionScript } from './completion.js';
 import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled } from './external.js';
 import { registerAllCommands } from './commanderAdapter.js';
 import { EXIT_CODES, getErrorMessage } from './errors.js';
+import { daemonStatus, daemonStop, daemonRestart } from './commands/daemon.js';
 
 export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
   const program = new Command();
@@ -36,7 +37,7 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     .option('--json', 'JSON output (deprecated)')
     .action((opts) => {
       const registry = getRegistry();
-      const commands = [...registry.values()].sort((a, b) => fullName(a).localeCompare(fullName(b)));
+      const commands = [...new Set(registry.values())].sort((a, b) => fullName(a).localeCompare(fullName(b)));
       const fmt = opts.json && opts.format === 'table' ? 'json' : opts.format;
       const isStructured = fmt === 'json' || fmt === 'yaml';
 
@@ -47,6 +48,7 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
               command: fullName(c),
               site: c.site,
               name: c.name,
+              aliases: c.aliases?.join(', ') ?? '',
               description: c.description,
               strategy: strategyLabel(c),
               browser: !!c.browser,
@@ -54,7 +56,7 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
             }));
         renderOutput(rows, {
           fmt,
-          columns: ['command', 'site', 'name', 'description', 'strategy', 'browser', 'args',
+          columns: ['command', 'site', 'name', 'aliases', 'description', 'strategy', 'browser', 'args',
                      ...(isStructured ? ['columns', 'domain'] : [])],
           title: 'opencli/list',
           source: 'opencli list',
@@ -80,7 +82,8 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
           const tag = label === 'public'
             ? chalk.green('[public]')
             : chalk.yellow(`[${label}]`);
-          console.log(`    ${cmd.name} ${tag}${cmd.description ? chalk.dim(` — ${cmd.description}`) : ''}`);
+          const aliases = cmd.aliases?.length ? chalk.dim(` (aliases: ${cmd.aliases.join(', ')})`) : '';
+          console.log(`    ${cmd.name} ${tag}${aliases}${cmd.description ? chalk.dim(` — ${cmd.description}`) : ''}`);
         }
         console.log();
       }
@@ -442,6 +445,21 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       }
     });
 
+  // ── Built-in: daemon ──────────────────────────────────────────────────────
+  const daemonCmd = program.command('daemon').description('Manage the opencli daemon');
+  daemonCmd
+    .command('status')
+    .description('Show daemon status')
+    .action(async () => { await daemonStatus(); });
+  daemonCmd
+    .command('stop')
+    .description('Stop the daemon')
+    .action(async () => { await daemonStop(); });
+  daemonCmd
+    .command('restart')
+    .description('Restart the daemon')
+    .action(async () => { await daemonRestart(); });
+
   // ── External CLIs ─────────────────────────────────────────────────────────
 
   const externalClis = loadExternalClis();

package/src/clis/antigravity/SKILL.md

@@ -7,17 +7,10 @@ description: How to automate Antigravity using OpenCLI
 This skill allows AI agents to control the [Antigravity](https://github.com/chengazhen/Antigravity) desktop app (and any Electron app with CDP enabled) programmatically via OpenCLI. 
 
 ## Requirements
-The target Electron application MUST be launched with the remote-debugging-port flag:
-\`\`\`bash
-/Applications/Antigravity.app/Contents/MacOS/Electron --remote-debugging-port=9224
-\`\`\`
-
-The agent must configure the endpoint environment variable locally before invoking standard commands:
-\`\`\`bash
-export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
-\`\`\`
+opencli automatically detects, launches (with `--remote-debugging-port=9234`), and connects to Antigravity.
+If Antigravity is already running without CDP, opencli will prompt to restart it.
 
-If the endpoint exposes multiple inspectable targets, also set:
+If the endpoint exposes multiple inspectable targets, set:
 \`\`\`bash
 export OPENCLI_CDP_TARGET="antigravity"
 \`\`\`
@@ -33,7 +26,6 @@ export OPENCLI_CDP_TARGET="antigravity"
 
 ### Generating and Saving Code
 \`\`\`bash
-export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
 opencli antigravity send "Write a python script to fetch HN top stories"
 # wait ~10-15 seconds for output to render
 opencli antigravity extract-code > hn_fetcher.py
@@ -42,6 +34,5 @@ opencli antigravity extract-code > hn_fetcher.py
 ### Reading Real-time Logs
 Agents can run long-running streaming watch instances:
 \`\`\`bash
-export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
 opencli antigravity watch
 \`\`\`

package/src/clis/antigravity/serve.ts

@@ -6,13 +6,14 @@
  * and returns it in Anthropic format.
  *
  * Usage:
- *   OPENCLI_CDP_ENDPOINT=http://127.0.0.1:9224 opencli antigravity serve --port 8082
+ *   opencli antigravity serve --port 8082
  *   ANTHROPIC_BASE_URL=http://localhost:8082 claude
  */
 
 import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
 import { CDPBridge } from '../../browser/cdp.js';
 import type { IPage } from '../../types.js';
+import { resolveElectronEndpoint } from '../../launcher.js';
 import { EXIT_CODES, getErrorMessage } from '../../errors.js';
 
 // ─── Types ───────────────────────────────────────────────────────────
@@ -436,13 +437,7 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
       }
     }
 
-    const endpoint = process.env.OPENCLI_CDP_ENDPOINT;
-    if (!endpoint) {
-      throw new Error(
-        'OPENCLI_CDP_ENDPOINT is not set.\n' +
-        'Usage: OPENCLI_CDP_ENDPOINT=http://127.0.0.1:9224 opencli antigravity serve'
-      );
-    }
+    const endpoint = await resolveElectronEndpoint('antigravity');
 
     // Note: Antigravity chat panel lives inside editor windows, not in Launchpad.
     // If multiple editor windows are open, set OPENCLI_CDP_TARGET to the window title.
@@ -461,7 +456,7 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
     console.error(`[serve] Connecting via CDP (target pattern: "${process.env.OPENCLI_CDP_TARGET}")...`);
     cdp = new CDPBridge();
     try {
-      page = await cdp.connect({ timeout: 15_000 });
+      page = await cdp.connect({ timeout: 15_000, cdpEndpoint: endpoint });
     } catch (err: unknown) {
       cdp = null;
       const errMsg = getErrorMessage(err);
@@ -471,7 +466,7 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
         isRefused
           ? `Cannot connect to Antigravity at ${endpoint}.\n` +
             '  1. Make sure Antigravity is running\n' +
-            '  2. Launch with: --remote-debugging-port=9224'
+            '  2. Launch with: --remote-debugging-port=9234'
           : `CDP connection failed: ${errMsg}`
       );
     }

package/src/clis/band/bands.ts

@@ -0,0 +1,76 @@
+import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+
+/**
+ * band bands — List all Bands you belong to.
+ *
+ * Band.us renders the full band list in the left sidebar of the home page for
+ * logged-in users, so we can extract everything we need from the DOM without
+ * XHR interception or any secondary navigation.
+ *
+ * Each sidebar item is an <a href="/band/{band_no}/..."> link whose text and
+ * data attributes carry the band name and member count.
+ */
+cli({
+  site: 'band',
+  name: 'bands',
+  description: 'List all Bands you belong to',
+  domain: 'www.band.us',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [],
+  columns: ['band_no', 'name', 'members'],
+
+  func: async (page, _kwargs) => {
+    const cookies = await page.getCookies({ domain: 'band.us' });
+    const isLoggedIn = cookies.some(c => c.name === 'band_session');
+    if (!isLoggedIn) throw new AuthRequiredError('band.us', 'Not logged in to Band');
+
+    // Extract the band list from the sidebar. Poll until at least one band card
+    // appears (React hydration may take a moment after navigation).
+    // Sidebar band cards use class "bandCover _link" with hrefs like /band/{id}/post.
+    const bands: { band_no: number; name: string; members: number }[] = await page.evaluate(`
+      (async () => {
+        const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+        // Wait up to 9 s for sidebar band cards to render.
+        for (let i = 0; i < 30; i++) {
+          if (document.querySelector('a.bandCover._link')) break;
+          await sleep(300);
+        }
+
+        const norm = s => (s || '').replace(/\\s+/g, ' ').trim();
+        const seen = new Set();
+        const results = [];
+
+        for (const a of Array.from(document.querySelectorAll('a.bandCover._link'))) {
+          // Extract band_no from href: /band/{id} or /band/{id}/post only.
+          const m = (a.getAttribute('href') || '').match(/^\\/band\\/(\\d+)(?:\\/post)?\\/?$/);
+          if (!m) continue;
+          const bandNo = Number(m[1]);
+          if (seen.has(bandNo)) continue;
+          seen.add(bandNo);
+
+          // Band name lives in p.uriText inside div.bandName.
+          const nameEl = a.querySelector('p.uriText');
+          const name = nameEl ? norm(nameEl.textContent) : '';
+          if (!name) continue;
+
+          // Member count is the <em> inside span.member.
+          const memberEl = a.querySelector('span.member em');
+          const members = memberEl ? parseInt((memberEl.textContent || '').replace(/[^0-9]/g, ''), 10) || 0 : 0;
+
+          results.push({ band_no: bandNo, name, members });
+        }
+
+        return results;
+      })()
+    `);
+
+    if (!bands || bands.length === 0) {
+      throw new EmptyResultError('band bands', 'No bands found in sidebar — are you logged in?');
+    }
+
+    return bands;
+  },
+});

package/src/clis/band/mentions.ts

@@ -0,0 +1,134 @@
+import { AuthRequiredError, EmptyResultError, SelectorError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+
+/**
+ * band mentions — Show Band notifications where you were @mentioned.
+ *
+ * Band.us signs every API request with a per-request HMAC (`md` header) generated
+ * by its own JavaScript, so we cannot replicate it externally. Instead we use
+ * Strategy.INTERCEPT: install an XHR interceptor, open the notification panel by
+ * clicking the bell to trigger the get_news XHR call, then apply client-side
+ * filtering to extract notifications matching the requested filter/unread options.
+ */
+cli({
+  site: 'band',
+  name: 'mentions',
+  description: 'Show Band notifications where you are @mentioned',
+  domain: 'www.band.us',
+  strategy: Strategy.INTERCEPT,
+  browser: true,
+  args: [
+    {
+      name: 'filter',
+      default: 'mentioned',
+      choices: ['mentioned', 'all', 'post', 'comment'],
+      help: 'Filter: mentioned (default) | all | post | comment',
+    },
+    { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+    { name: 'unread', type: 'bool', default: false, help: 'Show only unread notifications' },
+  ],
+  columns: ['time', 'band', 'type', 'from', 'text', 'url'],
+
+  func: async (page, kwargs) => {
+    const filter = kwargs.filter as string;
+    const limit = kwargs.limit as number;
+    const unreadOnly = kwargs.unread as boolean;
+
+    // Navigate with a timestamp param to force a fresh page load each run.
+    // Without this, same-URL navigation may skip the reload (preserving the JS context
+    // and leaving the notification panel open from a previous run).
+    await page.goto(`https://www.band.us/?_=${Date.now()}`);
+
+    const cookies = await page.getCookies({ domain: 'band.us' });
+    const isLoggedIn = cookies.some(c => c.name === 'band_session');
+    if (!isLoggedIn) throw new AuthRequiredError('band.us', 'Not logged in to Band');
+
+    // Install XHR interceptor before any clicks so all get_news responses are captured.
+    await page.installInterceptor('get_news');
+
+    // Wait for the bell button to appear (React hydration) instead of a fixed sleep.
+    let bellReady = false;
+    for (let i = 0; i < 20; i++) {
+      const exists = await page.evaluate(`() => !!document.querySelector('button._btnWidgetIcon')`);
+      if (exists) { bellReady = true; break; }
+      await page.wait(0.5);
+    }
+    if (!bellReady) {
+      throw new SelectorError('button._btnWidgetIcon', 'Notification bell not found. The Band.us UI may have changed.');
+    }
+
+    // Poll until a capture containing result_data.news arrives, up to maxSecs seconds.
+    // getInterceptedRequests() clears the array on each call, so captures are accumulated
+    // locally. The interceptor pattern 'get_news' also matches 'get_news_count' responses
+    // which don't have result_data.news — keep polling until the real news response arrives.
+    const waitForOneCapture = async (maxSecs = 8): Promise<any[]> => {
+      const captures: any[] = [];
+      for (let i = 0; i < maxSecs * 2; i++) {
+        await page.wait(0.5); // 0.5 seconds per iteration (page.wait takes seconds)
+        const reqs = await page.getInterceptedRequests();
+        if (reqs.length > 0) {
+          captures.push(...reqs);
+          if (captures.some((r: any) => Array.isArray(r?.result_data?.news))) return captures;
+        }
+      }
+      return captures;
+    };
+
+    // Click the bell. Guard against the element disappearing between the readiness
+    // check and the click (e.g. due to a React re-render) to surface a clear error.
+    const bellClicked = await page.evaluate(`() => {
+      const el = document.querySelector('button._btnWidgetIcon');
+      if (!el) return false;
+      el.click();
+      return true;
+    }`);
+    if (!bellClicked) {
+      throw new SelectorError('button._btnWidgetIcon', 'Notification bell disappeared before click. The Band.us UI may have changed.');
+    }
+
+    const requests = await waitForOneCapture();
+
+    // Find the get_news response (has result_data.news); get_news_count responses do not.
+    const newsReq = requests.find((r: any) => Array.isArray(r?.result_data?.news)) as any;
+    if (!newsReq) {
+      throw new EmptyResultError('band mentions', 'Failed to capture get_news response from Band.us. Try running the command again.');
+    }
+    let items: any[] = newsReq.result_data.news ?? [];
+
+    if (items.length === 0) {
+      throw new EmptyResultError('band mentions', 'No notifications found');
+    }
+
+    // Apply filters client-side from the full notification list.
+    if (unreadOnly) {
+      items = items.filter((n: any) => n.is_new === true);
+    }
+    if (filter === 'mentioned') {
+      // 'filters' is Band's server-side tag array; 'referred' means you were @mentioned.
+      items = items.filter((n: any) => n.filters?.includes('referred'));
+    } else if (filter === 'post') {
+      items = items.filter((n: any) => n.category === 'post');
+    } else if (filter === 'comment') {
+      items = items.filter((n: any) => n.category === 'comment');
+    }
+
+    // Band markup tags (<band:mention uid="...">, <band:sticker>, etc.) appear in
+    // notification text; strip them to get plain readable content.
+    const stripBandTags = (s: string) => s.replace(/<\/?band:[^>]+>/g, '');
+
+    return items.slice(0, limit).map((n: any) => {
+      const ts = n.created_at ? new Date(n.created_at) : null;
+      return {
+        time: ts
+          ? ts.toLocaleString('ja-JP', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
+          : '',
+        band: n.band?.name ?? '',
+        // 'filters' is Band's server-side tag array; 'referred' means you were @mentioned.
+        type: n.filters?.includes('referred') ? '@mention' : n.category ?? '',
+        from: n.actor?.name ?? '',
+        text: stripBandTags(n.subtext ?? '').slice(0, 100),
+        url: n.action?.pc ?? '',
+      };
+    });
+  },
+});

package/src/clis/band/post.ts

@@ -0,0 +1,187 @@
+import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+import { formatCookieHeader } from '../../download/index.js';
+import { downloadMedia } from '../../download/media-download.js';
+import { cli, Strategy } from '../../registry.js';
+
+/**
+ * band post — Export full content of a Band post: body, comments, and optional photo download.
+ *
+ * Navigates directly to the post URL and extracts everything from the DOM.
+ * No XHR interception needed — Band renders the full post for logged-in users.
+ *
+ * Output rows:
+ *   type=post    → the post itself (author, date, body text)
+ *   type=comment → top-level comment
+ *   type=reply   → reply to a comment (nested under its parent)
+ *
+ * Photo thumbnail URLs carry a ?type=sNNN suffix; stripping it yields full-res.
+ */
+cli({
+  site: 'band',
+  name: 'post',
+  description: 'Export full content of a post including comments',
+  domain: 'www.band.us',
+  strategy: Strategy.COOKIE,
+  navigateBefore: false,
+  browser: true,
+  args: [
+    { name: 'band_no', positional: true, required: true, type: 'int', help: 'Band number' },
+    { name: 'post_no', positional: true, required: true, type: 'int', help: 'Post number' },
+    { name: 'output', type: 'str', default: '', help: 'Directory to save attached photos' },
+    { name: 'comments', type: 'bool', default: true, help: 'Include comments (default: true)' },
+  ],
+  columns: ['type', 'author', 'date', 'text'],
+
+  func: async (page, kwargs) => {
+    const bandNo = Number(kwargs.band_no);
+    const postNo = Number(kwargs.post_no);
+    const outputDir = kwargs.output as string;
+    const withComments = kwargs.comments as boolean;
+
+    await page.goto(`https://www.band.us/band/${bandNo}/post/${postNo}`);
+
+    const cookies = await page.getCookies({ domain: 'band.us' });
+    const isLoggedIn = cookies.some(c => c.name === 'band_session');
+    if (!isLoggedIn) throw new AuthRequiredError('band.us', 'Not logged in to Band');
+
+    const data: {
+      author: string;
+      date: string;
+      text: string;
+      photos: string[];
+      comments: { depth: number; author: string; date: string; text: string }[];
+    } = await page.evaluate(`
+      (async () => {
+        const withComments = ${withComments};
+        const sleep = ms => new Promise(r => setTimeout(r, ms));
+        const norm = s => (s || '').replace(/\\s+/g, ' ').trim();
+        // Band embeds <band:mention>, <band:sticker>, etc. in content — strip to plain text.
+        const stripTags = s => s.replace(/<\\/?band:[^>]+>/g, '');
+
+        // Wait up to 9 s for the post content to render (poll for the author link,
+        // which appears after React hydration fills the post header).
+        for (let i = 0; i < 30; i++) {
+          if (document.querySelector('._postWrapper a.text')) break;
+          await sleep(300);
+        }
+
+        const postCard = document.querySelector('._postWrapper');
+        const commentSection = postCard?.querySelector('.dPostCommentMainView');
+
+        // Author and date live in the post header, above the comment section.
+        // Exclude any matches inside the comment section to avoid picking up comment authors.
+        let author = '', date = '';
+        for (const el of (postCard?.querySelectorAll('a.text') || [])) {
+          if (!commentSection?.contains(el)) { author = norm(el.textContent); break; }
+        }
+        for (const el of (postCard?.querySelectorAll('time.time') || [])) {
+          if (!commentSection?.contains(el)) { date = norm(el.textContent); break; }
+        }
+
+        const bodyEl = postCard?.querySelector('.postText._postText');
+        const text = bodyEl ? stripTags(norm(bodyEl.innerText || bodyEl.textContent)) : '';
+
+        // Photo thumbnails have a ?type=sNNN query param; strip it for full-res URL.
+        // Use location.href as base so protocol-relative or relative URLs resolve correctly.
+        const photos = Array.from(postCard?.querySelectorAll('img._imgRecentPhoto, img._imgPhoto') || [])
+          .map(img => {
+            const src = img.getAttribute('src') || '';
+            if (!src) return '';
+            try { const u = new URL(src, location.href); return u.origin + u.pathname; }
+            catch { return ''; }
+          })
+          .filter(Boolean);
+
+        if (!withComments) return { author, date, text, photos, comments: [] };
+
+        // Wait up to 6 s for the comment list container to render.
+        // Wait for the container itself (not .cComment) so posts with zero comments
+        // don't incur a fixed 6s delay waiting for an element that never appears.
+        for (let i = 0; i < 20; i++) {
+          if (postCard?.querySelector('.sCommentList._heightDetectAreaForComment')) break;
+          await sleep(300);
+        }
+
+        // Recursively collect comments and their replies.
+        // Replies live in .sReplyList > .sCommentList, not in ._replyRegion.
+        function extractComments(container, depth) {
+          const results = [];
+          for (const el of container.querySelectorAll(':scope > .cComment')) {
+            results.push({
+              depth,
+              author: norm(el.querySelector('strong.name')?.textContent),
+              date:   norm(el.querySelector('time.time')?.textContent),
+              text:   stripTags(norm(el.querySelector('p.txt._commentContent')?.innerText || '')),
+            });
+            const replyList = el.querySelector('.sReplyList .sCommentList._heightDetectAreaForComment');
+            if (replyList) results.push(...extractComments(replyList, depth + 1));
+          }
+          return results;
+        }
+
+        const commentList = postCard?.querySelector('.sCommentList._heightDetectAreaForComment');
+        const comments = commentList ? extractComments(commentList, 0) : [];
+
+        return { author, date, text, photos, comments };
+      })()
+    `);
+
+    if (!data?.text && !data?.comments?.length && !data?.photos?.length) {
+      throw new EmptyResultError('band post', 'Post not found or not accessible');
+    }
+
+    const photos: string[] = data.photos ?? [];
+
+    // Download photos when --output is specified, using the shared downloadMedia utility
+    // which handles redirects, timeouts, and stream errors correctly.
+    // Pass browser cookies so Band's login-protected photo URLs don't fail with 401/403.
+    if (outputDir && photos.length > 0) {
+      // Only send Band cookies to Band-hosted URLs; avoid leaking auth cookies to third-party CDNs.
+      // Use a global index across both batches so filenames don't collide (photo_1, photo_2, ...).
+      const cookieHeader = formatCookieHeader(await page.getCookies({ url: 'https://www.band.us' }));
+      const isBandUrl = (u: string) => { try { const h = new URL(u).hostname; return h === 'band.us' || h.endsWith('.band.us'); } catch { return false; } };
+      // Derive extension from URL path so downloaded files have correct extensions (e.g. photo_1.jpg).
+      const urlExt = (u: string) => { try { return new URL(u).pathname.match(/\.(\w+)$/)?.[1] ?? 'jpg'; } catch { return 'jpg'; } };
+      let globalIndex = 1;
+      const bandPhotos = photos.filter(isBandUrl);
+      const otherPhotos = photos.filter(u => !isBandUrl(u));
+      if (bandPhotos.length > 0) {
+        await downloadMedia(
+          bandPhotos.map(url => ({ type: 'image' as const, url, filename: `photo_${globalIndex++}.${urlExt(url)}` })),
+          { output: outputDir, verbose: false, cookies: cookieHeader },
+        );
+      }
+      if (otherPhotos.length > 0) {
+        await downloadMedia(
+          otherPhotos.map(url => ({ type: 'image' as const, url, filename: `photo_${globalIndex++}.${urlExt(url)}` })),
+          { output: outputDir, verbose: false },
+        );
+      }
+    }
+
+    const rows: Record<string, string>[] = [];
+
+    // Post row — append photo URLs inline when not downloading to disk.
+    rows.push({
+      type: 'post',
+      author: data.author ?? '',
+      date: data.date ?? '',
+      text: [
+        data.text ?? '',
+        ...(outputDir ? [] : photos.map((u, i) => `[photo${i + 1}] ${u}`)),
+      ].filter(Boolean).join('\n'),
+    });
+
+    // Comment rows — depth=0 → type 'comment', depth≥1 → type 'reply'.
+    for (const c of data.comments ?? []) {
+      rows.push({
+        type: c.depth === 0 ? 'comment' : 'reply',
+        author: c.author ?? '',
+        date: c.date ?? '',
+        text: c.depth > 0 ? '  '.repeat(c.depth) + '└ ' + (c.text ?? '') : (c.text ?? ''),
+      });
+    }
+
+    return rows;
+  },
+});