perp-cli 0.3.3

package/dist/commands/portfolio.js

@@ -0,0 +1,169 @@
+import chalk from "chalk";
+import { printJson, jsonOk, makeTable, formatUsd, formatPnl, withJsonErrors } from "../utils.js";
+const EXCHANGES = ["pacifica", "hyperliquid", "lighter"];
+async function fetchExchangeSnapshot(name, getAdapter) {
+    try {
+        const adapter = await getAdapter(name);
+        const [balance, positions, orders] = await Promise.all([
+            adapter.getBalance(),
+            adapter.getPositions(),
+            adapter.getOpenOrders(),
+        ]);
+        return {
+            exchange: name,
+            connected: true,
+            balance,
+            positions,
+            openOrders: orders.length,
+        };
+    }
+    catch (err) {
+        return {
+            exchange: name,
+            connected: false,
+            balance: null,
+            positions: [],
+            openOrders: 0,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function buildSummary(snapshots) {
+    let totalEquity = 0;
+    let totalAvailable = 0;
+    let totalMarginUsed = 0;
+    let totalUnrealizedPnl = 0;
+    let totalPositions = 0;
+    let totalOpenOrders = 0;
+    const allPositions = [];
+    for (const snap of snapshots) {
+        if (snap.balance) {
+            totalEquity += Number(snap.balance.equity);
+            totalAvailable += Number(snap.balance.available);
+            totalMarginUsed += Number(snap.balance.marginUsed);
+            totalUnrealizedPnl += Number(snap.balance.unrealizedPnl);
+        }
+        totalPositions += snap.positions.length;
+        totalOpenOrders += snap.openOrders;
+        for (const pos of snap.positions) {
+            allPositions.push({ ...pos, exchange: snap.exchange });
+        }
+    }
+    // Risk metrics
+    const marginUtilization = totalEquity > 0 ? (totalMarginUsed / totalEquity) * 100 : 0;
+    let largestPosition = null;
+    for (const pos of allPositions) {
+        const notional = Math.abs(Number(pos.size) * Number(pos.markPrice));
+        if (!largestPosition || notional > largestPosition.notional) {
+            largestPosition = { symbol: pos.symbol, exchange: pos.exchange, notional };
+        }
+    }
+    const exchangeConcentration = snapshots
+        .filter(s => s.balance && Number(s.balance.equity) > 0)
+        .map(s => ({
+        exchange: s.exchange,
+        pct: totalEquity > 0 ? (Number(s.balance.equity) / totalEquity) * 100 : 0,
+    }))
+        .sort((a, b) => b.pct - a.pct);
+    return {
+        totalEquity,
+        totalAvailable,
+        totalMarginUsed,
+        totalUnrealizedPnl,
+        totalPositions,
+        totalOpenOrders,
+        exchanges: snapshots,
+        positions: allPositions,
+        riskMetrics: {
+            marginUtilization,
+            largestPosition,
+            exchangeConcentration,
+        },
+    };
+}
+export function registerPortfolioCommands(program, getAdapterForExchange, isJson) {
+    program
+        .command("portfolio")
+        .description("Unified cross-exchange portfolio: balances, positions, risk")
+        .option("--exchange <exchanges>", "Comma-separated exchanges to include (default: all)")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const exchanges = opts.exchange
+                ? opts.exchange.split(",").map(e => e.trim())
+                : [...EXCHANGES];
+            const snapshots = await Promise.all(exchanges.map(ex => fetchExchangeSnapshot(ex, getAdapterForExchange)));
+            const summary = buildSummary(snapshots);
+            if (isJson()) {
+                return printJson(jsonOk(summary));
+            }
+            // ── Header ──
+            console.log(chalk.cyan.bold("\n  Cross-Exchange Portfolio\n"));
+            // ── Balance Summary ──
+            console.log(chalk.white.bold("  Balances"));
+            const balRows = snapshots.map(s => {
+                if (!s.connected) {
+                    return [chalk.white(s.exchange), chalk.red("disconnected"), "-", "-", "-", chalk.gray(s.error ?? "")];
+                }
+                const b = s.balance;
+                return [
+                    chalk.white.bold(s.exchange),
+                    `$${formatUsd(b.equity)}`,
+                    `$${formatUsd(b.available)}`,
+                    `$${formatUsd(b.marginUsed)}`,
+                    formatPnl(b.unrealizedPnl),
+                    chalk.green("connected"),
+                ];
+            });
+            // Totals row
+            balRows.push([
+                chalk.cyan.bold("TOTAL"),
+                chalk.cyan.bold(`$${formatUsd(summary.totalEquity)}`),
+                chalk.cyan.bold(`$${formatUsd(summary.totalAvailable)}`),
+                chalk.cyan.bold(`$${formatUsd(summary.totalMarginUsed)}`),
+                formatPnl(summary.totalUnrealizedPnl),
+                "",
+            ]);
+            console.log(makeTable(["Exchange", "Equity", "Available", "Margin Used", "uPnL", "Status"], balRows));
+            // ── Positions ──
+            if (summary.positions.length > 0) {
+                console.log(chalk.white.bold("\n  Open Positions"));
+                const posRows = summary.positions.map(p => {
+                    const sideColor = p.side === "long" ? chalk.green : chalk.red;
+                    const notional = Math.abs(Number(p.size) * Number(p.markPrice));
+                    return [
+                        chalk.white.bold(p.symbol),
+                        chalk.gray(p.exchange),
+                        sideColor(p.side.toUpperCase()),
+                        p.size,
+                        `$${formatUsd(p.entryPrice)}`,
+                        `$${formatUsd(p.markPrice)}`,
+                        formatPnl(p.unrealizedPnl),
+                        `$${formatUsd(notional)}`,
+                        `${p.leverage}x`,
+                    ];
+                });
+                console.log(makeTable(["Symbol", "Exchange", "Side", "Size", "Entry", "Mark", "uPnL", "Notional", "Lev"], posRows));
+            }
+            else {
+                console.log(chalk.gray("\n  No open positions.\n"));
+            }
+            // ── Risk Metrics ──
+            console.log(chalk.white.bold("\n  Risk Metrics"));
+            const mu = summary.riskMetrics.marginUtilization;
+            const muColor = mu < 30 ? chalk.green : mu < 60 ? chalk.yellow : chalk.red;
+            console.log(`  Margin Utilization: ${muColor(`${mu.toFixed(1)}%`)}`);
+            if (summary.riskMetrics.largestPosition) {
+                const lp = summary.riskMetrics.largestPosition;
+                console.log(`  Largest Position:   ${lp.symbol} on ${lp.exchange} ($${formatUsd(lp.notional)})`);
+            }
+            if (summary.riskMetrics.exchangeConcentration.length > 0) {
+                console.log(`  Exchange Allocation:`);
+                for (const ec of summary.riskMetrics.exchangeConcentration) {
+                    const bar = "\u2588".repeat(Math.round(ec.pct / 5)) + "\u2591".repeat(20 - Math.round(ec.pct / 5));
+                    console.log(`    ${ec.exchange.padEnd(12)} ${bar} ${ec.pct.toFixed(1)}%`);
+                }
+            }
+            console.log();
+        });
+    });
+}

