@jackwener/opencli 1.6.7 → 1.6.9

package/dist/src/build-manifest.js

@@ -6,7 +6,7 @@
  * manifest.json for instant cold-start registration (no runtime YAML parsing).
  *
  * Usage: npx tsx src/build-manifest.ts
- * Output: dist/cli-manifest.json
+ * Output: cli-manifest.json at the package root
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -14,9 +14,10 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import yaml from 'js-yaml';
 import { getErrorMessage } from './errors.js';
 import { fullName, getRegistry } from './registry.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const CLIS_DIR = path.resolve(__dirname, '..', 'clis');
-const OUTPUT = path.resolve(__dirname, '..', 'cli-manifest.json');
+import { findPackageRoot, getCliManifestPath } from './package-paths.js';
+const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
+const CLIS_DIR = path.join(PACKAGE_ROOT, 'clis');
+const OUTPUT = getCliManifestPath(CLIS_DIR);
 import { parseYamlArgs } from './yaml-schema.js';
 import { isRecord } from './utils.js';
 const CLI_MODULE_PATTERN = /\bcli\s*\(/;
@@ -43,7 +44,7 @@ function isCliCommandValue(value, site) {
         && typeof value.name === 'string'
         && Array.isArray(value.args);
 }
-function toManifestEntry(cmd, modulePath) {
+function toManifestEntry(cmd, modulePath, sourceFile) {
     return {
         site: cmd.site,
         name: cmd.name,
@@ -59,6 +60,7 @@ function toManifestEntry(cmd, modulePath) {
         replacedBy: cmd.replacedBy,
         type: 'ts',
         modulePath,
+        sourceFile,
         navigateBefore: cmd.navigateBefore,
     };
 }
@@ -90,6 +92,7 @@ function scanYaml(filePath, site) {
             deprecated: cliDef.deprecated,
             replacedBy: cliDef.replacedBy,
             type: 'yaml',
+            sourceFile: path.relative(CLIS_DIR, filePath),
             navigateBefore: cliDef.navigateBefore,
         };
     }
@@ -130,7 +133,7 @@ export async function loadTsManifestEntries(filePath, site, importer = moduleHre
             return true;
         })
             .sort((a, b) => a.name.localeCompare(b.name))
-            .map(cmd => toManifestEntry(cmd, modulePath));
+            .map(cmd => toManifestEntry(cmd, modulePath, path.relative(CLIS_DIR, filePath)));
     }
     catch (err) {
         // If parsing fails, log a warning (matching scanYaml behaviour) and skip the entry.
@@ -200,7 +203,7 @@ async function main() {
     // entry-point loses its executable permission, causing "Permission denied".
     // See: https://github.com/jackwener/opencli/issues/446
     if (process.platform !== 'win32') {
-        const projectRoot = path.resolve(__dirname, '..', '..');
+        const projectRoot = PACKAGE_ROOT;
         const pkgPath = path.resolve(projectRoot, 'package.json');
         try {
             const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));

package/dist/src/build-manifest.test.js

@@ -87,7 +87,7 @@ describe('manifest helper rules', () => {
                 replacedBy: 'opencli demo new',
             }),
         }));
