@jackwener/opencli 0.7.9 → 0.7.11

package/src/browser/discover.ts

@@ -9,19 +9,33 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 
 let _cachedMcpServerPath: string | null | undefined;
+let _existsSync = fs.existsSync;
+let _execSync = execSync;
+
+export function resetMcpServerPathCache(): void {
+  _cachedMcpServerPath = undefined;
+}
+
+export function setMcpDiscoveryTestHooks(input?: {
+  existsSync?: typeof fs.existsSync;
+  execSync?: typeof execSync;
+}): void {
+  _existsSync = input?.existsSync ?? fs.existsSync;
+  _execSync = input?.execSync ?? execSync;
+}
 
 export function findMcpServerPath(): string | null {
   if (_cachedMcpServerPath !== undefined) return _cachedMcpServerPath;
 
   const envMcp = process.env.OPENCLI_MCP_SERVER_PATH;
-  if (envMcp && fs.existsSync(envMcp)) {
+  if (envMcp && _existsSync(envMcp)) {
     _cachedMcpServerPath = envMcp;
     return _cachedMcpServerPath;
   }
 
   // Check local node_modules first (@playwright/mcp is the modern package)
   const localMcp = path.resolve('node_modules', '@playwright', 'mcp', 'cli.js');
-  if (fs.existsSync(localMcp)) {
+  if (_existsSync(localMcp)) {
     _cachedMcpServerPath = localMcp;
     return _cachedMcpServerPath;
   }
@@ -29,11 +43,33 @@ export function findMcpServerPath(): string | null {
   // Check project-relative path
   const __dirname2 = path.dirname(fileURLToPath(import.meta.url));
   const projectMcp = path.resolve(__dirname2, '..', '..', 'node_modules', '@playwright', 'mcp', 'cli.js');
-  if (fs.existsSync(projectMcp)) {
+  if (_existsSync(projectMcp)) {
     _cachedMcpServerPath = projectMcp;
     return _cachedMcpServerPath;
   }
 
+  // Check global npm/yarn locations derived from current Node runtime.
+  const nodePrefix = path.resolve(path.dirname(process.execPath), '..');
+  const globalNodeModules = path.join(nodePrefix, 'lib', 'node_modules');
+  const globalMcp = path.join(globalNodeModules, '@playwright', 'mcp', 'cli.js');
+  if (_existsSync(globalMcp)) {
+    _cachedMcpServerPath = globalMcp;
+    return _cachedMcpServerPath;
+  }
+
+  // Check npm global root directly.
+  try {
+    const npmRootGlobal = _execSync('npm root -g 2>/dev/null', {
+      encoding: 'utf-8',
+      timeout: 5000,
+    }).trim();
+    const npmGlobalMcp = path.join(npmRootGlobal, '@playwright', 'mcp', 'cli.js');
+    if (npmRootGlobal && _existsSync(npmGlobalMcp)) {
+      _cachedMcpServerPath = npmGlobalMcp;
+      return _cachedMcpServerPath;
+    }
+  } catch {}
+
   // Check common locations
   const candidates = [
     path.join(os.homedir(), '.npm', '_npx'),
@@ -43,8 +79,8 @@ export function findMcpServerPath(): string | null {
 
   // Try npx resolution (legacy package name)
   try {
-    const result = execSync('npx -y --package=@playwright/mcp which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 10000 }).trim();
-    if (result && fs.existsSync(result)) {
+    const result = _execSync('npx -y --package=@playwright/mcp which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 10000 }).trim();
+    if (result && _existsSync(result)) {
       _cachedMcpServerPath = result;
       return _cachedMcpServerPath;
     }
@@ -52,8 +88,8 @@ export function findMcpServerPath(): string | null {
 
   // Try which
   try {
-    const result = execSync('which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 5000 }).trim();
-    if (result && fs.existsSync(result)) {
+    const result = _execSync('which mcp-server-playwright 2>/dev/null', { encoding: 'utf-8', timeout: 5000 }).trim();
+    if (result && _existsSync(result)) {
       _cachedMcpServerPath = result;
       return _cachedMcpServerPath;
     }
@@ -61,9 +97,9 @@ export function findMcpServerPath(): string | null {
 
   // Search in common npx cache
   for (const base of candidates) {
-    if (!fs.existsSync(base)) continue;
+    if (!_existsSync(base)) continue;
     try {
-      const found = execSync(`find "${base}" -name "cli.js" -path "*playwright*mcp*" 2>/dev/null | head -1`, { encoding: 'utf-8', timeout: 5000 }).trim();
+      const found = _execSync(`find "${base}" -name "cli.js" -path "*playwright*mcp*" 2>/dev/null | head -1`, { encoding: 'utf-8', timeout: 5000 }).trim();
       if (found) {
         _cachedMcpServerPath = found;
         return _cachedMcpServerPath;
@@ -75,16 +111,41 @@ export function findMcpServerPath(): string | null {
   return _cachedMcpServerPath;
 }
 
-export function buildMcpArgs(input: { mcpPath: string; executablePath?: string | null }): string[] {
-  const args = [input.mcpPath];
+function buildRuntimeArgs(input?: { executablePath?: string | null }): string[] {
+  const args: string[] = [];
   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).
   // xvfb provides a virtual display for headed mode in GitHub Actions.
-  if (input.executablePath) {
+  if (input?.executablePath) {
     args.push('--executable-path', input.executablePath);
   }
   return args;
 }
+
+export function buildMcpArgs(input: { mcpPath: string; executablePath?: string | null }): string[] {
+  return [input.mcpPath, ...buildRuntimeArgs(input)];
+}
+
+export function buildMcpLaunchSpec(input: { mcpPath?: string | null; executablePath?: string | null }): {
+  command: string;
+  args: string[];
+  usedNpxFallback: boolean;
+} {
+  const runtimeArgs = buildRuntimeArgs(input);
+  if (input.mcpPath) {
+    return {
+      command: 'node',
+      args: [input.mcpPath, ...runtimeArgs],
+      usedNpxFallback: false,
+    };
+  }
+
+  return {
+    command: 'npx',
+    args: ['-y', '@playwright/mcp@latest', ...runtimeArgs],
+    usedNpxFallback: true,
+  };
+}

package/src/browser/index.ts

@@ -13,7 +13,7 @@ export type { ConnectFailureKind, ConnectFailureInput } from './errors.js';
 // Test-only helpers — exposed for unit tests
 import { createJsonRpcRequest } from './mcp.js';
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
-import { buildMcpArgs } from './discover.js';
+import { buildMcpArgs, buildMcpLaunchSpec, findMcpServerPath, resetMcpServerPathCache, setMcpDiscoveryTestHooks } from './discover.js';
 import { withTimeoutMs } from '../runtime.js';
 
 export const __test__ = {
@@ -22,5 +22,9 @@ export const __test__ = {
   diffTabIndexes,
   appendLimited,
   buildMcpArgs,
+  buildMcpLaunchSpec,
+  findMcpServerPath,
+  resetMcpServerPathCache,
+  setMcpDiscoveryTestHooks,
   withTimeoutMs,
 };

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, buildMcpArgs } from './discover.js';
+import { findMcpServerPath, buildMcpLaunchSpec } from './discover.js';
 import { extractTabIdentities, extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 
 const STDERR_BUFFER_LIMIT = 16 * 1024;
@@ -105,7 +105,6 @@ export class PlaywrightMCP {
     if (this._state === 'closed') throw new Error('Playwright MCP session is closed');
 
     const mcpPath = findMcpServerPath();
-    if (!mcpPath) throw new Error('Playwright MCP server not found. Install: npm install -D @playwright/mcp');
 
     PlaywrightMCP._registerGlobalCleanup();
     PlaywrightMCP._activeInsts.add(this);
@@ -154,17 +153,20 @@ export class PlaywrightMCP {
         }));
       }, timeout * 1000);
 
-      const mcpArgs = buildMcpArgs({
+      const launchSpec = buildMcpLaunchSpec({
         mcpPath,
         executablePath: process.env.OPENCLI_BROWSER_EXECUTABLE_PATH,
       });
       if (process.env.OPENCLI_VERBOSE) {
         console.error(`[opencli] Mode: ${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');
+        }
       }
-      debugLog(`Spawning node ${mcpArgs.join(' ')}`);
+      debugLog(`Spawning ${launchSpec.command} ${launchSpec.args.join(' ')}`);
 
-      this._proc = spawn('node', mcpArgs, {
+      this._proc = spawn(launchSpec.command, launchSpec.args, {
         stdio: ['pipe', 'pipe', 'pipe'],
         env: { ...process.env },
       });

package/src/browser.test.ts

@@ -1,6 +1,12 @@
-import { describe, it, expect } from 'vitest';
+import { afterEach, describe, it, expect, vi } from 'vitest';
 import { PlaywrightMCP, __test__ } from './browser/index.js';
 
+afterEach(() => {
+  __test__.resetMcpServerPathCache();
+  __test__.setMcpDiscoveryTestHooks();
+  delete process.env.OPENCLI_MCP_SERVER_PATH;
+});
+
 describe('browser helpers', () => {
   it('creates JSON-RPC requests with unique ids', () => {
     const first = __test__.createJsonRpcRequest('tools/call', { name: 'browser_tabs' });
@@ -106,9 +112,142 @@ describe('browser helpers', () => {
     }
   });
 
+  it('builds a direct node launch spec when a local MCP path is available', () => {
+    const savedCI = process.env.CI;
+    delete process.env.CI;
+    try {
+      expect(__test__.buildMcpLaunchSpec({
+        mcpPath: '/tmp/cli.js',
+        executablePath: '/usr/bin/google-chrome',
+      })).toEqual({
+        command: 'node',
+        args: ['/tmp/cli.js', '--extension', '--executable-path', '/usr/bin/google-chrome'],
+        usedNpxFallback: false,
+      });
+    } finally {
+      if (savedCI !== undefined) {
+        process.env.CI = savedCI;
+      } else {
+        delete process.env.CI;
+      }
+    }
+  });
+
+  it('falls back to npx bootstrap when no MCP path is available', () => {
+    const savedCI = process.env.CI;
+    delete process.env.CI;
+    try {
+      expect(__test__.buildMcpLaunchSpec({
+        mcpPath: null,
+      })).toEqual({
+        command: 'npx',
+        args: ['-y', '@playwright/mcp@latest', '--extension'],
+        usedNpxFallback: true,
+      });
+    } finally {
+      if (savedCI !== undefined) {
+        process.env.CI = savedCI;
+      } else {
+        delete process.env.CI;
+      }
+    }
+  });
+
   it('times out slow promises', async () => {
     await expect(__test__.withTimeoutMs(new Promise(() => {}), 10, 'timeout')).rejects.toThrow('timeout');
   });
+
+  it('prefers OPENCLI_MCP_SERVER_PATH over discovered locations', () => {
+    process.env.OPENCLI_MCP_SERVER_PATH = '/env/mcp/cli.js';
+    const existsSync = vi.fn((candidate: any) => candidate === '/env/mcp/cli.js');
+    const execSync = vi.fn();
+    __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync as any });
+
+    expect(__test__.findMcpServerPath()).toBe('/env/mcp/cli.js');
+    expect(execSync).not.toHaveBeenCalled();
+    expect(existsSync).toHaveBeenCalledWith('/env/mcp/cli.js');
+  });
+
+  it('discovers global @playwright/mcp from the current Node runtime prefix', () => {
+    const originalExecPath = process.execPath;
+    const runtimeExecPath = '/opt/homebrew/Cellar/node/25.2.1/bin/node';
+    const runtimeGlobalMcp = '/opt/homebrew/Cellar/node/25.2.1/lib/node_modules/@playwright/mcp/cli.js';
+    Object.defineProperty(process, 'execPath', {
+      value: runtimeExecPath,
+      configurable: true,
+    });
+
+    const existsSync = vi.fn((candidate: any) => candidate === runtimeGlobalMcp);
+    const execSync = vi.fn();
+    __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync as any });
+
+    try {
+      expect(__test__.findMcpServerPath()).toBe(runtimeGlobalMcp);
+      expect(execSync).not.toHaveBeenCalled();
+      expect(existsSync).toHaveBeenCalledWith(runtimeGlobalMcp);
+    } finally {
+      Object.defineProperty(process, 'execPath', {
+        value: originalExecPath,
+        configurable: true,
+      });
+    }
+  });
+
+  it('falls back to npm root -g when runtime prefix lookup misses', () => {
+    const originalExecPath = process.execPath;
+    const runtimeExecPath = '/opt/homebrew/Cellar/node/25.2.1/bin/node';
+    const runtimeGlobalMcp = '/opt/homebrew/Cellar/node/25.2.1/lib/node_modules/@playwright/mcp/cli.js';
+    const npmRootGlobal = '/Users/jakevin/.nvm/versions/node/v22.14.0/lib/node_modules';
+    const npmGlobalMcp = '/Users/jakevin/.nvm/versions/node/v22.14.0/lib/node_modules/@playwright/mcp/cli.js';
+    Object.defineProperty(process, 'execPath', {
+      value: runtimeExecPath,
+      configurable: true,
+    });
+
+    const existsSync = vi.fn((candidate: any) => candidate === npmGlobalMcp);
+    const execSync = vi.fn((command: string) => {
+      if (String(command).includes('npm root -g')) return `${npmRootGlobal}\n` as any;
+      throw new Error(`unexpected command: ${String(command)}`);
+    });
+    __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync as any });
+
+    try {
+      expect(__test__.findMcpServerPath()).toBe(npmGlobalMcp);
+      expect(execSync).toHaveBeenCalledOnce();
+      expect(existsSync).toHaveBeenCalledWith(runtimeGlobalMcp);
+      expect(existsSync).toHaveBeenCalledWith(npmGlobalMcp);
+    } finally {
+      Object.defineProperty(process, 'execPath', {
+        value: originalExecPath,
+        configurable: true,
+      });
+    }
+  });
+
+  it('returns null when new global discovery paths are unavailable', () => {
+    const originalExecPath = process.execPath;
+    const runtimeExecPath = '/opt/homebrew/Cellar/node/25.2.1/bin/node';
+    Object.defineProperty(process, 'execPath', {
+      value: runtimeExecPath,
+      configurable: true,
+    });
+
+    const existsSync = vi.fn(() => false);
+    const execSync = vi.fn((command: string) => {
+      if (String(command).includes('npm root -g')) return '/missing/global/node_modules\n' as any;
+      throw new Error(`missing command: ${String(command)}`);
+    });
+    __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync as any });
+
+    try {
+      expect(__test__.findMcpServerPath()).toBeNull();
+    } finally {
+      Object.defineProperty(process, 'execPath', {
+        value: originalExecPath,
+        configurable: true,
+      });
+    }
+  });
 });
 
 describe('PlaywrightMCP state', () => {

package/src/clis/barchart/flow.ts

@@ -0,0 +1,121 @@
+/**
+ * Barchart unusual options activity (options flow).
+ * Shows high volume/OI ratio trades that may indicate institutional activity.
+ * Auth: CSRF token from <meta name="csrf-token"> + session cookies.
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'barchart',
+  name: 'flow',
+  description: 'Barchart unusual options activity / options flow',
+  domain: 'www.barchart.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'type', type: 'str', default: 'all', help: 'Filter: all, call, or put', choices: ['all', 'call', 'put'] },
+    { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
+  ],
+  columns: [
+    'symbol', 'type', 'strike', 'expiration', 'last',
+    'volume', 'openInterest', 'volOiRatio', 'iv',
+  ],
+  func: async (page, kwargs) => {
+    const optionType = kwargs.type || 'all';
+    const limit = kwargs.limit ?? 20;
+
+    await page.goto('https://www.barchart.com/options/unusual-activity/stocks');
+    await page.wait(5);
+
+    const data = await page.evaluate(`
+      (async () => {
+        const limit = ${limit};
+        const typeFilter = '${optionType}'.toLowerCase();
+        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+        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
+        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) {
+            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,
+                };
+              });
+            }
+          }
+        } 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,
+            });
+            if (results.length >= limit) break;
+          }
+          return results;
+        } catch(e) {
+          return [];
+        }
+      })()
+    `);
+
+    if (!data || !Array.isArray(data)) return [];
+
+    return data.slice(0, limit).map(r => ({
+      symbol: r.symbol || '',
+      type: r.type || '',
+      strike: r.strike,
+      expiration: r.expiration ?? null,
+      last: r.last != null ? Number(Number(r.last).toFixed(2)) : null,
+      volume: r.volume,
+      openInterest: r.openInterest,
+      volOiRatio: r.volOiRatio != null ? Number(Number(r.volOiRatio).toFixed(2)) : null,
+      iv: r.iv != null ? Number(Number(r.iv).toFixed(2)) + '%' : null,
+    }));
+  },
+});

package/src/clis/barchart/greeks.ts

@@ -0,0 +1,123 @@
+/**
+ * Barchart options greeks overview — IV, delta, gamma, theta, vega, rho
+ * for near-the-money options on a given symbol.
+ * Auth: CSRF token from <meta name="csrf-token"> + session cookies.
+ */
+import { cli, Strategy } from '../../registry.js';
+
+cli({
+  site: 'barchart',
+  name: 'greeks',
+  description: 'Barchart options greeks overview (IV, delta, gamma, theta, vega)',
+  domain: 'www.barchart.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'symbol', required: true, help: 'Stock ticker (e.g. AAPL)' },
+    { name: 'expiration', type: 'str', help: 'Expiration date (YYYY-MM-DD). Defaults to the nearest available expiration.' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of near-the-money strikes per type' },
+  ],
+  columns: [
+    'type', 'strike', 'last', 'iv', 'delta', 'gamma', 'theta', 'vega', 'rho',
+    'volume', 'openInterest', 'expiration',
+  ],
+  func: async (page, kwargs) => {
+    const symbol = kwargs.symbol.toUpperCase().trim();
+    const expiration = kwargs.expiration ?? '';
+    const limit = kwargs.limit ?? 10;
+
+    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 expDate = '${expiration}';
+        const limit = ${limit};
+        const csrf = document.querySelector('meta[name="csrf-token"]')?.content || '';
+        const headers = { 'X-CSRF-TOKEN': csrf };
+
+        try {
+          const fields = [
+            'strikePrice','lastPrice','volume','openInterest',
+            'volatility','delta','gamma','theta','vega','rho',
+            'expirationDate','optionType','percentFromLast',
+          ].join(',');
+
+          let url = '/proxies/core-api/v1/options/chain?symbol=' + encodeURIComponent(sym)
+            + '&fields=' + fields + '&raw=1';
+          if (expDate) url += '&expirationDate=' + encodeURIComponent(expDate);
+          const resp = await fetch(url, { credentials: 'include', headers });
+          if (resp.ok) {
+            const d = await resp.json();
+            let items = d?.data || [];
+
+            if (!expDate) {
+              const expirations = items
+                .map(i => (i.raw || i).expirationDate || null)
+                .filter(Boolean)
+                .sort((a, b) => {
+                  const aTime = Date.parse(a);
+                  const bTime = Date.parse(b);
+                  if (Number.isNaN(aTime) && Number.isNaN(bTime)) return 0;
+                  if (Number.isNaN(aTime)) return 1;
+                  if (Number.isNaN(bTime)) return -1;
+                  return aTime - bTime;
+                });
+              const nearestExpiration = expirations[0];
+              if (nearestExpiration) {
+                items = items.filter(i => ((i.raw || i).expirationDate || null) === nearestExpiration);
+              }
+            }
+
+            // Separate calls and puts, sort by distance from current price
+            const calls = items
+              .filter(i => ((i.raw || i).optionType || '').toLowerCase() === 'call')
+              .sort((a, b) => Math.abs((a.raw || a).percentFromLast || 999) - Math.abs((b.raw || b).percentFromLast || 999))
+              .slice(0, limit);
+            const puts = items
+              .filter(i => ((i.raw || i).optionType || '').toLowerCase() === 'put')
+              .sort((a, b) => Math.abs((a.raw || a).percentFromLast || 999) - Math.abs((b.raw || b).percentFromLast || 999))
+              .slice(0, limit);
+
+            return [...calls, ...puts].map(i => {
+              const r = i.raw || i;
+              return {
+                type: r.optionType,
+                strike: r.strikePrice,
+                last: r.lastPrice,
+                iv: r.volatility,
+                delta: r.delta,
+                gamma: r.gamma,
+                theta: r.theta,
+                vega: r.vega,
+                rho: r.rho,
+                volume: r.volume,
+                openInterest: r.openInterest,
+                expiration: r.expirationDate,
+              };
+            });
+          }
+        } catch(e) {}
+
+        return [];
+      })()
+    `);
+
+    if (!data || !Array.isArray(data)) return [];
+
+    return data.map(r => ({
+      type: r.type || '',
+      strike: r.strike,
+      last: r.last != null ? Number(Number(r.last).toFixed(2)) : null,
+      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,
+      rho: r.rho != null ? Number(Number(r.rho).toFixed(4)) : null,
+      volume: r.volume,
+      openInterest: r.openInterest,
+      expiration: r.expiration ?? null,
+    }));
+  },
+});