@token2chat/t2c 0.2.0-beta.1

package/dist/commands/connect.js

@@ -0,0 +1,43 @@
+/**
+ * t2c connect <app> - Connect to a specific AI tool
+ *
+ * Uses the connector system to integrate with various tools.
+ */
+import { loadConfig, configExists, ConfigError } from "../config.js";
+import { connectors, listConnectorIds, getConnector } from "../connectors/index.js";
+export async function connectCommand(app) {
+    // If no app specified or empty, list available connectors
+    if (!app || app.trim() === "") {
+        console.log("\n🎟️  Token2Chat Connect\n");
+        console.log("Usage: t2c connect <app>\n");
+        console.log("Available connectors:\n");
+        for (const [id, connector] of connectors) {
+            const detected = await connector.detect();
+            const status = detected ? "✅" : "⚪";
+            const desc = connector.description ? ` - ${connector.description}` : "";
+            console.log(`  ${status} ${id.padEnd(12)} ${connector.name}${desc}`);
+        }
+        console.log("\nExamples:\n");
+        console.log("  t2c connect openclaw   # Configure OpenClaw integration");
+        console.log("  t2c connect env        # Show environment variables");
+        console.log("  t2c connect cursor     # Configure Cursor IDE\n");
+        return;
+    }
+    // Check if t2c is initialized
+    const hasConfig = await configExists();
+    if (!hasConfig) {
+        throw new ConfigError("Token2Chat not initialized. Run 't2c init' first to configure gate, mint, and wallet.", true // recoverable
+        );
+    }
+    // Load config
+    const config = await loadConfig();
+    // Find the connector
+    const connector = getConnector(app);
+    if (!connector) {
+        const available = listConnectorIds().join(", ");
+        throw new ConfigError(`Unknown connector: ${app}. Available connectors: ${available}. Run 't2c connect' to see all options.`, true // recoverable
+        );
+    }
+    // Run the connector
+    await connector.connect(config);
+}

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -0,0 +1,178 @@
+/**
+ * t2c doctor - Self-diagnostic command
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { loadConfig, configExists, checkGateHealth, checkMintHealth, CONFIG_PATH, WALLET_PATH, } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+// Platform-specific service paths
+const LAUNCHD_PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", "com.token2chat.proxy.plist");
+const SYSTEMD_UNIT_PATH = path.join(os.homedir(), ".config", "systemd", "user", "t2c-proxy.service");
+async function checkConfig() {
+    const exists = await configExists();
+    if (exists) {
+        return {
+            name: "Config",
+            ok: true,
+            detail: CONFIG_PATH,
+        };
+    }
+    return {
+        name: "Config",
+        ok: false,
+        detail: "Not found",
+        fix: "run 't2c setup'",
+    };
+}
+async function checkWallet(config) {
+    try {
+        const wallet = await CashuStore.load(WALLET_PATH, config.mintUrl);
+        return {
+            name: "Wallet",
+            ok: true,
+            detail: `${WALLET_PATH} (${wallet.balance} sat)`,
+        };
+    }
+    catch (e) {
+        return {
+            name: "Wallet",
+            ok: false,
+            detail: "Not found or unreadable",
+            fix: "run 't2c setup'",
+        };
+    }
+}
+async function checkProxy(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`, {
+            signal: AbortSignal.timeout(2000),
+        });
+        if (res.ok) {
+            return {
+                name: "Proxy",
+                ok: true,
+                detail: `Running on :${port}`,
+            };
+        }
+        return {
+            name: "Proxy",
+            ok: false,
+            detail: `Port ${port} responded but health check failed`,
+            fix: "run 't2c service restart'",
+        };
+    }
+    catch {
+        return {
+            name: "Proxy",
+            ok: false,
+            detail: "Not running",
+            fix: "run 't2c service start'",
+        };
+    }
+}
+async function checkGate(url) {
+    const ok = await checkGateHealth(url);
+    return {
+        name: "Gate",
+        ok,
+        detail: `${url} (${ok ? "reachable" : "unreachable"})`,
+        ...(!ok && { fix: "check your internet connection" }),
+    };
+}
+async function checkMint(url) {
+    let ok = await checkMintHealth(url);
+    if (!ok) {
+        // Try alternate endpoint
+        try {
+            const res = await fetch(`${url}/info`, { signal: AbortSignal.timeout(5000) });
+            ok = res.ok;
+        }
+        catch {
+            // still unreachable
+        }
+    }
+    return {
+        name: "Mint",
+        ok,
+        detail: `${url} (${ok ? "reachable" : "unreachable"})`,
+        ...(!ok && { fix: "check your internet connection" }),
+    };
+}
+async function checkService() {
+    const platform = os.platform();
+    if (platform === "darwin") {
+        try {
+            await fs.access(LAUNCHD_PLIST_PATH);
+            return {
+                name: "Service",
+                ok: true,
+                detail: "Installed (launchd)",
+            };
+        }
+        catch {
+            return {
+                name: "Service",
+                ok: false,
+                detail: "Not installed",
+                fix: "run 't2c service install'",
+            };
+        }
+    }
+    else if (platform === "linux") {
+        try {
+            await fs.access(SYSTEMD_UNIT_PATH);
+            return {
+                name: "Service",
+                ok: true,
+                detail: "Installed (systemd)",
+            };
+        }
+        catch {
+            return {
+                name: "Service",
+                ok: false,
+                detail: "Not installed",
+                fix: "run 't2c service install'",
+            };
+        }
+    }
+    return {
+        name: "Service",
+        ok: false,
+        detail: `Unsupported platform (${platform})`,
+    };
+}
+export async function doctorCommand() {
+    console.log("\n🎟️  Token2Chat Doctor\n");
+    const config = await loadConfig();
+    // Run all checks
+    const results = await Promise.all([
+        checkConfig(),
+        checkWallet(config),
+        checkProxy(config.proxyPort),
+        checkGate(config.gateUrl),
+        checkMint(config.mintUrl),
+        checkService(),
+    ]);
+    // Print results
+    for (const result of results) {
+        const icon = result.ok ? "✅" : "❌";
+        console.log(`${icon} ${result.name.padEnd(10)} ${result.detail}`);
+    }
+    // Print fixes for failed checks
+    const failed = results.filter((r) => !r.ok && r.fix);
+    if (failed.length > 0) {
+        console.log("\n📋 Suggested fixes:\n");
+        for (const result of failed) {
+            console.log(`   ${result.name}: ${result.fix}`);
+        }
+    }
+    const allOk = results.every((r) => r.ok);
+    if (allOk) {
+        console.log("\n✨ All systems operational!\n");
+    }
+    else {
+        console.log("");
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,3 @@
+export declare function initCommand(opts?: {
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,50 @@
+/**
+ * t2c init - Core initialization command
+ *
+ * Uses sensible defaults for gate/mint/port/wallet.
+ * No interactive prompts — just validate connectivity and create wallet.
+ */
+import { saveConfig, configExists, resolveHome, loadConfig, checkGateHealth, checkMintHealth, DEFAULT_CONFIG, } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+export async function initCommand(opts) {
+    console.log("\n🎟️  Token2Chat Init\n");
+    const hasConfig = await configExists();
+    if (hasConfig && !opts?.force) {
+        const existing = await loadConfig();
+        console.log("Already initialized.\n");
+        console.log(`  Gate:   ${existing.gateUrl}`);
+        console.log(`  Mint:   ${existing.mintUrl}`);
+        console.log(`  Port:   ${existing.proxyPort}`);
+        console.log(`  Wallet: ${existing.walletPath}`);
+        console.log("\nRun 't2c init --force' to reinitialize.\n");
+        return;
+    }
+    const config = { ...DEFAULT_CONFIG };
+    // Check Gate connectivity
+    process.stdout.write("  Checking Gate...  ");
+    const gateOk = await checkGateHealth(config.gateUrl);
+    console.log(gateOk ? "✅" : "❌ Unreachable (will retry on first use)");
+    // Check Mint connectivity
+    process.stdout.write("  Checking Mint...  ");
+    const mintOk = await checkMintHealth(config.mintUrl);
+    console.log(mintOk ? "✅" : "❌ Unreachable (will retry on first use)");
+    // Save config
+    await saveConfig(config);
+    console.log("\n  Config saved to ~/.t2c/config.json");
+    // Initialize wallet
+    try {
+        const resolvedPath = resolveHome(config.walletPath);
+        const wallet = await CashuStore.load(resolvedPath, config.mintUrl);
+        console.log(`  Wallet initialized (balance: ${wallet.balance} sat)`);
+    }
+    catch (e) {
+        console.log(`  ⚠️  Wallet init failed: ${e}`);
+    }
+    // Next steps
+    console.log("\n📋 Next steps:\n");
+    console.log("  1. Connect to your AI tool:");
+    console.log("     t2c connect openclaw    # For OpenClaw");
+    console.log("     t2c connect env         # For other tools\n");
+    console.log("  2. Add funds:");
+    console.log("     t2c mint\n");
+}

