@jackwener/opencli 1.5.8 → 1.5.9

package/skills/opencli-usage/public-api.md

@@ -0,0 +1,149 @@
+# Public API Commands
+
+Commands that work without browser or authentication.
+
+## Hacker News
+
+```bash
+opencli hackernews top --limit 10        # Top stories
+opencli hackernews new --limit 10        # Newest stories
+opencli hackernews best --limit 10       # Best stories
+opencli hackernews ask --limit 10        # Ask HN posts
+opencli hackernews show --limit 10       # Show HN posts
+opencli hackernews jobs --limit 10       # Job postings
+opencli hackernews search "rust"         # 搜索 (query positional)
+opencli hackernews user dang             # 用户资料 (username positional)
+```
+
+## V2EX (Public Features)
+
+```bash
+opencli v2ex hot --limit 10              # 热门话题
+opencli v2ex latest --limit 10           # 最新话题
+opencli v2ex topic 1024                  # 主题详情 (id positional)
+opencli v2ex node python                 # 节点话题列表 (name positional)
+opencli v2ex nodes --limit 30            # 所有节点列表
+opencli v2ex member username             # 用户资料 (username positional)
+opencli v2ex user username               # 用户发帖列表 (username positional)
+opencli v2ex replies 1024                # 主题回复列表 (id positional)
+```
+
+## BBC News
+
+```bash
+opencli bbc news --limit 10             # BBC News RSS headlines
+```
+
+## Sina Finance
+
+```bash
+opencli sinafinance news --limit 10 --type 1  # 7x24实时快讯
+# Types: 0=全部 1=A股 2=宏观 3=公司 4=数据 5=市场 6=国际 7=观点 8=央行 9=其它
+```
+
+## Lobsters
+
+```bash
+opencli lobsters hot --limit 10           # 热门
+opencli lobsters newest --limit 10        # 最新
+opencli lobsters active --limit 10        # 活跃
+opencli lobsters tag rust                 # 按标签筛选 (tag positional)
+```
+
+## Google
+
+```bash
+opencli google news --limit 10            # 新闻
+opencli google search "AI"                # 搜索 (query positional)
+opencli google suggest "AI"               # 搜索建议 (query positional)
+opencli google trends                     # 趋势
+```
+
+## DEV.to
+
+```bash
+opencli devto top --limit 10              # 热门文章
+opencli devto tag javascript --limit 10   # 按标签 (tag positional)
+opencli devto user username               # 用户文章 (username positional)
+```
+
+## Steam
+
+```bash
+opencli steam top-sellers --limit 10      # 热销游戏
+```
+
+## Apple Podcasts
+
+```bash
+opencli apple-podcasts top --limit 10     # 热门播客排行榜 (支持 --country us/cn/gb/jp)
+opencli apple-podcasts search "科技"       # 搜索播客 (query positional)
+opencli apple-podcasts episodes 12345     # 播客剧集列表 (id positional)
+```
+
+## arXiv
+
+```bash
+opencli arxiv search "attention"          # 搜索论文 (query positional)
+opencli arxiv paper 1706.03762            # 论文详情 (id positional)
+```
+
+## StackOverflow
+
+```bash
+opencli stackoverflow hot --limit 10     # 热门问题
+opencli stackoverflow search "typescript"  # 搜索 (query positional)
+opencli stackoverflow bounties --limit 10  # 悬赏问题
+```
+
+## Xiaoyuzhou (小宇宙)
+
+```bash
+opencli xiaoyuzhou podcast 12345          # 播客资料 (id positional)
+opencli xiaoyuzhou podcast-episodes 12345 # 播客剧集列表 (id positional)
+opencli xiaoyuzhou episode 12345          # 单集详情 (id positional)
+```
+
+## Wikipedia
+
+```bash
+opencli wikipedia search "AI"             # 搜索 (query positional)
+opencli wikipedia summary "Python"        # 摘要 (title positional)
+```
+
+## Bloomberg (RSS)
+
+```bash
+opencli bloomberg main --limit 10         # Bloomberg 首页头条
+opencli bloomberg markets --limit 10      # 市场新闻
+opencli bloomberg tech --limit 10         # 科技新闻
+opencli bloomberg politics --limit 10     # 政治新闻
+opencli bloomberg economics --limit 10    # 经济新闻
+opencli bloomberg opinions --limit 10     # 观点
+opencli bloomberg industries --limit 10   # 行业新闻
+opencli bloomberg businessweek --limit 10 # Businessweek
+opencli bloomberg feeds                   # 列出所有 RSS feed 别名
+```
+
+## Dictionary
+
+```bash
+opencli dictionary search "serendipity"   # 单词释义 (word positional)
+opencli dictionary synonyms "happy"       # 近义词 (word positional)
+opencli dictionary examples "ubiquitous"  # 例句 (word positional)
+```
+
+## HuggingFace
+
+```bash
+opencli hf top --limit 10                # 热门模型
+```
+
+## Product Hunt
+
+```bash
+opencli producthunt today --limit 10      # 今日产品
+opencli producthunt week --limit 10       # 本周产品
+opencli producthunt month --limit 10      # 本月产品
+opencli producthunt search "AI"           # 搜索产品 (query positional)
+```

