@jackwener/opencli 0.7.10 → 0.8.0

package/dist/clis/barchart/options.js

@@ -0,0 +1,106 @@
+/**
+ * Barchart options chain — strike, bid/ask, volume, OI, greeks, IV.
+ * Auth: CSRF token from <meta name="csrf-token"> + session cookies.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'barchart',
+    name: 'options',
+    description: 'Barchart options chain with greeks, IV, volume, and open interest',
+    domain: 'www.barchart.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL)' },
+        { name: 'type', type: 'str', default: 'Call', help: 'Option type: Call or Put', choices: ['Call', 'Put'] },
+        { name: 'limit', type: 'int', default: 20, help: 'Max number of strikes to return' },
+    ],
+    columns: [
+        'strike', 'bid', 'ask', 'last', 'change', 'volume', 'openInterest',
+        'iv', 'delta', 'gamma', 'theta', 'vega', 'expiration',
+    ],
+    func: async (page, kwargs) => {
+        const symbol = kwargs.symbol.toUpperCase().trim();
+        const optType = kwargs.type || 'Call';
+        const limit = kwargs.limit ?? 20;
+        await page.goto(`https://www.barchart.com/stocks/quotes/${encodeURIComponent(symbol)}/options`);
+        await page.wait(4);
+        const data = await page.evaluate(`
+      (async () => {
+        const sym = '${symbol}';
+        const type = '${optType}';
+        const limit = ${limit};
+        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+        const headers = { 'X-CSRF-TOKEN': csrf };
+
+        // API: options chain with greeks
+        try {
+          const fields = [
+            'strikePrice','bidPrice','askPrice','lastPrice','priceChange',
+            'volume','openInterest','volatility',
+            'delta','gamma','theta','vega',
+            'expirationDate','optionType','percentFromLast',
+          ].join(',');
+
+          const url = '/proxies/core-api/v1/options/chain?symbol=' + encodeURIComponent(sym)
+            + '&fields=' + fields + '&raw=1';
+          const resp = await fetch(url, { credentials: 'include', headers });
+          if (resp.ok) {
+            const d = await resp.json();
+            let items = d?.data || [];
+
+            // Filter by type
+            items = items.filter(i => {
+              const t = (i.raw || i).optionType || '';
+              return t.toLowerCase() === type.toLowerCase();
+            });
+
+            // Sort by closeness to current price
+            items.sort((a, b) => {
+              const aD = Math.abs((a.raw || a).percentFromLast || 999);
+              const bD = Math.abs((b.raw || b).percentFromLast || 999);
+              return aD - bD;
+            });
+
+            return items.slice(0, limit).map(i => {
+              const r = i.raw || i;
+              return {
+                strike: r.strikePrice,
+                bid: r.bidPrice,
+                ask: r.askPrice,
+                last: r.lastPrice,
+                change: r.priceChange,
+                volume: r.volume,
+                openInterest: r.openInterest,
+                iv: r.volatility,
+                delta: r.delta,
+                gamma: r.gamma,
+                theta: r.theta,
+                vega: r.vega,
+                expiration: r.expirationDate,
+              };
+            });
+          }
+        } catch(e) {}
+
+        return [];
+      })()
+    `);
+        if (!data || !Array.isArray(data))
+            return [];
+        return data.map(r => ({
+            strike: r.strike,
+            bid: r.bid != null ? Number(Number(r.bid).toFixed(2)) : null,
+            ask: r.ask != null ? Number(Number(r.ask).toFixed(2)) : null,
+            last: r.last != null ? Number(Number(r.last).toFixed(2)) : null,
+            change: r.change != null ? Number(Number(r.change).toFixed(2)) : null,
+            volume: r.volume,
+            openInterest: r.openInterest,
+            iv: r.iv != null ? Number(Number(r.iv).toFixed(2)) + '%' : null,
+            delta: r.delta != null ? Number(Number(r.delta).toFixed(4)) : null,
+            gamma: r.gamma != null ? Number(Number(r.gamma).toFixed(4)) : null,
+            theta: r.theta != null ? Number(Number(r.theta).toFixed(4)) : null,
+            vega: r.vega != null ? Number(Number(r.vega).toFixed(4)) : null,
+            expiration: r.expiration ?? null,
+        }));
+    },
+});

package/dist/clis/barchart/quote.d.ts

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

package/dist/clis/barchart/quote.js

@@ -0,0 +1,133 @@
+/**
+ * Barchart stock quote — price, volume, market cap, P/E, EPS, and key metrics.
+ * Auth: CSRF token from <meta name="csrf-token"> + session cookies.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'barchart',
+    name: 'quote',
+    description: 'Barchart stock quote with price, volume, and key metrics',
+    domain: 'www.barchart.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL, MSFT, TSLA)' },
+    ],
+    columns: [
+        'symbol', 'name', 'price', 'change', 'changePct',
+        'open', 'high', 'low', 'prevClose', 'volume',
+        'avgVolume', 'marketCap', 'peRatio', 'eps',
+    ],
+    func: async (page, kwargs) => {
+        const symbol = kwargs.symbol.toUpperCase().trim();
+        await page.goto(`https://www.barchart.com/stocks/quotes/${encodeURIComponent(symbol)}/overview`);
+        await page.wait(4);
+        const data = await page.evaluate(`
+      (async () => {
+        const sym = '${symbol}';
+        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+
+        // Strategy 1: internal proxy API with CSRF token
+        try {
+          const fields = [
+            'symbol','symbolName','lastPrice','priceChange','percentChange',
+            'highPrice','lowPrice','openPrice','previousPrice','volume','averageVolume',
+            'marketCap','peRatio','earningsPerShare','tradeTime',
+          ].join(',');
+          const url = '/proxies/core-api/v1/quotes/get?symbol=' + encodeURIComponent(sym) + '&fields=' + fields;
+          const resp = await fetch(url, {
+            credentials: 'include',
+            headers: { 'X-CSRF-TOKEN': csrf },
+          });
+          if (resp.ok) {
+            const d = await resp.json();
+            const row = d?.data?.[0] || null;
+            if (row) {
+              return { source: 'api', row };
+            }
+          }
+        } catch(e) {}
+
+        // Strategy 2: parse from DOM
+        try {
+          const priceEl = document.querySelector('span.last-change');
+          const price = priceEl ? priceEl.textContent.trim() : null;
+
+          // Change values are sibling spans inside .pricechangerow > .last-change
+          const changeParent = priceEl?.parentElement;
+          const changeSpans = changeParent ? changeParent.querySelectorAll('span') : [];
+          let change = null;
+          let changePct = null;
+          for (const s of changeSpans) {
+            const t = s.textContent.trim();
+            if (s === priceEl) continue;
+            if (t.includes('%')) changePct = t.replace(/[()]/g, '');
+            else if (t.match(/^[+-]?[\\d.]+$/)) change = t;
+          }
+
+          // Financial data rows
+          const rows = document.querySelectorAll('.financial-data-row');
+          const fdata = {};
+          for (const row of rows) {
+            const spans = row.querySelectorAll('span');
+            if (spans.length >= 2) {
+              const label = spans[0].textContent.trim();
+              const valSpan = row.querySelector('span.right span:not(.ng-hide)');
+              fdata[label] = valSpan ? valSpan.textContent.trim() : '';
+            }
+          }
+
+          // Day high/low from row chart
+          const dayLow = document.querySelector('.bc-quote-row-chart .small-6:first-child .inline:not(.ng-hide)');
+          const dayHigh = document.querySelector('.bc-quote-row-chart .text-right .inline:not(.ng-hide)');
+          const openEl = document.querySelector('.mark span');
+          const openText = openEl ? openEl.textContent.trim().replace('Open ', '') : null;
+
+          const name = document.querySelector('h1 span.symbol');
+
+          return {
+            source: 'dom',
+            row: {
+              symbol: sym,
+              symbolName: name ? name.textContent.trim() : sym,
+              lastPrice: price,
+              priceChange: change,
+              percentChange: changePct,
+              open: openText,
+              highPrice: dayHigh ? dayHigh.textContent.trim() : null,
+              lowPrice: dayLow ? dayLow.textContent.trim() : null,
+              previousClose: fdata['Previous Close'] || null,
+              volume: fdata['Volume'] || null,
+              averageVolume: fdata['Average Volume'] || null,
+              marketCap: null,
+              peRatio: null,
+              earningsPerShare: null,
+            }
+          };
+        } catch(e) {
+          return { error: 'Could not fetch quote for ' + sym + ': ' + e.message };
+        }
+      })()
+    `);
+        if (!data || data.error)
+            return [];
+        const r = data.row || {};
+        // API returns formatted strings like "+1.41" and "+0.56%"; use raw if available
+        const raw = r.raw || {};
+        return [{
+                symbol: r.symbol || symbol,
+                name: r.symbolName || r.name || symbol,
+                price: r.lastPrice ?? null,
+                change: r.priceChange ?? null,
+                changePct: r.percentChange ?? null,
+                open: r.openPrice ?? r.open ?? null,
+                high: r.highPrice ?? null,
+                low: r.lowPrice ?? null,
+                prevClose: r.previousPrice ?? r.previousClose ?? null,
+                volume: r.volume ?? null,
+                avgVolume: r.averageVolume ?? null,
+                marketCap: r.marketCap ?? null,
+                peRatio: r.peRatio ?? null,
+                eps: r.earningsPerShare ?? null,
+            }];
+    },
+});

package/dist/doctor.js

@@ -504,6 +504,14 @@ export function renderBrowserDoctorReport(report) {
     const uniqueFingerprints = [...new Set(tokenFingerprints)];
     const hasMismatch = uniqueFingerprints.length > 1;
     const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`), ''];
+    // CDP endpoint mode (for remote/server environments)
+    const cdpEndpoint = process.env.OPENCLI_CDP_ENDPOINT;
+    if (cdpEndpoint) {
+        lines.push(statusLine('OK', `CDP endpoint: ${chalk.cyan(cdpEndpoint)}`));
+        lines.push(chalk.dim('  → Remote Chrome mode: extension token not required'));
+        lines.push('');
+        return lines.join('\n');
+    }
     const installStatus = report.extensionInstalled ? 'OK' : 'MISSING';
     const installDetail = report.extensionInstalled
         ? `Extension installed (${report.extensionBrowsers.join(', ')})`

package/dist/engine.d.ts

@@ -17,4 +17,4 @@ export declare function discoverClis(...dirs: string[]): Promise<void>;
 /**
  * Execute a CLI command. Handles lazy-loading of TS modules.
  */
