@getalby/cli 0.6.1 → 0.8.0

package/build/test/pay-crypto.test.js

@@ -0,0 +1,175 @@
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import { spawn } from "child_process";
+import { createServer } from "http";
+// Stand up a local HTTP mock for the Lendaswap API endpoints the CLI hits
+// during validation. The CLI spawns a fresh subprocess per test, so the
+// `LENDASWAP_API_URL` env var (consumed in src/lendaswap/swap.ts) points it
+// at this mock instead of api.satora.io. We only need `/tokens` and
+// `/swap-pairs` — pair validation runs before wallet load, so tests never
+// reach the swap-creation endpoints.
+//
+// IMPORTANT: we use async `spawn`, not the shared `execSync`-based runCli
+// helper. `execSync` blocks the event loop, which would prevent this
+// in-process mock from accepting the subprocess's TCP connection — fetch
+// would just time out.
+let server;
+let mockUrl = "";
+const MOCK_TOKENS = {
+    btc_tokens: [],
+    evm_tokens: [
+        {
+            chain: "42161",
+            decimals: 6,
+            name: "USD Coin",
+            symbol: "USDC",
+            token_id: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+        },
+        {
+            chain: "42161",
+            decimals: 6,
+            name: "Tether USD",
+            symbol: "USDT",
+            token_id: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+        },
+    ],
+};
+// Only the Lightning → 42161 (Arbitrum) pair is enabled in the mock. So
+// USDC/USDT on Arbitrum resolve; the same symbols on any other chain are
+// rejected as unsupported.
+const MOCK_SWAP_PAIRS = {
+    pairs: [
+        {
+            fee_percentage: 0.0025,
+            max_sats: 100_000_000,
+            min_sats: 1000,
+            source: "Lightning",
+            target: "42161",
+        },
+    ],
+};
+beforeAll(async () => {
+    server = createServer((req, res) => {
+        res.setHeader("Content-Type", "application/json");
+        if (req.url === "/tokens") {
+            res.end(JSON.stringify(MOCK_TOKENS));
+        }
+        else if (req.url === "/swap-pairs") {
+            res.end(JSON.stringify(MOCK_SWAP_PAIRS));
+        }
+        else {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: "not found" }));
+        }
+    });
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    const addr = server.address();
+    mockUrl = `http://127.0.0.1:${addr.port}`;
+});
+afterAll(() => new Promise((resolve) => server.close(() => resolve())));
+function runCliAsync(args) {
+    return new Promise((resolve) => {
+        const child = spawn("node", ["build/index.js", ...args.split(" ")], {
+            env: {
+                ...process.env,
+                // Wallet load always fails — exposes the validation gates as the
+                // only thing that can succeed or fail before that point.
+                HOME: "/tmp/nonexistent-alby-cli-test-home",
+                NWC_URL: "",
+                LENDASWAP_API_URL: mockUrl,
+            },
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("close", (code) => {
+            const raw = code === 0 ? stdout : stderr || stdout || "{}";
+            try {
+                resolve({ success: code === 0, output: JSON.parse(raw) });
+            }
+            catch {
+                resolve({ success: code === 0, output: { error: raw } });
+            }
+        });
+    });
+}
+describe("pay-crypto validation", () => {
+    describe("unsupported currency/network combination", () => {
+        test("unknown currency is rejected and lists supported pairs", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency XYZ --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Unsupported currency/network combination");
+            expect(result.output.error).toContain("USDC on Arbitrum");
+        });
+        test("USDC on ethereum is rejected (chain not in swap-pairs)", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency USDC --network ethereum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Unsupported currency/network combination");
+            expect(result.output.error).toContain("USDC on Arbitrum");
+        });
+    });
+    describe("malformed EVM address", () => {
+        test("completely non-hex string is rejected", async () => {
+            const result = await runCliAsync("pay-crypto notanaddress --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("address does not look valid");
+        });
+        test("too-short hex with 0x prefix is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0xabc --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("address does not look valid");
+        });
+        test("40-char hex without 0x prefix is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 000000000000000000000000000000000000dead --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("address does not look valid");
+        });
+    });
+    describe("invalid amount", () => {
+        test("--amount 0 is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 0 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Amount must be a positive number");
+        });
+        test("--amount -1 is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount -1 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Amount must be a positive number");
+        });
+        test("--amount abc (NaN) is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount abc --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Amount must be a positive number");
+        });
+        // Unit-suffixed input must not be truncated to its leading digits
+        // (Number("123usd") is NaN, unlike parseFloat which would yield 123).
+        test("--amount 123usd is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 123usd --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("Amount must be a positive number");
+        });
+    });
+    describe("missing required options", () => {
+        test("missing --currency is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("--currency");
+        });
+        test("missing --network is rejected", async () => {
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency USDC");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("--network");
+        });
+    });
+    describe("happy-path validation", () => {
+        test("valid USDC/arbitrum inputs get past validation and fail only at wallet load", async () => {
+            // The mocked supported list includes USDC on 42161 (Arbitrum), so
+            // findSupportedPair succeeds. With the wallet env disabled, the only
+            // error left is "No wallet connection found" from getClient() —
+            // proof that amount, address, and pair gates all accepted the input.
+            const result = await runCliAsync("pay-crypto 0x000000000000000000000000000000000000dead --amount 10 --currency USDC --network arbitrum");
+            expect(result.success).toBe(false);
+            expect(result.output.error).toContain("No wallet connection found");
+        });
+    });
+});