package/src/browser/base-page.ts

@@ -0,0 +1,197 @@
+/**
+ * BasePage — shared IPage method implementations for DOM helpers.
+ *
+ * Both Page (daemon-backed) and CDPPage (direct CDP) execute JS the same way
+ * for DOM operations. This base class deduplicates ~200 lines of identical
+ * click/type/scroll/wait/snapshot/interceptor methods.
+ *
+ * Subclasses implement the transport-specific methods: goto, evaluate,
+ * getCookies, screenshot, tabs, etc.
+ */
+
+import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
+import {
+  clickJs,
+  typeTextJs,
+  pressKeyJs,
+  waitForTextJs,
+  waitForCaptureJs,
+  waitForSelectorJs,
+  scrollJs,
+  autoScrollJs,
+  networkRequestsJs,
+  waitForDomStableJs,
+} from './dom-helpers.js';
+import { formatSnapshot } from '../snapshotFormatter.js';
+
+export abstract class BasePage implements IPage {
+  protected _lastUrl: string | null = null;
+
+  // ── Transport-specific methods (must be implemented by subclasses) ──
+
+  abstract goto(url: string, options?: { waitUntil?: 'load' | 'none'; settleMs?: number }): Promise<void>;
+  abstract evaluate(js: string): Promise<unknown>;
+  abstract getCookies(opts?: { domain?: string; url?: string }): Promise<BrowserCookie[]>;
+  abstract screenshot(options?: ScreenshotOptions): Promise<string>;
+  abstract tabs(): Promise<unknown[]>;
+  abstract closeTab(index?: number): Promise<void>;
+  abstract newTab(): Promise<void>;
+  abstract selectTab(index: number): Promise<void>;
+
+  // ── Shared DOM helper implementations ──
+
+  async click(ref: string): Promise<void> {
+    await this.evaluate(clickJs(ref));
+  }
+
+  async typeText(ref: string, text: string): Promise<void> {
+    await this.evaluate(typeTextJs(ref, text));
+  }
+
+  async pressKey(key: string): Promise<void> {
+    await this.evaluate(pressKeyJs(key));
+  }
+
+  async scrollTo(ref: string): Promise<unknown> {
+    return this.evaluate(scrollToRefJs(ref));
+  }
+
+  async getFormState(): Promise<Record<string, unknown>> {
+    return (await this.evaluate(getFormStateJs())) as Record<string, unknown>;
+  }
+
+  async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
+    await this.evaluate(scrollJs(direction, amount));
+  }
+
+  async autoScroll(options?: { times?: number; delayMs?: number }): Promise<void> {
+    const times = options?.times ?? 3;
+    const delayMs = options?.delayMs ?? 2000;
+    await this.evaluate(autoScrollJs(times, delayMs));
+  }
+
+  async networkRequests(includeStatic: boolean = false): Promise<unknown[]> {
+    const result = await this.evaluate(networkRequestsJs(includeStatic));
+    return Array.isArray(result) ? result : [];
+  }
+
+  async consoleMessages(_level: string = 'info'): Promise<unknown[]> {
+    return [];
+  }
+
+  async wait(options: number | WaitOptions): Promise<void> {
+    if (typeof options === 'number') {
+      if (options >= 1) {
+        try {
+          const maxMs = options * 1000;
+          await this.evaluate(waitForDomStableJs(maxMs, Math.min(500, maxMs)));
+          return;
+        } catch {
+          // Fallback: fixed sleep
+        }
+      }
+      await new Promise(resolve => setTimeout(resolve, options * 1000));
+      return;
+    }
+    if (typeof options.time === 'number') {
+      await new Promise(resolve => setTimeout(resolve, options.time! * 1000));
+      return;
+    }
+    if (options.selector) {
+      const timeout = (options.timeout ?? 10) * 1000;
+      await this.evaluate(waitForSelectorJs(options.selector, timeout));
+      return;
+    }
+    if (options.text) {
+      const timeout = (options.timeout ?? 30) * 1000;
+      await this.evaluate(waitForTextJs(options.text, timeout));
+    }
+  }
+
+  async snapshot(opts: SnapshotOptions = {}): Promise<unknown> {
+    const snapshotJs = generateSnapshotJs({
+      viewportExpand: opts.viewportExpand ?? 800,
+      maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
+      interactiveOnly: opts.interactive ?? false,
+      maxTextLength: opts.maxTextLength ?? 120,
+      includeScrollInfo: true,
+      bboxDedup: true,
+    });
+
+    try {
+      return await this.evaluate(snapshotJs);
+    } catch {
+      return this._basicSnapshot(opts);
+    }
+  }
+
+  async getCurrentUrl(): Promise<string | null> {
+    if (this._lastUrl) return this._lastUrl;
+    try {
+      const current = await this.evaluate('window.location.href');
+      if (typeof current === 'string' && current) {
+        this._lastUrl = current;
+        return current;
+      }
+    } catch {
+      // Best-effort
+    }
+    return null;
+  }
+
+  async installInterceptor(pattern: string): Promise<void> {
+    const { generateInterceptorJs } = await import('../interceptor.js');
+    await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
+      arrayName: '__opencli_xhr',
+      patchGuard: '__opencli_interceptor_patched',
+    }));
+  }
+
+  async getInterceptedRequests(): Promise<unknown[]> {
+    const { generateReadInterceptedJs } = await import('../interceptor.js');
+    const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
+    return Array.isArray(result) ? result : [];
+  }
+
+  async waitForCapture(timeout: number = 10): Promise<void> {
+    const maxMs = timeout * 1000;
+    await this.evaluate(waitForCaptureJs(maxMs));
+  }
+
+  /** Fallback basic snapshot */
+  protected async _basicSnapshot(opts: Pick<SnapshotOptions, 'interactive' | 'compact' | 'maxDepth' | 'raw'> = {}): Promise<unknown> {
+    const maxDepth = Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200));
+    const code = `
+      (async () => {
+        function buildTree(node, depth) {
+          if (depth > ${maxDepth}) return '';
+          const role = node.getAttribute?.('role') || node.tagName?.toLowerCase() || 'generic';
+          const name = node.getAttribute?.('aria-label') || node.getAttribute?.('alt') || node.textContent?.trim().slice(0, 80) || '';
+          const isInteractive = ['a', 'button', 'input', 'select', 'textarea'].includes(node.tagName?.toLowerCase()) || node.getAttribute?.('tabindex') != null;
+
+          ${opts.interactive ? 'if (!isInteractive && !node.children?.length) return "";' : ''}
+
+          let indent = '  '.repeat(depth);
+          let line = indent + role;
+          if (name) line += ' "' + name.replace(/"/g, '\\\\\\"') + '"';
+          if (node.tagName?.toLowerCase() === 'a' && node.href) line += ' [' + node.href + ']';
+          if (node.tagName?.toLowerCase() === 'input') line += ' [' + (node.type || 'text') + ']';
+
+          let result = line + '\\n';
+          if (node.children) {
+            for (const child of node.children) {
+              result += buildTree(child, depth + 1);
+            }
+          }
+          return result;
+        }
+        return buildTree(document.body, 0);
+      })()
+    `;
+    const raw = await this.evaluate(code);
+    if (opts.raw) return raw;
+    if (typeof raw === 'string') return formatSnapshot(raw, opts);
+    return raw;
+  }
+}

