@harness.farm/social-cli 0.1.1 → 0.1.3

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,391 @@
+/**
+ * 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" }
+ *   - wait_until: { eval: "js", timeout: 120000, interval: 2000 }  # poll until truthy
+ */
+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;
+            }
+            case 'wait_until': {
+                // Poll a JS expression until it returns truthy, with timeout
+                const { eval: js, timeout = 120000, interval = 2000 } = val;
+                const interpolatedJs = interpolate(js, vars);
+                console.log(`  → wait_until (timeout: ${timeout / 1000}s, interval: ${interval / 1000}s)`);
+                const deadline = Date.now() + timeout;
+                let resolved = false;
+                while (Date.now() < deadline) {
+                    const r = exec.eval(interpolatedJs);
+                    if (r.ok && r.value && r.value !== 'false' && r.value !== '' && r.value !== 0) {
+                        resolved = true;
+                        break;
+                    }
+                    console.log(`     ... waiting (${Math.round((deadline - Date.now()) / 1000)}s left)`);
+                    exec.wait(interval);
+                }
+                if (!resolved) {
+                    throw new Error(`wait_until timed out after ${timeout / 1000}s`);
+                }
+                console.log(`     ✅ condition met`);
+                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();
+        });
+    });
+}