@jackwener/opencli 0.5.1 → 0.6.0

package/dist/doctor.js

@@ -1,23 +1,57 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { execSync } from 'node:child_process';
 import { createInterface } from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
+import chalk from 'chalk';
 import { getTokenFingerprint } from './browser.js';
 const PLAYWRIGHT_SERVER_NAME = 'playwright';
-const PLAYWRIGHT_TOKEN_ENV = 'PLAYWRIGHT_MCP_EXTENSION_TOKEN';
+export const PLAYWRIGHT_TOKEN_ENV = 'PLAYWRIGHT_MCP_EXTENSION_TOKEN';
 const PLAYWRIGHT_EXTENSION_ID = 'mmlmfjhmonkocbjadbfplnigmagldckm';
 const TOKEN_LINE_RE = /^(\s*export\s+PLAYWRIGHT_MCP_EXTENSION_TOKEN=)(['"]?)([^'"\\\n]+)\2\s*$/m;
-function label(status) {
-    return `[${status}]`;
+function colorLabel(status) {
+    switch (status) {
+        case 'OK': return chalk.green('[OK]');
+        case 'MISSING': return chalk.red('[MISSING]');
+        case 'MISMATCH': return chalk.yellow('[MISMATCH]');
+        case 'WARN': return chalk.yellow('[WARN]');
+    }
 }
 function statusLine(status, text) {
-    return `${label(status)} ${text}`;
+    return `${colorLabel(status)} ${text}`;
 }
 function tokenSummary(token, fingerprint) {
     if (!token)
-        return 'missing';
-    return `configured (${fingerprint})`;
+        return chalk.dim('missing');
+    return `configured ${chalk.dim(`(${fingerprint})`)}`;
+}
+export function shortenPath(p) {
+    const home = os.homedir();
+    return home && p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}
+export function toolName(p) {
+    if (p.includes('.codex/'))
+        return 'Codex';
+    if (p.includes('.cursor/'))
+        return 'Cursor';
+    if (p.includes('.claude.json'))
+        return 'Claude Code';
+    if (p.includes('antigravity'))
+        return 'Antigravity';
+    if (p.includes('.gemini/settings'))
+        return 'Gemini CLI';
+    if (p.includes('opencode'))
+        return 'OpenCode';
+    if (p.includes('Claude/claude_desktop'))
+        return 'Claude Desktop';
+    if (p.includes('.vscode/'))
+        return 'VS Code';
+    if (p.includes('.mcp.json'))
+        return 'Project MCP';
+    if (p.includes('.zshrc') || p.includes('.bashrc') || p.includes('.profile'))
+        return 'Shell';
+    return '';
 }
 export function getDefaultShellRcPath() {
     const shell = process.env.SHELL ?? '';
@@ -33,12 +67,16 @@ export function getDefaultMcpConfigPaths(cwd = process.cwd()) {
         path.join(home, '.codex', 'config.toml'),
         path.join(home, '.codex', 'mcp.json'),
         path.join(home, '.cursor', 'mcp.json'),
+        path.join(home, '.claude.json'),
+        path.join(home, '.gemini', 'settings.json'),
+        path.join(home, '.gemini', 'antigravity', 'mcp_config.json'),
         path.join(home, '.config', 'opencode', 'opencode.json'),
         path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
         path.join(home, '.config', 'Claude', 'claude_desktop_config.json'),
         path.join(cwd, '.cursor', 'mcp.json'),
         path.join(cwd, '.vscode', 'mcp.json'),
         path.join(cwd, '.opencode', 'opencode.json'),
+        path.join(cwd, '.mcp.json'),
     ];
     return [...new Set(candidates)];
 }
@@ -119,7 +157,7 @@ export function upsertTomlConfigToken(content, token) {
     const prefix = content.trim() ? `${content.replace(/\s*$/, '')}\n\n` : '';
     return `${prefix}[mcp_servers.playwright]\ntype = "stdio"\ncommand = "npx"\nargs = ["-y", "@playwright/mcp@latest", "--extension"]\n\n[mcp_servers.playwright.env]\n${tokenLine}\n`;
 }
-function fileExists(filePath) {
+export function fileExists(filePath) {
     try {
         return fs.existsSync(filePath);
     }
@@ -169,6 +207,144 @@ function readConfigStatus(filePath) {
         };
     }
 }
+/**
+ * Discover the auth token stored by the Playwright MCP Bridge extension
+ * by scanning Chrome's LevelDB localStorage files directly.
+ *
+ * Uses `strings` + `grep` for fast binary scanning on macOS/Linux,
+ * with a pure-Node fallback on Windows.
+ */
+export function discoverExtensionToken() {
+    const home = os.homedir();
+    const platform = os.platform();
+    const bases = [];
+    if (platform === 'darwin') {
+        bases.push(path.join(home, 'Library', 'Application Support', 'Google', 'Chrome'), path.join(home, 'Library', 'Application Support', 'Google', 'Chrome Canary'), path.join(home, 'Library', 'Application Support', 'Chromium'), path.join(home, 'Library', 'Application Support', 'Microsoft Edge'));
+    }
+    else if (platform === 'linux') {
+        bases.push(path.join(home, '.config', 'google-chrome'), path.join(home, '.config', 'chromium'), path.join(home, '.config', 'microsoft-edge'));
+    }
+    else if (platform === 'win32') {
+        const appData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+        bases.push(path.join(appData, 'Google', 'Chrome', 'User Data'), path.join(appData, 'Microsoft', 'Edge', 'User Data'));
+    }
+    const profiles = ['Default', 'Profile 1', 'Profile 2', 'Profile 3'];
+    // Token is 43 chars of base64url (from 32 random bytes)
+    const tokenRe = /([A-Za-z0-9_-]{40,50})/;
+    for (const base of bases) {
+        for (const profile of profiles) {
+            const dir = path.join(base, profile, 'Local Storage', 'leveldb');
+            if (!fileExists(dir))
+                continue;
+            // Fast path: use strings + grep to find candidate files and extract token
+            if (platform !== 'win32') {
+                const token = extractTokenViaStrings(dir, tokenRe);
+                if (token)
+                    return token;
+                continue;
+            }
+            // Slow path (Windows): read binary files directly
+            const token = extractTokenViaBinaryRead(dir, tokenRe);
+            if (token)
+                return token;
+        }
+    }
+    return null;
+}
+function extractTokenViaStrings(dir, tokenRe) {
+    try {
+        // Single shell pipeline: for each LevelDB file, extract strings, find lines
+        // after the extension ID, and filter for base64url token pattern.
+        //
+        // LevelDB `strings` output for the extension's auth-token entry:
+        //   auth-token                                    ← key name
+        //   4,mmlmfjhmonkocbjadbfplnigmagldckm.7          ← LevelDB internal key
+        //   hqI86ncsD1QpcVcj-k9CyzTF-ieCQd_4KreZ_wy1WHA  ← token value
+        //
+        // We get the line immediately after any EXTENSION_ID mention and check
+        // if it looks like a base64url token (40-50 chars, [A-Za-z0-9_-]).
+        const shellDir = dir.replace(/'/g, "'\\''");
+        const cmd = `for f in '${shellDir}'/*.ldb '${shellDir}'/*.log; do ` +
+            `[ -f "$f" ] && strings "$f" 2>/dev/null | ` +
+            `grep -A1 '${PLAYWRIGHT_EXTENSION_ID}' | ` +
+            `grep -v '${PLAYWRIGHT_EXTENSION_ID}' | ` +
+            `grep -E '^[A-Za-z0-9_-]{40,50}$' | head -1; ` +
+            `done 2>/dev/null`;
+        const result = execSync(cmd, { encoding: 'utf-8', timeout: 10000 }).trim();
+        // Take the first non-empty line
+        for (const line of result.split('\n')) {
+            const token = line.trim();
+            if (token && validateBase64urlToken(token))
+                return token;
+        }
+    }
+    catch { }
+    return null;
+}
+function extractTokenViaBinaryRead(dir, tokenRe) {
+    const extIdBuf = Buffer.from(PLAYWRIGHT_EXTENSION_ID);
+    const keyBuf = Buffer.from('auth-token');
+    let files;
+    try {
+        files = fs.readdirSync(dir)
+            .filter(f => f.endsWith('.ldb') || f.endsWith('.log'))
+            .map(f => path.join(dir, f));
+    }
+    catch {
+        return null;
+    }
+    // Sort by mtime descending
+    files.sort((a, b) => {
+        try {
+            return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    });
+    for (const file of files) {
+        let data;
+        try {
+            data = fs.readFileSync(file);
+        }
+        catch {
+            continue;
+        }
+        // Quick check: does file contain both the extension ID and auth-token key?
+        const extPos = data.indexOf(extIdBuf);
+        if (extPos === -1)
+            continue;
+        const keyPos = data.indexOf(keyBuf, Math.max(0, extPos - 500));
+        if (keyPos === -1)
+            continue;
+        // Scan for token value after auth-token key
+        let idx = 0;
+        while (true) {
+            const kp = data.indexOf(keyBuf, idx);
+            if (kp === -1)
+                break;
+            const contextStart = Math.max(0, kp - 500);
+            if (data.indexOf(extIdBuf, contextStart) !== -1 && data.indexOf(extIdBuf, contextStart) < kp) {
+                const after = data.subarray(kp + keyBuf.length, kp + keyBuf.length + 200).toString('latin1');
+                const m = after.match(tokenRe);
+                if (m && validateBase64urlToken(m[1]))
+                    return m[1];
+            }
+            idx = kp + 1;
+        }
+    }
+    return null;
+}
+function validateBase64urlToken(token) {
+    try {
+        const b64 = token.replace(/-/g, '+').replace(/_/g, '/');
+        const decoded = Buffer.from(b64, 'base64');
+        return decoded.length >= 28 && decoded.length <= 36;
+    }
+    catch {
+        return false;
+    }
+}
 export async function runBrowserDoctor(opts = {}) {
     const envToken = process.env[PLAYWRIGHT_TOKEN_ENV] ?? null;
     const shellPath = opts.shellRc ?? getDefaultShellRcPath();
@@ -181,18 +357,23 @@ export async function runBrowserDoctor(opts = {}) {
     });
     const configPaths = opts.configPaths?.length ? opts.configPaths : getDefaultMcpConfigPaths();
     const configs = configPaths.map(readConfigStatus);
+    // Try to discover the token directly from the Chrome extension's localStorage
+    const extensionToken = discoverExtensionToken();
     const allTokens = [
         opts.token ?? null,
+        extensionToken,
         envToken,
         ...shellFiles.map(s => s.token),
         ...configs.map(c => c.token),
     ].filter((v) => !!v);
     const uniqueTokens = [...new Set(allTokens)];
-    const recommendedToken = opts.token ?? envToken ?? (uniqueTokens.length === 1 ? uniqueTokens[0] : null) ?? null;
+    const recommendedToken = opts.token ?? extensionToken ?? envToken ?? (uniqueTokens.length === 1 ? uniqueTokens[0] : null) ?? null;
     const report = {
         cliVersion: opts.cliVersion,
         envToken,
         envFingerprint: getTokenFingerprint(envToken ?? undefined),
+        extensionToken,
+        extensionFingerprint: getTokenFingerprint(extensionToken ?? undefined),
         shellFiles,
         configs,
         recommendedToken,
@@ -219,24 +400,29 @@ export async function runBrowserDoctor(opts = {}) {
 }
 export function renderBrowserDoctorReport(report) {
     const tokenFingerprints = [
+        report.extensionFingerprint,
         report.envFingerprint,
         ...report.shellFiles.map(shell => shell.fingerprint),
         ...report.configs.filter(config => config.exists).map(config => config.fingerprint),
     ].filter((value) => !!value);
     const uniqueFingerprints = [...new Set(tokenFingerprints)];
     const hasMismatch = uniqueFingerprints.length > 1;
-    const lines = [`opencli v${report.cliVersion ?? 'unknown'} doctor`, ''];
+    const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`), ''];
+    const extStatus = !report.extensionToken ? 'MISSING' : hasMismatch ? 'MISMATCH' : 'OK';
+    lines.push(statusLine(extStatus, `Extension token (Chrome LevelDB): ${tokenSummary(report.extensionToken, report.extensionFingerprint)}`));
     const envStatus = !report.envToken ? 'MISSING' : hasMismatch ? 'MISMATCH' : 'OK';
     lines.push(statusLine(envStatus, `Environment token: ${tokenSummary(report.envToken, report.envFingerprint)}`));
     for (const shell of report.shellFiles) {
         const shellStatus = !shell.token ? 'MISSING' : hasMismatch ? 'MISMATCH' : 'OK';
-        lines.push(statusLine(shellStatus, `Shell file ${shell.path}: ${tokenSummary(shell.token, shell.fingerprint)}`));
+        const tool = toolName(shell.path);
+        const suffix = tool ? chalk.dim(` [${tool}]`) : '';
+        lines.push(statusLine(shellStatus, `${shortenPath(shell.path)}${suffix}: ${tokenSummary(shell.token, shell.fingerprint)}`));
     }
     const existingConfigs = report.configs.filter(config => config.exists);
     const missingConfigCount = report.configs.length - existingConfigs.length;
     if (existingConfigs.length > 0) {
         for (const config of existingConfigs) {
-            const parseSuffix = config.parseError ? ` (parse error: ${config.parseError})` : '';
+            const parseSuffix = config.parseError ? chalk.red(` (parse error)`) : '';
             const configStatus = config.parseError
                 ? 'WARN'
                 : !config.token
@@ -244,25 +430,27 @@ export function renderBrowserDoctorReport(report) {
                     : hasMismatch
                         ? 'MISMATCH'
                         : 'OK';
-            lines.push(statusLine(configStatus, `MCP config ${config.path}: ${tokenSummary(config.token, config.fingerprint)}${parseSuffix}`));
+            const tool = toolName(config.path);
+            const suffix = tool ? chalk.dim(` [${tool}]`) : '';
+            lines.push(statusLine(configStatus, `${shortenPath(config.path)}${suffix}: ${tokenSummary(config.token, config.fingerprint)}${parseSuffix}`));
         }
     }
     else {
-        lines.push(statusLine('MISSING', 'MCP config: no existing config files found in scanned locations'));
+        lines.push(statusLine('MISSING', 'MCP config: no existing config files found'));
     }
     if (missingConfigCount > 0)
-        lines.push(`     Other scanned config locations not present: ${missingConfigCount}`);
+        lines.push(chalk.dim(`     Other scanned config locations not present: ${missingConfigCount}`));
     lines.push('');
     lines.push(statusLine(hasMismatch ? 'MISMATCH' : report.recommendedToken ? 'OK' : 'WARN', `Recommended token fingerprint: ${report.recommendedFingerprint ?? 'unavailable'}`));
     if (report.issues.length) {
-        lines.push('', 'Issues:');
+        lines.push('', chalk.yellow('Issues:'));
         for (const issue of report.issues)
-            lines.push(`- ${issue}`);
+            lines.push(chalk.dim(`  • ${issue}`));
     }
     if (report.warnings.length) {
-        lines.push('', 'Warnings:');
+        lines.push('', chalk.yellow('Warnings:'));
         for (const warning of report.warnings)
-            lines.push(`- ${warning}`);
+            lines.push(chalk.dim(`  • ${warning}`));
     }
     return lines.join('\n');
 }
@@ -276,7 +464,7 @@ async function confirmPrompt(question) {
         rl.close();
     }
 }
-function writeFileWithMkdir(filePath, content) {
+export function writeFileWithMkdir(filePath, content) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, content, 'utf-8');
 }
@@ -284,25 +472,38 @@ export async function applyBrowserDoctorFix(report, opts = {}) {
     const token = opts.token ?? report.recommendedToken;
     if (!token)
         throw new Error('No Playwright MCP token is available to write. Provide --token first.');
+    const fp = getTokenFingerprint(token);
     const plannedWrites = [];
     const shellPath = opts.shellRc ?? report.shellFiles[0]?.path ?? getDefaultShellRcPath();
-    plannedWrites.push(shellPath);
+    const shellStatus = report.shellFiles.find(s => s.path === shellPath);
+    if (shellStatus?.fingerprint !== fp)
+        plannedWrites.push(shellPath);
     for (const config of report.configs) {
         if (!config.writable)
             continue;
+        if (config.fingerprint === fp)
+            continue; // already correct
         plannedWrites.push(config.path);
     }
+    if (plannedWrites.length === 0) {
+        console.log(chalk.green('All config files are already up to date.'));
+        return [];
+    }
     if (!opts.yes) {
-        const ok = await confirmPrompt(`Update ${plannedWrites.length} file(s) with Playwright MCP token fingerprint ${getTokenFingerprint(token)}?`);
+        const ok = await confirmPrompt(`Update ${plannedWrites.length} file(s) with Playwright MCP token fingerprint ${fp}?`);
         if (!ok)
             return [];
     }
     const written = [];
-    const shellBefore = fileExists(shellPath) ? fs.readFileSync(shellPath, 'utf-8') : '';
-    writeFileWithMkdir(shellPath, upsertShellToken(shellBefore, token));
-    written.push(shellPath);
+    if (plannedWrites.includes(shellPath)) {
+        const shellBefore = fileExists(shellPath) ? fs.readFileSync(shellPath, 'utf-8') : '';
+        writeFileWithMkdir(shellPath, upsertShellToken(shellBefore, token));
+        written.push(shellPath);
+    }
     for (const config of report.configs) {
-        if (!config.writable || config.parseError)
+        if (!plannedWrites.includes(config.path))
+            continue;
+        if (config.parseError)
             continue;
         const before = fileExists(config.path) ? fs.readFileSync(config.path, 'utf-8') : '';
         const next = config.format === 'toml' ? upsertTomlConfigToken(before, token) : upsertJsonConfigToken(before, token);

package/dist/doctor.test.js

@@ -70,33 +70,40 @@ describe('json token helpers', () => {
     });
 });
 describe('doctor report rendering', () => {
+    const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
     it('renders OK-style report when tokens match', () => {
-        const text = renderBrowserDoctorReport({
+        const text = strip(renderBrowserDoctorReport({
             envToken: 'abc123',
             envFingerprint: 'fp1',
+            extensionToken: 'abc123',
+            extensionFingerprint: 'fp1',
             shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'abc123', fingerprint: 'fp1' }],
             configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
             recommendedToken: 'abc123',
             recommendedFingerprint: 'fp1',
             warnings: [],
             issues: [],
-        });
+        }));
         expect(text).toContain('[OK] Environment token: configured (fp1)');
-        expect(text).toContain('[OK] MCP config /tmp/mcp.json: configured (fp1)');
+        expect(text).toContain('[OK] /tmp/mcp.json');
+        expect(text).toContain('configured (fp1)');
     });
     it('renders MISMATCH-style report when fingerprints differ', () => {
-        const text = renderBrowserDoctorReport({
+        const text = strip(renderBrowserDoctorReport({
             envToken: 'abc123',
             envFingerprint: 'fp1',
+            extensionToken: null,
+            extensionFingerprint: null,
             shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'def456', fingerprint: 'fp2' }],
             configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
             recommendedToken: 'abc123',
             recommendedFingerprint: 'fp1',
             warnings: [],
             issues: ['Detected inconsistent Playwright MCP tokens across env/config files.'],
-        });
+        }));
         expect(text).toContain('[MISMATCH] Environment token: configured (fp1)');
-        expect(text).toContain('[MISMATCH] Shell file /tmp/.zshrc: configured (fp2)');
+        expect(text).toContain('[MISMATCH] /tmp/.zshrc');
+        expect(text).toContain('configured (fp2)');
         expect(text).toContain('[MISMATCH] Recommended token fingerprint: fp1');
     });
 });

package/dist/engine.js

@@ -73,7 +73,6 @@ function loadFromManifest(manifestPath, clisDir) {
                     columns: entry.columns,
                     timeoutSeconds: entry.timeout,
                     source: modulePath,
-                    // Mark as lazy — executeCommand will load the module before running
                     _lazy: true,
                     _modulePath: modulePath,
                 };
@@ -158,8 +157,9 @@ function registerYamlCli(filePath, defaultSite) {
  */
 export async function executeCommand(cmd, page, kwargs, debug = false) {
     // Lazy-load TS module on first execution
-    if (cmd._lazy && cmd._modulePath) {
-        const modulePath = cmd._modulePath;
+    const internal = cmd;
+    if (internal._lazy && internal._modulePath) {
+        const modulePath = internal._modulePath;
         if (!_loadedModules.has(modulePath)) {
             try {
                 await import(`file://${modulePath}`);

package/dist/engine.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for engine.ts: CLI discovery and command execution.
+ */
+export {};

package/dist/engine.test.js

@@ -0,0 +1,67 @@
+/**
+ * Tests for engine.ts: CLI discovery and command execution.
+ */
+import { describe, it, expect } from 'vitest';
+import { discoverClis, executeCommand } from './engine.js';
+import { cli, Strategy } from './registry.js';
+describe('discoverClis', () => {
+    it('handles non-existent directories gracefully', async () => {
+        // Should not throw for missing directories
+        await expect(discoverClis('/tmp/nonexistent-opencli-test-dir')).resolves.not.toThrow();
+    });
+});
+describe('executeCommand', () => {
+    it('executes a command with func', async () => {
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'func-test',
+            description: 'test command with func',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            func: async (_page, kwargs) => {
+                return [{ title: kwargs.query ?? 'default' }];
+            },
+        });
+        const result = await executeCommand(cmd, null, { query: 'hello' });
+        expect(result).toEqual([{ title: 'hello' }]);
+    });
+    it('executes a command with pipeline', async () => {
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'pipe-test',
+            description: 'test command with pipeline',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            pipeline: [
+                { evaluate: '() => [{ n: 1 }, { n: 2 }, { n: 3 }]' },
+                { limit: '2' },
+            ],
+        });
+        // Pipeline commands require page for evaluate step, so we'll test the error path
+        await expect(executeCommand(cmd, null, {})).rejects.toThrow();
+    });
+    it('throws for command with no func or pipeline', async () => {
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'empty-test',
+            description: 'empty command',
+            browser: false,
+        });
+        await expect(executeCommand(cmd, null, {})).rejects.toThrow('has no func or pipeline');
+    });
+    it('passes debug flag to func', async () => {
+        let receivedDebug = false;
+        const cmd = cli({
+            site: 'test-engine',
+            name: 'debug-test',
+            description: 'debug test',
+            browser: false,
+            func: async (_page, _kwargs, debug) => {
+                receivedDebug = debug ?? false;
+                return [];
+            },
+        });
+        await executeCommand(cmd, null, {}, true);
+        expect(receivedDebug).toBe(true);
+    });
+});

package/dist/explore.js

@@ -8,6 +8,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { DEFAULT_BROWSER_EXPLORE_TIMEOUT, browserSession, runWithTimeout } from './runtime.js';
+import { VOLATILE_PARAMS, SEARCH_PARAMS, PAGINATION_PARAMS, LIMIT_PARAMS, FIELD_ROLES } from './constants.js';
 // ── Site name detection ────────────────────────────────────────────────────
 const KNOWN_SITE_ALIASES = {
     'x.com': 'twitter', 'twitter.com': 'twitter',
@@ -39,21 +40,6 @@ export function detectSiteName(url) {
 export function slugify(value) {
     return value.trim().toLowerCase().replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-|-$/g, '') || 'site';
 }
-// ── Field & capability inference ───────────────────────────────────────────
-const FIELD_ROLES = {
-    title: ['title', 'name', 'text', 'content', 'desc', 'description', 'headline', 'subject'],
-    url: ['url', 'uri', 'link', 'href', 'permalink', 'jump_url', 'web_url', 'share_url'],
-    author: ['author', 'username', 'user_name', 'nickname', 'nick', 'owner', 'creator', 'up_name', 'uname'],
-    score: ['score', 'hot', 'heat', 'likes', 'like_count', 'view_count', 'views', 'play', 'favorite_count', 'reply_count'],
-    time: ['time', 'created_at', 'publish_time', 'pub_time', 'date', 'ctime', 'mtime', 'pubdate', 'created'],
-    id: ['id', 'aid', 'bvid', 'mid', 'uid', 'oid', 'note_id', 'item_id'],
-    cover: ['cover', 'pic', 'image', 'thumbnail', 'poster', 'avatar'],
-    category: ['category', 'tag', 'type', 'tname', 'channel', 'section'],
-};
-const SEARCH_PARAMS = new Set(['q', 'query', 'keyword', 'search', 'wd', 'kw', 'search_query', 'w']);
-const PAGINATION_PARAMS = new Set(['page', 'pn', 'offset', 'cursor', 'next', 'page_num']);
-const LIMIT_PARAMS = new Set(['limit', 'count', 'size', 'per_page', 'page_size', 'ps', 'num']);
-const VOLATILE_PARAMS = new Set(['w_rid', 'wts', '_', 'callback', 'timestamp', 't', 'nonce', 'sign']);
 /**
  * Parse raw network output from Playwright MCP.
  * Handles text format: [GET] url => [200]

package/dist/interceptor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared XHR/Fetch interceptor JavaScript generators.
+ *
+ * Provides a single source of truth for monkey-patching browser
+ * fetch() and XMLHttpRequest to capture API responses matching
+ * a URL pattern. Used by:
+ *   - Page.installInterceptor()  (browser.ts)
+ *   - stepIntercept              (pipeline/steps/intercept.ts)
+ *   - stepTap                    (pipeline/steps/tap.ts)
+ */
+/**
+ * Generate JavaScript source that installs a fetch/XHR interceptor.
+ * Captured responses are pushed to `window.__opencli_intercepted`.
+ *
+ * @param patternExpr - JS expression resolving to a URL substring to match (e.g. a JSON.stringify'd string)
+ * @param opts.arrayName - Global array name for captured data (default: '__opencli_intercepted')
+ * @param opts.patchGuard - Global boolean name to prevent double-patching (default: '__opencli_interceptor_patched')
+ */
+export declare function generateInterceptorJs(patternExpr: string, opts?: {
+    arrayName?: string;
+    patchGuard?: string;
+}): string;
+/**
+ * Generate JavaScript source to read and clear intercepted data.
+ */
+export declare function generateReadInterceptedJs(arrayName?: string): string;
+/**
+ * Generate a self-contained tap interceptor for store-action bridge.
+ * Unlike the global interceptor, this one:
+ * - Installs temporarily, restores originals in finally block
+ * - Resolves a promise on first capture (for immediate await)
+ * - Returns captured data directly
+ */
+export declare function generateTapInterceptorJs(patternExpr: string): {
+    setupVar: string;
+    capturedVar: string;
+    promiseVar: string;
+    resolveVar: string;
+    fetchPatch: string;
+    xhrPatch: string;
+    restorePatch: string;
+};