@raintree-technology/perps 0.1.0

package/dist/commands/risk/audit.js

@@ -0,0 +1,52 @@
+import { getOutputOptions } from "../../cli/program.js";
+import { output } from "../../cli/output.js";
+import { withJsonContract } from "../../lib/contracts.js";
+import { queryRiskEvaluations } from "../../lib/risk/evaluation-log.js";
+export function registerRiskAuditCommand(parent) {
+    parent
+        .command("audit")
+        .description("Query risk evaluation log")
+        .option("--market <m>", "Filter by market")
+        .option("--exchange <e>", "Filter by exchange")
+        .option("--denied-only", "Show only denied evaluations")
+        .option("--trace <traceId>", "Filter by trace ID")
+        .option("--limit <n>", "Maximum results to return", Number.parseInt)
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        const evaluations = queryRiskEvaluations({
+            market: opts.market,
+            exchange: opts.exchange,
+            allowed: opts.deniedOnly ? false : undefined,
+            traceId: opts.trace,
+            limit: opts.limit,
+        });
+        if (outputOpts.json) {
+            output(withJsonContract("risk.audit.list", { evaluations }), outputOpts);
+            return;
+        }
+        if (evaluations.length === 0) {
+            console.log("\nNo risk evaluations found.\n");
+            return;
+        }
+        console.log("");
+        for (const ev of evaluations) {
+            const ts = new Date(ev.createdAt).toISOString();
+            const status = ev.allowed ? "ALLOWED" : "DENIED";
+            console.log(`  [${ts}] ${status}`);
+            console.log(`    Exchange: ${ev.exchange}`);
+            if (ev.market)
+                console.log(`    Market:   ${ev.market}`);
+            if (ev.side)
+                console.log(`    Side:     ${ev.side}`);
+            console.log(`    Requested: $${ev.requestedSizeUsd.toFixed(2)}`);
+            if (ev.rulesFired.length > 0) {
+                console.log(`    Rules fired: ${ev.rulesFired.join(", ")}`);
+            }
+            if (ev.reason) {
+                console.log(`    Reason: ${ev.reason}`);
+            }
+            console.log("");
+        }
+    });
+}

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

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

package/dist/commands/risk/index.js

@@ -0,0 +1,9 @@
+import { registerRiskRulesCommands } from "./rules.js";
+import { registerRiskAuditCommand } from "./audit.js";
+import { registerRiskAnalyticsCommands } from "./analytics.js";
+export function registerRiskCommands(program) {
+    const risk = program.command("risk").description("Risk rules, limits, and audit");
+    registerRiskRulesCommands(risk);
+    registerRiskAuditCommand(risk);
+    registerRiskAnalyticsCommands(risk);
+}

package/dist/commands/risk/rules.d.ts

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

package/dist/commands/risk/rules.js

