@harness.farm/social-cli 0.1.1 → 0.1.2

package/dist/adapters/base.js

@@ -0,0 +1,2 @@
+export class Adapter {
+}

package/dist/adapters/index.js

@@ -0,0 +1,8 @@
+import { XiaohongshuAdapter } from './xiaohongshu.js';
+export const adapters = {
+    xhs: new XiaohongshuAdapter(),
+    xiaohongshu: new XiaohongshuAdapter(),
+    // twitter:   new TwitterAdapter(),
+    // bilibili:  new BilibiliAdapter(),
+    // zhihu:     new ZhihuAdapter(),
+};

package/dist/adapters/xiaohongshu.js

@@ -0,0 +1,314 @@
+/**
+ * 小红书 adapter
+ *
+ * Commands:
+ *   search <keyword>                搜索笔记
+ *   hot                             首页推荐
+ *   post --title <t> --content <c> [--images <p1,p2>]   发布图文
+ */
+import path from 'path';
+import fs from 'fs';
+import { Adapter } from './base.js';
+import { sleep } from '../browser/cdp.js';
+// ─── selectors ────────────────────────────────────────────────────────────────
+const SEL = {
+    // 搜索 / 首页
+    noteItem: '.note-item',
+    noteTitle: '.title, [class*="title"]',
+    noteAuthor: '.author .name, .nickname, [class*="author"] span',
+    noteLikes: '[class*="like"] span, .like-wrapper [class*="count"]',
+    // 发布
+    postFileInput: 'input[type=file][accept*=jpg]',
+    postTitle: 'input.d-text[placeholder*="标题"]',
+    postContent: '.tiptap.ProseMirror',
+    postSubmit: 'button:last-of-type',
+    // 笔记详情页互动
+    likeBtn: '.like-wrapper',
+    collectBtn: '.collect-wrapper',
+    commentArea: '.comment-container, .comments-container',
+    commentInput: '.content-input', // contenteditable
+    commentSubmit: '.btn-send',
+    commentPlaceholder: '说点什么...',
+};
+function parseNotes(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+const NOTE_COLUMNS = [
+    { key: 'index', header: '#', width: 3 },
+    { key: 'title', header: '标题', width: 36 },
+    { key: 'author', header: '作者', width: 16 },
+    { key: 'likes', header: '点赞', width: 8 },
+    { key: 'link', header: '链接', width: 48 },
+];
+const SCRAPE_NOTES = `
+(function() {
+  const r = [];
+  document.querySelectorAll('${SEL.noteItem}').forEach(el => {
+    const title  = el.querySelector('${SEL.noteTitle}')?.textContent?.trim() ?? '';
+    const author = el.querySelector('${SEL.noteAuthor}')?.textContent?.trim() ?? '';
+    const likes  = el.querySelector('${SEL.noteLikes}')?.textContent?.trim() ?? '';
+    const href   = el.querySelector('a')?.href ?? '';
+    if (title) r.push({ title, author, likes, link: href.split('?')[0] });
+  });
+  return JSON.stringify(r);
+})()`;
+// ─── post helpers ─────────────────────────────────────────────────────────────
+function parsePostArgs(args) {
+    let title = '', content = '', images = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--title') {
+            title = args[++i] ?? '';
+            continue;
+        }
+        if (args[i] === '--content') {
+            content = args[++i] ?? '';
+            continue;
+        }
+        if (args[i] === '--images') {
+            images = (args[++i] ?? '').split(',').map(p => path.resolve(p)).filter(p => fs.existsSync(p));
+            continue;
+        }
+    }
+    return { title, content, images };
+}
+// ─── Adapter ──────────────────────────────────────────────────────────────────
+export class XiaohongshuAdapter extends Adapter {
+    platform = 'xiaohongshu';
+    loginUrl = 'https://www.xiaohongshu.com';
+    async isLoggedIn(client) {
+        const cookies = await client.getAllCookies();
+        return cookies.some(c => c.name === 'web_session');
+    }
+    commands = {
+        // ── search ────────────────────────────────────────────────────────────────
+        search: async (client, args) => {
+            const keyword = args[0];
+            if (!keyword)
+                throw new Error('用法: xhs search <关键词>');
+            const url = `https://www.xiaohongshu.com/search_result?keyword=${encodeURIComponent(keyword)}&source=web_explore_feed`;
+            await client.navigate(url, 4000);
+            const raw = await client.eval(SCRAPE_NOTES);
+            const notes = parseNotes(raw);
+            return { columns: NOTE_COLUMNS, rows: notes.map((n, i) => ({ index: i + 1, ...n })) };
+        },
+        // ── hot ───────────────────────────────────────────────────────────────────
+        hot: async (client) => {
+            await client.navigate('https://www.xiaohongshu.com/explore', 4000);
+            const raw = await client.eval(SCRAPE_NOTES);
+            const notes = parseNotes(raw);
+            return { columns: NOTE_COLUMNS, rows: notes.map((n, i) => ({ index: i + 1, ...n })) };
+        },
+        // ── like ──────────────────────────────────────────────────────────────────
+        like: async (client, args) => {
+            const url = args[0];
+            if (!url)
+                throw new Error('用法: xhs like <笔记URL>');
+            await client.navigate(url, 4000);
+            const result = await client.eval(`
+        (function() {
+          var btn = document.querySelector('.like-wrapper');
+          if (!btn) return JSON.stringify({ok: false, reason: 'like button not found'});
+          var wasLiked = btn.classList.contains('like-active');
+          btn.click();
+          var isLiked = btn.classList.contains('like-active');
+          var count = btn.querySelector('.count') ? btn.querySelector('.count').textContent.trim() : '?';
+          return JSON.stringify({ok: true, wasLiked: wasLiked, isLiked: isLiked, count: count});
+        })()
+      `);
+            const r = JSON.parse(result);
+            if (!r.ok)
+                throw new Error(r.reason ?? '点赞失败');
+            const action = r.wasLiked ? '取消点赞' : '点赞成功';
+            const status = r.isLiked ? '❤️  已点赞' : '🤍 未点赞';
+            return {
+                columns: [
+                    { key: 'field', header: '字段', width: 12 },
+                    { key: 'value', header: '值', width: 40 },
+                ],
+                rows: [
+                    { field: '操作', value: action },
+                    { field: '状态', value: status },
+                    { field: '点赞数', value: r.count },
+                    { field: '链接', value: url },
+                ],
+            };
+        },
+        // ── comment ───────────────────────────────────────────────────────────────
+        comment: async (client, args) => {
+            const url = args[0];
+            const text = args[1];
+            if (!url || !text)
+                throw new Error('用法: xhs comment <笔记URL> <评论内容>');
+            await client.navigate(url, 4000);
+            // 1. 点击「说点什么...」激活输入框
+            await client.eval(`
+        (function() {
+          var placeholder = [...document.querySelectorAll('*')].find(function(e) {
+            return e.textContent.trim() === '说点什么...' && e.children.length === 0;
+          });
+          if (placeholder) placeholder.click();
+        })()
+      `);
+            await sleep(800);
+            // 2. 写入评论内容（用 execCommand 兼容 contenteditable）
+            await client.eval(`
+        (function() {
+          var editor = document.querySelector('.content-input');
+          if (!editor) return;
+          editor.focus();
+          document.execCommand('selectAll', false, null);
+          document.execCommand('insertText', false, ${JSON.stringify(text)});
+        })()
+      `);
+            await sleep(500);
+            // 3. 验证内容已写入
+            const inputText = await client.eval(`
+        (document.querySelector('.content-input') || {}).textContent || ''
+      `);
+            console.log(`  ✏️  输入内容: "${inputText}"`);
+            // 4. 点击发送
+            const sent = await client.eval(`
+        (function() {
+          var btn = document.querySelector('.btn-send');
+          if (!btn) {
+            var btns = [...document.querySelectorAll('button')];
+            btn = btns.find(function(b) { return b.textContent.trim() === '发送'; });
+          }
+          if (btn && !btn.disabled) { btn.click(); return true; }
+          return false;
+        })()
+      `);
+            if (!sent)
+                throw new Error('发送按钮未找到或被禁用（评论内容可能为空）');
+            await sleep(1500);
+            // 5. 验证：新评论是否出现在列表里
+            const appeared = await client.eval(`
+        (function() {
+          var comments = [...document.querySelectorAll('.comment-item, [class*=comment-item]')];
+          return comments.some(function(c) { return c.textContent.includes(${JSON.stringify(text.slice(0, 10))}); });
+        })()
+      `);
+            return {
+                columns: [
+                    { key: 'field', header: '字段', width: 12 },
+                    { key: 'value', header: '值', width: 50 },
+                ],
+                rows: [
+                    { field: '状态', value: appeared ? '✅ 评论成功' : '⚠️  请在浏览器中确认' },
+                    { field: '评论内容', value: text },
+                    { field: '链接', value: url },
+                ],
+            };
+        },
+        // ── post ──────────────────────────────────────────────────────────────────
+        post: async (client, args) => {
+            const { title, content, images } = parsePostArgs(args);
+            if (!title && !content)
+                throw new Error('用法: xhs post --title <标题> --content <内容> [--images <图片路径>]');
+            // 1. 导航到发布页
+            await client.navigate('https://creator.xiaohongshu.com/publish/publish?source=official', 3000);
+            // 2. 切换到「上传图文」tab
+            await client.eval(`
+        (function() {
+          const els = [...document.querySelectorAll('*')].filter(e =>
+            e.textContent.trim() === '上传图文' && e.children.length === 0
+          );
+          if (els.length >= 2) els[1].click();
+          else if (els.length === 1) els[0].click();
+        })()
+      `);
+            await sleep(1500);
+            // 3. 上传图片（如果有）
+            if (images.length > 0) {
+                await client.uploadFiles('input[type=file][accept*=jpg]', images);
+                console.log(`  📎 上传图片: ${images.join(', ')}`);
+                await sleep(4000); // 等待图片上传完成
+            }
+            else {
+                // 没有图片时，小红书要求至少一张图，用「文字配图」模式
+                await client.eval(`
+          (function() {
+            const el = [...document.querySelectorAll('*')].find(e =>
+              e.textContent.trim() === '文字配图' && e.children.length === 0
+            );
+            if (el) el.click();
+          })()
+        `);
+                await sleep(2000);
+            }
+            // 4. 填写标题
+            if (title) {
+                await client.eval(`
+          (function() {
+            const input = document.querySelector('input.d-text[placeholder*="标题"]');
+            if (!input) return;
+            input.focus();
+            const nativeInput = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value');
+            nativeInput.set.call(input, ${JSON.stringify(title)});
+            input.dispatchEvent(new Event('input', { bubbles: true }));
+            input.dispatchEvent(new Event('change', { bubbles: true }));
+          })()
+        `);
+                await sleep(500);
+                console.log(`  ✏️  标题: ${title}`);
+            }
+            // 5. 填写正文
+            if (content) {
+                await client.eval(`
+          (function() {
+            const editor = document.querySelector('.tiptap.ProseMirror');
+            if (!editor) return;
+            editor.focus();
+            // 清空并输入内容
+            document.execCommand('selectAll', false, null);
+            document.execCommand('insertText', false, ${JSON.stringify(content)});
+          })()
+        `);
+                await sleep(500);
+                console.log(`  📝 正文: ${content.slice(0, 50)}${content.length > 50 ? '...' : ''}`);
+            }
+            await sleep(1000);
+            // 6. 点击发布
+            const clicked = await client.eval(`
+        (function() {
+          const btns = [...document.querySelectorAll('button')];
+          const btn = btns.reverse().find(b => b.textContent.trim() === '发布');
+          if (btn && !btn.disabled) { btn.click(); return true; }
+          return false;
+        })()
+      `);
+            if (!clicked)
+                throw new Error('未找到发布按钮，或按钮不可点击（可能图片还在上传中）');
+            await sleep(2000);
+            // 7. 检查是否发布成功
+            const result = await client.eval(`
+        JSON.stringify({
+          url: location.href,
+          toast: document.querySelector('[class*=toast],[class*=message],[class*=notice]')?.textContent?.trim() ?? ''
+        })
+      `);
+            const { url, toast } = JSON.parse(result);
+            const success = url.includes('manage') || url.includes('success') || !url.includes('publish');
+            const status = success ? '✅ 发布成功' : '⚠️  请在浏览器中确认';
+            return {
+                columns: [
+                    { key: 'field', header: '字段', width: 12 },
+                    { key: 'value', header: '值', width: 60 },
+                ],
+                rows: [
+                    { field: '状态', value: status },
+                    { field: '标题', value: title || '（无）' },
+                    { field: '正文', value: content.slice(0, 60) || '（无）' },
+                    { field: '图片', value: images.length > 0 ? `${images.length} 张` : '（无）' },
+                    { field: '当前URL', value: url },
+                    { field: '提示', value: toast || '（无）' },
+                ],
+            };
+        },
+    };
+}

