@token2chat/t2c 0.2.0-beta.1

package/dist/commands/service.js

@@ -0,0 +1,378 @@
+/**
+ * t2c service - Manage the local proxy service
+ */
+import fs from "node:fs/promises";
+import { spawn, execSync } from "node:child_process";
+import path from "node:path";
+import os from "node:os";
+import { loadConfig, PID_PATH, LOG_PATH, ensureConfigDir, CONFIG_DIR, } from "../config.js";
+import { startProxy } from "../proxy.js";
+// Platform-specific paths
+const LAUNCHD_PLIST_NAME = "com.token2chat.proxy.plist";
+const LAUNCHD_PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", LAUNCHD_PLIST_NAME);
+const SYSTEMD_UNIT_NAME = "t2c-proxy.service";
+const SYSTEMD_UNIT_PATH = path.join(os.homedir(), ".config", "systemd", "user", SYSTEMD_UNIT_NAME);
+async function getPid() {
+    try {
+        const raw = await fs.readFile(PID_PATH, "utf-8");
+        const pid = parseInt(raw.trim(), 10);
+        if (isNaN(pid))
+            return null;
+        // Check if process exists
+        try {
+            process.kill(pid, 0);
+            return pid;
+        }
+        catch {
+            // Process doesn't exist, clean up stale PID file
+            await fs.unlink(PID_PATH).catch(() => { });
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+async function writePid(pid) {
+    await ensureConfigDir();
+    await fs.writeFile(PID_PATH, String(pid), { mode: 0o600 });
+}
+async function removePid() {
+    await fs.unlink(PID_PATH).catch(() => { });
+}
+async function isProxyRunning(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`, {
+            signal: AbortSignal.timeout(2000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function startForeground() {
+    const config = await loadConfig();
+    // Check if already running
+    if (await isProxyRunning(config.proxyPort)) {
+        console.log(`Proxy already running on port ${config.proxyPort}`);
+        return;
+    }
+    console.log("Starting proxy in foreground (Ctrl+C to stop)...\n");
+    const handle = await startProxy(config);
+    // Handle shutdown
+    process.on("SIGINT", () => {
+        console.log("\nShutting down...");
+        handle.stop();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        handle.stop();
+        process.exit(0);
+    });
+    // Keep process alive
+    await new Promise(() => { });
+}
+async function startDaemon() {
+    const config = await loadConfig();
+    // Check if already running
+    const existingPid = await getPid();
+    if (existingPid) {
+        console.log(`Proxy already running (PID: ${existingPid})`);
+        return;
+    }
+    if (await isProxyRunning(config.proxyPort)) {
+        console.log(`Proxy already running on port ${config.proxyPort}`);
+        return;
+    }
+    await ensureConfigDir();
+    // Find t2c executable path
+    const t2cPath = process.argv[1];
+    // Spawn detached process
+    const logStream = await fs.open(LOG_PATH, "a");
+    const child = spawn(process.execPath, [t2cPath, "service", "start", "-f"], {
+        detached: true,
+        stdio: ["ignore", logStream.fd, logStream.fd],
+        env: { ...process.env, T2C_DAEMON: "1" },
+    });
+    child.unref();
+    await logStream.close();
+    if (child.pid) {
+        await writePid(child.pid);
+        console.log(`Proxy started (PID: ${child.pid})`);
+        console.log(`Logs: ${LOG_PATH}`);
+    }
+    else {
+        console.error("Failed to start proxy");
+        process.exit(1);
+    }
+}
+async function stopService() {
+    const pid = await getPid();
+    if (!pid) {
+        console.log("Proxy not running");
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(`Stopping proxy (PID: ${pid})...`);
+        // Wait for process to exit
+        for (let i = 0; i < 30; i++) {
+            await new Promise((r) => setTimeout(r, 100));
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                // Process exited
+                await removePid();
+                console.log("Proxy stopped");
+                return;
+            }
+        }
+        // Force kill
+        process.kill(pid, "SIGKILL");
+        await removePid();
+        console.log("Proxy killed");
+    }
+    catch (e) {
+        console.error(`Failed to stop proxy: ${e}`);
+        await removePid();
+    }
+}
+async function restartService() {
+    await stopService();
+    await new Promise((r) => setTimeout(r, 500));
+    await startDaemon();
+}
+async function showLogs(opts) {
+    const lines = parseInt(opts.lines || "50", 10);
+    try {
+        const content = await fs.readFile(LOG_PATH, "utf-8");
+        const allLines = content.split("\n");
+        const lastLines = allLines.slice(-lines).join("\n");
+        console.log(lastLines);
+        if (opts.follow) {
+            console.log("\n--- Following logs (Ctrl+C to stop) ---\n");
+            const tail = spawn("tail", ["-f", LOG_PATH], { stdio: "inherit" });
+            process.on("SIGINT", () => {
+                tail.kill();
+                process.exit(0);
+            });
+            await new Promise(() => { });
+        }
+    }
+    catch {
+        console.log("No logs found");
+    }
+}
+// ── Install/Uninstall for system service managers ──────────────────
+function generateLaunchdPlist(config) {
+    // Find t2c executable
+    const t2cPath = getT2CExecutablePath();
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.token2chat.proxy</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${t2cPath}</string>
+    <string>service</string>
+    <string>start</string>
+    <string>-f</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_PATH}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${CONFIG_DIR}</string>
+</dict>
+</plist>`;
+}
+function generateSystemdUnit(config) {
+    const t2cPath = getT2CExecutablePath();
+    return `[Unit]
+Description=Token2Chat Proxy Service
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${t2cPath} service start -f
+Restart=on-failure
+RestartSec=5
+StandardOutput=append:${LOG_PATH}
+StandardError=append:${LOG_PATH}
+WorkingDirectory=${CONFIG_DIR}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function getT2CExecutablePath() {
+    // If running from npm, use the bin path
+    // Otherwise use the current script path
+    return process.argv[1];
+}
+async function installService() {
+    const config = await loadConfig();
+    const platform = os.platform();
+    if (platform === "darwin") {
+        // macOS: launchd
+        const plistContent = generateLaunchdPlist(config);
+        const plistDir = path.dirname(LAUNCHD_PLIST_PATH);
+        await fs.mkdir(plistDir, { recursive: true });
+        await fs.writeFile(LAUNCHD_PLIST_PATH, plistContent);
+        console.log(`✅ Installed launchd service: ${LAUNCHD_PLIST_PATH}\n`);
+        console.log("To load and start the service:");
+        console.log(`  launchctl load ${LAUNCHD_PLIST_PATH}\n`);
+        console.log("To check status:");
+        console.log(`  launchctl list | grep com.token2chat\n`);
+        console.log("The service will auto-start on login.");
+    }
+    else if (platform === "linux") {
+        // Linux: systemd (user service)
+        const unitContent = generateSystemdUnit(config);
+        const unitDir = path.dirname(SYSTEMD_UNIT_PATH);
+        await fs.mkdir(unitDir, { recursive: true });
+        await fs.writeFile(SYSTEMD_UNIT_PATH, unitContent);
+        console.log(`✅ Installed systemd user service: ${SYSTEMD_UNIT_PATH}\n`);
+        console.log("To enable and start the service:");
+        console.log("  systemctl --user daemon-reload");
+        console.log(`  systemctl --user enable ${SYSTEMD_UNIT_NAME}`);
+        console.log(`  systemctl --user start ${SYSTEMD_UNIT_NAME}\n`);
+        console.log("To check status:");
+        console.log(`  systemctl --user status ${SYSTEMD_UNIT_NAME}\n`);
+        console.log("The service will auto-start on login.");
+    }
+    else {
+        console.error(`Unsupported platform for service installation: ${platform}`);
+        console.error("Use 't2c service start' to run manually.");
+        process.exit(1);
+    }
+}
+async function uninstallService() {
+    const platform = os.platform();
+    if (platform === "darwin") {
+        // macOS: launchd
+        try {
+            // Try to unload first
+            try {
+                execSync(`launchctl unload ${LAUNCHD_PLIST_PATH}`, { stdio: "ignore" });
+            }
+            catch {
+                // May not be loaded
+            }
+            await fs.unlink(LAUNCHD_PLIST_PATH);
+            console.log(`✅ Uninstalled launchd service`);
+        }
+        catch (e) {
+            if (e.code === "ENOENT") {
+                console.log("Service not installed");
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    else if (platform === "linux") {
+        // Linux: systemd
+        try {
+            // Try to stop and disable first
+            try {
+                execSync(`systemctl --user stop ${SYSTEMD_UNIT_NAME}`, { stdio: "ignore" });
+                execSync(`systemctl --user disable ${SYSTEMD_UNIT_NAME}`, { stdio: "ignore" });
+            }
+            catch {
+                // May not be running
+            }
+            await fs.unlink(SYSTEMD_UNIT_PATH);
+            execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+            console.log(`✅ Uninstalled systemd user service`);
+        }
+        catch (e) {
+            if (e.code === "ENOENT") {
+                console.log("Service not installed");
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    else {
+        console.error(`Unsupported platform: ${platform}`);
+        process.exit(1);
+    }
+}
+async function showServiceStatus() {
+    const config = await loadConfig();
+    const platform = os.platform();
+    const running = await isProxyRunning(config.proxyPort);
+    const pid = await getPid();
+    console.log("\n🎟️  Service Status\n");
+    console.log(`Platform:   ${platform}`);
+    console.log(`Proxy:      ${running ? "✅ Running" : "❌ Not running"}${pid ? ` (PID: ${pid})` : ""}`);
+    console.log(`Port:       ${config.proxyPort}`);
+    // Check if installed as system service
+    if (platform === "darwin") {
+        try {
+            await fs.access(LAUNCHD_PLIST_PATH);
+            console.log(`launchd:    ✅ Installed (${LAUNCHD_PLIST_PATH})`);
+        }
+        catch {
+            console.log(`launchd:    ❌ Not installed (run 't2c service install')`);
+        }
+    }
+    else if (platform === "linux") {
+        try {
+            await fs.access(SYSTEMD_UNIT_PATH);
+            console.log(`systemd:    ✅ Installed (${SYSTEMD_UNIT_PATH})`);
+        }
+        catch {
+            console.log(`systemd:    ❌ Not installed (run 't2c service install')`);
+        }
+    }
+    console.log(`\nLogs:       ${LOG_PATH}`);
+    console.log("");
+}
+export async function serviceCommand(action, opts) {
+    switch (action) {
+        case "start":
+            if (opts.foreground || process.env.T2C_DAEMON === "1") {
+                await startForeground();
+            }
+            else {
+                await startDaemon();
+            }
+            break;
+        case "stop":
+            await stopService();
+            break;
+        case "restart":
+            await restartService();
+            break;
+        case "logs":
+            await showLogs(opts);
+            break;
+        case "install":
+            await installService();
+            break;
+        case "uninstall":
+            await uninstallService();
+            break;
+        case "status":
+            await showServiceStatus();
+            break;
+    }
+}

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,128 @@
+/**
+ * t2c setup - Interactive setup wizard
+ */
+import * as readline from "node:readline";
+import { loadConfig, saveConfig, configExists, resolveHome, checkGateHealth, checkMintHealth, DEFAULT_CONFIG, } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+function createPrompt() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+async function question(rl, prompt) {
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => resolve(answer.trim()));
+    });
+}
+async function confirm(rl, prompt, defaultYes = true) {
+    const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+    const answer = await question(rl, `${prompt} ${suffix} `);
+    if (answer === "")
+        return defaultYes;
+    return answer.toLowerCase().startsWith("y");
+}
+export async function setupCommand() {
+    console.log("\n🎟️  Token2Chat Setup\n");
+    console.log("Pay-per-request LLM access via Cashu ecash.\n");
+    const hasConfig = await configExists();
+    const existingConfig = await loadConfig();
+    const rl = createPrompt();
+    try {
+        // Check if already configured
+        if (hasConfig) {
+            const reconfigure = await confirm(rl, "Configuration already exists. Reconfigure?", false);
+            if (!reconfigure) {
+                console.log("\nSetup cancelled. Run 't2c status' to see current configuration.\n");
+                return;
+            }
+        }
+        // Step 1: Gate URL
+        console.log("Step 1/4: Gate URL");
+        console.log(`  The Gate processes LLM requests and handles ecash payments.`);
+        const gateUrlAnswer = await question(rl, `  Gate URL [${existingConfig.gateUrl}]: `);
+        const gateUrl = gateUrlAnswer || existingConfig.gateUrl;
+        // Verify Gate
+        process.stdout.write("  Checking Gate... ");
+        const gateOk = await checkGateHealth(gateUrl);
+        if (gateOk) {
+            console.log("✅ Reachable");
+        }
+        else {
+            console.log("❌ Unreachable");
+            const proceed = await confirm(rl, "  Continue anyway?", false);
+            if (!proceed) {
+                console.log("\nSetup cancelled.\n");
+                return;
+            }
+        }
+        // Step 2: Mint URL
+        console.log("\nStep 2/4: Mint URL");
+        console.log(`  The Mint issues ecash tokens for payments.`);
+        const mintUrlAnswer = await question(rl, `  Mint URL [${existingConfig.mintUrl}]: `);
+        const mintUrl = mintUrlAnswer || existingConfig.mintUrl;
+        // Verify Mint
+        process.stdout.write("  Checking Mint... ");
+        const mintOk = await checkMintHealth(mintUrl);
+        if (mintOk) {
+            console.log("✅ Reachable");
+        }
+        else {
+            console.log("❌ Unreachable");
+            const proceed = await confirm(rl, "  Continue anyway?", false);
+            if (!proceed) {
+                console.log("\nSetup cancelled.\n");
+                return;
+            }
+        }
+        // Step 3: Proxy port
+        console.log("\nStep 3/4: Proxy Port");
+        console.log(`  The local proxy runs on this port for AI tools to connect.`);
+        const portAnswer = await question(rl, `  Port [${existingConfig.proxyPort}]: `);
+        const proxyPort = portAnswer ? parseInt(portAnswer, 10) : existingConfig.proxyPort;
+        if (isNaN(proxyPort) || proxyPort < 1 || proxyPort > 65535) {
+            console.log("  ❌ Invalid port number");
+            return;
+        }
+        // Step 4: Wallet path
+        console.log("\nStep 4/4: Wallet Path");
+        console.log(`  Your ecash wallet will be stored here.`);
+        const walletPathAnswer = await question(rl, `  Wallet path [${existingConfig.walletPath}]: `);
+        const walletPath = walletPathAnswer || existingConfig.walletPath;
+        // Create config
+        const config = {
+            gateUrl,
+            mintUrl,
+            walletPath,
+            proxyPort,
+            lowBalanceThreshold: DEFAULT_CONFIG.lowBalanceThreshold,
+            autoDiscover: DEFAULT_CONFIG.autoDiscover,
+            discoveryUrl: DEFAULT_CONFIG.discoveryUrl,
+        };
+        // Save config
+        await saveConfig(config);
+        console.log("\n✅ Configuration saved to ~/.t2c/config.json");
+        // Initialize wallet
+        try {
+            const resolvedPath = resolveHome(walletPath);
+            const wallet = await CashuStore.load(resolvedPath, mintUrl);
+            console.log(`✅ Wallet initialized (balance: ${wallet.balance} sat)`);
+        }
+        catch (e) {
+            console.log(`⚠️  Failed to initialize wallet: ${e}`);
+        }
+        // Next steps
+        console.log("\n📋 Next steps:\n");
+        console.log("  1. Start the proxy service:");
+        console.log("     t2c service start\n");
+        console.log("  2. Add funds to your wallet:");
+        console.log("     t2c mint\n");
+        console.log("  3. Configure your AI tool:");
+        console.log("     t2c config openclaw    # For OpenClaw");
+        console.log("     t2c config cursor      # For Cursor");
+        console.log("     t2c config env         # For other tools\n");
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,87 @@
+/**
+ * t2c status - Show service status and wallet balance
+ */
+import { loadConfig, resolveHome, configExists, checkGateHealth } from "../config.js";
+import { CashuStore } from "../cashu-store.js";
+async function checkProxy(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`, {
+            signal: AbortSignal.timeout(2000),
+        });
+        if (!res.ok)
+            return false;
+        const data = (await res.json());
+        return typeof data.ok === "boolean" && data.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function statusCommand(opts) {
+    const hasConfig = await configExists();
+    const config = await loadConfig();
+    const proxyRunning = await checkProxy(config.proxyPort);
+    const gateReachable = await checkGateHealth(config.gateUrl);
+    let walletInfo = null;
+    try {
+        const walletPath = resolveHome(config.walletPath);
+        const wallet = await CashuStore.load(walletPath, config.mintUrl);
+        walletInfo = {
+            path: config.walletPath,
+            balance: wallet.balance,
+            proofs: wallet.proofCount,
+        };
+    }
+    catch {
+        // Wallet doesn't exist yet
+    }
+    const result = {
+        configured: hasConfig,
+        proxyRunning,
+        proxyUrl: proxyRunning ? `http://127.0.0.1:${config.proxyPort}` : null,
+        wallet: walletInfo,
+        gate: {
+            url: config.gateUrl,
+            reachable: gateReachable,
+        },
+        mint: {
+            url: config.mintUrl,
+        },
+    };
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // Pretty print
+    console.log("\n🎟️  Token2Chat Status\n");
+    // Config
+    console.log(`Config:     ${hasConfig ? "✅ Configured" : "⚠️  Not configured (run 't2c setup')"}`);
+    // Proxy
+    if (proxyRunning) {
+        console.log(`Proxy:      ✅ Running on http://127.0.0.1:${config.proxyPort}`);
+    }
+    else {
+        console.log(`Proxy:      ❌ Not running (run 't2c service start')`);
+    }
+    // Gate
+    console.log(`Gate:       ${gateReachable ? "✅" : "❌"} ${config.gateUrl}`);
+    // Mint
+    console.log(`Mint:       ${config.mintUrl}`);
+    // Wallet
+    console.log("");
+    if (walletInfo) {
+        const balanceStr = walletInfo.balance.toLocaleString();
+        const status = walletInfo.balance > 0 ? "✅" : "⚠️";
+        console.log(`Wallet:     ${status} ${balanceStr} sat (${walletInfo.proofs} proofs)`);
+        if (walletInfo.balance === 0) {
+            console.log(`            Run 't2c mint' to add funds`);
+        }
+        else if (walletInfo.balance < config.lowBalanceThreshold) {
+            console.log(`            ⚠️  Low balance - consider adding funds`);
+        }
+    }
+    else {
+        console.log(`Wallet:     ⚠️  No wallet found (run 't2c setup')`);
+    }
+    console.log("");
+}

package/dist/config.d.ts

@@ -0,0 +1,83 @@
+export interface T2CConfig {
+    gateUrl: string;
+    mintUrl: string;
+    walletPath: string;
+    proxyPort: number;
+    lowBalanceThreshold: number;
+    autoDiscover: boolean;
+    discoveryUrl: string;
+}
+export declare const DEFAULT_CONFIG: T2CConfig;
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_PATH: string;
+export declare const WALLET_PATH: string;
+export declare const PID_PATH: string;
+export declare const LOG_PATH: string;
+export declare const PROXY_SECRET_PATH: string;
+export declare function resolveHome(p: string): string;
+export declare function ensureConfigDir(): Promise<void>;
+/**
+ * Load or create the proxy authentication secret.
+ * Used by the local proxy to authenticate requests.
+ */
+export declare function loadOrCreateProxySecret(): Promise<string>;
+/**
+ * Load config with automatic recovery from corruption
+ */
+export declare function loadConfig(): Promise<T2CConfig>;
+export declare function saveConfig(config: T2CConfig): Promise<void>;
+export declare function configExists(): Promise<boolean>;
+/**
+ * Custom error classes for better error handling
+ */
+export declare class ConfigError extends Error {
+    readonly recoverable: boolean;
+    constructor(message: string, recoverable?: boolean);
+}
+export declare class NetworkError extends Error {
+    readonly endpoint: string;
+    readonly cause?: Error | undefined;
+    constructor(message: string, endpoint: string, cause?: Error | undefined);
+}
+export declare class WalletError extends Error {
+    readonly code: "INSUFFICIENT_BALANCE" | "WALLET_NOT_FOUND" | "WALLET_CORRUPTED" | "PROOF_SELECTION_FAILED";
+    constructor(message: string, code: "INSUFFICIENT_BALANCE" | "WALLET_NOT_FOUND" | "WALLET_CORRUPTED" | "PROOF_SELECTION_FAILED");
+}
+/** Shared options for adapter config generation commands */
+export interface AdapterConfigOptions {
+    apply?: boolean;
+    json?: boolean;
+    proxySecret?: string;
+}
+export declare const FAILED_TOKENS_PATH: string;
+export interface FailedToken {
+    token: string;
+    type: "change" | "refund";
+    timestamp: number;
+    error: string;
+}
+interface FailedTokensFile {
+    tokens: FailedToken[];
+}
+export declare function loadFailedTokens(): Promise<FailedTokensFile>;
+export declare function saveFailedTokens(data: FailedTokensFile): Promise<void>;
+export declare function appendFailedToken(token: string, type: "change" | "refund", error: string): Promise<void>;
+export declare const TRANSACTIONS_LOG_PATH: string;
+export interface TransactionRecord {
+    id: string;
+    timestamp: number;
+    model: string;
+    priceSat: number;
+    changeSat: number;
+    refundSat: number;
+    gateStatus: number;
+    balanceBefore: number;
+    balanceAfter: number;
+    durationMs: number;
+    error?: string;
+}
+export declare function appendTransaction(record: TransactionRecord): Promise<void>;
+export declare function loadTransactions(limit?: number): Promise<TransactionRecord[]>;
+export declare function checkGateHealth(url: string): Promise<boolean>;
+export declare function checkMintHealth(url: string): Promise<boolean>;
+export {};