perp-cli 0.4.8 → 0.4.10

package/dist/commands/risk.js

@@ -1,6 +1,52 @@
 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 [pacPing, hlPing, ltPing] = await Promise.all([
+        pingPacifica(),
+        pingHyperliquid(),
+        pingLighter(),
+    ]);
+    const toPingResult = (name, p) => ({
+        exchange: name,
+        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),
+    ];
+    const allOk = checks.every(c => c.status === "ok");
+    if (isJson()) {
+        return printJson(jsonOk({ healthy: allOk, exchanges: checks }));
+    }
+    console.log(chalk.cyan.bold("\n  Exchange Health Check\n"));
+    const rows = checks.map(c => {
+        const statusIcon = c.status === "ok"
+            ? chalk.green("OK")
+            : c.status === "degraded"
+                ? chalk.yellow("DEGRADED")
+                : 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),
+            statusIcon,
+            latency,
+            c.error ? chalk.red(c.error) : chalk.gray("-"),
+        ];
+    });
+    console.log(makeTable(["Exchange", "Status", "Latency", "Error"], rows));
+    const overall = allOk ? chalk.green("ALL HEALTHY") : chalk.red("ISSUES DETECTED");
+    console.log(`\n  Overall: ${overall}\n`);
+}
 const EXCHANGES = ["pacifica", "hyperliquid", "lighter"];
 export function registerRiskCommands(program, getAdapterForExchange, isJson) {
     const risk = program.command("risk").description("Risk management and guardrails");
@@ -278,4 +324,14 @@ export function registerRiskCommands(program, getAdapterForExchange, isJson) {
             }
         });
     });
+    // ── deprecated: health (merged into risk) ──
+    const healthCmd = program
+        .command("health")
+        .description("Use 'perp status --health'")
+        .action(async () => {
+        if (!isJson())
+            console.log(chalk.yellow("  Use 'perp status --health' instead.\n"));
+        await runHealthCheck(isJson);
+    });
+    healthCmd._hidden = true;
 }

package/dist/commands/settings.js

@@ -1,6 +1,26 @@
 import chalk from "chalk";
 import { printJson, jsonOk, withJsonErrors } from "../utils.js";
 import { loadSettings, saveSettings } from "../settings.js";
+import { ENV_FILE, loadEnvFile, setEnvVar, EXCHANGE_ENV_MAP, validateKey } from "./init.js";
+// Resolve exchange alias → env var key
+function resolveEnvKey(nameOrKey) {
+    // Direct env var name
+    const upper = nameOrKey.toUpperCase();
+    for (const info of Object.values(EXCHANGE_ENV_MAP)) {
+        if (info.envKey === upper)
+            return { envKey: info.envKey, chain: info.chain };
+    }
+    // Exchange name alias
+    const info = EXCHANGE_ENV_MAP[nameOrKey.toLowerCase()];
+    if (info)
+        return { envKey: info.envKey, chain: info.chain };
+    // Common aliases
+    const aliases = { hl: "hyperliquid", pac: "pacifica", lt: "lighter" };
+    const aliased = aliases[nameOrKey.toLowerCase()];
+    if (aliased)
+        return resolveEnvKey(aliased);
+    return null;
+}
 export function registerSettingsCommands(program, isJson, getAdapterForExchange) {
     const settings = program.command("settings").description("CLI settings (referrals, defaults, fees)");
     // ── settings show ──
@@ -230,4 +250,131 @@ export function registerSettingsCommands(program, isJson, getAdapterForExchange)
             console.log(chalk.green(`\n  ${key} = ${value}\n`));
         });
     });
