@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/apple-podcasts/commands.test.js

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './search.js';
+import './top.js';
+describe('apple-podcasts search command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('uses the positional query argument for the iTunes search request', async () => {
+        const cmd = getRegistry().get('apple-podcasts/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                results: [
+                    {
+                        collectionId: 42,
+                        collectionName: 'Machine Learning Guide',
+                        artistName: 'OpenCLI',
+                        trackCount: 12,
+                        primaryGenreName: 'Technology',
+                    },
+                ],
+            }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await cmd.func(null, {
+            query: 'machine learning',
+            keyword: 'sports',
+            limit: 5,
+        });
+        expect(fetchMock).toHaveBeenCalledWith('https://itunes.apple.com/search?term=machine%20learning&media=podcast&limit=5');
+        expect(result).toEqual([
+            expect.objectContaining({
+                id: 42,
+                title: 'Machine Learning Guide',
+                author: 'OpenCLI',
+                episodes: 12,
+                genre: 'Technology',
+                url: '',
+            }),
+        ]);
+    });
+});
+describe('apple-podcasts top command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('adds a timeout signal to chart fetches', async () => {
+        const cmd = getRegistry().get('apple-podcasts/top');
+        expect(cmd?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                feed: {
+                    results: [
+                        { id: '100', name: 'Top Show', artistName: 'Host A' },
+                    ],
+                },
+            }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        await cmd.func(null, { country: 'US', limit: 1 });
+        const [, options] = fetchMock.mock.calls[0] ?? [];
+        expect(options).toBeDefined();
+        expect(options.signal).toBeDefined();
+        expect(options.signal).toHaveProperty('aborted', false);
+    });
+    it('uses the canonical Apple charts host and maps ranked results', async () => {
+        const cmd = getRegistry().get('apple-podcasts/top');
+        expect(cmd?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                feed: {
+                    results: [
+                        { id: '100', name: 'Top Show', artistName: 'Host A' },
+                        { id: '101', name: 'Second Show', artistName: 'Host B' },
+                    ],
+                },
+            }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await cmd.func(null, { country: 'US', limit: 2 });
+        expect(fetchMock).toHaveBeenCalledWith('https://rss.marketingtools.apple.com/api/v2/us/podcasts/top/2/podcasts.json', expect.objectContaining({
+            signal: expect.any(Object),
+        }));
+        expect(result).toEqual([
+            { rank: 1, title: 'Top Show', author: 'Host A', id: '100' },
+            { rank: 2, title: 'Second Show', author: 'Host B', id: '101' },
+        ]);
+    });
+    it('normalizes network failures into CliError output', async () => {
+        const cmd = getRegistry().get('apple-podcasts/top');
+        expect(cmd?.func).toBeTypeOf('function');
+        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('socket hang up')));
+        await expect(cmd.func(null, { country: 'us', limit: 3 })).rejects.toThrow('Unable to reach Apple Podcasts charts for US');
+    });
+});

package/vendor/opencli/dist/clis/apple-podcasts/episodes.d.ts

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

package/vendor/opencli/dist/clis/apple-podcasts/episodes.js

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { itunesFetch, formatDuration, formatDate } from './utils.js';
+cli({
+    site: 'apple-podcasts',
+    name: 'episodes',
+    description: 'List recent episodes of an Apple Podcast (use ID from search)',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Podcast ID (collectionId from search output)' },
+        { name: 'limit', type: 'int', default: 15, help: 'Max episodes to show' },
+    ],
+    columns: ['title', 'duration', 'date'],
+    func: async (_page, args) => {
+        const limit = Math.max(1, Math.min(Number(args.limit), 200));
+        // results[0] is the podcast itself; the rest are episodes
+        const data = await itunesFetch(`/lookup?id=${args.id}&entity=podcastEpisode&limit=${limit + 1}`);
+        const episodes = (data.results ?? []).filter((r) => r.kind === 'podcast-episode');
+        if (!episodes.length)
+            throw new CliError('NOT_FOUND', 'No episodes found', 'Check the podcast ID from: opencli apple-podcasts search <keyword>');
+        return episodes.slice(0, limit).map((ep) => ({
+            title: ep.trackName,
+            duration: formatDuration(ep.trackTimeMillis),
+            date: formatDate(ep.releaseDate),
+        }));
+    },
+});

