@token2chat/t2c 0.2.0-beta.1

package/dist/cashu-store.js

@@ -0,0 +1,201 @@
+/**
+ * CashuStore — Cashu ecash proof management.
+ *
+ * Single source of truth for proof storage, selection, encoding,
+ * and mint interactions.
+ */
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { CashuMint, CashuWallet, MintQuoteState, getEncodedTokenV4, } from "@cashu/cashu-ts";
+/**
+ * Simple async mutex to prevent concurrent wallet operations.
+ * Protects against double-spend and data loss from overlapping read-modify-write cycles.
+ */
+class Mutex {
+    _queue = [];
+    _locked = false;
+    async lock(fn) {
+        const release = await this._acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    _acquire() {
+        return new Promise((resolve) => {
+            const tryAcquire = () => {
+                if (!this._locked) {
+                    this._locked = true;
+                    resolve(() => {
+                        this._locked = false;
+                        const next = this._queue.shift();
+                        if (next)
+                            next();
+                    });
+                }
+                else {
+                    this._queue.push(tryAcquire);
+                }
+            };
+            tryAcquire();
+        });
+    }
+}
+export class CashuStore {
+    path;
+    data;
+    wallet = null;
+    mutex = new Mutex();
+    constructor(path, data) {
+        this.path = path;
+        this.data = data;
+    }
+    // ── Getters ────────────────────────────────────────────────
+    get mint() {
+        return this.data.mint;
+    }
+    get balance() {
+        return this.data.proofs.reduce((s, p) => s + p.amount, 0);
+    }
+    get proofCount() {
+        return this.data.proofs.length;
+    }
+    // ── Load / Save ────────────────────────────────────────────
+    /** Load from file, or create new empty store */
+    static async load(path, mint) {
+        try {
+            const raw = await readFile(path, "utf-8");
+            const data = JSON.parse(raw);
+            return new CashuStore(path, data);
+        }
+        catch {
+            const data = {
+                mint: mint ?? "https://mint.token2chat.com",
+                unit: "sat",
+                proofs: [],
+            };
+            const store = new CashuStore(path, data);
+            await store.save();
+            return store;
+        }
+    }
+    /** Persist to file */
+    async save() {
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        await writeFile(this.path, JSON.stringify(this.data, null, 2), { mode: 0o600 });
+    }
+    // ── Data export ────────────────────────────────────────────
+    /** Return a deep copy of the store data */
+    exportData() {
+        return {
+            mint: this.data.mint,
+            unit: this.data.unit,
+            proofs: this.data.proofs.map((p) => ({ ...p })),
+        };
+    }
+    // ── Funding check ──────────────────────────────────────────
+    /** Returns true if balance is below threshold */
+    needsFunding(threshold) {
+        return this.balance < threshold;
+    }
+    // ── Proof selection ────────────────────────────────────────
+    /**
+     * Select proofs totalling at least `amount` sat,
+     * encode as a Cashu V4 token, and remove them from the store.
+     */
+    async selectAndEncode(amount) {
+        return this.mutex.lock(async () => {
+            if (this.balance < amount) {
+                throw new Error(`Insufficient balance: need ${amount} sat, have ${this.balance} sat`);
+            }
+            const sorted = [...this.data.proofs].sort((a, b) => b.amount - a.amount);
+            const selected = [];
+            let total = 0;
+            for (const p of sorted) {
+                if (total >= amount)
+                    break;
+                selected.push(p);
+                total += p.amount;
+            }
+            if (total < amount) {
+                throw new Error(`Could not select enough proofs for ${amount} sat`);
+            }
+            // Remove selected proofs
+            const selectedSecrets = new Set(selected.map((p) => typeof p.secret === "string" ? p.secret : JSON.stringify(p.secret)));
+            this.data.proofs = this.data.proofs.filter((p) => !selectedSecrets.has(typeof p.secret === "string" ? p.secret : JSON.stringify(p.secret)));
+            await this.save();
+            return getEncodedTokenV4({
+                mint: this.data.mint,
+                proofs: selected,
+                unit: this.data.unit,
+            });
+        });
+    }
+    // ── Proof import (no mint interaction) ─────────────────────
+    /**
+     * Import proofs directly into the store.
+     * No mint swap — caller is responsible for proof validity.
+     */
+    async importProofs(proofs) {
+        if (proofs.length === 0)
+            return 0;
+        return this.mutex.lock(async () => {
+            const amount = proofs.reduce((s, p) => s + p.amount, 0);
+            this.data.proofs.push(...proofs);
+            await this.save();
+            return amount;
+        });
+    }
+    // ── Mint-dependent operations ──────────────────────────────
+    /** Get or init CashuWallet (lazy, connects to mint) */
+    async getCashuWallet() {
+        if (!this.wallet) {
+            const m = new CashuMint(this.data.mint);
+            this.wallet = new CashuWallet(m);
+            await this.wallet.loadMint();
+        }
+        return this.wallet;
+    }
+    /**
+     * Receive an encoded Cashu token — swap at mint for fresh proofs.
+     * Used for change/refund tokens from the Gate.
+     */
+    async receiveToken(encodedToken) {
+        return this.mutex.lock(async () => {
+            const w = await this.getCashuWallet();
+            const proofs = await w.receive(encodedToken);
+            if (!proofs || proofs.length === 0)
+                return 0;
+            const amount = proofs.reduce((s, p) => s + p.amount, 0);
+            this.data.proofs.push(...proofs);
+            await this.save();
+            return amount;
+        });
+    }
+    /**
+     * Create a mint quote (Lightning invoice) for funding.
+     */
+    async createMintQuote(amount) {
+        const wallet = await this.getCashuWallet();
+        const quote = await wallet.createMintQuote(amount);
+        return { quote: quote.quote, request: quote.request };
+    }
+    /**
+     * Check and mint tokens from a paid quote.
+     */
+    async mintFromQuote(quoteId, amount) {
+        return this.mutex.lock(async () => {
+            const wallet = await this.getCashuWallet();
+            const check = await wallet.checkMintQuote(quoteId);
+            if (check.state !== MintQuoteState.PAID && check.state !== MintQuoteState.ISSUED) {
+                throw new Error(`Quote not paid yet (state: ${check.state})`);
+            }
+            const proofs = await wallet.mintProofs(amount, quoteId);
+            this.data.proofs.push(...proofs);
+            await this.save();
+            return proofs.reduce((s, p) => s + p.amount, 0);
+        });
+    }
+}

package/dist/commands/audit.d.ts

@@ -0,0 +1,6 @@
+interface AuditOptions {
+    json?: boolean;
+    lines?: string;
+}
+export declare function auditCommand(opts: AuditOptions): Promise<void>;
+export {};

package/dist/commands/audit.js

@@ -0,0 +1,340 @@
+/**
+ * t2c audit — Full-chain fund visualization
+ *
+ * Unified view: local wallet + Mint + Gate + transaction log.
+ * Cross-references data and highlights anomalies.
+ */
+import { loadConfig, resolveHome, loadFailedTokens, loadTransactions, } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+import { GateRegistry } from "../gate-discovery.js";
+async function fetchMintInfo(mintUrl) {
+    try {
+        const [infoRes, keysetsRes] = await Promise.all([
+            fetch(`${mintUrl}/v1/info`, { signal: AbortSignal.timeout(8000) }),
+            fetch(`${mintUrl}/v1/keysets`, { signal: AbortSignal.timeout(8000) }),
+        ]);
+        const info = { reachable: infoRes.ok };
+        if (infoRes.ok) {
+            const data = (await infoRes.json());
+            info.name = data.name;
+            info.version = data.version;
+            info.nuts = data.nuts;
+        }
+        if (keysetsRes.ok) {
+            const data = (await keysetsRes.json());
+            info.keysetIds = data.keysets?.filter((k) => k.active).map((k) => k.id);
+        }
+        return info;
+    }
+    catch (e) {
+        return { reachable: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+async function fetchGateInfo(gateUrl) {
+    try {
+        const [healthRes, pricingRes] = await Promise.all([
+            fetch(`${gateUrl}/health`, { signal: AbortSignal.timeout(8000) }),
+            fetch(`${gateUrl}/v1/pricing`, { signal: AbortSignal.timeout(8000) }),
+        ]);
+        const info = { reachable: healthRes.ok };
+        if (healthRes.ok) {
+            const data = (await healthRes.json());
+            info.mints = data.mints;
+            info.models = data.models;
+        }
+        if (pricingRes.ok) {
+            const data = (await pricingRes.json());
+            info.pricing = data.models;
+        }
+        return info;
+    }
+    catch (e) {
+        return { reachable: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function detectAnomalies(report) {
+    const anomalies = [];
+    // Wallet anomalies
+    if (report.wallet) {
+        if (report.wallet.balance === 0) {
+            anomalies.push({ severity: "error", message: "Wallet balance is 0 — cannot make requests" });
+        }
+        else if (report.wallet.balance < 500) {
+            anomalies.push({ severity: "warn", message: `Low wallet balance: ${report.wallet.balance} sat` });
+        }
+        if (report.wallet.proofCount > 100) {
+            anomalies.push({ severity: "warn", message: `High proof count (${report.wallet.proofCount}) — consider consolidating via swap` });
+        }
+    }
+    else {
+        anomalies.push({ severity: "error", message: "No wallet found — run 't2c init'" });
+    }
+    // Mint anomalies
+    if (!report.mint.reachable) {
+        anomalies.push({ severity: "error", message: `Mint unreachable: ${report.mint.error ?? "connection failed"}` });
+    }
+    if (report.mint.keysetIds && report.mint.keysetIds.length === 0) {
+        anomalies.push({ severity: "error", message: "Mint has no active keysets" });
+    }
+    // Gate anomalies
+    if (!report.gate.reachable) {
+        anomalies.push({ severity: "error", message: `Gate unreachable: ${report.gate.error ?? "connection failed"}` });
+    }
+    if (report.gate.reachable && report.gate.mints && report.wallet) {
+        if (!report.gate.mints.includes(report.wallet.mint)) {
+            anomalies.push({
+                severity: "error",
+                message: `Wallet mint (${report.wallet.mint}) not in Gate's trusted mints: ${report.gate.mints.join(", ")}`,
+            });
+        }
+    }
+    // Transaction anomalies
+    if (report.transactions.errorCount > 0) {
+        anomalies.push({
+            severity: "warn",
+            message: `${report.transactions.errorCount} failed transaction(s) in history`,
+        });
+    }
+    const lossRate = report.transactions.totalSpent > 0
+        ? ((report.transactions.totalSpent - report.transactions.totalChange - report.transactions.totalRefund) / report.transactions.totalSpent * 100)
+        : 0;
+    if (report.transactions.totalSpent > 0 && lossRate > 50) {
+        anomalies.push({
+            severity: "warn",
+            message: `High fund loss rate: ${lossRate.toFixed(1)}% of spent sats not returned as change/refund`,
+        });
+    }
+    // Failed token anomalies
+    if (report.failedTokens.length > 0) {
+        const totalLost = report.failedTokens.length;
+        anomalies.push({
+            severity: "error",
+            message: `${totalLost} failed token(s) pending recovery — run 't2c recover'`,
+        });
+    }
+    // Balance consistency check
+    if (report.wallet && report.transactions.recent.length > 0) {
+        const last = report.transactions.recent[report.transactions.recent.length - 1];
+        if (last.balanceAfter !== report.wallet.balance) {
+            anomalies.push({
+                severity: "info",
+                message: `Balance drift: last tx recorded ${last.balanceAfter} sat, wallet now ${report.wallet.balance} sat (may indicate manual changes)`,
+            });
+        }
+    }
+    return anomalies;
+}
+function formatTime(ts) {
+    return new Date(ts).toLocaleString();
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function printReport(report) {
+    const config = report;
+    console.log("\n========================================");
+    console.log("       t2c Audit Report");
+    console.log(`       ${formatTime(report.timestamp)}`);
+    console.log("========================================\n");
+    // ── Wallet ──
+    console.log("--- Wallet ---");
+    if (report.wallet) {
+        console.log(`  Balance:     ${report.wallet.balance.toLocaleString()} sat`);
+        console.log(`  Proofs:      ${report.wallet.proofCount}`);
+        console.log(`  Mint:        ${report.wallet.mint}`);
+        const denominations = Object.entries(report.wallet.proofBreakdown)
+            .sort(([a], [b]) => Number(b) - Number(a));
+        if (denominations.length > 0) {
+            console.log("  Breakdown:");
+            for (const [denom, count] of denominations) {
+                console.log(`    ${denom} sat x ${count} = ${Number(denom) * count} sat`);
+            }
+        }
+    }
+    else {
+        console.log("  (no wallet found)");
+    }
+    // ── Mint ──
+    console.log("\n--- Mint ---");
+    console.log(`  Status:      ${report.mint.reachable ? "reachable" : "UNREACHABLE"}`);
+    if (report.mint.name)
+        console.log(`  Name:        ${report.mint.name}`);
+    if (report.mint.version)
+        console.log(`  Version:     ${report.mint.version}`);
+    if (report.mint.nuts) {
+        console.log(`  NUTs:        ${Object.keys(report.mint.nuts).sort().join(", ")}`);
+    }
+    if (report.mint.keysetIds) {
+        console.log(`  Keysets:     ${report.mint.keysetIds.join(", ") || "(none active)"}`);
+    }
+    // ── Gate ──
+    console.log("\n--- Gate ---");
+    console.log(`  Status:      ${report.gate.reachable ? "reachable" : "UNREACHABLE"}`);
+    if (report.gate.mints) {
+        console.log(`  Mints:       ${report.gate.mints.join(", ")}`);
+    }
+    if (report.gate.models) {
+        console.log(`  Models:      ${report.gate.models.join(", ")}`);
+    }
+    if (report.gate.pricing) {
+        console.log("  Pricing:");
+        for (const [model, rule] of Object.entries(report.gate.pricing)) {
+            const parts = [];
+            if (rule.input_per_million)
+                parts.push(`in:${rule.input_per_million}/M`);
+            if (rule.output_per_million)
+                parts.push(`out:${rule.output_per_million}/M`);
+            if (rule.per_request)
+                parts.push(`req:${rule.per_request}`);
+            console.log(`    ${model}: ${parts.join(", ")} sat`);
+        }
+    }
+    // ── Discovered Gates ──
+    if (report.discoveredGates.length > 0) {
+        console.log("\n--- Discovered Gates ---");
+        for (const g of report.discoveredGates) {
+            const status = g.healthy ? "OK" : "DOWN";
+            console.log(`  [${status}] ${g.name} — ${g.url}`);
+            if (g.mint)
+                console.log(`         Mint: ${g.mint}`);
+            if (g.models.length > 0)
+                console.log(`         Models: ${g.models.join(", ")}`);
+        }
+    }
+    // ── Transactions ──
+    console.log("\n--- Transactions ---");
+    if (report.transactions.total === 0) {
+        console.log("  (no transactions recorded yet)");
+    }
+    else {
+        console.log(`  Total:       ${report.transactions.total} requests`);
+        console.log(`  Spent:       ${report.transactions.totalSpent.toLocaleString()} sat`);
+        console.log(`  Change:      +${report.transactions.totalChange.toLocaleString()} sat`);
+        console.log(`  Refund:      +${report.transactions.totalRefund.toLocaleString()} sat`);
+        console.log(`  Net cost:    ${report.transactions.netCost.toLocaleString()} sat`);
+        console.log(`  Errors:      ${report.transactions.errorCount}`);
+        if (report.transactions.recent.length > 0) {
+            console.log("\n  Recent transactions:");
+            console.log("  " + "-".repeat(90));
+            console.log("  " + padR("Time", 20) + padR("Model", 28) + padR("Paid", 8) + padR("Change", 8) + padR("Status", 8) + "Duration");
+            console.log("  " + "-".repeat(90));
+            for (const tx of report.transactions.recent) {
+                const time = new Date(tx.timestamp).toLocaleTimeString();
+                const model = tx.model.length > 26 ? tx.model.slice(0, 24) + ".." : tx.model;
+                const status = tx.error ? `ERR` : `${tx.gateStatus}`;
+                console.log("  " +
+                    padR(time, 20) +
+                    padR(model, 28) +
+                    padR(`${tx.priceSat}`, 8) +
+                    padR(`+${tx.changeSat}`, 8) +
+                    padR(status, 8) +
+                    formatDuration(tx.durationMs));
+            }
+            console.log("  " + "-".repeat(90));
+        }
+    }
+    // ── Failed Tokens ──
+    if (report.failedTokens.length > 0) {
+        console.log("\n--- Failed Tokens ---");
+        for (const ft of report.failedTokens) {
+            console.log(`  [${ft.type}] ${formatTime(ft.timestamp)} — ${ft.error}`);
+            console.log(`    Token: ${ft.token.slice(0, 40)}...`);
+        }
+    }
+    // ── Anomalies ──
+    console.log("\n--- Anomalies ---");
+    if (report.anomalies.length === 0) {
+        console.log("  No anomalies detected.");
+    }
+    else {
+        for (const a of report.anomalies) {
+            const icon = a.severity === "error" ? "!!" : a.severity === "warn" ? " !" : " i";
+            console.log(`  [${icon}] ${a.message}`);
+        }
+    }
+    console.log("\n========================================\n");
+}
+function padR(s, n) {
+    return s.length >= n ? s.slice(0, n) : s + " ".repeat(n - s.length);
+}
+export async function auditCommand(opts) {
+    const config = await loadConfig();
+    const limit = parseInt(opts.lines || "20", 10);
+    // Gather data in parallel
+    const [mintInfo, gateInfo, transactions, failedTokensData, walletResult, discoveredGates] = await Promise.all([
+        fetchMintInfo(config.mintUrl),
+        fetchGateInfo(config.gateUrl),
+        loadTransactions(),
+        loadFailedTokens(),
+        (async () => {
+            try {
+                const walletPath = resolveHome(config.walletPath);
+                const store = await CashuStore.load(walletPath, config.mintUrl);
+                const data = store.exportData();
+                const breakdown = {};
+                for (const p of data.proofs) {
+                    breakdown[p.amount] = (breakdown[p.amount] || 0) + 1;
+                }
+                return {
+                    balance: store.balance,
+                    proofCount: store.proofCount,
+                    proofBreakdown: breakdown,
+                    mint: data.mint,
+                };
+            }
+            catch {
+                return null;
+            }
+        })(),
+        (async () => {
+            try {
+                const registry = new GateRegistry(config.gateUrl, config.discoveryUrl);
+                await registry.discover();
+                return registry.getAll().map((g) => ({
+                    name: g.name,
+                    url: g.url,
+                    mint: g.mint,
+                    models: g.models,
+                    healthy: g.healthy,
+                }));
+            }
+            catch {
+                return [];
+            }
+        })(),
+    ]);
+    // Compute transaction summaries
+    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 errorCount = transactions.filter((t) => t.error).length;
+    const recent = transactions.slice(-limit);
+    const report = {
+        timestamp: Date.now(),
+        wallet: walletResult,
+        mint: mintInfo,
+        gate: gateInfo,
+        discoveredGates,
+        transactions: {
+            total: transactions.length,
+            shown: recent.length,
+            totalSpent,
+            totalChange,
+            totalRefund,
+            netCost: totalSpent - totalChange - totalRefund,
+            errorCount,
+            recent,
+        },
+        failedTokens: failedTokensData.tokens,
+        anomalies: [],
+    };
+    report.anomalies = detectAnomalies(report);
+    if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        printReport(report);
+    }
+}

package/dist/commands/balance.d.ts

@@ -0,0 +1,5 @@
+interface BalanceOptions {
+    json?: boolean;
+}
+export declare function balanceCommand(opts: BalanceOptions): Promise<void>;
+export {};

package/dist/commands/balance.js

@@ -0,0 +1,29 @@
+/**
+ * t2c balance - Simple balance display
+ */
+import { loadConfig, WALLET_PATH } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+export async function balanceCommand(opts) {
+    const config = await loadConfig();
+    try {
+        const wallet = await CashuStore.load(WALLET_PATH, config.mintUrl);
+        if (opts.json) {
+            console.log(JSON.stringify({
+                balance: wallet.balance,
+                proofs: wallet.proofCount,
+            }));
+        }
+        else {
+            console.log(`${wallet.balance} sat`);
+        }
+    }
+    catch (e) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "Wallet not found" }));
+        }
+        else {
+            console.error("Wallet not found. Run 't2c setup' first.");
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * t2c config - Generate config for AI tools
+ */
+import { type AdapterConfigOptions } from "../config.js";
+export declare function configCommand(tool: string, opts: AdapterConfigOptions): Promise<void>;

package/dist/commands/config.js

@@ -0,0 +1,62 @@
+/**
+ * t2c config - Generate config for AI tools
+ */
+import { loadConfig, loadOrCreateProxySecret } from "../config.js";
+import { openclawAdapter } from "../adapters/openclaw.js";
+import { cursorAdapter } from "../adapters/cursor.js";
+import { envAdapter } from "../adapters/env.js";
+import { clineAdapter } from "../adapters/cline.js";
+import { continueAdapter } from "../adapters/continue.js";
+import { aiderAdapter } from "../adapters/aider.js";
+const ADAPTERS = {
+    openclaw: {
+        name: "OpenClaw",
+        description: "Personal AI assistant with multi-channel support",
+        adapter: openclawAdapter,
+    },
+    cursor: {
+        name: "Cursor",
+        description: "AI-powered code editor",
+        adapter: cursorAdapter,
+    },
+    cline: {
+        name: "Cline",
+        description: "VS Code AI coding assistant extension",
+        adapter: clineAdapter,
+    },
+    continue: {
+        name: "Continue",
+        description: "Open-source AI code assistant for VS Code/JetBrains",
+        adapter: continueAdapter,
+    },
+    aider: {
+        name: "Aider",
+        description: "Terminal-based AI pair programming",
+        adapter: aiderAdapter,
+    },
+    env: {
+        name: "Environment Variables",
+        description: "Generic OpenAI-compatible configuration",
+        adapter: envAdapter,
+    },
+};
+export async function configCommand(tool, opts) {
+    if (tool === "list") {
+        console.log("\n🎟️  Supported AI Tools\n");
+        for (const [id, info] of Object.entries(ADAPTERS)) {
+            console.log(`  ${id.padEnd(12)} ${info.name}`);
+            console.log(`  ${"".padEnd(12)} ${info.description}\n`);
+        }
+        console.log("Usage: t2c config <tool>\n");
+        return;
+    }
+    const adapterInfo = ADAPTERS[tool];
+    if (!adapterInfo) {
+        console.error(`Unknown tool: ${tool}`);
+        console.error(`Run 't2c config list' to see supported tools.`);
+        process.exit(1);
+    }
+    const config = await loadConfig();
+    const proxySecret = await loadOrCreateProxySecret();
+    await adapterInfo.adapter(config, { ...opts, proxySecret });
+}

package/dist/commands/connect.d.ts

@@ -0,0 +1 @@
+export declare function connectCommand(app: string): Promise<void>;