-export declare function executeCommand(cmd: CliCommand, page: IPage | null, kwargs: Record<string, any>, debug?: boolean): Promise<any>;
+export declare function executeCommand(cmd: CliCommand, page: IPage | null, rawKwargs: Record<string, any>, debug?: boolean): Promise<any>;

package/dist/engine.js

@@ -155,10 +155,68 @@ function registerYamlCli(filePath, defaultSite) {
         log.warn(`Failed to load ${filePath}: ${err.message}`);
     }
 }
+/**
+ * Validates and coerces arguments based on the command's Arg definitions.
+ */
+function coerceAndValidateArgs(cmdArgs, kwargs) {
+    const result = { ...kwargs };
+    for (const argDef of cmdArgs) {
+        const val = result[argDef.name];
+        // 1. Check required
+        if (argDef.required && (val === undefined || val === null || val === '')) {
+            throw new Error(`Argument "${argDef.name}" is required.\n${argDef.help ? `Hint: ${argDef.help}` : ''}`);
+        }
+        if (val !== undefined && val !== null) {
+            // 2. Type coercion
+            if (argDef.type === 'int' || argDef.type === 'number') {
+                const num = Number(val);
+                if (Number.isNaN(num)) {
+                    throw new Error(`Argument "${argDef.name}" must be a valid number. Received: "${val}"`);
+                }
+                result[argDef.name] = num;
+            }
+            else if (argDef.type === 'boolean' || argDef.type === 'bool') {
+                if (typeof val === 'string') {
+                    const lower = val.toLowerCase();
+                    if (lower === 'true' || lower === '1')
+                        result[argDef.name] = true;
+                    else if (lower === 'false' || lower === '0')
+                        result[argDef.name] = false;
+                    else
+                        throw new Error(`Argument "${argDef.name}" must be a boolean (true/false). Received: "${val}"`);
+                }
+                else {
+                    result[argDef.name] = Boolean(val);
+                }
+            }
+            // 3. Choices validation
+            const coercedVal = result[argDef.name];
+            if (argDef.choices && argDef.choices.length > 0) {
+                // Only stringent check for string/number types against choices array
+                if (!argDef.choices.map(String).includes(String(coercedVal))) {
+                    throw new Error(`Argument "${argDef.name}" must be one of: ${argDef.choices.join(', ')}. Received: "${coercedVal}"`);
+                }
+            }
+        }
+        else if (argDef.default !== undefined) {
+            // Set default if value is missing
+            result[argDef.name] = argDef.default;
+        }
+    }
+    return result;
+}
 /**
  * Execute a CLI command. Handles lazy-loading of TS modules.
  */
