@jackwener/opencli 0.7.10 → 0.8.0

package/dist/browser/mcp.js

@@ -7,7 +7,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, resolveCdpEndpoint } from './discover.js';
 import { extractTabIdentities, extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 const STDERR_BUFFER_LIMIT = 16 * 1024;
 const INITIAL_TABS_TIMEOUT_MS = 1500;
@@ -102,8 +102,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);
         this._state = 'connecting';
@@ -111,7 +109,8 @@ export class PlaywrightMCP {
         return new Promise((resolve, reject) => {
             const isDebug = process.env.DEBUG?.includes('opencli:mcp');
             const debugLog = (msg) => 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 = '';
@@ -146,19 +145,24 @@ export class PlaywrightMCP {
                 settleError(inferConnectFailureKind({
                     hasExtensionToken: !!extensionToken,
                     stderr: stderrBuffer,
+                    isCdpMode: requestedCdp,
                 }));
             }, timeout * 1000);
-            const mcpArgs = buildMcpArgs({
+            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');
+                }
             }
-            debugLog(`Spawning node ${mcpArgs.join(' ')}`);
-            this._proc = spawn('node', mcpArgs, {
+            debugLog(`Spawning ${launchSpec.command} ${launchSpec.args.join(' ')}`);
+            this._proc = spawn(launchSpec.command, launchSpec.args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
                 env: { ...process.env },
             });
@@ -209,6 +213,7 @@ export class PlaywrightMCP {
                         hasExtensionToken: !!extensionToken,
                         stderr: stderrBuffer,
                         exited: true,
+                        isCdpMode: requestedCdp,
                     }), { exitCode: code });
                 }
             });
@@ -225,6 +230,7 @@ export class PlaywrightMCP {
                         hasExtensionToken: !!extensionToken,
                         stderr: stderrBuffer,
                         rawMessage: `MCP init failed: ${resp.error.message}`,
+                        isCdpMode: requestedCdp,
                     }), { rawMessage: resp.error.message });
                     return;
                 }

package/dist/browser/page.js

@@ -4,6 +4,7 @@
 import { formatSnapshot } from '../snapshotFormatter.js';
 import { normalizeEvaluateSource } from '../pipeline/template.js';
 import { generateInterceptorJs, generateReadInterceptedJs } from '../interceptor.js';
+import { BrowserConnectError } from '../errors.js';
 /**
  * Page abstraction wrapping JSON-RPC calls to Playwright MCP.
  */