package/dist/browser/cdp.js

@@ -0,0 +1,106 @@
+/**
+ * CDP client — wraps a single Chrome tab via WebSocket.
+ * Handles request/response matching, navigate, eval, cookies.
+ */
+import WebSocket from 'ws';
+export class CDPClient {
+    ws;
+    pending = new Map();
+    idCounter = 0;
+    ready;
+    constructor(wsUrl) {
+        this.ws = new WebSocket(wsUrl);
+        this.ready = new Promise((resolve, reject) => {
+            this.ws.once('open', resolve);
+            this.ws.once('error', reject);
+        });
+        this.ws.on('message', (raw) => {
+            const msg = JSON.parse(raw.toString());
+            if (msg.id !== undefined) {
+                const cb = this.pending.get(msg.id);
+                if (!cb)
+                    return;
+                this.pending.delete(msg.id);
+                if (msg.error)
+                    cb.reject(new Error(msg.error.message));
+                else
+                    cb.resolve(msg.result ?? null);
+            }
+        });
+    }
+    async waitReady() {
+        await this.ready;
+    }
+    send(method, params = {}) {
+        const id = ++this.idCounter;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: resolve, reject });
+            this.ws.send(JSON.stringify({ id, method, params }));
+        });
+    }
+    async navigate(url, waitMs = 3000) {
+        await this.send('Page.navigate', { url });
+        await sleep(waitMs);
+    }
+    async eval(expression) {
+        const res = await this.send('Runtime.evaluate', {
+            expression,
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        return res.result.value;
+    }
+    async getAllCookies() {
+        const res = await this.send('Network.getAllCookies');
+        return res.cookies;
+    }
+    /** 通过 DOM.setFileInputFiles 上传本地文件到 input[type=file] */
+    async uploadFiles(selector, filePaths) {
+        await this.send('DOM.enable');
+        const doc = await this.send('DOM.getDocument', { depth: 1 });
+        const q = await this.send('DOM.querySelector', {
+            nodeId: doc.root.nodeId,
+            selector,
+        });
+        if (!q.nodeId)
+            throw new Error(`uploadFiles: selector not found: ${selector}`);
+        await this.send('DOM.setFileInputFiles', { files: filePaths, nodeId: q.nodeId });
+    }
+    async setCookies(cookies) {
+        for (const c of cookies) {
+            await this.send('Network.setCookie', {
+                name: c.name,
+                value: c.value,
+                domain: c.domain,
+                path: c.path,
+                secure: c.secure,
+                httpOnly: c.httpOnly,
+            });
+        }
+    }
+    close() {
+        this.ws.close();
+    }
+}
+export function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/** 连接到 Chrome CDP，返回指定 tab 的 CDPClient */
+export async function connectTab(cdpPort = 9222, tabIndex = 0) {
+    const res = await fetch(`http://localhost:${cdpPort}/json`);
+    const tabs = (await res.json());
+    const pages = tabs.filter((t) => t.type === 'page');
+    if (!pages[tabIndex])
+        throw new Error(`No page tab at index ${tabIndex}`);
+    const client = new CDPClient(pages[tabIndex].webSocketDebuggerUrl);
+    await client.waitReady();
+    return client;
+}
+/** 新建 tab，返回其 CDPClient */
+export async function newTab(cdpPort = 9222) {
+    const res = await fetch(`http://localhost:${cdpPort}/json/new`, { method: 'PUT' });
+    const tab = (await res.json());
+    const client = new CDPClient(tab.webSocketDebuggerUrl);
+    await client.waitReady();
+    return client;
+}

package/dist/browser/runner.js

@@ -0,0 +1,75 @@
+/**
+ * Runner — orchestrates login flow + command execution for any adapter.
+ *
+ * Flow:
+ *   1. Connect to Chrome tab
+ *   2. Check if already logged in (via saved session or live cookies)
+ *   3. If not, navigate to loginUrl and wait for user to log in
+ *   4. Save session cookies
+ *   5. Run the requested command
+ *   6. Render output
+ */
+import { newTab, sleep } from './cdp.js';
+import { captureSession, restoreSession, hasSession } from './session.js';
+import { renderTable } from '../output/table.js';
+export async function run(adapter, opts) {
+    const port = opts.cdpPort ?? 9222;
+    console.log(`\n🔌 连接 Chrome CDP :${port}...`);
+    const client = await newTab(port);
+    // --- 登录流程 ---
+    let loggedIn = false;
+    // 先尝试恢复已保存的 session
+    if (hasSession(adapter.platform)) {
+        await restoreSession(client, adapter.platform);
+        // 导航到目标站验证 session 是否还有效
+        await client.navigate(adapter.loginUrl, 3000);
+        loggedIn = await adapter.isLoggedIn(client);
+        if (!loggedIn) {
+            console.log('⚠️  已保存的 session 已失效，需要重新登录');
+        }
+    }
+    // session 无效或没有 session → 引导用户登录
+    if (!loggedIn) {
+        await client.navigate(adapter.loginUrl, 2000);
+        console.log(`\n🔑 请在 Chrome 中登录 ${adapter.platform}，完成后按 Enter 继续...`);
+        await waitForEnter();
+        // 等待并轮询登录状态
+        for (let i = 0; i < 30; i++) {
+            loggedIn = await adapter.isLoggedIn(client);
+            if (loggedIn)
+                break;
+            process.stdout.write(`\r等待登录... ${(i + 1) * 2}s`);
+            await sleep(2000);
+        }
+        process.stdout.write('\n');
+        if (!loggedIn) {
+            client.close();
+            throw new Error('登录超时，请重试');
+        }
+        // 保存 session
+        await captureSession(client, adapter.platform);
+    }
+    console.log(`✅ 已登录 ${adapter.platform}`);
+    // --- 执行命令 ---
+    const handler = adapter.commands[opts.command];
+    if (!handler) {
+        const available = Object.keys(adapter.commands).join(', ');
+        client.close();
+        throw new Error(`未知命令 "${opts.command}"，可用: ${available}`);
+    }
+    console.log(`\n🔍 执行: ${adapter.platform} ${opts.command} ${(opts.args ?? []).join(' ')}\n`);
+    const result = await handler(client, opts.args ?? []);
+    client.close();
+    // --- 渲染 ---
+    renderTable(result.columns, result.rows);
+}
+function waitForEnter() {
+    return new Promise((resolve) => {
+        process.stdin.setRawMode?.(false);
+        process.stdin.resume();
+        process.stdin.once('data', () => {
+            process.stdin.pause();
+            resolve();
+        });
+    });
+}

package/dist/browser/session.js

@@ -0,0 +1,38 @@
+/**
+ * Session manager — save/load cookies to disk per platform.
+ */
+import fs from 'fs';
+import path from 'path';
+const SESSION_DIR = path.join(process.env.HOME ?? '.', '.cdp-scraper', 'sessions');
+function sessionPath(platform) {
+    return path.join(SESSION_DIR, `${platform}.json`);
+}
+export function saveSession(platform, cookies) {
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+    fs.writeFileSync(sessionPath(platform), JSON.stringify(cookies, null, 2));
+    console.log(`✅ Session saved → ${sessionPath(platform)} (${cookies.length} cookies)`);
+}
+export function loadSession(platform) {
+    const p = sessionPath(platform);
+    if (!fs.existsSync(p))
+        return null;
+    return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+export function hasSession(platform) {
+    return fs.existsSync(sessionPath(platform));
+}
+/** 从 browser 读取 cookies 并保存 */
+export async function captureSession(client, platform) {
+    const cookies = await client.getAllCookies();
+    saveSession(platform, cookies);
+    return cookies;
+}
+/** 恢复已保存的 session 到 browser */
+export async function restoreSession(client, platform) {
+    const cookies = loadSession(platform);
+    if (!cookies)
+        return false;
+    await client.setCookies(cookies);
+    console.log(`✅ Session restored ← ${platform} (${cookies.length} cookies)`);
+    return true;
+}

package/dist/cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * CLI entry — supports both YAML adapters and TypeScript adapters.
+ *
+ * Usage:
+ *   tsx src/cli.ts <platform> <command> [args...]
+ *
+ * Adapter resolution order:
+ *   1. adapters/<platform>.yaml   ← YAML-first
+ *   2. src/adapters/<platform>.ts ← TypeScript fallback
+ *
+ * Examples:
+ *   tsx src/cli.ts xhs search 法律ai
+ *   tsx src/cli.ts xhs like "https://..."
+ *   tsx src/cli.ts xhs comment "https://..." "太棒了！"
+ *   tsx src/cli.ts xhs post --title "标题" --content "内容"
+ */
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { runYamlCommand } from './runner/yaml-runner.js';
+import { run } from './browser/runner.js';
+import { adapters } from './adapters/index.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const [, , platform, command, ...rest] = process.argv;
+if (!platform || !command) {
+    printHelp();
+    process.exit(1);
+}
+// ── Resolve adapter ────────────────────────────────────────────────────────
+const yamlPath = path.join(ROOT, 'adapters', `${platform}.yaml`);
+const hasYaml = fs.existsSync(yamlPath);
+const tsAdapter = adapters[platform];
+if (!hasYaml && !tsAdapter) {
+    console.error(`❌ Unknown platform "${platform}"`);
+    console.error(`   YAML adapters: ${listYamlAdapters().join(', ') || '(none)'}`);
+    console.error(`   TS adapters:   ${Object.keys(adapters).join(', ')}`);
+    process.exit(1);
+}
+// ── Parse args ─────────────────────────────────────────────────────────────
+// Support both positional args and --key value flags
+const args = parseArgs(rest);
+// ── Run ───────────────────────────────────────────────────────────────────
+if (hasYaml) {
+    // YAML adapter: pass positional args in order
+    runYamlCommand(yamlPath, command, args.positional).catch(err => {
+        console.error('❌', err.message);
+        process.exit(1);
+    });
+}
+else {
+    // TypeScript adapter: pass flags as array (legacy)
+    run(tsAdapter, { command, args: rest }).catch(err => {
+        console.error('❌', err.message);
+        process.exit(1);
+    });
+}
+// ── Helpers ───────────────────────────────────────────────────────────────
+function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i].startsWith('--')) {
+            flags[argv[i].slice(2)] = argv[++i] ?? '';
+        }
+        else {
+            positional.push(argv[i]);
+        }
+    }
+    return { positional, flags };
+}
+function listYamlAdapters() {
+    const dir = path.join(ROOT, 'adapters');
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir)
+        .filter(f => f.endsWith('.yaml'))
+        .map(f => f.replace('.yaml', ''));
+}
+function printHelp() {
+    const yaml = listYamlAdapters();
+    const ts = Object.keys(adapters);
+    console.log('用法: tsx src/cli.ts <platform> <command> [args...]');
+    console.log('');
+    if (yaml.length) {
+        console.log('YAML 平台 (推荐):');
+        yaml.forEach(p => console.log(`  ${p}`));
+    }
+    if (ts.length) {
+        console.log('TS 平台:');
+        ts.forEach(p => console.log(`  ${p}`));
+    }
+    console.log('');
+    console.log('示例:');
+    console.log('  tsx src/cli.ts xhs search 法律ai');
+    console.log('  tsx src/cli.ts xhs like "https://www.xiaohongshu.com/explore/..."');
+    console.log('  tsx src/cli.ts xhs comment "https://..." "太棒了！"');
+}

