@token2chat/t2c 0.2.0-beta.1 → 0.2.0

package/dist/commands/monitor.d.ts

@@ -0,0 +1,51 @@
+/** Mint /stats response shape */
+export interface MintStats {
+    totalMintedSats: number;
+    totalMeltedSats: number;
+    mintCount: number;
+    meltCount: number;
+}
+/** Gate /stats response summary shape */
+export interface GateStatsSummary {
+    total_requests: number;
+    success_count: number;
+    error_count: number;
+    ecash_received: number;
+    model_breakdown: Record<string, {
+        count: number;
+        ecash_in: number;
+        errors: number;
+    }>;
+    error_breakdown: Record<string, number>;
+}
+export interface GateStats {
+    generated_at: string;
+    today: GateStatsSummary;
+    last_7_days: GateStatsSummary;
+}
+/**
+ * Fetch Gate statistics from the /stats endpoint.
+ * Returns null on error (network, parse, etc).
+ */
+export declare function fetchGateStats(gateUrl: string): Promise<GateStats | null>;
+/**
+ * Fetch Mint statistics from the /stats endpoint.
+ * Returns null on error (network, parse, etc).
+ */
+export declare function fetchMintStats(mintUrl: string): Promise<MintStats | null>;
+/**
+ * Format sats with thousands separators.
+ */
+export declare function formatSats(sats: number): string;
+/**
+ * Build proxy panel content from transaction history.
+ */
+export declare function buildProxyContent(maxLines: number, maxWidth: number): Promise<string>;
+export interface MonitorOptions {
+    refresh?: string;
+}
+/**
+ * Create and run the TUI monitor dashboard.
+ * Layout: 2x2 grid with Gate, Mint, Proxy, Funds panels.
+ */
+export declare function monitorCommand(opts: MonitorOptions): Promise<void>;

package/dist/commands/monitor.js