package/vendor/opencli/dist/clis/apple-podcasts/search.d.ts

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

package/vendor/opencli/dist/clis/apple-podcasts/search.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { itunesFetch } from './utils.js';
+cli({
+    site: 'apple-podcasts',
+    name: 'search',
+    description: 'Search Apple Podcasts',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results' },
+    ],
+    columns: ['id', 'title', 'author', 'episodes', 'genre', 'url'],
+    func: async (_page, args) => {
+        const term = encodeURIComponent(args.query);
+        const limit = Math.max(1, Math.min(Number(args.limit), 25));
+        const data = await itunesFetch(`/search?term=${term}&media=podcast&limit=${limit}`);
+        if (!data.results?.length)
+            throw new CliError('NOT_FOUND', 'No podcasts found', `Try a different keyword`);
+        return data.results.map((p) => ({
+            id: p.collectionId,
+            title: p.collectionName,
+            author: p.artistName,
+            episodes: p.trackCount ?? '-',
+            genre: p.primaryGenreName ?? '-',
+            url: p.collectionViewUrl || '',
+        }));
+    },
+});

package/vendor/opencli/dist/clis/apple-podcasts/top.d.ts

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

package/vendor/opencli/dist/clis/apple-podcasts/top.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+// Apple Marketing Tools RSS API — public, no key required
+const CHARTS_URL = 'https://rss.marketingtools.apple.com/api/v2';
+const CHARTS_TIMEOUT_MS = 15_000;
+cli({
+    site: 'apple-podcasts',
+    name: 'top',
+    description: 'Top podcasts chart on Apple Podcasts',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of podcasts (max 100)' },
+        { name: 'country', default: 'us', help: 'Country code (e.g. us, cn, gb, jp)' },
+    ],
+    columns: ['rank', 'title', 'author', 'id'],
+    func: async (_page, args) => {
+        const limit = Math.max(1, Math.min(Number(args.limit), 100));
+        const country = String(args.country || 'us').trim().toLowerCase();
+        const url = `${CHARTS_URL}/${country}/podcasts/top/${limit}/podcasts.json`;
+        let resp;
+        try {
+            resp = await fetch(url, {
+                signal: AbortSignal.timeout(CHARTS_TIMEOUT_MS),
+            });
+        }
+        catch (error) {
+            const reason = error?.cause?.code ?? error?.message ?? 'unknown network error';
+            throw new CliError('FETCH_ERROR', `Unable to reach Apple Podcasts charts for ${country.toUpperCase()}`, `Apple charts may be temporarily unavailable (${reason}). Try again later.`);
+        }
+        if (!resp.ok)
+            throw new CliError('FETCH_ERROR', `Charts API HTTP ${resp.status}`, `Check country code: ${country}`);
+        const data = await resp.json();
+        const results = data?.feed?.results;
+        if (!results?.length)
+            throw new CliError('NOT_FOUND', 'No chart data found', `Try a different country code`);
+        return results.map((p, i) => ({
+            rank: i + 1,
+            title: p.name,
+            author: p.artistName,
+            id: p.id,
+        }));
+    },
+});

package/vendor/opencli/dist/clis/apple-podcasts/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared Apple Podcasts utilities.
+ *
+ * Uses the public iTunes Search API — no API key required.
+ * https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/iTuneSearchAPI/
+ */
+export declare function itunesFetch(path: string): Promise<any>;
+/** Format milliseconds to mm:ss. Returns '-' for missing input. */
+export declare function formatDuration(ms: number): string;
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export declare function formatDate(iso: string): string;