package/dist/output/table.js

@@ -0,0 +1,43 @@
+/**
+ * CLI table renderer with CJK character width support.
+ */
+function dispWidth(s) {
+    let w = 0;
+    for (const c of s)
+        w += c.codePointAt(0) > 127 ? 2 : 1;
+    return w;
+}
+function truncate(s, maxW) {
+    let out = '', cur = 0;
+    for (const c of s) {
+        const cw = c.codePointAt(0) > 127 ? 2 : 1;
+        if (cur + cw > maxW - 1)
+            return out + '…';
+        out += c;
+        cur += cw;
+    }
+    return out;
+}
+function pad(s, width) {
+    return s + ' '.repeat(Math.max(0, width - dispWidth(s)));
+}
+function sep(cols, char = '-') {
+    return '+' + cols.map((c) => char.repeat(c.width + 2)).join('+') + '+';
+}
+function row(cols, values) {
+    return '|' + cols.map((c, i) => ` ${pad(truncate(String(values[i] ?? ''), c.width), c.width)} `).join('|') + '|';
+}
+export function renderTable(cols, data) {
+    const divider = sep(cols);
+    const doubleSep = sep(cols, '=');
+    console.log(divider);
+    console.log(row(cols, cols.map((c) => c.header)));
+    console.log(doubleSep);
+    data.forEach((item, i) => {
+        console.log(row(cols, cols.map((c) => String(item[c.key] ?? ''))));
+        if (i < data.length - 1)
+            console.log(divider);
+    });
+    console.log(divider);
+    console.log(`\n共 ${data.length} 条结果`);
+}