package/build/test/receive-command.test.js

@@ -0,0 +1,79 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { createTestWallet, runCli } from "./helpers.js";
+describe("receive command — validation", () => {
+    test("--description without --amount is rejected", () => {
+        const result = runCli(`receive --description "hi"`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--description requires --amount");
+    });
+    test("--currency without --amount is rejected", () => {
+        const result = runCli(`receive --currency USD`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency requires --amount");
+    });
+    test("--amount 0 is rejected at parse time", () => {
+        const result = runCli(`receive --amount 0`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Amount must be a positive number");
+    });
+    test("--amount abc (NaN) is rejected at parse time", () => {
+        const result = runCli(`receive --amount abc`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("Amount must be a positive number");
+    });
+    test("--amount without --currency is rejected", () => {
+        const result = runCli(`receive --amount 100 --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--currency");
+    });
+    test("--amount --currency BTC without --unit is rejected", () => {
+        const result = runCli(`receive --amount 100 --currency BTC --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit");
+    });
+    test("--unit on a fiat currency is rejected", () => {
+        const result = runCli(`receive --amount 5 --currency USD --unit sats --network lightning`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("--unit is not valid");
+    });
+    test("a chain network is rejected (invoices are lightning-only)", () => {
+        const result = runCli(`receive --amount 10 --currency USDC --network arbitrum`);
+        expect(result.success).toBe(false);
+        expect(result.output.error).toContain("lightning");
+    });
+});
+describe("receive command — live integration", () => {
+    let wallet;
+    beforeAll(async () => {
+        wallet = await createTestWallet();
+    }, 60000);
+    test("receive (no amount) returns the wallet's lightning address", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive`);
+        expect(result.success).toBe(true);
+        expect(result.output.lightning_address).toBe(wallet.lightningAddress);
+    });
+    test("receive --amount --currency BTC --unit sats returns a BOLT-11 invoice", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 100 --currency BTC --unit sats --network lightning`);
+        expect(result.success).toBe(true);
+        expect(result.output.invoice).toMatch(/^lnbc/i);
+        expect(result.output.amount_in_sats).toBe(100);
+    });
+    test("receive --unit BTC converts to sats", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 0.000001 --currency BTC --unit BTC --network lightning`);
+        expect(result.success).toBe(true);
+        expect(result.output.amount_in_sats).toBe(100);
+    });
+    test("receive --amount --currency USD resolves fiat to sats", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 5 --currency USD --network lightning`);
+        expect(result.success).toBe(true);
+        expect(result.output.invoice).toMatch(/^lnbc/i);
+        expect(result.output.amount_in_sats).toBeGreaterThan(0);
+        expect(result.output.fiat).toEqual({ amount: 5, currency: "USD" });
+    });
+    test("receive --amount --description produces an invoice", () => {
+        const result = runCli(`-c "${wallet.nwcUrl}" receive --amount 100 --currency BTC --unit sats --network lightning --description "test"`);
+        expect(result.success).toBe(true);
+        expect(result.output.invoice).toMatch(/^lnbc/i);
+        expect(result.output.amount_in_sats).toBe(100);
+    });
+});

package/build/tools/lightning/discover.js

@@ -9,7 +9,7 @@ export async function discover(params) {
         url.searchParams.set("health", params.health);
     if (params.sort)
         url.searchParams.set("sort", params.sort);
-    // Filter to BTC (Lightning) services server-side
+    // Filter to BTC (lightning) services server-side
     url.searchParams.set("payment_asset", "BTC");
     url.searchParams.set("limit", String(requestedLimit));
     const controller = new AbortController();

package/build/tools/lightning/fetch.js

@@ -18,7 +18,7 @@ export async function fetch402(client, params) {
     const maxAmountSats = params.maxAmountSats ?? DEFAULT_MAX_AMOUNT_SATS;
     const result = await fetch402Lib(params.url, requestOptions, {
         wallet: client,
-        maxAmount: maxAmountSats || undefined,
+        maxAmount: maxAmountSats,
     });
     const responseContent = await result.text();
     if (!result.ok) {

package/build/utils.js

@@ -1,8 +1,15 @@
 import { NWAClient, NWCClient } from "@getalby/sdk";
 import { getInfo } from "./tools/nwc/get_info.js";
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+export const DEFAULT_RELAY_URLS = [
+    "wss://relay.getalby.com",
+    "wss://relay2.getalby.com",
+];
+export function getAlbyCliDir() {
+    return join(homedir(), ".alby-cli");
+}
 function sanitizeWalletName(name) {
     return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
@@ -10,23 +17,70 @@ export function getConnectionSecretPath(name) {
     const filename = name
         ? `connection-secret-${sanitizeWalletName(name)}.key`
         : "connection-secret.key";
-    return join(homedir(), ".alby-cli", filename);
+    return join(getAlbyCliDir(), filename);
 }
 export function getPendingConnectionSecretPath(name) {
     const filename = name
         ? `pending-connection-secret-${sanitizeWalletName(name)}.key`
         : "pending-connection-secret.key";
-    return join(homedir(), ".alby-cli", filename);
+    return join(getAlbyCliDir(), filename);
 }
 export function getPendingConnectionRelayPath(name) {
     const filename = name
         ? `pending-connection-relay-${sanitizeWalletName(name)}.txt`
         : "pending-connection-relay.txt";
-    return join(homedir(), ".alby-cli", filename);
+    return join(getAlbyCliDir(), filename);
+}
+/**
+ * List configured wallets by scanning ~/.alby-cli for connection secret files.
+ * Never reads or returns secret contents - only wallet names and status.
+ */
+export function listWallets() {
+    const dir = getAlbyCliDir();
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    // Map of wallet name (null for default) -> status. Connected takes precedence
+    // over pending so a re-authed wallet still shows as usable.
+    const wallets = new Map();
+    const patterns = [
+        { regex: /^connection-secret(?:-(.+))?\.key$/, status: "connected" },
+        { regex: /^pending-connection-secret(?:-(.+))?\.key$/, status: "pending" },
+    ];
+    for (const file of files) {
+        for (const { regex, status } of patterns) {
+            const match = file.match(regex);
+            if (!match)
+                continue;
+            const name = match[1] ?? null;
+            if (status === "connected" || !wallets.has(name)) {
+                wallets.set(name, wallets.get(name) === "connected" ? "connected" : status);
+            }
+            break;
+        }
+    }
+    return [...wallets.entries()]
+        .map(([name, status]) => ({
+        name,
+        isDefault: name === null,
+        status,
+    }))
+        .sort((a, b) => {
+        if (a.isDefault !== b.isDefault)
+            return a.isDefault ? -1 : 1;
+        return (a.name ?? "").localeCompare(b.name ?? "");
+    });
 }
 export function saveConnectionSecret(path, secret, verbose) {
     const alreadyExists = existsSync(path);
-    const dir = join(homedir(), ".alby-cli");
+    const dir = getAlbyCliDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
@@ -43,16 +97,20 @@ export async function testAndLogConnection(client) {
     const info = await getInfo(client);
     console.log(`Connected to ${info.alias || "wallet"} (${info.network || "unknown network"})`);
 }
-export async function completePendingConnection(pendingSecretPath, connectionSecretPath, relayUrl, verbose, pendingRelayPath) {
+export async function completePendingConnection(pendingSecretPath, connectionSecretPath, relayUrls, verbose, pendingRelayPath) {
     const secret = readFileSync(pendingSecretPath, "utf-8").trim();
-    const DEFAULT_RELAY = "wss://relay.getalby.com/v1";
-    if (!relayUrl && pendingRelayPath && existsSync(pendingRelayPath)) {
-        relayUrl = readFileSync(pendingRelayPath, "utf-8").trim();
+    if ((!relayUrls || relayUrls.length === 0) &&
+        pendingRelayPath &&
+        existsSync(pendingRelayPath)) {
+        relayUrls = readFileSync(pendingRelayPath, "utf-8")
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
     }
-    const resolvedRelay = relayUrl ?? DEFAULT_RELAY;
+    const resolvedRelays = relayUrls && relayUrls.length > 0 ? relayUrls : DEFAULT_RELAY_URLS;
     const nwaClient = new NWAClient({
         appSecretKey: secret,
-        relayUrls: [resolvedRelay],
+        relayUrls: resolvedRelays,
         requestMethods: [],
     });
     return new Promise((resolve, reject) => {
@@ -117,7 +175,11 @@ export async function getClient(program) {
         }
     }
     if (!connectionSecret) {
-        throw new Error("No connection secret provided. Pass -c <secret or file path>, set NWC_URL, use --wallet-name <name>, or create ~/.alby-cli/connection-secret.key");
+        throw new Error("No wallet connection found. Run 'auth' or 'connect' first to set up a wallet:\n" +
+            "    npx @getalby/cli auth <wallet-url>          # e.g. https://my.albyhub.com\n" +
+            '    npx @getalby/cli connect "nostr+walletconnect://..."\n' +
+            "\n" +
+            "Already have a connection secret? Pass -c <secret or file path>, set NWC_URL, use --wallet-name <name>, or create ~/.alby-cli/connection-secret.key");
     }
     // Auto-detect: if it doesn't start with the protocol, treat as file path
     if (!connectionSecret.startsWith("nostr+walletconnect://")) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@getalby/cli",
   "description": "CLI for Nostr Wallet Connect (NIP-47) with a few additional useful lightning tools",
   "repository": "https://github.com/getAlby/cli.git",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "type": "module",
   "main": "build/index.js",
   "bin": {
@@ -36,8 +36,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@getalby/lightning-tools": "^8.0.0",
-    "@getalby/sdk": "^7.0.0",
+    "@getalby/lightning-tools": "^8.1.1",
+    "@getalby/sdk": "^8.0.1",
+    "@lendasat/lendaswap-sdk-pure": "^0.2.38",
     "@noble/hashes": "^2.0.1",
     "commander": "^14.0.3",
     "nostr-tools": "^2.23.3"