package/vendor/opencli/dist/clis/apple-podcasts/utils.js

@@ -0,0 +1,30 @@
+/**
+ * Shared Apple Podcasts utilities.
+ *
+ * Uses the public iTunes Search API — no API key required.
+ * https://developer.apple.com/library/archive/documentation/AudioVideo/Conceptual/iTuneSearchAPI/
+ */
+import { CliError } from '../../errors.js';
+const BASE = 'https://itunes.apple.com';
+export async function itunesFetch(path) {
+    const resp = await fetch(`${BASE}${path}`);
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `iTunes API HTTP ${resp.status}`, 'Check your search term or podcast ID');
+    }
+    return resp.json();
+}
+/** Format milliseconds to mm:ss. Returns '-' for missing input. */
+export function formatDuration(ms) {
+    if (!ms || !Number.isFinite(ms))
+        return '-';
+    const totalSec = Math.round(ms / 1000);
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    return `${m}:${String(s).padStart(2, '0')}`;
+}
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export function formatDate(iso) {
+    if (!iso)
+        return '-';
+    return iso.slice(0, 10);
+}

package/vendor/opencli/dist/clis/apple-podcasts/utils.test.d.ts

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

package/vendor/opencli/dist/clis/apple-podcasts/utils.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatDuration, formatDate, itunesFetch } from './utils.js';
+describe('formatDuration', () => {
+    it('formats typical duration in ms', () => {
+        expect(formatDuration(3661000)).toBe('61:01');
+    });
+    it('pads single-digit seconds', () => {
+        expect(formatDuration(65000)).toBe('1:05');
+    });
+    it('formats exact minutes', () => {
+        expect(formatDuration(3600000)).toBe('60:00');
+    });
+    it('rounds fractional milliseconds', () => {
+        expect(formatDuration(3600500)).toBe('60:01');
+    });
+    it('returns dash for zero', () => {
+        expect(formatDuration(0)).toBe('-');
+    });
+    it('returns dash for NaN', () => {
+        expect(formatDuration(NaN)).toBe('-');
+    });
+});
+describe('formatDate', () => {
+    it('extracts YYYY-MM-DD from ISO string', () => {
+        expect(formatDate('2026-03-19T12:00:00.000Z')).toBe('2026-03-19');
+    });
+    it('handles date-only string', () => {
+        expect(formatDate('2025-01-01')).toBe('2025-01-01');
+    });
+    it('returns dash for empty string', () => {
+        expect(formatDate('')).toBe('-');
+    });
+    it('returns dash for undefined', () => {
+        expect(formatDate(undefined)).toBe('-');
+    });
+});
+describe('itunesFetch', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('returns parsed JSON on success', async () => {
+        const mockData = { resultCount: 1, results: [{ collectionId: 123 }] };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockData),
+        }));
+        const result = await itunesFetch('/search?term=test&media=podcast&limit=1');
+        expect(result).toEqual(mockData);
+    });
+    it('throws CliError on HTTP error', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+        }));
+        await expect(itunesFetch('/search?term=test')).rejects.toThrow('iTunes API HTTP 403');
+    });
+});

package/vendor/opencli/dist/clis/arxiv/paper.d.ts

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

package/vendor/opencli/dist/clis/arxiv/paper.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { arxivFetch, parseEntries } from './utils.js';
+cli({
+    site: 'arxiv',
+    name: 'paper',
+    description: 'Get arXiv paper details by ID',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'arXiv paper ID (e.g. 1706.03762)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published', 'abstract', 'url'],
+    func: async (_page, args) => {
+        const xml = await arxivFetch(`id_list=${encodeURIComponent(args.id)}`);
+        const entries = parseEntries(xml);
+        if (!entries.length)
+            throw new CliError('NOT_FOUND', `Paper ${args.id} not found`, 'Check the arXiv ID format, e.g. 1706.03762');
+        return entries;
+    },
+});

