@raintree-technology/perps 0.1.0

package/dist/cli/program.js

@@ -0,0 +1,164 @@
+import { createRequire } from "module";
+import { Command } from "commander";
+import { registerCommands } from "../commands/index.js";
+import { loadConfig } from "../lib/config.js";
+import { getAvailableExchanges, setExchange } from "../lib/exchange.js";
+import { getSetting } from "../lib/settings.js";
+import { createContext } from "./context.js";
+import { highlighter, printCommandCompletion, printSessionBanner } from "./experience.js";
+import { commandPathFromCommand, resolveTestnetMode } from "./network-defaults.js";
+import { outputError } from "./output.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+const commandMeta = new WeakMap();
+function findMeta(command) {
+    let current = command;
+    while (current) {
+        const meta = commandMeta.get(current);
+        if (meta)
+            return meta;
+        current = current.parent;
+    }
+    return undefined;
+}
+export function createProgram() {
+    const program = new Command();
+    const availableExchanges = getAvailableExchanges().join(", ");
+    const defaultExchange = getConfiguredDefaultExchange();
+    program
+        .name("perps")
+        .description("Universal CLI for perpetual DEXes")
+        .showSuggestionAfterError(true)
+        .showHelpAfterError()
+        .version(pkg.version)
+        .option("--json", "Output in JSON format", false)
+        .option("--human", "Enable human-first output UX (banner, timing, rich formatting)", false)
+        .option("--no-banner", "Disable session header for human-readable output")
+        .option("--testnet", "Force testnet network")
+        .option("--mainnet", "Force mainnet network")
+        .option("-e, --exchange <name>", `Exchange to use (${availableExchanges})`, defaultExchange)
+        .option("-v, --verbose", "Show detailed output", false)
+        .addHelpText("after", `
+Examples:
+  perps markets ls
+  perps order market buy BTC 0.01 --idempotency-key demo-001
+  perps doctor --network
+`)
+        .hook("preAction", async (thisCommand, actionCommand) => {
+        const invokedCommand = actionCommand ?? thisCommand;
+        const opts = invokedCommand.optsWithGlobals();
+        const commandPath = commandPathFromCommand(invokedCommand);
+        const exchangeNetworkOverride = getExchangeNetworkOverride(opts.exchange);
+        const isHumanMode = opts.human ?? false;
+        const verbose = opts.verbose ?? false;
+        const isTestnet = resolveTestnetMode({
+            argv: process.argv.slice(2),
+            commandPath,
+            exchangeNetworkOverride,
+            fallbackTestnet: getConfiguredTestnetFallback(),
+        });
+        // Set exchange context
+        try {
+            setExchange(opts.exchange);
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            console.error(highlighter.dim(`Available exchanges: ${getAvailableExchanges().join(", ")}`));
+            process.exit(1);
+        }
+        let config;
+        try {
+            config = loadConfig(isTestnet, opts.exchange);
+        }
+        catch (err) {
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+        const context = createContext(config);
+        // Store metadata on the root command
+        commandMeta.set(thisCommand, {
+            context,
+            outputOptions: { json: opts.json },
+            exchange: opts.exchange,
+            isTestnet,
+            commandPath,
+            isHumanMode,
+            verbose,
+            startTime: performance.now(),
+        });
+        if (!opts.json && isHumanMode && opts.banner && commandPath[0] !== "ui") {
+            // Show "ALL" when cross-exchange flags are active
+            const subOpts = invokedCommand.opts();
+            const bannerExchange = subOpts.all || subOpts.report ? "ALL" : opts.exchange;
+            printSessionBanner({
+                version: pkg.version,
+                commandPath,
+                exchange: bannerExchange,
+                isTestnet,
+            });
+        }
+    })
+        .hook("postAction", (thisCommand) => {
+        const meta = commandMeta.get(thisCommand);
+        if (!meta)
+            return;
+        const isJson = meta.outputOptions.json;
+        // Only show timing for non-JSON output
+        if (!isJson && meta.isHumanMode) {
+            const duration = (performance.now() - meta.startTime) / 1000;
+            printCommandCompletion(duration);
+        }
+    });
+    registerCommands(program);
+    return program;
+}
+export function getContext(command) {
+    const meta = findMeta(command);
+    if (meta)
+        return meta.context;
+    throw new Error("Context not found");
+}
+export function getOutputOptions(command) {
+    const meta = findMeta(command);
+    return meta?.outputOptions ?? { json: false };
+}
+export function getSelectedExchange(command) {
+    const meta = findMeta(command);
+    return meta?.exchange ?? "hyperliquid";
+}
+export function getVerbose(command) {
+    const meta = findMeta(command);
+    return meta?.verbose ?? false;
+}
+function getConfiguredDefaultExchange() {
+    try {
+        const configured = getSetting("defaultExchange");
+        return configured?.trim() || "hyperliquid";
+    }
+    catch {
+        return "hyperliquid";
+    }
+}
+function getConfiguredTestnetFallback() {
+    try {
+        return getSetting("testnetByDefault");
+    }
+    catch {
+        return false;
+    }
+}
+function getExchangeNetworkOverride(exchangeId) {
+    const normalized = exchangeId.trim().toLowerCase();
+    const lookup = {
+        hyperliquid: process.env.HYPERLIQUID_NETWORK,
+        decibel: process.env.DECIBEL_NETWORK,
+        aevo: process.env.AEVO_NETWORK,
+        orderly: process.env.ORDERLY_NETWORK,
+        paradex: process.env.PARADEX_NETWORK,
+    };
+    const value = lookup[normalized]?.trim().toLowerCase();
+    if (value === "testnet" || value === "mainnet") {
+        return value;
+    }
+    return undefined;
+}

package/dist/cli/watch.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Utilities for watch mode terminal display
+ */
+/**
+ * Clear terminal screen and move cursor to top-left
+ */
+export declare function clearScreen(): void;
+/**
+ * Hide terminal cursor (also registers signal handlers to restore on exit)
+ */
+export declare function hideCursor(): void;
+/**
+ * Show terminal cursor
+ */
+export declare function showCursor(): void;
+/**
+ * Format current time as HH:MM:SS
+ */
+export declare function formatTimestamp(): string;

package/dist/cli/watch.js

@@ -0,0 +1,35 @@
+/**
+ * Utilities for watch mode terminal display
+ */
+import { registerCursorCleanup } from "./experience.js";
+/**
+ * Clear terminal screen and move cursor to top-left
+ */
+export function clearScreen() {
+    process.stdout.write("\x1b[2J\x1b[H");
+}
+/**
+ * Hide terminal cursor (also registers signal handlers to restore on exit)
+ */
+export function hideCursor() {
+    registerCursorCleanup();
+    process.stdout.write("\x1b[?25l");
+}
+/**
+ * Show terminal cursor
+ */
+export function showCursor() {
+    process.stdout.write("\x1b[?25h");
+}
+/**
+ * Format current time as HH:MM:SS
+ */
+export function formatTimestamp() {
+    const now = new Date();
+    return now.toLocaleTimeString("en-US", {
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+}

package/dist/client/index.d.ts

@@ -0,0 +1,55 @@
+import { AllPerpMetasResponse, SpotMetaResponse } from "@nktkas/hyperliquid";
+import { AllDexsAssetCtxsEvent, SpotAssetCtxsEvent } from "@nktkas/hyperliquid/api/subscription";
+export interface ServerStatus {
+    running: boolean;
+    testnet: boolean;
+    connected: boolean;
+    startedAt: number;
+    uptime: number;
+    cache: {
+        hasMids: boolean;
+        hasAssetCtxs: boolean;
+        hasPerpMetas: boolean;
+        hasSpotMeta: boolean;
+        hasSpotAssetCtxs: boolean;
+        midsAge?: number;
+        assetCtxsAge?: number;
+        perpMetasAge?: number;
+        spotMetaAge?: number;
+        spotAssetCtxsAge?: number;
+    };
+}
+export declare class ServerClient {
+    private socket;
+    private requestId;
+    private pending;
+    private buffer;
+    connect(): Promise<void>;
+    private handleData;
+    private request;
+    getPrices(coin?: string): Promise<{
+        data: Record<string, string>;
+        cached_at: number;
+    }>;
+    getAssetCtxs(): Promise<{
+        data: AllDexsAssetCtxsEvent;
+        cached_at: number;
+    }>;
+    getPerpMeta(): Promise<{
+        data: AllPerpMetasResponse;
+        cached_at: number;
+    }>;
+    getSpotMeta(): Promise<{
+        data: SpotMetaResponse;
+        cached_at: number;
+    }>;
+    getSpotAssetCtxs(): Promise<{
+        data: SpotAssetCtxsEvent;
+        cached_at: number;
+    }>;
+    getStatus(): Promise<ServerStatus>;
+    shutdown(): Promise<void>;
+    close(): void;
+}
+export declare function isServerRunning(): boolean;
+export declare function tryConnectToServer(): Promise<ServerClient | null>;

package/dist/client/index.js

@@ -0,0 +1,157 @@
+import { connect } from "node:net";
+import { existsSync } from "node:fs";
+import { SERVER_SOCKET_PATH } from "../lib/paths.js";
+const IPC_REQUEST_TIMEOUT_MS = 5_000;
+export class ServerClient {
+    socket = null;
+    requestId = 0;
+    pending = new Map();
+    buffer = "";
+    async connect() {
+        if (this.socket)
+            return;
+        return new Promise((resolve, reject) => {
+            const socket = connect(SERVER_SOCKET_PATH);
+            socket.on("connect", () => {
+                this.socket = socket;
+                resolve();
+            });
+            socket.on("error", (err) => {
+                reject(err);
+            });
+            socket.on("data", (data) => {
+                this.handleData(data.toString());
+            });
+            socket.on("close", () => {
+                this.socket = null;
+                // Reject all pending requests
+                for (const pending of this.pending.values()) {
+                    pending.reject(new Error("Connection closed"));
+                }
+                this.pending.clear();
+            });
+        });
+    }
+    handleData(data) {
+        this.buffer += data;
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() || "";
+        for (const line of lines) {
+            if (line.trim()) {
+                try {
+                    const response = JSON.parse(line);
+                    const pending = this.pending.get(response.id);
+                    if (pending) {
+                        this.pending.delete(response.id);
+                        pending.resolve(response);
+                    }
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        }
+    }
+    async request(method, params) {
+        if (!this.socket) {
+            throw new Error("Not connected");
+        }
+        const id = String(++this.requestId);
+        const request = { id, method, params };
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error("Not connected");
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error("Request timeout"));
+                }
+            }, IPC_REQUEST_TIMEOUT_MS);
+            this.pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timeoutId);
+                    resolve(value);
+                },
+                reject: (err) => {
+                    clearTimeout(timeoutId);
+                    reject(err);
+                },
+            });
+            socket.write(JSON.stringify(request) + "\n");
+        });
+    }
+    async getPrices(coin) {
+        const response = await this.request("getPrices", coin ? { coin } : undefined);
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return { data: response.result, cached_at: response.cached_at };
+    }
+    async getAssetCtxs() {
+        const response = await this.request("getAssetCtxs");
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return { data: response.result, cached_at: response.cached_at };
+    }
+    async getPerpMeta() {
+        const response = await this.request("getPerpMeta");
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return { data: response.result, cached_at: response.cached_at };
+    }
+    async getSpotMeta() {
+        const response = await this.request("getSpotMeta");
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return { data: response.result, cached_at: response.cached_at };
+    }
+    async getSpotAssetCtxs() {
+        const response = await this.request("getSpotAssetCtxs");
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return { data: response.result, cached_at: response.cached_at };
+    }
+    async getStatus() {
+        const response = await this.request("getStatus");
+        if (response.error) {
+            throw new Error(response.error);
+        }
+        return response.result;
+    }
+    async shutdown() {
+        const response = await this.request("shutdown");
+        if (response.error) {
+            throw new Error(response.error);
+        }
+    }
+    close() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+}
+// Helper to check if server is running
+export function isServerRunning() {
+    return existsSync(SERVER_SOCKET_PATH);
+}
+// Helper to try connecting to server
+export async function tryConnectToServer() {
+    if (!isServerRunning()) {
+        return null;
+    }
+    try {
+        const client = new ServerClient();
+        await client.connect();
+        return client;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/account/add.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerAddCommand(account: Command): void;