@jackwener/opencli 0.9.6 → 1.0.0

package/src/clis/feishu/new.ts

@@ -0,0 +1,32 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const newCommand = cli({
+  site: 'feishu',
+  name: 'new',
+  description: 'Create a new message or document in Feishu',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [],
+  columns: ['Status'],
+  func: async (page: IPage | null) => {
+    try {
+      execSync("osascript -e 'tell application \"Lark\" to activate'");
+      execSync("osascript -e 'delay 0.3'");
+
+      // Cmd+N for new conversation/document
+      execSync(
+        "osascript " +
+        "-e 'tell application \"System Events\"' " +
+        "-e 'keystroke \"n\" using command down' " +
+        "-e 'end tell'"
+      );
+
+      return [{ Status: 'New item dialog opened (Cmd+N)' }];
+    } catch (err: any) {
+      return [{ Status: 'Error: ' + err.message }];
+    }
+  },
+});

package/src/clis/feishu/read.ts

@@ -0,0 +1,48 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const readCommand = cli({
+  site: 'feishu',
+  name: 'read',
+  description: 'Read the current chat content by selecting all and copying',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [],
+  columns: ['Content'],
+  func: async (page: IPage | null) => {
+    try {
+      let clipBackup = '';
+      try {
+        clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
+      } catch { /* empty */ }
+
+      execSync("osascript -e 'tell application \"Lark\" to activate'");
+      execSync("osascript -e 'delay 0.3'");
+
+      execSync(
+        "osascript " +
+        "-e 'tell application \"System Events\"' " +
+        "-e 'keystroke \"a\" using command down' " +
+        "-e 'delay 0.2' " +
+        "-e 'keystroke \"c\" using command down' " +
+        "-e 'delay 0.2' " +
+        "-e 'end tell'"
+      );
+
+      const content = execSync('pbpaste', { encoding: 'utf-8' }).trim();
+
+      if (clipBackup) {
+        spawnSync('pbcopy', { input: clipBackup });
+      }
+
+      // Deselect
+      execSync("osascript -e 'tell application \"System Events\" to key code 53'");
+
+      return [{ Content: content || '(no content captured)' }];
+    } catch (err: any) {
+      return [{ Content: 'Error: ' + err.message }];
+    }
+  },
+});

package/src/clis/feishu/search.ts

@@ -0,0 +1,35 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const searchCommand = cli({
+  site: 'feishu',
+  name: 'search',
+  description: 'Open Feishu global search and type a query (Cmd+K)',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: 'query', required: true, positional: true, help: 'Search query' }],
+  columns: ['Status'],
+  func: async (page: IPage | null, kwargs: any) => {
+    const query = kwargs.query as string;
+    try {
+      execSync("osascript -e 'tell application \"Lark\" to activate'");
+      execSync("osascript -e 'delay 0.3'");
+
+      // Feishu uses Cmd+K for global search (similar to Slack/Notion)
+      execSync(
+        "osascript " +
+        "-e 'tell application \"System Events\"' " +
+        "-e 'keystroke \"k\" using command down' " +
+        "-e 'delay 0.5' " +
+        `-e 'keystroke ${JSON.stringify(query)}' ` +
+        "-e 'end tell'"
+      );
+
+      return [{ Status: `Searching for: ${query}` }];
+    } catch (err: any) {
+      return [{ Status: 'Error: ' + err.message }];
+    }
+  },
+});

package/src/clis/feishu/send.ts

@@ -0,0 +1,46 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const sendCommand = cli({
+  site: 'feishu',
+  name: 'send',
+  description: 'Send a message in the active Feishu (Lark) conversation',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+  columns: ['Status'],
+  func: async (page: IPage | null, kwargs: any) => {
+    const text = kwargs.text as string;
+    try {
+      // Backup clipboard
+      let clipBackup = '';
+      try {
+        clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
+      } catch { /* empty */ }
+
+      spawnSync('pbcopy', { input: text });
+
+      execSync("osascript -e 'tell application \"Lark\" to activate'");
+      execSync("osascript -e 'delay 0.5'");
+
+      execSync(
+        "osascript " +
+        "-e 'tell application \"System Events\"' " +
+        "-e 'keystroke \"v\" using command down' " +
+        "-e 'delay 0.2' " +
+        "-e 'keystroke return' " +
+        "-e 'end tell'"
+      );
+
+      if (clipBackup) {
+        spawnSync('pbcopy', { input: clipBackup });
+      }
+
+      return [{ Status: 'Success' }];
+    } catch (err: any) {
+      return [{ Status: 'Error: ' + err.message }];
+    }
+  },
+});