package/dist/runner/step-executor.js

@@ -0,0 +1,142 @@
+/**
+ * Step executor — maps YAML step types to agent-browser CLI calls.
+ *
+ * Each method runs `agent-browser <args>` and returns parsed JSON result.
+ */
+import { execSync } from 'child_process';
+export class StepExecutor {
+    wsUrl;
+    connected = false;
+    constructor(wsUrl) {
+        this.wsUrl = wsUrl;
+    }
+    /** Connect to Chrome tab (once per session) */
+    connect() {
+        if (this.connected)
+            return;
+        this.run(['connect', this.wsUrl]);
+        this.connected = true;
+    }
+    // ── Core step methods ──────────────────────────────────────────────────────
+    open(url) {
+        return this.run(['open', url]);
+    }
+    click(selector) {
+        return this.run(['click', selector]);
+    }
+    /** Click an element by its visible text (uses eval under the hood) */
+    clickText(text) {
+        const js = `(function(){
+      var el = [...document.querySelectorAll('*')].find(function(e){
+        return e.textContent.trim() === ${JSON.stringify(text)} && e.children.length === 0;
+      });
+      if(el){ el.click(); return true; }
+      return false;
+    })()`;
+        const r = this.eval(js);
+        if (!r.value)
+            return { ok: false, error: `Text not found: "${text}"` };
+        return { ok: true };
+    }
+    fill(selector, value) {
+        // Use eval to avoid shell-quoting issues with complex selectors
+        const js = `(function(){
+      var el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return false;
+      el.focus();
+      var nativeSet = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')
+                   || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value');
+      if (nativeSet && nativeSet.set) nativeSet.set.call(el, ${JSON.stringify(value)});
+      else el.value = ${JSON.stringify(value)};
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return true;
+    })()`;
+        return this.eval(js);
+    }
+    type(selector, value) {
+        return this.run(['type', selector, value]);
+    }
+    /** Type into a contenteditable element via execCommand */
+    typeContentEditable(selector, value) {
+        const js = `(function(){
+      var el = document.querySelector(${JSON.stringify(selector)});
+      if(!el) return false;
+      el.focus();
+      document.execCommand('selectAll', false, null);
+      document.execCommand('insertText', false, ${JSON.stringify(value)});
+      return el.textContent || el.value || true;
+    })()`;
+        return this.eval(js);
+    }
+    /** Type via agent-browser's real keystroke simulation (works with Draft.js / React) */
+    typeKeys(selector, value) {
+        return this.run(['type', selector, value]);
+    }
+    wait(msOrSelector) {
+        if (typeof msOrSelector === 'number') {
+            return this.run(['wait', String(msOrSelector)]);
+        }
+        return this.run(['wait', msOrSelector]);
+    }
+    /** Press a key via agent-browser press (real key event, e.g. z, x, Enter, Control+Enter) */
+    pressKey(key) {
+        return this.run(['press', key]);
+    }
+    /** Insert text into the currently focused element via agent-browser keyboard type */
+    keyboardInsertText(text) {
+        // 'keyboard type' sends real key events char-by-char — works with Draft.js
+        return this.run(['keyboard', 'type', text]);
+    }
+    eval(js) {
+        const r = this.run(['eval', js]);
+        if (r.ok && r.value !== undefined) {
+            // agent-browser wraps eval result in data.result
+            const data = r.value;
+            return { ok: true, value: data.result ?? r.value };
+        }
+        return r;
+    }
+    screenshot(path) {
+        return this.run(path ? ['screenshot', path] : ['screenshot']);
+    }
+    upload(selector, filePath) {
+        return this.run(['upload', selector, filePath]);
+    }
+    getUrl() {
+        const r = this.run(['get', 'url']);
+        const data = r.value;
+        return data?.url ?? '';
+    }
+    snapshot() {
+        const r = this.run(['snapshot']);
+        return String(r.value ?? '');
+    }
+    // ── Internal runner ────────────────────────────────────────────────────────
+    run(args) {
+        try {
+            const cmd = `agent-browser ${args.map(a => this.shellQuote(a)).join(' ')}`;
+            const out = execSync(cmd, {
+                env: { ...process.env, AGENT_BROWSER_JSON: '1' },
+                timeout: 30000,
+                encoding: 'utf8',
+            });
+            // Find last JSON line (agent-browser may emit warnings before JSON)
+            const jsonLine = out.trim().split('\n').reverse().find(l => l.startsWith('{'));
+            if (!jsonLine)
+                return { ok: true };
+            const parsed = JSON.parse(jsonLine);
+            if (!parsed.success)
+                return { ok: false, error: parsed.error ?? 'unknown error' };
+            return { ok: true, value: parsed.data };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: msg };
+        }
+    }
+    shellQuote(s) {
+        // Wrap in single quotes, escape internal single quotes
+        return `'${s.replace(/'/g, "'\\''")}'`;
+    }
+}

