@jackwener/opencli 1.4.1 → 1.5.0

package/src/clis/36kr/search.ts

@@ -0,0 +1,78 @@
+/**
+ * 36kr article search — INTERCEPT strategy.
+ *
+ * Navigates to the 36kr search results page and scrapes rendered articles.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: '36kr',
+  name: 'search',
+  description: '搜索36氪文章',
+  domain: 'www.36kr.com',
+  strategy: Strategy.INTERCEPT,
+  args: [
+    { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "AI", "OpenAI")' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results (max 50)' },
+  ],
+  columns: ['rank', 'title', 'date', 'url'],
+  func: async (page: IPage, args) => {
+    const count = Math.min(Number(args.limit) || 20, 50);
+    const query = encodeURIComponent(String(args.query ?? ''));
+
+    await page.installInterceptor('36kr.com/api');
+    await page.goto(`https://www.36kr.com/search/articles/${query}`);
+    await page.wait(6);
+
+    const domItems: any = await page.evaluate(`
+      (() => {
+        const seen = new Set();
+        const results = [];
+        // article-item-title contains the clickable title link
+        const titleEls = document.querySelectorAll('.article-item-title a[href*="/p/"], .article-item-title[href*="/p/"]');
+        for (const el of titleEls) {
+          const href = el.getAttribute('href') || '';
+          const title = el.textContent?.trim() || '';
+          if (!title || seen.has(href)) continue;
+          seen.add(href);
+          // Look for date near the article item
+          const item = el.closest('[class*="article-item"]') || el.parentElement;
+          const dateEl = item?.querySelector('[class*="time"], [class*="date"], time');
+          const date = dateEl?.textContent?.trim() || '';
+          results.push({
+            title,
+            url: href.startsWith('http') ? href : 'https://36kr.com' + href,
+            date,
+          });
+        }
+        // Fallback: generic /p/ links with meaningful text
+        if (results.length === 0) {
+          const links = document.querySelectorAll('a[href*="/p/"]');
+          for (const el of links) {
+            const href = el.getAttribute('href') || '';
+            const title = el.textContent?.trim() || '';
+            if (!title || title.length < 8 || seen.has(href) || seen.has(title)) continue;
+            seen.add(href);
+            seen.add(title);
+            results.push({ title, url: href.startsWith('http') ? href : 'https://36kr.com' + href, date: '' });
+          }
+        }
+        return results;
+      })()
+    `);
+
+    const items = Array.isArray(domItems) ? (domItems as any[]) : [];
+    if (items.length === 0) {
+      throw new CliError('NO_DATA', 'No results found', `Try a different query or check your keyword`);
+    }
+
+    return items.slice(0, count).map((item: any, i: number) => ({
+      rank: i + 1,
+      title: item.title,
+      date: item.date,
+      url: item.url,
+    }));
+  },
+});

package/src/clis/bilibili/comments.test.ts

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { mockApiGet } = vi.hoisted(() => ({
+  mockApiGet: vi.fn(),
+}));
+
+vi.mock('./utils.js', () => ({
+  apiGet: mockApiGet,
+}));
+
+import { getRegistry } from '../../registry.js';
+import './comments.js';
+
+describe('bilibili comments', () => {
+  const command = getRegistry().get('bilibili/comments');
+
+  beforeEach(() => {
+    mockApiGet.mockReset();
+  });
+
+  it('resolves bvid to aid and fetches replies', async () => {
+    mockApiGet
+      .mockResolvedValueOnce({ data: { aid: 12345 } }) // view endpoint
+      .mockResolvedValueOnce({
+        data: {
+          replies: [
+            {
+              member: { uname: 'Alice' },
+              content: { message: 'Great video!' },
+              like: 42,
+              rcount: 3,
+              ctime: 1700000000,
+            },
+          ],
+        },
+      });
+
+    const result = await command!.func!({} as any, { bvid: 'BV1WtAGzYEBm', limit: 5 });
+
+    expect(mockApiGet).toHaveBeenNthCalledWith(1, {}, '/x/web-interface/view', { params: { bvid: 'BV1WtAGzYEBm' } });
+    expect(mockApiGet).toHaveBeenNthCalledWith(2, {}, '/x/v2/reply/main', {
+      params: { oid: 12345, type: 1, mode: 3, ps: 5 },
+      signed: true,
+    });
+
+    expect(result).toEqual([
+      {
+        rank: 1,
+        author: 'Alice',
+        text: 'Great video!',
+        likes: 42,
+        replies: 3,
+        time: new Date(1700000000 * 1000).toISOString().slice(0, 16).replace('T', ' '),
+      },
+    ]);
+  });
+
+  it('throws when aid cannot be resolved', async () => {
+    mockApiGet.mockResolvedValueOnce({ data: {} }); // no aid
+
+    await expect(command!.func!({} as any, { bvid: 'BV_invalid', limit: 5 })).rejects.toThrow(
+      'Cannot resolve aid for bvid: BV_invalid',
+    );
+  });
+
+  it('returns empty array when replies is missing', async () => {
+    mockApiGet
+      .mockResolvedValueOnce({ data: { aid: 99 } })
+      .mockResolvedValueOnce({ data: {} }); // no replies key
+
+    const result = await command!.func!({} as any, { bvid: 'BV1xxx', limit: 5 });
+    expect(result).toEqual([]);
+  });
+
+  it('caps limit at 50', async () => {
+    mockApiGet
+      .mockResolvedValueOnce({ data: { aid: 1 } })
+      .mockResolvedValueOnce({ data: { replies: [] } });
+
+    await command!.func!({} as any, { bvid: 'BV1xxx', limit: 999 });
+
+    expect(mockApiGet).toHaveBeenNthCalledWith(2, {}, '/x/v2/reply/main', {
+      params: { oid: 1, type: 1, mode: 3, ps: 50 },
+      signed: true,
+    });
+  });
+
+  it('collapses newlines in comment text', async () => {
+    mockApiGet
+      .mockResolvedValueOnce({ data: { aid: 1 } })
+      .mockResolvedValueOnce({
+        data: {
+          replies: [
+            { member: { uname: 'Bob' }, content: { message: 'line1\nline2\nline3' }, like: 0, rcount: 0, ctime: 0 },
+          ],
+        },
+      });
+
+    const result = (await command!.func!({} as any, { bvid: 'BV1xxx', limit: 5 })) as any[];
+    expect(result[0].text).toBe('line1 line2 line3');
+  });
+});

package/src/clis/bilibili/comments.ts

@@ -0,0 +1,44 @@
+/**
+ * Bilibili comments — fetches top-level replies via the official API with WBI signing.
+ * Uses the /x/v2/reply/main endpoint which is stable and doesn't depend on DOM structure.
+ */
+
+import { cli, Strategy } from '../../registry.js';
+import { apiGet } from './utils.js';
+
+cli({
+  site: 'bilibili',
+  name: 'comments',
+  description: '获取 B站视频评论（使用官方 API + WBI 签名）',
+  domain: 'www.bilibili.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bvid', required: true, positional: true, help: 'Video BV ID (e.g. BV1WtAGzYEBm)' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of comments (max 50)' },
+  ],
+  columns: ['rank', 'author', 'text', 'likes', 'replies', 'time'],
+  func: async (page, kwargs) => {
+    const bvid = String(kwargs.bvid).trim();
+    const limit = Math.min(Number(kwargs.limit) || 20, 50);
+
+    // Resolve bvid → aid (required by reply API)
+    const view = await apiGet(page, '/x/web-interface/view', { params: { bvid } });
+    const aid = view?.data?.aid;
+    if (!aid) throw new Error(`Cannot resolve aid for bvid: ${bvid}`);
+
+    const payload = await apiGet(page, '/x/v2/reply/main', {
+      params: { oid: aid, type: 1, mode: 3, ps: limit },
+      signed: true,
+    });
+
+    const replies: any[] = payload?.data?.replies ?? [];
+    return replies.slice(0, limit).map((r: any, i: number) => ({
+      rank: i + 1,
+      author: r.member?.uname ?? '',
+      text: (r.content?.message ?? '').replace(/\n/g, ' ').trim(),
+      likes: r.like ?? 0,
+      replies: r.rcount ?? 0,
+      time: new Date(r.ctime * 1000).toISOString().slice(0, 16).replace('T', ' '),
+    }));
+  },
+});

