perp-cli 0.3.3

package/dist/strategies/trailing-stop.js

@@ -0,0 +1,121 @@
+import { updateJobState } from "../jobs.js";
+import { logExecution } from "../execution-log.js";
+export async function runTrailingStop(adapter, params, jobId, log = console.log) {
+    const { symbol, trailPct } = params;
+    const intervalMs = (params.intervalSec ?? 5) * 1000;
+    const activationPrice = params.activationPrice;
+    const startedAt = Date.now();
+    // Auto-detect position side
+    const positions = await adapter.getPositions();
+    const pos = positions.find(p => {
+        const c = p.symbol.toUpperCase();
+        const t = symbol.toUpperCase();
+        return c === t || c === `${t}-PERP` || c.replace(/-PERP$/, "") === t;
+    });
+    if (!pos) {
+        log(`[TRAIL] No open position for ${symbol}. Exiting.`);
+        return { triggered: false, reason: "no_position", runtime: 0 };
+    }
+    const positionSide = pos.side;
+    const closeSide = positionSide === "long" ? "sell" : "buy";
+    const posSize = pos.size;
+    log(`[TRAIL] ${symbol} ${positionSide} ${posSize} | Trail: ${trailPct}%${activationPrice ? ` | Activation: $${activationPrice}` : ""}`);
+    let peakPrice = 0;
+    let activated = !activationPrice;
+    let running = true;
+    const cleanup = () => { running = false; };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    if (jobId) {
+        updateJobState(jobId, {
+            status: "running",
+            result: { symbol, positionSide, trailPct, activationPrice },
+        });
+    }
+    try {
+        while (running) {
+            const markets = await adapter.getMarkets();
+            const market = markets.find(m => {
+                const c = m.symbol.toUpperCase();
+                const t = symbol.toUpperCase();
+                return c === t || c === `${t}-PERP` || c.replace(/-PERP$/, "") === t;
+            });
+            if (!market) {
+                log(`[TRAIL] Market data for ${symbol} not found, retrying...`);
+                await new Promise(r => setTimeout(r, intervalMs));
+                continue;
+            }
+            const currentPrice = parseFloat(market.markPrice);
+            // Check activation
+            if (!activated && activationPrice) {
+                if (positionSide === "long" && currentPrice >= activationPrice) {
+                    activated = true;
+                    log(`[TRAIL] Activated at $${currentPrice.toFixed(2)} (>= $${activationPrice})`);
+                }
+                else if (positionSide === "short" && currentPrice <= activationPrice) {
+                    activated = true;
+                    log(`[TRAIL] Activated at $${currentPrice.toFixed(2)} (<= $${activationPrice})`);
+                }
+                else {
+                    log(`[TRAIL] $${currentPrice.toFixed(2)} | Waiting for activation ($${activationPrice})...`);
+                    await new Promise(r => setTimeout(r, intervalMs));
+                    continue;
+                }
+            }
+            if (positionSide === "long") {
+                if (currentPrice > peakPrice)
+                    peakPrice = currentPrice;
+                const dropPct = peakPrice > 0 ? ((peakPrice - currentPrice) / peakPrice) * 100 : 0;
+                log(`[TRAIL] $${currentPrice.toFixed(2)} | Peak: $${peakPrice.toFixed(2)} | Drop: ${dropPct.toFixed(2)}%`);
+                if (dropPct >= trailPct) {
+                    log(`[TRAIL] TRIGGERED! Price dropped ${dropPct.toFixed(2)}% from peak $${peakPrice.toFixed(2)}`);
+                    log(`[TRAIL] Closing ${positionSide} ${posSize} ${symbol}...`);
+                    await adapter.marketOrder(symbol, closeSide, posSize);
+                    logExecution({
+                        type: "market_order", exchange: adapter.name, symbol,
+                        side: closeSide, size: posSize, status: "success", dryRun: false,
+                        meta: { action: "trailing-stop", trailPct, peakPrice, triggerPrice: currentPrice },
+                    });
+                    return {
+                        triggered: true, reason: "triggered",
+                        peakPrice, triggerPrice: currentPrice, changePct: dropPct,
+                        positionSide, runtime: (Date.now() - startedAt) / 1000,
+                    };
+                }
+            }
+            else {
+                // Short: track trough, trigger on rise
+                if (peakPrice === 0 || currentPrice < peakPrice)
+                    peakPrice = currentPrice;
+                const risePct = peakPrice > 0 ? ((currentPrice - peakPrice) / peakPrice) * 100 : 0;
+                log(`[TRAIL] $${currentPrice.toFixed(2)} | Trough: $${peakPrice.toFixed(2)} | Rise: ${risePct.toFixed(2)}%`);
+                if (risePct >= trailPct) {
+                    log(`[TRAIL] TRIGGERED! Price rose ${risePct.toFixed(2)}% from trough $${peakPrice.toFixed(2)}`);
+                    log(`[TRAIL] Closing ${positionSide} ${posSize} ${symbol}...`);
+                    await adapter.marketOrder(symbol, closeSide, posSize);
+                    logExecution({
+                        type: "market_order", exchange: adapter.name, symbol,
+                        side: closeSide, size: posSize, status: "success", dryRun: false,
+                        meta: { action: "trailing-stop", trailPct, troughPrice: peakPrice, triggerPrice: currentPrice },
+                    });
+                    return {
+                        triggered: true, reason: "triggered",
+                        peakPrice, triggerPrice: currentPrice, changePct: risePct,
+                        positionSide, runtime: (Date.now() - startedAt) / 1000,
+                    };
+                }
+            }
+            await new Promise(r => setTimeout(r, intervalMs));
+        }
+    }
+    finally {
+        process.removeListener("SIGINT", cleanup);
+        process.removeListener("SIGTERM", cleanup);
+    }
+    return {
+        triggered: false, reason: "cancelled",
+        peakPrice: peakPrice || undefined,
+        positionSide,
+        runtime: (Date.now() - startedAt) / 1000,
+    };
+}

