perp-cli 0.3.3

package/dist/commands/run.js

@@ -0,0 +1,202 @@
+import { printJson, jsonOk } from "../utils.js";
+import { updateJobState } from "../jobs.js";
+import { runTWAP } from "../strategies/twap.js";
+import { runFundingArb } from "../strategies/funding-arb.js";
+import { runGrid } from "../strategies/grid.js";
+import { runDCA } from "../strategies/dca.js";
+import { runTrailingStop } from "../strategies/trailing-stop.js";
+import chalk from "chalk";
+export function registerRunCommands(program, getAdapter, getAdapterFor, isJson) {
+    const run = program.command("run").description("Run a strategy (foreground or as background job target)");
+    run
+        .command("twap <symbol> <side> <size> <duration>")
+        .description("Run client-side TWAP (splits market orders over time)")
+        .option("-s, --slices <n>", "Number of slices (default: auto)")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, side, size, duration, opts) => {
+        const s = side.toLowerCase();
+        if (s !== "buy" && s !== "sell") {
+            console.error(chalk.red("Side must be buy or sell"));
+            process.exit(1);
+        }
+        const adapter = await getAdapter();
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: s,
+            totalSize: parseFloat(size),
+            durationSec: parseInt(duration),
+            slices: opts.slices ? parseInt(opts.slices) : undefined,
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runTWAP(adapter, params, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+    run
+        .command("funding-arb")
+        .description("Run funding rate arbitrage monitor/executor")
+        .option("--min-spread <pct>", "Min annual spread % to enter", "10")
+        .option("--close-spread <pct>", "Close when spread drops below (%)", "5")
+        .option("--size <size>", "Position size per leg (base amount)", "0.01")
+        .option("--size-usd <usd>", "Position size per leg in USD (alternative)")
+        .option("--symbols <list>", "Comma-separated symbol filter")
+        .option("--interval <sec>", "Check interval in seconds", "60")
+        .option("--auto-execute", "Actually place trades (default: monitor only)")
+        .option("--max-positions <n>", "Max simultaneous positions", "3")
+        .option("--exchanges <list>", "Comma-separated exchanges to use", "pacifica,hyperliquid,lighter")
+        .option("--auto-rebalance", "Trigger rebalance alerts when exchange balance is low")
+        .option("--rebalance-threshold <usd>", "Rebalance when available < this ($)", "100")
+        .option("--max-drawdown <usd>", "Close all positions if total uPnL exceeds this loss ($)")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (opts) => {
+        const exchangeNames = opts.exchanges.split(",").map((e) => e.trim());
+        const adapters = new Map();
+        for (const name of exchangeNames) {
+            try {
+                const a = await getAdapterFor(name);
+                adapters.set(name, a);
+            }
+            catch {
+                if (!isJson())
+                    console.log(chalk.yellow(`  Skipping ${name} (no credentials)`));
+            }
+        }
+        if (adapters.size < 2) {
+            console.error(chalk.red("Need at least 2 exchanges for arbitrage. Set credentials for 2+ exchanges."));
+            process.exit(1);
+        }
+        const params = {
+            minSpread: parseFloat(opts.minSpread),
+            closeSpread: parseFloat(opts.closeSpread),
+            size: opts.size,
+            sizeUsd: opts.sizeUsd ? parseFloat(opts.sizeUsd) : undefined,
+            symbols: opts.symbols ? opts.symbols.split(",").map((s) => s.trim().toUpperCase()) : undefined,
+            intervalSec: parseInt(opts.interval),
+            autoExecute: opts.autoExecute ?? false,
+            maxPositions: parseInt(opts.maxPositions),
+            autoRebalance: opts.autoRebalance ?? false,
+            rebalanceThreshold: parseFloat(opts.rebalanceThreshold),
+            maxDrawdown: opts.maxDrawdown ? parseFloat(opts.maxDrawdown) : undefined,
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        await runFundingArb(adapters, params, opts.jobId, log);
+    });
+    // ── Grid Bot ──
+    run
+        .command("grid <symbol>")
+        .description("Run grid trading bot (places limit orders across a price range)")
+        .requiredOption("--upper <price>", "Upper price bound")
+        .requiredOption("--lower <price>", "Lower price bound")
+        .option("--grids <n>", "Number of grid lines", "10")
+        .option("--size <size>", "Total position size (base)", "0.1")
+        .option("--side <side>", "Grid bias: long, short, neutral", "neutral")
+        .option("--leverage <n>", "Leverage to set")
+        .option("--interval <sec>", "Check interval in seconds", "10")
+        .option("--max-runtime <sec>", "Max runtime in seconds (0 = forever)", "0")
+        .option("--trailing-stop <pct>", "Stop if equity drops by this % from peak")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, opts) => {
+        const side = opts.side.toLowerCase();
+        if (side !== "long" && side !== "short" && side !== "neutral") {
+            console.error(chalk.red("Side must be long, short, or neutral"));
+            process.exit(1);
+        }
+        const adapter = await getAdapter();
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: side,
+            upperPrice: parseFloat(opts.upper),
+            lowerPrice: parseFloat(opts.lower),
+            grids: parseInt(opts.grids),
+            totalSize: parseFloat(opts.size),
+            leverage: opts.leverage ? parseInt(opts.leverage) : undefined,
+            intervalSec: parseInt(opts.interval),
+            maxRuntime: parseInt(opts.maxRuntime),
+            trailingStop: opts.trailingStop ? parseFloat(opts.trailingStop) : undefined,
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runGrid(adapter, params, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+    // ── DCA (Dollar Cost Averaging) ──
+    run
+        .command("dca <symbol> <side> <amount> <interval>")
+        .description("Run DCA strategy (periodic market orders at fixed intervals)")
+        .option("--orders <n>", "Total number of orders (0 = unlimited)", "0")
+        .option("--price-limit <price>", "Stop buying above / selling below this price")
+        .option("--max-runtime <sec>", "Max runtime in seconds (0 = forever)", "0")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, side, amount, interval, opts) => {
+        const s = side.toLowerCase();
+        if (s !== "buy" && s !== "sell") {
+            console.error(chalk.red("Side must be buy or sell"));
+            process.exit(1);
+        }
+        const adapter = await getAdapter();
+        const params = {
+            symbol: symbol.toUpperCase(),
+            side: s,
+            amountPerOrder: parseFloat(amount),
+            intervalSec: parseInt(interval),
+            totalOrders: parseInt(opts.orders),
+            priceLimit: opts.priceLimit ? parseFloat(opts.priceLimit) : undefined,
+            maxRuntime: parseInt(opts.maxRuntime),
+        };
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runDCA(adapter, params, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+    // ── Trailing Stop ──
+    run
+        .command("trailing-stop <symbol>")
+        .description("Run client-side trailing stop (monitors price, closes position when trail % hit)")
+        .requiredOption("--trail <pct>", "Trail percentage")
+        .option("--interval <sec>", "Check interval in seconds", "5")
+        .option("--activation <price>", "Only start trailing after price reaches this level")
+        .option("--job-id <id>", "Job ID (set automatically for background jobs)")
+        .action(async (symbol, opts) => {
+        const sym = symbol.toUpperCase();
+        const trailPct = parseFloat(opts.trail);
+        const intervalSec = parseInt(opts.interval);
+        const activationPrice = opts.activation ? parseFloat(opts.activation) : undefined;
+        const adapter = await getAdapter();
+        const log = (msg) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`${chalk.gray(ts)} ${msg}`);
+        };
+        const result = await runTrailingStop(adapter, {
+            symbol: sym,
+            trailPct,
+            intervalSec,
+            activationPrice,
+        }, opts.jobId, log);
+        if (isJson())
+            printJson(jsonOk(result));
+        if (opts.jobId) {
+            updateJobState(opts.jobId, { status: "done" });
+        }
+    });
+}

package/dist/commands/settings.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSettingsCommands(program: Command, isJson: () => boolean): void;

package/dist/commands/settings.js

@@ -0,0 +1,102 @@
+import chalk from "chalk";
+import { printJson, jsonOk, withJsonErrors } from "../utils.js";
+import { loadSettings, saveSettings } from "../settings.js";
+export function registerSettingsCommands(program, isJson) {
+    const settings = program.command("settings").description("CLI settings (referrals, defaults)");
+    // ── settings show ──
+    settings
+        .command("show")
+        .description("Show current settings")
+        .action(async () => {
+        await withJsonErrors(isJson(), async () => {
+            const s = loadSettings();
+            if (isJson())
+                return printJson(jsonOk(s));
+            console.log(chalk.cyan.bold("\n  CLI Settings\n"));
+            console.log(`  Default Exchange: ${s.defaultExchange ? chalk.cyan(s.defaultExchange) : chalk.gray("pacifica (built-in)")}`);
+            console.log(`  Referrals:        ${s.referrals ? chalk.green("ON") : chalk.gray("OFF (opt-in)")}`);
+            console.log(chalk.white.bold("\n  Referral Codes:"));
+            console.log(`    Pacifica:      ${s.referralCodes.pacifica || chalk.gray("(none)")}`);
+            console.log(`    Hyperliquid:   ${s.referralCodes.hyperliquid || chalk.gray("(none)")}`);
+            console.log(`    Lighter:       ${s.referralCodes.lighter || chalk.gray("(none)")}`);
+            console.log(chalk.gray(`\n  Config: ~/.perp/settings.json\n`));
+        });
+    });
+    // ── settings referrals ──
+    settings
+        .command("referrals")
+        .description("Enable or disable referral codes")
+        .argument("<action>", "on | off")
+        .action(async (action) => {
+        await withJsonErrors(isJson(), async () => {
+            const s = loadSettings();
+            if (action === "on") {
+                s.referrals = true;
+                // Reset applied flags so referrals get re-sent on next connection
+                s.referralApplied = { hyperliquid: false, lighter: false };
+                saveSettings(s);
+                if (isJson())
+                    return printJson(jsonOk({ referrals: true }));
+                console.log(chalk.green("\n  Referrals enabled. Codes will be sent on next connection.\n"));
+                if (s.referralCodes.pacifica)
+                    console.log(`  Pacifica builder code: ${s.referralCodes.pacifica}`);
+                if (s.referralCodes.hyperliquid)
+                    console.log(`  Hyperliquid referral:  ${s.referralCodes.hyperliquid}`);
+                if (s.referralCodes.lighter)
+                    console.log(`  Lighter referral:      ${s.referralCodes.lighter}`);
+                console.log();
+            }
+            else if (action === "off") {
+                s.referrals = false;
+                saveSettings(s);
+                if (isJson())
+                    return printJson(jsonOk({ referrals: false }));
+                console.log(chalk.yellow("\n  Referrals disabled. No codes will be sent.\n"));
+            }
+            else {
+                console.error(chalk.red(`\n  Usage: perp settings referrals <on|off>\n`));
+            }
+        });
+    });
+    // ── settings set ──
+    settings
+        .command("set")
+        .description("Set a specific setting")
+        .argument("<key>", "Setting key (e.g. referralCodes.hyperliquid)")
+        .argument("<value>", "Setting value")
+        .action(async (key, value) => {
+        await withJsonErrors(isJson(), async () => {
+            const s = loadSettings();
+            if (key === "default-exchange" || key === "defaultExchange") {
+                const valid = ["pacifica", "hyperliquid", "lighter"];
+                if (!valid.includes(value.toLowerCase())) {
+                    console.error(chalk.red(`  Invalid exchange: ${value}. Use: ${valid.join(", ")}`));
+                    return;
+                }
+                s.defaultExchange = value.toLowerCase();
+            }
+            else if (key === "referrals") {
+                s.referrals = value === "true" || value === "on";
+            }
+            else if (key.startsWith("referralCodes.")) {
+                const exchange = key.split(".")[1];
+                if (exchange in s.referralCodes) {
+                    s.referralCodes[exchange] = value;
+                }
+                else {
+                    console.error(chalk.red(`  Unknown exchange: ${exchange}`));
+                    return;
+                }
+            }
+            else {
+                console.error(chalk.red(`  Unknown key: ${key}`));
+                console.log(chalk.gray("  Valid keys: default-exchange, referrals, referralCodes.pacifica, referralCodes.hyperliquid, referralCodes.lighter\n"));
+                return;
+            }
+            saveSettings(s);
+            if (isJson())
+                return printJson(jsonOk({ key, value }));
+            console.log(chalk.green(`\n  ${key} = ${value}\n`));
+        });
+    });
+}

package/dist/commands/stream.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { type Network } from "../pacifica/index.js";
+import type { Exchange } from "../config.js";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export declare function registerStreamCommands(program: Command, getNetwork: () => Network, getExchange: () => Exchange, getAdapter?: () => Promise<ExchangeAdapter>): void;

package/dist/commands/stream.js

@@ -0,0 +1,123 @@
+import { PacificaWSClient } from "../pacifica/index.js";
+import chalk from "chalk";
+import { formatUsd, formatPercent } from "../utils.js";
+export function registerStreamCommands(program, getNetwork, getExchange, getAdapter) {
+    const stream = program.command("stream").description("Live WebSocket streams (Ctrl+C to stop)");
+    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"));
+        await new Promise(() => { }); // keep alive
+    });
+    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`));
+        await new Promise(() => { });
+    });
+    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`));
+        await new Promise(() => { });
+    });
+    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`));
+        await new Promise(() => { });
+    });
+    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`));
+        await new Promise(() => { });
+    });
+    // ── stream events ── (unified account events as NDJSON)
+    if (getAdapter) {
+        stream
+            .command("events")
+            .description("Stream account events as NDJSON (positions, orders, balance, liquidation warnings)")
+            .option("--interval <ms>", "Polling interval in milliseconds", "5000")
+            .option("--liq-warn <pct>", "Liquidation warning distance %", "10")
+            .option("--log-positions", "Log position lifecycle events to ~/.perp/positions.jsonl")
+            .action(async (opts) => {
+            const adapter = await getAdapter();
+            const { startEventStream } = await import("../event-stream.js");
+            console.error(chalk.cyan(`Streaming ${adapter.name} events... (Ctrl+C to stop)\n`));
+            if (opts.logPositions) {
+                console.error(chalk.gray("  Position logging enabled → ~/.perp/positions.jsonl\n"));
+            }
+            const controller = new AbortController();
+            process.on("SIGINT", () => controller.abort());
+            let onEvent = (event) => {
+                // NDJSON: one JSON per line to stdout
+                process.stdout.write(JSON.stringify(event) + "\n");
+            };
+            if (opts.logPositions) {
+                const { attachPositionLogger } = await import("../position-history.js");
+                onEvent = attachPositionLogger(onEvent);
+            }
+            await startEventStream(adapter, {
+                intervalMs: parseInt(opts.interval),
+                liquidationWarningPct: parseFloat(opts.liqWarn),
+                onEvent,
+                signal: controller.signal,
+            });
+        });
+    }
+}

package/dist/commands/trade.d.ts

@@ -0,0 +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;