package/src/clis/feishu/status.ts

@@ -0,0 +1,34 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const statusCommand = cli({
+  site: 'feishu',
+  name: 'status',
+  description: 'Check if Feishu (Lark) Desktop is running on macOS',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [],
+  columns: ['Status', 'Detail'],
+  func: async (page: IPage | null) => {
+    try {
+      const running = execSync("osascript -e 'application \"Lark\" is running'", { encoding: 'utf-8' }).trim();
+      if (running !== 'true') {
+        return [{ Status: 'Stopped', Detail: 'Feishu/Lark is not running' }];
+      }
+
+      const windowCount = execSync(
+        "osascript -e 'tell application \"System Events\" to count windows of application process \"Lark\"'",
+        { encoding: 'utf-8' }
+      ).trim();
+
+      return [{
+        Status: 'Running',
+        Detail: `${windowCount} window(s) open`,
+      }];
+    } catch (err: any) {
+      return [{ Status: 'Error', Detail: err.message }];
+    }
+  },
+});

package/src/clis/grok/ask.ts

@@ -0,0 +1,90 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const askCommand = cli({
+  site: 'grok',
+  name: 'ask',
+  description: 'Send a message to Grok and get response',
+  domain: 'grok.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'prompt', type: 'string', required: true },
+    { name: 'timeout', type: 'int', default: 120 },
+    { name: 'new', type: 'boolean', default: false },
+  ],
+  columns: ['response'],
+  func: async (page: IPage, kwargs: Record<string, any>) => {
+    const prompt = kwargs.prompt as string;
+    const timeoutMs = ((kwargs.timeout as number) || 120) * 1000;
+    const newChat = kwargs.new as boolean;
+
+    if (newChat) {
+      await page.goto('https://grok.com');
+      await page.wait(2);
+      await page.evaluate(`(() => {
+        const btn = [...document.querySelectorAll('a, button')].find(b => {
+          const t = (b.textContent || '').trim().toLowerCase();
+          return t.includes('new') || b.getAttribute('href') === '/';
+        });
+        if (btn) btn.click();
+      })()`);
+      await page.wait(2);
+    }
+
+    await page.goto('https://grok.com');
+    await page.wait(3);
+
+    const promptJson = JSON.stringify(prompt);
+
+    const sendResult = await page.evaluate(`(async () => {
+      try {
+        const box = document.querySelector('textarea');
+        if (!box) return { ok: false, msg: 'no textarea' };
+        box.focus(); box.value = '';
+        document.execCommand('selectAll');
+        document.execCommand('insertText', false, ${promptJson});
+        await new Promise(r => setTimeout(r, 1500));
+        const btn = document.querySelector('button[aria-label="\\u63d0\\u4ea4"]');
+        if (btn && !btn.disabled) { btn.click(); return { ok: true, msg: 'clicked' }; }
+        const sub = [...document.querySelectorAll('button[type="submit"]')].find(b => !b.disabled);
+        if (sub) { sub.click(); return { ok: true, msg: 'clicked-submit' }; }
+        box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+        return { ok: true, msg: 'enter' };
+      } catch (e) { return { ok: false, msg: e.toString() }; }
+    })()`);
+
+    if (!sendResult || !sendResult.ok) {
+      return [{ response: '[SEND FAILED] ' + JSON.stringify(sendResult) }];
+    }
+
+    const startTime = Date.now();
+    let lastText = '';
+    let stableCount = 0;
+
+    while (Date.now() - startTime < timeoutMs) {
+      await page.wait(3);
+      const response = await page.evaluate(`(() => {
+        const bubbles = document.querySelectorAll('div.message-bubble, [data-testid="message-bubble"]');
+        if (bubbles.length < 2) return '';
+        const last = bubbles[bubbles.length - 1];
+        const text = (last.innerText || '').trim();
+        if (!text || text.length < 2) return '';
+        return text;
+      })()`);
+
+      if (response && response.length > 2) {
+        if (response === lastText) {
+          stableCount++;
+          if (stableCount >= 2) return [{ response }];
+        } else {
+          stableCount = 0;
+        }
+      }
+      lastText = response || '';
+    }
+
+    if (lastText) return [{ response: lastText }];
+    return [{ response: '[NO RESPONSE]' }];
+  },
+});