package/src/clis/chatgpt/ask.ts

@@ -2,7 +2,7 @@ import { execSync, spawnSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
 import { ConfigError } from '../../errors.js';
 import type { IPage } from '../../types.js';
-import { getVisibleChatMessages } from './ax.js';
+import { activateChatGPT, getVisibleChatMessages, selectModel, MODEL_CHOICES, isGenerating } from './ax.js';
 
 export const askCommand = cli({
   site: 'chatgpt',
@@ -13,6 +13,7 @@ export const askCommand = cli({
   browser: false,
   args: [
     { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+    { name: 'model', required: false, help: 'Model/mode to use: auto, instant, thinking, 5.2-instant, 5.2-thinking', choices: MODEL_CHOICES },
     { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
   ],
   columns: ['Role', 'Text'],
@@ -22,8 +23,15 @@ export const askCommand = cli({
     }
 
     const text = kwargs.text as string;
+    const model = kwargs.model as string | undefined;
     const timeout = parseInt(kwargs.timeout as string, 10) || 30;
 
+    // Switch model before sending if requested
+    if (model) {
+      activateChatGPT();
+      selectModel(model);
+    }
+
     // Backup clipboard
     let clipBackup = '';
     try { clipBackup = execSync('pbpaste', { encoding: 'utf-8' }); } catch {}
@@ -31,8 +39,7 @@ export const askCommand = cli({
 
     // Send the message
     spawnSync('pbcopy', { input: text });
-    execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-    execSync("osascript -e 'delay 0.5'");
+    activateChatGPT();
 
     const cmd = "osascript " +
                 "-e 'tell application \"System Events\"' " +
@@ -45,25 +52,32 @@ export const askCommand = cli({
     // Restore clipboard after the prompt is sent.
     if (clipBackup) spawnSync('pbcopy', { input: clipBackup });
 
-    // Wait for response, then read the latest visible assistant message from the AX tree.
-    const pollInterval = 1;
+    // Wait for response: poll until ChatGPT stops generating ("Stop generating" button disappears),
+    // then read the final response text.
+    const pollInterval = 2;
     const maxPolls = Math.ceil(timeout / pollInterval);
     let response = '';
+    let generationStarted = false;
 
     for (let i = 0; i < maxPolls; i++) {
       execSync(`sleep ${pollInterval}`);
-      execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-      execSync("osascript -e 'delay 0.2'");
+      const generating = isGenerating();
+      if (generating) {
+        generationStarted = true;
+        continue;
+      }
+      // Generation finished (or never started yet)
+      if (!generationStarted && i < 3) continue; // give it a moment to start
 
+      // Read final response
+      activateChatGPT(0.3);
       const messagesNow = getVisibleChatMessages();
-      if (messagesNow.length <= messagesBefore.length) continue;
-
-      const newMessages = messagesNow.slice(messagesBefore.length);
-      const candidate = [...newMessages].reverse().find((message) => message !== text);
-      if (candidate) {
-        response = candidate;
-        break;
+      if (messagesNow.length > messagesBefore.length) {
+        const newMessages = messagesNow.slice(messagesBefore.length);
+        const candidate = [...newMessages].reverse().find((message) => message !== text);
+        if (candidate) response = candidate;
       }
+      break;
     }
 
     if (!response) {

package/src/clis/chatgpt/ax.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, execSync } from 'node:child_process';
 
 const AX_READ_SCRIPT = `
 import Cocoa
@@ -62,6 +62,185 @@ let data = try! JSONSerialization.data(withJSONObject: best, options: [])
 print(String(data: data, encoding: .utf8)!)
 `;
 
+const AX_MODEL_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func press(_ el: AXUIElement) {
+    AXUIElementPerformAction(el, kAXPressAction as CFString)
+}
+
+func findByDesc(_ el: AXUIElement, _ target: String, prefix: Bool = false, depth: Int = 0) -> AXUIElement? {
+    guard depth < 20 else { return nil }
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if prefix ? desc.hasPrefix(target) : (desc == target) { return el }
+    for c in children(el) {
+        if let found = findByDesc(c, target, prefix: prefix, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func findPopover(_ el: AXUIElement, depth: Int = 0) -> AXUIElement? {
+    guard depth < 20 else { return nil }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if role == "AXPopover" { return el }
+    for c in children(el) {
+        if let found = findPopover(c, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func pressEscape() {
+    let src = CGEventSource(stateID: .combinedSessionState)
+    if let esc = CGEvent(keyboardEventSource: src, virtualKey: 0x35, keyDown: true) { esc.post(tap: .cghidEventTap) }
+    if let esc = CGEvent(keyboardEventSource: src, virtualKey: 0x35, keyDown: false) { esc.post(tap: .cghidEventTap) }
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    fputs("ChatGPT not running\\n", stderr); exit(1)
+}
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    fputs("No focused ChatGPT window\\n", stderr); exit(1)
+}
+
+let args = CommandLine.arguments
+let target = args.count > 1 ? args[1] : ""
+let needsLegacy = args.count > 2 && args[2] == "legacy"
+
+// Step 1: Click the "Options" button to open the popover
+guard let optionsBtn = findByDesc(win, "Options") else {
+    fputs("Could not find Options button\\n", stderr); exit(1)
+}
+press(optionsBtn)
+Thread.sleep(forTimeInterval: 0.8)
+
+// Step 2: Find the popover that appeared, search ONLY within it
+guard let popover = findPopover(win) else {
+    pressEscape()
+    fputs("Popover did not appear\\n", stderr); exit(1)
+}
+
+// Step 3: If legacy, click "Legacy models" to expand submenu
+if needsLegacy {
+    guard let legacyBtn = findByDesc(popover, "Legacy models") else {
+        pressEscape()
+        fputs("Could not find Legacy models button\\n", stderr); exit(1)
+    }
+    press(legacyBtn)
+    Thread.sleep(forTimeInterval: 0.8)
+}
+
+// Step 4: Click the target model button within the popover (prefix match)
+guard let modelBtn = findByDesc(popover, target, prefix: true) else {
+    pressEscape()
+    fputs("Could not find button starting with '\\(target)' in popover\\n", stderr); exit(1)
+}
+press(modelBtn)
+print("Selected: \\(target)")
+`;
+
+const AX_GENERATING_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String, !v.isEmpty { return v }
+    return nil
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func hasButton(_ el: AXUIElement, desc target: String, depth: Int = 0) -> Bool {
+    guard depth < 15 else { return false }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if role == "AXButton" && desc == target { return true }
+    for c in children(el) {
+        if hasButton(c, desc: target, depth: depth + 1) { return true }
+    }
+    return false
+}
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    print("false"); exit(0)
+}
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    print("false"); exit(0)
+}
+print(hasButton(win, desc: "Stop generating") ? "true" : "false")
+`;
+
+type ModelChoice = 'auto' | 'instant' | 'thinking' | '5.2-instant' | '5.2-thinking';
+
+const MODEL_MAP: Record<ModelChoice, { desc: string; legacy?: boolean }> = {
+  'auto':         { desc: 'Auto' },
+  'instant':      { desc: 'Instant' },
+  'thinking':     { desc: 'Thinking' },
+  '5.2-instant':  { desc: 'GPT-5.2 Instant',  legacy: true },
+  '5.2-thinking': { desc: 'GPT-5.2 Thinking', legacy: true },
+};
+
+export const MODEL_CHOICES = Object.keys(MODEL_MAP) as ModelChoice[];
+
+export function activateChatGPT(delaySeconds: number = 0.5): void {
+  execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+  execSync(`osascript -e 'delay ${delaySeconds}'`);
+}
+
+export function selectModel(model: string): string {
+  const entry = MODEL_MAP[model as ModelChoice];
+  if (!entry) {
+    throw new Error(`Unknown model "${model}". Choose from: ${MODEL_CHOICES.join(', ')}`);
+  }
+  const swiftArgs = ['-', entry.desc];
+  if (entry.legacy) swiftArgs.push('legacy');
+
+  const output = execFileSync('swift', swiftArgs, {
+    input: AX_MODEL_SCRIPT,
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+  }).trim();
+  return output;
+}
+
+export function isGenerating(): boolean {
+  try {
+    const output = execFileSync('swift', ['-'], {
+      input: AX_GENERATING_SCRIPT,
+      encoding: 'utf-8',
+      maxBuffer: 10 * 1024 * 1024,
+    }).trim();
+    return output === 'true';
+  } catch {
+    return false;
+  }
+}
+
 export function getVisibleChatMessages(): string[] {
   const output = execFileSync('swift', ['-'], {
     input: AX_READ_SCRIPT,

package/src/clis/chatgpt/model.ts

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+import { ConfigError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
+
+export const modelCommand = cli({
+  site: 'chatgpt',
+  name: 'model',
+  description: 'Switch ChatGPT Desktop model/mode (auto, instant, thinking, 5.2-instant, 5.2-thinking)',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'model', required: true, positional: true, help: 'Model to switch to', choices: MODEL_CHOICES },
+  ],
+  columns: ['Status', 'Model'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (process.platform !== 'darwin') {
+      throw new ConfigError('ChatGPT Desktop integration requires macOS');
+    }
+
+    const model = kwargs.model as string;
+    activateChatGPT();
+    const result = selectModel(model);
+    return [{ Status: 'Success', Model: result }];
+  },
+});

package/src/clis/chatgpt/send.ts

@@ -2,6 +2,7 @@ import { execSync, spawnSync } from 'node:child_process';
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.js';
 import { getErrorMessage } from '../../errors.js';
+import { activateChatGPT, selectModel, MODEL_CHOICES } from './ax.js';
 
 export const sendCommand = cli({
   site: 'chatgpt',
@@ -10,11 +11,21 @@ export const sendCommand = cli({
   domain: 'localhost',
   strategy: Strategy.PUBLIC,
   browser: false,
-  args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+  args: [
+    { name: 'text', required: true, positional: true, help: 'Message to send' },
+    { name: 'model', required: false, help: 'Model/mode to use: auto, instant, thinking, 5.2-instant, 5.2-thinking', choices: MODEL_CHOICES },
+  ],
   columns: ['Status'],
   func: async (page: IPage | null, kwargs: any) => {
     const text = kwargs.text as string;
+    const model = kwargs.model as string | undefined;
     try {
+      // Switch model before sending if requested
+      if (model) {
+        activateChatGPT();
+        selectModel(model);
+      }
+
       // Backup current clipboard content
       let clipBackup = '';
       try {
@@ -23,17 +34,16 @@ export const sendCommand = cli({
 
       // Copy text to clipboard
       spawnSync('pbcopy', { input: text });
-      
-      execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
-      execSync("osascript -e 'delay 0.5'");
-      
+
+      activateChatGPT();
+
       const cmd = "osascript " +
                   "-e 'tell application \"System Events\"' " +
                   "-e 'keystroke \"v\" using command down' " +
                   "-e 'delay 0.2' " +
                   "-e 'keystroke return' " +
                   "-e 'end tell'";
-                     
+
       execSync(cmd);
 
       // Restore original clipboard content