package/dist/runner/yaml-runner.js

@@ -0,0 +1,368 @@
+/**
+ * YAML Runner — parses adapter YAML and executes commands step by step.
+ *
+ * YAML schema:
+ *   platform: string
+ *   login_url: string
+ *   login_check:
+ *     cookie: string        # cookie name that indicates logged-in state
+ *   commands:
+ *     <name>:
+ *       args: string[]       # positional arg names
+ *       steps: Step[]
+ *
+ * Step types:
+ *   - open: "{{url}}"
+ *   - click: ".selector"
+ *   - click: { text: "visible text" }
+ *   - fill: { selector: ".sel", value: "{{text}}" }
+ *   - type_rich: { selector: ".sel", value: "{{text}}" }   # for contenteditable
+ *   - wait: 3000
+ *   - wait: { selector: ".sel" }
+ *   - eval: "js expression"
+ *   - capture: { name: varName, eval: "js" }
+ *   - upload: { selector: ".sel", file: "{{file}}" }
+ *   - screenshot: path.png
+ *   - extract: { selector, fields: { key: ".sel" | { selector, attr } } }
+ *   - return: [ { field, value } ]  →  builds output table
+ *   - assert: { eval: "js", message: "error msg" }
+ */
+import fs from 'fs';
+import { parse as parseYaml } from 'yaml';
+import { StepExecutor } from './step-executor.js';
+import { renderTable } from '../output/table.js';
+import { connectTab } from '../browser/cdp.js';
+import { loadSession } from '../browser/session.js';
+// ─── Runner ───────────────────────────────────────────────────────────────────
+export async function runYamlCommand(adapterPath, commandName, argValues, cdpPort = 9222) {
+    // 1. Load & parse YAML
+    const raw = fs.readFileSync(adapterPath, 'utf-8');
+    const adapter = parseYaml(raw);
+    const cmdDef = adapter.commands[commandName];
+    if (!cmdDef) {
+        const available = Object.keys(adapter.commands).join(', ');
+        throw new Error(`Unknown command "${commandName}". Available: ${available}`);
+    }
+    // 2. Build variables map from args
+    const vars = {};
+    (cmdDef.args ?? []).forEach((name, i) => {
+        vars[name] = argValues[i] ?? '';
+    });
+    // 3. Ensure logged in → resolve tab ws URL
+    const wsUrl = await resolveTabWsUrl(adapter, cdpPort);
+    const exec = new StepExecutor(wsUrl);
+    exec.connect();
+    const cdpClient = await connectTab(cdpPort);
+    console.log(`✅ 已连接 ${adapter.platform}`);
+    console.log(`\n🔍 执行: ${adapter.platform} ${commandName} ${argValues.join(' ')}\n`);
+    // 4. Execute steps
+    let extractedRows = null;
+    let returnRows = null;
+    for (const step of cmdDef.steps) {
+        const key = Object.keys(step)[0];
+        const val = step[key];
+        switch (key) {
+            case 'open': {
+                const url = interpolate(val, vars);
+                console.log(`  → open ${url}`);
+                exec.open(url);
+                break;
+            }
+            case 'click': {
+                if (typeof val === 'string') {
+                    // plain selector
+                    const sel = interpolate(val, vars);
+                    console.log(`  → click "${sel}"`);
+                    throwIfFail(exec.click(sel), `click failed: ${sel}`);
+                }
+                else if (typeof val === 'object' && val !== null && 'text' in val) {
+                    const text = interpolate(val.text, vars);
+                    console.log(`  → click text="${text}"`);
+                    throwIfFail(exec.clickText(text), `text not found: "${text}"`);
+                }
+                else if (typeof val === 'object' && val !== null && 'selector' in val) {
+                    const sel = interpolate(val.selector, vars);
+                    console.log(`  → click selector="${sel}"`);
+                    throwIfFail(exec.click(sel), `click failed: ${sel}`);
+                }
+                break;
+            }
+            case 'fill': {
+                const { selector, value } = val;
+                const sel = interpolate(selector, vars);
+                const v = interpolate(value, vars);
+                console.log(`  → fill "${sel}" = "${v.slice(0, 40)}"`);
+                throwIfFail(exec.fill(sel, v), `fill failed: ${sel}`);
+                break;
+            }
+            case 'type_rich': {
+                const { selector, value } = val;
+                const sel = interpolate(selector, vars);
+                const v = interpolate(value, vars);
+                console.log(`  → type_rich "${sel}" = "${v.slice(0, 40)}"`);
+                throwIfFail(exec.typeContentEditable(sel, v), `type_rich failed: ${sel}`);
+                break;
+            }
+            case 'wait': {
+                if (typeof val === 'number') {
+                    console.log(`  → wait ${val}ms`);
+                    exec.wait(val);
+                }
+                else {
+                    const sel = interpolate(val.selector, vars);
+                    console.log(`  → wait selector="${sel}"`);
+                    exec.wait(sel);
+                }
+                break;
+            }
+            case 'eval': {
+                const js = interpolate(val, vars);
+                console.log(`  → eval ...`);
+                exec.eval(js);
+                break;
+            }
+            case 'capture': {
+                const { name, eval: js } = val;
+                const interpolatedJs = interpolate(js, vars);
+                console.log(`  → capture ${name}`);
+                const r = exec.eval(interpolatedJs);
+                vars[name] = String(r.value ?? '');
+                console.log(`     ${name} = ${vars[name].slice(0, 60)}`);
+                break;
+            }
+            case 'upload': {
+                const { selector, file } = val;
+                const sel = interpolate(selector, vars);
+                const f = interpolate(file, vars);
+                console.log(`  → upload "${sel}" ← ${f}`);
+                throwIfFail(exec.upload(sel, f), `upload failed: ${sel}`);
+                break;
+            }
+            case 'screenshot': {
+                const p = interpolate(val, vars);
+                console.log(`  → screenshot → ${p}`);
+                exec.screenshot(p);
+                break;
+            }
+            case 'extract': {
+                const def = val;
+                console.log(`  → extract "${def.selector}"`);
+                extractedRows = runExtract(exec, def, vars);
+                break;
+            }
+            case 'return': {
+                returnRows = val.map(r => ({
+                    field: interpolate(r.field, vars),
+                    value: interpolate(r.value, vars),
+                }));
+                break;
+            }
+            case 'assert': {
+                const { eval: js, message } = val;
+                const r = exec.eval(interpolate(js, vars));
+                if (!r.value)
+                    throw new Error(message ?? `Assertion failed: ${js}`);
+                console.log(`  → assert ✅`);
+                break;
+            }
+            case 'key': {
+                const k = interpolate(val, vars);
+                console.log(`  → key "${k}"`);
+                // For Enter/special keys that need to reach the focused element, use CDPClient directly
+                if (k === 'Enter' || k === 'Control+Enter') {
+                    const modifiers = k.startsWith('Control') ? 2 : 0;
+                    await cdpClient.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, modifiers });
+                    await cdpClient.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, modifiers });
+                }
+                else {
+                    exec.pressKey(k);
+                }
+                break;
+            }
+            case 'keyboard_insert': {
+                // Send text char-by-char via CDP Input.dispatchKeyEvent 'char' events
+                // This triggers Draft.js / React input handlers correctly
+                const text = interpolate(val, vars);
+                console.log(`  → keyboard_insert "${text.slice(0, 40)}"`);
+                for (const char of text) {
+                    const code = char.codePointAt(0);
+                    await cdpClient.send('Input.dispatchKeyEvent', { type: 'keyDown', key: char, windowsVirtualKeyCode: code });
+                    await cdpClient.send('Input.dispatchKeyEvent', { type: 'char', key: char, text: char });
+                    await cdpClient.send('Input.dispatchKeyEvent', { type: 'keyUp', key: char, windowsVirtualKeyCode: code });
+                }
+                break;
+            }
+            case 'insert_text': {
+                // CDP Input.insertText — inserts text directly into the focused element,
+                // works even inside shadow DOM (unlike keyboard_insert which targets document.activeElement)
+                const text = interpolate(val, vars);
+                console.log(`  → insert_text "${text.slice(0, 40)}"`);
+                await cdpClient.send('Input.insertText', { text });
+                break;
+            }
+        }
+    }
+    // 5. Render output
+    console.log('');
+    if (extractedRows) {
+        const fields = Object.keys(extractedRows[0] ?? {});
+        const columns = fields.map(k => ({
+            key: k,
+            header: k,
+            width: k === 'index' ? 4 : k === 'link' ? 52 : k === 'title' ? 36 : 24,
+        }));
+        renderTable(columns, extractedRows);
+    }
+    else if (returnRows) {
+        renderTable([{ key: 'field', header: '字段', width: 12 }, { key: 'value', header: '值', width: 50 }], returnRows);
+    }
+    cdpClient.close();
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Replace {{expr}} placeholders — supports plain var names and JS expressions */
+function interpolate(template, vars) {
+    return template.replace(/\{\{(.+?)\}\}/g, (_, expr) => {
+        const trimmed = expr.trim();
+        // Plain variable name: fast path
+        if (/^\w+$/.test(trimmed))
+            return vars[trimmed] ?? '';
+        // JS expression: inject vars as locals and eval
+        try {
+            const keys = Object.keys(vars);
+            const vals = keys.map(k => vars[k]);
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval
+            return String(new Function(...keys, `return (${trimmed})`)(...vals) ?? '');
+        }
+        catch {
+            return '';
+        }
+    });
+}
+function throwIfFail(r, msg) {
+    if (!r.ok)
+        throw new Error(`${msg}: ${r.error ?? ''}`);
+}
+/** Run an extract step: scrape a list of items with named fields */
+function runExtract(exec, def, vars) {
+    const fieldsJson = JSON.stringify(def.fields);
+    const js = `(function(){
+    var fields = ${fieldsJson};
+    var results = [];
+    document.querySelectorAll(${JSON.stringify(def.selector)}).forEach(function(item, i) {
+      var row = { index: i + 1 };
+      Object.keys(fields).forEach(function(key) {
+        var spec = fields[key];
+        if (typeof spec === 'string') {
+          var el = item.querySelector(spec);
+          row[key] = el ? el.textContent.trim() : '';
+        } else {
+          var el2 = item.querySelector(spec.selector);
+          row[key] = el2 ? (spec.attr === 'href' ? (el2.href || el2.getAttribute(spec.attr)) : el2.getAttribute(spec.attr)) || el2.textContent.trim() : '';
+        }
+      });
+      if (Object.values(row).some(function(v){ return v && v !== i + 1; })) results.push(row);
+    });
+    return JSON.stringify(results);
+  })()`;
+    const r = exec.eval(js);
+    try {
+        return JSON.parse(String(r.value ?? '[]'));
+    }
+    catch {
+        return [];
+    }
+}
+/** Find the ws URL of the right tab, with full user onboarding if needed */
+async function resolveTabWsUrl(adapter, cdpPort) {
+    // Step 1: Check Chrome is running with CDP
+    let tabs;
+    try {
+        const res = await fetch(`http://localhost:${cdpPort}/json`, { signal: AbortSignal.timeout(2000) });
+        tabs = (await res.json());
+    }
+    catch {
+        console.error(`\n❌ 无法连接到 Chrome CDP (端口 ${cdpPort})`);
+        console.error('\n👉 请先启动 Chrome，开启远程调试：\n');
+        console.error(`   macOS:   /Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome \\`);
+        console.error(`              --remote-debugging-port=${cdpPort} \\`);
+        console.error(`              --user-data-dir=$HOME/.cdp-scraper/chrome-profile\n`);
+        console.error(`   Windows: chrome.exe --remote-debugging-port=${cdpPort} --user-data-dir=%USERPROFILE%\\.cdp-scraper\\chrome-profile\n`);
+        console.error(`   Linux:   google-chrome --remote-debugging-port=${cdpPort} --user-data-dir=~/.cdp-scraper/chrome-profile\n`);
+        console.error('启动后重新运行此命令。');
+        process.exit(1);
+    }
+    const pageTabs = tabs.filter(t => t.type === 'page');
+    if (pageTabs.length === 0) {
+        console.error('❌ Chrome 中没有打开的页面，请至少保持一个标签页打开。');
+        process.exit(1);
+    }
+    // Step 2: Prefer a tab already on the platform domain
+    const domain = new URL(adapter.login_url).hostname.replace('www.', '');
+    const existing = pageTabs.find(t => t.url.includes(domain) && !t.url.includes('creator'));
+    if (existing)
+        return existing.webSocketDebuggerUrl;
+    // Step 3: Check saved session cookie
+    const cookies = loadSession(adapter.platform);
+    const hasCookie = cookies?.some(c => c.name === adapter.login_check.cookie);
+    if (hasCookie) {
+        const page = pageTabs[0];
+        return page.webSocketDebuggerUrl;
+    }
+    // Step 4: Not logged in — guide user through login
+    console.log(`\n🔑 需要登录 ${adapter.platform}`);
+    console.log('─'.repeat(50));
+    // Open the platform login page in the first tab via agent-browser
+    const firstTab = pageTabs[0].webSocketDebuggerUrl;
+    console.log(`\n   正在打开登录页: ${adapter.login_url}`);
+    console.log(`   (使用 agent-browser 连接到: ${firstTab})\n`);
+    const { execSync } = await import('child_process');
+    try {
+        execSync(`agent-browser connect '${firstTab}'`, {
+            env: { ...process.env, AGENT_BROWSER_JSON: '1' },
+            timeout: 5000,
+            encoding: 'utf8',
+        });
+        execSync(`agent-browser open '${adapter.login_url}'`, {
+            env: { ...process.env, AGENT_BROWSER_JSON: '1' },
+            timeout: 10000,
+            encoding: 'utf8',
+        });
+    }
+    catch {
+        console.log(`   ⚠️  无法自动打开页面，请手动在 Chrome 中访问: ${adapter.login_url}`);
+    }
+    console.log(`👀 请在 Chrome 中完成登录 ${adapter.platform}，然后按 Enter...`);
+    await waitForEnter();
+    // Step 5: Verify login by checking for the cookie
+    const resTabs = await fetch(`http://localhost:${cdpPort}/json`);
+    const freshTabs = (await resTabs.json());
+    const freshPage = freshTabs.filter(t => t.type === 'page')[0];
+    if (!freshPage) {
+        console.error('❌ Chrome 中没有打开的页面');
+        process.exit(1);
+    }
+    // Save session from the browser
+    const { connectTab } = await import('../browser/cdp.js');
+    const { captureSession } = await import('../browser/session.js');
+    const client = await connectTab(cdpPort);
+    const saved = await captureSession(client, adapter.platform);
+    client.close();
+    const ok = saved.some(c => c.name === adapter.login_check.cookie);
+    if (!ok) {
+        console.error(`❌ 未检测到登录 cookie (${adapter.login_check.cookie})，请确认已登录后重试`);
+        process.exit(1);
+    }
+    console.log(`✅ 登录成功，session 已保存\n`);
+    return freshPage.webSocketDebuggerUrl;
+}
+function waitForEnter() {
+    return new Promise((resolve) => {
+        process.stdin.setRawMode?.(false);
+        process.stdin.resume();
+        process.stdout.write('   > ');
+        process.stdin.once('data', () => {
+            process.stdin.pause();
+            resolve();
+        });
+    });
+}