+    // ── settings env ──
+    const env = settings.command("env").description("Manage ~/.perp/.env configuration");
+    // ── settings env show ──
+    env
+        .command("show")
+        .description("Show current configuration")
+        .action(async () => {
+        const stored = loadEnvFile();
+        const entries = [];
+        for (const [exchange, info] of Object.entries(EXCHANGE_ENV_MAP)) {
+            const fromFile = stored[info.envKey];
+            const fromEnv = process.env[info.envKey];
+            if (fromFile) {
+                entries.push({ name: exchange, chain: info.chain, key: fromFile, source: "~/.perp/.env" });
+            }
+            else if (fromEnv) {
+                entries.push({ name: exchange, chain: info.chain, key: fromEnv, source: "environment" });
+            }
+        }
+        // Derive addresses
+        const results = [];
+        for (const entry of entries) {
+            const { valid, address } = await validateKey(entry.chain, entry.key);
+            results.push({ name: entry.name, address: valid ? address : "(invalid key)", source: entry.source });
+        }
+        if (isJson()) {
+            const data = results.map((r) => ({ exchange: r.name, address: r.address, source: r.source }));
+            return printJson(jsonOk({ envFile: ENV_FILE, exchanges: data }));
+        }
+        console.log(chalk.cyan.bold("\n  perp-cli Configuration\n"));
+        console.log(`  File: ${chalk.gray(ENV_FILE)}\n`);
+        if (results.length === 0) {
+            console.log(chalk.gray("  No keys configured. Run 'perp init' or 'perp settings env set <exchange> <key>'\n"));
+            return;
+        }
+        for (const { name, address, source } of results) {
+            console.log(`  ${chalk.cyan(name.padEnd(14))} ${chalk.green(address)}  ${chalk.gray(source)}`);
+        }
+        console.log();
+    });
+    // ── settings env set <exchange|key> <value> ──
+    env
+        .command("set <name> <value>")
+        .description("Set a key (exchange name or env var name)")
+        .action(async (name, value) => {
+        const resolved = resolveEnvKey(name);
+        if (resolved) {
+            // Validate the key
+            const { valid, address } = await validateKey(resolved.chain, value);
+            if (!valid) {
+                if (isJson()) {
+                    const { jsonError } = await import("../utils.js");
+                    return printJson(jsonError("INVALID_PARAMS", `Invalid ${resolved.chain} private key`));
+                }
+                console.error(chalk.red(`\n  Invalid ${resolved.chain} private key.\n`));
+                process.exit(1);
+            }
+            const normalized = resolved.chain === "evm"
+                ? (value.startsWith("0x") ? value : `0x${value}`)
+                : value;
+            setEnvVar(resolved.envKey, normalized);
+            if (isJson())
+                return printJson(jsonOk({ key: resolved.envKey, address, file: ENV_FILE }));
+            console.log(chalk.green(`\n  ${resolved.envKey} set.`));
+            console.log(`  Address: ${chalk.gray(address)}`);
+            console.log(`  File:    ${chalk.gray("~/.perp/.env")}\n`);
+        }
+        else {
+            // Raw env var (e.g. LIGHTER_API_KEY, custom vars)
+            setEnvVar(name, value);
+            if (isJson())
+                return printJson(jsonOk({ key: name, file: ENV_FILE }));
+            console.log(chalk.green(`\n  ${name} set.`));
+            console.log(`  File: ${chalk.gray("~/.perp/.env")}\n`);
+        }
+    });
+    // ── settings env remove <name> ──
+    env
+        .command("remove <name>")
+        .description("Remove a key from ~/.perp/.env")
+        .action(async (name) => {
+        const resolved = resolveEnvKey(name);
+        const envKey = resolved?.envKey || name;
+        const env = loadEnvFile();
+        if (!(envKey in env)) {
+            if (isJson()) {
+                const { jsonError } = await import("../utils.js");
+                return printJson(jsonError("NOT_FOUND", `${envKey} not found in ~/.perp/.env`));
+            }
+            console.log(chalk.gray(`\n  ${envKey} not found in ~/.perp/.env\n`));
+            return;
+        }
+        delete env[envKey];
+        // Rewrite file
+        const { writeFileSync } = await import("fs");
+        const lines = ["# perp-cli configuration", "# Generated by 'perp init' — edit freely", ""];
+        for (const [k, v] of Object.entries(env))
+            lines.push(`${k}=${v}`);
+        lines.push("");
+        writeFileSync(ENV_FILE, lines.join("\n"), { mode: 0o600 });
+        if (isJson())
+            return printJson(jsonOk({ removed: envKey }));
+        console.log(chalk.yellow(`\n  ${envKey} removed from ~/.perp/.env\n`));
+    });
+    // ── settings env path ──
+    env
+        .command("path")
+        .description("Print env file path")
+        .action(() => {
+        if (isJson())
+            return printJson(jsonOk({ path: ENV_FILE }));
+        console.log(ENV_FILE);
+    });
+    // ── Deprecated top-level `env` command ──
+    const deprecatedEnv = program
+        .command("env")
+        .description("[deprecated] Use 'perp settings env'")
+        .allowUnknownOption()
+        .action(() => {
+        console.log(chalk.yellow("\n  'perp env' is deprecated. Use 'perp settings env' instead.\n"));
+        console.log(chalk.gray("  Examples:"));
+        console.log(chalk.gray("    perp settings env show"));
+        console.log(chalk.gray("    perp settings env set <exchange> <key>"));
+        console.log(chalk.gray("    perp settings env remove <name>"));
+        console.log(chalk.gray("    perp settings env path\n"));
+    });
+    deprecatedEnv._hidden = true;
 }

package/dist/commands/trade.d.ts

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