perp-cli 0.3.3

package/dist/commands/init.js

@@ -0,0 +1,266 @@
+import chalk from "chalk";
+import { createInterface } from "readline";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { loadSettings, saveSettings } from "../settings.js";
+const PERP_DIR = resolve(process.env.HOME || "~", ".perp");
+const ENV_FILE = resolve(PERP_DIR, ".env");
+// ── .env helpers ──────────────────────────────────────────────
+export { ENV_FILE, loadEnvFile, setEnvVar };
+function ensurePerpDir() {
+    if (!existsSync(PERP_DIR))
+        mkdirSync(PERP_DIR, { recursive: true, mode: 0o700 });
+}
+function loadEnvFile() {
+    if (!existsSync(ENV_FILE))
+        return {};
+    const lines = readFileSync(ENV_FILE, "utf-8").split("\n");
+    const env = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx > 0) {
+            env[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+        }
+    }
+    return env;
+}
+function writeEnvFile(env) {
+    ensurePerpDir();
+    const lines = [
+        "# perp-cli configuration",
+        "# Generated by 'perp init' — edit freely",
+        "",
+    ];
+    for (const [key, value] of Object.entries(env)) {
+        lines.push(`${key}=${value}`);
+    }
+    lines.push("");
+    writeFileSync(ENV_FILE, lines.join("\n"), { mode: 0o600 });
+}
+function setEnvVar(key, value) {
+    ensurePerpDir();
+    const env = loadEnvFile();
+    env[key] = value;
+    writeEnvFile(env);
+    // Also set in current process
+    process.env[key] = value;
+}
+// ── Interactive helpers ───────────────────────────────────────
+function ask(rl, question) {
+    return new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+}
+function askChoice(rl, question, choices) {
+    return new Promise((resolve) => {
+        const choiceStr = choices.map((c, i) => `${i + 1}) ${c}`).join("  ");
+        rl.question(`${question} [${choiceStr}]: `, (answer) => {
+            const trimmed = answer.trim();
+            const idx = parseInt(trimmed) - 1;
+            if (idx >= 0 && idx < choices.length)
+                return resolve(choices[idx]);
+            const match = choices.find((c) => c.toLowerCase().startsWith(trimmed.toLowerCase()));
+            resolve(match || choices[0]);
+        });
+    });
+}
+// ── Exchange → env var mapping ────────────────────────────────
+export const EXCHANGE_ENV_MAP = {
+    pacifica: { envKey: "PACIFICA_PRIVATE_KEY", chain: "solana", label: "Pacifica (Solana)" },
+    hyperliquid: { envKey: "HL_PRIVATE_KEY", chain: "evm", label: "Hyperliquid (EVM)" },
+    lighter: { envKey: "LIGHTER_PRIVATE_KEY", chain: "evm", label: "Lighter (EVM)" },
+};
+// ── Validate keys ─────────────────────────────────────────────
+export async function validateKey(chain, key) {
+    if (chain === "solana") {
+        try {
+            const { Keypair } = await import("@solana/web3.js");
+            const bs58 = (await import("bs58")).default;
+            try {
+                const kp = Keypair.fromSecretKey(bs58.decode(key));
+                return { valid: true, address: kp.publicKey.toBase58() };
+            }
+            catch {
+                const arr = JSON.parse(key);
+                const kp = Keypair.fromSecretKey(Uint8Array.from(arr));
+                return { valid: true, address: kp.publicKey.toBase58() };
+            }
+        }
+        catch {
+            return { valid: false, address: "" };
+        }
+    }
+    else {
+        try {
+            const { ethers } = await import("ethers");
+            const pk = key.startsWith("0x") ? key : `0x${key}`;
+            return { valid: true, address: new ethers.Wallet(pk).address };
+        }
+        catch {
+            return { valid: false, address: "" };
+        }
+    }
+}
+// ── Commands ──────────────────────────────────────────────────
+export function registerInitCommand(program) {
+    // ── perp init (interactive) ──
+    program
+        .command("init")
+        .description("Interactive setup wizard — configure keys & default exchange")
+        .action(async () => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            console.log(chalk.cyan.bold("\n  perp-cli Setup Wizard\n"));
+            // Show current state
+            const env = loadEnvFile();
+            const configured = [];
+            for (const [exchange, info] of Object.entries(EXCHANGE_ENV_MAP)) {
+                if (env[info.envKey] || process.env[info.envKey]) {
+                    configured.push(exchange);
+                }
+            }
+            if (configured.length > 0) {
+                console.log(chalk.white("  Already configured:"));
+                for (const ex of configured) {
+                    const info = EXCHANGE_ENV_MAP[ex];
+                    const key = env[info.envKey] || process.env[info.envKey] || "";
+                    const masked = key.slice(0, 6) + "..." + key.slice(-4);
+                    console.log(`    ${chalk.cyan(ex.padEnd(14))} ${chalk.gray(masked)}`);
+                }
+                console.log();
+                const action = await askChoice(rl, "  Add/update keys or exit?", ["update", "exit"]);
+                if (action === "exit") {
+                    rl.close();
+                    return;
+                }
+            }
+            // Select exchanges
+            console.log(chalk.white("  Exchanges:"));
+            console.log(`    1) ${chalk.cyan("Pacifica")}    ${chalk.gray("— Solana perps (USDC on Solana)")}`);
+            console.log(`    2) ${chalk.cyan("Hyperliquid")} ${chalk.gray("— EVM perps (USDC on Arbitrum)")}`);
+            console.log(`    3) ${chalk.cyan("Lighter")}     ${chalk.gray("— EVM perps (USDC on Ethereum/Arb)")}`);
+            console.log();
+            const exchangeChoice = await ask(rl, "  Which exchange(s)? (1,2,3 or 'all'): ");
+            const selected = parseExchangeChoice(exchangeChoice);
+            if (selected.length === 0) {
+                console.log(chalk.red("\n  No exchanges selected.\n"));
+                rl.close();
+                return;
+            }
+            // Collect keys per exchange
+            // EVM exchanges can share the same key
+            const evmExchanges = selected.filter((e) => EXCHANGE_ENV_MAP[e].chain === "evm");
+            const solExchanges = selected.filter((e) => EXCHANGE_ENV_MAP[e].chain === "solana");
+            const newEnv = { ...env };
+            if (evmExchanges.length > 0) {
+                console.log(chalk.cyan.bold("\n  EVM Private Key") + chalk.gray(` (for ${evmExchanges.join(", ")})`));
+                // Check if they share one key
+                let sharedKey = "";
+                if (evmExchanges.length > 1) {
+                    const share = await askChoice(rl, "  Use same key for all EVM exchanges?", ["yes", "no"]);
+                    if (share === "yes") {
+                        sharedKey = await ask(rl, "  EVM private key (0x...): ");
+                        const { valid, address } = await validateKey("evm", sharedKey);
+                        if (!valid) {
+                            console.log(chalk.red("  Invalid EVM key."));
+                            rl.close();
+                            return;
+                        }
+                        const normalized = sharedKey.startsWith("0x") ? sharedKey : `0x${sharedKey}`;
+                        console.log(`  ${chalk.green("OK")} ${chalk.gray(address)}`);
+                        for (const ex of evmExchanges) {
+                            newEnv[EXCHANGE_ENV_MAP[ex].envKey] = normalized;
+                        }
+                    }
+                }
+                if (!sharedKey) {
+                    for (const ex of evmExchanges) {
+                        const info = EXCHANGE_ENV_MAP[ex];
+                        const key = await ask(rl, `  ${info.label} private key (0x...): `);
+                        if (!key) {
+                            console.log(chalk.gray("  Skipped."));
+                            continue;
+                        }
+                        const { valid, address } = await validateKey("evm", key);
+                        if (!valid) {
+                            console.log(chalk.red("  Invalid key, skipped."));
+                            continue;
+                        }
+                        const normalized = key.startsWith("0x") ? key : `0x${key}`;
+                        newEnv[info.envKey] = normalized;
+                        console.log(`  ${chalk.green("OK")} ${chalk.gray(address)}`);
+                    }
+                }
+            }
+            if (solExchanges.length > 0) {
+                console.log(chalk.cyan.bold("\n  Solana Private Key") + chalk.gray(" (for Pacifica)"));
+                const key = await ask(rl, "  Solana private key (base58): ");
+                if (key) {
+                    const { valid, address } = await validateKey("solana", key);
+                    if (valid) {
+                        newEnv.PACIFICA_PRIVATE_KEY = key;
+                        console.log(`  ${chalk.green("OK")} ${chalk.gray(address)}`);
+                    }
+                    else {
+                        console.log(chalk.red("  Invalid Solana key, skipped."));
+                    }
+                }
+            }
+            // Default exchange
+            const settings = loadSettings();
+            if (selected.length === 1) {
+                settings.defaultExchange = selected[0];
+            }
+            else if (!settings.defaultExchange) {
+                const defaultEx = await askChoice(rl, "\n  Default exchange?", selected);
+                settings.defaultExchange = defaultEx;
+            }
+            saveSettings(settings);
+            // Write .env
+            writeEnvFile(newEnv);
+            // Summary
+            console.log(chalk.cyan.bold("\n  Setup Complete!\n"));
+            console.log(`  Config:   ${chalk.gray("~/.perp/.env")}`);
+            console.log(`  Default:  ${chalk.cyan(settings.defaultExchange || selected[0])}`);
+            for (const ex of selected) {
+                const info = EXCHANGE_ENV_MAP[ex];
+                const key = newEnv[info.envKey];
+                if (key) {
+                    console.log(`  ${chalk.cyan(ex.padEnd(14))} ${chalk.green("configured")}`);
+                }
+            }
+            console.log(chalk.white.bold("\n  Next steps:"));
+            console.log(`    ${chalk.green("perp status")}                     account overview`);
+            if (selected.includes("hyperliquid")) {
+                console.log(`    ${chalk.green("perp deposit hyperliquid <amt>")}   deposit USDC`);
+            }
+            if (selected.includes("pacifica")) {
+                console.log(`    ${chalk.green("perp deposit pacifica <amt>")}      deposit USDC`);
+            }
+            console.log(`    ${chalk.green("perp market list")}                 browse markets`);
+            console.log(`    ${chalk.green("perp dashboard")}                   live monitoring\n`);
+            rl.close();
+        }
+        catch (err) {
+            rl.close();
+            throw err;
+        }
+    });
+}
+function parseExchangeChoice(input) {
+    const lower = input.toLowerCase().trim();
+    if (lower === "all" || lower === "1,2,3")
+        return ["pacifica", "hyperliquid", "lighter"];
+    const exchanges = [];
+    const parts = lower.split(/[,\s]+/);
+    for (const p of parts) {
+        if (p === "1" || p.startsWith("pac"))
+            exchanges.push("pacifica");
+        else if (p === "2" || p.startsWith("hyp") || p === "hl")
+            exchanges.push("hyperliquid");
+        else if (p === "3" || p.startsWith("lig") || p === "lt")
+            exchanges.push("lighter");
+    }
+    return [...new Set(exchanges)];
+}

