perp-cli 0.12.15 → 0.14.0

package/dist/commands/alerts.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
+import "../exchanges/venues/index.js";
 export declare function registerAlertCommands(program: Command, isJson: () => boolean): void;

package/dist/commands/alerts.js

@@ -5,6 +5,11 @@ import { validateBotToken as validateDiscordBot, sendDiscordDM, openDMChannel }
 import { validateTelegramBot, sendTelegramMessage, getRecentChatId } from "../telegram.js";
 import { printJson, jsonOk } from "../utils.js";
 import { fetchAllFundingRates } from "../funding-rates.js";
+import "../exchanges/venues/index.js";
+import { resolveVenueId, getVenue } from "../exchanges/venue.js";
+import { PerpError } from "../errors.js";
+import { scrubSecretEnv } from "../secret-env.js";
+import { networkOf } from "../cli-flags.js";
 function ask(rl, question) {
     return new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
 }
@@ -99,8 +104,7 @@ export function registerAlertCommands(program, isJson) {
         .action(async () => {
         const settings = loadSettings();
         if (!hasAnyService(settings.alerts)) {
-            console.log(chalk.red("  Not configured. Run: perp alerts setup\n"));
-            return;
+            throw new PerpError("INVALID_PARAMS", "No alert messaging service (Telegram / Discord) is configured", { remediation: "Run: perp alerts setup" });
         }
         const msg = `[TEST] perp-cli alert system is working. ${new Date().toISOString()}`;
         try {
@@ -110,9 +114,9 @@ export function registerAlertCommands(program, isJson) {
             console.log(chalk.green(`  Test message sent! (${serviceStatus(settings.alerts).join(", ")})\n`));
         }
         catch (err) {
-            if (isJson())
-                return printJson(jsonOk({ error: String(err) }));
-            console.log(chalk.red(`  Failed: ${err instanceof Error ? err.message : err}\n`));
+            throw new PerpError("EXCHANGE_ERROR", `Test alert failed: ${err instanceof Error ? err.message : String(err)}`, {
+                remediation: "Check the bot token / chat id or webhook: perp alerts setup",
+            });
         }
     });
     // ── alerts add ──
@@ -122,7 +126,7 @@ export function registerAlertCommands(program, isJson) {
         .argument("[symbol]", "Symbol to monitor (e.g. ETH, BTC)")
         .argument("[threshold]", "Annual funding rate % threshold")
         .option("--all", "Monitor all symbols")
-        .option("--exchange <ex>", "Filter by exchange (hl, pac, lt)")
+        .option("--exchange <ex>", "Filter by venue id or alias (e.g. hl, pac, lt, ast, lighter-rh, ondo, arcus, qfex)")
         .option("--below", "Alert when rate drops below threshold (default: above)")
         .action((symbol, thresholdStr, opts) => {
         const sym = opts.all ? "*" : symbol?.toUpperCase();
@@ -136,8 +140,12 @@ export function registerAlertCommands(program, isJson) {
             console.log(chalk.red("  Threshold must be a positive number (annual %)\n"));
             return;
         }
-        const aliasMap = { hl: "hyperliquid", pac: "pacifica", lt: "lighter" };
-        const exchange = opts.exchange ? (aliasMap[opts.exchange.toLowerCase()] || opts.exchange.toLowerCase()) : "*";
+        // Unknown venue → UNKNOWN_VENUE (a stored rule with a typo would never match).
+        // `--exchange` is also the root option (-e, --exchange), which commander gives to the root
+        // program: read it there when it was passed on the command line (never its default venue).
+        const rootExchange = program.getOptionValueSource("exchange") === "cli" ? String(program.opts().exchange) : undefined;
+        const filter = opts.exchange ?? rootExchange;
+        const exchange = filter !== undefined ? resolveVenueId(filter) : "*";
         const settings = loadSettings();
         const rule = {
             id: `${sym}-${exchange}-${Date.now()}`,
@@ -240,13 +248,11 @@ export function registerAlertCommands(program, isJson) {
         .action(async (opts) => {
         const settings = loadSettings();
         if (!hasAnyService(settings.alerts)) {
-            console.log(chalk.red("  No messaging service configured. Run: perp alerts setup\n"));
-            return;
+            throw new PerpError("INVALID_PARAMS", "No alert messaging service (Telegram / Discord) is configured", { remediation: "Run: perp alerts setup" });
         }
         const rules = settings.alerts.rules.filter(r => r.enabled);
         if (rules.length === 0) {
-            console.log(chalk.red("  No active alert rules. Add one: perp alerts add ETH 30\n"));
-            return;
+            throw new PerpError("INVALID_PARAMS", "No active alert rules", { remediation: "Add one: perp alerts add ETH 30" });
         }
         const intervalSec = parseInt(opts.interval || String(settings.alerts.intervalSec)) || 300;
         const cooldownMin = parseInt(opts.cooldown || String(settings.alerts.cooldownMin)) || 60;
@@ -254,27 +260,23 @@ export function registerAlertCommands(program, isJson) {
         if (opts.background) {
             const { execSync } = await import("child_process");
             try {
-                execSync("which tmux", { stdio: "ignore" });
+                execSync("which tmux", { stdio: "ignore", env: scrubSecretEnv(process.env) });
             }
             catch {
                 console.log(chalk.red("  tmux required for --background. Install: brew install tmux\n"));
                 return;
             }
             const session = `perp-alerts-${Date.now().toString(36)}`;
-            const nodeCmd = process.argv[0];
-            const cliPath = process.argv[1];
-            const args = [
+            // The daemon reads public funding rates + settings.json only: no key material is
+            // handed to it (SSOT Rule #3) — launchTmuxChild strips secret env vars.
+            const { launchTmuxChild } = await import("../jobs.js");
+            launchTmuxChild(session, [
+                // Same network as the parent (review L6): the daemon reads that network's funding rates.
+                "-n", networkOf(program),
                 "alerts", "start",
                 "--interval", String(intervalSec),
                 "--cooldown", String(cooldownMin),
-            ].join(" ");
-            // Pass through env vars for keys
-            // L2 agent key + indices now live in ~/.perp keystore + settings.agents (SSOT Rule #3),
-            // not env. Only Tier 3 master PKs need passthrough.
-            const envKeys = ["LIGHTER_PRIVATE_KEY", "HL_PRIVATE_KEY", "PACIFICA_PRIVATE_KEY", "ASTER_PRIVATE_KEY", "PRIVATE_KEY"];
-            const envStr = envKeys.filter(k => process.env[k]).map(k => `${k}='${process.env[k]}'`).join(" ");
-            const cmd = `${envStr} ${nodeCmd} ${cliPath} ${args}`;
-            execSync(`tmux new-session -d -s ${session} '${cmd.replace(/'/g, "'\\''")}'`);
+            ], null, false);
             if (isJson())
                 return printJson(jsonOk({ status: "started", session, rules: rules.length, interval: intervalSec }));
             console.log(chalk.green(`\n  Alert daemon started in background.`));
@@ -323,7 +325,7 @@ export function registerAlertCommands(program, isJson) {
                                 continue;
                             cooldowns.set(cooldownKey, Date.now());
                             alertCount++;
-                            const exAbbr = rate.exchange === "pacifica" ? "PAC" : rate.exchange === "hyperliquid" ? "HL" : "LT";
+                            const exAbbr = getVenue(rate.exchange).displayName;
                             const sign = rate.annualizedPct > 0 ? "+" : "";
                             const msg = [
                                 `${comparison.symbol} funding alert`,
@@ -362,17 +364,18 @@ export function registerAlertCommands(program, isJson) {
         .action(async () => {
         const { execSync } = await import("child_process");
         try {
-            const sessions = execSync("tmux list-sessions -F '#{session_name}'", { encoding: "utf-8" })
-                .trim().split("\n").filter(s => s.startsWith("perp-alerts-"));
+            const sessions = execSync("tmux list-sessions -F '#{session_name}'", { encoding: "utf-8", env: scrubSecretEnv(process.env) })
+                .trim().split("\n").filter(s => /^perp-alerts-[A-Za-z0-9_-]+$/.test(s));
             if (sessions.length === 0) {
                 if (isJson())
                     return printJson(jsonOk({ status: "none" }));
                 console.log(chalk.gray("  No alert daemon running.\n"));
                 return;
             }
+            const { killTmuxSession } = await import("../jobs.js");
             for (const session of sessions) {
                 try {
-                    execSync(`tmux kill-session -t ${session}`);
+                    killTmuxSession(session);
                 }
                 catch { /* already dead */ }
             }

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

@@ -1,3 +1,62 @@
 import { Command } from "commander";
-import { type ExchangeAdapter } from "../../exchanges/index.js";
+import { type ExchangeAdapter, type ExchangePosition } from "../../exchanges/index.js";
+import { type ExecutionRecord } from "../../execution-log.js";
+/**
+ * Venues an arb leg can sit on: every registered trading venue with a configured
+ * credential source (registry order). Never a hard-coded list — a venue added to the
+ * registry is covered by `arb status` / `arb close` without touching this file.
+ */
+export declare function listArbVenues(): Promise<string[]>;
+/**
+ * Positions of every venue in `venues`. A venue whose adapter cannot be built or whose
+ * positions read fails is an error (Rule #2): an unread venue is not "no positions" —
+ * a hidden leg would make a live pair look closed.
+ */
+export declare function readArbVenuePositions(venues: readonly string[], getAdapter: (exchange: string) => Promise<ExchangeAdapter>): Promise<{
+    exchange: string;
+    position: ExchangePosition;
+}[]>;
+/**
+ * State-file entries the venues do not confirm: no live pair with the same symbol and
+ * legs. `arb status` reports them apart from the live pairs (the venue is the source of truth).
+ */
+export declare function staleArbStateEntries(persisted: ReadonlyArray<{
+    id: string;
+    symbol: string;
+    longExchange: string;
+    shortExchange: string;
+    entryTime: string;
+    mode?: "perp-perp" | "spot-perp";
+    spotExchange?: string;
+}>, livePerpPerp: ReadonlyArray<{
+    symbol: string;
+    longExchange: string;
+    shortExchange: string;
+}>, liveSpotPerp: ReadonlyArray<{
+    symbol: string;
+    spotExchange: string;
+    perpExchange: string;
+}>): {
+    id: string;
+    symbol: string;
+    mode: "perp-perp" | "spot-perp";
+    longExchange: string;
+    shortExchange: string;
+    entryTime: string;
+    reason: string;
+}[];
+export type ArbPairProvenance = "state" | "executionLog" | "inferred";
+/**
+ * Whether a live long/short pair was opened by arb: an arb state entry for exactly these legs
+ * ("state"), else the latest successful arb_entry for exactly these legs in the execution log —
+ * combined (meta.arbPairId / meta.longExchange + shortExchange) or per-leg (meta.leg long on the
+ * long venue + leg short on the short venue within 10 min) — with no successful arb_close of the
+ * pair after it ("executionLog"). Anything else is "inferred". Never a symbol-only match.
+ */
+export declare function arbPairProvenance(symbol: string, longExchange: string, shortExchange: string, persisted: ReadonlyArray<{
+    symbol: string;
+    longExchange: string;
+    shortExchange: string;
+    mode?: "perp-perp" | "spot-perp";
+}>, records: ReadonlyArray<ExecutionRecord>): ArbPairProvenance;
 export declare function registerArbManageCommands(program: Command, getAdapterForExchange: (exchange: string) => Promise<ExchangeAdapter>, isJson: () => boolean): void;