package/dist/commands/rebalance.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerRebalanceCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;

package/dist/commands/rebalance.js

@@ -0,0 +1,293 @@
+import chalk from "chalk";
+import { formatUsd, makeTable, printJson, jsonOk } from "../utils.js";
+import { fetchAllBalances, computeRebalancePlan, describeBridgeRoute, estimateMoveTime, } from "../rebalance.js";
+import { EXCHANGE_TO_CHAIN, executeBestBridge } from "../bridge-engine.js";
+import { loadPrivateKey, parseSolanaKeypair } from "../config.js";
+export function registerRebalanceCommands(program, getAdapterForExchange, isJson) {
+    const rebalance = program.command("rebalance").description("Cross-exchange balance management");
+    // ── rebalance check ──
+    rebalance
+        .command("check")
+        .description("Show balances across all exchanges")
+        .option("--exchanges <list>", "Comma-separated exchanges", "pacifica,hyperliquid,lighter")
+        .action(async (opts) => {
+        const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
+        const adapters = new Map();
+        for (const name of exchangeNames) {
+            try {
+                adapters.set(name, await getAdapterForExchange(name));
+            }
+            catch {
+                // skip unavailable
+            }
+        }
+        if (adapters.size === 0) {
+            console.error(chalk.red("\n  No exchanges available. Check credentials.\n"));
+            return;
+        }
+        if (!isJson())
+            console.log(chalk.cyan("\n  Fetching balances across exchanges...\n"));
+        const snapshots = await fetchAllBalances(adapters);
+        if (isJson())
+            return printJson(jsonOk(snapshots));
+        const totalEquity = snapshots.reduce((s, e) => s + e.equity, 0);
+        const totalAvailable = snapshots.reduce((s, e) => s + e.available, 0);
+        const rows = snapshots.map((s) => {
+            const pct = totalEquity > 0 ? ((s.equity / totalEquity) * 100).toFixed(1) + "%" : "-";
+            return [
+                chalk.white.bold(s.exchange.padEnd(12)),
+                `$${formatUsd(s.equity)}`,
+                `$${formatUsd(s.available)}`,
+                `$${formatUsd(s.marginUsed)}`,
+                s.unrealizedPnl >= 0
+                    ? chalk.green(`+$${formatUsd(s.unrealizedPnl)}`)
+                    : chalk.red(`-$${formatUsd(Math.abs(s.unrealizedPnl))}`),
+                pct,
+            ];
+        });
+        console.log(makeTable(["Exchange", "Equity", "Available", "Margin", "uPnL", "Alloc%"], rows));
+        console.log(chalk.cyan.bold("  Totals"));
+        console.log(`  Total Equity:    $${formatUsd(totalEquity)}`);
+        console.log(`  Total Available: $${formatUsd(totalAvailable)}`);
+        console.log(`  Exchanges:       ${snapshots.length}\n`);
+    });
+    // ── rebalance plan ──
+    rebalance
+        .command("plan")
+        .description("Calculate optimal rebalancing moves")
+        .option("--exchanges <list>", "Comma-separated exchanges", "pacifica,hyperliquid,lighter")
+        .option("--min-move <usd>", "Minimum move amount ($)", "50")
+        .option("--reserve <usd>", "Keep at least this much per exchange ($)", "20")
+        .action(async (opts) => {
+        const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
+        const adapters = new Map();
+        for (const name of exchangeNames) {
+            try {
+                adapters.set(name, await getAdapterForExchange(name));
+            }
+            catch {
+                // skip unavailable
+            }
+        }
+        if (adapters.size < 2) {
+            console.error(chalk.red("\n  Need at least 2 exchanges for rebalancing.\n"));
+            return;
+        }
+        if (!isJson())
+            console.log(chalk.cyan("\n  Computing rebalance plan...\n"));
+        const snapshots = await fetchAllBalances(adapters);
+        const plan = computeRebalancePlan(snapshots, {
+            minMove: parseFloat(opts.minMove),
+            reserve: parseFloat(opts.reserve),
+        });
+        if (isJson())
+            return printJson(jsonOk(plan));
+        // Show current state
+        const rows = plan.snapshots.map((s) => {
+            const target = plan.targetPerExchange;
+            const diff = s.available - target;
+            const diffStr = diff >= 0
+                ? chalk.green(`+$${formatUsd(diff)}`)
+                : chalk.red(`-$${formatUsd(Math.abs(diff))}`);
+            return [
+                chalk.white.bold(s.exchange),
+                `$${formatUsd(s.available)}`,
+                `$${formatUsd(target)}`,
+                diffStr,
+            ];
+        });
+        console.log(makeTable(["Exchange", "Available", "Target", "Diff"], rows));
+        if (plan.moves.length === 0) {
+            console.log(chalk.green("  Balanced — no moves needed.\n"));
+            return;
+        }
+        console.log(chalk.cyan.bold("  Proposed Moves\n"));
+        for (let i = 0; i < plan.moves.length; i++) {
+            const m = plan.moves[i];
+            console.log(chalk.white.bold(`  Move ${i + 1}: $${m.amount} ${m.from} → ${m.to}`));
+            console.log(chalk.gray(`    Route: ${describeBridgeRoute(m)}`));
+            console.log(chalk.gray(`    Time:  ${estimateMoveTime(m)}`));
+            console.log();
+        }
+        console.log(chalk.yellow(`  To execute: perp rebalance execute --exchanges ${opts.exchanges}\n`));
+    });
+    // ── rebalance execute ──
+    rebalance
+        .command("execute")
+        .description("Execute rebalancing (withdraw → bridge → deposit)")
+        .option("--exchanges <list>", "Comma-separated exchanges", "pacifica,hyperliquid,lighter")
+        .option("--min-move <usd>", "Minimum move amount ($)", "50")
+        .option("--reserve <usd>", "Keep at least this much per exchange ($)", "20")
+        .option("--dry-run", "Show what would happen without executing")
+        .option("--withdraw-only", "Only execute withdrawals (manual bridge + deposit)")
+        .option("--auto-bridge", "Auto-bridge via deBridge DLN (withdraw → bridge in one step)")
+        .action(async (opts) => {
+        const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
+        const adapters = new Map();
+        for (const name of exchangeNames) {
+            try {
+                adapters.set(name, await getAdapterForExchange(name));
+            }
+            catch {
+                // skip
+            }
+        }
+        if (adapters.size < 2) {
+            console.error(chalk.red("\n  Need at least 2 exchanges.\n"));
+            return;
+        }
+        const snapshots = await fetchAllBalances(adapters);
+        const plan = computeRebalancePlan(snapshots, {
+            minMove: parseFloat(opts.minMove),
+            reserve: parseFloat(opts.reserve),
+        });
+        if (plan.moves.length === 0) {
+            if (isJson())
+                return printJson(jsonOk({ status: "balanced", moves: [] }));
+            console.log(chalk.green("\n  Already balanced — nothing to do.\n"));
+            return;
+        }
+        if (!isJson())
+            console.log(chalk.cyan.bold("\n  Executing Rebalance\n"));
+        const moveResults = [];
+        for (const move of plan.moves) {
+            if (!isJson())
+                console.log(chalk.white.bold(`  $${move.amount} ${move.from} → ${move.to}`));
+            if (opts.dryRun) {
+                if (!isJson())
+                    console.log(chalk.yellow("    [DRY RUN] Skipped.\n"));
+                moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "dry_run" });
+                continue;
+            }
+            // Step 1: Withdraw from source exchange
+            try {
+                if (!isJson())
+                    console.log(chalk.gray(`    Step 1: Withdrawing $${move.amount} from ${move.from}...`));
+                await executeWithdraw(move, adapters);
+                if (!isJson())
+                    console.log(chalk.green(`    Withdrawal submitted.`));
+            }
+            catch (err) {
+                console.error(chalk.red(`    Withdraw failed: ${err instanceof Error ? err.message : err}`));
+                if (!isJson())
+                    console.log(chalk.yellow(`    Skipping this move.\n`));
+                moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "withdraw_failed", error: err instanceof Error ? err.message : String(err) });
+                continue;
+            }
+            if (opts.withdrawOnly) {
+                if (!isJson()) {
+                    console.log(chalk.yellow(`    [WITHDRAW-ONLY] Bridge and deposit manually.`));
+                    console.log(chalk.gray(`    Route: ${describeBridgeRoute(move)}\n`));
+                }
+                moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "withdrawn" });
+                continue;
+            }
+            // Step 2: Bridge
+            const srcChain = EXCHANGE_TO_CHAIN[move.from];
+            const dstChain = EXCHANGE_TO_CHAIN[move.to];
+            if (!srcChain || !dstChain || srcChain === dstChain) {
+                if (!isJson())
+                    console.log(chalk.green(`    Same chain — no bridge needed.\n`));
+                moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "same_chain" });
+                continue;
+            }
+            if (opts.autoBridge) {
+                try {
+                    if (!isJson())
+                        console.log(chalk.gray(`    Step 2: Bridging $${move.amount} (${srcChain} → ${dstChain})...`));
+                    // Load keys for bridge
+                    const { senderAddress, recipientAddress, signerKey, dstSignerKey } = await loadBridgeKeys(move.from, move.to, srcChain, dstChain);
+                    const result = await executeBestBridge(srcChain, dstChain, move.amount, signerKey, senderAddress, recipientAddress, dstSignerKey);
+                    if (!isJson()) {
+                        console.log(chalk.green(`    Bridge submitted! TX: ${result.txHash}`));
+                        console.log(chalk.gray(`    Provider: ${result.provider} | ~$${result.amountOut} arriving on ${dstChain}\n`));
+                    }
+                    moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "bridged", txHash: result.txHash });
+                }
+                catch (err) {
+                    console.error(chalk.red(`    Bridge failed: ${err instanceof Error ? err.message : err}`));
+                    if (!isJson())
+                        console.log(chalk.yellow(`    Manual fallback: perp bridge exchange --from ${move.from} --to ${move.to} --amount ${move.amount}\n`));
+                    moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "bridge_failed", error: err instanceof Error ? err.message : String(err) });
+                }
+            }
+            else {
+                if (!isJson()) {
+                    console.log(chalk.gray(`    Step 2: Bridge needed.`));
+                    console.log(chalk.gray(`    Run: perp bridge exchange --from ${move.from} --to ${move.to} --amount ${move.amount}`));
+                    console.log();
+                }
+                moveResults.push({ from: move.from, to: move.to, amount: move.amount, status: "needs_bridge" });
+            }
+        }
+        if (isJson())
+            return printJson(jsonOk({ status: "executed", moves: moveResults }));
+        console.log(chalk.cyan("  Rebalance initiated. Monitor progress with 'perp rebalance check'.\n"));
+    });
+}
+/**
+ * Execute a withdrawal from a source exchange.
+ */
+async function executeWithdraw(move, adapters) {
+    const adapter = adapters.get(move.from);
+    if (!adapter)
+        throw new Error(`No adapter for ${move.from}`);
+    switch (move.from) {
+        case "pacifica": {
+            const { PacificaAdapter } = await import("../exchanges/pacifica.js");
+            if (!(adapter instanceof PacificaAdapter))
+                throw new Error("Invalid adapter");
+            await adapter.sdk.withdraw({ amount: String(move.amount), dest_address: adapter.publicKey }, adapter.publicKey, adapter.signer);
+            break;
+        }
+        case "hyperliquid": {
+            const { HyperliquidAdapter } = await import("../exchanges/hyperliquid.js");
+            if (!(adapter instanceof HyperliquidAdapter))
+                throw new Error("Invalid adapter");
+            await adapter.withdraw(String(move.amount), adapter.address);
+            break;
+        }
+        case "lighter": {
+            const { LighterAdapter } = await import("../exchanges/lighter.js");
+            if (!(adapter instanceof LighterAdapter))
+                throw new Error("Invalid adapter");
+            await adapter.withdraw(move.amount);
+            break;
+        }
+        default:
+            throw new Error(`Withdraw not supported for ${move.from}`);
+    }
+}
+/**
+ * Load sender/recipient addresses and signer key for a bridge move.
+ */
+async function loadBridgeKeys(srcExchange, dstExchange, srcChain, dstChain) {
+    let senderAddress;
+    let recipientAddress;
+    let signerKey;
+    let dstSignerKey;
+    // Source
+    if (srcChain === "solana") {
+        const pk = await loadPrivateKey("pacifica");
+        senderAddress = parseSolanaKeypair(pk).publicKey.toBase58();
+        signerKey = pk;
+    }
+    else {
+        const pk = await loadPrivateKey(srcExchange);
+        const { ethers } = await import("ethers");
+        senderAddress = new ethers.Wallet(pk).address;
+        signerKey = pk;
+    }
+    // Destination
+    if (dstChain === "solana") {
+        const pk = await loadPrivateKey("pacifica");
+        recipientAddress = parseSolanaKeypair(pk).publicKey.toBase58();
+    }
+    else {
+        const pk = await loadPrivateKey(dstExchange);
+        const { ethers } = await import("ethers");
+        recipientAddress = new ethers.Wallet(pk).address;
+        dstSignerKey = pk; // For auto receiveMessage
+    }
+    return { senderAddress, recipientAddress, signerKey, dstSignerKey };
+}

