@jackwener/opencli 1.5.5 → 1.5.7

package/dist/cli.js

@@ -15,6 +15,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, USER_CLIS) {
     const program = new Command();
     // enablePositionalOptions: prevents parent from consuming flags meant for subcommands;
@@ -32,7 +33,7 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
         .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';
         if (fmt !== 'table') {
@@ -42,6 +43,7 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
                     command: fullName(c),
                     site: c.site,
                     name: c.name,
+                    aliases: c.aliases?.join(', ') ?? '',
                     description: c.description,
                     strategy: strategyLabel(c),
                     browser: !!c.browser,
@@ -49,7 +51,7 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
                 }));
             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',
@@ -73,7 +75,8 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
                 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();
         }
@@ -411,6 +414,20 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
             process.exitCode = EXIT_CODES.GENERIC_ERROR;
         }
     });
+    // ── 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();
     program

package/dist/clis/antigravity/serve.d.ts

@@ -6,7 +6,7 @@
  * 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
  */
 export declare function startServe(opts?: {

package/dist/clis/antigravity/serve.js

@@ -6,11 +6,12 @@
  * 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 } from 'node:http';
 import { CDPBridge } from '../../browser/cdp.js';
+import { resolveElectronEndpoint } from '../../launcher.js';
 import { EXIT_CODES, getErrorMessage } from '../../errors.js';
 // ─── Helpers ─────────────────────────────────────────────────────────
 function generateMsgId() {
@@ -365,11 +366,7 @@ export async function startServe(opts = {}) {
                 page = null;
             }
         }
-        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.
         if (process.env.OPENCLI_CDP_TARGET) {
@@ -386,7 +383,7 @@ export async function startServe(opts = {}) {
         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) {
             cdp = null;
@@ -396,7 +393,7 @@ export async function startServe(opts = {}) {
             throw new Error(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}`);
         }
         console.error('[serve] ✅ CDP connected.');

package/dist/clis/band/bands.d.ts

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

package/dist/clis/band/bands.js

@@ -0,0 +1,72 @@
+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 = 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/dist/clis/band/mentions.d.ts

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

package/dist/clis/band/mentions.js

@@ -0,0 +1,127 @@
+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;
+        const limit = kwargs.limit;
+        const unreadOnly = kwargs.unread;
+        // 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) => {
+            const captures = [];
+            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) => 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) => Array.isArray(r?.result_data?.news));
+        if (!newsReq) {
+            throw new EmptyResultError('band mentions', 'Failed to capture get_news response from Band.us. Try running the command again.');
+        }
+        let items = 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) => n.is_new === true);
+        }
+        if (filter === 'mentioned') {
+            // 'filters' is Band's server-side tag array; 'referred' means you were @mentioned.
+            items = items.filter((n) => n.filters?.includes('referred'));
+        }
+        else if (filter === 'post') {
+            items = items.filter((n) => n.category === 'post');
+        }
+        else if (filter === 'comment') {
+            items = items.filter((n) => 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) => s.replace(/<\/?band:[^>]+>/g, '');
+        return items.slice(0, limit).map((n) => {
+            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/dist/clis/band/post.d.ts

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

package/dist/clis/band/post.js

@@ -0,0 +1,175 @@
+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;
+        const withComments = kwargs.comments;
+        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 = 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 = 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) => { 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) => { 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', url, filename: `photo_${globalIndex++}.${urlExt(url)}` })), { output: outputDir, verbose: false, cookies: cookieHeader });
+            }
+            if (otherPhotos.length > 0) {
+                await downloadMedia(otherPhotos.map(url => ({ type: 'image', url, filename: `photo_${globalIndex++}.${urlExt(url)}` })), { output: outputDir, verbose: false });
+            }
+        }
+        const rows = [];
+        // 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;
+    },
+});

package/dist/clis/band/posts.d.ts

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

package/dist/clis/band/posts.js

@@ -0,0 +1,94 @@
+import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+/**
+ * band posts — List posts from a specific Band.
+ *
+ * Band.us renders the post list in the DOM for logged-in users, so we navigate
+ * directly to the band's post page and extract everything from the DOM — no XHR
+ * interception or home-page detour required.
+ */
+cli({
+    site: 'band',
+    name: 'posts',
+    description: 'List posts from a Band',
+    domain: 'www.band.us',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    browser: true,
+    args: [
+        {
+            name: 'band_no',
+            positional: true,
+            required: true,
+            type: 'int',
+            help: 'Band number (get it from: band bands)',
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+    ],
+    columns: ['date', 'author', 'content', 'comments', 'url'],
+    func: async (page, kwargs) => {
+        const bandNo = Number(kwargs.band_no);
+        const limit = Number(kwargs.limit);
+        // Navigate directly to the band's post page — no home-page detour needed.
+        await page.goto(`https://www.band.us/band/${bandNo}/post`);
+        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 post list from the DOM. Poll until post items appear (React hydration).
+        const posts = await page.evaluate(`
+      (async () => {
+        const sleep = ms => new Promise(r => setTimeout(r, ms));
+        const norm = s => (s || '').replace(/\\s+/g, ' ').trim();
+        const limit = ${limit};
+
+        // Wait up to 9 s for post items to render.
+        for (let i = 0; i < 30; i++) {
+          if (document.querySelector('article.cContentsCard._postMainWrap')) break;
+          await sleep(300);
+        }
+
+        // Band embeds custom <band:mention>, <band:sticker>, etc. tags in content.
+        const stripTags = s => s.replace(/<\\/?band:[^>]+>/g, '');
+
+        const results = [];
+        const postEls = Array.from(
+          document.querySelectorAll('article.cContentsCard._postMainWrap')
+        );
+
+        for (const el of postEls) {
+          // URL: first post permalink link (absolute or relative).
+          const linkEl = el.querySelector('a[href*="/post/"]');
+          const href = linkEl?.getAttribute('href') || '';
+          if (!href) continue;
+          const url = href.startsWith('http') ? href : 'https://www.band.us' + href;
+
+          // Author name — a.text in the post header area.
+          const author = norm(el.querySelector('a.text')?.textContent);
+
+          // Date / timestamp.
+          const date = norm(el.querySelector('time')?.textContent);
+
+          // Post body text (strip Band markup tags, truncate for listing).
+          const bodyEl = el.querySelector('.postText._postText');
+          const content = bodyEl
+            ? stripTags(norm(bodyEl.innerText || bodyEl.textContent)).slice(0, 120)
+            : '';
+
+          // Comment count is in span.count inside the count area.
+          const commentEl = el.querySelector('span.count');
+          const comments = commentEl ? parseInt((commentEl.textContent || '').replace(/[^0-9]/g, ''), 10) || 0 : 0;
+
+          if (results.length >= limit) break;
+          results.push({ date, author, content, comments, url });
+        }
+
+        return results;
+      })()
+    `);
+        if (!posts || posts.length === 0) {
+            throw new EmptyResultError('band posts', 'No posts found in this Band');
+        }
+        return posts;
+    },
+});

package/dist/clis/bilibili/subtitle.js

@@ -33,8 +33,12 @@ cli({
         if (payload.code !== 0) {
             throw new CommandExecutionError(`获取视频播放信息失败: ${payload.message} (${payload.code})`);
         }
+        const needLoginSubtitle = payload.data?.need_login_subtitle === true;
         const subtitles = payload.data?.subtitle?.subtitles || [];
         if (subtitles.length === 0) {
+            if (needLoginSubtitle) {
+                throw new AuthRequiredError('bilibili.com', 'Bilibili subtitles are hidden behind login for this video. Please log in to bilibili.com in Chrome and retry.');
+            }
             throw new EmptyResultError('bilibili subtitle', '此视频没有发现外挂或智能字幕。');
         }
         // 4. 选择目标字幕语言

package/dist/clis/bilibili/subtitle.test.d.ts

@@ -0,0 +1 @@
+import './subtitle.js';