@raintree-technology/perps 0.1.0

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerDoctorCommand(program: Command): void;

package/dist/commands/doctor.js

@@ -0,0 +1,201 @@
+import { getOutputOptions, getSelectedExchange, getVerbose } from "../cli/program.js";
+import { output } from "../cli/output.js";
+import { parsePositiveInt } from "../lib/validate.js";
+import { loadConfig } from "../lib/config.js";
+import { getAvailableExchanges } from "../lib/exchange.js";
+import { generateAdapterCapabilityReport } from "../adapters/certification.js";
+import { getUIDemoJsonPreview } from "./ui/demo.js";
+import { formatStatusLine, highlighter, startSpinner, } from "../cli/experience.js";
+function getErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function formatCheckMessage(check) {
+    const duration = highlighter.dim(`(${check.durationMs}ms)`);
+    if (check.ok) {
+        if (check.details) {
+            return `${check.name} ${duration} ${highlighter.dim(`· ${check.details}`)}`;
+        }
+        return `${check.name} ${duration}`;
+    }
+    return `${check.name} ${duration}: ${check.error}`;
+}
+async function runCheck(definition, showProgress) {
+    const startedAt = performance.now();
+    const spinner = showProgress ? startSpinner(`Checking ${definition.name}...`) : null;
+    try {
+        const details = await definition.run();
+        const result = {
+            name: definition.name,
+            recommendation: definition.recommendation,
+            ok: true,
+            durationMs: Math.round(performance.now() - startedAt),
+            details,
+        };
+        spinner?.succeed(formatCheckMessage(result));
+        return result;
+    }
+    catch (err) {
+        const result = {
+            name: definition.name,
+            recommendation: definition.recommendation,
+            ok: false,
+            durationMs: Math.round(performance.now() - startedAt),
+            error: getErrorMessage(err),
+        };
+        spinner?.fail(formatCheckMessage(result));
+        return result;
+    }
+}
+function checkNodeVersion() {
+    const major = Number(process.versions.node.split(".")[0]);
+    if (!Number.isFinite(major) || major < 18) {
+        throw new Error(`Node >=18 required, found ${process.versions.node}`);
+    }
+    return process.versions.node;
+}
+function checkConfigLoad(exchange) {
+    const config = loadConfig(false, exchange);
+    return config.testnet ? "loaded (testnet)" : "loaded (mainnet)";
+}
+function checkExchangeRegistry() {
+    const exchanges = getAvailableExchanges();
+    if (exchanges.length === 0) {
+        throw new Error("No exchanges registered");
+    }
+    return `${exchanges.length} exchanges`;
+}
+function checkCapabilityReport() {
+    const report = generateAdapterCapabilityReport();
+    if (!Array.isArray(report.exchanges) || report.exchanges.length === 0) {
+        throw new Error("Capability report is empty");
+    }
+    const exchangesWithIssues = report.exchanges.filter((exchange) => exchange.errorSemantics.issues.length > 0).length;
+    return `${report.exchanges.length} exchanges, ${exchangesWithIssues} issue sets`;
+}
+function checkUIDemoContract() {
+    const preview = getUIDemoJsonPreview(500);
+    if (preview.command !== "ui demo") {
+        throw new Error("Unexpected ui demo command field");
+    }
+    if (preview.interactive !== false) {
+        throw new Error("Expected interactive=false in JSON preview");
+    }
+    return "ui demo JSON shape OK";
+}
+async function checkNetwork(timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch("https://api.hyperliquid.xyz/info", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ type: "meta" }),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const payload = (await response.json());
+        const universe = Array.isArray(payload.universe) ? payload.universe : [];
+        if (universe.length === 0) {
+            throw new Error("Received empty market universe");
+        }
+        return `${universe.length} markets`;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function printFailureDetails(report) {
+    const failedChecks = report.checks.filter((check) => !check.ok);
+    if (failedChecks.length === 0)
+        return;
+    for (const check of failedChecks) {
+        console.log(`  ${highlighter.error("✗")} ${check.name}: ${check.error}`);
+        console.log(`    ${highlighter.dim("→")} ${check.recommendation}`);
+    }
+}
+function buildChecks(exchange, includeNetwork, timeoutMs) {
+    const checks = [
+        {
+            name: "node version",
+            recommendation: "Install Node.js 18+ (Node 20+ recommended).",
+            run: () => checkNodeVersion(),
+        },
+        {
+            name: "config load",
+            recommendation: "Verify your .env and settings with `perps config show`.",
+            run: () => checkConfigLoad(exchange),
+        },
+        {
+            name: "exchange registry",
+            recommendation: "Reinstall dependencies so adapters register correctly (`corepack pnpm install`).",
+            run: () => checkExchangeRegistry(),
+        },
+        {
+            name: "capability report",
+            recommendation: "Run `perps exchange capabilities --json` to inspect adapter health details.",
+            run: () => checkCapabilityReport(),
+        },
+        {
+            name: "ui demo contract",
+            recommendation: "Rebuild the CLI (`corepack pnpm build`) to restore UI demo output shape.",
+            run: () => checkUIDemoContract(),
+        },
+    ];
+    if (includeNetwork) {
+        checks.push({
+            name: "network reachability",
+            recommendation: "Verify outbound HTTPS access to https://api.hyperliquid.xyz/info or retry with a larger --timeout.",
+            run: () => checkNetwork(timeoutMs),
+        });
+    }
+    return checks;
+}
+export function registerDoctorCommand(program) {
+    program
+        .command("doctor")
+        .description("Run runtime health checks")
+        .option("--network", "Include live network reachability check")
+        .option("--timeout <ms>", "Network timeout in milliseconds", "15000")
+        .action(async function (options) {
+        const outputOpts = getOutputOptions(this);
+        const verbose = getVerbose(this);
+        const includeNetwork = options.network ?? false;
+        const timeoutMs = parsePositiveInt(options.timeout, "timeout", 15_000);
+        const selectedExchange = getSelectedExchange(this);
+        const checks = buildChecks(selectedExchange, includeNetwork, timeoutMs);
+        const results = [];
+        for (const check of checks) {
+            results.push(await runCheck(check, verbose && !outputOpts.json));
+        }
+        const report = {
+            ok: results.every((check) => check.ok),
+            generatedAt: new Date().toISOString(),
+            includeNetwork,
+            nodeVersion: process.versions.node,
+            exchange: selectedExchange,
+            checks: results,
+        };
+        if (outputOpts.json) {
+            output(report, outputOpts);
+        }
+        else {
+            const passed = results.filter((c) => c.ok).length;
+            const total = results.length;
+            if (verbose) {
+                console.log("");
+            }
+            if (report.ok) {
+                console.log(formatStatusLine("success", `${passed}/${total} checks passed`));
+            }
+            else {
+                console.log(formatStatusLine("error", `${passed}/${total} checks passed`));
+                printFailureDetails(report);
+            }
+        }
+        if (!report.ok) {
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/exchange/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerExchangeCommands(program: Command): void;

package/dist/commands/exchange/index.js

@@ -0,0 +1,107 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { getOutputOptions } from "../../cli/program.js";
+import { output } from "../../cli/output.js";
+import { generateAdapterCapabilityReport } from "../../adapters/certification.js";
+import { withJsonContract } from "../../lib/contracts.js";
+function buildCapabilityRows(report) {
+    return report.exchanges.map((exchange) => {
+        return {
+            id: exchange.id,
+            name: exchange.name,
+            marketData: exchange.capabilities.marketData.level,
+            authenticatedReads: exchange.capabilities.authenticatedReads.level,
+            orderLifecycle: exchange.capabilities.orderLifecycle.level,
+            orderCancellation: exchange.capabilities.orderCancellation.level,
+            subscriptions: exchange.capabilities.subscriptions.level,
+        };
+    });
+}
+export function registerExchangeCommands(program) {
+    const exchange = program.command("exchange").description("Exchange metadata and capabilities");
+    exchange
+        .command("capabilities")
+        .description("Show machine-readable adapter capability status")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const report = generateAdapterCapabilityReport();
+        const rows = buildCapabilityRows(report);
+        if (outputOpts.json) {
+            output(withJsonContract("exchange.capabilities.report", report), outputOpts);
+            return;
+        }
+        console.log("");
+        console.log("Exchange".padEnd(18) + "Market".padEnd(10) + "Auth".padEnd(10) + "Orders".padEnd(10) + "Cancel".padEnd(10) + "Subs");
+        console.log("─".repeat(66));
+        for (const row of rows) {
+            console.log(row.name.padEnd(18) +
+                row.marketData.padEnd(10) +
+                row.authenticatedReads.padEnd(10) +
+                row.orderLifecycle.padEnd(10) +
+                row.orderCancellation.padEnd(10) +
+                row.subscriptions);
+        }
+        console.log("");
+    });
+    exchange
+        .command("parity")
+        .description("Generate adapter parity dashboard and optionally write reports")
+        .option("--write <dir>", "Write markdown + json parity report artifacts to a directory")
+        .option("--strict", "Exit non-zero if any exchange is not fully featured")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const report = generateAdapterCapabilityReport();
+        const rows = buildCapabilityRows(report);
+        const fullCount = rows.filter((row) => row.marketData === "full" &&
+            row.authenticatedReads === "full" &&
+            row.orderLifecycle === "full" &&
+            row.orderCancellation === "full" &&
+            row.subscriptions === "full").length;
+        const fullyFeatured = fullCount === rows.length;
+        if (opts.write) {
+            const targetDir = resolve(opts.write);
+            mkdirSync(targetDir, { recursive: true });
+            const jsonPath = resolve(targetDir, "adapter-parity.json");
+            const markdownPath = resolve(targetDir, "adapter-parity.md");
+            writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`);
+            writeFileSync(markdownPath, [
+                "# Adapter Parity Dashboard",
+                "",
+                `Generated: ${new Date(report.generatedAt).toISOString()}`,
+                "",
+                "| exchange | market | auth | order | cancel | subs |",
+                "| --- | --- | --- | --- | --- | --- |",
+                ...rows.map((row) => `| ${row.id} | ${row.marketData} | ${row.authenticatedReads} | ${row.orderLifecycle} | ${row.orderCancellation} | ${row.subscriptions} |`),
+                "",
+            ].join("\n"));
+        }
+        const payload = {
+            generatedAt: report.generatedAt,
+            fullyFeatured,
+            fullCount,
+            total: rows.length,
+            rows,
+            report,
+        };
+        if (outputOpts.json) {
+            output(withJsonContract("exchange.parity.dashboard", payload), outputOpts);
+        }
+        else {
+            console.log("");
+            console.log(`Fully featured adapters: ${fullCount}/${rows.length}`);
+            for (const row of rows) {
+                console.log(`  ${row.id.padEnd(12)} market=${row.marketData} auth=${row.authenticatedReads} order=${row.orderLifecycle} cancel=${row.orderCancellation} subs=${row.subscriptions}`);
+            }
+            if (opts.write) {
+                console.log(`\nReport files written to ${resolve(opts.write)}\n`);
+            }
+            else {
+                console.log("");
+            }
+        }
+        if (opts.strict && !fullyFeatured) {
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerCommands(program: Command): void;

package/dist/commands/index.js

@@ -0,0 +1,48 @@
+import { registerAccountCommands } from "./account/index.js";
+import { registerMarketsCommands } from "./markets/index.js";
+import { registerAssetCommands } from "./asset/index.js";
+import { registerOrderCommands } from "./order/index.js";
+import { registerConfigCommands } from "./config/index.js";
+import { registerServerCommands } from "./server.js";
+import { registerUpgradeCommand } from "./upgrade.js";
+import { registerArbCommands } from "./arb/index.js";
+import { registerExchangeCommands } from "./exchange/index.js";
+import { registerDataCommands } from "./data/index.js";
+import { registerOperatorCommands } from "./operator/index.js";
+import { registerUICommands } from "./ui/index.js";
+import { registerDoctorCommand } from "./doctor.js";
+import { registerSetupCommands } from "./setup/index.js";
+import { registerAgentCommands } from "./agent/index.js";
+import { registerReferralCommands } from "./referral/index.js";
+import { registerStateCommands } from "./state/index.js";
+import { registerRiskCommands } from "./risk/index.js";
+import { registerCompletionCommand } from "./completion.js";
+import { registerStrategyCommands } from "./strategy/index.js";
+import { registerReplayCommands } from "./replay/index.js";
+import { registerTracesCommands } from "./traces/index.js";
+import { registerSignalCommands } from "./signal/index.js";
+export function registerCommands(program) {
+    registerAccountCommands(program);
+    registerMarketsCommands(program);
+    registerAssetCommands(program);
+    registerOrderCommands(program);
+    registerArbCommands(program);
+    registerOperatorCommands(program);
+    registerUICommands(program);
+    registerSetupCommands(program);
+    registerAgentCommands(program);
+    registerConfigCommands(program);
+    registerExchangeCommands(program);
+    registerDataCommands(program);
+    registerReferralCommands(program);
+    registerStateCommands(program);
+    registerRiskCommands(program);
+    registerDoctorCommand(program);
+    registerServerCommands(program);
+    registerUpgradeCommand(program);
+    registerStrategyCommands(program);
+    registerReplayCommands(program);
+    registerTracesCommands(program);
+    registerSignalCommands(program);
+    registerCompletionCommand(program);
+}

package/dist/commands/markets/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerMarketsCommands(program: Command): void;

package/dist/commands/markets/index.js

@@ -0,0 +1,5 @@
+import { registerMarketsLsSimpleCommand } from "./ls-simple.js";
+export function registerMarketsCommands(program) {
+    const markets = program.command("markets").description("Market information");
+    registerMarketsLsSimpleCommand(markets);
+}

package/dist/commands/markets/ls-simple.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Markets list command
+ * Supports single-exchange listing, cross-exchange grouping (--all),
+ * and cross-exchange analysis report (--report)
+ */
+import { Command } from "commander";
+export declare function registerMarketsLsSimpleCommand(markets: Command): void;

package/dist/commands/markets/ls-simple.js

@@ -0,0 +1,277 @@
+/**
+ * Markets list command
+ * Supports single-exchange listing, cross-exchange grouping (--all),
+ * and cross-exchange analysis report (--report)
+ */
+import { output, outputError } from "../../cli/output.js";
+import { getContext, getOutputOptions, getVerbose } from "../../cli/program.js";
+import { getAvailableExchanges, getExchangeAdapter, getExchangeAdapterById, } from "../../lib/exchange.js";
+import { pLimit } from "../../lib/rate-limit.js";
+export function registerMarketsLsSimpleCommand(markets) {
+    markets
+        .command("ls")
+        .description("List available markets")
+        .option("--perp", "Show perpetual markets only")
+        .option("--spot", "Show spot markets only")
+        .option("--all", "List markets across all exchanges, grouped by asset")
+        .option("--report", "Show cross-exchange analysis report (implies --all)")
+        .option("--limit <n>", "Number of markets to show (0 for all)", "20")
+        .action(async function () {
+        const ctx = getContext(this);
+        const outputOpts = getOutputOptions(this);
+        const verbose = getVerbose(this);
+        const opts = this.opts();
+        const parsed = parseInt(opts.limit ?? "20", 10);
+        const limit = verbose ? 0 : (Number.isFinite(parsed) ? Math.max(0, parsed) : 20);
+        if (opts.report) {
+            await handleReport(ctx, outputOpts, opts);
+        }
+        else if (opts.all) {
+            await handleAllExchanges(ctx, outputOpts, opts);
+        }
+        else {
+            await handleSingleExchange(ctx, outputOpts, opts, limit);
+        }
+    });
+}
+async function handleSingleExchange(ctx, outputOpts, opts, limit = 0) {
+    const adapter = getExchangeAdapter();
+    let connected = false;
+    try {
+        await adapter.connect({ testnet: ctx.config.testnet });
+        connected = true;
+        const markets = await adapter.getMarkets();
+        let filtered = markets;
+        if (opts.perp) {
+            filtered = markets.filter((m) => m.type === "perp");
+        }
+        else if (opts.spot) {
+            filtered = markets.filter((m) => m.type === "spot");
+        }
+        if (outputOpts.json) {
+            output(filtered, outputOpts);
+        }
+        else {
+            const showAll = limit === 0 || limit >= filtered.length;
+            const display = showAll ? filtered : filtered.slice(0, limit);
+            const remaining = filtered.length - display.length;
+            console.log(`\n${adapter.info.name} Markets (${filtered.length}):\n`);
+            console.log("  Symbol".padEnd(15) + "Base".padEnd(8) + "Max Lev".padEnd(10) + "Min Size");
+            console.log("  " + "-".repeat(50));
+            for (const m of display) {
+                const row = [
+                    `  ${m.symbol}`.padEnd(15),
+                    m.baseAsset.padEnd(8),
+                    `${m.maxLeverage}x`.padEnd(10),
+                    m.minSize,
+                ].join("");
+                console.log(row);
+            }
+            if (remaining > 0) {
+                console.log(`\n  ... and ${remaining} more (--limit 0 or -v to show all)`);
+            }
+            console.log("");
+        }
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        if (connected) {
+            await adapter.disconnect().catch(() => undefined);
+        }
+    }
+}
+async function fetchAllExchangeMarkets(ctx) {
+    const exchangeIds = getAvailableExchanges();
+    const connectedAdapters = [];
+    const tasks = exchangeIds.map((id) => async () => {
+        const adapter = getExchangeAdapterById(id);
+        await adapter.connect({ testnet: ctx.config.testnet });
+        connectedAdapters.push(adapter);
+        const markets = await adapter.getMarkets();
+        return { id, name: adapter.info.name, markets };
+    });
+    const results = await pLimit(tasks, 3);
+    const exchangeMarkets = [];
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            exchangeMarkets.push(result.value);
+        }
+    }
+    return { exchangeMarkets, connectedAdapters };
+}
+function groupByAsset(exchangeMarkets, opts) {
+    const assetMap = new Map();
+    for (const { id, markets } of exchangeMarkets) {
+        let filtered = markets;
+        if (opts.perp) {
+            filtered = markets.filter((m) => m.type === "perp");
+        }
+        else if (opts.spot) {
+            filtered = markets.filter((m) => m.type === "spot");
+        }
+        for (const m of filtered) {
+            const existing = assetMap.get(m.baseAsset);
+            if (existing) {
+                existing.exchanges.push(id);
+            }
+            else {
+                assetMap.set(m.baseAsset, { symbol: m.symbol, exchanges: [id] });
+            }
+        }
+    }
+    return assetMap;
+}
+function sortedAssets(assetMap) {
+    return [...assetMap.entries()].sort((a, b) => {
+        const countDiff = b[1].exchanges.length - a[1].exchanges.length;
+        if (countDiff !== 0)
+            return countDiff;
+        return a[0].localeCompare(b[0]);
+    });
+}
+async function handleAllExchanges(ctx, outputOpts, opts) {
+    let connectedAdapters = [];
+    try {
+        const fetched = await fetchAllExchangeMarkets(ctx);
+        connectedAdapters = fetched.connectedAdapters;
+        const assetMap = groupByAsset(fetched.exchangeMarkets, opts);
+        const sorted = sortedAssets(assetMap);
+        if (outputOpts.json) {
+            const jsonData = sorted.map(([asset, info]) => ({
+                asset,
+                symbol: info.symbol,
+                exchanges: info.exchanges,
+                count: info.exchanges.length,
+            }));
+            output(jsonData, outputOpts);
+        }
+        else {
+            const totalExchanges = fetched.exchangeMarkets.length;
+            console.log(`\nCross-Exchange Markets (${sorted.length} assets, ${totalExchanges} exchanges):\n`);
+            console.log("  " + "Asset".padEnd(10) + "Symbol".padEnd(14) + "Exchanges");
+            console.log("  " + "-".repeat(60));
+            for (const [asset, info] of sorted) {
+                const row = "  " + asset.padEnd(10) + info.symbol.padEnd(14) + info.exchanges.join("  ");
+                console.log(row);
+            }
+            console.log("");
+        }
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        for (const adapter of connectedAdapters) {
+            await adapter.disconnect().catch(() => undefined);
+        }
+    }
+}
+async function handleReport(ctx, outputOpts, opts) {
+    let connectedAdapters = [];
+    try {
+        const fetched = await fetchAllExchangeMarkets(ctx);
+        connectedAdapters = fetched.connectedAdapters;
+        const { exchangeMarkets } = fetched;
+        const assetMap = groupByAsset(exchangeMarkets, opts);
+        const sorted = sortedAssets(assetMap);
+        const totalAssets = sorted.length;
+        const totalExchanges = exchangeMarkets.length;
+        const multiExchange = sorted.filter(([, info]) => info.exchanges.length >= 2);
+        const allExchange = sorted.filter(([, info]) => info.exchanges.length === totalExchanges);
+        const exclusive = sorted.filter(([, info]) => info.exchanges.length === 1);
+        // Per-exchange market counts
+        const exchangeCounts = [];
+        for (const ex of exchangeMarkets) {
+            let filtered = ex.markets;
+            if (opts.perp) {
+                filtered = ex.markets.filter((m) => m.type === "perp");
+            }
+            else if (opts.spot) {
+                filtered = ex.markets.filter((m) => m.type === "spot");
+            }
+            exchangeCounts.push({ exchange: ex.id, markets: filtered.length });
+        }
+        exchangeCounts.sort((a, b) => b.markets - a.markets);
+        // Exclusives grouped by exchange
+        const exclusivesByExchange = new Map();
+        for (const [asset, info] of exclusive) {
+            const ex = info.exchanges[0];
+            const list = exclusivesByExchange.get(ex) ?? [];
+            list.push(asset);
+            exclusivesByExchange.set(ex, list);
+        }
+        if (outputOpts.json) {
+            const report = {
+                summary: {
+                    totalAssets,
+                    totalExchanges,
+                    arbCandidates: multiExchange.length,
+                    onAllExchanges: allExchange.length,
+                    exclusiveToOne: exclusive.length,
+                },
+                exchanges: exchangeCounts,
+                arbOpportunities: multiExchange.map(([asset, info]) => ({
+                    asset,
+                    symbol: info.symbol,
+                    exchanges: info.exchanges,
+                    count: info.exchanges.length,
+                })),
+                exclusives: Object.fromEntries(exclusivesByExchange),
+            };
+            output(report, outputOpts);
+        }
+        else {
+            console.log("\n" + "=".repeat(64));
+            console.log("  CROSS-EXCHANGE MARKET REPORT");
+            console.log("=".repeat(64));
+            console.log("\n  Summary");
+            console.log("  " + "-".repeat(40));
+            console.log(`  Total assets:        ${totalAssets}`);
+            console.log(`  Exchanges online:    ${totalExchanges}`);
+            console.log(`  Arb candidates:      ${multiExchange.length} (listed on 2+ exchanges)`);
+            console.log(`  On all exchanges:    ${allExchange.length}`);
+            console.log(`  Exclusive to one:    ${exclusive.length}`);
+            console.log("\n  Markets per Exchange");
+            console.log("  " + "-".repeat(40));
+            for (const { exchange, markets } of exchangeCounts) {
+                console.log(`  ${exchange.padEnd(20)} ${markets}`);
+            }
+            if (multiExchange.length > 0) {
+                console.log("\n  Arb Opportunities (2+ exchanges)");
+                console.log("  " + "-".repeat(60));
+                console.log("  " + "Asset".padEnd(10) + "Symbol".padEnd(14) + "#".padEnd(4) + "Exchanges");
+                console.log("  " + "-".repeat(60));
+                for (const [asset, info] of multiExchange) {
+                    console.log("  " +
+                        asset.padEnd(10) +
+                        info.symbol.padEnd(14) +
+                        String(info.exchanges.length).padEnd(4) +
+                        info.exchanges.join("  "));
+                }
+            }
+            if (exclusive.length > 0) {
+                console.log("\n  Exchange Exclusives");
+                console.log("  " + "-".repeat(60));
+                for (const [ex, assets] of exclusivesByExchange) {
+                    const preview = assets.slice(0, 10).join(", ");
+                    const suffix = assets.length > 10 ? ` (+${assets.length - 10} more)` : "";
+                    console.log(`  ${ex.padEnd(16)} ${assets.length} assets: ${preview}${suffix}`);
+                }
+            }
+            console.log("\n" + "=".repeat(64) + "\n");
+        }
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        for (const adapter of connectedAdapters) {
+            await adapter.disconnect().catch(() => undefined);
+        }
+    }
+}

package/dist/commands/operator/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerOperatorCommands(program: Command): void;