package/dist/commands/risk.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerRiskCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;

package/dist/commands/risk.js

@@ -0,0 +1,169 @@
+import chalk from "chalk";
+import { printJson, jsonOk, makeTable, formatUsd, withJsonErrors } from "../utils.js";
+import { loadRiskLimits, saveRiskLimits, assessRisk } from "../risk.js";
+const EXCHANGES = ["pacifica", "hyperliquid", "lighter"];
+export function registerRiskCommands(program, getAdapterForExchange, isJson) {
+    const risk = program.command("risk").description("Risk management and guardrails");
+    // ── risk status ──
+    risk
+        .command("status")
+        .description("Assess current risk across all exchanges")
+        .option("--exchange <exchanges>", "Comma-separated exchanges (default: all)")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const exchanges = opts.exchange
+                ? opts.exchange.split(",").map(e => e.trim())
+                : [...EXCHANGES];
+            const balances = [];
+            const positions = [];
+            const results = await Promise.allSettled(exchanges.map(async (ex) => {
+                const adapter = await getAdapterForExchange(ex);
+                const [bal, pos] = await Promise.all([
+                    adapter.getBalance(),
+                    adapter.getPositions(),
+                ]);
+                balances.push({ exchange: ex, balance: bal });
+                for (const p of pos)
+                    positions.push({ exchange: ex, position: p });
+            }));
+            // Log failed exchanges
+            for (let i = 0; i < results.length; i++) {
+                if (results[i].status === "rejected") {
+                    const err = results[i].reason;
+                    if (!isJson()) {
+                        console.log(chalk.yellow(`  ${exchanges[i]}: ${err instanceof Error ? err.message : String(err)}`));
+                    }
+                }
+            }
+            const assessment = assessRisk(balances, positions);
+            if (isJson()) {
+                return printJson(jsonOk(assessment));
+            }
+            // Display
+            const levelColor = {
+                low: chalk.green,
+                medium: chalk.yellow,
+                high: chalk.red,
+                critical: chalk.bgRed.white,
+            }[assessment.level];
+            console.log(chalk.cyan.bold("\n  Risk Assessment\n"));
+            console.log(`  Overall Risk:         ${levelColor(assessment.level.toUpperCase())}`);
+            console.log(`  Can Trade:            ${assessment.canTrade ? chalk.green("YES") : chalk.red("NO")}`);
+            console.log(`  Total Equity:         $${formatUsd(assessment.metrics.totalEquity)}`);
+            console.log(`  Unrealized PnL:       ${(assessment.metrics.totalUnrealizedPnl >= 0 ? chalk.green : chalk.red)(`$${formatUsd(Math.abs(assessment.metrics.totalUnrealizedPnl))}`)}`);
+            console.log(`  Total Exposure:       $${formatUsd(assessment.metrics.totalExposure)}`);
+            console.log(`  Margin Utilization:   ${assessment.metrics.marginUtilization.toFixed(1)}%`);
+            console.log(`  Positions:            ${assessment.metrics.positionCount}`);
+            console.log(`  Largest Position:     $${formatUsd(assessment.metrics.largestPositionUsd)}`);
+            console.log(`  Max Leverage Used:    ${assessment.metrics.maxLeverageUsed}x`);
+            if (assessment.violations.length > 0) {
+                console.log(chalk.red.bold("\n  Violations"));
+                const vRows = assessment.violations.map(v => {
+                    const sevColor = {
+                        low: chalk.green,
+                        medium: chalk.yellow,
+                        high: chalk.red,
+                        critical: chalk.bgRed.white,
+                    }[v.severity];
+                    return [
+                        sevColor(v.severity.toUpperCase()),
+                        v.rule,
+                        v.message,
+                    ];
+                });
+                console.log(makeTable(["Severity", "Rule", "Details"], vRows));
+            }
+            else {
+                console.log(chalk.green("\n  No risk violations. All clear.\n"));
+            }
+        });
+    });
+    // ── risk limits ──
+    risk
+        .command("limits")
+        .description("View or set risk limits")
+        .option("--max-drawdown <usd>", "Max unrealized loss before closing all")
+        .option("--max-position <usd>", "Max single position notional")
+        .option("--max-exposure <usd>", "Max total exposure across all positions")
+        .option("--daily-loss <usd>", "Daily realized loss limit")
+        .option("--max-positions <n>", "Max number of simultaneous positions")
+        .option("--max-leverage <n>", "Max leverage per position")
+        .option("--max-margin <pct>", "Max margin utilization %")
+        .option("--reset", "Reset all limits to defaults")
+        .action(async (opts) => {
+        let limits = loadRiskLimits();
+        const hasUpdate = opts.maxDrawdown || opts.maxPosition || opts.maxExposure ||
+            opts.dailyLoss || opts.maxPositions || opts.maxLeverage || opts.maxMargin || opts.reset;
+        if (opts.reset) {
+            limits = {
+                maxDrawdownUsd: 500, maxPositionUsd: 5000, maxTotalExposureUsd: 20000,
+                dailyLossLimitUsd: 200, maxPositions: 10, maxLeverage: 20, maxMarginUtilization: 80,
+            };
+        }
+        if (opts.maxDrawdown)
+            limits.maxDrawdownUsd = parseFloat(opts.maxDrawdown);
+        if (opts.maxPosition)
+            limits.maxPositionUsd = parseFloat(opts.maxPosition);
+        if (opts.maxExposure)
+            limits.maxTotalExposureUsd = parseFloat(opts.maxExposure);
+        if (opts.dailyLoss)
+            limits.dailyLossLimitUsd = parseFloat(opts.dailyLoss);
+        if (opts.maxPositions)
+            limits.maxPositions = parseInt(opts.maxPositions);
+        if (opts.maxLeverage)
+            limits.maxLeverage = parseInt(opts.maxLeverage);
+        if (opts.maxMargin)
+            limits.maxMarginUtilization = parseFloat(opts.maxMargin);
+        if (hasUpdate)
+            saveRiskLimits(limits);
+        if (isJson())
+            return printJson(jsonOk(limits));
+        console.log(chalk.cyan.bold(`\n  Risk Limits ${hasUpdate ? "(updated)" : ""}\n`));
+        console.log(`  Max Drawdown:          $${formatUsd(limits.maxDrawdownUsd)}`);
+        console.log(`  Max Position Size:     $${formatUsd(limits.maxPositionUsd)}`);
+        console.log(`  Max Total Exposure:    $${formatUsd(limits.maxTotalExposureUsd)}`);
+        console.log(`  Daily Loss Limit:      $${formatUsd(limits.dailyLossLimitUsd)}`);
+        console.log(`  Max Positions:         ${limits.maxPositions}`);
+        console.log(`  Max Leverage:          ${limits.maxLeverage}x`);
+        console.log(`  Max Margin Util:       ${limits.maxMarginUtilization}%\n`);
+        console.log(chalk.gray(`  Config file: ~/.perp/risk.json\n`));
+    });
+    // ── risk check ── (pre-trade check, for agent use)
+    risk
+        .command("check")
+        .description("Pre-trade risk check (for agents)")
+        .requiredOption("--notional <usd>", "Order notional value in USD")
+        .requiredOption("--leverage <n>", "Order leverage")
+        .option("--exchange <exchanges>", "Comma-separated exchanges (default: all)")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const exchanges = opts.exchange
+                ? opts.exchange.split(",").map(e => e.trim())
+                : [...EXCHANGES];
+            const balances = [];
+            const positions = [];
+            await Promise.allSettled(exchanges.map(async (ex) => {
+                const adapter = await getAdapterForExchange(ex);
+                const [bal, pos] = await Promise.all([
+                    adapter.getBalance(),
+                    adapter.getPositions(),
+                ]);
+                balances.push({ exchange: ex, balance: bal });
+                for (const p of pos)
+                    positions.push({ exchange: ex, position: p });
+            }));
+            const { preTradeCheck, assessRisk: ar } = await import("../risk.js");
+            const assessment = ar(balances, positions);
+            const result = preTradeCheck(assessment, parseFloat(opts.notional), parseFloat(opts.leverage));
+            if (isJson()) {
+                return printJson(jsonOk({ ...result, riskLevel: assessment.level }));
+            }
+            if (result.allowed) {
+                console.log(chalk.green(`\n  Trade ALLOWED (risk: ${assessment.level})\n`));
+            }
+            else {
+                console.log(chalk.red(`\n  Trade BLOCKED: ${result.reason}\n`));
+            }
+        });
+    });
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerRunCommands(program: Command, getAdapter: () => Promise<ExchangeAdapter>, getAdapterFor: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;