@jackwener/opencli 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "publishConfig": {
     "access": "public"
   },
@@ -12,7 +12,9 @@
   },
   "scripts": {
     "dev": "tsx src/main.ts",
-    "build": "tsc",
+    "build": "tsc && npm run clean-yaml && npm run copy-yaml",
+    "clean-yaml": "find dist/clis -name '*.yaml' -o -name '*.yml' 2>/dev/null | xargs rm -f",
+    "copy-yaml": "find src/clis -name '*.yaml' -o -name '*.yml' | while read f; do d=\"dist/${f#src/}\"; mkdir -p \"$(dirname \"$d\")\"; cp \"$f\" \"$d\"; done",
     "start": "node dist/main.js",
     "typecheck": "tsc --noEmit",
     "lint": "tsc --noEmit",

package/src/browser.ts

@@ -36,7 +36,18 @@ export class Page {
     if (result?.content) {
       const textParts = result.content.filter((c: any) => c.type === 'text');
       if (textParts.length === 1) {
-        const text = textParts[0].text;
+        let text = textParts[0].text;
+        // MCP browser_evaluate returns: "[JSON]\n### Ran Playwright code\n```js\n...\n```"
+        // Strip the "### Ran Playwright code" suffix to get clean JSON
+        const codeMarker = text.indexOf('### Ran Playwright code');
+        if (codeMarker !== -1) {
+          text = text.slice(0, codeMarker).trim();
+        }
+        // Also handle "### Result\n[JSON]" format (some MCP versions)
+        const resultMarker = text.indexOf('### Result\n');
+        if (resultMarker !== -1) {
+          text = text.slice(resultMarker + '### Result\n'.length).trim();
+        }
         try { return JSON.parse(text); } catch { return text; }
       }
     }
@@ -115,6 +126,8 @@ export class PlaywrightMCP {
   private _lockAcquired = false;
   private _initialTabCount = 0;
 
+  private _page: Page | null = null;
+
   async connect(opts: { timeout?: number } = {}): Promise<Page> {
     await this._acquireLock();
     const timeout = opts.timeout ?? CONNECT_TIMEOUT;
@@ -137,6 +150,7 @@ export class PlaywrightMCP {
         (msg) => { if (this._proc?.stdin?.writable) this._proc.stdin.write(msg); },
         () => new Promise<any>((res) => { this._waiters.push(res); }),
       );
+      this._page = page;
 
       this._proc.stdout?.on('data', (chunk: Buffer) => {
         this._buffer += chunk.toString();
@@ -185,11 +199,29 @@ export class PlaywrightMCP {
 
   async close(): Promise<void> {
     try {
+      // Close tabs opened during this session (site tabs + extension tabs)
+      if (this._page && this._proc && !this._proc.killed) {
+        try {
+          const tabs = await this._page.tabs();
+          const tabStr = typeof tabs === 'string' ? tabs : JSON.stringify(tabs);
+          const allTabs = tabStr.match(/Tab (\d+)/g) || [];
+          const currentTabCount = allTabs.length;
+
+          // Close tabs in reverse order to avoid index shifting issues
+          // Keep the original tabs that existed before the command started
+          if (currentTabCount > this._initialTabCount && this._initialTabCount > 0) {
+            for (let i = currentTabCount - 1; i >= this._initialTabCount; i--) {
+              try { await this._page.closeTab(i); } catch {}
+            }
+          }
+        } catch {}
+      }
       if (this._proc && !this._proc.killed) {
         this._proc.kill('SIGTERM');
         await new Promise<void>((res) => { this._proc?.on('exit', () => res()); setTimeout(res, 3000); });
       }
     } finally {
+      this._page = null;
       this._releaseLock();
     }
   }

package/src/cascade.ts

@@ -0,0 +1,217 @@
+/**
+ * Strategy Cascade: automatic strategy downgrade chain.
+ *
+ * Probes an API endpoint starting from the simplest strategy (PUBLIC)
+ * and automatically downgrades through the strategy tiers until one works:
+ *
+ *   PUBLIC → COOKIE → HEADER → INTERCEPT → UI
+ *
+ * This eliminates the need for manual strategy selection — the system
+ * automatically finds the minimum-privilege strategy that works.
+ */
+
+import { Strategy } from './registry.js';
+
+/** Strategy cascade order (simplest → most complex) */
+const CASCADE_ORDER: Strategy[] = [
+  Strategy.PUBLIC,
+  Strategy.COOKIE,
+  Strategy.HEADER,
+  Strategy.INTERCEPT,
+  Strategy.UI,
+];
+
+interface ProbeResult {
+  strategy: Strategy;
+  success: boolean;
+  statusCode?: number;
+  hasData?: boolean;
+  error?: string;
+  responsePreview?: string;
+}
+
+interface CascadeResult {
+  bestStrategy: Strategy;
+  probes: ProbeResult[];
+  confidence: number;
+}
+
+/**
+ * Probe an endpoint with a specific strategy.
+ * Returns whether the probe succeeded and basic response info.
+ */
+export async function probeEndpoint(
+  page: any,
+  url: string,
+  strategy: Strategy,
+  opts: { timeout?: number } = {},
+): Promise<ProbeResult> {
+  const result: ProbeResult = { strategy, success: false };
+
+  try {
+    switch (strategy) {
+      case Strategy.PUBLIC: {
+        // Try direct fetch without browser (no credentials)
+        const js = `
+          async () => {
+            try {
+              const resp = await fetch(${JSON.stringify(url)});
+              const status = resp.status;
+              if (!resp.ok) return { status, ok: false };
+              const text = await resp.text();
+              let hasData = false;
+              try {
+                const json = JSON.parse(text);
+                hasData = !!json && (Array.isArray(json) ? json.length > 0 :
+                  typeof json === 'object' && Object.keys(json).length > 0);
+              } catch {}
+              return { status, ok: true, hasData, preview: text.slice(0, 200) };
+            } catch (e) { return { ok: false, error: e.message }; }
+          }
+        `;
+        const resp = await page.evaluate(js);
+        result.statusCode = resp?.status;
+        result.success = resp?.ok && resp?.hasData;
+        result.hasData = resp?.hasData;
+        result.responsePreview = resp?.preview;
+        break;
+      }
+
+      case Strategy.COOKIE: {
+        // Fetch with credentials: 'include' (uses browser cookies)
+        const js = `
+          async () => {
+            try {
+              const resp = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+              const status = resp.status;
+              if (!resp.ok) return { status, ok: false };
+              const text = await resp.text();
+              let hasData = false;
+              try {
+                const json = JSON.parse(text);
+                hasData = !!json && (Array.isArray(json) ? json.length > 0 :
+                  typeof json === 'object' && Object.keys(json).length > 0);
+                // Check for API-level error codes (common in Chinese sites)
+                if (json.code !== undefined && json.code !== 0) hasData = false;
+              } catch {}
+              return { status, ok: true, hasData, preview: text.slice(0, 200) };
+            } catch (e) { return { ok: false, error: e.message }; }
+          }
+        `;
+        const resp = await page.evaluate(js);
+        result.statusCode = resp?.status;
+        result.success = resp?.ok && resp?.hasData;
+        result.hasData = resp?.hasData;
+        result.responsePreview = resp?.preview;
+        break;
+      }
+
+      case Strategy.HEADER: {
+        // Fetch with credentials + try to extract common auth headers
+        const js = `
+          async () => {
+            try {
+              // Try to extract CSRF tokens from cookies
+              const cookies = document.cookie.split(';').map(c => c.trim());
+              const csrf = cookies.find(c => c.startsWith('ct0=') || c.startsWith('csrf_token=') || c.startsWith('_csrf='))?.split('=').slice(1).join('=');
+              
+              const headers = {};
+              if (csrf) {
+                headers['X-Csrf-Token'] = csrf;
+                headers['X-XSRF-Token'] = csrf;
+              }
+              
+              const resp = await fetch(${JSON.stringify(url)}, {
+                credentials: 'include',
+                headers
+              });
+              const status = resp.status;
+              if (!resp.ok) return { status, ok: false };
+              const text = await resp.text();
+              let hasData = false;
+              try {
+                const json = JSON.parse(text);
+                hasData = !!json && (Array.isArray(json) ? json.length > 0 :
+                  typeof json === 'object' && Object.keys(json).length > 0);
+                if (json.code !== undefined && json.code !== 0) hasData = false;
+              } catch {}
+              return { status, ok: true, hasData, preview: text.slice(0, 200) };
+            } catch (e) { return { ok: false, error: e.message }; }
+          }
+        `;
+        const resp = await page.evaluate(js);
+        result.statusCode = resp?.status;
+        result.success = resp?.ok && resp?.hasData;
+        result.hasData = resp?.hasData;
+        result.responsePreview = resp?.preview;
+        break;
+      }
+
+      case Strategy.INTERCEPT:
+      case Strategy.UI:
+        // These require specific implementation per-site
+        // Mark as needing manual implementation
+        result.success = false;
+        result.error = `Strategy ${strategy} requires site-specific implementation`;
+        break;
+    }
+  } catch (err: any) {
+    result.success = false;
+    result.error = err.message ?? String(err);
+  }
+
+  return result;
+}
+
+/**
+ * Run the cascade: try each strategy in order until one works.
+ * Returns the simplest working strategy.
+ */
+export async function cascadeProbe(
+  page: any,
+  url: string,
+  opts: { maxStrategy?: Strategy; timeout?: number } = {},
+): Promise<CascadeResult> {
+  const maxIdx = opts.maxStrategy
+    ? CASCADE_ORDER.indexOf(opts.maxStrategy)
+    : CASCADE_ORDER.indexOf(Strategy.HEADER); // Don't auto-try INTERCEPT/UI
+
+  const probes: ProbeResult[] = [];
+
+  for (let i = 0; i <= Math.min(maxIdx, CASCADE_ORDER.length - 1); i++) {
+    const strategy = CASCADE_ORDER[i];
+    const probe = await probeEndpoint(page, url, strategy, opts);
+    probes.push(probe);
+
+    if (probe.success) {
+      return {
+        bestStrategy: strategy,
+        probes,
+        confidence: 1.0 - (i * 0.1), // Higher confidence for simpler strategies
+      };
+    }
+  }
+
+  // None worked — default to COOKIE (most common for logged-in sites)
+  return {
+    bestStrategy: Strategy.COOKIE,
+    probes,
+    confidence: 0.3,
+  };
+}
+
+/**
+ * Render cascade results for display.
+ */
+export function renderCascadeResult(result: CascadeResult): string {
+  const lines = [
+    `Strategy Cascade: ${result.bestStrategy} (${(result.confidence * 100).toFixed(0)}% confidence)`,
+  ];
+  for (const probe of result.probes) {
+    const icon = probe.success ? '✅' : '❌';
+    const status = probe.statusCode ? ` [${probe.statusCode}]` : '';
+    const err = probe.error ? ` — ${probe.error}` : '';
+    lines.push(`  ${icon} ${probe.strategy}${status}${err}`);
+  }
+  return lines.join('\n');
+}

package/src/clis/index.ts

@@ -16,4 +16,7 @@ import './bilibili/user-videos.js';
 import './github/search.js';
 
 // zhihu
-import './zhihu/search.js';
+import './zhihu/question.js';
+
+// xiaohongshu
+import './xiaohongshu/search.js';

package/src/clis/reddit/hot.yaml

@@ -0,0 +1,46 @@
+site: reddit
+name: hot
+description: Reddit 热门帖子
+domain: www.reddit.com
+
+args:
+  subreddit:
+    type: str
+    default: ""
+    description: "Subreddit name (e.g. programming). Empty for frontpage"
+  limit:
+    type: int
+    default: 20
+    description: Number of posts
+
+pipeline:
+  - navigate: https://www.reddit.com
+
+  - evaluate: |
+      (async () => {
+        const sub = '${{ args.subreddit }}';
+        const path = sub ? '/r/' + sub + '/hot.json' : '/hot.json';
+        const res = await fetch(path + '?limit=${{ args.limit }}&raw_json=1', {
+          credentials: 'include'
+        });
+        const d = await res.json();
+        return (d?.data?.children || []).map(c => ({
+          title: c.data.title,
+          subreddit: c.data.subreddit_name_prefixed,
+          score: c.data.score,
+          comments: c.data.num_comments,
+          author: c.data.author,
+          url: 'https://www.reddit.com' + c.data.permalink,
+        }));
+      })()
+
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      subreddit: ${{ item.subreddit }}
+      score: ${{ item.score }}
+      comments: ${{ item.comments }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, title, subreddit, score, comments]

package/src/clis/v2ex/hot.yaml

@@ -2,6 +2,8 @@ site: v2ex
 name: hot
 description: V2EX 热门话题
 domain: www.v2ex.com
+strategy: public
+browser: false
 
 args:
   limit:
@@ -10,20 +12,14 @@ args:
     description: Number of topics
 
 pipeline:
-  - evaluate: |
-      (async () => {
-        const res = await fetch('https://www.v2ex.com/api/topics/hot.json');
-        return await res.json();
-      })()
+  - fetch:
+      url: https://www.v2ex.com/api/topics/hot.json
 
   - map:
       rank: ${{ index + 1 }}
       title: ${{ item.title }}
-      node: ${{ item.node?.title }}
-      author: ${{ item.member?.username }}
       replies: ${{ item.replies }}
-      url: ${{ item.url }}
 
   - limit: ${{ args.limit }}
 
-columns: [rank, title, node, author, replies]
+columns: [rank, title, replies]

package/src/clis/v2ex/latest.yaml

@@ -2,6 +2,8 @@ site: v2ex
 name: latest
 description: V2EX 最新话题
 domain: www.v2ex.com
+strategy: public
+browser: false
 
 args:
   limit:
@@ -10,19 +12,14 @@ args:
     description: Number of topics
 
 pipeline:
-  - evaluate: |
-      (async () => {
-        const res = await fetch('https://www.v2ex.com/api/topics/latest.json');
-        return await res.json();
-      })()
+  - fetch:
+      url: https://www.v2ex.com/api/topics/latest.json
 
   - map:
       rank: ${{ index + 1 }}
       title: ${{ item.title }}
-      node: ${{ item.node?.title }}
-      author: ${{ item.member?.username }}
       replies: ${{ item.replies }}
 
   - limit: ${{ args.limit }}
 
-columns: [rank, title, node, author, replies]
+columns: [rank, title, replies]

package/src/clis/v2ex/topic.yaml

@@ -0,0 +1,27 @@
+site: v2ex
+name: topic
+description: V2EX 主题详情和回复
+domain: www.v2ex.com
+strategy: public
+browser: false
+
+args:
+  id:
+    type: str
+    required: true
+    description: Topic ID
+
+pipeline:
+  - fetch:
+      url: https://www.v2ex.com/api/topics/show.json
+      params:
+        id: ${{ args.id }}
+
+  - map:
+      title: ${{ item.title }}
+      replies: ${{ item.replies }}
+      url: ${{ item.url }}
+
+  - limit: 1
+
+columns: [title, replies, url]

package/src/clis/xiaohongshu/feed.yaml

@@ -0,0 +1,32 @@
+site: xiaohongshu
+name: feed
+description: "小红书首页推荐 Feed (via Pinia Store Action)"
+domain: www.xiaohongshu.com
+strategy: intercept
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of items to return
+
+columns: [title, author, likes, type, url]
+
+pipeline:
+  - navigate: https://www.xiaohongshu.com/explore
+  - wait: 3
+  - tap:
+      store: feed
+      action: fetchFeeds
+      capture: homefeed
+      select: data.items
+      timeout: 8
+  - map:
+      id: ${{ item.id }}
+      title: ${{ item.note_card.display_title }}
+      type: ${{ item.note_card.type }}
+      author: ${{ item.note_card.user.nickname }}
+      likes: ${{ item.note_card.interact_info.liked_count }}
+      url: https://www.xiaohongshu.com/explore/${{ item.id }}
+  - limit: ${{ args.limit | default(20) }}

package/src/clis/xiaohongshu/notifications.yaml

@@ -0,0 +1,38 @@
+site: xiaohongshu
+name: notifications
+description: "小红书通知 (mentions/likes/connections)"
+domain: www.xiaohongshu.com
+strategy: intercept
+browser: true
+
+args:
+  type:
+    type: str
+    default: mentions
+    description: "Notification type: mentions, likes, or connections"
+  limit:
+    type: int
+    default: 20
+    description: Number of notifications to return
+
+columns: [rank, user, action, content, note, time]
+
+pipeline:
+  - navigate: https://www.xiaohongshu.com/notification
+  - wait: 3
+  - tap:
+      store: notification
+      action: getNotification
+      args:
+        - ${{ args.type | default('mentions') }}
+      capture: /you/
+      select: data.message_list
+      timeout: 8
+  - map:
+      rank: ${{ index + 1 }}
+      user: ${{ item.user_info.nickname }}
+      action: ${{ item.title }}
+      content: ${{ item.comment_info.content }}
+      note: ${{ item.item_info.content }}
+      time: ${{ item.time }}
+  - limit: ${{ args.limit | default(20) }}

package/src/clis/xiaohongshu/search.ts

@@ -0,0 +1,71 @@
+/**
+ * Xiaohongshu search — trigger search via Pinia store + XHR interception.
+ * Inspired by bb-sites/xiaohongshu/search.js but adapted for opencli pipeline.
+ */
+
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'xiaohongshu',
+  name: 'search',
+  description: '搜索小红书笔记',
+  domain: 'www.xiaohongshu.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'keyword', required: true, help: 'Search keyword' },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+  ],
+  columns: ['rank', 'title', 'author', 'likes', 'type'],
+  func: async (page, kwargs) => {
+    await page.goto('https://www.xiaohongshu.com');
+    await page.wait(2);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const app = document.querySelector('#app')?.__vue_app__;
+        const pinia = app?.config?.globalProperties?.$pinia;
+        if (!pinia?._s) return {error: 'Page not ready'};
+
+        const searchStore = pinia._s.get('search');
+        if (!searchStore) return {error: 'Search store not found'};
+
+        let captured = null;
+        const origOpen = XMLHttpRequest.prototype.open;
+        const origSend = XMLHttpRequest.prototype.send;
+        XMLHttpRequest.prototype.open = function(m, u) { this.__url = u; return origOpen.apply(this, arguments); };
+        XMLHttpRequest.prototype.send = function(b) {
+          if (this.__url?.includes('search/notes')) {
+            const x = this;
+            const orig = x.onreadystatechange;
+            x.onreadystatechange = function() { if (x.readyState === 4 && !captured) { try { captured = JSON.parse(x.responseText); } catch {} } if (orig) orig.apply(this, arguments); };
+          }
+          return origSend.apply(this, arguments);
+        };
+
+        try {
+          searchStore.mutateSearchValue('${kwargs.keyword}');
+          await searchStore.loadMore();
+          await new Promise(r => setTimeout(r, 800));
+        } finally {
+          XMLHttpRequest.prototype.open = origOpen;
+          XMLHttpRequest.prototype.send = origSend;
+        }
+
+        if (!captured?.success) return {error: captured?.msg || 'Search failed'};
+        return (captured.data?.items || []).map(i => ({
+          title: i.note_card?.display_title || '',
+          type: i.note_card?.type || '',
+          url: 'https://www.xiaohongshu.com/explore/' + i.id,
+          author: i.note_card?.user?.nickname || '',
+          likes: i.note_card?.interact_info?.liked_count || '0',
+        }));
+      })()
+    `);
+
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, kwargs.limit).map((item: any, i: number) => ({
+      rank: i + 1,
+      ...item,
+    }));
+  },
+});

package/src/clis/zhihu/hot.yaml

@@ -12,17 +12,31 @@ args:
 pipeline:
   - navigate: https://www.zhihu.com
 
-  - fetch:
-      url: https://www.zhihu.com/api/v4/search/top_search
-      params:
-        limit: ${{ args.limit }}
-
-  - select: top_search.words
+  - evaluate: |
+      (async () => {
+        const res = await fetch('https://www.zhihu.com/api/v3/feed/topstory/hot-lists/total?limit=50', {
+          credentials: 'include'
+        });
+        const d = await res.json();
+        return (d?.data || []).map((item) => {
+          const t = item.target || {};
+          return {
+            title: t.title,
+            url: 'https://www.zhihu.com/question/' + t.id,
+            answer_count: t.answer_count,
+            follower_count: t.follower_count,
+            heat: item.detail_text || '',
+          };
+        });
+      })()
 
   - map:
       rank: ${{ index + 1 }}
-      title: ${{ item.query }}
+      title: ${{ item.title }}
+      heat: ${{ item.heat }}
+      answers: ${{ item.answer_count }}
+      url: ${{ item.url }}
 
   - limit: ${{ args.limit }}
 
-columns: [rank, title]
+columns: [rank, title, heat, answers]

package/src/clis/zhihu/question.ts

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'zhihu',
+  name: 'question',
+  description: '知乎问题详情和回答',
+  domain: 'www.zhihu.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'id', required: true, help: 'Question ID (numeric)' },
+    { name: 'limit', type: 'int', default: 5, help: 'Number of answers' },
+  ],
+  columns: ['rank', 'author', 'votes', 'content'],
+  func: async (page, kwargs) => {
+    const { id, limit = 5 } = kwargs;
+
+    const stripHtml = (html: string) =>
+      (html || '').replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').trim();
+
+    // Fetch question detail and answers in parallel via evaluate
+    const result = await page.evaluate(`
+      async () => {
+        const [qResp, aResp] = await Promise.all([
+          fetch('https://www.zhihu.com/api/v4/questions/${id}?include=data[*].detail,excerpt,answer_count,follower_count,visit_count', {credentials: 'include'}),
+          fetch('https://www.zhihu.com/api/v4/questions/${id}/answers?limit=${limit}&offset=0&sort_by=default&include=data[*].content,voteup_count,comment_count,author', {credentials: 'include'})
+        ]);
+        if (!qResp.ok || !aResp.ok) return { error: true };
+        const q = await qResp.json();
+        const a = await aResp.json();
+        return { question: q, answers: a.data || [] };
+      }
+    `);
+
+    if (!result || result.error) throw new Error('Failed to fetch question. Are you logged in?');
+
+    const answers = (result.answers ?? []).slice(0, Number(limit)).map((a: any, i: number) => ({
+      rank: i + 1,
+      author: a.author?.name ?? 'anonymous',
+      votes: a.voteup_count ?? 0,
+      content: stripHtml(a.content ?? '').slice(0, 200),
+    }));
+
+    return answers;
+  },
+});