@jackwener/opencli 1.6.8 → 1.6.9

package/dist/src/browser/daemon-client.js

@@ -39,6 +39,18 @@ export async function fetchDaemonStatus(opts) {
         return null;
     }
 }
+/**
+ * Unified daemon health check — single entry point for all status queries.
+ * Replaces isDaemonRunning(), isExtensionConnected(), and checkDaemonStatus().
+ */
+export async function getDaemonHealth(opts) {
+    const status = await fetchDaemonStatus(opts);
+    if (!status)
+        return { state: 'stopped', status: null };
+    if (!status.extensionConnected)
+        return { state: 'no-extension', status };
+    return { state: 'ready', status };
+}
 export async function requestDaemonShutdown(opts) {
     try {
         const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
@@ -48,19 +60,6 @@ export async function requestDaemonShutdown(opts) {
         return false;
     }
 }
-/**
- * Check if daemon is running.
- */
-export async function isDaemonRunning() {
-    return (await fetchDaemonStatus()) !== null;
-}
-/**
- * Check if daemon is running AND the extension is connected.
- */
-export async function isExtensionConnected() {
-    const status = await fetchDaemonStatus();
-    return !!status?.extensionConnected;
-}
 /**
  * Send a command to the daemon and wait for a result.
  * Retries up to 4 times: network errors retry at 500ms,

package/dist/src/browser/daemon-client.test.js

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { fetchDaemonStatus, isDaemonRunning, isExtensionConnected, requestDaemonShutdown, } from './daemon-client.js';
+import { fetchDaemonStatus, getDaemonHealth, requestDaemonShutdown, } from './daemon-client.js';
 describe('daemon-client', () => {
     beforeEach(() => {
         vi.stubGlobal('fetch', vi.fn());
@@ -42,36 +42,43 @@ describe('daemon-client', () => {
             headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
         }));
     });
-    it('isDaemonRunning reflects shared status availability', async () => {
+    it('getDaemonHealth returns stopped when daemon is not reachable', async () => {
+        vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
+        await expect(getDaemonHealth()).resolves.toEqual({ state: 'stopped', status: null });
+    });
+    it('getDaemonHealth returns no-extension when daemon is running but extension disconnected', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: false,
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 16,
+            port: 19825,
+        };
         vi.mocked(fetch).mockResolvedValue({
             ok: true,
-            json: () => Promise.resolve({
-                ok: true,
-                pid: 123,
-                uptime: 10,
-                extensionConnected: false,
-                pending: 0,
-                lastCliRequestTime: Date.now(),
-                memoryMB: 16,
-                port: 19825,
-            }),
+            json: () => Promise.resolve(status),
         });
-        await expect(isDaemonRunning()).resolves.toBe(true);
+        await expect(getDaemonHealth()).resolves.toEqual({ state: 'no-extension', status });
     });
-    it('isExtensionConnected reflects shared status payload', async () => {
+    it('getDaemonHealth returns ready when daemon and extension are both connected', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: true,
+            extensionVersion: '1.2.3',
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 32,
+            port: 19825,
+        };
         vi.mocked(fetch).mockResolvedValue({
             ok: true,
-            json: () => Promise.resolve({
-                ok: true,
-                pid: 123,
-                uptime: 10,
-                extensionConnected: false,
-                pending: 0,
-                lastCliRequestTime: Date.now(),
-                memoryMB: 16,
-                port: 19825,
-            }),
+            json: () => Promise.resolve(status),
         });
-        await expect(isExtensionConnected()).resolves.toBe(false);
+        await expect(getDaemonHealth()).resolves.toEqual({ state: 'ready', status });
     });
 });

package/dist/src/browser/index.d.ts

@@ -7,7 +7,8 @@
 export { Page } from './page.js';
 export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
-export { isDaemonRunning } from './daemon-client.js';
+export { getDaemonHealth } from './daemon-client.js';
+export type { DaemonHealth } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 export { generateStealthJs } from './stealth.js';
 export type { DomSnapshotOptions } from './dom-snapshot.js';

package/dist/src/browser/index.js

@@ -7,6 +7,6 @@
 export { Page } from './page.js';
 export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
-export { isDaemonRunning } from './daemon-client.js';
+export { getDaemonHealth } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 export { generateStealthJs } from './stealth.js';

package/dist/src/browser.test.js

@@ -105,10 +105,9 @@ describe('BrowserBridge state', () => {
         await expect(bridge.connect()).rejects.toThrow('Session is closing');
     });
     it('fails fast when daemon is running but extension is disconnected', async () => {
-        vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
-        vi.spyOn(daemonClient, 'fetchDaemonStatus').mockResolvedValue({ extensionConnected: false });
+        vi.spyOn(daemonClient, 'getDaemonHealth').mockResolvedValue({ state: 'no-extension', status: { extensionConnected: false } });
         const bridge = new BrowserBridge();
-        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
+        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Bridge extension not connected');
     });
 });
 describe('stealth anti-detection', () => {

package/dist/src/cli.js

@@ -270,11 +270,11 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     operate.command('open').argument('<url>').description('Open URL in automation window')
         .action(operateAction(async (page, url) => {
         // Start session-level capture before navigation (catches initial requests)
-        await page.startNetworkCapture?.();
+        const hasSessionCapture = await page.startNetworkCapture?.().then(() => true).catch(() => false);
         await page.goto(url);
         await page.wait(2);
-        // Fallback: also inject JS interceptor for pages without session capture
-        if (!page.startNetworkCapture) {
+        // Fallback: inject JS interceptor when session capture is unavailable
+        if (!hasSessionCapture) {
             try {
                 await page.evaluate(NETWORK_INTERCEPTOR_JS);
             }

package/dist/src/clis/binance/commands.test.d.ts

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

package/dist/src/clis/binance/commands.test.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import yaml from 'js-yaml';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { executePipeline } from '../../pipeline/index.js';
+function loadPipeline(name) {
+    const file = new URL(`./${name}.yaml`, import.meta.url);
+    const def = yaml.load(fs.readFileSync(file, 'utf-8'));
+    return def.pipeline;
+}
+function mockJsonOnce(payload) {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: vi.fn().mockResolvedValue(payload),
+    }));
+}
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+describe('binance YAML adapters', () => {
+    it('sorts top pairs by numeric quote volume', async () => {
+        mockJsonOnce([
+            { symbol: 'SMALL', lastPrice: '1', priceChangePercent: '1.2', highPrice: '1', lowPrice: '1', quoteVolume: '9.9' },
+            { symbol: 'LARGE', lastPrice: '2', priceChangePercent: '2.3', highPrice: '2', lowPrice: '2', quoteVolume: '100.0' },
+            { symbol: 'MID', lastPrice: '3', priceChangePercent: '3.4', highPrice: '3', lowPrice: '3', quoteVolume: '11.0' },
+        ]);
+        const result = await executePipeline(null, loadPipeline('top'), { args: { limit: 3 } });
+        expect(result.map((item) => item.symbol)).toEqual(['LARGE', 'MID', 'SMALL']);
+        expect(result.map((item) => item.rank)).toEqual([1, 2, 3]);
+    });
+    it('sorts gainers by numeric percent change', async () => {
+        mockJsonOnce([
+            { symbol: 'TEN', lastPrice: '1', priceChangePercent: '10.0', quoteVolume: '100' },
+            { symbol: 'NINE', lastPrice: '1', priceChangePercent: '9.5', quoteVolume: '100' },
+            { symbol: 'HUNDRED', lastPrice: '1', priceChangePercent: '100.0', quoteVolume: '100' },
+        ]);
+        const result = await executePipeline(null, loadPipeline('gainers'), { args: { limit: 3 } });
+        expect(result.map((item) => item.symbol)).toEqual(['HUNDRED', 'TEN', 'NINE']);
+    });
+    it('keeps only TRADING pairs', async () => {
+        mockJsonOnce({
+            symbols: [
+                { symbol: 'BTCUSDT', baseAsset: 'BTC', quoteAsset: 'USDT', status: 'TRADING' },
+                { symbol: 'OLDPAIR', baseAsset: 'OLD', quoteAsset: 'USDT', status: 'BREAK' },
+            ],
+        });
+        const result = await executePipeline(null, loadPipeline('pairs'), { args: { limit: 10 } });
+        expect(result).toEqual([
+            { symbol: 'BTCUSDT', base: 'BTC', quote: 'USDT', status: 'TRADING' },
+        ]);
+    });
+});

package/dist/src/commanderAdapter.js

@@ -15,7 +15,8 @@ import { formatRegistryHelpText } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { executeCommand } from './execution.js';
 import { CliError, EXIT_CODES, ERROR_ICONS, getErrorMessage, BrowserConnectError, AuthRequiredError, TimeoutError, SelectorError, EmptyResultError, ArgumentError, AdapterLoadError, CommandExecutionError, } from './errors.js';
-import { checkDaemonStatus } from './browser/discover.js';
+import { getDaemonHealth } from './browser/daemon-client.js';
+import { isDiagnosticEnabled } from './diagnostic.js';
 export function normalizeArgValue(argType, value, name) {
     if (argType !== 'bool' && argType !== 'boolean')
         return value;
@@ -169,18 +170,27 @@ function renderBridgeStatus(running, extensionConnected) {
         console.error(chalk.dim('  Try reloading the extension, or run: opencli doctor'));
     }
 }
+/** Emit AutoFix hint for repairable adapter errors (skipped if already in diagnostic mode). */
+function emitAutoFixHint(cmdName) {
+    if (isDiagnosticEnabled())
+        return; // Already collecting diagnostics, don't repeat
+    console.error();
+    console.error(chalk.cyan('💡 AutoFix: re-run with OPENCLI_DIAGNOSTIC=1 for repair context.'));
+    console.error(chalk.dim(`    OPENCLI_DIAGNOSTIC=1 ${cmdName}`));
+}
 async function renderError(err, cmdName, verbose) {
     // ── BrowserConnectError: real-time diagnosis, kind as fallback ────────
     if (err instanceof BrowserConnectError) {
-        console.error(chalk.red('🔌 Browser Bridge not connected'));
+        console.error(chalk.red(`🔌 ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
         console.error();
         try {
-            // 300ms matches execution.ts — localhost responds in <50ms when running.
-            const status = await checkDaemonStatus({ timeout: 300 });
-            renderBridgeStatus(status.running, status.extensionConnected);
+            const health = await getDaemonHealth({ timeout: 300 });
+            renderBridgeStatus(health.state !== 'stopped', health.state === 'ready');
         }
         catch (_statusErr) {
-            // checkDaemonStatus itself failed — derive best-guess state from kind.
+            // getDaemonHealth itself failed — derive best-guess state from kind.
             const running = err.kind !== 'daemon-not-running';
             const extensionConnected = err.kind === 'command-failed';
             renderBridgeStatus(running, extensionConnected);
@@ -208,6 +218,7 @@ async function renderError(err, cmdName, verbose) {
         console.error(chalk.yellow(`→ ${err.hint ?? 'The page structure may have changed — this adapter may be outdated.'}`));
         console.error(chalk.dim(`  Debug:  ${cmdName} --verbose`));
         console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        emitAutoFixHint(cmdName);
         return;
     }
     // ── ArgumentError ─────────────────────────────────────────────────────
@@ -251,6 +262,8 @@ async function renderError(err, cmdName, verbose) {
         console.error(chalk.yellow(`→ ${classified.hint}`));
         if (classified.kind === 'not-found')
             console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        if (classified.kind === 'not-found')
+            emitAutoFixHint(cmdName);
         return;
     }
     // ── Unknown error: show stack in verbose mode ─────────────────────────

package/dist/src/diagnostic.d.ts

@@ -32,6 +32,7 @@ export interface RepairContext {
         url: string;
         snapshot: string;
         networkRequests: unknown[];
+        capturedPayloads?: unknown[];
         consoleErrors: unknown[];
     };
     timestamp: string;

package/dist/src/diagnostic.js

@@ -24,10 +24,16 @@ const MAX_SNAPSHOT_CHARS = 100_000;
 const MAX_SOURCE_CHARS = 50_000;
 /** Maximum number of network requests to include. */
 const MAX_NETWORK_REQUESTS = 50;
+/** Maximum number of captured interceptor payloads to include. */
+const MAX_CAPTURED_PAYLOADS = 20;
 /** Maximum characters for a single network request body. */
 const MAX_REQUEST_BODY_CHARS = 4_000;
 /** Maximum characters for error stack trace. */
 const MAX_STACK_CHARS = 5_000;
+/** Maximum nesting depth for arbitrary captured payloads. */
+const MAX_CAPTURED_DEPTH = 4;
+/** Maximum object keys or array items to keep per nesting level. */
+const MAX_CAPTURED_CHILDREN = 20;
 // ── Sensitive data patterns ──────────────────────────────────────────────────
 const SENSITIVE_HEADERS = new Set([
     'authorization',
@@ -82,6 +88,39 @@ function redactHeaders(headers) {
     }
     return result;
 }
+/** Recursively sanitize arbitrary captured response content for diagnostic output. */
+function sanitizeCapturedValue(value, depth = 0) {
+    if (typeof value === 'string') {
+        return redactText(truncate(value, MAX_REQUEST_BODY_CHARS));
+    }
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (depth >= MAX_CAPTURED_DEPTH) {
+        return '[truncated: max depth reached]';
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, MAX_CAPTURED_CHILDREN)
+            .map(item => sanitizeCapturedValue(item, depth + 1));
+        if (value.length > MAX_CAPTURED_CHILDREN) {
+            items.push(`[truncated, ${value.length - MAX_CAPTURED_CHILDREN} items omitted]`);
+        }
+        return items;
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const entries = Object.entries(value);
+    const result = {};
+    for (const [key, child] of entries.slice(0, MAX_CAPTURED_CHILDREN)) {
+        result[key] = sanitizeCapturedValue(child, depth + 1);
+    }
+    if (entries.length > MAX_CAPTURED_CHILDREN) {
+        result.__truncated__ = `[${entries.length - MAX_CAPTURED_CHILDREN} fields omitted]`;
+    }
+    return result;
+}
 /** Redact sensitive data from a single network request entry. */
 function redactNetworkRequest(req) {
     if (!req || typeof req !== 'object')
@@ -106,6 +145,12 @@ function redactNetworkRequest(req) {
     if (typeof redacted.body === 'string') {
         redacted.body = truncate(redacted.body, MAX_REQUEST_BODY_CHARS);
     }
+    if ('responseBody' in redacted) {
+        redacted.responseBody = sanitizeCapturedValue(redacted.responseBody);
+    }
+    if ('responsePreview' in redacted) {
+        redacted.responsePreview = sanitizeCapturedValue(redacted.responsePreview);
+    }
     return redacted;
 }
 // ── Timeout helper ───────────────────────────────────────────────────────────
@@ -163,23 +208,32 @@ function mapDistToSource(filePath) {
 export function isDiagnosticEnabled() {
     return process.env.OPENCLI_DIAGNOSTIC === '1';
 }
+function normalizeInterceptedRequests(interceptedRequests) {
+    return interceptedRequests.slice(0, MAX_CAPTURED_PAYLOADS).map(responseBody => ({
+        source: 'interceptor',
+        responseBody: sanitizeCapturedValue(responseBody),
+    }));
+}
 /** Safely collect page diagnostic state with redaction, size caps, and timeout. */
 async function collectPageState(page) {
     const collect = async () => {
         try {
-            const [url, snapshot, networkRequests, consoleErrors] = await Promise.all([
+            const [url, snapshot, networkRequests, interceptedRequests, consoleErrors] = await Promise.all([
                 page.getCurrentUrl?.().catch(() => null) ?? Promise.resolve(null),
                 page.snapshot().catch(() => '(snapshot unavailable)'),
                 page.networkRequests().catch(() => []),
+                page.getInterceptedRequests().catch(() => []),
                 page.consoleMessages('error').catch(() => []),
             ]);
             const rawUrl = url ?? 'unknown';
+            const capturedResponses = normalizeInterceptedRequests(interceptedRequests);
             return {
                 url: redactUrl(rawUrl),
                 snapshot: redactText(truncate(snapshot, MAX_SNAPSHOT_CHARS)),
                 networkRequests: networkRequests
                     .slice(0, MAX_NETWORK_REQUESTS)
                     .map(redactNetworkRequest),
+                capturedPayloads: capturedResponses,
                 consoleErrors: consoleErrors
                     .slice(0, 50)
                     .map(e => typeof e === 'string' ? redactText(e) : e),
@@ -235,7 +289,15 @@ export function emitDiagnostic(ctx) {
     let json = JSON.stringify(ctx);
     // Enforce total output budget — drop page state (largest section) first if over budget
     if (json.length > MAX_DIAGNOSTIC_BYTES && ctx.page) {
-        const trimmed = { ...ctx, page: { ...ctx.page, snapshot: '[omitted: over size budget]', networkRequests: [] } };
+        const trimmed = {
+            ...ctx,
+            page: {
+                ...ctx.page,
+                snapshot: '[omitted: over size budget]',
+                networkRequests: [],
+                capturedPayloads: [],
+            },
+        };
         json = JSON.stringify(trimmed);
     }
     // If still over budget, drop page entirely

package/dist/src/diagnostic.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, afterEach } from 'vitest';
-import { buildRepairContext, isDiagnosticEnabled, emitDiagnostic, truncate, redactUrl, redactText, resolveAdapterSourcePath, MAX_DIAGNOSTIC_BYTES, } from './diagnostic.js';
+import { buildRepairContext, collectDiagnostic, isDiagnosticEnabled, emitDiagnostic, truncate, redactUrl, redactText, resolveAdapterSourcePath, MAX_DIAGNOSTIC_BYTES, } from './diagnostic.js';
 import { SelectorError, CommandExecutionError } from './errors.js';
 function makeCmd(overrides = {}) {
     return {
@@ -211,3 +211,93 @@ describe('emitDiagnostic', () => {
         expect(redactUrl('https://api.com/data?token=secret123')).toContain('[REDACTED]');
     });
 });
+function makePage(overrides = {}) {
+    return {
+        goto: vi.fn(),
+        evaluate: vi.fn(),
+        getCookies: vi.fn(),
+        snapshot: vi.fn().mockResolvedValue('<div>...</div>'),
+        click: vi.fn(),
+        typeText: vi.fn(),
+        pressKey: vi.fn(),
+        scrollTo: vi.fn(),
+        getFormState: vi.fn(),
+        wait: vi.fn(),
+        tabs: vi.fn(),
+        selectTab: vi.fn(),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn(),
+        autoScroll: vi.fn(),
+        installInterceptor: vi.fn(),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn(),
+        screenshot: vi.fn(),
+        getCurrentUrl: vi.fn().mockResolvedValue('https://example.com/page'),
+        ...overrides,
+    };
+}
+describe('collectDiagnostic', () => {
+    it('keeps intercepted payloads in a dedicated capturedPayloads field', async () => {
+        const page = makePage({
+            networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
+            getInterceptedRequests: vi.fn().mockResolvedValue([{ items: [{ id: 1 }] }]),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        expect(ctx.page?.networkRequests).toEqual([
+            { url: '/api/data', status: 200 },
+        ]);
+        expect(ctx.page?.capturedPayloads).toEqual([
+            { source: 'interceptor', responseBody: { items: [{ id: 1 }] } },
+        ]);
+    });
+    it('preserves the previous network request output when interception is empty', async () => {
+        const page = makePage({
+            networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
+            getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        expect(ctx.page?.networkRequests).toEqual([{ url: '/api/data', status: 200 }]);
+        expect(ctx.page?.capturedPayloads).toEqual([]);
+    });
+    it('swallows intercepted request failures and still returns page state', async () => {
+        const page = makePage({
+            networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
+            getInterceptedRequests: vi.fn().mockRejectedValue(new Error('interceptor unavailable')),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        expect(ctx.page).toEqual({
+            url: 'https://example.com/page',
+            snapshot: '<div>...</div>',
+            networkRequests: [{ url: '/api/data', status: 200 }],
+            capturedPayloads: [],
+            consoleErrors: [],
+        });
+    });
+    it('redacts and truncates intercepted payloads recursively', async () => {
+        const page = makePage({
+            getInterceptedRequests: vi.fn().mockResolvedValue([{
+                    token: 'token=abc123def456ghi789',
+                    nested: {
+                        cookie: 'cookie: session=super-secret-cookie-value',
+                        body: 'x'.repeat(5000),
+                    },
+                }]),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        const payload = ctx.page?.capturedPayloads?.[0];
+        const body = payload.responseBody.nested.body;
+        expect(payload).toEqual({
+            source: 'interceptor',
+            responseBody: {
+                token: 'token=[REDACTED]',
+                nested: {
+                    cookie: 'cookie: [REDACTED]',
+                    body,
+                },
+            },
+        });
+        expect(body).toContain('[truncated,');
+        expect(body.length).toBeLessThan(5000);
+    });
+});

package/dist/src/doctor.d.ts

@@ -17,7 +17,9 @@ export type ConnectivityResult = {
 export type DoctorReport = {
     cliVersion?: string;
     daemonRunning: boolean;
+    daemonFlaky?: boolean;
     extensionConnected: boolean;
+    extensionFlaky?: boolean;
     extensionVersion?: string;
     connectivity?: ConnectivityResult;
     sessions?: Array<{