@@ -18,10 +19,18 @@ export class Page {
             throw new Error(`page.${method}: ${resp.error.message ?? JSON.stringify(resp.error)}`);
         // Extract text content from MCP result
         const result = resp.result;
+        if (result?.isError) {
+            const errorText = result.content?.find((c) => 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) => 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/dist/browser.test.js

@@ -1,5 +1,10 @@
-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' });
@@ -91,9 +96,138 @@ 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) => candidate === '/env/mcp/cli.js');
+        const execSync = vi.fn();
+        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
+        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) => candidate === runtimeGlobalMcp);
+        const execSync = vi.fn();
+        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
+        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) => candidate === npmGlobalMcp);
+        const execSync = vi.fn((command) => {
+            if (String(command).includes('npm root -g'))
+                return `${npmRootGlobal}\n`;
+            throw new Error(`unexpected command: ${String(command)}`);
+        });
+        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
+        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) => {
+            if (String(command).includes('npm root -g'))
+                return '/missing/global/node_modules\n';
+            throw new Error(`missing command: ${String(command)}`);
+        });
+        __test__.setMcpDiscoveryTestHooks({ existsSync, execSync: execSync });
+        try {
+            expect(__test__.findMcpServerPath()).toBeNull();
+        }
+        finally {
+            Object.defineProperty(process, 'execPath', {
+                value: originalExecPath,
+                configurable: true,
+            });
+        }
+    });
 });
 describe('PlaywrightMCP state', () => {
     it('transitions to closed after close()', async () => {

package/dist/cli-manifest.json

@@ -1,4 +1,167 @@
 [
+  {
+    "site": "barchart",
+    "name": "flow",
+    "description": "Barchart unusual options activity / options flow",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "type",
+        "type": "str",
+        "default": "all",
+        "required": false,
+        "help": "Filter: all, call, or put"
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 20,
+        "required": false,
+        "help": "Number of results"
+      }
+    ],
+    "type": "ts",
+    "modulePath": "barchart/flow.js",
+    "domain": "www.barchart.com",
+    "columns": [
+      "symbol",
+      "type",
+      "strike",
+      "expiration",
+      "last",
+      "volume",
+      "openInterest",
+      "volOiRatio",
+      "iv"
+    ]
+  },
+  {
+    "site": "barchart",
+    "name": "greeks",
+    "description": "Barchart options greeks overview (IV, delta, gamma, theta, vega)",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "symbol",
+        "type": "str",
+        "required": true,
+        "help": "Stock ticker (e.g. AAPL)"
+      },
+      {
+        "name": "expiration",
+        "type": "str",
+        "required": false,
+        "help": "Expiration date (YYYY-MM-DD). Defaults to the nearest available expiration."
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 10,
+        "required": false,
+        "help": "Number of near-the-money strikes per type"
+      }
+    ],
+    "type": "ts",
+    "modulePath": "barchart/greeks.js",
+    "domain": "www.barchart.com",
+    "columns": [
+      "type",
+      "strike",
+      "last",
+      "iv",
+      "delta",
+      "gamma",
+      "theta",
+      "vega",
+      "rho",
+      "volume",
+      "openInterest",
+      "expiration"
+    ]
+  },
+  {
+    "site": "barchart",
+    "name": "options",
+    "description": "Barchart options chain with greeks, IV, volume, and open interest",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "symbol",
+        "type": "str",
+        "required": true,
+        "help": "Stock ticker (e.g. AAPL)"
+      },
+      {
+        "name": "type",
+        "type": "str",
+        "default": "Call",
+        "required": false,
+        "help": "Option type: Call or Put"
+      },
+      {
+        "name": "limit",
+        "type": "int",
+        "default": 20,
+        "required": false,
+        "help": "Max number of strikes to return"
+      }
+    ],
+    "type": "ts",
+    "modulePath": "barchart/options.js",
+    "domain": "www.barchart.com",
+    "columns": [
+      "strike",
+      "bid",
+      "ask",
+      "last",
+      "change",
+      "volume",
+      "openInterest",
+      "iv",
+      "delta",
+      "gamma",
+      "theta",
+      "vega",
+      "expiration"
+    ]
+  },
+  {
+    "site": "barchart",
+    "name": "quote",
+    "description": "Barchart stock quote with price, volume, and key metrics",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "symbol",
+        "type": "str",
+        "required": true,
+        "help": "Stock ticker (e.g. AAPL, MSFT, TSLA)"
+      }
+    ],
+    "type": "ts",
+    "modulePath": "barchart/quote.js",
+    "domain": "www.barchart.com",
+    "columns": [
+      "symbol",
+      "name",
+      "price",
+      "change",
+      "changePct",
+      "open",
+      "high",
+      "low",
+      "prevClose",
+      "volume",
+      "avgVolume",
+      "marketCap",
+      "peRatio",
+      "eps"
+    ]
+  },
   {
     "site": "bbc",
     "name": "news",

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

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

package/dist/clis/barchart/flow.js

@@ -0,0 +1,115 @@
+/**
+ * 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();
+
+        // 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 doesn't work
+        const fetchLimit = typeFilter !== 'all' ? limit * 3 : limit;
+
+        // 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) continue;
+
+            // 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) {}
+        }
+
+        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 || '',
+            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/dist/clis/barchart/greeks.d.ts

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

package/dist/clis/barchart/greeks.js

@@ -0,0 +1,119 @@
+/**
+ * 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,
+        }));
+    },
+});

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

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