package/src/clis/grok/debug.ts

@@ -0,0 +1,49 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const debugCommand = cli({
+  site: 'grok',
+  name: 'debug',
+  description: 'Debug grok page structure',
+  domain: 'grok.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  columns: ['data'],
+  func: async (page: IPage, _kwargs: Record<string, any>) => {
+    await page.goto('https://grok.com');
+    await page.wait(3);
+
+    // Get all button-like elements near textarea
+    const debug = await page.evaluate(`(() => {
+      const ta = document.querySelector('textarea');
+      if (!ta) return { error: 'no textarea' };
+
+      // Get parent containers
+      let parent = ta.parentElement;
+      const parents = [];
+      for (let i = 0; i < 5 && parent; i++) {
+        parents.push({
+          tag: parent.tagName,
+          class: parent.className?.substring(0, 80),
+          childCount: parent.children.length,
+        });
+        parent = parent.parentElement;
+      }
+
+      // Find buttons in the form/container near textarea
+      const form = ta.closest('form') || ta.closest('[class*="composer"]') || ta.closest('[class*="input"]') || ta.parentElement?.parentElement;
+      const buttons = form ? [...form.querySelectorAll('button')].map(b => ({
+        testid: b.getAttribute('data-testid'),
+        type: b.type,
+        disabled: b.disabled,
+        text: (b.textContent || '').substring(0, 30),
+        html: b.outerHTML.substring(0, 200),
+        rect: b.getBoundingClientRect().toJSON(),
+      })) : [];
+
+      return { parents, buttons, formTag: form?.tagName, formClass: form?.className?.substring(0, 80) };
+    })()`);
+
+    return [{ data: JSON.stringify(debug, null, 2) }];
+  },
+});

package/src/clis/jimeng/generate.yaml

@@ -0,0 +1,84 @@
+site: jimeng
+name: generate
+description: 即梦AI 文生图 — 输入 prompt 生成图片
+domain: jimeng.jianying.com
+strategy: cookie
+browser: true
+
+args:
+  prompt:
+    type: string
+    required: true
+    description: "图片描述 prompt"
+  model:
+    type: string
+    default: "high_aes_general_v50"
+    description: "模型: high_aes_general_v50 (5.0 Lite), high_aes_general_v42 (4.6), high_aes_general_v40 (4.0)"
+  wait:
+    type: int
+    default: 40
+    description: "等待生成完成的秒数"
+
+columns: [status, prompt, image_count, image_urls]
+
+pipeline:
+  - navigate: https://jimeng.jianying.com/ai-tool/generate?type=image&workspace=0
+  - wait: 3
+  - evaluate: |
+      (async () => {
+        const prompt = ${{ args.prompt | json }};
+        const waitSec = ${{ args.wait }};
+        
+        // Step 1: Count existing images before generation
+        const beforeImgs = document.querySelectorAll('img[src*="dreamina-sign"], img[src*="tb4s082cfz"]').length;
+        
+        // Step 2: Clear and set prompt
+        const editors = document.querySelectorAll('[contenteditable="true"]');
+        const editor = editors[0];
+        if (!editor) return [{ status: 'failed', prompt: prompt, image_count: 0, image_urls: 'Editor not found' }];
+        
+        editor.focus();
+        await new Promise(r => setTimeout(r, 200));
+        document.execCommand('selectAll');
+        await new Promise(r => setTimeout(r, 100));
+        document.execCommand('delete');
+        await new Promise(r => setTimeout(r, 200));
+        document.execCommand('insertText', false, prompt);
+        await new Promise(r => setTimeout(r, 500));
+        
+        // Step 3: Click generate
+        const btn = document.querySelector('.lv-btn.lv-btn-primary[class*="circle"]');
+        if (!btn) return [{ status: 'failed', prompt: prompt, image_count: 0, image_urls: 'Generate button not found' }];
+        btn.click();
+        
+        // Step 4: Wait for new images to appear
+        let newImgs = [];
+        for (let i = 0; i < waitSec; i++) {
+          await new Promise(r => setTimeout(r, 1000));
+          const allImgs = document.querySelectorAll('img[src*="dreamina-sign"], img[src*="tb4s082cfz"]');
+          if (allImgs.length > beforeImgs) {
+            // New images appeared — generation complete
+            newImgs = Array.from(allImgs).slice(0, allImgs.length - beforeImgs);
+            break;
+          }
+        }
+        
+        if (newImgs.length === 0) {
+          return [{ status: 'timeout', prompt: prompt, image_count: 0, image_urls: 'Generation may still be in progress' }];
+        }
+        
+        // Step 5: Extract image URLs (use thumbnail URLs which are accessible)
+        const urls = newImgs.map(img => img.src);
+        
+        return [{ 
+          status: 'success', 
+          prompt: prompt.substring(0, 80), 
+          image_count: urls.length, 
+          image_urls: urls.join('\n')
+        }];
+      })()
+  - map:
+      status: ${{ item.status }}
+      prompt: ${{ item.prompt }}
+      image_count: ${{ item.image_count }}
+      image_urls: ${{ item.image_urls }}