package/dist/commands/jobs.d.ts

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

package/dist/commands/jobs.js

@@ -0,0 +1,133 @@
+import { listJobs, stopJob, removeJob, loadJob, logFile } from "../jobs.js";
+import { printJson, jsonOk } from "../utils.js";
+import chalk from "chalk";
+import { existsSync, readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+export function registerJobsCommands(program, isJson) {
+    const jobs = program.command("jobs").description("Background job management (tmux)");
+    jobs
+        .command("list", { isDefault: true })
+        .description("List all jobs")
+        .action(() => {
+        const all = listJobs();
+        if (isJson())
+            return printJson(jsonOk(all));
+        if (all.length === 0) {
+            console.log(chalk.gray("\n  No jobs.\n"));
+            return;
+        }
+        console.log(chalk.cyan.bold("\n  Background Jobs\n"));
+        for (const j of all) {
+            const statusColor = j.status === "running" ? chalk.green : j.status === "error" ? chalk.red : chalk.gray;
+            const elapsed = j.status === "running"
+                ? ` (${formatElapsed(Date.now() - new Date(j.startedAt).getTime())})`
+                : "";
+            console.log(`  ${chalk.white.bold(j.id)}  ${statusColor(j.status.padEnd(8))} ` +
+                `${chalk.cyan(j.strategy.padEnd(14))} ` +
+                `${chalk.gray(j.exchange.padEnd(12))} ` +
+                `${chalk.gray(new Date(j.startedAt).toLocaleString())}${elapsed}`);
+            // Show result summary if available
+            if (j.result) {
+                const r = j.result;
+                if (r.pctComplete !== undefined) {
+                    console.log(chalk.gray(`         Progress: ${r.pctComplete}% | Filled: ${r.filled}/${(Number(r.filled) + Number(r.remaining)).toFixed(4)}`));
+                }
+                else if (r.activePositions !== undefined) {
+                    console.log(chalk.gray(`         Positions: ${r.activePositions} | Cycle: ${r.cycle}`));
+                }
+            }
+        }
+        console.log();
+    });
+    jobs
+        .command("stop <id>")
+        .description("Stop a running job")
+        .action((id) => {
+        const job = loadJob(id);
+        if (!job) {
+            console.log(chalk.red(`\n  Job ${id} not found.\n`));
+            return;
+        }
+        stopJob(id);
+        if (isJson())
+            return printJson(jsonOk({ id, status: "stopped" }));
+        console.log(chalk.green(`\n  Job ${id} stopped.\n`));
+    });
+    jobs
+        .command("logs <id>")
+        .description("Show logs for a job")
+        .option("-f, --follow", "Follow log output (tail -f)")
+        .option("-n, --lines <n>", "Number of lines to show", "50")
+        .action((id, opts) => {
+        const log = logFile(id);
+        if (!existsSync(log)) {
+            console.log(chalk.gray(`\n  No logs for job ${id}.\n`));
+            return;
+        }
+        if (opts.follow) {
+            // Attach to tmux session if running, otherwise tail -f
+            const job = loadJob(id);
+            if (job?.status === "running") {
+                try {
+                    execSync(`tmux attach-session -t ${job.tmuxSession}`, { stdio: "inherit" });
+                    return;
+                }
+                catch { /* fall through to tail */ }
+            }
+            try {
+                execSync(`tail -f ${log}`, { stdio: "inherit" });
+            }
+            catch { /* ctrl-c */ }
+        }
+        else {
+            const content = readFileSync(log, "utf-8");
+            const lines = content.split("\n");
+            const n = parseInt(opts.lines);
+            const show = lines.slice(-n).join("\n");
+            console.log(show);
+        }
+    });
+    jobs
+        .command("remove <id>")
+        .description("Remove a job entry and its logs")
+        .action((id) => {
+        const job = loadJob(id);
+        if (!job) {
+            console.log(chalk.red(`\n  Job ${id} not found.\n`));
+            return;
+        }
+        if (job.status === "running") {
+            stopJob(id);
+        }
+        removeJob(id);
+        if (isJson())
+            return printJson(jsonOk({ id, removed: true }));
+        console.log(chalk.green(`\n  Job ${id} removed.\n`));
+    });
+    jobs
+        .command("clean")
+        .description("Remove all stopped/done jobs")
+        .action(() => {
+        const all = listJobs();
+        let removed = 0;
+        for (const j of all) {
+            if (j.status !== "running") {
+                removeJob(j.id);
+                removed++;
+            }
+        }
+        if (isJson())
+            return printJson(jsonOk({ removed }));
+        console.log(chalk.green(`\n  Removed ${removed} finished jobs.\n`));
+    });
+}
+function formatElapsed(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${s % 60}s`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${m % 60}m`;
+}

package/dist/commands/manage.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import type { ExchangeAdapter } from "../exchanges/interface.js";
+import { PacificaAdapter } from "../exchanges/pacifica.js";
+export declare function registerManageCommands(program: Command, getAdapter: () => Promise<ExchangeAdapter>, isJson: () => boolean, getPacificaAdapter: () => PacificaAdapter): void;