perp-cli 0.4.2 → 0.4.8

package/dist/commands/pnl.js

@@ -0,0 +1,243 @@
+/**
+ * PnL Tracker CLI commands.
+ *
+ * perp pnl snapshot  — take one-time equity snapshots across exchanges
+ * perp pnl track     — continuous equity tracking (foreground)
+ * perp pnl daily     — daily PnL breakdown table
+ * perp pnl weekly    — weekly PnL breakdown table
+ * perp pnl summary   — performance summary (Sharpe, drawdown, win rate)
+ */
+import chalk from "chalk";
+import { printJson, jsonOk, jsonError, makeTable, formatUsd, formatPnl, withJsonErrors } from "../utils.js";
+import { saveEquitySnapshot, readEquityHistory, computePnlMetrics, computeDailyPnl, aggregateWeekly, } from "../equity-tracker.js";
+const EXCHANGES = ["pacifica", "hyperliquid", "lighter"];
+function parseSince(since) {
+    if (!since)
+        return undefined;
+    const match = since.match(/^(\d+)(h|d|w)$/);
+    if (match) {
+        const [, num, unit] = match;
+        const ms = { h: 3600000, d: 86400000, w: 604800000 }[unit] ?? 86400000;
+        return new Date(Date.now() - parseInt(num) * ms);
+    }
+    return new Date(since);
+}
+/** Take equity snapshot for given adapters. */
+async function takeSnapshot(getAdapterForExchange, exchanges) {
+    const ts = new Date().toISOString();
+    const snaps = [];
+    const results = await Promise.allSettled(exchanges.map(async (ex) => {
+        const adapter = await getAdapterForExchange(ex);
+        const [balance, positions] = await Promise.all([
+            adapter.getBalance(),
+            adapter.getPositions(),
+        ]);
+        const snap = {
+            ts,
+            exchange: ex,
+            equity: Number(balance.equity),
+            available: Number(balance.available),
+            marginUsed: Number(balance.marginUsed),
+            unrealizedPnl: Number(balance.unrealizedPnl),
+            positionCount: positions.filter(p => Number(p.size) > 0).length,
+        };
+        saveEquitySnapshot(snap);
+        return snap;
+    }));
+    for (const r of results) {
+        if (r.status === "fulfilled")
+            snaps.push(r.value);
+    }
+    return snaps;
+}
+export function registerPnlCommands(program, getAdapterForExchange, isJson) {
+    const pnl = program.command("pnl").description("PnL tracker — equity tracking & performance metrics");
+    // ── pnl snapshot ──
+    pnl
+        .command("snapshot")
+        .description("Take equity snapshot across all exchanges")
+        .option("--exchanges <list>", "Comma-separated exchange list", EXCHANGES.join(","))
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const exchanges = opts.exchanges.split(",").map(e => e.trim());
+            const snaps = await takeSnapshot(getAdapterForExchange, exchanges);
+            if (isJson()) {
+                printJson(jsonOk({ snapshots: snaps }));
+            }
+            else {
+                const total = snaps.reduce((s, sn) => s + sn.equity, 0);
+                console.log(chalk.cyan.bold("Equity Snapshot\n"));
+                for (const s of snaps) {
+                    console.log(`  ${s.exchange.padEnd(14)} $${formatUsd(s.equity)}  ` +
+                        `avail $${formatUsd(s.available)}  ` +
+                        `uPnL ${formatPnl(s.unrealizedPnl)}  ` +
+                        `pos: ${s.positionCount}`);
+                }
+                console.log(`\n  ${"Total".padEnd(14)} $${formatUsd(total)}`);
+                console.log(chalk.gray(`\n  Saved at ${snaps[0]?.ts ?? "—"}`));
+            }
+        });
+    });
+    // ── pnl track ──
+    pnl
+        .command("track")
+        .description("Continuously track equity (foreground)")
+        .option("--interval <sec>", "Snapshot interval in seconds", "300")
+        .option("--exchanges <list>", "Comma-separated exchange list", EXCHANGES.join(","))
+        .action(async (opts) => {
+        const intervalMs = parseInt(opts.interval) * 1000;
+        const exchanges = opts.exchanges.split(",").map(e => e.trim());
+        console.log(chalk.cyan(`PnL tracker started — snapshot every ${opts.interval}s for [${exchanges.join(", ")}]`));
+        console.log(chalk.gray("Press Ctrl+C to stop\n"));
+        const controller = new AbortController();
+        process.on("SIGINT", () => controller.abort());
+        // Initial snapshot
+        const snaps = await takeSnapshot(getAdapterForExchange, exchanges);
+        const total = snaps.reduce((s, sn) => s + sn.equity, 0);
+        console.log(`${chalk.gray(new Date().toLocaleTimeString())} Total equity: $${formatUsd(total)}`);
+        while (!controller.signal.aborted) {
+            await new Promise((resolve) => {
+                const timer = setTimeout(resolve, intervalMs);
+                controller.signal.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+            });
+            if (controller.signal.aborted)
+                break;
+            try {
+                const s = await takeSnapshot(getAdapterForExchange, exchanges);
+                const t = s.reduce((sum, sn) => sum + sn.equity, 0);
+                const delta = t - total;
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} ` +
+                    `Total: $${formatUsd(t)}  ${formatPnl(delta)}`);
+            }
+            catch (err) {
+                console.error(chalk.red(`Snapshot error: ${err instanceof Error ? err.message : err}`));
+            }
+        }
+    });
+    // ── pnl daily ──
+    pnl
+        .command("daily")
+        .description("Daily PnL breakdown")
+        .option("--exchange <name>", "Single exchange filter")
+        .option("--days <n>", "Number of days to show", "14")
+        .option("--since <period>", "Time range (e.g. 7d, 2w, 30d)")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const since = parseSince(opts.since) ?? new Date(Date.now() - parseInt(opts.days) * 86400000);
+            const snapshots = readEquityHistory({ exchange: opts.exchange, since });
+            if (snapshots.length === 0) {
+                if (isJson()) {
+                    printJson(jsonError("NO_DATA", "No equity snapshots found. Run 'perp pnl snapshot' or 'perp pnl track' first."));
+                }
+                else {
+                    console.log(chalk.yellow("No equity snapshots found. Run 'perp pnl snapshot' or 'perp pnl track' first."));
+                }
+                return;
+            }
+            const daily = computeDailyPnl(snapshots, opts.exchange);
+            if (isJson()) {
+                printJson(jsonOk({ daily }));
+            }
+            else {
+                console.log(chalk.cyan.bold(`Daily PnL${opts.exchange ? ` (${opts.exchange})` : ""}\n`));
+                const head = ["Date", "Start", "End", "PnL", "PnL %"];
+                const rows = daily.map(d => [
+                    d.date,
+                    `$${formatUsd(d.startEquity)}`,
+                    `$${formatUsd(d.endEquity)}`,
+                    formatPnl(d.pnl),
+                    `${d.pnlPct >= 0 ? "+" : ""}${d.pnlPct.toFixed(2)}%`,
+                ]);
+                console.log(makeTable(head, rows));
+            }
+        });
+    });
+    // ── pnl weekly ──
+    pnl
+        .command("weekly")
+        .description("Weekly PnL breakdown")
+        .option("--exchange <name>", "Single exchange filter")
+        .option("--weeks <n>", "Number of weeks to show", "8")
+        .option("--since <period>", "Time range (e.g. 4w, 8w)")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const since = parseSince(opts.since) ?? new Date(Date.now() - parseInt(opts.weeks) * 7 * 86400000);
+            const snapshots = readEquityHistory({ exchange: opts.exchange, since });
+            if (snapshots.length === 0) {
+                if (isJson()) {
+                    printJson(jsonError("NO_DATA", "No equity snapshots found."));
+                }
+                else {
+                    console.log(chalk.yellow("No equity snapshots found. Run 'perp pnl snapshot' or 'perp pnl track' first."));
+                }
+                return;
+            }
+            const daily = computeDailyPnl(snapshots, opts.exchange);
+            const weekly = aggregateWeekly(daily);
+            if (isJson()) {
+                printJson(jsonOk({ weekly }));
+            }
+            else {
+                console.log(chalk.cyan.bold(`Weekly PnL${opts.exchange ? ` (${opts.exchange})` : ""}\n`));
+                const head = ["Week", "Start", "End", "PnL", "PnL %"];
+                const rows = weekly.map(w => [
+                    w.date,
+                    `$${formatUsd(w.startEquity)}`,
+                    `$${formatUsd(w.endEquity)}`,
+                    formatPnl(w.pnl),
+                    `${w.pnlPct >= 0 ? "+" : ""}${w.pnlPct.toFixed(2)}%`,
+                ]);
+                console.log(makeTable(head, rows));
+            }
+        });
+    });
+    // ── pnl summary ──
+    pnl
+        .command("summary")
+        .description("Performance summary — Sharpe, drawdown, win rate")
+        .option("--exchange <name>", "Single exchange filter")
+        .option("--since <period>", "Time range (e.g. 7d, 30d, 12w)")
+        .action(async (opts) => {
+        await withJsonErrors(isJson(), async () => {
+            const since = parseSince(opts.since);
+            const snapshots = readEquityHistory({ exchange: opts.exchange, since });
+            if (snapshots.length === 0) {
+                if (isJson()) {
+                    printJson(jsonError("NO_DATA", "No equity snapshots found."));
+                }
+                else {
+                    console.log(chalk.yellow("No equity snapshots found. Run 'perp pnl snapshot' or 'perp pnl track' first."));
+                }
+                return;
+            }
+            const metrics = computePnlMetrics(snapshots, opts.exchange);
+            if (isJson()) {
+                printJson(jsonOk({
+                    ...metrics,
+                    dailyReturns: undefined, // omit large array from JSON
+                    dailyCount: metrics.dailyReturns.length,
+                }));
+            }
+            else {
+                console.log(chalk.cyan.bold(`Performance Summary${opts.exchange ? ` (${opts.exchange})` : ""}\n`));
+                console.log(`  Period:          ${metrics.period.from} → ${metrics.period.to} (${metrics.period.days} days)`);
+                console.log(`  Total Return:    ${formatPnl(metrics.totalReturn)} (${metrics.totalReturnPct >= 0 ? "+" : ""}${metrics.totalReturnPct.toFixed(2)}%)`);
+                console.log(`  Peak Equity:     $${formatUsd(metrics.peakEquity)}`);
+                console.log(`  Avg Daily PnL:   ${formatPnl(metrics.avgDailyPnl)}`);
+                console.log();
+                console.log(`  Sharpe Ratio:    ${metrics.sharpeRatio >= 0 ? chalk.green(metrics.sharpeRatio.toFixed(2)) : chalk.red(metrics.sharpeRatio.toFixed(2))}`);
+                console.log(`  Max Drawdown:    ${chalk.red(`$${formatUsd(metrics.maxDrawdown)}`)} (${chalk.red(`-${metrics.maxDrawdownPct.toFixed(2)}%`)})`);
+                console.log(`  Current DD:      $${formatUsd(metrics.currentDrawdown)} (-${metrics.currentDrawdownPct.toFixed(2)}%)`);
+                console.log();
+                console.log(`  Win Days:        ${chalk.green(String(metrics.winDays))} / ${metrics.winDays + metrics.lossDays}`);
+                console.log(`  Win Rate:        ${metrics.winRate.toFixed(1)}%`);
+                if (metrics.bestDay) {
+                    console.log(`  Best Day:        ${metrics.bestDay.date}  ${formatPnl(metrics.bestDay.pnl)}`);
+                }
+                if (metrics.worstDay) {
+                    console.log(`  Worst Day:       ${metrics.worstDay.date}  ${formatPnl(metrics.worstDay.pnl)}`);
+                }
+            }
+        });
+    });
+}

package/dist/commands/stream.js

@@ -1,93 +1,170 @@
 import { PacificaWSClient } from "../pacifica/index.js";
 import chalk from "chalk";
 import { formatUsd, formatPercent } from "../utils.js";
+/** Create an HL or Lighter market feed, connected and ready. */
+async function getMarketFeed(exchange) {
+    const { createMarketFeed } = await import("../ws/market-feed.js");
+    const feed = createMarketFeed(exchange);
+    await feed.connect();
+    process.on("SIGINT", () => { feed.close(); process.exit(0); });
+    return feed;
+}
 export function registerStreamCommands(program, getNetwork, getExchange, getAdapter) {
     const stream = program.command("stream").description("Live WebSocket streams (Ctrl+C to stop)");
+    // ── stream prices ──
     stream
         .command("prices")
         .description("Stream live prices")
         .action(async () => {
-        const ws = new PacificaWSClient({ network: getNetwork() });
-        await ws.connect();
-        ws.subscribe("prices");
-        ws.on("prices", (msg) => {
-            const data = msg;
-            const d = data.data ?? data;
-            if (Array.isArray(d)) {
-                d.forEach((p) => {
-                    const mark = Number(p.mark ?? p.m ?? 0);
-                    const funding = Number(p.funding ?? p.f ?? 0);
-                    const sym = String(p.symbol ?? p.s ?? "").padEnd(10);
-                    console.log(`${chalk.white.bold(sym)} $${formatUsd(mark)}  ${formatPercent(funding)}`);
-                });
-            }
-        });
-        console.log(chalk.cyan("Streaming prices... (Ctrl+C to stop)\n"));
+        const exchange = getExchange();
+        if (exchange === "pacifica") {
+            const ws = new PacificaWSClient({ network: getNetwork() });
+            await ws.connect();
+            ws.subscribe("prices");
+            ws.on("prices", (msg) => {
+                const data = msg;
+                const d = data.data ?? data;
+                if (Array.isArray(d)) {
+                    d.forEach((p) => {
+                        const mark = Number(p.mark ?? p.m ?? 0);
+                        const funding = Number(p.funding ?? p.f ?? 0);
+                        const sym = String(p.symbol ?? p.s ?? "").padEnd(10);
+                        console.log(`${chalk.white.bold(sym)} $${formatUsd(mark)}  ${formatPercent(funding)}`);
+                    });
+                }
+            });
+            console.log(chalk.cyan("Streaming pacifica prices... (Ctrl+C to stop)\n"));
+        }
+        else {
+            const feed = await getMarketFeed(exchange);
+            feed.subscribePrices();
+            feed.on("prices", (updates) => {
+                for (const p of updates) {
+                    const sym = p.symbol.padEnd(10);
+                    console.log(`${chalk.white.bold(sym)} $${formatUsd(p.mid)}`);
+                }
+            });
+            console.log(chalk.cyan(`Streaming ${exchange} prices... (Ctrl+C to stop)\n`));
+        }
         await new Promise(() => { }); // keep alive
     });
+    // ── stream book ──
     stream
         .command("book <symbol>")
         .description("Stream orderbook updates")
         .action(async (symbol) => {
-        const ws = new PacificaWSClient({ network: getNetwork() });
-        await ws.connect();
-        ws.subscribe("book", { symbol: symbol.toUpperCase() });
-        ws.on("book", (msg) => {
-            const data = msg;
-            console.log(`${chalk.cyan(new Date().toLocaleTimeString())} ${JSON.stringify(data.data ?? data)}`);
-        });
-        console.log(chalk.cyan(`Streaming ${symbol.toUpperCase()} orderbook... (Ctrl+C to stop)\n`));
+        const exchange = getExchange();
+        const sym = symbol.toUpperCase();
+        if (exchange === "pacifica") {
+            const ws = new PacificaWSClient({ network: getNetwork() });
+            await ws.connect();
+            ws.subscribe("book", { symbol: sym });
+            ws.on("book", (msg) => {
+                const data = msg;
+                console.log(`${chalk.cyan(new Date().toLocaleTimeString())} ${JSON.stringify(data.data ?? data)}`);
+            });
+        }
+        else {
+            const feed = await getMarketFeed(exchange);
+            feed.subscribeBook(sym);
+            feed.on("book", (data) => {
+                const topBids = data.bids.slice(0, 5).map(([p, s]) => `${p}x${s}`).join(" ");
+                const topAsks = data.asks.slice(0, 5).map(([p, s]) => `${p}x${s}`).join(" ");
+                console.log(`${chalk.cyan(new Date().toLocaleTimeString())} ${chalk.green("BID")} ${topBids}  ${chalk.red("ASK")} ${topAsks}`);
+            });
+        }
+        console.log(chalk.cyan(`Streaming ${sym} orderbook on ${exchange}... (Ctrl+C to stop)\n`));
         await new Promise(() => { });
     });
+    // ── stream trades ──
     stream
         .command("trades <symbol>")
         .description("Stream live trades")
         .action(async (symbol) => {
-        const ws = new PacificaWSClient({ network: getNetwork() });
-        await ws.connect();
-        ws.subscribe("trades", { symbol: symbol.toUpperCase() });
-        ws.on("trades", (msg) => {
-            const data = msg;
-            const d = (data.data ?? data);
-            const side = String(d.side ?? d.d ?? "");
-            const price = String(d.price ?? d.p ?? "");
-            const amount = String(d.amount ?? d.a ?? "");
-            const color = side === "bid" || side === "buy" ? chalk.green : chalk.red;
-            console.log(`${chalk.gray(new Date().toLocaleTimeString())} ${color(side === "bid" ? "BUY " : "SELL")} $${formatUsd(price)} x ${amount}`);
-        });
-        console.log(chalk.cyan(`Streaming ${symbol.toUpperCase()} trades... (Ctrl+C to stop)\n`));
+        const exchange = getExchange();
+        const sym = symbol.toUpperCase();
+        if (exchange === "pacifica") {
+            const ws = new PacificaWSClient({ network: getNetwork() });
+            await ws.connect();
+            ws.subscribe("trades", { symbol: sym });
+            ws.on("trades", (msg) => {
+                const data = msg;
+                const d = (data.data ?? data);
+                const side = String(d.side ?? d.d ?? "");
+                const price = String(d.price ?? d.p ?? "");
+                const amount = String(d.amount ?? d.a ?? "");
+                const color = side === "bid" || side === "buy" ? chalk.green : chalk.red;
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} ${color(side === "bid" ? "BUY " : "SELL")} $${formatUsd(price)} x ${amount}`);
+            });
+        }
+        else {
+            const feed = await getMarketFeed(exchange);
+            feed.subscribeTrades(sym);
+            feed.on("trade", (t) => {
+                const color = t.side === "buy" ? chalk.green : chalk.red;
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} ${color(t.side === "buy" ? "BUY " : "SELL")} $${formatUsd(t.price)} x ${t.size}`);
+            });
+        }
+        console.log(chalk.cyan(`Streaming ${sym} trades on ${exchange}... (Ctrl+C to stop)\n`));
         await new Promise(() => { });
     });
+    // ── stream bbo ──
     stream
         .command("bbo <symbol>")
         .description("Stream best bid/offer")
         .action(async (symbol) => {
-        const ws = new PacificaWSClient({ network: getNetwork() });
-        await ws.connect();
-        ws.subscribe("bbo", { symbol: symbol.toUpperCase() });
-        ws.on("bbo", (msg) => {
-            const data = msg.data ?? msg;
-            console.log(`${chalk.gray(new Date().toLocaleTimeString())} ${JSON.stringify(data)}`);
-        });
-        console.log(chalk.cyan(`Streaming ${symbol.toUpperCase()} BBO... (Ctrl+C to stop)\n`));
+        const exchange = getExchange();
+        const sym = symbol.toUpperCase();
+        if (exchange === "pacifica") {
+            const ws = new PacificaWSClient({ network: getNetwork() });
+            await ws.connect();
+            ws.subscribe("bbo", { symbol: sym });
+            ws.on("bbo", (msg) => {
+                const data = msg.data ?? msg;
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} ${JSON.stringify(data)}`);
+            });
+        }
+        else {
+            // BBO derived from orderbook (HL/Lighter don't have dedicated BBO channel)
+            const feed = await getMarketFeed(exchange);
+            feed.subscribeBook(sym);
+            feed.on("book", (data) => {
+                const bid = data.bids[0] ?? ["—", "—"];
+                const ask = data.asks[0] ?? ["—", "—"];
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} ${chalk.green("bid")} ${bid[0]} (${bid[1]})  ${chalk.red("ask")} ${ask[0]} (${ask[1]})`);
+            });
+        }
+        console.log(chalk.cyan(`Streaming ${sym} BBO on ${exchange}... (Ctrl+C to stop)\n`));
         await new Promise(() => { });
     });
+    // ── stream candle ──
     stream
         .command("candle <symbol> <interval>")
         .description("Stream candlestick data")
         .action(async (symbol, interval) => {
-        const ws = new PacificaWSClient({ network: getNetwork() });
-        await ws.connect();
-        ws.subscribe("candle", { symbol: symbol.toUpperCase(), interval });
-        ws.on("candle", (msg) => {
-            const data = msg.data ?? msg;
-            const d = data;
-            console.log(`${chalk.gray(new Date().toLocaleTimeString())} O:$${formatUsd(String(d.o ?? ""))} H:$${formatUsd(String(d.h ?? ""))} L:$${formatUsd(String(d.l ?? ""))} C:$${formatUsd(String(d.c ?? ""))} V:${d.v ?? ""}`);
-        });
-        console.log(chalk.cyan(`Streaming ${symbol.toUpperCase()} ${interval} candles... (Ctrl+C to stop)\n`));
+        const exchange = getExchange();
+        const sym = symbol.toUpperCase();
+        if (exchange === "pacifica") {
+            const ws = new PacificaWSClient({ network: getNetwork() });
+            await ws.connect();
+            ws.subscribe("candle", { symbol: sym, interval });
+            ws.on("candle", (msg) => {
+                const data = msg.data ?? msg;
+                const d = data;
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} O:$${formatUsd(String(d.o ?? ""))} H:$${formatUsd(String(d.h ?? ""))} L:$${formatUsd(String(d.l ?? ""))} C:$${formatUsd(String(d.c ?? ""))} V:${d.v ?? ""}`);
+            });
+        }
+        else {
+            const feed = await getMarketFeed(exchange);
+            feed.subscribeCandle(sym, interval);
+            feed.on("candle", (d) => {
+                console.log(`${chalk.gray(new Date().toLocaleTimeString())} O:$${formatUsd(d.o)} H:$${formatUsd(d.h)} L:$${formatUsd(d.l)} C:$${formatUsd(d.c)} V:${d.v}`);
+            });
+        }
+        console.log(chalk.cyan(`Streaming ${sym} ${interval} candles on ${exchange}... (Ctrl+C to stop)\n`));
         await new Promise(() => { });
     });
