@jackwener/opencli 1.0.1 → 1.0.4

package/dist/explore.js

@@ -9,6 +9,9 @@ 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';
+import { detectFramework } from './scripts/framework.js';
+import { discoverStores } from './scripts/store.js';
+import { interactFuzz } from './scripts/interact.js';
 // ── Site name detection ────────────────────────────────────────────────────
 const KNOWN_SITE_ALIASES = {
     'x.com': 'twitter', 'twitter.com': 'twitter',
@@ -134,11 +137,13 @@ function flattenFields(obj, prefix, maxDepth) {
     if (maxDepth <= 0 || !obj || typeof obj !== 'object')
         return [];
     const names = [];
-    for (const key of Object.keys(obj)) {
+    const record = obj;
+    for (const key of Object.keys(record)) {
         const full = prefix ? `${prefix}.${key}` : key;
         names.push(full);
-        if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key]))
-            names.push(...flattenFields(obj[key], full, maxDepth - 1));
+        const val = record[key];
+        if (val && typeof val === 'object' && !Array.isArray(val))
+            names.push(...flattenFields(val, full, maxDepth - 1));
     }
     return names;
 }
@@ -200,83 +205,11 @@ function inferStrategy(authIndicators) {
     return 'cookie';
 }
 // ── Framework detection ────────────────────────────────────────────────────
-const FRAMEWORK_DETECT_JS = `
-  () => {
-    const r = {};
-    try {
-      const app = document.querySelector('#app');
-      r.vue3 = !!(app && app.__vue_app__);
-      r.vue2 = !!(app && app.__vue__);
-      r.react = !!window.__REACT_DEVTOOLS_GLOBAL_HOOK__ || !!document.querySelector('[data-reactroot]');
-      r.nextjs = !!window.__NEXT_DATA__;
-      r.nuxt = !!window.__NUXT__;
-      if (r.vue3 && app.__vue_app__) { const gp = app.__vue_app__.config?.globalProperties; r.pinia = !!(gp && gp.$pinia); r.vuex = !!(gp && gp.$store); }
-    } catch {}
-    return r;
-  }
-`;
+const FRAMEWORK_DETECT_JS = detectFramework.toString();
 // ── Store discovery ────────────────────────────────────────────────────────
-const STORE_DISCOVER_JS = `
-  () => {
-    const stores = [];
-    try {
-      const app = document.querySelector('#app');
-      if (!app?.__vue_app__) return stores;
-      const gp = app.__vue_app__.config?.globalProperties;
-
-      // Pinia stores
-      const pinia = gp?.$pinia;
-      if (pinia?._s) {
-        pinia._s.forEach((store, id) => {
-          const actions = [];
-          const stateKeys = [];
-          for (const k in store) {
-            try {
-              if (k.startsWith('$') || k.startsWith('_')) continue;
-              if (typeof store[k] === 'function') actions.push(k);
-              else stateKeys.push(k);
-            } catch {}
-          }
-          stores.push({ type: 'pinia', id, actions: actions.slice(0, 20), stateKeys: stateKeys.slice(0, 15) });
-        });
-      }
-
-      // Vuex store modules
-      const vuex = gp?.$store;
-      if (vuex?._modules?.root?._children) {
-        const children = vuex._modules.root._children;
-        for (const [modName, mod] of Object.entries(children)) {
-          const actions = Object.keys(mod._rawModule?.actions ?? {}).slice(0, 20);
-          const stateKeys = Object.keys(mod.state ?? {}).slice(0, 15);
-          stores.push({ type: 'vuex', id: modName, actions, stateKeys });
-        }
-      }
-    } catch {}
-    return stores;
-  }
-`;
+const STORE_DISCOVER_JS = discoverStores.toString();
 // ── Auto-Interaction (Fuzzing) ─────────────────────────────────────────────
