@token2chat/t2c 0.2.0-beta.1

package/dist/gate-discovery.js

@@ -0,0 +1,142 @@
+/**
+ * Gate auto-discovery and failover.
+ *
+ * Fetches available Gates from token2.cash/gates.json,
+ * tracks health per Gate, and selects the best one per request.
+ */
+const DISCOVERY_URL = "https://token2.cash/gates.json";
+const CACHE_TTL_MS = 5 * 60_000; // 5 minutes
+const CIRCUIT_OPEN_MS = 60_000; // 1 minute circuit breaker
+const MAX_FAIL_COUNT = 3;
+export class GateRegistry {
+    gates = [];
+    health = new Map();
+    lastFetch = 0;
+    primaryUrl;
+    discoveryUrl;
+    constructor(primaryUrl, discoveryUrl = DISCOVERY_URL) {
+        this.primaryUrl = primaryUrl;
+        this.discoveryUrl = discoveryUrl;
+    }
+    /**
+     * Fetch gates.json and update registry.
+     * Cached for CACHE_TTL_MS.
+     */
+    async discover() {
+        const now = Date.now();
+        if (this.gates.length > 0 && now - this.lastFetch < CACHE_TTL_MS) {
+            return this.gates;
+        }
+        try {
+            const res = await fetch(this.discoveryUrl, { signal: AbortSignal.timeout(8000) });
+            if (res.ok) {
+                const data = (await res.json());
+                if (data.gates && Array.isArray(data.gates)) {
+                    this.gates = data.gates;
+                    this.lastFetch = now;
+                }
+            }
+        }
+        catch {
+            // Discovery failed — keep existing cache or fall back to primary
+        }
+        // Ensure primary gate is always in the list
+        if (!this.gates.some((g) => g.url === this.primaryUrl)) {
+            this.gates.unshift({
+                name: "primary",
+                url: this.primaryUrl,
+                mint: "",
+                providers: [],
+                models: ["*"],
+                markup: "0%",
+                description: "Configured primary gate",
+            });
+        }
+        return this.gates;
+    }
+    /**
+     * Select the best gate for a given model.
+     * Priority: primary gate > healthy gates that support the model > any healthy gate.
+     */
+    async selectGate(model) {
+        await this.discover();
+        const now = Date.now();
+        const candidates = [];
+        // Primary first if healthy
+        const primaryEntry = this.gates.find((g) => g.url === this.primaryUrl);
+        if (primaryEntry && this.isHealthy(primaryEntry.url, now)) {
+            candidates.push(primaryEntry);
+        }
+        // Then other healthy gates
+        for (const gate of this.gates) {
+            if (gate.url === this.primaryUrl)
+                continue;
+            if (!this.isHealthy(gate.url, now))
+                continue;
+            // Check model support
+            if (model && gate.models.length > 0) {
+                const supports = gate.models.some((m) => m === "*" || m.includes("*") || model.includes(m) || m.includes(model.split("/").pop()));
+                if (!supports)
+                    continue;
+            }
+            candidates.push(gate);
+        }
+        // If primary was unhealthy, add it as last resort
+        if (primaryEntry && !this.isHealthy(primaryEntry.url, now)) {
+            candidates.push(primaryEntry);
+        }
+        // Ensure at least primary is returned
+        if (candidates.length === 0) {
+            return [this.primaryUrl];
+        }
+        return candidates.map((g) => g.url);
+    }
+    /**
+     * Mark a gate as having failed.
+     */
+    markFailed(gateUrl) {
+        const h = this.getHealth(gateUrl);
+        h.healthy = false;
+        h.failCount++;
+        h.lastFailure = Date.now();
+    }
+    /**
+     * Mark a gate as having succeeded.
+     */
+    markSuccess(gateUrl) {
+        const h = this.getHealth(gateUrl);
+        h.healthy = true;
+        h.failCount = 0;
+        h.lastSuccess = Date.now();
+    }
+    /**
+     * Get list of all known gates with health status.
+     */
+    getAll() {
+        const now = Date.now();
+        return this.gates.map((g) => ({
+            ...g,
+            healthy: this.isHealthy(g.url, now),
+        }));
+    }
+    isHealthy(gateUrl, now) {
+        const h = this.health.get(gateUrl);
+        if (!h)
+            return true; // Unknown = healthy (optimistic)
+        if (h.healthy)
+            return true;
+        // Circuit breaker: re-try after CIRCUIT_OPEN_MS
+        if (h.failCount >= MAX_FAIL_COUNT && now - h.lastFailure < CIRCUIT_OPEN_MS) {
+            return false;
+        }
+        return true; // Half-open: allow retry
+    }
+    getHealth(gateUrl) {
+        let h = this.health.get(gateUrl);
+        if (!h) {
+            h = { healthy: true, failCount: 0, lastFailure: 0, lastSuccess: 0 };
+            this.health.set(gateUrl, h);
+        }
+        return h;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * t2c - Token2Chat CLI
+ *
+ * Pay-per-request LLM access via Cashu ecash
+ */
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { connectCommand } from "./commands/connect.js";
+import { setupCommand } from "./commands/setup.js";
+import { statusCommand } from "./commands/status.js";
+import { serviceCommand } from "./commands/service.js";
+import { configCommand } from "./commands/config.js";
+import { mintCommand } from "./commands/mint.js";
+import { recoverCommand } from "./commands/recover.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { balanceCommand } from "./commands/balance.js";
+import { auditCommand } from "./commands/audit.js";
+// debug command is loaded dynamically — excluded from npm package
+const program = new Command();
+program
+    .name("t2c")
+    .description("Pay-per-request LLM access via Cashu ecash")
+    .version("0.1.0");
+// t2c init - Core initialization
+program
+    .command("init")
+    .description("Initialize Token2Chat")
+    .option("-f, --force", "Reinitialize even if already configured")
+    .action((opts) => initCommand(opts));
+// t2c connect <app> - Connect to AI tools
+program
+    .command("connect [app]")
+    .description("Connect to an AI tool (openclaw, cursor, env)")
+    .action(connectCommand);
+// t2c setup - Interactive setup wizard (legacy, points to init)
+program
+    .command("setup")
+    .description("Interactive setup wizard (alias for init)")
+    .action(setupCommand);
+// t2c status - Show service status and wallet balance
+program
+    .command("status")
+    .description("Show service status and wallet balance")
+    .option("--json", "Output as JSON")
+    .action(statusCommand);
+// t2c service - Manage the local proxy service
+const service = program
+    .command("service")
+    .description("Manage the local proxy service");
+service
+    .command("start")
+    .description("Start the proxy service")
+    .option("-f, --foreground", "Run in foreground (don't daemonize)")
+    .action((opts) => serviceCommand("start", opts));
+service
+    .command("stop")
+    .description("Stop the proxy service")
+    .action(() => serviceCommand("stop", {}));
+service
+    .command("restart")
+    .description("Restart the proxy service")
+    .action(() => serviceCommand("restart", {}));
+service
+    .command("status")
+    .description("Show detailed service status")
+    .action(() => serviceCommand("status", {}));
+service
+    .command("logs")
+    .description("Show service logs")
+    .option("-f, --follow", "Follow log output")
+    .option("-n, --lines <n>", "Number of lines to show", "50")
+    .action((opts) => serviceCommand("logs", opts));
+service
+    .command("install")
+    .description("Install as system service (launchd on macOS, systemd on Linux)")
+    .action(() => serviceCommand("install", {}));
+service
+    .command("uninstall")
+    .description("Uninstall system service")
+    .action(() => serviceCommand("uninstall", {}));
+// t2c mint - Add funds to wallet
+program
+    .command("mint [amount]")
+    .description("Show deposit address or mint ecash from pending deposits")
+    .option("--check", "Check for pending deposits and mint")
+    .action(mintCommand);
+// t2c recover - Recover failed tokens
+program
+    .command("recover")
+    .description("Recover failed change/refund tokens")
+    .action(recoverCommand);
+// t2c doctor - Self-diagnostic command
+program
+    .command("doctor")
+    .description("Run diagnostics and check all components")
+    .action(doctorCommand);
+// t2c balance - Simple balance display
+program
+    .command("balance")
+    .description("Show wallet balance")
+    .option("--json", "Output as JSON")
+    .action(balanceCommand);
+// t2c audit - Full-chain fund visualization
+program
+    .command("audit")
+    .description("Full-chain fund audit: wallet + mint + gate + transactions")
+    .option("--json", "Output as JSON")
+    .option("-n, --lines <n>", "Number of recent transactions to show", "20")
+    .action(auditCommand);
+// t2c config - Generate config for AI tools
+const config = program
+    .command("config")
+    .description("Generate config for AI tools");
+config
+    .command("openclaw")
+    .description("Generate OpenClaw configuration")
+    .option("--apply", "Apply config directly to openclaw.json")
+    .option("--json", "Output as JSON (for manual editing)")
+    .action((opts) => configCommand("openclaw", opts));
+config
+    .command("cursor")
+    .description("Generate Cursor configuration")
+    .action((opts) => configCommand("cursor", opts));
+config
+    .command("cline")
+    .description("Generate Cline VS Code extension configuration")
+    .option("--json", "Output as JSON")
+    .action((opts) => configCommand("cline", opts));
+config
+    .command("continue")
+    .description("Generate Continue.dev configuration")
+    .option("--json", "Output as JSON")
+    .action((opts) => configCommand("continue", opts));
+config
+    .command("aider")
+    .description("Generate Aider configuration")
+    .option("--json", "Output as JSON")
+    .action((opts) => configCommand("aider", opts));
+config
+    .command("env")
+    .description("Output environment variables for generic OpenAI-compatible tools")
+    .action((opts) => configCommand("env", opts));
+config
+    .command("list")
+    .description("List supported AI tools")
+    .action(() => configCommand("list", {}));
+// t2c debug — dev-only commands, dynamically loaded (excluded from npm package)
+try {
+    const { debugCommand } = await import("./commands/debug.js");
+    const debug = program
+        .command("debug")
+        .description("⚠️ Debug/testing commands (dev only)")
+        .action(() => debugCommand("help"));
+    debug
+        .command("force")
+        .description("Force OpenClaw to use token2chat as sole provider")
+        .action(() => debugCommand("force"));
+    debug
+        .command("rollback")
+        .description("Restore original OpenClaw config")
+        .action(() => debugCommand("rollback"));
+    debug
+        .command("logs")
+        .description("Show auth profiles, cooldowns, and recent model errors")
+        .option("-n, --lines <n>", "Number of log lines to show", "30")
+        .action((opts) => debugCommand("logs", opts));
+    debug
+        .command("topup")
+        .description("Transfer ecash from Gate to local plugin wallet")
+        .requiredOption("--amount <sats>", "Amount in sats to withdraw from Gate")
+        .action((opts) => debugCommand("topup", opts));
+}
+catch {
+    // debug module not available (stripped from npm package) — skip silently
+}
+program.parse();

package/dist/proxy.d.ts

@@ -0,0 +1,11 @@
+import { type T2CConfig } from "./config.js";
+export interface Logger {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export interface ProxyHandle {
+    stop: () => void;
+    proxySecret: string;
+}
+export declare function startProxy(config: T2CConfig, logger?: Logger): Promise<ProxyHandle>;

package/dist/proxy.js

@@ -0,0 +1,352 @@
+/**
+ * Local HTTP proxy that translates standard OpenAI-compatible requests
+ * into ecash-paid requests to the token2chat Gate.
+ */
+import { createServer } from "node:http";
+import crypto from "node:crypto";
+import { CashuStore } from "./cashu-store.js";
+import { resolveHome, FAILED_TOKENS_PATH, appendFailedToken, appendTransaction, loadOrCreateProxySecret } from "./config.js";
+import { GateRegistry } from "./gate-discovery.js";
+const defaultLogger = {
+    info: (...args) => console.log("[t2c]", ...args),
+    warn: (...args) => console.warn("[t2c]", ...args),
+    error: (...args) => console.error("[t2c]", ...args),
+};
+/**
+ * Known provider prefixes for model ID transformation.
+ * We use `-` as separator in OpenClaw to avoid double-slash issue,
+ * but Gate/OpenRouter expects `/` as separator.
+ */
+const MODEL_PROVIDER_PREFIXES = [
+    "openai",
+    "anthropic",
+    "google",
+    "deepseek",
+    "qwen",
+    "moonshotai",
+    "mistralai",
+    "meta-llama",
+    "nvidia",
+    "cohere",
+    "perplexity",
+];
+/**
+ * Transform model ID from dash format to slash format.
+ * e.g., "anthropic-claude-sonnet-4.5" → "anthropic/claude-sonnet-4.5"
+ */
+function transformModelId(model) {
+    for (const prefix of MODEL_PROVIDER_PREFIXES) {
+        if (model.startsWith(`${prefix}-`)) {
+            return `${prefix}/${model.slice(prefix.length + 1)}`;
+        }
+    }
+    return model;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const MAX_RETRY_DELAY_MS = 30_000;
+function parseRetryAfter(value) {
+    if (!value)
+        return null;
+    const seconds = parseFloat(value);
+    if (!isNaN(seconds) && isFinite(seconds)) {
+        return Math.max(0, Math.ceil(seconds * 1000));
+    }
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+        return Math.max(0, date.getTime() - Date.now());
+    }
+    return null;
+}
+export async function startProxy(config, logger = defaultLogger) {
+    const { gateUrl, mintUrl, proxyPort: port, lowBalanceThreshold } = config;
+    const walletPath = resolveHome(config.walletPath);
+    // Gate discovery + failover
+    const gateRegistry = config.autoDiscover
+        ? new GateRegistry(gateUrl, config.discoveryUrl)
+        : null;
+    if (gateRegistry) {
+        await gateRegistry.discover().catch(() => { });
+    }
+    // Load proxy authentication secret
+    const proxySecret = await loadOrCreateProxySecret();
+    function checkAuth(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(proxySecret);
+        if (provided.length !== expected.length)
+            return false;
+        return crypto.timingSafeEqual(provided, expected);
+    }
+    // Load wallet synchronously before starting server (fixes race condition)
+    let wallet;
+    try {
+        wallet = await CashuStore.load(walletPath, mintUrl);
+        logger.info(`Wallet loaded: ${wallet.balance} sat (${wallet.proofCount} proofs)`);
+    }
+    catch (e) {
+        logger.error("Failed to load wallet:", e);
+        throw new Error(`Cannot start proxy: wallet load failed - ${e instanceof Error ? e.message : e}`);
+    }
+    // Cache pricing info
+    let pricingCache = null;
+    let pricingFetchedAt = 0;
+    async function fetchPricing() {
+        const now = Date.now();
+        if (pricingCache && now - pricingFetchedAt < 5 * 60_000)
+            return pricingCache;
+        try {
+            const res = await fetch(`${gateUrl}/v1/pricing`);
+            if (res.ok) {
+                const data = (await res.json());
+                pricingCache = {};
+                for (const [model, rule] of Object.entries(data.models)) {
+                    pricingCache[model] = rule.per_request;
+                }
+                pricingFetchedAt = now;
+            }
+        }
+        catch (e) {
+            logger.warn("Failed to fetch pricing:", e);
+        }
+        return pricingCache ?? {};
+    }
+    function getPrice(pricing, model) {
+        return pricing[model] ?? pricing["*"] ?? 500;
+    }
+    const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10 MB
+    async function readBody(req) {
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of req) {
+            size += chunk.length;
+            if (size > MAX_BODY_SIZE) {
+                req.destroy();
+                throw new Error("Request body too large");
+            }
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    const server = createServer(async (req, res) => {
+        // Health check (unauthenticated — no sensitive data)
+        if (req.method === "GET" && req.url === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
+        // All endpoints below require authentication
+        if (!checkAuth(req)) {
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: { message: "Unauthorized. Provide a valid Bearer token." } }));
+            return;
+        }
+        // Pricing passthrough
+        if (req.method === "GET" && req.url === "/v1/pricing") {
+            try {
+                const upstream = await fetch(`${gateUrl}/v1/pricing`);
+                res.writeHead(upstream.status, { "Content-Type": "application/json" });
+                res.end(await upstream.text());
+            }
+            catch {
+                res.writeHead(502, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Gate unreachable" }));
+            }
+            return;
+        }
+        // Models endpoint
+        if (req.method === "GET" && req.url === "/v1/models") {
+            const pricing = await fetchPricing();
+            const models = Object.keys(pricing).map((id) => ({
+                id,
+                object: "model",
+                created: Date.now(),
+                owned_by: "token2chat",
+            }));
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ object: "list", data: models }));
+            return;
+        }
+        // Only proxy POST /v1/chat/completions
+        if (req.method !== "POST" || !req.url?.startsWith("/v1/chat/completions")) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: { message: "Not found" } }));
+            return;
+        }
+        try {
+            const body = await readBody(req);
+            const parsed = JSON.parse(body.toString());
+            const requestedModel = parsed.model;
+            const isStream = parsed.stream === true;
+            // Transaction tracking
+            const txStart = Date.now();
+            const txId = `tx-${txStart}-${Math.random().toString(36).slice(2, 8)}`;
+            let txChangeSat = 0;
+            let txRefundSat = 0;
+            const balanceBefore = wallet.balance;
+            const pricing = await fetchPricing();
+            const price = getPrice(pricing, requestedModel);
+            const balance = wallet.balance;
+            if (balance < price) {
+                logger.warn(`Insufficient balance: ${balance} sat < ${price} sat for ${requestedModel}`);
+                res.writeHead(402, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    error: {
+                        code: "insufficient_balance",
+                        message: `Wallet balance ${balance} sat < ${price} sat required. Run 't2c mint' to add funds.`,
+                        type: "insufficient_funds",
+                    },
+                }));
+                return;
+            }
+            // Prepare modified body once (model transform doesn't change between retries)
+            parsed.model = transformModelId(requestedModel);
+            const modifiedBody = JSON.stringify(parsed);
+            // Resolve gate URL(s) — with failover if auto-discover enabled
+            const gateUrls = gateRegistry
+                ? await gateRegistry.selectGate(requestedModel)
+                : [gateUrl];
+            // Make request with retry logic
+            const maxRetries = 2;
+            const retryBaseDelayMs = 2000;
+            let lastResponse = null;
+            let lastResponseBody;
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                // Pick gate for this attempt (rotate through available gates)
+                const currentGateUrl = gateUrls[attempt % gateUrls.length];
+                const currentPrice = getPrice(pricing, requestedModel);
+                const token = await wallet.selectAndEncode(currentPrice);
+                const currentBalance = wallet.balance;
+                if (attempt === 0) {
+                    logger.info(`Paying ${currentPrice} sat for ${requestedModel} → ${currentGateUrl} (balance: ${currentBalance + currentPrice} → ~${currentBalance})`);
+                }
+                else {
+                    logger.info(`Retry ${attempt}/${maxRetries} for ${requestedModel} → ${currentGateUrl}`);
+                }
+                const gateRes = await fetch(`${currentGateUrl}/v1/chat/completions`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "X-Cashu": token,
+                    },
+                    body: modifiedBody,
+                });
+                // Handle change/refund tokens from Gate
+                for (const [header, type] of [["X-Cashu-Change", "change"], ["X-Cashu-Refund", "refund"]]) {
+                    const tokenStr = gateRes.headers.get(header);
+                    if (!tokenStr)
+                        continue;
+                    try {
+                        const amt = await wallet.receiveToken(tokenStr);
+                        if (type === "change")
+                            txChangeSat += amt;
+                        else
+                            txRefundSat += amt;
+                        logger.info(`Received ${amt} sat ${type}`);
+                    }
+                    catch (e) {
+                        const errMsg = e instanceof Error ? e.message : String(e);
+                        logger.warn(`Failed to store ${type}: ${errMsg}`);
+                        logger.warn(`Token saved to ${FAILED_TOKENS_PATH} - run 't2c recover' to retry`);
+                        await appendFailedToken(tokenStr, type, errMsg);
+                    }
+                }
+                // If not 429, we're done (and mark gate healthy for failover)
+                if (gateRes.status !== 429) {
+                    if (gateRegistry) {
+                        if (gateRes.status >= 500)
+                            gateRegistry.markFailed(currentGateUrl);
+                        else
+                            gateRegistry.markSuccess(currentGateUrl);
+                    }
+                    const resHeaders = {};
+                    const ct = gateRes.headers.get("content-type");
+                    if (ct)
+                        resHeaders["Content-Type"] = ct;
+                    res.writeHead(gateRes.status, resHeaders);
+                    if (isStream && gateRes.body) {
+                        const reader = gateRes.body.getReader();
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
+                                res.write(value);
+                            }
+                        }
+                        finally {
+                            reader.releaseLock();
+                        }
+                        res.end();
+                    }
+                    else {
+                        res.end(await gateRes.text());
+                    }
+                    // Log balance warning
+                    const newBalance = wallet.balance;
+                    if (newBalance < lowBalanceThreshold) {
+                        logger.warn(`⚠️ Low ecash balance: ${newBalance} sat (threshold: ${lowBalanceThreshold})`);
+                    }
+                    // Record transaction
+                    appendTransaction({
+                        id: txId, timestamp: txStart, model: requestedModel,
+                        priceSat: currentPrice, changeSat: txChangeSat, refundSat: txRefundSat,
+                        gateStatus: gateRes.status, balanceBefore, balanceAfter: wallet.balance,
+                        durationMs: Date.now() - txStart,
+                    }).catch(() => { });
+                    return;
+                }
+                // Store last 429 response — mark gate for failover
+                if (gateRegistry)
+                    gateRegistry.markFailed(currentGateUrl);
+                lastResponse = gateRes;
+                lastResponseBody = await gateRes.text();
+                // On 429, calculate backoff delay
+                if (attempt < maxRetries) {
+                    const retryAfterMs = parseRetryAfter(gateRes.headers.get("Retry-After"));
+                    const backoffMs = Math.min(retryAfterMs ?? retryBaseDelayMs * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
+                    logger.warn(`Rate limited (429), retrying in ${backoffMs}ms...`);
+                    await sleep(backoffMs);
+                }
+            }
+            // All retries exhausted — record failed transaction
+            appendTransaction({
+                id: txId, timestamp: txStart, model: requestedModel,
+                priceSat: price, changeSat: txChangeSat, refundSat: txRefundSat,
+                gateStatus: lastResponse.status, balanceBefore, balanceAfter: wallet.balance,
+                durationMs: Date.now() - txStart, error: "Rate limited after retries",
+            }).catch(() => { });
+            res.writeHead(lastResponse.status, { "Content-Type": "application/json" });
+            res.end(lastResponseBody);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            logger.error("Proxy error:", e);
+            if (msg === "Request body too large") {
+                res.writeHead(413, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: { code: "payload_too_large", message: "Request body too large" } }));
+            }
+            else {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: { code: "proxy_error", message: "Internal proxy error" } }));
+            }
+        }
+    });
+    server.listen(port, "127.0.0.1", () => {
+        logger.info(`🎟️ t2c proxy on http://127.0.0.1:${port}`);
+        logger.info(`   Gate: ${gateUrl} | Mint: ${mintUrl}`);
+    });
+    return {
+        stop: () => {
+            server.close();
+            logger.info("t2c proxy stopped");
+        },
+        proxySecret,
+    };
+}