-    // ── stream events ── (unified account events as NDJSON)
+    // ── stream events ── (unified account events as NDJSON, already exchange-agnostic)
     if (getAdapter) {
         stream
             .command("events")

package/dist/commands/trade.js

@@ -245,21 +245,42 @@ export function registerTradeCommands(program, getAdapter, isJson, isDryRun = ()
         printJson(jsonOk(result));
     });
     trade
-        .command("cancel <symbol> <orderId>")
-        .description("Cancel a specific order")
-        .action(async (symbol, orderId) => {
+        .command("cancel <symbolOrOrderId> [orderId]")
+        .description("Cancel an order by orderId (auto-detects symbol), or by symbol + orderId")
+        .action(async (symbolOrOrderId, orderId) => {
         const adapter = await getAdapter();
-        if (dryRunGuard("cancel", { exchange: adapter.name, symbol: symbol.toUpperCase(), orderId }))
+        let symbol;
+        let oid;
+        if (orderId) {
+            // cancel <symbol> <orderId>
+            symbol = symbolOrOrderId.toUpperCase();
+            oid = orderId;
+        }
+        else {
+            // cancel <orderId> — look up symbol from open orders
+            oid = symbolOrOrderId;
+            const orders = await adapter.getOpenOrders();
+            const match = orders.find((o) => String(o.orderId) === oid);
+            if (!match) {
+                const err = `Order ${oid} not found in open orders`;
+                if (isJson())
+                    return printJson(jsonOk({ cancelled: false, reason: err }));
+                console.log(chalk.yellow(`\n  ${err}\n`));
+                return;
+            }
+            symbol = match.symbol;
+        }
+        if (dryRunGuard("cancel", { exchange: adapter.name, symbol, orderId: oid }))
             return;
         try {
-            const result = await adapter.cancelOrder(symbol.toUpperCase(), orderId);
-            logExecution({ type: "cancel", exchange: adapter.name, symbol: symbol.toUpperCase(), side: "cancel", size: "0", status: "success", dryRun: false, meta: { orderId } });
+            const result = await adapter.cancelOrder(symbol, oid);
+            logExecution({ type: "cancel", exchange: adapter.name, symbol, side: "cancel", size: "0", status: "success", dryRun: false, meta: { orderId: oid } });
             if (isJson())
                 return printJson(jsonOk(result));
-            console.log(chalk.green(`\n  Order ${orderId} cancelled on ${adapter.name}.\n`));
+            console.log(chalk.green(`\n  Order ${oid} cancelled on ${adapter.name}.\n`));
         }
         catch (err) {
-            logExecution({ type: "cancel", exchange: adapter.name, symbol: symbol.toUpperCase(), side: "cancel", size: "0", status: "failed", dryRun: false, error: err instanceof Error ? err.message : String(err), meta: { orderId } });
+            logExecution({ type: "cancel", exchange: adapter.name, symbol, side: "cancel", size: "0", status: "failed", dryRun: false, error: err instanceof Error ? err.message : String(err), meta: { orderId: oid } });
             throw err;
         }
     });

package/dist/commands/wallet.js

@@ -389,7 +389,7 @@ export function registerWalletCommands(program, isJson) {
                 const { LighterAdapter } = await import("../exchanges/lighter.js");
                 const adapter = new LighterAdapter(normalized);
                 await adapter.init();
-                const apiKeyIndex = 2;
+                const apiKeyIndex = 4;
                 const { privateKey: apiKey } = await adapter.setupApiKey(apiKeyIndex);
                 setEnvVar("LIGHTER_API_KEY", apiKey);
                 setEnvVar("LIGHTER_ACCOUNT_INDEX", String(adapter.accountIndex));

package/dist/config.d.ts

@@ -1,5 +1,10 @@
 import { Keypair } from "@solana/web3.js";
 export type Exchange = "pacifica" | "hyperliquid" | "lighter";
+/**
+ * Try to load a private key without throwing if none is found.
+ * Returns null if no key is configured.
+ */
+export declare function tryLoadPrivateKey(exchange: Exchange, pkOverride?: string): Promise<string | null>;
 export declare function loadPrivateKey(exchange: Exchange, pkOverride?: string): Promise<string>;
 export declare function parseSolanaKeypair(input: string): Keypair;
 export declare function isEvmPrivateKey(input: string): boolean;

package/dist/config.js

@@ -3,6 +3,18 @@ import bs58 from "bs58";
 import chalk from "chalk";
 import { resolve } from "path";
 import { existsSync, readFileSync } from "fs";
+/**
+ * Try to load a private key without throwing if none is found.
+ * Returns null if no key is configured.
+ */
+export async function tryLoadPrivateKey(exchange, pkOverride) {
+    try {
+        return await loadPrivateKey(exchange, pkOverride);
+    }
+    catch {
+        return null;
+    }
+}
 export async function loadPrivateKey(exchange, pkOverride) {
     // 1. CLI flag
     if (pkOverride)

package/dist/dashboard/ws-feeds.js

@@ -569,7 +569,7 @@ class LighterFeed extends ExchangeWsFeed {
                         liquidationPrice: String(p.liquidation_price || "N/A"),
                         unrealizedPnl: String(p.unrealized_pnl ?? "0"),
                         leverage: Number(p.initial_margin_fraction ?? 0) > 0
-                            ? Math.round(100 / Number(p.initial_margin_fraction))
+                            ? Math.round(10000 / Number(p.initial_margin_fraction))
                             : 1,
                     };
                 });

package/dist/equity-tracker.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Equity Tracker — time-series equity snapshots for PnL analysis.
+ *
+ * Stores snapshots in ~/.perp/equity-history/YYYY-MM.jsonl (monthly files).
+ * Computes daily PnL, Sharpe ratio, max drawdown, win/loss stats.
+ */
+export interface EquitySnapshot {
+    ts: string;
+    exchange: string;
+    equity: number;
+    available: number;
+    marginUsed: number;
+    unrealizedPnl: number;
+    positionCount: number;
+}
+export interface DailyPnl {
+    date: string;
+    exchange: string;
+    startEquity: number;
+    endEquity: number;
+    pnl: number;
+    pnlPct: number;
+}
+export interface PnlMetrics {
+    totalReturn: number;
+    totalReturnPct: number;
+    dailyReturns: DailyPnl[];
+    sharpeRatio: number;
+    maxDrawdown: number;
+    maxDrawdownPct: number;
+    winDays: number;
+    lossDays: number;
+    winRate: number;
+    peakEquity: number;
+    currentDrawdown: number;
+    currentDrawdownPct: number;
+    bestDay: DailyPnl | null;
+    worstDay: DailyPnl | null;
+    avgDailyPnl: number;
+    period: {
+        from: string;
+        to: string;
+        days: number;
+    };
+}
+export declare function saveEquitySnapshot(snap: EquitySnapshot): void;
+export declare function readEquityHistory(opts?: {
+    exchange?: string;
+    since?: Date;
+    until?: Date;
+}): EquitySnapshot[];
+/** Group snapshots by date, take first and last per day for daily PnL. */
+export declare function computeDailyPnl(snapshots: EquitySnapshot[], exchange?: string): DailyPnl[];
+/** Compute comprehensive PnL metrics from equity snapshots. */
+export declare function computePnlMetrics(snapshots: EquitySnapshot[], exchange?: string): PnlMetrics;
+/** Compute weekly PnL from daily PnL data. */
+export declare function aggregateWeekly(daily: DailyPnl[]): DailyPnl[];