@jackwener/opencli 1.5.6 → 1.5.7

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/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/douyin/_shared/sts2.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { AuthRequiredError } from '../../../errors.js';
+import { getSts2Credentials } from './sts2.js';
+
+describe('douyin sts2 credentials', () => {
+  it('accepts top-level credential fields returned by creator center', async () => {
+    const page = {
+      evaluate: async () => ({
+        access_key_id: 'ak',
+        secret_access_key: 'sk',
+        session_token: 'token',
+        expired_time: 1_234_567_890,
+      }),
+    };
+
+    await expect(getSts2Credentials(page as never)).resolves.toEqual({
+      access_key_id: 'ak',
+      secret_access_key: 'sk',
+      session_token: 'token',
+      expired_time: 1_234_567_890,
+    });
+  });
+
+  it('still rejects responses without credential fields', async () => {
+    const page = {
+      evaluate: async () => ({ status_code: 8 }),
+    };
+
+    await expect(getSts2Credentials(page as never)).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+});

package/src/clis/douyin/_shared/sts2.ts

@@ -12,9 +12,17 @@ const STS2_URL =
  */
 export async function getSts2Credentials(page: IPage): Promise<Sts2Credentials> {
   const js = `fetch(${JSON.stringify(STS2_URL)}, { credentials: 'include' }).then(r => r.json())`;
-  const res = await page.evaluate(js) as { data: Sts2Credentials };
-  if (!res?.data?.access_key_id) {
+  const res = await page.evaluate(js) as Sts2Credentials | { data?: Sts2Credentials };
+  const credentials = (
+    typeof res === 'object' &&
+    res !== null &&
+    'data' in res &&
+    res.data
+  )
+    ? res.data
+    : (res as Sts2Credentials);
+  if (!credentials?.access_key_id) {
     throw new AuthRequiredError('creator.douyin.com', 'STS2 credentials missing');
   }
-  return res.data;
+  return credentials;
 }

package/src/clis/douyin/activities.test.ts

@@ -1,8 +1,21 @@
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { browserFetchMock } = vi.hoisted(() => ({
+  browserFetchMock: vi.fn(),
+}));
+
+vi.mock('./_shared/browser-fetch.js', () => ({
+  browserFetch: browserFetchMock,
+}));
+
 import { getRegistry } from '../../registry.js';
 import './activities.js';
 
 describe('douyin activities registration', () => {
+  beforeEach(() => {
+    browserFetchMock.mockReset();
+  });
+
   it('registers the activities command', () => {
     const registry = getRegistry();
     const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
@@ -22,4 +35,31 @@ describe('douyin activities registration', () => {
     const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
     expect(cmd?.strategy).toBe('cookie');
   });
+
+  it('maps the current activity payload shape returned by creator center', async () => {
+    const registry = getRegistry();
+    const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
+    expect(cmd?.func).toBeDefined();
+    if (!cmd?.func) throw new Error('douyin activities command not registered');
+
+    browserFetchMock.mockResolvedValueOnce({
+      activity_list: [
+        {
+          activity_id: '200',
+          activity_name: '超会玩派对',
+          show_end_time: '2026.05.31',
+        },
+      ],
+    });
+
+    const rows = await cmd.func({} as never, {});
+
+    expect(rows).toEqual([
+      {
+        activity_id: '200',
+        title: '超会玩派对',
+        end_time: '2026.05.31',
+      },
+    ]);
+  });
 });

package/src/clis/douyin/activities.ts

@@ -12,12 +12,21 @@ cli({
   func: async (page, _kwargs) => {
     const url = 'https://creator.douyin.com/web/api/media/activity/get/?aid=1128';
     const res = await browserFetch(page, 'GET', url) as {
-      activity_list: Array<{ activity_id: string; title: string; end_time: number }>
+      activity_list: Array<{
+        activity_id: string;
+        title?: string;
+        activity_name?: string;
+        end_time?: number;
+        show_end_time?: string;
+      }>
     };
     return (res.activity_list ?? []).map(a => ({
       activity_id: a.activity_id,
-      title: a.title,
-      end_time: new Date(a.end_time * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
+      title: a.title ?? a.activity_name ?? '',
+      end_time:
+        typeof a.end_time === 'number'
+          ? new Date(a.end_time * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' })
+          : (a.show_end_time ?? ''),
     }));
   },
 });