@jackwener/opencli 1.5.5 → 1.5.7

package/src/clis/band/posts.ts

@@ -0,0 +1,106 @@
+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: {
+      date: string;
+      author: string;
+      content: string;
+      comments: number;
+      url: string;
+    }[] = 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/src/clis/bilibili/subtitle.test.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { AuthRequiredError, EmptyResultError } from '../../errors.js';
+
+const { mockApiGet } = vi.hoisted(() => ({
+  mockApiGet: vi.fn(),
+}));
+
+vi.mock('./utils.js', () => ({
+  apiGet: mockApiGet,
+}));
+
+import { getRegistry } from '../../registry.js';
+import './subtitle.js';
+
+describe('bilibili subtitle', () => {
+  const command = getRegistry().get('bilibili/subtitle');
+  const page = {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(),
+  } as any;
+
+  beforeEach(() => {
+    mockApiGet.mockReset();
+    page.goto.mockClear();
+    page.evaluate.mockReset();
+  });
+
+  it('throws AuthRequiredError when bilibili hides subtitles behind login', async () => {
+    page.evaluate.mockResolvedValueOnce(123456);
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        need_login_subtitle: true,
+        subtitle: {
+          subtitles: [],
+        },
+      },
+    });
+
+    await expect(command!.func!(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toSatisfy((err: Error) =>
+      err instanceof AuthRequiredError && /login|登录/i.test(err.message),
+    );
+  });
+
+  it('throws EmptyResultError when a video truly has no subtitles', async () => {
+    page.evaluate.mockResolvedValueOnce(123456);
+    mockApiGet.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        need_login_subtitle: false,
+        subtitle: {
+          subtitles: [],
+        },
+      },
+    });
+
+    await expect(command!.func!(page, { bvid: 'BV1GbXPBeEZm' })).rejects.toThrow(EmptyResultError);
+  });
+});

package/src/clis/bilibili/subtitle.ts