@@ -0,0 +1,102 @@
+import { getOutputOptions } from "../../cli/program.js";
+import { output, outputError, outputSuccess } from "../../cli/output.js";
+import { withJsonContract } from "../../lib/contracts.js";
+import { addRiskRule, listRiskRules, removeRiskRule, } from "../../lib/risk/rules-store.js";
+const VALID_TYPES = [
+    "max_position_size",
+    "max_total_exposure",
+    "max_leverage",
+    "max_drawdown",
+    "min_confidence",
+    "cooldown_after_loss",
+    "rate_limit",
+];
+const VALID_SCOPES = ["global", "exchange", "market", "strategy"];
+export function registerRiskRulesCommands(parent) {
+    const rules = parent.command("rules").description("Manage risk rules");
+    rules
+        .command("ls")
+        .description("List all risk rules")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const allRules = listRiskRules();
+        if (outputOpts.json) {
+            output(withJsonContract("risk.rules.list", { rules: allRules }), outputOpts);
+            return;
+        }
+        if (allRules.length === 0) {
+            console.log("\nNo risk rules configured.\n");
+            return;
+        }
+        const rows = allRules.map((r) => ({
+            ID: r.id,
+            Name: r.name,
+            Type: r.type,
+            Scope: r.scope,
+            "Scope Value": r.scopeValue ?? "",
+            Value: r.value,
+            Enabled: r.enabled ? "yes" : "no",
+        }));
+        output(rows, outputOpts);
+    });
+    rules
+        .command("add")
+        .description("Add a risk rule")
+        .requiredOption("--name <name>", "Rule name")
+        .requiredOption("--type <type>", "Rule type")
+        .requiredOption("--scope <scope>", "Rule scope (global, exchange, market, strategy)")
+        .option("--scope-value <value>", "Scope value (e.g. exchange name, market symbol)")
+        .requiredOption("--value <number>", "Rule threshold value", Number.parseFloat)
+        .option("--disabled", "Create the rule in disabled state")
+        .action(function () {
+        const outputOpts = getOutputOptions(this);
+        const opts = this.opts();
+        if (!VALID_TYPES.includes(opts.type)) {
+            outputError(`Invalid type "${opts.type}". Must be one of: ${VALID_TYPES.join(", ")}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!VALID_SCOPES.includes(opts.scope)) {
+            outputError(`Invalid scope "${opts.scope}". Must be one of: ${VALID_SCOPES.join(", ")}`);
+            process.exitCode = 1;
+            return;
+        }
+        const id = addRiskRule({
+            name: opts.name,
+            type: opts.type,
+            scope: opts.scope,
+            scopeValue: opts.scopeValue ?? null,
+            value: opts.value,
+            enabled: !opts.disabled,
+        });
+        if (outputOpts.json) {
+            output({ success: true, id }, outputOpts);
+            return;
+        }
+        outputSuccess(`Rule added with ID ${id}`);
+    });
+    rules
+        .command("remove <id>")
+        .description("Remove a risk rule by ID")
+        .action(function (id) {
+        const outputOpts = getOutputOptions(this);
+        const numericId = Number.parseInt(id, 10);
+        if (Number.isNaN(numericId)) {
+            outputError("Invalid rule ID");
+            process.exitCode = 1;
+            return;
+        }
+        const removed = removeRiskRule(numericId);
+        if (outputOpts.json) {
+            output({ success: removed, id: numericId }, outputOpts);
+            return;
+        }
+        if (removed) {
+            outputSuccess(`Rule ${numericId} removed`);
+        }
+        else {
+            outputError(`Rule ${numericId} not found`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/server.d.ts

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

package/dist/commands/server.js

@@ -0,0 +1,208 @@
+import { spawn } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { getOutputOptions } from "../cli/program.js";
+import { output, outputError, outputSuccess } from "../cli/output.js";
+import { SERVER_PID_PATH, SERVER_LOG_PATH } from "../lib/paths.js";
+import { ServerClient, isServerRunning } from "../client/index.js";
+export function registerServerCommands(program) {
+    const server = program.command("server").description("Manage the background WebSocket server");
+    server
+        .command("start")
+        .description("Start the background WebSocket server")
+        .action(async function () {
+        const opts = this.optsWithGlobals();
+        const isTestnet = opts.testnet ?? false;
+        // Check if server is already running
+        if (existsSync(SERVER_PID_PATH)) {
+            const pid = parseInt(readFileSync(SERVER_PID_PATH, "utf-8").trim(), 10);
+            try {
+                // Check if process is still alive (signal 0 just checks)
+                process.kill(pid, 0);
+                outputError(`Server is already running (pid: ${pid})`);
+                process.exit(1);
+            }
+            catch {
+                // Process not running, PID file is stale
+            }
+        }
+        // Resolve server entry point for both built (dist) and dev (src) modes.
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const jsServerPath = join(__dirname, "..", "server", "index.js");
+        const tsServerPath = join(__dirname, "..", "server", "index.ts");
+        let spawnCommand = process.execPath;
+        let spawnArgs = [];
+        if (existsSync(jsServerPath)) {
+            spawnArgs = [jsServerPath];
+        }
+        else if (existsSync(tsServerPath)) {
+            // Use local tsx bin for source-mode runs (`pnpm dev`).
+            const tsxBin = join(process.cwd(), "node_modules", ".bin", process.platform === "win32" ? "tsx.cmd" : "tsx");
+            if (existsSync(tsxBin)) {
+                spawnCommand = tsxBin;
+                spawnArgs = [tsServerPath];
+            }
+            else {
+                // Fallback for environments where tsx is available as a node import.
+                spawnArgs = ["--import", "tsx", tsServerPath];
+            }
+        }
+        else {
+            outputError(`Server entry point not found: ${jsServerPath} or ${tsServerPath}`);
+            process.exit(1);
+        }
+        // Spawn server as detached background process
+        if (isTestnet) {
+            spawnArgs.push("--testnet");
+        }
+        const child = spawn(spawnCommand, spawnArgs, {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        // Wait for server to start (poll for socket file, max 10 seconds)
+        const maxWait = 10_000;
+        const pollInterval = 200;
+        let waited = 0;
+        while (waited < maxWait) {
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            waited += pollInterval;
+            if (isServerRunning()) {
+                // Try connecting to verify it's ready
+                try {
+                    const client = new ServerClient();
+                    await client.connect();
+                    await client.getStatus();
+                    client.close();
+                    const network = isTestnet ? "testnet" : "mainnet";
+                    outputSuccess(`Server started (${network})`);
+                    return;
+                }
+                catch {
+                    // Socket exists but server not ready yet, keep waiting
+                }
+            }
+        }
+        outputError(`Failed to start server. Check logs at: ${SERVER_LOG_PATH}`);
+        process.exit(1);
+    });
+    server
+        .command("stop")
+        .description("Stop the background WebSocket server")
+        .action(async function () {
+        if (!isServerRunning()) {
+            outputError("Server is not running, run 'perps server start' to start it");
+            process.exit(1);
+        }
+        try {
+            const client = new ServerClient();
+            await client.connect();
+            await client.shutdown();
+            client.close();
+            // Wait for server to stop
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            if (isServerRunning()) {
+                // Force kill if still running
+                if (existsSync(SERVER_PID_PATH)) {
+                    const pid = parseInt(readFileSync(SERVER_PID_PATH, "utf-8").trim(), 10);
+                    try {
+                        process.kill(pid, "SIGKILL");
+                    }
+                    catch {
+                        // Already dead
+                    }
+                }
+            }
+            outputSuccess("Server stopped");
+        }
+        catch (err) {
+            // Try force kill via PID
+            if (existsSync(SERVER_PID_PATH)) {
+                const pid = parseInt(readFileSync(SERVER_PID_PATH, "utf-8").trim(), 10);
+                try {
+                    process.kill(pid, "SIGTERM");
+                    outputSuccess("Server stopped");
+                    return;
+                }
+                catch {
+                    // Already dead
+                }
+            }
+            outputError(err instanceof Error ? err.message : String(err));
+            process.exit(1);
+        }
+    });
+    server
+        .command("status")
+        .description("Show background server status")
+        .action(async function () {
+        const outputOpts = getOutputOptions(this);
+        if (!isServerRunning()) {
+            if (outputOpts.json) {
+                output({ running: false }, outputOpts);
+            }
+            else {
+                console.log(`Server is not running, run 'perps server start' to start it`);
+            }
+            return;
+        }
+        try {
+            const client = new ServerClient();
+            await client.connect();
+            const status = await client.getStatus();
+            client.close();
+            if (outputOpts.json) {
+                output(status, outputOpts);
+            }
+            else {
+                console.log(`Status:     running`);
+                console.log(`Network:    ${status.testnet ? "testnet" : "mainnet"}`);
+                console.log(`WebSocket:  ${status.connected ? "connected" : "disconnected"}`);
+                console.log(`Uptime:     ${formatUptime(status.uptime)}`);
+                console.log(``);
+                console.log(`Cache:`);
+                console.log(`  Mid Prices:      ${status.cache.hasMids ? `cached (${formatAge(status.cache.midsAge)} ago)` : "not loaded"}`);
+                console.log(`  Perp Meta:   ${status.cache.hasPerpMetas ? `cached (${formatAge(status.cache.perpMetasAge)} ago)` : "not loaded"}`);
+                console.log(`  Perp Asset Ctxs:  ${status.cache.hasAssetCtxs ? `cached (${formatAge(status.cache.assetCtxsAge)} ago)` : "not loaded"}`);
+                console.log(`  Spot Meta:   ${status.cache.hasSpotMeta ? `cached (${formatAge(status.cache.spotMetaAge)} ago)` : "not loaded"}`);
+                console.log(`  Spot Ctxs:   ${status.cache.hasSpotAssetCtxs ? `cached (${formatAge(status.cache.spotAssetCtxsAge)} ago)` : "not loaded"}`);
+            }
+        }
+        catch (err) {
+            // Server might be in bad state
+            if (outputOpts.json) {
+                output({ running: true, error: String(err) }, outputOpts);
+            }
+            else {
+                console.log(`Server appears running but not responding`);
+                console.log(`Try: perps server stop && perps server start`);
+            }
+        }
+    });
+}
+function formatUptime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+function formatAge(ms) {
+    if (ms === undefined)
+        return "unknown";
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    return `${minutes}m ${seconds % 60}s`;
+}

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

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