-        expect(entries).toEqual([
+        expect(entries).toMatchObject([
             {
                 site,
                 name: 'dynamic',
@@ -97,7 +97,7 @@ describe('manifest helper rules', () => {
                 browser: false,
                 aliases: ['metadata'],
                 args: [
-                    {
+                    expect.objectContaining({
                         name: 'model',
                         type: 'str',
                         required: true,
@@ -105,7 +105,7 @@ describe('manifest helper rules', () => {
                         help: 'Choose a model',
                         choices: ['auto', 'thinking'],
                         default: '30',
-                    },
+                    }),
                 ],
                 type: 'ts',
                 modulePath: `${site}/${site}.js`,
@@ -114,6 +114,8 @@ describe('manifest helper rules', () => {
                 replacedBy: 'opencli demo new',
             },
         ]);
+        // Verify sourceFile is included
+        expect(entries[0].sourceFile).toBeDefined();
         getRegistry().delete(key);
     });
     it('falls back to registry delta for side-effect-only cli modules', async () => {
@@ -133,7 +135,7 @@ describe('manifest helper rules', () => {
             });
             return {};
         });
-        expect(entries).toEqual([
+        expect(entries).toMatchObject([
             {
                 site,
                 name: 'legacy',
@@ -147,6 +149,8 @@ describe('manifest helper rules', () => {
                 replacedBy: 'opencli demo new',
             },
         ]);
+        // Verify sourceFile is included
+        expect(entries[0].sourceFile).toBeDefined();
         getRegistry().delete(key);
     });
     it('keeps every command a module exports instead of guessing by site', async () => {

package/dist/src/cli.d.ts

@@ -5,6 +5,7 @@
  * Dynamic adapter commands are registered via commanderAdapter.ts.
  */
 import { Command } from 'commander';
+import { findPackageRoot } from './package-paths.js';
 export declare function createProgram(BUILTIN_CLIS: string, USER_CLIS: string): Command;
 export declare function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void;
 export interface OperateVerifyInvocation {
@@ -13,7 +14,7 @@ export interface OperateVerifyInvocation {
     cwd: string;
     shell?: boolean;
 }
-export declare function findPackageRoot(startFile: string, fileExists?: (path: string) => boolean): string;
+export { findPackageRoot };
 export declare function resolveOperateVerifyInvocation(opts?: {
     projectRoot?: string;
     platform?: NodeJS.Platform;

package/dist/src/cli.js

@@ -9,6 +9,7 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 import chalk from 'chalk';
+import { findPackageRoot, getBuiltEntryCandidates } from './package-paths.js';
 import { fullName, getRegistry, strategyLabel } from './registry.js';
 import { serializeCommand, formatArgSummary } from './serialization.js';
 import { render as renderOutput } from './output.js';
@@ -268,13 +269,17 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
     const NETWORK_INTERCEPTOR_JS = `(function(){if(window.__opencli_net)return;window.__opencli_net=[];var M=200,B=50000,F=window.fetch;window.fetch=async function(){var r=await F.apply(this,arguments);try{var ct=r.headers.get('content-type')||'';if(ct.includes('json')||ct.includes('text')){var c=r.clone(),t=await c.text();if(window.__opencli_net.length<M){var b=null;if(t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:r.url||(arguments[0]&&arguments[0].url)||String(arguments[0]),method:(arguments[1]&&arguments[1].method)||'GET',status:r.status,size:t.length,ct:ct,body:b})}}}catch(e){}return r};var X=XMLHttpRequest.prototype,O=X.open,S=X.send;X.open=function(m,u){this._om=m;this._ou=u;return O.apply(this,arguments)};X.send=function(){var x=this;x.addEventListener('load',function(){try{var ct=x.getResponseHeader('content-type')||'';if((ct.includes('json')||ct.includes('text'))&&window.__opencli_net.length<M){var t=x.responseText,b=null;if(t&&t.length<=B)try{b=JSON.parse(t)}catch(e){b=t}window.__opencli_net.push({url:x._ou,method:x._om||'GET',status:x.status,size:t?t.length:0,ct:ct,body:b})}}catch(e){}});return S.apply(this,arguments)}})()`;
     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)
+        const hasSessionCapture = await page.startNetworkCapture?.().then(() => true).catch(() => false);
         await page.goto(url);
         await page.wait(2);
-        // Auto-inject network interceptor for API discovery
-        try {
-            await page.evaluate(NETWORK_INTERCEPTOR_JS);
+        // Fallback: inject JS interceptor when session capture is unavailable
+        if (!hasSessionCapture) {
+            try {
+                await page.evaluate(NETWORK_INTERCEPTOR_JS);
+            }
+            catch { /* non-fatal */ }
         }
-        catch { /* non-fatal */ }
         console.log(`Navigated to: ${await page.getCurrentUrl?.() ?? url}`);
     }));
     operate.command('back').description('Go back in browser history')
@@ -456,17 +461,46 @@ export function createProgram(BUILTIN_CLIS, USER_CLIS) {
         .option('--all', 'Show all requests including static resources')
         .description('Show captured network requests (auto-captured since last open)')
         .action(operateAction(async (page, opts) => {
-        const requests = await page.evaluate(`(function(){
-        var reqs = window.__opencli_net || [];
-        return JSON.stringify(reqs);
-      })()`);
         let items = [];
-        try {
-            items = JSON.parse(requests);
+        if (page.readNetworkCapture) {
+            const raw = await page.readNetworkCapture();
+            // Normalize daemon/CDP capture entries to __opencli_net shape.
+            // Daemon returns: responseStatus, responseContentType, responsePreview
+            // CDP returns the same shape after PR A fix.
+            items = raw.map(e => {
+                const preview = e.responsePreview ?? null;
+                let body = null;
+                if (preview) {
+                    try {
+                        body = JSON.parse(preview);
+                    }
+                    catch {
+                        body = preview;
+                    }
+                }
+                return {
+                    url: e.url || '',
+                    method: e.method || 'GET',
+                    status: e.responseStatus || 0,
+                    size: preview ? preview.length : 0,
+                    ct: e.responseContentType || '',
+                    body,
+                };
+            });
         }
-        catch {
-            console.log('No network data captured. Run "operate open <url>" first.');
-            return;
+        else {
+            // Fallback to JS interceptor data
+            const requests = await page.evaluate(`(function(){
+          var reqs = window.__opencli_net || [];
+          return JSON.stringify(reqs);
+        })()`);
+            try {
+                items = JSON.parse(requests);
+            }
+            catch {
+                console.log('No network data captured. Run "operate open <url>" first.');
+                return;
+            }
         }
         if (items.length === 0) {
             console.log('No requests captured.');
@@ -943,39 +977,7 @@ cli({
 export function runCli(BUILTIN_CLIS, USER_CLIS) {
     createProgram(BUILTIN_CLIS, USER_CLIS).parse();
 }
-export function findPackageRoot(startFile, fileExists = fs.existsSync) {
-    let dir = path.dirname(startFile);
-    while (true) {
-        if (fileExists(path.join(dir, 'package.json')))
-            return dir;
-        const parent = path.dirname(dir);
-        if (parent === dir) {
-            throw new Error(`Could not find package.json above ${startFile}`);
-        }
-        dir = parent;
-    }
-}
-function getBuiltEntryCandidates(packageRoot, readFile) {
-    const candidates = [];
-    try {
-        const pkg = JSON.parse(readFile(path.join(packageRoot, 'package.json')));
-        if (typeof pkg.bin === 'string') {
-            candidates.push(path.join(packageRoot, pkg.bin));
-        }
-        else if (pkg.bin && typeof pkg.bin === 'object' && typeof pkg.bin.opencli === 'string') {
-            candidates.push(path.join(packageRoot, pkg.bin.opencli));
-        }
-        if (typeof pkg.main === 'string') {
-            candidates.push(path.join(packageRoot, pkg.main));
-        }
-    }
-    catch {
-        // Fall through to compatibility candidates below.
-    }
-    // Compatibility fallback for partially-built trees or older layouts.
-    candidates.push(path.join(packageRoot, 'dist', 'src', 'main.js'), path.join(packageRoot, 'dist', 'main.js'));
-    return [...new Set(candidates)];
-}
+export { findPackageRoot };
 export function resolveOperateVerifyInvocation(opts = {}) {
     const platform = opts.platform ?? process.platform;
     const fileExists = opts.fileExists ?? fs.existsSync;

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/commands/daemon.js

@@ -6,15 +6,7 @@
  */
 import chalk from 'chalk';
 import { fetchDaemonStatus, requestDaemonShutdown } from '../browser/daemon-client.js';
-function formatUptime(seconds) {
-    const h = Math.floor(seconds / 3600);
-    const m = Math.floor((seconds % 3600) / 60);
-    if (h > 0)
-        return `${h}h ${m}m`;
-    if (m > 0)
-        return `${m}m`;
-    return `${Math.floor(seconds)}s`;
-}
+import { formatDuration } from '../download/progress.js';
 function formatTimeSince(timestampMs) {
     const seconds = (Date.now() - timestampMs) / 1000;
     if (seconds < 60)
@@ -32,7 +24,7 @@ export async function daemonStatus() {
         return;
     }
     console.log(`Daemon: ${chalk.green('running')} (PID ${status.pid})`);
-    console.log(`Uptime: ${formatUptime(status.uptime)}`);
+    console.log(`Uptime: ${formatDuration(Math.round(status.uptime * 1000))}`);
     console.log(`Extension: ${status.extensionConnected ? chalk.green('connected') : chalk.yellow('disconnected')}`);
     console.log(`Last CLI request: ${formatTimeSince(status.lastCliRequestTime)}`);
     console.log(`Memory: ${status.memoryMB} MB`);

package/dist/src/diagnostic.d.ts

@@ -4,9 +4,17 @@
  * When OPENCLI_DIAGNOSTIC=1, failed commands emit a JSON RepairContext to stderr
  * containing the error, adapter source, and browser state (DOM snapshot, network
  * requests, console errors). AI Agents consume this to diagnose and fix adapters.
+ *
+ * Safety boundaries:
+ * - Sensitive headers/cookies are redacted before emission
+ * - Individual fields are capped to prevent unbounded output
+ * - Network response bodies from authenticated requests are stripped
+ * - Total output is capped to MAX_DIAGNOSTIC_BYTES
  */
 import type { IPage } from './types.js';
 import type { InternalCliCommand } from './registry.js';
+/** Maximum bytes for the entire diagnostic JSON output. */
+export declare const MAX_DIAGNOSTIC_BYTES: number;
 export interface RepairContext {
     error: {
         code: string;
@@ -24,15 +32,33 @@ export interface RepairContext {
         url: string;
         snapshot: string;
         networkRequests: unknown[];
+        capturedPayloads?: unknown[];
         consoleErrors: unknown[];
     };
     timestamp: string;
 }
+/** Truncate a string to maxLen, appending a truncation marker. */
+export declare function truncate(str: string, maxLen: number): string;
+/** Redact sensitive query parameters from a URL. */
+export declare function redactUrl(url: string): string;
+/** Redact inline secrets from free-text strings (error messages, stack traces, console output, DOM). */
+export declare function redactText(text: string): string;
+/**
+ * Resolve the editable source file path for an adapter.
+ *
+ * Priority:
+ * 1. cmd.source (set for FS-scanned YAML/TS and manifest lazy-loaded TS)
+ * 2. cmd._modulePath (set for manifest lazy-loaded TS, points to dist/)
+ *
+ * For dist/ paths, attempt to map back to the original .ts source file.
+ * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
+ */
+export declare function resolveAdapterSourcePath(cmd: InternalCliCommand): string | undefined;
 /** Whether diagnostic mode is enabled. */
 export declare function isDiagnosticEnabled(): boolean;
 /** Build a RepairContext from an error, command metadata, and optional page state. */
 export declare function buildRepairContext(err: unknown, cmd: InternalCliCommand, pageState?: RepairContext['page']): RepairContext;
-/** Collect full diagnostic context including page state. */
+/** Collect full diagnostic context including page state (with timeout). */
 export declare function collectDiagnostic(err: unknown, cmd: InternalCliCommand, page: IPage | null): Promise<RepairContext>;
-/** Emit diagnostic JSON to stderr. */
+/** Emit diagnostic JSON to stderr, enforcing total size cap. */
 export declare function emitDiagnostic(ctx: RepairContext): void;