package/dist/strategies/twap.d.ts

@@ -0,0 +1,20 @@
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+export interface TWAPParams {
+    symbol: string;
+    side: "buy" | "sell";
+    totalSize: number;
+    durationSec: number;
+    slices?: number;
+    maxSlippage?: number;
+}
+export interface TWAPState {
+    filled: number;
+    remaining: number;
+    slicesDone: number;
+    totalSlices: number;
+    avgPrice: number;
+    errors: number;
+    startedAt: number;
+    lastSliceAt: number;
+}
+export declare function runTWAP(adapter: ExchangeAdapter, params: TWAPParams, jobId?: string, log?: (msg: string) => void): Promise<TWAPState>;

package/dist/strategies/twap.js

@@ -0,0 +1,78 @@
+import { updateJobState } from "../jobs.js";
+export async function runTWAP(adapter, params, jobId, log = console.log) {
+    const totalSlices = params.slices || Math.max(Math.floor(params.durationSec / 30), 2);
+    const sliceSize = params.totalSize / totalSlices;
+    const intervalMs = (params.durationSec * 1000) / totalSlices;
+    const state = {
+        filled: 0,
+        remaining: params.totalSize,
+        slicesDone: 0,
+        totalSlices,
+        avgPrice: 0,
+        errors: 0,
+        startedAt: Date.now(),
+        lastSliceAt: 0,
+    };
+    log(`[TWAP] ${params.side.toUpperCase()} ${params.totalSize} ${params.symbol} over ${params.durationSec}s`);
+    log(`[TWAP] ${totalSlices} slices, ${sliceSize.toFixed(6)} per slice, ${(intervalMs / 1000).toFixed(1)}s interval`);
+    log(`[TWAP] Exchange: ${adapter.name}`);
+    let totalCost = 0;
+    for (let i = 0; i < totalSlices; i++) {
+        if (i > 0) {
+            await sleep(intervalMs);
+        }
+        const thisSlice = i === totalSlices - 1
+            ? state.remaining // Last slice: fill whatever remains (avoid rounding dust)
+            : sliceSize;
+        if (thisSlice <= 0)
+            break;
+        try {
+            log(`[TWAP] Slice ${i + 1}/${totalSlices}: ${params.side} ${thisSlice.toFixed(6)} ${params.symbol}...`);
+            const result = await adapter.marketOrder(params.symbol, params.side, String(thisSlice));
+            state.slicesDone++;
+            state.filled += thisSlice;
+            state.remaining = params.totalSize - state.filled;
+            state.lastSliceAt = Date.now();
+            // Try to extract fill price from result
+            const fillPrice = Number(result?.price ?? result?.avg_price ?? result?.fill_price ?? 0);
+            if (fillPrice > 0) {
+                totalCost += thisSlice * fillPrice;
+                state.avgPrice = totalCost / state.filled;
+            }
+            const pct = ((state.filled / params.totalSize) * 100).toFixed(1);
+            log(`[TWAP] Filled ${state.filled.toFixed(6)}/${params.totalSize} (${pct}%)${state.avgPrice > 0 ? ` avg $${state.avgPrice.toFixed(4)}` : ""}`);
+            // Update job state file if running as background job
+            if (jobId) {
+                updateJobState(jobId, {
+                    result: {
+                        filled: state.filled,
+                        remaining: state.remaining,
+                        slicesDone: state.slicesDone,
+                        totalSlices: state.totalSlices,
+                        avgPrice: state.avgPrice,
+                        pctComplete: parseFloat(pct),
+                    },
+                });
+            }
+        }
+        catch (err) {
+            state.errors++;
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`[TWAP] Slice ${i + 1} error: ${msg}`);
+            // Continue — don't abort the whole TWAP for one failed slice
+            if (state.errors > totalSlices * 0.5) {
+                log(`[TWAP] Too many errors (${state.errors}/${totalSlices}), aborting.`);
+                break;
+            }
+        }
+    }
+    const elapsed = ((Date.now() - state.startedAt) / 1000).toFixed(1);
+    log(`[TWAP] Complete. Filled ${state.filled.toFixed(6)} in ${elapsed}s, ${state.errors} errors.`);
+    if (jobId) {
+        updateJobState(jobId, { status: "done", result: { ...state } });
+    }
+    return state;
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/trade-validator.d.ts

