perp-cli 0.14.2 → 0.15.0

package/dist/commands/portfolio.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { makeTable, formatUsd, formatPnl, printJson, jsonOk, jsonError, withJsonErrors } from "../utils.js";
 import { isDexCapable } from "../exchanges/capabilities.js";
-import { getVenue, listVenuesWithRole, tryResolveVenueId } from "../exchanges/venue.js";
+import { getVenue, listVenuesWithRole, roleUnsupported, tryResolveVenueId } from "../exchanges/venue.js";
 import { PerpError } from "../errors.js";
 import "../exchanges/venues/index.js";
 import { listConfiguredAccountVenues } from "../config.js";
@@ -9,6 +9,7 @@ import { HYPERLIQUID_API_URL } from "../api/public/urls.js";
 import { fetchValuedSpotBalances, getSpotAdapter, spotSharesPerpMargin, withSpotTimeout } from "../exchanges/spot-factory.js";
 import { scrubSecretEnv } from "../secret-env.js";
 import { networkOf } from "../cli-flags.js";
+import { probeVenueHealth } from "../venue-health.js";
 // ── Types ──────────────────────────────────────────────────────────────────
 /** Venues with an account API (market-data-only venues are excluded). */
 function accountVenueIds() {
@@ -51,6 +52,12 @@ function validateExchanges(list) {
     const valid = accountVenueIds();
     // Aliases (hl, pac, lt, lrh, ast, …) resolve through the venue registry, like every other command.
     const ids = list.map(s => tryResolveVenueId(s) ?? s.toLowerCase());
+    // A registered market-data-only venue (TxFlow) is a capability refusal, not an unknown name.
+    for (const id of ids) {
+        const known = tryResolveVenueId(id);
+        if (known !== null && !valid.includes(known))
+            throw roleUnsupported(getVenue(known), "account");
+    }
     const unknown = ids.filter(e => !valid.includes(e));
     if (unknown.length > 0) {
         throw new PerpError("INVALID_PARAMS", `Unknown exchange: ${unknown.join(", ")}`, { remediation: `Use one of: ${valid.join(", ")} (or an alias such as hl, pac, lt, lrh, ast)` });
@@ -178,7 +185,7 @@ async function fetchExchangeEntry(exName, getAdapter) {
             adapter.getOpenOrders(),
             adapter.getFundingPayments(200).then((rows) => ({ rows, error: null }), (e) => ({ rows: null, error: e instanceof Error ? e.message : String(e) })),
         ]);
-        // Spot balances for every venue with def.spot (§12). Failures are surfaced on
+        // Spot balances for every venue with def.spot. Failures are surfaced on
         // stderr (the perp snapshot is still reported); unpriced tokens are excluded + warned.
         let spot = [];
         let isUnified = false;
@@ -205,7 +212,7 @@ async function fetchExchangeEntry(exName, getAdapter) {
         const funding24h = fundingPayments.rows === null
             ? null
             : fundingPayments.rows.filter(f => f.time >= cutoff24h).reduce((sum, f) => sum + Number(f.payment), 0);
-        // Shared balances (Pacifica USDC, HL unified USDC) are already in perp equity (§12.4 #8).
+        // Shared balances (Pacifica USDC, HL unified USDC) are already in perp equity.
         const nonUsdcSpotValue = spot.filter(b => !b.shared).reduce((s, b) => s + b.valueUsd, 0);
         return {
             name: exName,
@@ -288,42 +295,12 @@ function buildTotals(entries) {
 }
 // ── Health check (no balance fetches) ──────────────────────────────────────
 async function runHealth(exchangeList, network) {
-    const { pingPacifica, pingHyperliquid, pingLighter } = await import("../shared-api.js");
-    const pingAster = async () => {
-        const start = Date.now();
-        try {
-            const res = await fetch("https://fapi.asterdex.com/fapi/v1/time");
-            return { ok: res.ok, latencyMs: Date.now() - start, status: res.status };
-        }
-        catch {
-            return { ok: false, latencyMs: Date.now() - start, status: 0 };
-        }
-    };
-    const pingMap = {
-        pacifica: pingPacifica,
-        hyperliquid: pingHyperliquid,
-        lighter: pingLighter,
-        aster: pingAster,
-    };
+    // The same probe as `perp health` and the MCP health_check, over the selected venues.
+    const h = await probeVenueHealth(network, exchangeList);
     const exchanges = {};
-    await Promise.all(exchangeList.map(async (ex) => {
-        const fn = pingMap[ex];
-        try {
-            if (!fn) {
-                // No dedicated ping helper: probe the venue's public market-data path.
-                await getVenue(ex).publicData.fetchMarkets(network);
-                exchanges[ex] = "ok";
-                return;
-            }
-            const r = await fn();
-            exchanges[ex] = r.ok ? "ok" : "error";
-        }
-        catch {
-            exchanges[ex] = "error";
-        }
-    }));
-    const anyDown = Object.values(exchanges).some(v => v === "error");
-    return { exchanges, anyDown };
+    for (const p of h.probes)
+        exchanges[p.venue] = p.ok ? "ok" : "error";
+    return { exchanges, anyDown: !h.allHealthy, probes: h.probes, skipped: h.skipped };
 }
 // ── Arb top-5 ──────────────────────────────────────────────────────────────
 async function fetchArbTop() {
@@ -514,11 +491,15 @@ function renderSnapshotText(data) {
 }
 function renderHealthText(h) {
     console.log(chalk.cyan.bold("\n  Exchange Health Check\n"));
-    const rows = Object.entries(h.exchanges).map(([ex, status]) => {
-        const statusIcon = status === "ok" ? chalk.green("OK") : chalk.red("DOWN");
-        return [chalk.white.bold(ex), statusIcon];
-    });
-    console.log(makeTable(["Exchange", "Status"], rows));
+    const rows = h.probes.map((p) => [
+        chalk.white.bold(p.venue),
+        p.ok ? chalk.green("OK") : chalk.red("DOWN"),
+        `${p.latencyMs}ms`,
+        p.error !== null ? chalk.red(p.error) : chalk.gray("-"),
+    ]);
+    console.log(makeTable(["Exchange", "Status", "Latency", "Error"], rows));
+    for (const s of h.skipped)
+        console.log(chalk.gray(`  ${s.venue}: not probed — ${s.reason}`));
     const overall = h.anyDown ? chalk.red("ISSUES DETECTED") : chalk.green("ALL HEALTHY");
     console.log(`\n  Overall: ${overall}\n`);
 }
@@ -773,7 +754,11 @@ export function registerPortfolioCommand(program, getAdapterForExchange, isJson,
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (json) {
-                console.log(JSON.stringify(jsonError("INVALID_PARAMS", msg)));
+                // A typed refusal (CAPABILITY_UNSUPPORTED for a market-data-only venue) keeps its code.
+                const s = err instanceof PerpError ? err.structured : null;
+                console.log(JSON.stringify(s !== null
+                    ? jsonError(s.code, msg, { ...(s.details !== undefined ? { details: s.details } : {}), ...(s.remediation !== undefined ? { remediation: s.remediation } : {}) })
+                    : jsonError("INVALID_PARAMS", msg)));
             }
             else {
                 console.error(chalk.red(`Error: ${msg}`));
@@ -794,9 +779,9 @@ export function registerPortfolioCommand(program, getAdapterForExchange, isJson,
                     version,
                     scope: resolved.scope,
                     mode: "health",
-                    exchanges: [],
-                    totals: { equity: 0, spotValueUsd: 0, accountValueUsd: 0, marginUsed: 0, marginPct: 0, funding24h: 0, fundingIncomplete: false },
-                    risk: { level: "LOW", marginPct: 0 },
+                    exchanges: null,
+                    totals: null,
+                    risk: null,
                     health,
                 };
                 if (json)

package/dist/commands/rebalance.d.ts

@@ -1,4 +1,5 @@
 import { Command } from "commander";
 import type { ExchangeAdapter } from "../exchanges/index.js";
 import type { Network } from "../exchanges/venue-types.js";
+import "../exchanges/venues/index.js";
 export declare function registerFundsRebalanceCommands(parent: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean, getNetwork: () => Network): void;

package/dist/commands/rebalance.js

@@ -5,6 +5,10 @@ import { PerpError } from "../errors.js";
 import { fetchBalancesWithFailures, computeRebalancePlan, describeBridgeRoute, estimateMoveTime, } from "../rebalance.js";
 import { EXCHANGE_TO_CHAIN, assertBridgeNetwork, executeBestBridge } from "../bridge-engine.js";
 import { cliCredentialOptsFrom } from "../config.js";
+import { getVenue, roleUnsupported, tryResolveVenueId } from "../exchanges/venue.js";
+import { unsupported } from "../exchanges/trading-v2.js";
+import { RISEX_FUNDS_APP_ONLY } from "../exchanges/venues/risex.js";
+import "../exchanges/venues/index.js";
 export function registerFundsRebalanceCommands(parent, getAdapterForExchange, isJson, getNetwork) {
     const rebalance = parent.command("rebalance").description("Cross-exchange balance management");
     // ── rebalance check ──
@@ -149,6 +153,17 @@ export function registerFundsRebalanceCommands(parent, getAdapterForExchange, is
         if (opts.autoBridge && !dryRun)
             assertBridgeNetwork(getNetwork());
         const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
+        // Venues whose funds perp-cli cannot move are refused before any read (no partial plan).
+        for (const name of exchangeNames) {
+            const id = tryResolveVenueId(name);
+            if (id === null)
+                continue;
+            const def = getVenue(id);
+            if (!def.roles.includes("account"))
+                throw roleUnsupported(def, "rebalance");
+            if (id === "risex")
+                throw unsupported("risex", "rebalance", RISEX_FUNDS_APP_ONLY.reason, RISEX_FUNDS_APP_ONLY.remediation);
+        }
         const adapters = new Map();
         const unavailable = [];
         for (const name of exchangeNames) {

package/dist/commands/risk.d.ts

@@ -1,5 +1,14 @@
 import { Command } from "commander";
 import type { ExchangeAdapter } from "../exchanges/index.js";
-/** Run health check and return results + render. Exported for use by status --health. */
-export declare function runHealthCheck(isJson: () => boolean): Promise<void>;
+import type { Network } from "../exchanges/venue-types.js";
+/**
+ * `perp health`: probe EVERY registered venue on the selected network — the same probe as
+ * `perp portfolio --health` and the MCP health_check (src/venue-health.ts). A venue with no
+ * environment on that network is listed under `skipped`, never silently dropped.
+ *
+ * JSON: `exchanges` = official-API venues, `unofficial` = venues read through an undocumented API
+ * (TxFlow), each entry with `error` (null when ok). `healthy` = every OFFICIAL venue is up — an
+ * unofficial API being down does not make the CLI unhealthy; `allHealthy` includes them.
+ */
+export declare function runHealthCheck(isJson: () => boolean, network: Network): Promise<void>;
 export declare function registerRiskCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;

package/dist/commands/risk.js

@@ -2,61 +2,55 @@ import { listConfiguredAccountVenues } from "../config.js";
 import chalk from "chalk";
 import { printJson, jsonOk, makeTable, formatUsd, withJsonErrors } from "../utils.js";
 import { loadRiskLimits, saveRiskLimits, assessRisk, getLiquidationDistances } from "../risk.js";
-import { pingPacifica, pingHyperliquid, pingLighter } from "../shared-api.js";
-/** Run health check and return results + render. Exported for use by status --health. */
-export async function runHealthCheck(isJson) {
-    const pingAster = async () => {
-        const start = Date.now();
-        try {
-            const res = await fetch("https://fapi.asterdex.com/fapi/v1/time");
-            return { ok: res.ok, latencyMs: Date.now() - start, status: res.status };
-        }
-        catch {
-            return { ok: false, latencyMs: Date.now() - start, status: 0 };
-        }
-    };
-    const [pacPing, hlPing, ltPing, astPing] = await Promise.all([
-        pingPacifica(),
-        pingHyperliquid(),
-        pingLighter(),
-        pingAster(),
-    ]);
-    const toPingResult = (name, p) => ({
-        exchange: name,
+import { probeVenueHealth } from "../venue-health.js";
+import { networkOf } from "../cli-flags.js";
+/**
+ * `perp health`: probe EVERY registered venue on the selected network — the same probe as
+ * `perp portfolio --health` and the MCP health_check (src/venue-health.ts). A venue with no
+ * environment on that network is listed under `skipped`, never silently dropped.
+ *
+ * JSON: `exchanges` = official-API venues, `unofficial` = venues read through an undocumented API
+ * (TxFlow), each entry with `error` (null when ok). `healthy` = every OFFICIAL venue is up — an
+ * unofficial API being down does not make the CLI unhealthy; `allHealthy` includes them.
+ */
+export async function runHealthCheck(isJson, network) {
+    const health = await probeVenueHealth(network);
+    const checks = health.probes.map(p => ({
+        exchange: p.venue,
         status: p.ok ? "ok" : "down",
         latency_ms: p.latencyMs,
-        error: p.ok ? undefined : `HTTP ${p.status}`,
-    });
-    const checks = [
-        toPingResult("pacifica", pacPing),
-        toPingResult("hyperliquid", hlPing),
-        toPingResult("lighter", ltPing),
-        toPingResult("aster", astPing),
-    ];
-    const allOk = checks.every(c => c.status === "ok");
+        error: p.error,
+        probe: p.probe,
+        apiStatus: p.apiStatus,
+    }));
+    const official = checks.filter(c => c.apiStatus === "official");
+    const unofficial = checks.filter(c => c.apiStatus === "unofficial");
+    const allOk = official.every(c => c.status === "ok");
     if (isJson()) {
-        return printJson(jsonOk({ healthy: allOk, exchanges: checks }));
+        return printJson(jsonOk({ healthy: allOk, allHealthy: health.allHealthy, network, exchanges: official, unofficial, skipped: health.skipped }));
     }
-    console.log(chalk.cyan.bold("\n  Exchange Health Check\n"));
+    console.log(chalk.cyan.bold(`\n  Exchange Health Check (${network})\n`));
     const rows = checks.map(c => {
-        const statusIcon = c.status === "ok"
-            ? chalk.green("OK")
-            : c.status === "degraded"
-                ? chalk.yellow("DEGRADED")
-                : chalk.red("DOWN");
+        const statusIcon = c.status === "ok" ? chalk.green("OK") : chalk.red("DOWN");
         const latency = c.latency_ms < 500
             ? chalk.green(`${c.latency_ms}ms`)
             : c.latency_ms < 2000
                 ? chalk.yellow(`${c.latency_ms}ms`)
                 : chalk.red(`${c.latency_ms}ms`);
         return [
-            chalk.white.bold(c.exchange),
+            chalk.white.bold(c.exchange) + (c.apiStatus === "unofficial" ? chalk.yellow(" *") : ""),
             statusIcon,
             latency,
-            c.error ? chalk.red(c.error) : chalk.gray("-"),
+            c.probe,
+            c.error !== null ? chalk.red(c.error) : chalk.gray("-"),
         ];
     });
-    console.log(makeTable(["Exchange", "Status", "Latency", "Error"], rows));
+    console.log(makeTable(["Exchange", "Status", "Latency", "Probe", "Error"], rows));
+    if (unofficial.length > 0) {
+        console.log(chalk.yellow("  * unofficial (undocumented) venue API — may change without notice; not counted in Overall"));
+    }
+    for (const s of health.skipped)
+        console.log(chalk.gray(`  ${s.venue}: not probed — ${s.reason}`));
     const overall = allOk ? chalk.green("ALL HEALTHY") : chalk.red("ISSUES DETECTED");
     console.log(`\n  Overall: ${overall}\n`);
 }
@@ -122,11 +116,12 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
             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.metrics.minLiquidationDistancePct >= 0) {
-                const ldColor = assessment.metrics.minLiquidationDistancePct < assessment.limits.minLiquidationDistance
+            const minLiq = assessment.metrics.minLiquidationDistancePct;
+            if (minLiq !== null) {
+                const ldColor = minLiq < assessment.limits.minLiquidationDistance
                     ? chalk.red
                     : chalk.green;
-                console.log(`  Min Liq Distance:     ${ldColor(`${assessment.metrics.minLiquidationDistancePct.toFixed(1)}%`)}`);
+                console.log(`  Min Liq Distance:     ${ldColor(`${minLiq.toFixed(1)}%`)}`);
             }
             for (const { exchange, position: p } of positions.filter(x => x.position.liquidationPrice === null)) {
                 console.log(`  Liq Price ${exchange}:${p.symbol}: ${chalk.yellow("unknown (venue does not report)")} — not in Min Liq Distance`);
@@ -367,6 +362,6 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
         .command("health")
         .description("Adapter health check: ping venue REST endpoints (connectivity + latency)")
         .action(async () => {
-        await runHealthCheck(isJson);
+        await runHealthCheck(isJson, networkOf(program));
     });
 }

package/dist/commands/trade.d.ts

@@ -3,6 +3,7 @@ import type { ExchangeAdapter } from "../exchanges/index.js";
 import { PerpError } from "../errors.js";
 import "../exchanges/venues/index.js";
 import { type CancelResult } from "../exchanges/venue-types.js";
+export declare function parseSlippageBpsFlag(raw: string | undefined): number | null;
 /**
  * A cancel with anything not proven cancelled (failed, or pending / still listed open after the
  * verifying re-list) → ORDER_PARTIAL carrying the whole result (non-zero exit, also in --json);