package/src/clis/jimeng/history.yaml

@@ -0,0 +1,47 @@
+site: jimeng
+name: history
+description: 即梦AI 查看最近生成的作品
+domain: jimeng.jianying.com
+strategy: cookie
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 5
+
+columns: [prompt, model, status, image_url, created_at]
+
+pipeline:
+  - navigate: https://jimeng.jianying.com/ai-tool/generate?type=image&workspace=0
+  - wait: 3
+  - evaluate: |
+      (async () => {
+        const limit = ${{ args.limit }};
+        const res = await fetch('/mweb/v1/get_history?aid=513695&device_platform=web&region=cn&da_version=3.3.11&web_version=7.5.0&aigc_features=app_lip_sync', {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ cursor: '', count: limit, need_page_item: true, need_aigc_data: true, aigc_mode_list: ['workbench'] })
+        });
+        const data = await res.json();
+        const items = data?.data?.history_list || [];
+        return items.slice(0, limit).map(item => {
+          const params = item.aigc_image_params?.text2image_params || {};
+          const images = item.image?.large_images || [];
+          return {
+            prompt: params.prompt || item.common_attr?.title || 'N/A',
+            model: params.model_config?.model_name || 'unknown',
+            status: item.common_attr?.status === 102 ? 'completed' : 'pending',
+            image_url: images[0]?.image_url || '',
+            created_at: new Date((item.common_attr?.create_time || 0) * 1000).toLocaleString('zh-CN'),
+          };
+        });
+      })()
+  - map:
+      prompt: ${{ item.prompt }}
+      model: ${{ item.model }}
+      status: ${{ item.status }}
+      image_url: ${{ item.image_url }}
+      created_at: ${{ item.created_at }}
+  - limit: ${{ args.limit }}

package/src/clis/linux-do/categories.yaml

@@ -0,0 +1,41 @@
+site: linux-do
+name: categories
+description: linux.do 分类列表
+domain: linux.do
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of categories
+
+pipeline:
+  - navigate: https://linux.do
+
+  - evaluate: |
+      (async () => {
+        const res = await fetch('/categories.json', { credentials: 'include' });
+        if (!res.ok) throw new Error('HTTP ' + res.status + ' - 请先登录 linux.do');
+        let data;
+        try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
+        const cats = data?.category_list?.categories || [];
+        return cats.slice(0, ${{ args.limit }}).map(c => ({
+          name: c.name,
+          slug: c.slug,
+          id: c.id,
+          topics: c.topic_count,
+          description: (c.description_text || '').slice(0, 80),
+        }));
+      })()
+
+  - map:
+      name: ${{ item.name }}
+      slug: ${{ item.slug }}
+      id: ${{ item.id }}
+      topics: ${{ item.topics }}
+      description: ${{ item.description }}
+
+  - limit: ${{ args.limit }}
+
+columns: [name, slug, id, topics, description]