package/dist/commands/mint.d.ts

@@ -0,0 +1,5 @@
+interface MintOptions {
+    check?: boolean;
+}
+export declare function mintCommand(amount: string | undefined, opts: MintOptions): Promise<void>;
+export {};

package/dist/commands/mint.js

@@ -0,0 +1,168 @@
+/**
+ * t2c mint - Add funds to wallet
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig, resolveHome, CONFIG_DIR } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+// Fallback deposit address (Mint's EVM address for USDC/USDT)
+// This is used if /v1/info endpoint doesn't provide a deposit address
+const FALLBACK_DEPOSIT_ADDRESS = "0xDC20821A78C4e1c586BE317e87A12f690E94E6c6";
+const SUPPORTED_CHAINS = [
+    { name: "Ethereum", chainId: 1, tokens: ["USDC", "USDT"] },
+    { name: "Base", chainId: 8453, tokens: ["USDC", "USDT"] },
+    { name: "Arbitrum", chainId: 42161, tokens: ["USDC", "USDT"] },
+    { name: "BNB Chain", chainId: 56, tokens: ["USDC", "USDT"] },
+];
+// Path to store pending quotes
+const PENDING_QUOTES_PATH = path.join(CONFIG_DIR, "pending-quotes.json");
+async function loadPendingQuotes() {
+    try {
+        const raw = await fs.readFile(PENDING_QUOTES_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { quotes: [] };
+    }
+}
+async function savePendingQuotes(data) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    await fs.writeFile(PENDING_QUOTES_PATH, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+async function fetchDepositAddress(mintUrl) {
+    try {
+        const res = await fetch(`${mintUrl}/v1/info`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (res.ok) {
+            const data = (await res.json());
+            if (data.deposit_address)
+                return data.deposit_address;
+            if (data.depositAddress)
+                return data.depositAddress;
+        }
+    }
+    catch {
+        // Fall through to default
+    }
+    return FALLBACK_DEPOSIT_ADDRESS;
+}
+export async function mintCommand(amount, opts) {
+    const config = await loadConfig();
+    const walletPath = resolveHome(config.walletPath);
+    let wallet;
+    try {
+        wallet = await CashuStore.load(walletPath, config.mintUrl);
+    }
+    catch (e) {
+        console.error(`Failed to load wallet: ${e}`);
+        console.error("Run 't2c setup' first.");
+        process.exit(1);
+    }
+    const currentBalance = wallet.balance;
+    console.log("\n🎟️  Token2Chat Funding\n");
+    console.log(`Current balance: ${currentBalance.toLocaleString()} sat\n`);
+    if (opts.check) {
+        // Check for pending Lightning quotes and mint paid ones
+        console.log("Checking pending Lightning quotes...\n");
+        const pendingData = await loadPendingQuotes();
+        if (pendingData.quotes.length === 0) {
+            console.log("No pending quotes found.");
+            console.log("Use 't2c mint <amount>' to create a Lightning invoice.\n");
+            return;
+        }
+        let mintedTotal = 0;
+        const stillPending = [];
+        const expired = [];
+        const now = Date.now();
+        const QUOTE_TTL_MS = 60 * 60 * 1000; // 1 hour
+        for (const pq of pendingData.quotes) {
+            // Skip expired quotes (older than 1 hour)
+            if (now - pq.createdAt > QUOTE_TTL_MS) {
+                expired.push(pq);
+                continue;
+            }
+            try {
+                const minted = await wallet.mintFromQuote(pq.quote, pq.amount);
+                console.log(`✅ Minted ${minted.toLocaleString()} sat from quote ${pq.quote.slice(0, 8)}...`);
+                mintedTotal += minted;
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                if (errMsg.includes("not paid") || errMsg.includes("UNPAID")) {
+                    stillPending.push(pq);
+                }
+                else if (errMsg.includes("ISSUED") || errMsg.includes("already")) {
+                    // Already minted, skip
+                    console.log(`ℹ️  Quote ${pq.quote.slice(0, 8)}... already processed`);
+                }
+                else {
+                    console.warn(`⚠️  Error checking quote ${pq.quote.slice(0, 8)}...: ${errMsg}`);
+                    stillPending.push(pq);
+                }
+            }
+        }
+        // Update pending quotes file
+        await savePendingQuotes({ quotes: stillPending });
+        if (mintedTotal > 0) {
+            console.log(`\n🎉 Total minted: ${mintedTotal.toLocaleString()} sat`);
+            console.log(`New balance: ${wallet.balance.toLocaleString()} sat\n`);
+        }
+        else if (stillPending.length > 0) {
+            console.log(`\n${stillPending.length} quote(s) still awaiting payment.`);
+            console.log("Pay the Lightning invoice and run 't2c mint --check' again.\n");
+        }
+        else {
+            console.log("No paid quotes found.\n");
+        }
+        if (expired.length > 0) {
+            console.log(`ℹ️  ${expired.length} expired quote(s) removed.\n`);
+        }
+        return;
+    }
+    // Lightning funding (if amount specified)
+    if (amount) {
+        const sats = parseInt(amount, 10);
+        if (isNaN(sats) || sats <= 0) {
+            console.error("Invalid amount. Specify sats to fund via Lightning.");
+            process.exit(1);
+        }
+        console.log(`⚡ Creating Lightning invoice for ${sats.toLocaleString()} sat...\n`);
+        try {
+            const quote = await wallet.createMintQuote(sats);
+            // Save to pending quotes
+            const pendingData = await loadPendingQuotes();
+            pendingData.quotes.push({
+                quote: quote.quote,
+                amount: sats,
+                request: quote.request,
+                createdAt: Date.now(),
+            });
+            await savePendingQuotes(pendingData);
+            console.log("Pay this Lightning invoice:\n");
+            console.log(`  ${quote.request}\n`);
+            console.log(`Quote ID: ${quote.quote}`);
+            console.log("\nAfter paying, run 't2c mint --check' to mint your tokens.\n");
+        }
+        catch (e) {
+            console.error(`Failed to create Lightning invoice: ${e}`);
+            process.exit(1);
+        }
+        return;
+    }
+    // Show deposit instructions (EVM stablecoins)
+    const depositAddress = await fetchDepositAddress(config.mintUrl);
+    console.log("Option 1: Lightning (recommended)\n");
+    console.log("  t2c mint <amount_sats>    Create a Lightning invoice\n");
+    console.log("Option 2: EVM Stablecoins\n");
+    console.log("  Send USDC or USDT to:\n");
+    console.log(`  ${depositAddress}\n`);
+    console.log("  Supported chains:");
+    for (const chain of SUPPORTED_CHAINS) {
+        console.log(`    • ${chain.name} (${chain.tokens.join(", ")})`);
+    }
+    console.log("\n💡 Tips:");
+    console.log("  • Lightning deposits are instant");
+    console.log("  • EVM deposits: ~1 sat per $0.001 USD");
+    console.log("  • Minimum deposit: $1 USD or 1000 sat\n");
+}

package/dist/commands/recover.d.ts

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

package/dist/commands/recover.js

@@ -0,0 +1,61 @@
+/**
+ * t2c recover - Recover failed tokens
+ */
+import { loadConfig, resolveHome, FAILED_TOKENS_PATH, loadFailedTokens, saveFailedTokens, } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+export async function recoverCommand() {
+    const config = await loadConfig();
+    const walletPath = resolveHome(config.walletPath);
+    console.log("\n🔧 Token Recovery\n");
+    const failedData = await loadFailedTokens();
+    if (failedData.tokens.length === 0) {
+        console.log("No failed tokens to recover. ✨\n");
+        return;
+    }
+    console.log(`Found ${failedData.tokens.length} failed token(s) to recover.\n`);
+    let wallet;
+    try {
+        wallet = await CashuStore.load(walletPath, config.mintUrl);
+    }
+    catch (e) {
+        console.error(`Failed to load wallet: ${e}`);
+        console.error("Run 't2c setup' first.");
+        process.exit(1);
+    }
+    const stillFailed = [];
+    let recoveredTotal = 0;
+    for (const ft of failedData.tokens) {
+        const shortToken = ft.token.slice(0, 20) + "...";
+        const date = new Date(ft.timestamp).toLocaleString();
+        console.log(`Attempting to recover ${ft.type} token from ${date}...`);
+        try {
+            const amount = await wallet.receiveToken(ft.token);
+            console.log(`  ✅ Recovered ${amount} sat\n`);
+            recoveredTotal += amount;
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            console.log(`  ❌ Failed: ${errMsg}\n`);
+            stillFailed.push({
+                ...ft,
+                error: errMsg,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    // Save remaining failed tokens
+    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`);
+    }
+    if (stillFailed.length > 0) {
+        console.log(`\n⚠️  ${stillFailed.length} token(s) still failed.`);
+        console.log(`   Saved to: ${FAILED_TOKENS_PATH}`);
+        console.log("   You can manually import these tokens or contact support.\n");
+    }
+    else if (recoveredTotal > 0) {
+        console.log("All tokens recovered successfully! ✨\n");
+    }
+}

package/dist/commands/service.d.ts

@@ -0,0 +1,7 @@
+interface ServiceOptions {
+    foreground?: boolean;
+    follow?: boolean;
+    lines?: string;
+}
+export declare function serviceCommand(action: "start" | "stop" | "restart" | "logs" | "install" | "uninstall" | "status", opts: ServiceOptions): Promise<void>;
+export {};