package/dist/scripts/explore-bili.js

@@ -0,0 +1,37 @@
+import { connectTab } from '../browser/cdp.js';
+const client = await connectTab(9222);
+await client.send('Page.bringToFront');
+await new Promise(r => setTimeout(r, 300));
+// Deep focus into bili-comments shadow DOM
+const focused = await client.eval(`(function(){
+  var host = document.querySelector("bili-comments");
+  if(!host) return "no bili-comments";
+  function deepFocus(root){
+    var sr = root.shadowRoot;
+    if(!sr) return null;
+    var editor = sr.querySelector(".brt-editor");
+    if(editor) { editor.click(); editor.focus(); return "ok"; }
+    var els = sr.querySelectorAll("*");
+    for(var i=0; i<els.length; i++){
+      var r = deepFocus(els[i]);
+      if(r) return r;
+    }
+    return null;
+  }
+  return deepFocus(host) || "not found";
+})()`);
+console.log('focus result:', focused);
+await new Promise(r => setTimeout(r, 500));
+// Try Input.insertText
+await client.send('Input.insertText', { text: 'hello shadow insertText' });
+await new Promise(r => setTimeout(r, 500));
+const content = await client.eval(`(function(){
+  var ed = document.querySelector("bili-comments")
+    .shadowRoot.querySelector("bili-comments-header-renderer")
+    .shadowRoot.querySelector("bili-comment-box")
+    .shadowRoot.querySelector("bili-comment-rich-textarea")
+    .shadowRoot.querySelector(".brt-editor");
+  return ed ? JSON.stringify({ text: ed.textContent.trim(), html: ed.innerHTML.slice(0,100) }) : "not found";
+})()`);
+console.log('editor content:', content);
+client.close();