@@ -39,8 +39,12 @@ cli({
       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', '此视频没有发现外挂或智能字幕。');
     }
 

package/src/clis/chatwise/ask.ts

@@ -1,7 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import { SelectorError } from '../../errors.js';
 import type { IPage } from '../../types.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
 export const askCommand = cli({
   site: 'chatwise',
@@ -10,7 +9,6 @@ export const askCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
-  requiredEnv: chatwiseRequiredEnv,
   args: [
     { name: 'text', required: true, positional: true, help: 'Prompt to send' },
     { name: 'timeout', required: false, help: 'Max seconds to wait (default: 30)', default: '30' },

package/src/clis/chatwise/export.ts

@@ -1,7 +1,6 @@
 import * as fs from 'node:fs';
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
 export const exportCommand = cli({
   site: 'chatwise',
@@ -10,7 +9,6 @@ export const exportCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
-  requiredEnv: chatwiseRequiredEnv,
   args: [
     { name: 'output', required: false,  help: 'Output file (default: /tmp/chatwise-export.md)' },
   ],

package/src/clis/chatwise/history.ts

@@ -1,6 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
 export const historyCommand = cli({
   site: 'chatwise',
@@ -9,7 +8,6 @@ export const historyCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
-  requiredEnv: chatwiseRequiredEnv,
   args: [],
   columns: ['Index', 'Title'],
   func: async (page: IPage) => {

package/src/clis/chatwise/model.ts

@@ -1,7 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import { SelectorError } from '../../errors.js';
 import type { IPage } from '../../types.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
 export const modelCommand = cli({
   site: 'chatwise',
@@ -10,7 +9,6 @@ export const modelCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
-  requiredEnv: chatwiseRequiredEnv,
   args: [
     { name: 'model-name', required: false, positional: true, help: 'Model to switch to (e.g. gpt-4, claude-3)' },
   ],

package/src/clis/chatwise/new.ts

@@ -1,4 +1,3 @@
 import { makeNewCommand } from '../_shared/desktop-commands.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
-export const newCommand = makeNewCommand('chatwise', 'ChatWise conversation', { requiredEnv: chatwiseRequiredEnv });
+export const newCommand = makeNewCommand('chatwise', 'ChatWise conversation');

package/src/clis/chatwise/read.ts

@@ -1,6 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
 export const readCommand = cli({
   site: 'chatwise',
@@ -9,7 +8,6 @@ export const readCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
-  requiredEnv: chatwiseRequiredEnv,
   args: [],
   columns: ['Content'],
   func: async (page: IPage) => {

package/src/clis/chatwise/screenshot.ts

@@ -1,4 +1,3 @@
 import { makeScreenshotCommand } from '../_shared/desktop-commands.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
-export const screenshotCommand = makeScreenshotCommand('chatwise', 'ChatWise', { requiredEnv: chatwiseRequiredEnv });
+export const screenshotCommand = makeScreenshotCommand('chatwise', 'ChatWise');

package/src/clis/chatwise/send.ts

@@ -1,7 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import { SelectorError } from '../../errors.js';
 import type { IPage } from '../../types.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
 export const sendCommand = cli({
   site: 'chatwise',
@@ -10,7 +9,6 @@ export const sendCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
-  requiredEnv: chatwiseRequiredEnv,
   args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
   columns: ['Status', 'InjectedText'],
   func: async (page: IPage, kwargs: any) => {

package/src/clis/chatwise/status.ts

@@ -1,4 +1,3 @@
 import { makeStatusCommand } from '../_shared/desktop-commands.js';
-import { chatwiseRequiredEnv } from './shared.js';
 
-export const statusCommand = makeStatusCommand('chatwise', 'ChatWise Desktop', { requiredEnv: chatwiseRequiredEnv });
+export const statusCommand = makeStatusCommand('chatwise', 'ChatWise Desktop');

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

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './search.js';
+
+describe('ctrip search', () => {
+  const command = getRegistry().get('ctrip/search');
+
+  beforeEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('maps live endpoint results into ranked rows', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
+      Response: {
+        searchResults: [
+          {
+            displayName: '苏州, 江苏, 中国',
+            displayType: '城市',
+            commentScore: 0,
+            price: '',
+          },
+          {
+            word: '姑苏区',
+            type: '行政区',
+            cStar: 4.8,
+            minPrice: 320,
+          },
+        ],
+      },
+    }), { status: 200 })));
+
+    const result = await command!.func!(null as any, { query: '苏州', limit: 3 });
+    expect(result).toEqual([
+      {
+        rank: 1,
+        name: '苏州, 江苏, 中国',
+        type: '城市',
+        score: 0,
+        price: '',
+        url: '',
+      },
+      {
+        rank: 2,
+        name: '姑苏区',
+        type: '行政区',
+        score: 4.8,
+        price: 320,
+        url: '',
+      },
+    ]);
+  });
+
+  it('rejects empty queries', async () => {
+    await expect(command!.func!(null as any, { query: '   ', limit: 3 })).rejects.toThrow('Search keyword cannot be empty');
+  });
+
+  it('surfaces fetch failures as CliError', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('{}', { status: 503 })));
+
+    await expect(command!.func!(null as any, { query: '苏州', limit: 3 })).rejects.toMatchObject({
+      code: 'FETCH_ERROR',
+      message: 'ctrip search failed with status 503',
+    });
+  });
+
+  it('surfaces empty results as EmptyResultError', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
+      Response: { searchResults: [] },
+    }), { status: 200 })));
+
+    await expect(command!.func!(null as any, { query: '苏州', limit: 3 })).rejects.toThrow('ctrip search returned no data');
+  });
+});

package/src/clis/ctrip/search.ts

@@ -1,61 +1,111 @@
 /**
- * 携程旅行搜索 — browser cookie, multi-strategy.
+ * 携程旅行搜索 — public destination and hotel suggestion lookup.
  */
+import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
 import { cli, Strategy } from '../../registry.js';
 
+interface CtripSearchResultItem {
+  displayName?: string;
+  word?: string;
+  cityName?: string;
+  displayType?: string;
+  type?: string;
+  commentScore?: number | string;
+  cStar?: number | string;
+  price?: number | string;
+  minPrice?: number | string;
+}
+
+function clampLimit(raw: unknown, fallback = 15): number {
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(1, Math.min(Math.floor(parsed), 50));
+}
+
+function mapSearchResults(results: unknown[], limit: number) {
+  return results
+    .filter((item): item is CtripSearchResultItem => !!item && typeof item === 'object')
+    .slice(0, limit)
+    .map((item, index) => ({
+      rank: index + 1,
+      name: String(item.displayName || item.word || item.cityName || '').replace(/\s+/g, ' ').trim(),
+      type: String(item.displayType || item.type || '').replace(/\s+/g, ' ').trim(),
+      score: item.commentScore ?? item.cStar ?? '',
+      price: item.price ?? item.minPrice ?? '',
+      url: '',
+    }))
+    .filter((item) => item.name);
+}
+
 cli({
   site: 'ctrip',
   name: 'search',
-  description: '携程旅行搜索',
-  domain: 'www.ctrip.com',
-  strategy: Strategy.COOKIE,
+  description: '搜索携程目的地、景区和酒店联想结果',
+  strategy: Strategy.PUBLIC,
+  browser: false,
   args: [
     { name: 'query', required: true, positional: true, help: 'Search keyword (city or attraction)' },
     { name: 'limit', type: 'int', default: 15, help: 'Number of results' },
   ],
   columns: ['rank', 'name', 'type', 'score', 'price', 'url'],
-  func: async (page, kwargs) => {
-    const limit = kwargs.limit || 15;
-    await page.goto('https://www.ctrip.com');
-    await page.wait(2);
-    const data = await page.evaluate(`
-      (async () => {
-        const query = '${kwargs.query.replace(/'/g, "\\'")}';
-        const limit = ${limit};
-
-        // Strategy 1: Suggestion API
-        try {
-          const suggestUrl = 'https://m.ctrip.com/restapi/h5api/searchapp/search?action=onekeyali&keyword=' + encodeURIComponent(query);
-          const resp = await fetch(suggestUrl, {credentials: 'include'});
-          if (resp.ok) {
-            const d = await resp.json();
-            const raw = d.data || d.result || d;
-            if (raw && typeof raw === 'object') {
-              // Flatten all result categories
-              const items = [];
-              for (const key of Object.keys(raw)) {
-                const list = Array.isArray(raw[key]) ? raw[key] : [];
-                for (const item of list) {
-                  if (items.length >= limit) break;
-                  items.push({
-                    rank: items.length + 1,
-                    name: item.word || item.name || item.title || '',
-                    type: item.type || item.tpName || key,
-                    score: item.score || '',
-                    price: item.price || item.minPrice || '',
-                    url: item.url || item.surl || '',
-                  });
-                }
-              }
-              if (items.length > 0) return items;
-            }
-          }
-        } catch(e) {}
-
-        return {error: 'No results for: ' + query};
-      })()
-    `);
-    if (!Array.isArray(data)) return [];
-    return data;
+  func: async (_page, kwargs) => {
+    const query = String(kwargs.query || '').trim();
+    if (!query) {
+      throw new ArgumentError('Search keyword cannot be empty');
+    }
+
+    const limit = clampLimit(kwargs.limit);
+    const response = await fetch('https://m.ctrip.com/restapi/soa2/21881/json/gaHotelSearchEngine', {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({
+        keyword: query,
+        searchType: 'D',
+        platform: 'online',
+        pageID: '102001',
+        head: {
+          Locale: 'zh-CN',
+          LocaleController: 'zh_cn',
+          Currency: 'CNY',
+          PageId: '102001',
+          clientID: 'opencli-ctrip-search',
+          group: 'ctrip',
+          Frontend: {
+            sessionID: 1,
+            pvid: 1,
+          },
+          HotelExtension: {
+            group: 'CTRIP',
+            WebpSupport: false,
+          },
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new CliError(
+        'FETCH_ERROR',
+        `ctrip search failed with status ${response.status}`,
+        'Retry the command or verify ctrip.com is reachable',
+      );
+    }
+
+    const payload = await response.json();
+    const rawResults = Array.isArray(payload?.Response?.searchResults) ? payload.Response.searchResults : [];
+    const results = mapSearchResults(rawResults, limit);
+    if (!results.length) {
+      throw new EmptyResultError(
+        'ctrip search',
+        'Try a destination, scenic spot, or hotel keyword such as "苏州" or "朱家尖"',
+      );
+    }
+    return results;
   },
 });
+
+export const __test__ = {
+  clampLimit,
+  mapSearchResults,
+};

package/src/clis/doubao/detail.test.ts

@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockGetConversationDetail } = vi.hoisted(() => ({
+  mockGetConversationDetail: vi.fn(),
+}));
+
+vi.mock('./utils.js', async () => {
+  const actual = await vi.importActual<typeof import('./utils.js')>('./utils.js');
+  return {
+    ...actual,
+    getConversationDetail: mockGetConversationDetail,
+  };
+});
+
+import { getRegistry } from '../../registry.js';
+import './detail.js';
+
+describe('doubao detail', () => {
+  const detail = getRegistry().get('doubao/detail');
+
+  beforeEach(() => {
+    mockGetConversationDetail.mockReset();
+  });
+
+  it('returns meeting metadata even when the conversation has no chat messages', async () => {
+    mockGetConversationDetail.mockResolvedValue({
+      messages: [],
+      meeting: {
+        title: 'Weekly Sync',
+        time: '2026-03-28 10:00',
+      },
+    });
+
+    const result = await detail!.func!({} as any, { id: '1234567890' });
+
+    expect(result).toEqual([
+      { Role: 'Meeting', Text: 'Weekly Sync (2026-03-28 10:00)' },
+    ]);
+  });
+
+  it('still returns an error row for a truly empty conversation', async () => {
+    mockGetConversationDetail.mockResolvedValue({
+      messages: [],
+      meeting: null,
+    });
+
+    const result = await detail!.func!({} as any, { id: '1234567890' });
+
+    expect(result).toEqual([
+      { Role: 'System', Text: 'No messages found. Verify the conversation ID.' },
+    ]);
+  });
+});

package/src/clis/doubao/detail.ts

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { DOUBAO_DOMAIN, getConversationDetail, parseDoubaoConversationId } from './utils.js';
+
+export const detailCommand = cli({
+  site: 'doubao',
+  name: 'detail',
+  description: 'Read a specific Doubao conversation by ID',
+  domain: DOUBAO_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'id', required: true, positional: true, help: 'Conversation ID (numeric or full URL)' },
+  ],
+  columns: ['Role', 'Text'],
+  func: async (page: IPage, kwargs: Record<string, unknown>) => {
+    const conversationId = parseDoubaoConversationId(kwargs.id as string);
+
+    const { messages, meeting } = await getConversationDetail(page, conversationId);
+
+    if (messages.length === 0 && !meeting) {
+      return [{ Role: 'System', Text: 'No messages found. Verify the conversation ID.' }];
+    }
+
+    const result: Array<{ Role: string; Text: string }> = [];
+
+    if (meeting) {
+      result.push({
+        Role: 'Meeting',
+        Text: `${meeting.title}${meeting.time ? ` (${meeting.time})` : ''}`,
+      });
+    }
+
+    for (const m of messages) {
+      result.push({ Role: m.Role, Text: m.Text });
+    }
+
+    return result;
+  },
+});

package/src/clis/doubao/history.test.ts

@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockGetDoubaoConversationList } = vi.hoisted(() => ({
+  mockGetDoubaoConversationList: vi.fn(),
+}));
+
+vi.mock('./utils.js', async () => {
+  const actual = await vi.importActual<typeof import('./utils.js')>('./utils.js');
+  return {
+    ...actual,
+    getDoubaoConversationList: mockGetDoubaoConversationList,
+  };
+});
+
+import { getRegistry } from '../../registry.js';
+import './history.js';
+
+describe('doubao history', () => {
+  const history = getRegistry().get('doubao/history');
+
+  beforeEach(() => {
+    mockGetDoubaoConversationList.mockReset();
+  });
+
+  it('includes the conversation id in the tabular output', async () => {
+    mockGetDoubaoConversationList.mockResolvedValue([
+      {
+        Id: '1234567890123',
+        Title: 'Weekly Sync',
+        Url: 'https://www.doubao.com/chat/1234567890123',
+      },
+    ]);
+
+    const result = await history!.func!({} as any, {});
+
+    expect(result).toEqual([
+      {
+        Index: 1,
+        Id: '1234567890123',
+        Title: 'Weekly Sync',
+        Url: 'https://www.doubao.com/chat/1234567890123',
+      },
+    ]);
+  });
+});