@jackwener/opencli 0.7.11 → 0.8.0

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.11",
+  "version": "0.8.0",
   "publishConfig": {
     "access": "public"
   },

package/src/browser/discover.ts

@@ -111,13 +111,87 @@ export function findMcpServerPath(): string | null {
   return _cachedMcpServerPath;
 }
 
-function buildRuntimeArgs(input?: { executablePath?: string | null }): string[] {
+/**
+ * Chrome 144+ auto-discovery: read DevToolsActivePort file to get CDP endpoint.
+ *
+ * Starting with Chrome 144, users can enable remote debugging from
+ * chrome://inspect#remote-debugging without any command-line flags.
+ * Chrome writes the active port and browser GUID to a DevToolsActivePort file
+ * in the user data directory, which we read to construct the WebSocket endpoint.
+ */
+export function discoverChromeEndpoint(): string | null {
+  const candidates: string[] = [];
+
+  // User-specified Chrome data dir takes highest priority
+  if (process.env.CHROME_USER_DATA_DIR) {
+    candidates.push(path.join(process.env.CHROME_USER_DATA_DIR, 'DevToolsActivePort'));
+  }
+
+  // Standard Chrome/Edge user data dirs per platform
+  if (process.platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+    candidates.push(path.join(localAppData, 'Google', 'Chrome', 'User Data', 'DevToolsActivePort'));
+    candidates.push(path.join(localAppData, 'Microsoft', 'Edge', 'User Data', 'DevToolsActivePort'));
+  } else if (process.platform === 'darwin') {
+    candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome', 'DevToolsActivePort'));
+    candidates.push(path.join(os.homedir(), 'Library', 'Application Support', 'Microsoft Edge', 'DevToolsActivePort'));
+  } else {
+    candidates.push(path.join(os.homedir(), '.config', 'google-chrome', 'DevToolsActivePort'));
+    candidates.push(path.join(os.homedir(), '.config', 'chromium', 'DevToolsActivePort'));
+    candidates.push(path.join(os.homedir(), '.config', 'microsoft-edge', 'DevToolsActivePort'));
+  }
+
+  for (const filePath of candidates) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8').trim();
+      const lines = content.split('\n');
+      if (lines.length >= 2) {
+        const port = parseInt(lines[0], 10);
+        const browserPath = lines[1]; // e.g. /devtools/browser/<GUID>
+        if (port > 0 && browserPath.startsWith('/devtools/browser/')) {
+          return `ws://127.0.0.1:${port}${browserPath}`;
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
+export function resolveCdpEndpoint(): { endpoint?: string; requestedCdp: boolean } {
+  const envVal = process.env.OPENCLI_CDP_ENDPOINT;
+  if (envVal === '1' || envVal?.toLowerCase() === 'true') {
+    const autoDiscovered = discoverChromeEndpoint();
+    return { endpoint: autoDiscovered ?? envVal, requestedCdp: true };
+  }
+
+  if (envVal) {
+    return { endpoint: envVal, requestedCdp: true };
+  }
+
+  // Fallback to auto-discovery if not explicitly set
+  const autoDiscovered = discoverChromeEndpoint();
+  if (autoDiscovered) {
+    return { endpoint: autoDiscovered, requestedCdp: true };
+  }
+
+  return { requestedCdp: false };
+}
+
+function buildRuntimeArgs(input?: { executablePath?: string | null; cdpEndpoint?: string }): string[] {
   const args: string[] = [];
+
+  // Priority 1: CDP endpoint (remote Chrome debugging or local Auto-Discovery)
+  if (input?.cdpEndpoint) {
+    args.push('--cdp-endpoint', input.cdpEndpoint);
+    return args;
+  }
+
+  // Priority 2: Extension mode (local Chrome with MCP Bridge extension)
   if (!process.env.CI) {
-    // Local: always connect to user's running Chrome via MCP Bridge extension
     args.push('--extension');
   }
-  // CI: standalone mode — @playwright/mcp launches its own browser (headed by default).
+
+  // CI/standalone mode: @playwright/mcp launches its own browser (headed by default).
   // xvfb provides a virtual display for headed mode in GitHub Actions.
   if (input?.executablePath) {
     args.push('--executable-path', input.executablePath);
@@ -125,11 +199,11 @@ function buildRuntimeArgs(input?: { executablePath?: string | null }): string[]
   return args;
 }
 
-export function buildMcpArgs(input: { mcpPath: string; executablePath?: string | null }): string[] {
+export function buildMcpArgs(input: { mcpPath: string; executablePath?: string | null; cdpEndpoint?: string }): string[] {
   return [input.mcpPath, ...buildRuntimeArgs(input)];
 }
 
-export function buildMcpLaunchSpec(input: { mcpPath?: string | null; executablePath?: string | null }): {
+export function buildMcpLaunchSpec(input: { mcpPath?: string | null; executablePath?: string | null; cdpEndpoint?: string }): {
   command: string;
   args: string[];
   usedNpxFallback: boolean;

package/src/browser/errors.ts

@@ -4,7 +4,7 @@
 
 import { createHash } from 'node:crypto';
 
-export type ConnectFailureKind = 'missing-token' | 'extension-timeout' | 'extension-not-installed' | 'mcp-init' | 'process-exit' | 'unknown';
+export type ConnectFailureKind = 'missing-token' | 'extension-timeout' | 'extension-not-installed' | 'mcp-init' | 'process-exit' | 'cdp-connection-failed' | 'unknown';
 
 export type ConnectFailureInput = {
   kind: ConnectFailureKind;
@@ -26,6 +26,15 @@ export function formatBrowserConnectError(input: ConnectFailureInput): Error {
   const suffix = stderr ? `\n\nMCP stderr:\n${stderr}` : '';
   const tokenHint = input.tokenFingerprint ? ` Token fingerprint: ${input.tokenFingerprint}.` : '';
 
+  if (input.kind === 'cdp-connection-failed') {
+    return new Error(
+      `Failed to connect to remote Chrome via CDP endpoint.\n\n` +
+      `Check if Chrome is running with remote debugging enabled (--remote-debugging-port=9222) or DevToolsActivePort is available under chrome://inspect#remote-debugging.\n` +
+      `If you specified OPENCLI_CDP_ENDPOINT=1, auto-discovery might have failed.` +
+      suffix,
+    );
+  }
+
   if (input.kind === 'missing-token') {
     return new Error(
       'Failed to connect to Playwright MCP Bridge: PLAYWRIGHT_MCP_EXTENSION_TOKEN is not set.\n\n' +
@@ -74,9 +83,16 @@ export function inferConnectFailureKind(args: {
   stderr: string;
   rawMessage?: string;
   exited?: boolean;
+  isCdpMode?: boolean;
 }): ConnectFailureKind {
   const haystack = `${args.rawMessage ?? ''}\n${args.stderr}`.toLowerCase();
 
+  if (args.isCdpMode) {
+    if (args.rawMessage?.startsWith('MCP init failed:')) return 'mcp-init';
+    if (args.exited) return 'cdp-connection-failed';
+    return 'cdp-connection-failed';
+  }
+
   if (!args.hasExtensionToken)
     return 'missing-token';
   if (haystack.includes('extension connection timeout') || haystack.includes('playwright mcp bridge'))

package/src/browser/index.ts

@@ -9,6 +9,7 @@ export { Page } from './page.js';
 export { PlaywrightMCP } from './mcp.js';
 export { getTokenFingerprint, formatBrowserConnectError } from './errors.js';
 export type { ConnectFailureKind, ConnectFailureInput } from './errors.js';
+export { resolveCdpEndpoint } from './discover.js';
 
 // Test-only helpers — exposed for unit tests
 import { createJsonRpcRequest } from './mcp.js';

package/src/browser/mcp.ts

@@ -9,7 +9,7 @@ import { withTimeoutMs, DEFAULT_BROWSER_CONNECT_TIMEOUT } from '../runtime.js';
 import { PKG_VERSION } from '../version.js';
 import { Page } from './page.js';
 import { getTokenFingerprint, formatBrowserConnectError, inferConnectFailureKind } from './errors.js';
-import { findMcpServerPath, buildMcpLaunchSpec } from './discover.js';
+import { findMcpServerPath, buildMcpLaunchSpec, resolveCdpEndpoint } from './discover.js';
 import { extractTabIdentities, extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 
 const STDERR_BUFFER_LIMIT = 16 * 1024;
@@ -114,7 +114,8 @@ export class PlaywrightMCP {
     return new Promise<Page>((resolve, reject) => {
       const isDebug = process.env.DEBUG?.includes('opencli:mcp');
       const debugLog = (msg: string) => isDebug && console.error(`[opencli:mcp] ${msg}`);
-      const useExtension = !!process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN;
+      const { endpoint: cdpEndpoint, requestedCdp } = resolveCdpEndpoint();
+      const useExtension = !requestedCdp;
       const extensionToken = process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN;
       const tokenFingerprint = getTokenFingerprint(extensionToken);
       let stderrBuffer = '';
@@ -150,15 +151,17 @@ export class PlaywrightMCP {
         settleError(inferConnectFailureKind({
           hasExtensionToken: !!extensionToken,
           stderr: stderrBuffer,
+          isCdpMode: requestedCdp,
         }));
       }, timeout * 1000);
 
       const launchSpec = buildMcpLaunchSpec({
         mcpPath,
         executablePath: process.env.OPENCLI_BROWSER_EXECUTABLE_PATH,
+        cdpEndpoint,
       });
       if (process.env.OPENCLI_VERBOSE) {
-        console.error(`[opencli] Mode: ${useExtension ? 'extension' : 'standalone'}`);
+        console.error(`[opencli] Mode: ${requestedCdp ? 'CDP' : useExtension ? 'extension' : 'standalone'}`);
         if (useExtension) console.error(`[opencli] Extension token: fingerprint ${tokenFingerprint}`);
         if (launchSpec.usedNpxFallback) {
           console.error('[opencli] Playwright MCP not found locally; bootstrapping via npx @playwright/mcp@latest');
@@ -218,6 +221,7 @@ export class PlaywrightMCP {
             hasExtensionToken: !!extensionToken,
             stderr: stderrBuffer,
             exited: true,
+            isCdpMode: requestedCdp,
           }), { exitCode: code });
         }
       });
@@ -235,6 +239,7 @@ export class PlaywrightMCP {
             hasExtensionToken: !!extensionToken,
             stderr: stderrBuffer,
             rawMessage: `MCP init failed: ${resp.error.message}`,
+            isCdpMode: requestedCdp,
           }), { rawMessage: resp.error.message });
           return;
         }

package/src/browser/page.ts

@@ -6,6 +6,7 @@ import { formatSnapshot } from '../snapshotFormatter.js';
 import { normalizeEvaluateSource } from '../pipeline/template.js';
 import { generateInterceptorJs, generateReadInterceptedJs } from '../interceptor.js';
 import type { IPage } from '../types.js';
+import { BrowserConnectError } from '../errors.js';
 
 /**
  * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
@@ -18,10 +19,28 @@ export class Page implements IPage {
     if (resp.error) throw new Error(`page.${method}: ${(resp.error as any).message ?? JSON.stringify(resp.error)}`);
     // Extract text content from MCP result
     const result = resp.result as any;
+
+    if (result?.isError) {
+      const errorText = result.content?.find((c: any) => c.type === 'text')?.text || 'Unknown MCP Error';
+      throw new BrowserConnectError(
+        errorText,
+        'Please check if the browser is running or if the Playwright MCP / CDP connection is configured correctly.'
+      );
+    }
+
     if (result?.content) {
       const textParts = result.content.filter((c: any) => c.type === 'text');
-      if (textParts.length === 1) {
-        let text = textParts[0].text;
+      if (textParts.length >= 1) {
+        let text = textParts[textParts.length - 1].text; // Usually the main output is in the last text block
+
+        // Some versions of the MCP return error text without the `isError` boolean flag
+        if (typeof text === 'string' && text.trim().startsWith('### Error')) {
+            throw new BrowserConnectError(
+              text.trim(),
+              'Please check if the browser is running or if the Playwright MCP / CDP connection is configured correctly.'
+            );
+        }
+
         // MCP browser_evaluate returns: "[JSON]\n### Ran Playwright code\n```js\n...\n```"
         // Strip the "### Ran Playwright code" suffix to get clean JSON
         const codeMarker = text.indexOf('### Ran Playwright code');

package/src/clis/barchart/flow.ts

@@ -30,81 +30,80 @@ cli({
       (async () => {
         const limit = ${limit};
         const typeFilter = '${optionType}'.toLowerCase();
-        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
-        const headers = { 'X-CSRF-TOKEN': csrf };
 
+        // Wait for CSRF token to appear (Angular may inject it after initial render)
+        let csrf = '';
+        for (let i = 0; i < 10; i++) {
+          csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+          if (csrf) break;
+          await new Promise(r => setTimeout(r, 500));
+        }
+        if (!csrf) return { error: 'no-csrf' };
+
+        const headers = { 'X-CSRF-TOKEN': csrf };
         const fields = [
           'baseSymbol','strikePrice','expirationDate','optionType',
           'lastPrice','volume','openInterest','volumeOpenInterestRatio','volatility',
         ].join(',');
 
-        // Fetch extra rows when filtering by type since server-side filter may not work
+        // Fetch extra rows when filtering by type since server-side filter doesn't work
         const fetchLimit = typeFilter !== 'all' ? limit * 3 : limit;
-        try {
-          const url = '/proxies/core-api/v1/options/get?list=options.unusual_activity.stocks.us'
-            + '&fields=' + fields
-            + '&orderBy=volumeOpenInterestRatio&orderDir=desc'
-            + '&raw=1&limit=' + fetchLimit;
 
-          const resp = await fetch(url, { credentials: 'include', headers });
-          if (resp.ok) {
+        // Try unusual_activity first, fall back to mostActive (unusual_activity is
+        // empty outside market hours)
+        const lists = [
+          'options.unusual_activity.stocks.us',
+          'options.mostActive.us',
+        ];
+
+        for (const list of lists) {
+          try {
+            const url = '/proxies/core-api/v1/options/get?list=' + list
+              + '&fields=' + fields
+              + '&orderBy=volumeOpenInterestRatio&orderDir=desc'
+              + '&raw=1&limit=' + fetchLimit;
+
+            const resp = await fetch(url, { credentials: 'include', headers });
+            if (!resp.ok) continue;
             const d = await resp.json();
             let items = d?.data || [];
-            if (items.length > 0) {
-              // Apply client-side type filter
-              if (typeFilter !== 'all') {
-                items = items.filter(i => {
-                  const t = ((i.raw || i).optionType || '').toLowerCase();
-                  return t === typeFilter;
-                });
-              }
-              return items.slice(0, limit).map(i => {
-                const r = i.raw || i;
-                return {
-                  symbol: r.baseSymbol || r.symbol,
-                  type: r.optionType,
-                  strike: r.strikePrice,
-                  expiration: r.expirationDate,
-                  last: r.lastPrice,
-                  volume: r.volume,
-                  openInterest: r.openInterest,
-                  volOiRatio: r.volumeOpenInterestRatio,
-                  iv: r.volatility,
-                };
+            if (items.length === 0) continue;
+
+            // Apply client-side type filter
+            if (typeFilter !== 'all') {
+              items = items.filter(i => {
+                const t = ((i.raw || i).optionType || '').toLowerCase();
+                return t === typeFilter;
               });
             }
-          }
-        } catch(e) {}
-
-        // Fallback: parse from DOM table
-        try {
-          const rows = document.querySelectorAll('tr[data-ng-repeat], tbody tr');
-          const results = [];
-          for (const row of rows) {
-            const cells = row.querySelectorAll('td');
-            if (cells.length < 6) continue;
-            const getText = (idx) => cells[idx]?.textContent?.trim() || null;
-            results.push({
-              symbol: getText(0),
-              type: getText(1),
-              strike: getText(2),
-              expiration: getText(3),
-              last: getText(4),
-              volume: getText(5),
-              openInterest: cells.length > 6 ? getText(6) : null,
-              volOiRatio: cells.length > 7 ? getText(7) : null,
-              iv: cells.length > 8 ? getText(8) : null,
+            return items.slice(0, limit).map(i => {
+              const r = i.raw || i;
+              return {
+                symbol: r.baseSymbol || r.symbol,
+                type: r.optionType,
+                strike: r.strikePrice,
+                expiration: r.expirationDate,
+                last: r.lastPrice,
+                volume: r.volume,
+                openInterest: r.openInterest,
+                volOiRatio: r.volumeOpenInterestRatio,
+                iv: r.volatility,
+              };
             });
-            if (results.length >= limit) break;
-          }
-          return results;
-        } catch(e) {
-          return [];
+          } catch(e) {}
         }
+
+        return [];
       })()
     `);
 
-    if (!data || !Array.isArray(data)) return [];
+    if (!data) return [];
+
+    if (data.error === 'no-csrf') {
+      throw new Error('Could not extract CSRF token from barchart.com. Make sure you are logged in.');
+    }
+
+    if (!Array.isArray(data)) return [];
 
     return data.slice(0, limit).map(r => ({
       symbol: r.symbol || '',

package/src/doctor.ts

@@ -591,6 +591,15 @@ export function renderBrowserDoctorReport(report: DoctorReport): string {
   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: ReportStatus = report.extensionInstalled ? 'OK' : 'MISSING';
   const installDetail = report.extensionInstalled
     ? `Extension installed (${report.extensionBrowsers.join(', ')})`