package/dist/scripts/explore-douyin.js

@@ -0,0 +1,30 @@
+import { connectTab } from '../browser/cdp.js';
+const client = await connectTab(9222);
+await client.send('Page.bringToFront');
+await new Promise(r => setTimeout(r, 200));
+// Get follow button (JbfEzak6) coordinates
+const coords = await client.eval(`(function(){
+  var el = document.querySelector('.JbfEzak6');
+  if(!el) return 'null';
+  var r = el.getBoundingClientRect();
+  return JSON.stringify({ x: Math.round(r.x + r.width/2), y: Math.round(r.y + r.height/2) });
+})()`);
+console.log('follow btn coords:', coords);
+// check current state by checking parent avatar area
+const beforeInfo = await client.eval(`JSON.stringify({
+  JbfEzak6Count: document.querySelectorAll('.JbfEzak6').length,
+  hasFollowedState: document.body.innerHTML.includes('已关注')
+})`);
+console.log('before:', JSON.parse(beforeInfo));
+const { x, y } = JSON.parse(coords);
+await client.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
+await client.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+await client.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+await new Promise(r => setTimeout(r, 2000));
+const afterInfo = await client.eval(`JSON.stringify({
+  JbfEzak6Count: document.querySelectorAll('.JbfEzak6').length,
+  hasFollowedState: document.body.innerHTML.includes('已关注'),
+  bodySnippet: [...document.querySelectorAll('[class*=follow]')].map(function(el){ return el.className.slice(0,60) + ':' + el.textContent.trim().slice(0,20); }).join(' | ')
+})`);
+console.log('after:', JSON.parse(afterInfo));
+client.close();