-const INTERACT_FUZZ_JS = `
-  async () => {
-    const sleep = ms => new Promise(r => setTimeout(r, ms));
-    const clickables = Array.from(document.querySelectorAll(
-      'button, [role="button"], [role="tab"], .tab, .btn, a[href="javascript:void(0)"], a[href="#"]'
-    )).slice(0, 15); // limit to 15 to avoid endless loops
-
-    let clicked = 0;
-    for (const el of clickables) {
-      try {
-        const rect = el.getBoundingClientRect();
-        if (rect.width > 0 && rect.height > 0) {
-          el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
-          clicked++;
-          await sleep(300); // give it time to trigger network
-        }
-      } catch {}
-    }
-    return clicked;
-  }
-`;
+const INTERACT_FUZZ_JS = interactFuzz.toString();
 // ── Main explore function ──────────────────────────────────────────────────
 export async function exploreUrl(url, opts) {
     const waitSeconds = opts.waitSeconds ?? 3.0;
@@ -286,25 +219,19 @@ export async function exploreUrl(url, opts) {
             // Step 1: Navigate
             await page.goto(url);
             await page.wait(waitSeconds);
-            // Step 2: Auto-scroll to trigger lazy loading (use keyboard since page.scroll may not exist)
-            for (let i = 0; i < 3; i++) {
-                try {
-                    await page.pressKey('End');
-                }
-                catch { }
-                await page.wait(1);
-            }
+            // Step 2: Auto-scroll to trigger lazy loading intelligently
+            await page.autoScroll({ times: 3, delayMs: 1500 }).catch(() => { });
             // Step 2.5: Interactive Fuzzing (if requested)
             if (opts.auto) {
                 try {
                     // First: targeted clicks by label (e.g. "字幕", "CC", "评论")
                     if (opts.clickLabels?.length) {
                         for (const label of opts.clickLabels) {
-                            const safeLabel = label.replace(/'/g, "\\'");
+                            const safeLabel = JSON.stringify(label);
                             await page.evaluate(`
                  (() => {
                    const el = [...document.querySelectorAll('button, [role="button"], [role="tab"], a, span')]
-                     .find(e => e.textContent && e.textContent.trim().includes('${safeLabel}'));
+                     .find(e => e.textContent && e.textContent.trim().includes(${safeLabel}));
                    if (el) el.click();
                  })()
                `);
@@ -324,11 +251,27 @@ export async function exploreUrl(url, opts) {
             // Step 4: Capture network traffic
             const rawNetwork = await page.networkRequests(false);
             const networkEntries = parseNetworkRequests(rawNetwork);
-            // Step 5: For JSON endpoints, re-fetch response body in-browser
-            const jsonEndpoints = networkEntries.filter(e => e.contentType.includes('json') && e.method === 'GET' && e.status === 200);
-            for (const ep of jsonEndpoints.slice(0, 10)) {
+            // Step 5: For JSON endpoints missing a body, carefully re-fetch in-browser via a pristine iframe
+            const jsonEndpoints = networkEntries.filter(e => e.contentType.includes('json') && e.method === 'GET' && e.status === 200 && !e.responseBody);
+            await Promise.allSettled(jsonEndpoints.slice(0, 5).map(async (ep) => {
                 try {
-                    const body = await page.evaluate(`async () => { try { const r = await fetch(${JSON.stringify(ep.url)}, {credentials:'include'}); if (!r.ok) return null; const d = await r.json(); return JSON.stringify(d).slice(0,10000); } catch { return null; } }`);
+                    const body = await page.evaluate(`async () => {
+            let iframe = null;
+            try {
+              iframe = document.createElement('iframe');
+              iframe.style.display = 'none';
+              document.body.appendChild(iframe);
+              const cleanFetch = iframe.contentWindow.fetch || window.fetch;
+              const r = await cleanFetch(${JSON.stringify(ep.url)}, { credentials: 'include' });
+              if (!r.ok) return null;
+              const d = await r.json();
+              return JSON.stringify(d).slice(0, 10000);
+            } catch {
+              return null;
+            } finally {
+              if (iframe && iframe.parentNode) iframe.parentNode.removeChild(iframe);
+            }
+          }`);
                     if (body && typeof body === 'string') {
                         try {
                             ep.responseBody = JSON.parse(body);
@@ -339,7 +282,7 @@ export async function exploreUrl(url, opts) {
                         ep.responseBody = body;
                 }
                 catch { }
-            }
+            }));
             // Step 6: Detect framework
             let framework = {};
             try {
@@ -443,7 +386,7 @@ export async function exploreUrl(url, opts) {
             const topStrategy = allAuth.has('signature') ? 'intercept' : allAuth.has('bearer') || allAuth.has('csrf') ? 'header' : allAuth.size === 0 ? 'public' : 'cookie';
             const siteName = opts.site ?? detectSiteName(metadata.url || url);
             const targetDir = opts.outDir ?? path.join('.opencli', 'explore', siteName);
-            fs.mkdirSync(targetDir, { recursive: true });
+            await fs.promises.mkdir(targetDir, { recursive: true });
             const result = {
                 site: siteName, target_url: url, final_url: metadata.url, title: metadata.title,
                 framework, stores, top_strategy: topStrategy,
@@ -452,27 +395,29 @@ export async function exploreUrl(url, opts) {
                 capabilities, auth_indicators: [...allAuth],
             };
             // Write artifacts
-            fs.writeFileSync(path.join(targetDir, 'manifest.json'), JSON.stringify({
+            const writeTasks = [];
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'manifest.json'), JSON.stringify({
                 site: siteName, target_url: url, final_url: metadata.url, title: metadata.title,
                 framework, stores: stores.map(s => ({ type: s.type, id: s.id, actions: s.actions })),
                 top_strategy: topStrategy, explored_at: new Date().toISOString(),
-            }, null, 2));
-            fs.writeFileSync(path.join(targetDir, 'endpoints.json'), JSON.stringify(analyzedEndpoints.map(ep => ({
+            }, null, 2)));
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'endpoints.json'), JSON.stringify(analyzedEndpoints.map(ep => ({
                 pattern: ep.pattern, method: ep.method, url: ep.url, status: ep.status,
                 contentType: ep.contentType, score: ep.score, queryParams: ep.queryParams,
                 itemPath: ep.responseAnalysis?.itemPath ?? null, itemCount: ep.responseAnalysis?.itemCount ?? 0,
                 detectedFields: ep.responseAnalysis?.detectedFields ?? {}, authIndicators: ep.authIndicators,
-            })), null, 2));
-            fs.writeFileSync(path.join(targetDir, 'capabilities.json'), JSON.stringify(capabilities, null, 2));
-            fs.writeFileSync(path.join(targetDir, 'auth.json'), JSON.stringify({
+            })), null, 2)));
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'capabilities.json'), JSON.stringify(capabilities, null, 2)));
+            writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'auth.json'), JSON.stringify({
                 top_strategy: topStrategy, indicators: [...allAuth], framework,
-            }, null, 2));
+            }, null, 2)));
             if (stores.length > 0) {
-                fs.writeFileSync(path.join(targetDir, 'stores.json'), JSON.stringify(stores, null, 2));
+                writeTasks.push(fs.promises.writeFile(path.join(targetDir, 'stores.json'), JSON.stringify(stores, null, 2)));
             }
+            await Promise.all(writeTasks);
             return { ...result, out_dir: targetDir };
         })(), { timeout: exploreTimeout, label: `Explore ${url}` });