package/src/clis/linux-do/category.yaml

@@ -0,0 +1,49 @@
+site: linux-do
+name: category
+description: linux.do 分类内话题
+domain: linux.do
+browser: true
+
+args:
+  slug:
+    type: str
+    required: true
+    description: Category slug (use 'categories' command to find)
+  id:
+    type: int
+    required: true
+    description: Category ID (use 'categories' command to find)
+  limit:
+    type: int
+    default: 20
+    description: Number of topics
+
+pipeline:
+  - navigate: https://linux.do
+
+  - evaluate: |
+      (async () => {
+        const slug = ${{ args.slug | json }};
+        const res = await fetch('/c/' + encodeURIComponent(slug) + '/${{ args.id }}.json', { credentials: 'include' });
+        if (!res.ok) throw new Error('HTTP ' + res.status + ' - 请先登录 linux.do');
+        let data;
+        try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
+        const topics = data?.topic_list?.topics || [];
+        return topics.slice(0, ${{ args.limit }}).map(t => ({
+          title: t.title,
+          replies: (t.posts_count || 1) - 1,
+          views: t.views,
+          likes: t.like_count,
+        }));
+      })()
+
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      replies: ${{ item.replies }}
+      views: ${{ item.views }}
+      likes: ${{ item.likes }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, title, replies, views, likes]

package/src/clis/linux-do/hot.yaml

@@ -0,0 +1,50 @@
+site: linux-do
+name: hot
+description: linux.do 热门话题
+domain: linux.do
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of topics
+  period:
+    type: str
+    default: weekly
+    description: Time period
+    choices: [all, daily, weekly, monthly, yearly]
+
+pipeline:
+  - navigate: https://linux.do
+
+  - evaluate: |
+      (async () => {
+        const period = ${{ args.period | json }};
+        const res = await fetch('/top.json?period=' + encodeURIComponent(period), { credentials: 'include' });
+        if (!res.ok) throw new Error('HTTP ' + res.status + ' - 请先登录 linux.do');
+        let data;
+        try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
+        const topics = data?.topic_list?.topics || [];
+        const cats = data?.topic_list?.categories || data?.categories || [];
+        const catMap = Object.fromEntries(cats.map(c => [c.id, c.name]));
+        return topics.slice(0, ${{ args.limit }}).map(t => ({
+          title: t.title,
+          replies: (t.posts_count || 1) - 1,
+          views: t.views,
+          likes: t.like_count,
+          category: catMap[t.category_id] || String(t.category_id),
+        }));
+      })()
+
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      replies: ${{ item.replies }}
+      views: ${{ item.views }}
+      likes: ${{ item.likes }}
+      category: ${{ item.category }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, title, replies, views, likes, category]

package/src/clis/linux-do/latest.yaml

@@ -0,0 +1,40 @@
+site: linux-do
+name: latest
+description: linux.do 最新话题
+domain: linux.do
+browser: true
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of topics
+
+pipeline:
+  - navigate: https://linux.do
+
+  - evaluate: |
+      (async () => {
+        const res = await fetch('/latest.json', { credentials: 'include' });
+        if (!res.ok) throw new Error('HTTP ' + res.status + ' - 请先登录 linux.do');
+        let data;
+        try { data = await res.json(); } catch { throw new Error('响应不是有效 JSON - 请先登录 linux.do'); }
+        const topics = data?.topic_list?.topics || [];
+        return topics.slice(0, ${{ args.limit }}).map(t => ({
+          title: t.title,
+          replies: (t.posts_count || 1) - 1,
+          views: t.views,
+          likes: t.like_count,
+        }));
+      })()
+
+  - map:
+      rank: ${{ index + 1 }}
+      title: ${{ item.title }}
+      replies: ${{ item.replies }}
+      views: ${{ item.views }}
+      likes: ${{ item.likes }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, title, replies, views, likes]