package/dist/scripts/explore-x.js

@@ -0,0 +1,31 @@
+import { newTab } from '../browser/cdp.js';
+const client = await newTab(9222);
+await client.navigate('https://x.com/search?q=AI+law&src=typed_query&f=top', 4000);
+const info = await client.eval(`JSON.stringify({
+  url: location.href,
+  tweetItems: (() => {
+    var tweets = [...document.querySelectorAll('[data-testid="tweet"]')];
+    return tweets.slice(0,3).map(function(t){
+      return {
+        text: t.querySelector('[data-testid="tweetText"]')?.textContent?.trim()?.slice(0,60) || '',
+        user: t.querySelector('[data-testid="User-Name"]')?.textContent?.trim()?.slice(0,30) || '',
+        link: (() => {
+          var a = [...t.querySelectorAll('a')].find(function(a){ return /\\/status\\//.test(a.href); });
+          return a ? a.href : '';
+        })(),
+        time: t.querySelector('time')?.getAttribute('datetime') || ''
+      };
+    });
+  })()
+})`);
+const d = JSON.parse(info);
+console.log('URL:', d.url);
+console.log('\n搜索结果结构:');
+d.tweetItems.forEach((t, i) => {
+    console.log(`\n[${i + 1}]`);
+    console.log('  text:', t.text);
+    console.log('  user:', t.user);
+    console.log('  link:', t.link);
+    console.log('  time:', t.time);
+});
+client.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness.farm/social-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "CDP-based social media automation CLI — X, 小红书, 抖音, B站, Temu",
   "type": "module",
   "publishConfig": {
@@ -14,6 +14,7 @@
     "adapters"
   ],
   "scripts": {
+    "prepublishOnly": "tsc",
     "dev": "tsx src/cli.ts",
     "build": "tsc",
     "x": "tsx src/cli.ts x",