@jackwener/opencli 1.0.1 → 1.0.4

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void;

package/dist/cli.js

@@ -0,0 +1,234 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { executeCommand } from './engine.js';
+import { Strategy, fullName, getRegistry, strategyLabel } from './registry.js';
+import { render as renderOutput } from './output.js';
+import { BrowserBridge, CDPBridge } from './browser/index.js';
+import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
+import { PKG_VERSION } from './version.js';
+import { printCompletionScript } from './completion.js';
+import { CliError } from './errors.js';
+import { shouldUseBrowserSession } from './capabilityRouting.js';
+export function runCli(BUILTIN_CLIS, USER_CLIS) {
+    const program = new Command();
+    program.name('opencli').description('Make any website your CLI. Zero setup. AI-powered.').version(PKG_VERSION);
+    // ── Built-in commands ──────────────────────────────────────────────────────
+    program.command('list').description('List all available CLI commands').option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table').option('--json', 'JSON output (deprecated)')
+        .action((opts) => {
+        const registry = getRegistry();
+        const commands = [...registry.values()].sort((a, b) => fullName(a).localeCompare(fullName(b)));
+        const rows = commands.map(c => ({
+            command: fullName(c),
+            site: c.site,
+            name: c.name,
+            description: c.description,
+            strategy: strategyLabel(c),
+            browser: c.browser,
+            args: c.args.map(a => a.name).join(', '),
+        }));
+        const fmt = opts.json && opts.format === 'table' ? 'json' : opts.format;
+        if (fmt !== 'table') {
+            renderOutput(rows, {
+                fmt,
+                columns: ['command', 'site', 'name', 'description', 'strategy', 'browser', 'args'],
+                title: 'opencli/list',
+                source: 'opencli list',
+            });
+            return;
+        }
+        const sites = new Map();
+        for (const cmd of commands) {
+            const g = sites.get(cmd.site) ?? [];
+            g.push(cmd);
+            sites.set(cmd.site, g);
+        }
+        console.log();
+        console.log(chalk.bold('  opencli') + chalk.dim(' — available commands'));
+        console.log();
+        for (const [site, cmds] of sites) {
+            console.log(chalk.bold.cyan(`  ${site}`));
+            for (const cmd of cmds) {
+                const tag = strategyLabel(cmd) === 'public' ? chalk.green('[public]') : chalk.yellow(`[${strategyLabel(cmd)}]`);
+                console.log(`    ${cmd.name} ${tag}${cmd.description ? chalk.dim(` — ${cmd.description}`) : ''}`);
+            }
+            console.log();
+        }
+        console.log(chalk.dim(`  ${commands.length} commands across ${sites.size} sites`));
+        console.log();
+    });
+    program.command('validate').description('Validate CLI definitions').argument('[target]', 'site or site/name')
+        .action(async (target) => {
+        const { validateClisWithTarget, renderValidationReport } = await import('./validate.js');
+        console.log(renderValidationReport(validateClisWithTarget([BUILTIN_CLIS, USER_CLIS], target)));
+    });
+    program.command('verify').description('Validate + smoke test').argument('[target]').option('--smoke', 'Run smoke tests', false)
+        .action(async (target, opts) => {
+        const { verifyClis, renderVerifyReport } = await import('./verify.js');
+        const r = await verifyClis({ builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, target, smoke: opts.smoke });
+        console.log(renderVerifyReport(r));
+        process.exitCode = r.ok ? 0 : 1;
+    });
+    program.command('explore').alias('probe').description('Explore a website: discover APIs, stores, and recommend strategies').argument('<url>').option('--site <name>').option('--goal <text>').option('--wait <s>', '', '3').option('--auto', 'Enable interactive fuzzing (simulate clicks to trigger lazy APIs)').option('--click <labels>', 'Comma-separated labels to click before fuzzing (e.g. "字幕,CC,评论")')
+        .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); const clickLabels = opts.click ? opts.click.split(',').map((s) => s.trim()) : undefined; const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; const workspace = `explore:${opts.site ?? (() => { try {
+        return new URL(url).host;
+    }
+    catch {
+        return 'default';
+    } })()}`; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: BrowserFactory, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels, workspace }))); });
+    program.command('synthesize').description('Synthesize CLIs from explore').argument('<target>').option('--top <n>', '', '3')
+        .action(async (target, opts) => { const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js'); console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) }))); });
+    program.command('generate').description('One-shot: explore → synthesize → register').argument('<url>').option('--goal <text>').option('--site <name>')
+        .action(async (url, opts) => { const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js'); const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; const workspace = `generate:${opts.site ?? (() => { try {
+        return new URL(url).host;
+    }
+    catch {
+        return 'default';
+    } })()}`; const r = await generateCliFromUrl({ url, BrowserFactory: BrowserFactory, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site, workspace }); console.log(renderGenerateSummary(r)); process.exitCode = r.ok ? 0 : 1; });
+    program.command('cascade').description('Strategy cascade: find simplest working strategy').argument('<url>').option('--site <name>')
+        .action(async (url, opts) => {
+        const { cascadeProbe, renderCascadeResult } = await import('./cascade.js');
+        const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge;
+        const result = await browserSession(BrowserFactory, async (page) => {
+            // Navigate to the site first for cookie context
+            try {
+                const siteUrl = new URL(url);
+                await page.goto(`${siteUrl.protocol}//${siteUrl.host}`);
+                await page.wait(2);
+            }
+            catch { }
+            return cascadeProbe(page, url);
+        }, { workspace: `cascade:${opts.site ?? (() => { try {
+                return new URL(url).host;
+            }
+            catch {
+                return 'default';
+            } })()}` });
+        console.log(renderCascadeResult(result));
+    });
+    program.command('doctor')
+        .description('Diagnose opencli browser bridge connectivity')
+        .option('--live', 'Test browser connectivity (requires Chrome running)', false)
+        .option('--sessions', 'Show active automation sessions', false)
+        .action(async (opts) => {
+        const { runBrowserDoctor, renderBrowserDoctorReport } = await import('./doctor.js');
+        const report = await runBrowserDoctor({ live: opts.live, sessions: opts.sessions, cliVersion: PKG_VERSION });
+        console.log(renderBrowserDoctorReport(report));
+    });
+    program.command('setup')
+        .description('Interactive setup: verify browser bridge connectivity')
+        .action(async () => {
+        const { runSetup } = await import('./setup.js');
+        await runSetup({ cliVersion: PKG_VERSION });
+    });
+    program.command('completion')
+        .description('Output shell completion script')
+        .argument('<shell>', 'Shell type: bash, zsh, or fish')
+        .action((shell) => {
+        printCompletionScript(shell);
+    });
+    // ── Antigravity serve (built-in, long-running) ──────────────────────────────
+    const antigravityCmd = program.command('antigravity').description('antigravity commands');
+    antigravityCmd.command('serve')
+        .description('Start Anthropic-compatible API proxy for Antigravity')
+        .option('--port <port>', 'Server port (default: 8082)', '8082')
+        .action(async (opts) => {
+        const { startServe } = await import('./clis/antigravity/serve.js');
+        await startServe({ port: parseInt(opts.port) });
+    });
+    // ── Dynamic site commands ──────────────────────────────────────────────────
+    const registry = getRegistry();
+    const siteGroups = new Map();
+    // Pre-seed with the antigravity command registered above to avoid duplicates
+    siteGroups.set('antigravity', antigravityCmd);
+    for (const [, cmd] of registry) {
+        let siteCmd = siteGroups.get(cmd.site);
+        if (!siteCmd) {
+            siteCmd = program.command(cmd.site).description(`${cmd.site} commands`);
+            siteGroups.set(cmd.site, siteCmd);
+        }
+        const subCmd = siteCmd.command(cmd.name).description(cmd.description);
+        // Register positional args first, then named options
+        const positionalArgs = [];
+        for (const arg of cmd.args) {
+            if (arg.positional) {
+                const bracket = arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+                subCmd.argument(bracket, arg.help ?? '');
+                positionalArgs.push(arg);
+            }
+            else {
+                const flag = arg.required ? `--${arg.name} <value>` : `--${arg.name} [value]`;
+                if (arg.required)
+                    subCmd.requiredOption(flag, arg.help ?? '');
+                else if (arg.default != null)
+                    subCmd.option(flag, arg.help ?? '', String(arg.default));
+                else
+                    subCmd.option(flag, arg.help ?? '');
+            }
+        }
+        subCmd.option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table').option('-v, --verbose', 'Debug output', false);
+        subCmd.action(async (...actionArgs) => {
+            // Commander passes positional args first, then options object, then the Command
+            const actionOpts = actionArgs[positionalArgs.length] ?? {};
+            const startTime = Date.now();
+            const kwargs = {};
+            // Collect positional args
+            for (let i = 0; i < positionalArgs.length; i++) {
+                const arg = positionalArgs[i];
+                const v = actionArgs[i];
+                if (v !== undefined)
+                    kwargs[arg.name] = v;
+            }
+            // Collect named options
+            for (const arg of cmd.args) {
+                if (arg.positional)
+                    continue;
+                const camelName = arg.name.replace(/-([a-z])/g, (_m, ch) => ch.toUpperCase());
+                const v = actionOpts[arg.name] ?? actionOpts[camelName];
+                if (v !== undefined)
+                    kwargs[arg.name] = v;
+            }
+            try {
+                if (actionOpts.verbose)
+                    process.env.OPENCLI_VERBOSE = '1';
+                let result;
+                if (shouldUseBrowserSession(cmd)) {
+                    const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge;
+                    result = await browserSession(BrowserFactory, async (page) => {
+                        // Cookie/header strategies require same-origin context for credentialed fetch.
+                        if ((cmd.strategy === Strategy.COOKIE || cmd.strategy === Strategy.HEADER) && cmd.domain) {
+                            try {
+                                await page.goto(`https://${cmd.domain}`);
+                                await page.wait(2);
+                            }
+                            catch { }
+                        }
+                        return runWithTimeout(executeCommand(cmd, page, kwargs, actionOpts.verbose), { timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT, label: fullName(cmd) });
+                    }, { workspace: `site:${cmd.site}` });
+                }
+                else {
+                    result = await executeCommand(cmd, null, kwargs, actionOpts.verbose);
+                }
+                if (actionOpts.verbose && (!result || (Array.isArray(result) && result.length === 0))) {
+                    console.error(chalk.yellow(`[Verbose] Warning: Command returned an empty result. If the website structural API changed or requires authentication, check the network or update the adapter.`));
+                }
+                const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
+                renderOutput(result, { fmt: actionOpts.format, columns: resolved.columns, title: `${resolved.site}/${resolved.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(resolved), footerExtra: resolved.footerExtra?.(kwargs) });
+            }
+            catch (err) {
+                if (err instanceof CliError) {
+                    console.error(chalk.red(`Error [${err.code}]: ${err.message}`));
+                    if (err.hint)
+                        console.error(chalk.yellow(`Hint: ${err.hint}`));
+                }
+                else if (actionOpts.verbose && err.stack) {
+                    console.error(chalk.red(err.stack));
+                }
+                else {
+                    console.error(chalk.red(`Error: ${err.message ?? err}`));
+                }
+                process.exitCode = 1;
+            }
+        });
+    }
+    program.parse();
+}

package/dist/clis/antigravity/serve.d.ts

@@ -0,0 +1,14 @@
+/**
+ * antigravity serve — Anthropic-compatible `/v1/messages` proxy server.
+ *
+ * Starts an HTTP server that accepts Anthropic Messages API requests,
+ * forwards them to a running Antigravity app via CDP, polls for the response,
+ * and returns it in Anthropic format.
+ *
+ * Usage:
+ *   OPENCLI_CDP_ENDPOINT=http://127.0.0.1:9224 opencli antigravity serve --port 8082
+ *   ANTHROPIC_BASE_URL=http://localhost:8082 claude
+ */
+export declare function startServe(opts?: {
+    port?: number;
+}): Promise<void>;

package/dist/clis/antigravity/serve.js

@@ -0,0 +1,263 @@
+/**
+ * antigravity serve — Anthropic-compatible `/v1/messages` proxy server.
+ *
+ * Starts an HTTP server that accepts Anthropic Messages API requests,
+ * forwards them to a running Antigravity app via CDP, polls for the response,
+ * and returns it in Anthropic format.
+ *
+ * Usage:
+ *   OPENCLI_CDP_ENDPOINT=http://127.0.0.1:9224 opencli antigravity serve --port 8082
+ *   ANTHROPIC_BASE_URL=http://localhost:8082 claude
+ */
+import { createServer } from 'node:http';
+import { CDPBridge } from '../../browser/cdp.js';
+// ─── Helpers ─────────────────────────────────────────────────────────
+function generateMsgId() {
+    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let id = 'msg_';
+    for (let i = 0; i < 24; i++)
+        id += chars[Math.floor(Math.random() * chars.length)];
+    return id;
+}
+function estimateTokens(text) {
+    // Rough approximation: ~4 chars per token for English, ~2 for CJK
+    return Math.max(1, Math.ceil(text.length / 3));
+}
+function extractTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    return content
+        .filter(b => b.type === 'text' && b.text)
+        .map(b => b.text)
+        .join('\n');
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        req.on('error', reject);
+    });
+}
+function jsonResponse(res, status, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, x-api-key, anthropic-version, Authorization',
+    });
+    res.end(body);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ─── Antigravity CDP Operations ──────────────────────────────────────
+async function getConversationText(page) {
+    const text = await page.evaluate(`
+    (() => {
+      const container = document.getElementById('conversation');
+      return container ? container.innerText : '';
+    })()
+  `);
+    return String(text ?? '');
+}
+async function sendMessage(page, message) {
+    await page.evaluate(`
+    (async () => {
+      const container = document.getElementById('antigravity.agentSidePanelInputBox');
+      if (!container) throw new Error('Could not find antigravity.agentSidePanelInputBox');
+      const editor = container.querySelector('[data-lexical-editor="true"]');
+      if (!editor) throw new Error('Could not find Antigravity input box');
+      
+      editor.focus();
+      document.execCommand('insertText', false, ${JSON.stringify(message)});
+    })()
+  `);
+    await sleep(500);
+    await page.pressKey('Enter');
+}
+async function waitForReply(page, beforeText, opts = {}) {
+    const timeout = opts.timeout ?? 120_000; // 2 minutes max
+    const pollInterval = opts.pollInterval ?? 500; // 500ms polling
+    const stableThreshold = opts.stableThreshold ?? 6; // 6 × 500ms = 3s stable
+    const deadline = Date.now() + timeout;
+    let lastText = beforeText;
+    let stableCount = 0;
+    // Wait a bit for the model to start generating
+    await sleep(1000);
+    while (Date.now() < deadline) {
+        const current = await getConversationText(page);
+        if (current.length > beforeText.length) {
+            // New content appeared
+            if (current === lastText) {
+                stableCount++;
+                if (stableCount >= stableThreshold) {
+                    // Text has been stable — reply is complete
+                    return current.slice(beforeText.length).trim();
+                }
+            }
+            else {
+                // Still generating
+                stableCount = 0;
+                lastText = current;
+            }
+        }
+        await sleep(pollInterval);
+    }
+    // Timeout — return whatever we have
+    const finalText = await getConversationText(page);
+    if (finalText.length > beforeText.length) {
+        return finalText.slice(beforeText.length).trim();
+    }
+    throw new Error('Timeout waiting for Antigravity reply');
+}
+// ─── Request Handlers ────────────────────────────────────────────────
+async function handleMessages(body, page) {
+    // Extract the last user message
+    const userMessages = body.messages.filter(m => m.role === 'user');
+    if (userMessages.length === 0) {
+        throw new Error('No user message found in request');
+    }
+    const lastUserMsg = userMessages[userMessages.length - 1];
+    const userText = extractTextContent(lastUserMsg.content);
+    if (!userText.trim()) {
+        throw new Error('Empty user message');
+    }
+    // Get conversation state before sending
+    const beforeText = await getConversationText(page);
+    // Send the message
+    console.error(`[serve] Sending: "${userText.slice(0, 80)}${userText.length > 80 ? '...' : ''}"`);
+    await sendMessage(page, userText);
+    // Poll for reply
+    console.error('[serve] Waiting for reply...');
+    const replyText = await waitForReply(page, beforeText);
+    console.error(`[serve] Got reply: "${replyText.slice(0, 80)}${replyText.length > 80 ? '...' : ''}"`);
+    return {
+        id: generateMsgId(),
+        type: 'message',
+        role: 'assistant',
+        content: [{ type: 'text', text: replyText }],
+        model: body.model ?? 'antigravity',
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: {
+            input_tokens: estimateTokens(userText),
+            output_tokens: estimateTokens(replyText),
+        },
+    };
+}
+// ─── Server ──────────────────────────────────────────────────────────
+export async function startServe(opts = {}) {
+    const port = opts.port ?? 8082;
+    // Establish persistent CDP connection
+    console.error('[serve] Connecting to Antigravity via CDP...');
+    const cdp = new CDPBridge();
+    const page = await cdp.connect({ timeout: 15_000 });
+    console.error('[serve] CDP connected successfully.');
+    // Verify we can read conversation
+    const testText = await getConversationText(page);
+    console.error(`[serve] Conversation element found (${testText.length} chars).`);
+    let requestInFlight = false;
+    const server = createServer(async (req, res) => {
+        // CORS preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, x-api-key, anthropic-version, Authorization',
+            });
+            res.end();
+            return;
+        }
+        const url = req.url ?? '/';
+        const pathname = url.split('?')[0];
+        try {
+            // GET /v1/models — return available models
+            if (req.method === 'GET' && pathname === '/v1/models') {
+                jsonResponse(res, 200, {
+                    data: [
+                        {
+                            id: 'antigravity',
+                            object: 'model',
+                            created: Math.floor(Date.now() / 1000),
+                            owned_by: 'antigravity',
+                        },
+                    ],
+                });
+                return;
+            }
+            // POST /v1/messages — main endpoint
+            if (req.method === 'POST' && pathname === '/v1/messages') {
+                if (requestInFlight) {
+                    jsonResponse(res, 429, {
+                        type: 'error',
+                        error: {
+                            type: 'rate_limit_error',
+                            message: 'Another request is currently being processed. Antigravity can only handle one request at a time.',
+                        },
+                    });
+                    return;
+                }
+                requestInFlight = true;
+                try {
+                    const rawBody = await readBody(req);
+                    const body = JSON.parse(rawBody);
+                    if (body.stream) {
+                        // We don't support streaming — return error
+                        jsonResponse(res, 400, {
+                            type: 'error',
+                            error: {
+                                type: 'invalid_request_error',
+                                message: 'Streaming is not supported. Set "stream": false.',
+                            },
+                        });
+                        return;
+                    }
+                    const response = await handleMessages(body, page);
+                    jsonResponse(res, 200, response);
+                }
+                finally {
+                    requestInFlight = false;
+                }
+                return;
+            }
+            // Health check
+            if (req.method === 'GET' && (pathname === '/' || pathname === '/health')) {
+                jsonResponse(res, 200, { ok: true, status: 'connected' });
+                return;
+            }
+            jsonResponse(res, 404, {
+                type: 'error',
+                error: { type: 'not_found_error', message: `Not found: ${pathname}` },
+            });
+        }
+        catch (err) {
+            console.error('[serve] Error:', err);
+            jsonResponse(res, 500, {
+                type: 'error',
+                error: {
+                    type: 'api_error',
+                    message: err instanceof Error ? err.message : 'Internal server error',
+                },
+            });
+        }
+    });
+    server.listen(port, '127.0.0.1', () => {
+        console.error(`\n[serve] ✅ Antigravity API proxy running at http://127.0.0.1:${port}`);
+        console.error(`[serve] Compatible with Anthropic /v1/messages API`);
+        console.error(`\n[serve] Usage with Claude Code:`);
+        console.error(`  ANTHROPIC_BASE_URL=http://localhost:${port} claude\n`);
+    });
+    // Graceful shutdown
+    const shutdown = () => {
+        console.error('\n[serve] Shutting down...');
+        cdp.close().catch(() => { });
+        server.close();
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+    // Keep alive
+    await new Promise(() => { });
+}

package/dist/clis/bilibili/download.js

@@ -10,7 +10,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { cli, Strategy } from '../../registry.js';
-import { ytdlpDownload, checkYtdlp, sanitizeFilename, getTempDir, exportCookiesToNetscape, } from '../../download/index.js';
+import { ytdlpDownload, checkYtdlp, sanitizeFilename, getTempDir, exportCookiesToNetscape, formatCookieHeader, } from '../../download/index.js';
 import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
 cli({
     site: 'bilibili',
@@ -50,26 +50,16 @@ cli({
     `);
         const title = sanitizeFilename(data?.title || 'video');
         // Extract cookies for authenticated downloads
-        const cookieString = await page.evaluate(`(() => document.cookie)()`);
+        const cookies = await page.getCookies({ domain: 'bilibili.com' });
+        const cookieString = formatCookieHeader(cookies);
         // Create output directory
         fs.mkdirSync(output, { recursive: true });
         // Export cookies to Netscape format for yt-dlp
         let cookiesFile;
-        if (typeof cookieString === 'string' && cookieString) {
+        if (cookies.length > 0) {
             const tempDir = getTempDir();
             fs.mkdirSync(tempDir, { recursive: true });
             cookiesFile = path.join(tempDir, `bilibili_cookies_${Date.now()}.txt`);
-            const cookies = cookieString.split(';').map((c) => {
-                const [name, ...rest] = c.trim().split('=');
-                return {
-                    name: name || '',
-                    value: rest.join('=') || '',
-                    domain: '.bilibili.com',
-                    path: '/',
-                    secure: true,
-                    httpOnly: false,
-                };
-            }).filter((c) => c.name);
             exportCookiesToNetscape(cookies, cookiesFile);
         }
         // Build yt-dlp format string based on quality

package/dist/clis/boss/chatlist.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/boss/chatlist.js

@@ -0,0 +1,50 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'boss',
+    name: 'chatlist',
+    description: 'BOSS直聘查看聊天列表（招聘端）',
+    domain: 'www.zhipin.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'page', type: 'int', default: 1, help: 'Page number' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+        { name: 'job_id', default: '0', help: 'Filter by job ID (0=all)' },
+    ],
+    columns: ['name', 'job', 'last_msg', 'last_time', 'uid', 'security_id'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Browser page required');
+        await page.goto('https://www.zhipin.com/web/chat/index');
+        await page.wait({ time: 2 });
+        const jobId = kwargs.job_id || '0';
+        const pageNum = kwargs.page || 1;
+        const limit = kwargs.limit || 20;
+        const targetUrl = `https://www.zhipin.com/wapi/zprelation/friend/getBossFriendListV2.json?page=${pageNum}&status=0&jobId=${jobId}`;
+        const data = await page.evaluate(`
+      async () => {
+        return new Promise((resolve, reject) => {
+          const xhr = new XMLHttpRequest();
+          xhr.open('GET', '${targetUrl}', true);
+          xhr.withCredentials = true;
+          xhr.timeout = 15000;
+          xhr.setRequestHeader('Accept', 'application/json');
+          xhr.onload = () => { try { resolve(JSON.parse(xhr.responseText)); } catch(e) { reject(new Error('JSON parse failed')); } };
+          xhr.onerror = () => reject(new Error('Network Error'));
+          xhr.send();
+        });
+      }
+    `);
+        if (data.code !== 0)
+            throw new Error(`API error: ${data.message} (code=${data.code})`);
+        const friends = (data.zpData?.friendList || []).slice(0, limit);
+        return friends.map((f) => ({
+            name: f.name || '',
+            job: f.jobName || '',
+            last_msg: f.lastMessageInfo?.text || '',
+            last_time: f.lastTime || '',
+            uid: f.encryptUid || '',
+            security_id: f.securityId || '',
+        }));
+    },
+});

package/dist/clis/boss/chatmsg.d.ts

@@ -0,0 +1 @@
+export {};