@@ -0,0 +1,39 @@
+import type { ExchangeAdapter } from "./exchanges/interface.js";
+export interface CheckResult {
+    check: "symbol_valid" | "balance_sufficient" | "price_fresh" | "liquidity_ok" | "risk_limits" | "position_exists";
+    passed: boolean;
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface TradeValidation {
+    valid: boolean;
+    checks: CheckResult[];
+    warnings: string[];
+    estimatedCost?: {
+        margin: number;
+        fee: number;
+        slippage: number;
+        total: number;
+    };
+    marketInfo?: {
+        symbol: string;
+        markPrice: number;
+        fundingRate: number;
+        maxLeverage: number;
+    };
+    timestamp: string;
+}
+export interface TradeCheckParams {
+    symbol: string;
+    side: "buy" | "sell";
+    size: number;
+    price?: number;
+    type?: "market" | "limit" | "stop";
+    leverage?: number;
+    reduceOnly?: boolean;
+}
+/**
+ * Validate a trade before execution.
+ * Runs multiple checks in parallel where possible.
+ */
+export declare function validateTrade(adapter: ExchangeAdapter, params: TradeCheckParams): Promise<TradeValidation>;

package/dist/trade-validator.js

@@ -0,0 +1,154 @@
+import { symbolMatch } from "./utils.js";
+const DEFAULT_TAKER_FEE = 0.0005; // 0.05%
+const DEFAULT_MAX_SLIPPAGE = 0.005; // 0.5%
+/**
+ * Validate a trade before execution.
+ * Runs multiple checks in parallel where possible.
+ */
+export async function validateTrade(adapter, params) {
+    const checks = [];
+    const warnings = [];
+    const sym = params.symbol.toUpperCase();
+    // Fetch market data, balance, positions, orderbook in parallel
+    const [markets, balance, positions, orderbook] = await Promise.all([
+        adapter.getMarkets().catch(() => []),
+        adapter.getBalance().catch(() => ({ equity: "0", available: "0", marginUsed: "0", unrealizedPnl: "0" })),
+        adapter.getPositions().catch(() => []),
+        params.type !== "limit" ? adapter.getOrderbook(sym).catch(() => ({ bids: [], asks: [] })) : Promise.resolve({ bids: [], asks: [] }),
+    ]);
+    // 1. Symbol validity (handle BTC vs BTC-PERP suffix variants)
+    const market = markets.find(m => {
+        const ms = m.symbol.toUpperCase();
+        return ms === sym || ms === `${sym}-PERP` || ms.replace(/-PERP$/, "") === sym;
+    });
+    if (market) {
+        checks.push({ check: "symbol_valid", passed: true, message: `${sym} found on ${adapter.name}`, details: { maxLeverage: market.maxLeverage } });
+    }
+    else {
+        checks.push({ check: "symbol_valid", passed: false, message: `${sym} not found on ${adapter.name}` });
+        return { valid: false, checks, warnings, timestamp: new Date().toISOString() };
+    }
+    const markPrice = Number(market.markPrice);
+    const price = params.price ?? markPrice;
+    const notional = params.size * price;
+    const leverage = params.leverage ?? market.maxLeverage;
+    const marginRequired = notional / leverage;
+    // 2. Balance check
+    const available = Number(balance.available);
+    if (params.reduceOnly) {
+        // reduce-only doesn't need margin
+        checks.push({ check: "balance_sufficient", passed: true, message: "Reduce-only order, no margin needed" });
+    }
+    else if (available >= marginRequired) {
+        checks.push({ check: "balance_sufficient", passed: true, message: `Available $${available.toFixed(2)} >= margin required $${marginRequired.toFixed(2)}`, details: { available, marginRequired, leverage } });
+    }
+    else {
+        checks.push({ check: "balance_sufficient", passed: false, message: `Insufficient balance: $${available.toFixed(2)} available, $${marginRequired.toFixed(2)} required at ${leverage}x`, details: { available, marginRequired, leverage } });
+    }
+    // 3. Price freshness (if mark price is way off from input price for limits)
+    if (params.price && markPrice > 0) {
+        const deviation = Math.abs(params.price - markPrice) / markPrice;
+        if (deviation > 0.10) {
+            checks.push({ check: "price_fresh", passed: false, message: `Price $${params.price} deviates ${(deviation * 100).toFixed(1)}% from mark $${markPrice.toFixed(2)}`, details: { price: params.price, markPrice, deviationPct: deviation * 100 } });
+        }
+        else if (deviation > 0.03) {
+            checks.push({ check: "price_fresh", passed: true, message: `Price deviation ${(deviation * 100).toFixed(1)}% from mark` });
+            warnings.push(`Price $${params.price} is ${(deviation * 100).toFixed(1)}% from mark price $${markPrice.toFixed(2)}`);
+        }
+        else {
+            checks.push({ check: "price_fresh", passed: true, message: "Price within normal range of mark" });
+        }
+    }
+    else {
+        checks.push({ check: "price_fresh", passed: true, message: markPrice > 0 ? `Mark price: $${markPrice.toFixed(2)}` : "No mark price to compare" });
+    }
+    // 4. Liquidity check (market orders)
+    if (params.type !== "limit" && orderbook.bids.length > 0) {
+        const book = params.side === "buy" ? orderbook.asks : orderbook.bids;
+        let availableLiquidity = 0;
+        let worstPrice = 0;
+        for (const [px, sz] of book) {
+            availableLiquidity += Number(px) * Number(sz);
+            worstPrice = Number(px);
+            if (availableLiquidity >= notional)
+                break;
+        }
+        if (availableLiquidity >= notional) {
+            const slippage = markPrice > 0 ? Math.abs(worstPrice - markPrice) / markPrice : 0;
+            if (slippage > DEFAULT_MAX_SLIPPAGE) {
+                checks.push({ check: "liquidity_ok", passed: false, message: `Slippage ${(slippage * 100).toFixed(2)}% exceeds ${(DEFAULT_MAX_SLIPPAGE * 100).toFixed(1)}% threshold`, details: { slippagePct: slippage * 100, worstPrice, liquidityUsd: availableLiquidity } });
+            }
+            else {
+                checks.push({ check: "liquidity_ok", passed: true, message: `Sufficient liquidity ($${availableLiquidity.toFixed(0)}), slippage ~${(slippage * 100).toFixed(3)}%`, details: { slippagePct: slippage * 100, liquidityUsd: availableLiquidity } });
+            }
+        }
+        else {
+            checks.push({ check: "liquidity_ok", passed: false, message: `Insufficient liquidity: $${availableLiquidity.toFixed(0)} available vs $${notional.toFixed(0)} needed`, details: { liquidityUsd: availableLiquidity, notional } });
+        }
+    }
+    else {
+        checks.push({ check: "liquidity_ok", passed: true, message: "Liquidity check skipped (limit order or no book data)" });
+    }
+    // 5. Risk limits (use existing risk system)
+    try {
+        const { assessRisk, preTradeCheck } = await import("./risk.js");
+        const assessment = assessRisk([{ exchange: adapter.name, balance }], positions.map(p => ({ exchange: adapter.name, position: p })));
+        const riskResult = preTradeCheck(assessment, notional, leverage);
+        if (riskResult.allowed) {
+            checks.push({ check: "risk_limits", passed: true, message: "Within risk limits" });
+        }
+        else {
+            checks.push({ check: "risk_limits", passed: false, message: `Risk violation: ${riskResult.reason}`, details: { reason: riskResult.reason } });
+        }
+        // Surface non-critical violations from the assessment as warnings
+        for (const v of assessment.violations) {
+            if (v.severity !== "critical") {
+                warnings.push(`${v.rule}: ${v.message}`);
+            }
+        }
+    }
+    catch {
+        checks.push({ check: "risk_limits", passed: true, message: "Risk check skipped (no limits configured)" });
+    }
+    // 6. Position check (for reduce-only)
+    if (params.reduceOnly) {
+        const pos = positions.find(p => symbolMatch(p.symbol, sym));
+        if (pos) {
+            const posSize = parseFloat(pos.size);
+            if (params.size > posSize) {
+                checks.push({ check: "position_exists", passed: false, message: `Reduce size ${params.size} exceeds position ${posSize}`, details: { positionSize: posSize, reduceSize: params.size } });
+            }
+            else {
+                checks.push({ check: "position_exists", passed: true, message: `Position exists: ${pos.side} ${pos.size}`, details: { side: pos.side, size: posSize } });
+            }
+        }
+        else {
+            checks.push({ check: "position_exists", passed: false, message: `No position found for ${sym} (reduce-only requires open position)` });
+        }
+    }
+    // Estimated cost
+    const fee = notional * DEFAULT_TAKER_FEE;
+    const estimatedSlippage = params.type === "limit" ? 0 : notional * 0.001;
+    const valid = checks.every(c => c.passed);
+    if (leverage > market.maxLeverage) {
+        warnings.push(`Requested leverage ${leverage}x exceeds max ${market.maxLeverage}x`);
+    }
+    return {
+        valid,
+        checks,
+        warnings,
+        estimatedCost: {
+            margin: marginRequired,
+            fee,
+            slippage: estimatedSlippage,
+            total: marginRequired + fee + estimatedSlippage,
+        },
+        marketInfo: {
+            symbol: sym,
+            markPrice,
+            fundingRate: Number(market.fundingRate),
+            maxLeverage: market.maxLeverage,
+        },
+        timestamp: new Date().toISOString(),
+    };
+}

package/dist/utils.d.ts

@@ -0,0 +1,38 @@
+export declare function symbolMatch(candidate: string, target: string): boolean;
+export declare function formatUsd(value: string | number): string;
+export declare function formatPnl(value: string | number): string;
+export declare function formatPercent(value: string | number): string;
+export declare function makeTable(head: string[], rows: string[][]): string;
+export declare function printJson(data: unknown): void;
+export declare function errorAndExit(msg: string): never;
+/** Standard JSON response envelope */
+export interface ApiResponse<T = unknown> {
+    ok: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+        status?: number;
+        retryable?: boolean;
+        retryAfterMs?: number;
+        details?: Record<string, unknown>;
+    };
+    meta?: {
+        exchange?: string;
+        timestamp: string;
+        duration_ms?: number;
+    };
+}
+/** Wrap successful result in standard envelope */
+export declare function jsonOk<T>(data: T, meta?: Partial<ApiResponse['meta']>): ApiResponse<T>;
+/** Wrap error in standard envelope */
+export declare function jsonError(code: string, message: string, meta?: Partial<ApiResponse['meta']> & {
+    status?: number;
+    retryable?: boolean;
+    retryAfterMs?: number;
+    details?: Record<string, unknown>;
+}): ApiResponse<never>;
+/** Execute a command action with structured error handling.
+ *  In JSON mode, errors are returned as JSON instead of crashing.
+ */
+export declare function withJsonErrors<T>(isJson: boolean, fn: () => Promise<T>, exchange?: string): Promise<T | undefined>;

