@jackwener/opencli 1.0.1 → 1.0.4

package/src/pipeline/steps/download.ts

@@ -23,6 +23,7 @@ import {
   generateFilename,
   exportCookiesToNetscape,
   getTempDir,
+  formatCookieHeader,
 } from '../../download/index.js';
 import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
 
@@ -62,9 +63,8 @@ async function mapConcurrent<T, R>(
  */
 async function extractBrowserCookies(page: IPage, domain?: string): Promise<string> {
   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 '';
   }
@@ -78,20 +78,17 @@ async function extractCookiesArray(
   domain: string,
 ): Promise<Array<{ name: string; value: string; domain: string; path: string; secure: boolean; httpOnly: boolean }>> {
   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/src/registry.ts

@@ -15,7 +15,7 @@ export enum Strategy {
 export interface Arg {
   name: string;
   type?: string;
-  default?: any;
+  default?: unknown;
   required?: boolean;
   positional?: boolean;
   help?: string;
@@ -31,10 +31,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) */
@@ -51,18 +52,21 @@ export interface CliOptions extends Partial<Omit<CliCommand, 'args' | 'descripti
 const _registry = new Map<string, CliCommand>();
 
 export function cli(opts: CliOptions): CliCommand {
+  const strategy = opts.strategy ?? (opts.browser === false ? Strategy.PUBLIC : Strategy.COOKIE);
+  const browser = opts.browser ?? (strategy !== Strategy.PUBLIC);
   const cmd: CliCommand = {
     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);

package/src/runtime.ts

@@ -30,17 +30,18 @@ export function withTimeoutMs<T>(promise: Promise<T>, timeoutMs: number, message
 
 /** Interface for browser factory (BrowserBridge or test mocks) */
 export interface IBrowserFactory {
-  connect(opts?: { timeout?: number }): Promise<IPage>;
+  connect(opts?: { timeout?: number; workspace?: string }): Promise<IPage>;
   close(): Promise<void>;
 }
 
 export async function browserSession<T>(
   BrowserFactory: new () => IBrowserFactory,
   fn: (page: IPage) => Promise<T>,
+  opts: { workspace?: string } = {},
 ): Promise<T> {
   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 {
     await mcp.close().catch(() => {});

package/src/scripts/framework.ts

@@ -0,0 +1,20 @@
+/**
+ * Injected script for detecting frontend frameworks (Vue, React, Next, Nuxt, etc.)
+ */
+export function detectFramework() {
+  const r: Record<string, boolean> = {};
+  try {
+    const app = document.querySelector('#app') as any;
+    r.vue3 = !!(app && app.__vue_app__);
+    r.vue2 = !!(app && app.__vue__);
+    r.react = !!(window as any).__REACT_DEVTOOLS_GLOBAL_HOOK__ || !!document.querySelector('[data-reactroot]');
+    r.nextjs = !!(window as any).__NEXT_DATA__;
+    r.nuxt = !!(window as any).__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;
+}

package/src/scripts/interact.ts

@@ -0,0 +1,22 @@
+/**
+ * Injected script for interactive fuzzing (clicking elements to trigger lazy loading)
+ */
+export async function interactFuzz() {
+  const sleep = (ms: number) => 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 a small number 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;
+}

package/src/scripts/store.ts

@@ -0,0 +1,40 @@
+/**
+ * Injected script for discovering Pinia or Vuex stores and their actions/state representations
+ */
+export function discoverStores() {
+  const stores: Array<{ type: string; id: string; actions: string[]; stateKeys: string[] }> = [];
+  try {
+    const app = document.querySelector('#app') as any;
+    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: any, id: string) => {
+        const actions: string[] = [];
+        const stateKeys: string[] = [];
+        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<any>(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;
+}

package/src/synthesize.ts

@@ -116,7 +116,7 @@ function buildEvaluateScript(url: string, itemPath: string, endpoint: any): stri
 
   return [
     '(async () => {',
-    `  const res = await fetch('${url}', {`,
+    `  const res = await fetch(${JSON.stringify(url)}, {`,
     `    credentials: 'include'`,
     '  });',
     '  const data = await res.json();',

package/src/types.ts

@@ -8,6 +8,15 @@
 export interface IPage {
   goto(url: string): Promise<void>;
   evaluate(js: string): Promise<any>;
+  getCookies(opts?: { domain?: string; url?: string }): Promise<Array<{
+    name: string;
+    value: string;
+    domain: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    expirationDate?: number;
+  }>>;
   snapshot(opts?: { interactive?: boolean; compact?: boolean; maxDepth?: number; raw?: boolean }): Promise<any>;
   click(ref: string): Promise<void>;
   typeText(ref: string, text: string): Promise<void>;

package/src/verify.ts

@@ -7,6 +7,9 @@
  */
 
 import { validateClisWithTarget, renderValidationReport, type ValidationReport } from './validate.js';
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
 export interface VerifyOptions {
   builtinClis: string;
@@ -18,15 +21,73 @@ export interface VerifyOptions {
 export interface VerifyReport {
   ok: boolean;
   validation: ValidationReport;
-  smoke: null;
+  smoke: null | {
+    requested: boolean;
+    executed: boolean;
+    ok: boolean;
+    summary: string;
+  };
 }
 
 export async function verifyClis(opts: VerifyOptions): Promise<VerifyReport> {
   const report = validateClisWithTarget([opts.builtinClis, opts.userClis], opts.target);
-  return { ok: report.ok, validation: report, smoke: null };
+  let smoke: VerifyReport['smoke'] = null;
+  if (opts.smoke) {
+    smoke = await runSmokeTests(opts.builtinClis);
+  }
+  return { ok: report.ok && (smoke?.ok ?? true), validation: report, smoke };
 }
 
 export function renderVerifyReport(report: VerifyReport): string {
-  return renderValidationReport(report.validation);
+  const base = renderValidationReport(report.validation);
+  if (!report.smoke) return base;
+  const status = report.smoke.ok ? 'PASS' : 'FAIL';
+  const mode = report.smoke.executed ? 'executed' : 'skipped';
+  return `${base}\nSmoke: ${status} (${mode}) — ${report.smoke.summary}`;
 }
 
+async function runSmokeTests(builtinClis: string): Promise<NonNullable<VerifyReport['smoke']>> {
+  const projectRoot = path.resolve(builtinClis, '..', '..');
+  const smokeDir = path.join(projectRoot, 'tests', 'smoke');
+
+  if (!fs.existsSync(smokeDir)) {
+    return {
+      requested: true,
+      executed: false,
+      ok: false,
+      summary: 'Smoke tests are unavailable in this package/environment.',
+    };
+  }
+
+  const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+  return new Promise((resolve) => {
+    const child = spawn(npx, ['vitest', 'run', 'tests/smoke/', '--reporter=dot'], {
+      cwd: projectRoot,
+      env: { ...process.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stderr = '';
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', (error) => {
+      resolve({
+        requested: true,
+        executed: false,
+        ok: false,
+        summary: `Failed to start smoke tests: ${error.message}`,
+      });
+    });
+
+    child.on('close', (code) => {
+      resolve({
+        requested: true,
+        executed: true,
+        ok: code === 0,
+        summary: code === 0 ? 'tests/smoke passed' : (stderr.trim() || `vitest exited with code ${code}`),
+      });
+    });
+  });
+}