package/src/browser/cdp.ts

@@ -11,25 +11,14 @@
 import { WebSocket, type RawData } from 'ws';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
-import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import type { BrowserCookie, IPage, ScreenshotOptions } from '../types.js';
 import type { IBrowserFactory } from '../runtime.js';
 import { wrapForEval } from './utils.js';
-import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import { generateStealthJs } from './stealth.js';
-import {
-  clickJs,
-  typeTextJs,
-  pressKeyJs,
-  waitForTextJs,
-  scrollJs,
-  autoScrollJs,
-  networkRequestsJs,
-  waitForDomStableJs,
-  waitForCaptureJs,
-  waitForSelectorJs,
-} from './dom-helpers.js';
+import { waitForDomStableJs } from './dom-helpers.js';
 import { isRecord, saveBase64ToFile } from '../utils.js';
 import { getAllElectronApps } from '../electron-apps.js';
+import { BasePage } from './base-page.js';
 
 export interface CDPTarget {
   type?: string;
@@ -174,10 +163,11 @@ export class CDPBridge implements IBrowserFactory {
   }
 }
 
-class CDPPage implements IPage {
+class CDPPage extends BasePage {
   private _pageEnabled = false;
-  private _lastUrl: string | null = null;
-  constructor(private bridge: CDPBridge) {}
+  constructor(private bridge: CDPBridge) {
+    super();
+  }
 
   async goto(url: string, options?: { waitUntil?: 'load' | 'none'; settleMs?: number }): Promise<void> {
     if (!this._pageEnabled) {
@@ -216,78 +206,6 @@ class CDPPage implements IPage {
       : cookies;
   }
 
-  async snapshot(opts: SnapshotOptions = {}): Promise<unknown> {
-    const snapshotJs = generateSnapshotJs({
-      viewportExpand: opts.viewportExpand ?? 800,
-      maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
-      interactiveOnly: opts.interactive ?? false,
-      maxTextLength: opts.maxTextLength ?? 120,
-      includeScrollInfo: true,
-      bboxDedup: true,
-    });
-    return this.evaluate(snapshotJs);
-  }
-
-  async click(ref: string): Promise<void> {
-    await this.evaluate(clickJs(ref));
-  }
-
-  async typeText(ref: string, text: string): Promise<void> {
-    await this.evaluate(typeTextJs(ref, text));
-  }
-
-  async pressKey(key: string): Promise<void> {
-    await this.evaluate(pressKeyJs(key));
-  }
-
-  async scrollTo(ref: string): Promise<unknown> {
-    return this.evaluate(scrollToRefJs(ref));
-  }
-
-  async getFormState(): Promise<Record<string, unknown>> {
-    return (await this.evaluate(getFormStateJs())) as Record<string, unknown>;
-  }
-
-  async wait(options: number | WaitOptions): Promise<void> {
-    if (typeof options === 'number') {
-      if (options >= 1) {
-        try {
-          const maxMs = options * 1000;
-          await this.evaluate(waitForDomStableJs(maxMs, Math.min(500, maxMs)));
-          return;
-        } catch {
-          // Fallback: fixed sleep
-        }
-      }
-      await new Promise((resolve) => setTimeout(resolve, options * 1000));
-      return;
-    }
-    if (typeof options.time === 'number') {
-      const waitTime = options.time;
-      await new Promise((resolve) => setTimeout(resolve, waitTime * 1000));
-      return;
-    }
-    if (options.selector) {
-      const timeout = (options.timeout ?? 10) * 1000;
-      await this.evaluate(waitForSelectorJs(options.selector, timeout));
-      return;
-    }
-    if (options.text) {
-      const timeout = (options.timeout ?? 30) * 1000;
-      await this.evaluate(waitForTextJs(options.text, timeout));
-    }
-  }
-
-  async scroll(direction: string = 'down', amount: number = 500): Promise<void> {
-    await this.evaluate(scrollJs(direction, amount));
-  }
-
-  async autoScroll(options?: { times?: number; delayMs?: number }): Promise<void> {
-    const times = options?.times ?? 3;
-    const delayMs = options?.delayMs ?? 2000;
-    await this.evaluate(autoScrollJs(times, delayMs));
-  }
-
   async screenshot(options: ScreenshotOptions = {}): Promise<string> {
     const result = await this.bridge.send('Page.captureScreenshot', {
       format: options.format ?? 'png',
@@ -301,11 +219,6 @@ class CDPPage implements IPage {
     return base64;
   }
 
-  async networkRequests(includeStatic: boolean = false): Promise<unknown[]> {
-    const result = await this.evaluate(networkRequestsJs(includeStatic));
-    return Array.isArray(result) ? result : [];
-  }
-
   async tabs(): Promise<unknown[]> {
     return [];
   }
@@ -321,43 +234,6 @@ class CDPPage implements IPage {
   async selectTab(_index: number): Promise<void> {
     // Not supported in direct CDP mode
   }
-
-  async consoleMessages(_level?: string): Promise<unknown[]> {
-    return [];
-  }
-
-  async getCurrentUrl(): Promise<string | null> {
-    if (this._lastUrl) return this._lastUrl;
-    try {
-      const current = await this.evaluate('window.location.href');
-      if (typeof current === 'string' && current) {
-        this._lastUrl = current;
-        return current;
-      }
-    } catch {
-      // Best-effort: direct CDP sessions may not have a ready page yet.
-    }
-    return null;
-  }
-
-  async installInterceptor(pattern: string): Promise<void> {
-    const { generateInterceptorJs } = await import('../interceptor.js');
-    await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
-      arrayName: '__opencli_xhr',
-      patchGuard: '__opencli_interceptor_patched',
-    }));
-  }
-
-  async getInterceptedRequests(): Promise<unknown[]> {
-    const { generateReadInterceptedJs } = await import('../interceptor.js');
-    const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
-    return Array.isArray(result) ? result : [];
-  }
-
-  async waitForCapture(timeout: number = 10): Promise<void> {
-    const maxMs = timeout * 1000;
-    await this.evaluate(waitForCaptureJs(maxMs));
-  }
 }
 
 function isCookie(value: unknown): value is BrowserCookie {

package/src/browser/daemon-client.ts

@@ -7,6 +7,7 @@
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import type { BrowserSessionInfo } from '../types.js';
 import { sleep } from '../utils.js';
+import { isTransientBrowserError } from './errors.js';
 
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
@@ -19,7 +20,7 @@ function generateId(): string {
 
 export interface DaemonCommand {
   id: string;
-  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'bind-current';
+  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input';
   tabId?: number;
   code?: string;
   workspace?: string;
@@ -27,8 +28,6 @@ export interface DaemonCommand {
   op?: string;
   index?: number;
   domain?: string;
-  matchDomain?: string;
-  matchPathPrefix?: string;
   format?: 'png' | 'jpeg';
   quality?: number;
   fullPage?: boolean;
@@ -114,12 +113,7 @@ export async function sendCommand(
 
       if (!result.ok) {
         // Check if error is a transient extension issue worth retrying
-        const errMsg = result.error ?? '';
-        const isTransient = errMsg.includes('Extension disconnected')
-          || errMsg.includes('Extension not connected')
-          || errMsg.includes('attach failed')
-          || errMsg.includes('no longer exists');
-        if (isTransient && attempt < maxRetries) {
+        if (isTransientBrowserError(new Error(result.error ?? '')) && attempt < maxRetries) {
           // Longer delay for extension recovery (service worker restart)
           await sleep(1500);
           continue;
@@ -146,8 +140,3 @@ export async function listSessions(): Promise<BrowserSessionInfo[]> {
   const result = await sendCommand('sessions');
   return Array.isArray(result) ? result : [];
 }
-
-export async function bindCurrentTab(workspace: string, opts: { matchDomain?: string; matchPathPrefix?: string } = {}): Promise<unknown> {
-  return sendCommand('bind-current', { workspace, ...opts });
-}
-

package/src/browser/discover.ts

@@ -1,8 +1,5 @@
 /**
- * Daemon discovery — simplified from MCP server path discovery.
- *
- * Only needs to check if the daemon is running. No more file system
- * scanning for @playwright/mcp locations.
+ * Daemon discovery — checks if the daemon is running.
  */
 
 import { DEFAULT_DAEMON_PORT } from '../constants.js';

package/src/browser/errors.ts

@@ -8,6 +8,28 @@
 import { BrowserConnectError, type BrowserConnectKind } from '../errors.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 
+/**
+ * Transient browser error patterns — shared across daemon-client, pipeline executor,
+ * and page retry logic. These errors indicate temporary conditions (extension restart,
+ * service worker cycle, tab navigation) that are worth retrying.
+ */
+const TRANSIENT_ERROR_PATTERNS = [
+  'Extension disconnected',
+  'Extension not connected',
+  'attach failed',
+  'no longer exists',
+  'CDP connection',
+  'Daemon command failed',
+] as const;
+
+/**
+ * Check if an error message indicates a transient browser error worth retrying.
+ */
+export function isTransientBrowserError(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return TRANSIENT_ERROR_PATTERNS.some(pattern => msg.includes(pattern));
+}
+
 // Re-export so callers don't need to import from two places
 export type ConnectFailureKind = BrowserConnectKind;
 

package/src/browser/index.ts

@@ -6,7 +6,7 @@
  */
 
 export { Page } from './page.js';
-export { BrowserBridge } from './mcp.js';
+export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';