-    });
+    }, { workspace: opts.workspace });
 }
 export function renderExploreSummary(result) {
     const lines = [

package/dist/generate.js

@@ -60,6 +60,7 @@ export async function generateCliFromUrl(opts) {
         site: opts.site,
         goal: normalizeGoal(opts.goal) ?? opts.goal,
         waitSeconds: opts.waitSeconds ?? 3,
+        workspace: opts.workspace,
     });
     // Step 2: Synthesize candidates
     const synthesizeResult = synthesizeFromExplore(exploreResult.out_dir, {

package/dist/interceptor.js

@@ -22,6 +22,7 @@ export function generateInterceptorJs(patternExpr, opts = {}) {
     return `
     () => {
       window.${arr} = window.${arr} || [];
+      window.${arr}_errors = window.${arr}_errors || [];
       const __pattern = ${patternExpr};
 
       if (!window.${guard}) {
@@ -38,7 +39,7 @@ export function generateInterceptorJs(patternExpr, opts = {}) {
               const clone = response.clone();
               const json = await clone.json();
               window.${arr}.push(json);
-            } catch(e) {}
+            } catch(e) { window.${arr}_errors.push({ url: reqUrl, error: String(e) }); }
           }
           return response;
         };
@@ -56,7 +57,7 @@ export function generateInterceptorJs(patternExpr, opts = {}) {
             this.addEventListener('load', function() {
               try {
                 window.${arr}.push(JSON.parse(this.responseText));
-              } catch(e) {}
+              } catch(e) { window.${arr}_errors.push({ url: this.__opencli_url, error: String(e) }); }
             });
           }
           return __origSend.apply(this, arguments);

package/dist/main.js

@@ -5,16 +5,9 @@
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { discoverClis, executeCommand } from './engine.js';
-import { fullName, getRegistry, strategyLabel } from './registry.js';
-import { render as renderOutput } from './output.js';
-import { BrowserBridge } from './browser/index.js';
-import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
-import { PKG_VERSION } from './version.js';
-import { getCompletions, printCompletionScript } from './completion.js';
-import { CliError } from './errors.js';
+import { discoverClis } from './engine.js';
+import { getCompletions } from './completion.js';
+import { runCli } from './cli.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
@@ -42,186 +35,4 @@ if (getCompIdx !== -1) {
     process.stdout.write(candidates.join('\n') + '\n');
     process.exit(0);
 }
-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; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: BrowserBridge, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels }))); });
-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 r = await generateCliFromUrl({ url, BrowserFactory: BrowserBridge, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site }); 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 result = await browserSession(BrowserBridge, 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);
-    });
-    console.log(renderCascadeResult(result));
-});
-program.command('doctor')
-    .description('Diagnose opencli browser bridge connectivity')
-    .option('--live', 'Test browser connectivity (requires Chrome running)', false)
-    .action(async (opts) => {
-    const { runBrowserDoctor, renderBrowserDoctorReport } = await import('./doctor.js');
-    const report = await runBrowserDoctor({ live: opts.live, 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);
-});
-// ── Dynamic site commands ──────────────────────────────────────────────────
-const registry = getRegistry();
-const siteGroups = new Map();
-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 (cmd.browser) {
-                result = await browserSession(BrowserBridge, async (page) => {
-                    return runWithTimeout(executeCommand(cmd, page, kwargs, actionOpts.verbose), { timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT, label: fullName(cmd) });
-                });
-            }
-            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.`));
-            }
-            renderOutput(result, { fmt: actionOpts.format, columns: cmd.columns, title: `${cmd.site}/${cmd.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(cmd) });
-        }
-        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();
+runCli(BUILTIN_CLIS, USER_CLIS);

package/dist/output.d.ts

@@ -7,5 +7,6 @@ export interface RenderOptions {
     title?: string;
     elapsed?: number;
     source?: string;
+    footerExtra?: string;
 }
-export declare function render(data: any, opts?: RenderOptions): void;
+export declare function render(data: unknown, opts?: RenderOptions): void;

package/dist/output.js

@@ -60,6 +60,8 @@ function renderTable(data, opts) {
         footer.push(`${opts.elapsed.toFixed(1)}s`);
     if (opts.source)
         footer.push(opts.source);
+    if (opts.footerExtra)
+        footer.push(opts.footerExtra);
     console.log(chalk.dim(footer.join(' · ')));
 }
 function renderJson(data) {
@@ -85,7 +87,7 @@ function renderCsv(data, opts) {
     for (const row of rows) {
         console.log(columns.map(c => {
             const v = String(row[c] ?? '');
-            return v.includes(',') || v.includes('"') || v.includes('\n')
+            return v.includes(',') || v.includes('"') || v.includes('\n') || v.includes('\r')
                 ? `"${v.replace(/"/g, '""')}"` : v;
         }).join(','));
     }