package/dist/utils.js

@@ -0,0 +1,110 @@
+import Table from "cli-table3";
+import chalk from "chalk";
+import { classifyError } from "./errors.js";
+export function symbolMatch(candidate, target) {
+    const c = candidate.toUpperCase();
+    const t = target.toUpperCase();
+    return c === t || c === `${t}-PERP` || c.replace(/-PERP$/, "") === t;
+}
+export function formatUsd(value) {
+    const num = Number(value);
+    if (isNaN(num))
+        return String(value);
+    return num.toLocaleString("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+}
+export function formatPnl(value) {
+    const num = Number(value);
+    if (isNaN(num))
+        return String(value);
+    const formatted = formatUsd(Math.abs(num));
+    if (num > 0)
+        return chalk.green(`+$${formatted}`);
+    if (num < 0)
+        return chalk.red(`-$${formatted}`);
+    return `$${formatted}`;
+}
+export function formatPercent(value) {
+    const num = Number(value);
+    if (isNaN(num))
+        return String(value);
+    const pct = (num * 100).toFixed(4);
+    const prefix = num > 0 ? "+" : "";
+    const color = num > 0 ? chalk.green : num < 0 ? chalk.red : chalk.white;
+    return color(`${prefix}${pct}%`);
+}
+export function makeTable(head, rows) {
+    const table = new Table({
+        head: head.map((h) => chalk.cyan.bold(h)),
+        style: { head: [], border: [] },
+        chars: {
+            top: "─", "top-mid": "┬", "top-left": "┌", "top-right": "┐",
+            bottom: "─", "bottom-mid": "┴", "bottom-left": "└", "bottom-right": "┘",
+            left: "│", "left-mid": "├",
+            mid: "─", "mid-mid": "┼",
+            right: "│", "right-mid": "┤",
+            middle: "│",
+        },
+    });
+    rows.forEach((r) => table.push(r));
+    return table.toString();
+}
+export function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export function errorAndExit(msg) {
+    if (process.argv.includes("--json")) {
+        console.log(JSON.stringify(jsonError("INVALID_PARAMS", msg)));
+    }
+    else {
+        console.error(chalk.red(`Error: ${msg}`));
+    }
+    process.exit(1);
+}
+/** Wrap successful result in standard envelope */
+export function jsonOk(data, meta) {
+    return {
+        ok: true,
+        data,
+        meta: { timestamp: new Date().toISOString(), ...meta },
+    };
+}
+/** Wrap error in standard envelope */
+export function jsonError(code, message, meta) {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+            ...(meta?.status !== undefined ? { status: meta.status } : {}),
+            ...(meta?.retryable !== undefined ? { retryable: meta.retryable } : {}),
+            ...(meta?.retryAfterMs !== undefined ? { retryAfterMs: meta.retryAfterMs } : {}),
+            ...(meta?.details ? { details: meta.details } : {}),
+        },
+        meta: { timestamp: new Date().toISOString(), ...meta },
+    };
+}
+/** Execute a command action with structured error handling.
+ *  In JSON mode, errors are returned as JSON instead of crashing.
+ */
+export async function withJsonErrors(isJson, fn, exchange) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        const classified = classifyError(err, exchange);
+        if (isJson) {
+            console.log(JSON.stringify(jsonError(classified.code, classified.message, {
+                status: classified.status,
+                retryable: classified.retryable,
+                retryAfterMs: classified.retryAfterMs,
+            })));
+        }
+        else {
+            console.error(chalk.red(`Error: ${classified.message}`));
+        }
+        return undefined;
+    }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "perp-cli",
+  "version": "0.3.3",
+  "description": "Multi-DEX Perpetual Futures CLI - Pacifica, Hyperliquid, Lighter",
+  "bin": {
+    "perp": "./dist/index.js",
+    "perp-mcp": "./dist/mcp-server.js"
+  },
+  "files": [
+    "dist",
+    "skills"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run --exclude '**/integration/**'",
+    "test:integration": "vitest run '**/*.integration.test.ts'",
+    "test:all": "vitest run",
+    "prepublishOnly": "pnpm run build"
+  },
+  "keywords": [
+    "pacifica",
+    "hyperliquid",
+    "lighter",
+    "solana",
+    "perps",
+    "dex",
+    "cli",
+    "trading",
+    "funding-rate",
+    "arbitrage"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": "^20.0.0 || ^22.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@msgpack/msgpack": "^3.1.3",
+    "@solana/web3.js": "^1.98.0",
+    "bs58": "^6.0.0",
+    "chalk": "^5.4.1",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "dotenv": "^16.5.0",
+    "ethers": "^6.13.2",
+    "hyperliquid": "^1.7.7",
+    "lighter-sdk": "^0.0.17",
+    "tweetnacl": "^1.0.3",
+    "ws": "^8.19.0",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  }
+}