@@ -0,0 +1,353 @@
+/**
+ * t2c monitor — Live TUI dashboard
+ *
+ * Real-time monitoring of Gate, Mint, Proxy, and Funds.
+ * Uses blessed-contrib for terminal UI.
+ */
+import blessed from "blessed";
+import contrib from "blessed-contrib";
+import { loadConfig, resolveHome, loadTransactions, formatUnits } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+/**
+ * Fetch Gate statistics from the /stats endpoint.
+ * Returns null on error (network, parse, etc).
+ */
+export async function fetchGateStats(gateUrl) {
+    try {
+        const res = await fetch(`${gateUrl}/stats`, { signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetch Mint statistics from the /stats endpoint.
+ * Returns null on error (network, parse, etc).
+ */
+export async function fetchMintStats(mintUrl) {
+    try {
+        const res = await fetch(`${mintUrl}/stats`, { signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Format sats with thousands separators.
+ */
+export function formatSats(sats) {
+    return sats.toLocaleString("en-US");
+}
+/**
+ * Format a transaction record for TUI display.
+ */
+function formatTransaction(tx, maxWidth) {
+    const time = new Date(tx.timestamp).toLocaleTimeString("en-US", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    });
+    // Status indicator with color
+    const statusIcon = tx.error
+        ? "{red-fg}✗{/red-fg}"
+        : tx.gateStatus === 200
+            ? "{green-fg}✓{/green-fg}"
+            : `{yellow-fg}${tx.gateStatus}{/yellow-fg}`;
+    // Cost display
+    const cost = formatUnits(tx.priceSat).padStart(8);
+    // Truncate model name to fit available space
+    const modelMaxLen = Math.max(10, maxWidth - 26);
+    const model = tx.model.length > modelMaxLen
+        ? tx.model.slice(0, modelMaxLen - 2) + ".."
+        : tx.model;
+    return `  ${time} ${statusIcon} ${cost} ${model}`;
+}
+/**
+ * Build proxy panel content from transaction history.
+ */
+export async function buildProxyContent(maxLines, maxWidth) {
+    const transactions = await loadTransactions();
+    if (transactions.length === 0) {
+        return "{center}No transactions yet{/center}\n\n" +
+            "  Run requests through the proxy\n" +
+            "  to see activity here.";
+    }
+    // Show most recent first
+    const recent = transactions.slice().reverse();
+    // Calculate summary stats
+    const totalSpent = transactions.reduce((s, t) => s + t.priceSat, 0);
+    const totalChange = transactions.reduce((s, t) => s + t.changeSat, 0);
+    const errorCount = transactions.filter((t) => t.error).length;
+    const netCost = totalSpent - totalChange;
+    const lines = [
+        `  Requests: ${transactions.length} | Spent: ${formatUnits(netCost)}`,
+        errorCount > 0
+            ? `  {red-fg}Errors: ${errorCount}{/red-fg}`
+            : `  {green-fg}All OK{/green-fg}`,
+        "  " + "─".repeat(Math.min(36, maxWidth - 4)),
+    ];
+    // Add recent transactions (leave room for header)
+    const displayCount = Math.min(recent.length, Math.max(1, maxLines - 5));
+    for (let i = 0; i < displayCount; i++) {
+        lines.push(formatTransaction(recent[i], maxWidth));
+    }
+    if (recent.length > displayCount) {
+        lines.push(`  ... +${recent.length - displayCount} more`);
+    }
+    return lines.join("\n");
+}
+/** Low balance threshold for warning highlight */
+const LOW_BALANCE_THRESHOLD = 500;
+/** Default refresh interval in milliseconds */
+const DEFAULT_REFRESH_MS = 5000;
+/**
+ * Create and run the TUI monitor dashboard.
+ * Layout: 2x2 grid with Gate, Mint, Proxy, Funds panels.
+ */
+export async function monitorCommand(opts) {
+    // Parse refresh interval
+    const refreshMs = opts.refresh
+        ? parseInt(opts.refresh, 10) * 1000
+        : DEFAULT_REFRESH_MS;
+    // Create the main screen
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: "t2c monitor",
+        fullUnicode: true,
+    });
+    // Create a 2x2 grid layout
+    const grid = new contrib.grid({
+        rows: 2,
+        cols: 2,
+        screen: screen,
+    });
+    // ── Gate Panel (top-left) ──
+    const gateBox = grid.set(0, 0, 1, 1, blessed.box, {
+        label: " Gate ",
+        border: { type: "line" },
+        style: {
+            border: { fg: "cyan" },
+            label: { fg: "cyan", bold: true },
+        },
+        content: "{center}Loading...{/center}",
+        tags: true,
+    });
+    // ── Mint Panel (top-right) ──
+    const mintBox = grid.set(0, 1, 1, 1, blessed.box, {
+        label: " Mint ",
+        border: { type: "line" },
+        style: {
+            border: { fg: "green" },
+            label: { fg: "green", bold: true },
+        },
+        content: "{center}Loading...{/center}",
+        tags: true,
+    });
+    // ── Proxy Panel (bottom-left) ──
+    const proxyBox = grid.set(1, 0, 1, 1, blessed.box, {
+        label: " Proxy ",
+        border: { type: "line" },
+        style: {
+            border: { fg: "yellow" },
+            label: { fg: "yellow", bold: true },
+        },
+        content: "{center}Loading...{/center}",
+        tags: true,
+    });
+    // ── Funds Panel (bottom-right) ──
+    const fundsBox = grid.set(1, 1, 1, 1, blessed.box, {
+        label: " Funds ",
+        border: { type: "line" },
+        style: {
+            border: { fg: "magenta" },
+            label: { fg: "magenta", bold: true },
+        },
+        content: "{center}Loading...{/center}",
+        tags: true,
+    });
+    // Status bar at the bottom
+    const statusBar = blessed.box({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        width: "100%",
+        height: 1,
+        style: {
+            bg: "blue",
+            fg: "white",
+        },
+        content: ` t2c monitor | q: quit | r: refresh | interval: ${refreshMs / 1000}s `,
+        tags: true,
+    });
+    // Reference to refresh timer for cleanup
+    let refreshTimer = null;
+    // Key bindings for clean exit
+    screen.key(["escape", "q", "C-c"], () => {
+        cleanup();
+    });
+    // Refresh key
+    screen.key(["r"], () => {
+        updatePanels();
+    });
+    // Cleanup function
+    function cleanup() {
+        if (refreshTimer) {
+            clearInterval(refreshTimer);
+            refreshTimer = null;
+        }
+        screen.destroy();
+        process.exit(0);
+    }
+    // Handle process signals for clean exit
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    // Panel update function
+    async function updatePanels() {
+        const now = new Date().toLocaleTimeString();
+        // Calculate available lines for proxy panel (rough estimate)
+        const panelHeight = Math.floor(screen.height / 2) - 3;
+        const panelWidth = Math.floor(screen.width / 2) - 4;
+        // Load config for panel updates
+        const config = await loadConfig();
+        // Update Gate panel with stats
+        await updateGatePanel(gateBox, config.gateUrl, now);
+        // Update Mint panel with stats
+        const mintStats = await fetchMintStats(config.mintUrl);
+        if (mintStats) {
+            const netFlow = mintStats.totalMintedSats - mintStats.totalMeltedSats;
+            const netFlowColor = netFlow >= 0 ? "green-fg" : "red-fg";
+            const netFlowSign = netFlow >= 0 ? "+" : "";
+            mintBox.setContent(`{center}Mint Statistics{/center}\n\n` +
+                `  {bold}Minted:{/bold}  ${formatUnits(mintStats.totalMintedSats)} (${mintStats.mintCount} ops)\n` +
+                `  {bold}Melted:{/bold}  ${formatUnits(mintStats.totalMeltedSats)} (${mintStats.meltCount} ops)\n` +
+                `  {bold}Net:{/bold}     {${netFlowColor}}${netFlowSign}${formatUnits(netFlow)}{/${netFlowColor}}\n\n` +
+                `{right}Updated: ${now}{/right}`);
+        }
+        else {
+            mintBox.setContent(`{center}Mint Statistics{/center}\n\n` +
+                `  {red-fg}●{/red-fg} Unable to fetch stats\n` +
+                `  URL: ${config.mintUrl}\n\n` +
+                `{right}Updated: ${now}{/right}`);
+        }
+        // Update Proxy panel with real transaction data
+        try {
+            const proxyContent = await buildProxyContent(panelHeight, panelWidth);
+            proxyBox.setContent(proxyContent + `\n\n{right}${now}{/right}`);
+        }
+        catch (err) {
+            proxyBox.setContent(`{center}Proxy Events{/center}\n\n` +
+                `  {red-fg}Error loading transactions{/red-fg}\n` +
+                `  ${err instanceof Error ? err.message : String(err)}\n\n` +
+                `{right}${now}{/right}`);
+        }
+        // Update Funds panel with wallet balance and fund flow statistics
+        await updateFundsPanel(fundsBox, now);
+        screen.render();
+    }
+    /** Update the Funds panel with wallet balance and fund flow statistics */
+    async function updateFundsPanel(box, now) {
+        try {
+            const config = await loadConfig();
+            const walletPath = resolveHome(config.walletPath);
+            // Load wallet and transactions in parallel
+            const [store, transactions] = await Promise.all([
+                CashuStore.load(walletPath, config.mintUrl),
+                loadTransactions(),
+            ]);
+            const balance = store.balance;
+            const proofCount = store.proofCount;
+            // Calculate fund flow statistics from transactions
+            const totalSpent = transactions.reduce((s, t) => s + t.priceSat, 0);
+            const totalChange = transactions.reduce((s, t) => s + t.changeSat, 0);
+            const totalRefund = transactions.reduce((s, t) => s + t.refundSat, 0);
+            const netCost = totalSpent - totalChange - totalRefund;
+            // Format balance with low balance warning
+            const balanceColor = balance < LOW_BALANCE_THRESHOLD ? "red" : "green";
+            const balanceWarning = balance < LOW_BALANCE_THRESHOLD ? " {red-fg}⚠ LOW{/red-fg}" : "";
+            const balanceStr = `{${balanceColor}-fg}${formatUnits(balance)}{/${balanceColor}-fg}${balanceWarning}`;
+            box.setContent(`{center}Wallet Funds{/center}\n\n` +
+                `  Balance: ${balanceStr}\n` +
+                `  Proofs:  ${proofCount}\n\n` +
+                `  {bold}Fund Flow{/bold}\n` +
+                `  Spent:   ${formatUnits(totalSpent)}\n` +
+                `  Change:  +${formatUnits(totalChange)}\n` +
+                `  Refund:  +${formatUnits(totalRefund)}\n` +
+                `  Net:     ${formatUnits(netCost)}\n\n` +
+                `{right}Updated: ${now}{/right}`);
+        }
+        catch (err) {
+            box.setContent(`{center}Wallet Funds{/center}\n\n` +
+                `  {red-fg}Error loading wallet{/red-fg}\n` +
+                `  ${err instanceof Error ? err.message : String(err)}\n\n` +
+                `{right}Updated: ${now}{/right}`);
+        }
+    }
+    /** Update the Gate panel with stats from /stats endpoint */
+    async function updateGatePanel(box, gateUrl, now) {
+        const stats = await fetchGateStats(gateUrl);
+        if (!stats) {
+            box.setContent(`{center}Gate Statistics{/center}\n\n` +
+                `  Status: {red-fg}●{/red-fg} Unreachable\n` +
+                `  URL: ${gateUrl}\n\n` +
+                `{right}Updated: ${now}{/right}`);
+            return;
+        }
+        const today = stats.today;
+        const week = stats.last_7_days;
+        // Format error count with red highlight if > 0
+        const todayErrors = today.error_count > 0
+            ? `{red-fg}${today.error_count}{/red-fg}`
+            : `${today.error_count}`;
+        const weekErrors = week.error_count > 0
+            ? `{red-fg}${week.error_count}{/red-fg}`
+            : `${week.error_count}`;
+        // Calculate success rate
+        const todayRate = today.total_requests > 0
+            ? ((today.success_count / today.total_requests) * 100).toFixed(1)
+            : "100.0";
+        const weekRate = week.total_requests > 0
+            ? ((week.success_count / week.total_requests) * 100).toFixed(1)
+            : "100.0";
+        // Build content
+        let content = `{center}Gate Statistics{/center}\n\n`;
+        content += `  {bold}Today{/bold}\n`;
+        content += `  Total: ${formatSats(today.total_requests)}  `;
+        content += `OK: ${formatSats(today.success_count)}  `;
+        content += `Err: ${todayErrors}\n`;
+        content += `  Rate: ${todayRate}%  `;
+        content += `Ecash: ${formatUnits(today.ecash_received)}\n\n`;
+        content += `  {bold}Last 7 Days{/bold}\n`;
+        content += `  Total: ${formatSats(week.total_requests)}  `;
+        content += `OK: ${formatSats(week.success_count)}  `;
+        content += `Err: ${weekErrors}\n`;
+        content += `  Rate: ${weekRate}%  `;
+        content += `Ecash: ${formatUnits(week.ecash_received)}\n`;
+        // Show error breakdown if any errors today
+        if (today.error_count > 0 && Object.keys(today.error_breakdown).length > 0) {
+            content += `\n  {bold}{red-fg}Errors Today{/red-fg}{/bold}\n`;
+            for (const [code, count] of Object.entries(today.error_breakdown)) {
+                content += `  {red-fg}• ${code}: ${count}{/red-fg}\n`;
+            }
+        }
+        content += `\n{right}Updated: ${now}{/right}`;
+        box.setContent(content);
+    }
+    // Initial render
+    await updatePanels();
+    screen.render();
+    // Set up auto-refresh
+    refreshTimer = setInterval(() => {
+        updatePanels().catch(() => {
+            // Ignore refresh errors, will retry next interval
+        });
+    }, refreshMs);
+}

package/dist/commands/recover.js

@@ -1,7 +1,7 @@
 /**
  * t2c recover - Recover failed tokens
  */
-import { loadConfig, resolveHome, FAILED_TOKENS_PATH, loadFailedTokens, saveFailedTokens, } from "../config.js";
+import { loadConfig, resolveHome, FAILED_TOKENS_PATH, loadFailedTokens, saveFailedTokens, formatUnits, } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 export async function recoverCommand() {
     const config = await loadConfig();
@@ -30,7 +30,7 @@ export async function recoverCommand() {
         console.log(`Attempting to recover ${ft.type} token from ${date}...`);
         try {
             const amount = await wallet.receiveToken(ft.token);
-            console.log(`  ✅ Recovered ${amount} sat\n`);
+            console.log(`  ✅ Recovered ${formatUnits(amount)}\n`);
             recoveredTotal += amount;
         }
         catch (e) {
@@ -47,8 +47,8 @@ export async function recoverCommand() {
     await saveFailedTokens({ tokens: stillFailed });
     console.log("─".repeat(40));
     if (recoveredTotal > 0) {
-        console.log(`\n🎉 Recovered total: ${recoveredTotal.toLocaleString()} sat`);
-        console.log(`New wallet balance: ${wallet.balance.toLocaleString()} sat\n`);
+        console.log(`\n🎉 Recovered total: ${formatUnits(recoveredTotal)}`);
+        console.log(`New wallet balance: ${formatUnits(wallet.balance)}\n`);
     }
     if (stillFailed.length > 0) {
         console.log(`\n⚠️  ${stillFailed.length} token(s) still failed.`);

package/dist/commands/setup.js

@@ -2,7 +2,7 @@
  * t2c setup - Interactive setup wizard
  */
 import * as readline from "node:readline";
-import { loadConfig, saveConfig, configExists, resolveHome, checkGateHealth, checkMintHealth, DEFAULT_CONFIG, } from "../config.js";
+import { loadConfig, saveConfig, configExists, resolveHome, checkGateHealth, checkMintHealth, DEFAULT_CONFIG, formatUnits, } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 function createPrompt() {
     return readline.createInterface({
@@ -106,7 +106,7 @@ export async function setupCommand() {
         try {
             const resolvedPath = resolveHome(walletPath);
             const wallet = await CashuStore.load(resolvedPath, mintUrl);
-            console.log(`✅ Wallet initialized (balance: ${wallet.balance} sat)`);
+            console.log(`✅ Wallet initialized (balance: ${formatUnits(wallet.balance)})`);
         }
         catch (e) {
             console.log(`⚠️  Failed to initialize wallet: ${e}`);

package/dist/commands/status.js

@@ -1,7 +1,7 @@
 /**
  * t2c status - Show service status and wallet balance
  */
-import { loadConfig, resolveHome, configExists, checkGateHealth } from "../config.js";
+import { loadConfig, resolveHome, configExists, checkGateHealth, formatUnits } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 async function checkProxy(port) {
     try {
@@ -70,9 +70,8 @@ export async function statusCommand(opts) {
     // Wallet
     console.log("");
     if (walletInfo) {
-        const balanceStr = walletInfo.balance.toLocaleString();
         const status = walletInfo.balance > 0 ? "✅" : "⚠️";
-        console.log(`Wallet:     ${status} ${balanceStr} sat (${walletInfo.proofs} proofs)`);
+        console.log(`Wallet:     ${status} ${formatUnits(walletInfo.balance)} (${walletInfo.proofs} proofs)`);
         if (walletInfo.balance === 0) {
             console.log(`            Run 't2c mint' to add funds`);
         }

package/dist/config.d.ts

@@ -30,6 +30,11 @@ export declare function configExists(): Promise<boolean>;
 /**
  * Custom error classes for better error handling
  */
+/**
+ * Format units (1 unit = $0.00001) as USD string.
+ * 100000 units = $1.00
+ */
+export declare function formatUnits(units: number): string;
 export declare class ConfigError extends Error {
     readonly recoverable: boolean;
     constructor(message: string, recoverable?: boolean);

package/dist/config.js

@@ -128,6 +128,23 @@ export async function configExists() {
 /**
  * Custom error classes for better error handling
  */
+/**
+ * Format units (1 unit = $0.00001) as USD string.
+ * 100000 units = $1.00
+ */
+export function formatUnits(units) {
+    const dollars = units / 100000;
+    if (dollars >= 1 || dollars === 0) {
+        return "$" + dollars.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+    }
+    // For sub-dollar: show enough decimal places to be meaningful
+    const str = dollars.toFixed(5).replace(/0+$/, "");
+    // Ensure at least 2 decimal places
+    const parts = str.split(".");
+    const decimals = parts[1] || "";
+    const padded = decimals.length < 2 ? decimals.padEnd(2, "0") : decimals;
+    return "$" + parts[0] + "." + padded;
+}
 export class ConfigError extends Error {
     recoverable;
     constructor(message, recoverable = false) {

package/dist/connectors/cursor.js

@@ -1,28 +1,57 @@
+/**
+ * Cursor Connector
+ *
+ * Detects Cursor IDE installation and provides configuration instructions.
+ */
+import { accessSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+function detectCursorInstallation() {
+    const home = homedir();
+    const plat = platform();
+    const candidates = [];
+    if (plat === "darwin") {
+        candidates.push(join(home, "Library", "Application Support", "Cursor"));
+    }
+    else if (plat === "win32") {
+        const appData = process.env.APPDATA;
+        if (appData)
+            candidates.push(join(appData, "Cursor"));
+    }
+    else {
+        // Linux and others
+        candidates.push(join(home, ".config", "Cursor"));
+    }
+    for (const p of candidates) {
+        try {
+            accessSync(p);
+            return true;
+        }
+        catch {
+            // not found
+        }
+    }
+    return false;
+}
 export const cursorConnector = {
     id: "cursor",
     name: "Cursor",
-    description: "Configure Cursor IDE (coming soon)",
+    description: "Configure Cursor IDE for Token2Chat",
     async detect() {
-        // TODO: Detect Cursor installation
-        // Could check for:
-        // - ~/Library/Application Support/Cursor (macOS)
-        // - ~/.config/Cursor (Linux)
-        // - %APPDATA%\Cursor (Windows)
-        return false;
+        return detectCursorInstallation();
     },
     async connect(_config) {
-        console.log("\n🎟️  Cursor Integration\n");
-        console.log("   Cursor connector coming soon!\n");
-        console.log("   In the meantime, you can configure Cursor manually:\n");
+        console.log("\n  Cursor Integration\n");
+        console.log("   Configure Cursor manually:\n");
         console.log("   1. Open Cursor Settings (Cmd/Ctrl + ,)");
-        console.log("   2. Set OpenAI Base URL:");
+        console.log("   2. Search for 'OpenAI Base URL' and set:");
         console.log(`      http://127.0.0.1:${_config.proxyPort}/v1\n`);
-        console.log("   3. Set OpenAI API Key:");
-        console.log("      ecash-proxy\n");
-        console.log("   4. Use model:");
+        console.log("   3. Set 'OpenAI API Key' to your proxy secret:");
+        console.log("      (find it with: t2c status --json)\n");
+        console.log("   4. Use any model from the Gate, e.g.:");
         console.log("      anthropic/claude-sonnet-4\n");
     },
     async verify() {
-        return false;
+        return detectCursorInstallation();
     },
 };

package/dist/index.js

@@ -16,6 +16,7 @@ import { recoverCommand } from "./commands/recover.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { balanceCommand } from "./commands/balance.js";
 import { auditCommand } from "./commands/audit.js";
+import { monitorCommand } from "./commands/monitor.js";
 // debug command is loaded dynamically — excluded from npm package
 const program = new Command();
 program
@@ -108,6 +109,12 @@ program
     .option("--json", "Output as JSON")
     .option("-n, --lines <n>", "Number of recent transactions to show", "20")
     .action(auditCommand);
+// t2c monitor - Live TUI dashboard
+program
+    .command("monitor")
+    .description("Live TUI dashboard for Gate, Mint, Proxy, and Funds")
+    .option("-r, --refresh <seconds>", "Refresh interval in seconds", "5")
+    .action(monitorCommand);
 // t2c config - Generate config for AI tools
 const config = program
     .command("config")
@@ -168,7 +175,7 @@ try {
     debug
         .command("topup")
         .description("Transfer ecash from Gate to local plugin wallet")
-        .requiredOption("--amount <sats>", "Amount in sats to withdraw from Gate")
+        .requiredOption("--amount <units>", "Amount in units to withdraw from Gate")
         .action((opts) => debugCommand("topup", opts));
 }
 catch {

package/dist/proxy/auth.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Request-like object with authorization header.
+ */
+export interface AuthRequest {
+    headers: {
+        authorization?: string;
+    };
+}
+/**
+ * Function that checks if a request is authenticated.
+ */
+export type AuthChecker = (req: AuthRequest) => boolean;
+/**
+ * Create an auth checker function for Bearer token authentication.
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param secret - The expected Bearer token value
+ * @returns A function that returns true if the request has a valid Bearer token
+ */
+export declare function createAuthChecker(secret: string): AuthChecker;

package/dist/proxy/auth.js

@@ -0,0 +1,28 @@
+/**
+ * Authentication middleware for proxy requests.
+ * Uses timing-safe comparison to prevent timing attacks.
+ */
+import crypto from "node:crypto";
+/**
+ * Create an auth checker function for Bearer token authentication.
+ * Uses timing-safe comparison to prevent timing attacks.
+ *
+ * @param secret - The expected Bearer token value
+ * @returns A function that returns true if the request has a valid Bearer token
+ */
+export function createAuthChecker(secret) {
+    return (req) => {
+        const auth = req.headers.authorization;
+        if (!auth)
+            return false;
+        const parts = auth.split(" ");
+        if (parts.length !== 2 || parts[0] !== "Bearer")
+            return false;
+        const provided = Buffer.from(parts[1]);
+        const expected = Buffer.from(secret);
+        // Length check before timing-safe comparison
+        if (provided.length !== expected.length)
+            return false;
+        return crypto.timingSafeEqual(provided, expected);
+    };
+}