-export async function executeCommand(cmd, page, kwargs, debug = false) {
+export async function executeCommand(cmd, page, rawKwargs, debug = false) {
+    let kwargs;
+    try {
+        kwargs = coerceAndValidateArgs(cmd.args, rawKwargs);
+    }
+    catch (err) {
+        // Re-throw validation errors clearly
+        throw new Error(`[Argument Validation Error]\n${err.message}`);
+    }
     // Lazy-load TS module on first execution
     const internal = cmd;
     if (internal._lazy && internal._modulePath) {

package/dist/main.js

@@ -199,9 +199,7 @@ for (const [, cmd] of registry) {
             const arg = positionalArgs[i];
             const v = actionArgs[i];
             if (v !== undefined)
-                kwargs[arg.name] = coerce(v, arg.type ?? 'str');
-            else if (arg.default != null)
-                kwargs[arg.name] = arg.default;
+                kwargs[arg.name] = v;
         }
         // Collect named options
         for (const arg of cmd.args) {
@@ -209,9 +207,7 @@ for (const [, cmd] of registry) {
                 continue;
             const v = actionOpts[arg.name];
             if (v !== undefined)
-                kwargs[arg.name] = coerce(v, arg.type ?? 'str');
-            else if (arg.default != null)
-                kwargs[arg.name] = arg.default;
+                kwargs[arg.name] = v;
         }
         try {
             if (actionOpts.verbose)
@@ -244,13 +240,4 @@ for (const [, cmd] of registry) {
         }
     });
 }
-function coerce(v, t) {
-    if (t === 'bool')
-        return ['1', 'true', 'yes', 'on'].includes(String(v).toLowerCase());
-    if (t === 'int')
-        return parseInt(String(v), 10);
-    if (t === 'float')
-        return parseFloat(String(v));
-    return String(v);
-}
 program.parse();

package/dist/pipeline/executor.js

@@ -1,30 +1,8 @@
 /**
  * Pipeline executor: runs YAML pipeline steps sequentially.
  */
-import { stepNavigate, stepClick, stepType, stepWait, stepPress, stepSnapshot, stepEvaluate } from './steps/browser.js';
-import { stepFetch } from './steps/fetch.js';
-import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
-import { stepIntercept } from './steps/intercept.js';
-import { stepTap } from './steps/tap.js';
+import { getStep } from './registry.js';
 import { log } from '../logger.js';
-/** Registry of all available step handlers */
-const STEP_HANDLERS = {
-    navigate: stepNavigate,
-    fetch: stepFetch,
-    select: stepSelect,
-    evaluate: stepEvaluate,
-    snapshot: stepSnapshot,
-    click: stepClick,
-    type: stepType,
-    wait: stepWait,
-    press: stepPress,
-    map: stepMap,
-    filter: stepFilter,
-    sort: stepSort,
-    limit: stepLimit,
-    intercept: stepIntercept,
-    tap: stepTap,
-};
 export async function executePipeline(page, pipeline, ctx = {}) {
     const args = ctx.args ?? {};
     const debug = ctx.debug ?? false;
@@ -37,7 +15,7 @@ export async function executePipeline(page, pipeline, ctx = {}) {
         for (const [op, params] of Object.entries(step)) {
             if (debug)
                 debugStepStart(i + 1, total, op, params);
-            const handler = STEP_HANDLERS[op];
+            const handler = getStep(op);
             if (handler) {
                 data = await handler(page, params, data, args);
             }

package/dist/pipeline/registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dynamic registry for pipeline steps.
+ * Allows core and third-party plugins to register custom YAML operations.
+ */
+import type { IPage } from '../types.js';
+/**
+ * Step handler: all pipeline steps conform to this generic interface.
+ * TData is the type of the `data` state flowing into the step.
+ * TResult is the expected return type.
+ */
+export type StepHandler<TData = any, TResult = any> = (page: IPage | null, params: any, data: TData, args: Record<string, any>) => Promise<TResult>;
+/**
+ * Get a registered step handler by name.
+ */
+export declare function getStep(name: string): StepHandler | undefined;
+/**
+ * Register a new custom step handler for the YAML pipeline.
+ */
+export declare function registerStep(name: string, handler: StepHandler): void;

package/dist/pipeline/registry.js

@@ -0,0 +1,41 @@
+/**
+ * Dynamic registry for pipeline steps.
+ * Allows core and third-party plugins to register custom YAML operations.
+ */
+// Import core steps
+import { stepNavigate, stepClick, stepType, stepWait, stepPress, stepSnapshot, stepEvaluate } from './steps/browser.js';
+import { stepFetch } from './steps/fetch.js';
+import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
+import { stepIntercept } from './steps/intercept.js';
+import { stepTap } from './steps/tap.js';
+const _stepRegistry = new Map();
+/**
+ * Get a registered step handler by name.
+ */
+export function getStep(name) {
+    return _stepRegistry.get(name);
+}
+/**
+ * Register a new custom step handler for the YAML pipeline.
+ */
+export function registerStep(name, handler) {
+    _stepRegistry.set(name, handler);
+}
+// -------------------------------------------------------------
+// Auto-Register Core Steps
+// -------------------------------------------------------------
+registerStep('navigate', stepNavigate);
+registerStep('fetch', stepFetch);
+registerStep('select', stepSelect);
+registerStep('evaluate', stepEvaluate);
+registerStep('snapshot', stepSnapshot);
+registerStep('click', stepClick);
+registerStep('type', stepType);
+registerStep('wait', stepWait);
+registerStep('press', stepPress);
+registerStep('map', stepMap);
+registerStep('filter', stepFilter);
+registerStep('sort', stepSort);
+registerStep('limit', stepLimit);
+registerStep('intercept', stepIntercept);
+registerStep('tap', stepTap);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.7.10",
+  "version": "0.8.0",
   "publishConfig": {
     "access": "public"
   },