package/dist/pipeline/executor.test.js

@@ -8,6 +8,7 @@ function createMockPage(overrides = {}) {
     return {
         goto: vi.fn(),
         evaluate: vi.fn().mockResolvedValue(null),
+        getCookies: vi.fn().mockResolvedValue([]),
         snapshot: vi.fn().mockResolvedValue(''),
         click: vi.fn(),
         typeText: vi.fn(),

package/dist/pipeline/steps/download.js

@@ -10,7 +10,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { render } from '../template.js';
-import { httpDownload, ytdlpDownload, saveDocument, detectContentType, requiresYtdlp, sanitizeFilename, generateFilename, exportCookiesToNetscape, getTempDir, } from '../../download/index.js';
+import { httpDownload, ytdlpDownload, saveDocument, detectContentType, requiresYtdlp, sanitizeFilename, generateFilename, exportCookiesToNetscape, getTempDir, formatCookieHeader, } from '../../download/index.js';
 import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
 /**
  * Simple async concurrency limiter for downloads.
@@ -33,9 +33,8 @@ async function mapConcurrent(items, limit, fn) {
  */
 async function extractBrowserCookies(page, domain) {
     try {
-        // Use browser evaluate to get document.cookie
-        const cookieString = await page.evaluate(`(() => document.cookie)()`);
-        return typeof cookieString === 'string' ? cookieString : '';
+        const cookies = await page.getCookies(domain ? { domain } : {});
+        return formatCookieHeader(cookies);
     }
     catch {
         return '';
@@ -46,20 +45,17 @@ async function extractBrowserCookies(page, domain) {
  */
 async function extractCookiesArray(page, domain) {
     try {
-        const cookieString = await extractBrowserCookies(page);
-        if (!cookieString)
-            return [];
-        return cookieString.split(';').map((c) => {
-            const [name, ...rest] = c.trim().split('=');
-            return {
-                name: name || '',
-                value: rest.join('=') || '',
-                domain,
-                path: '/',
-                secure: true,
-                httpOnly: false,
-            };
-        }).filter((c) => c.name);
+        const cookies = await page.getCookies({ domain });
+        return cookies
+            .filter((cookie) => cookie.name)
+            .map((cookie) => ({
+            name: cookie.name,
+            value: cookie.value,
+            domain: cookie.domain,
+            path: cookie.path ?? '/',
+            secure: cookie.secure ?? false,
+            httpOnly: cookie.httpOnly ?? false,
+        }));
     }
     catch {
         return [];

package/dist/registry.d.ts

@@ -12,7 +12,7 @@ export declare enum Strategy {
 export interface Arg {
     name: string;
     type?: string;
-    default?: any;
+    default?: unknown;
     required?: boolean;
     positional?: boolean;
     help?: string;
@@ -27,10 +27,11 @@ export interface CliCommand {
     browser?: boolean;
     args: Arg[];
     columns?: string[];
-    func?: (page: IPage, kwargs: Record<string, any>, debug?: boolean) => Promise<any>;
-    pipeline?: any[];
+    func?: (page: IPage, kwargs: Record<string, any>, debug?: boolean) => Promise<unknown>;
+    pipeline?: Record<string, unknown>[];
     timeoutSeconds?: number;
     source?: string;
+    footerExtra?: (kwargs: Record<string, any>) => string | undefined;
 }
 /** Internal extension for lazy-loaded TS modules (not exposed in public API) */
 export interface InternalCliCommand extends CliCommand {

package/dist/registry.js

@@ -11,18 +11,21 @@ export var Strategy;
 })(Strategy || (Strategy = {}));
 const _registry = new Map();
 export function cli(opts) {
+    const strategy = opts.strategy ?? (opts.browser === false ? Strategy.PUBLIC : Strategy.COOKIE);
+    const browser = opts.browser ?? (strategy !== Strategy.PUBLIC);
     const cmd = {
         site: opts.site,
         name: opts.name,
         description: opts.description ?? '',
         domain: opts.domain,
-        strategy: opts.strategy ?? (opts.browser === false ? Strategy.PUBLIC : Strategy.COOKIE),
-        browser: opts.browser ?? (opts.strategy === Strategy.PUBLIC ? false : true),
+        strategy,
+        browser,
         args: opts.args ?? [],
         columns: opts.columns,
         func: opts.func,
         pipeline: opts.pipeline,
         timeoutSeconds: opts.timeoutSeconds,
+        footerExtra: opts.footerExtra,
     };
     const key = fullName(cmd);
     _registry.set(key, cmd);

package/dist/runtime.d.ts

@@ -18,7 +18,10 @@ export declare function withTimeoutMs<T>(promise: Promise<T>, timeoutMs: number,
 export interface IBrowserFactory {
     connect(opts?: {
         timeout?: number;
+        workspace?: string;
     }): Promise<IPage>;
     close(): Promise<void>;
 }
-export declare function browserSession<T>(BrowserFactory: new () => IBrowserFactory, fn: (page: IPage) => Promise<T>): Promise<T>;
+export declare function browserSession<T>(BrowserFactory: new () => IBrowserFactory, fn: (page: IPage) => Promise<T>, opts?: {
+    workspace?: string;
+}): Promise<T>;

package/dist/runtime.js

@@ -17,10 +17,10 @@ export function withTimeoutMs(promise, timeoutMs, message) {
         promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
     });
 }
-export async function browserSession(BrowserFactory, fn) {
+export async function browserSession(BrowserFactory, fn, opts = {}) {
     const mcp = new BrowserFactory();
     try {
-        const page = await mcp.connect({ timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT });
+        const page = await mcp.connect({ timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT, workspace: opts.workspace });
         return await fn(page);
     }
     finally {

package/dist/scripts/framework.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Injected script for detecting frontend frameworks (Vue, React, Next, Nuxt, etc.)
+ */
+export declare function detectFramework(): Record<string, boolean>;