package/vendor/opencli/dist/clis/arxiv/search.d.ts

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

package/vendor/opencli/dist/clis/arxiv/search.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { arxivFetch, parseEntries } from './utils.js';
+cli({
+    site: 'arxiv',
+    name: 'search',
+    description: 'Search arXiv papers',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "attention is all you need")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results (max 25)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published', 'url'],
+    func: async (_page, args) => {
+        const limit = Math.max(1, Math.min(Number(args.limit), 25));
+        const query = encodeURIComponent(`all:${args.query}`);
+        const xml = await arxivFetch(`search_query=${query}&max_results=${limit}&sortBy=relevance`);
+        const entries = parseEntries(xml);
+        if (!entries.length)
+            throw new CliError('NOT_FOUND', 'No papers found', 'Try a different keyword');
+        return entries.map(e => ({ id: e.id, title: e.title, authors: e.authors, published: e.published, url: e.url }));
+    },
+});

package/vendor/opencli/dist/clis/arxiv/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * arXiv adapter utilities.
+ *
+ * arXiv exposes a public Atom/XML API — no key required.
+ * https://info.arxiv.org/help/api/index.html
+ */
+export declare const ARXIV_BASE = "https://export.arxiv.org/api/query";
+export declare function arxivFetch(params: string): Promise<string>;
+export interface ArxivEntry {
+    id: string;
+    title: string;
+    authors: string;
+    abstract: string;
+    published: string;
+    url: string;
+}
+/** Parse Atom XML feed into structured entries. */
+export declare function parseEntries(xml: string): ArxivEntry[];

package/vendor/opencli/dist/clis/arxiv/utils.js

@@ -0,0 +1,49 @@
+/**
+ * arXiv adapter utilities.
+ *
+ * arXiv exposes a public Atom/XML API — no key required.
+ * https://info.arxiv.org/help/api/index.html
+ */
+import { CliError } from '../../errors.js';
+export const ARXIV_BASE = 'https://export.arxiv.org/api/query';
+export async function arxivFetch(params) {
+    const resp = await fetch(`${ARXIV_BASE}?${params}`);
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `arXiv API HTTP ${resp.status}`, 'Check your search term or paper ID');
+    }
+    return resp.text();
+}
+/** Extract the text content of the first matching XML tag. */
+function extract(xml, tag) {
+    const m = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+    return m ? m[1].trim() : '';
+}
+/** Extract all text contents of a repeated XML tag. */
+function extractAll(xml, tag) {
+    const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'g');
+    const results = [];
+    let m;
+    while ((m = re.exec(xml)) !== null)
+        results.push(m[1].trim());
+    return results;
+}
+/** Parse Atom XML feed into structured entries. */
+export function parseEntries(xml) {
+    const entryRe = /<entry>([\s\S]*?)<\/entry>/g;
+    const entries = [];
+    let m;
+    while ((m = entryRe.exec(xml)) !== null) {
+        const e = m[1];
+        const rawId = extract(e, 'id');
+        const arxivId = rawId.replace(/^https?:\/\/arxiv\.org\/abs\//, '').replace(/v\d+$/, '');
+        entries.push({
+            id: arxivId,
+            title: extract(e, 'title').replace(/\s+/g, ' '),
+            authors: extractAll(e, 'name').slice(0, 3).join(', '),
+            abstract: (() => { const s = extract(e, 'summary').replace(/\s+/g, ' '); return s.length > 200 ? s.slice(0, 200) + '...' : s; })(),
+            published: extract(e, 'published').slice(0, 10),
+            url: `https://arxiv.org/abs/${arxivId}`,
+        });
+    }
+    return entries;
+}

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

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

package/vendor/opencli/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/vendor/opencli/dist/clis/band/mentions.d.ts

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

package/vendor/opencli/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/vendor/opencli/dist/clis/band/post.d.ts

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