@token2chat/t2c 0.2.0-beta.1

package/dist/config.js

@@ -0,0 +1,224 @@
+/**
+ * t2c configuration management
+ */
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import path from "node:path";
+import os from "node:os";
+// Keep in sync with plugin/src/index.ts
+export const DEFAULT_CONFIG = {
+    gateUrl: "https://gate.token2chat.com",
+    mintUrl: "https://mint.token2chat.com",
+    walletPath: "~/.t2c/wallet.json",
+    proxyPort: 10402,
+    lowBalanceThreshold: 1000,
+    autoDiscover: false,
+    discoveryUrl: "https://token2.cash/gates.json",
+};
+export const CONFIG_DIR = path.join(os.homedir(), ".t2c");
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+export const WALLET_PATH = path.join(CONFIG_DIR, "wallet.json");
+export const PID_PATH = path.join(CONFIG_DIR, "proxy.pid");
+export const LOG_PATH = path.join(CONFIG_DIR, "proxy.log");
+export const PROXY_SECRET_PATH = path.join(CONFIG_DIR, "proxy-secret");
+export function resolveHome(p) {
+    let resolved = p;
+    if (resolved.startsWith("~/")) {
+        resolved = path.join(os.homedir(), resolved.slice(2));
+    }
+    // Normalize to prevent path traversal via .. segments
+    return path.resolve(resolved);
+}
+export async function ensureConfigDir() {
+    await fs.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+}
+/**
+ * Load or create the proxy authentication secret.
+ * Used by the local proxy to authenticate requests.
+ */
+export async function loadOrCreateProxySecret() {
+    try {
+        const secret = (await fs.readFile(PROXY_SECRET_PATH, "utf-8")).trim();
+        if (secret.length > 0)
+            return secret;
+    }
+    catch {
+        // File doesn't exist or unreadable — create a new one
+    }
+    await ensureConfigDir();
+    const secret = `t2c-${crypto.randomBytes(24).toString("hex")}`;
+    await fs.writeFile(PROXY_SECRET_PATH, secret + "\n", { mode: 0o600 });
+    return secret;
+}
+/**
+ * Load config with automatic recovery from corruption
+ */
+export async function loadConfig() {
+    try {
+        const raw = await fs.readFile(CONFIG_PATH, "utf-8");
+        const saved = JSON.parse(raw);
+        // Validate the loaded config
+        const merged = { ...DEFAULT_CONFIG, ...saved };
+        // Basic sanity checks
+        if (typeof merged.proxyPort !== "number" ||
+            merged.proxyPort < 1 ||
+            merged.proxyPort > 65535) {
+            console.warn(`Warning: Invalid proxy port in config (${merged.proxyPort}), using default`);
+            merged.proxyPort = DEFAULT_CONFIG.proxyPort;
+        }
+        if (typeof merged.gateUrl !== "string" || !merged.gateUrl.startsWith("http")) {
+            console.warn(`Warning: Invalid gate URL in config, using default`);
+            merged.gateUrl = DEFAULT_CONFIG.gateUrl;
+        }
+        if (typeof merged.mintUrl !== "string" || !merged.mintUrl.startsWith("http")) {
+            console.warn(`Warning: Invalid mint URL in config, using default`);
+            merged.mintUrl = DEFAULT_CONFIG.mintUrl;
+        }
+        return merged;
+    }
+    catch (e) {
+        const err = e;
+        // File doesn't exist - return defaults
+        if (err.code === "ENOENT") {
+            return { ...DEFAULT_CONFIG };
+        }
+        // File exists but is corrupted
+        if (err instanceof SyntaxError || err.message?.includes("JSON")) {
+            console.warn("Warning: Config file corrupted, attempting recovery...");
+            // Try to backup corrupted file
+            try {
+                const backupPath = `${CONFIG_PATH}.corrupted.${Date.now()}`;
+                await fs.rename(CONFIG_PATH, backupPath);
+                console.warn(`  Backed up corrupted config to: ${backupPath}`);
+            }
+            catch {
+                // Couldn't backup, that's ok
+            }
+            console.warn("  Using default configuration");
+            return { ...DEFAULT_CONFIG };
+        }
+        // Other error (permissions, etc)
+        console.error(`Error reading config: ${err.message}`);
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export async function saveConfig(config) {
+    await ensureConfigDir();
+    // Validate before saving
+    if (config.proxyPort < 1 || config.proxyPort > 65535) {
+        throw new Error(`Invalid proxy port: ${config.proxyPort}`);
+    }
+    if (!config.gateUrl.startsWith("http")) {
+        throw new Error(`Invalid gate URL: ${config.gateUrl}`);
+    }
+    if (!config.mintUrl.startsWith("http")) {
+        throw new Error(`Invalid mint URL: ${config.mintUrl}`);
+    }
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export async function configExists() {
+    try {
+        await fs.access(CONFIG_PATH);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Custom error classes for better error handling
+ */
+export class ConfigError extends Error {
+    recoverable;
+    constructor(message, recoverable = false) {
+        super(message);
+        this.recoverable = recoverable;
+        this.name = "ConfigError";
+    }
+}
+export class NetworkError extends Error {
+    endpoint;
+    cause;
+    constructor(message, endpoint, cause) {
+        super(message);
+        this.endpoint = endpoint;
+        this.cause = cause;
+        this.name = "NetworkError";
+    }
+}
+export class WalletError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "WalletError";
+    }
+}
+// ── Failed token persistence (shared by proxy + recover) ──────────
+/** Simple async mutex to serialize failed-token file writes */
+let _failedTokenLock = Promise.resolve();
+function withFailedTokenLock(fn) {
+    const prev = _failedTokenLock;
+    let resolve;
+    _failedTokenLock = new Promise((r) => { resolve = r; });
+    return prev.then(fn).finally(() => resolve());
+}
+export const FAILED_TOKENS_PATH = path.join(CONFIG_DIR, "failed-tokens.json");
+export async function loadFailedTokens() {
+    try {
+        const raw = await fs.readFile(FAILED_TOKENS_PATH, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { tokens: [] };
+    }
+}
+export async function saveFailedTokens(data) {
+    await fs.mkdir(path.dirname(FAILED_TOKENS_PATH), { recursive: true, mode: 0o700 });
+    await fs.writeFile(FAILED_TOKENS_PATH, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+export async function appendFailedToken(token, type, error) {
+    return withFailedTokenLock(async () => {
+        const data = await loadFailedTokens();
+        data.tokens.push({ token, type, timestamp: Date.now(), error });
+        await saveFailedTokens(data);
+    });
+}
+// ── Transaction log (JSONL — one record per proxy request) ────────
+export const TRANSACTIONS_LOG_PATH = path.join(CONFIG_DIR, "transactions.jsonl");
+export async function appendTransaction(record) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    await fs.appendFile(TRANSACTIONS_LOG_PATH, JSON.stringify(record) + "\n", { mode: 0o600 });
+}
+export async function loadTransactions(limit) {
+    try {
+        const raw = await fs.readFile(TRANSACTIONS_LOG_PATH, "utf-8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        const records = lines.map((l) => JSON.parse(l));
+        if (limit && limit > 0)
+            return records.slice(-limit);
+        return records;
+    }
+    catch {
+        return [];
+    }
+}
+// ── Connectivity checks (shared by init, setup, doctor, status) ───
+export async function checkGateHealth(url) {
+    try {
+        const res = await fetch(`${url}/health`, { signal: AbortSignal.timeout(5000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkMintHealth(url) {
+    try {
+        const res = await fetch(`${url}/v1/info`, { signal: AbortSignal.timeout(5000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/connectors/cursor.d.ts

@@ -0,0 +1,2 @@
+import type { Connector } from "./interface.js";
+export declare const cursorConnector: Connector;

package/dist/connectors/cursor.js

@@ -0,0 +1,28 @@
+export const cursorConnector = {
+    id: "cursor",
+    name: "Cursor",
+    description: "Configure Cursor IDE (coming soon)",
+    async detect() {
+        // TODO: Detect Cursor installation
+        // Could check for:
+        // - ~/Library/Application Support/Cursor (macOS)
+        // - ~/.config/Cursor (Linux)
+        // - %APPDATA%\Cursor (Windows)
+        return false;
+    },
+    async connect(_config) {
+        console.log("\n🎟️  Cursor Integration\n");
+        console.log("   Cursor connector coming soon!\n");
+        console.log("   In the meantime, you can configure Cursor manually:\n");
+        console.log("   1. Open Cursor Settings (Cmd/Ctrl + ,)");
+        console.log("   2. Set OpenAI Base URL:");
+        console.log(`      http://127.0.0.1:${_config.proxyPort}/v1\n`);
+        console.log("   3. Set OpenAI API Key:");
+        console.log("      ecash-proxy\n");
+        console.log("   4. Use model:");
+        console.log("      anthropic/claude-sonnet-4\n");
+    },
+    async verify() {
+        return false;
+    },
+};

package/dist/connectors/env.d.ts

@@ -0,0 +1,2 @@
+import type { Connector } from "./interface.js";
+export declare const envConnector: Connector;

package/dist/connectors/env.js

@@ -0,0 +1,38 @@
+/**
+ * Environment Variables Connector
+ *
+ * Outputs environment variables for use with any OpenAI-compatible tool.
+ */
+import { loadOrCreateProxySecret } from "../config.js";
+export const envConnector = {
+    id: "env",
+    name: "Environment Variables",
+    description: "Show environment variables for OpenAI-compatible tools",
+    async detect() {
+        // Always available
+        return true;
+    },
+    async connect(config) {
+        const baseUrl = `http://127.0.0.1:${config.proxyPort}/v1`;
+        const apiKey = await loadOrCreateProxySecret();
+        console.log("\n🎟️  Environment Variables\n");
+        console.log("   Add these to your shell profile (~/.bashrc, ~/.zshrc):\n");
+        console.log(`   export OPENAI_API_BASE="${baseUrl}"`);
+        console.log(`   export OPENAI_BASE_URL="${baseUrl}"`);
+        console.log(`   export OPENAI_API_KEY="${apiKey}"\n`);
+        console.log("   Or set them in a .env file:\n");
+        console.log(`   OPENAI_API_BASE=${baseUrl}`);
+        console.log(`   OPENAI_BASE_URL=${baseUrl}`);
+        console.log(`   OPENAI_API_KEY=${apiKey}\n`);
+        console.log("   Compatible with:\n");
+        console.log("   - LangChain / LangGraph");
+        console.log("   - LlamaIndex");
+        console.log("   - Aider");
+        console.log("   - Continue.dev");
+        console.log("   - Any OpenAI SDK-based tool\n");
+    },
+    async verify() {
+        const secret = await loadOrCreateProxySecret();
+        return process.env.OPENAI_API_KEY === secret;
+    },
+};

package/dist/connectors/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Connectors index
+ *
+ * Registry of all available connectors for t2c connect
+ */
+export type { Connector } from "./interface.js";
+export { openclawConnector } from "./openclaw.js";
+export { cursorConnector } from "./cursor.js";
+export { envConnector } from "./env.js";
+import type { Connector } from "./interface.js";
+/**
+ * Registry of all available connectors.
+ * Maps connector ID to connector instance.
+ */
+export declare const connectors: Map<string, Connector>;
+/**
+ * Get a connector by its ID.
+ * @param id - The unique identifier of the connector
+ * @returns The connector instance, or undefined if not found
+ */
+export declare function getConnector(id: string): Connector | undefined;
+/**
+ * List all available connector IDs.
+ * @returns Array of connector IDs
+ */
+export declare function listConnectorIds(): string[];

package/dist/connectors/index.js

@@ -0,0 +1,30 @@
+export { openclawConnector } from "./openclaw.js";
+export { cursorConnector } from "./cursor.js";
+export { envConnector } from "./env.js";
+import { openclawConnector } from "./openclaw.js";
+import { cursorConnector } from "./cursor.js";
+import { envConnector } from "./env.js";
+/**
+ * Registry of all available connectors.
+ * Maps connector ID to connector instance.
+ */
+export const connectors = new Map([
+    [openclawConnector.id, openclawConnector],
+    [cursorConnector.id, cursorConnector],
+    [envConnector.id, envConnector],
+]);
+/**
+ * Get a connector by its ID.
+ * @param id - The unique identifier of the connector
+ * @returns The connector instance, or undefined if not found
+ */
+export function getConnector(id) {
+    return connectors.get(id);
+}
+/**
+ * List all available connector IDs.
+ * @returns Array of connector IDs
+ */
+export function listConnectorIds() {
+    return Array.from(connectors.keys());
+}

package/dist/connectors/interface.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Connector interface for t2c connect command
+ *
+ * Connectors handle integration with specific AI tools.
+ */
+import type { T2CConfig } from "../config.js";
+export interface Connector {
+    /** Unique identifier (used in CLI) */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description for --help output */
+    description?: string;
+    /** Check if this tool is installed/available */
+    detect(): Promise<boolean>;
+    /** Connect t2c to this tool (configure, patch, etc.) */
+    connect(config: T2CConfig): Promise<void>;
+    /** Verify the connection works (optional) */
+    verify?(): Promise<boolean>;
+}

package/dist/connectors/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/connectors/openclaw.d.ts

@@ -0,0 +1,2 @@
+import type { Connector } from "./interface.js";
+export declare const openclawConnector: Connector;

package/dist/connectors/openclaw.js

@@ -0,0 +1,202 @@
+/**
+ * OpenClaw Connector
+ *
+ * Patches OpenClaw config to add Token2Chat plugin and models provider.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { loadOrCreateProxySecret } from "../config.js";
+/**
+ * Default models when Gate is unreachable.
+ * IDs use dash format (proxy transforms to slash for Gate/OpenRouter).
+ */
+const DEFAULT_MODELS = [
+    { id: "openai-gpt-4o-mini", name: "GPT-4o Mini" },
+    { id: "openai-gpt-4o", name: "GPT-4o" },
+    { id: "anthropic-claude-sonnet-4-20250514", name: "Claude Sonnet 4" },
+    { id: "anthropic-claude-opus-4-20250514", name: "Claude Opus 4" },
+];
+/**
+ * Fetch available models from Gate pricing endpoint.
+ * Returns model entries in OpenClaw dash format.
+ */
+async function fetchGateModels(gateUrl) {
+    try {
+        const res = await fetch(`${gateUrl}/v1/pricing`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        if (!data.models)
+            return [];
+        return Object.keys(data.models)
+            .filter((id) => id !== "*") // skip wildcard
+            .map((id) => ({
+            // Transform slash to dash for OpenClaw (e.g. "anthropic/claude-sonnet-4" → "anthropic-claude-sonnet-4")
+            id: id.replace("/", "-"),
+            name: id.split("/").pop()?.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()) ?? id,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+const OPENCLAW_CONFIG_DIR = ".openclaw";
+// OpenClaw may use either filename (openclaw.json is newer, clawdbot.json is legacy)
+const OPENCLAW_CONFIG_FILES = ["openclaw.json", "clawdbot.json"];
+/**
+ * Find the first existing config file, or return the preferred default.
+ */
+async function getConfigPath() {
+    const dir = path.join(os.homedir(), OPENCLAW_CONFIG_DIR);
+    for (const file of OPENCLAW_CONFIG_FILES) {
+        const p = path.join(dir, file);
+        try {
+            await fs.access(p);
+            return p;
+        }
+        catch {
+            // try next
+        }
+    }
+    // Default to the first (preferred) filename if none exist
+    return path.join(dir, OPENCLAW_CONFIG_FILES[0]);
+}
+/**
+ * Merge Token2Chat configuration into existing OpenClaw config.
+ * Handles:
+ * - Arrays and nested objects
+ * - Existing token2chat config (overwrites, doesn't duplicate)
+ */
+function mergeToken2ChatConfig(existingConfig, t2cConfig, gateModels, apiKey) {
+    const config = { ...existingConfig };
+    // Ensure plugins.entries exists
+    if (!config.plugins || typeof config.plugins !== "object") {
+        config.plugins = {};
+    }
+    const plugins = config.plugins;
+    if (!plugins.entries || typeof plugins.entries !== "object") {
+        plugins.entries = {};
+    }
+    const entries = plugins.entries;
+    // Set/overwrite token2chat plugin config
+    entries.token2chat = {
+        enabled: true,
+        config: {
+            gateUrl: t2cConfig.gateUrl,
+            mintUrl: t2cConfig.mintUrl,
+            proxyPort: t2cConfig.proxyPort,
+            walletPath: t2cConfig.walletPath,
+        },
+    };
+    // Ensure models.providers exists
+    if (!config.models || typeof config.models !== "object") {
+        config.models = {};
+    }
+    const models = config.models;
+    if (!models.providers || typeof models.providers !== "object") {
+        models.providers = {};
+    }
+    const providers = models.providers;
+    // Set/overwrite token2chat provider config
+    providers.token2chat = {
+        baseUrl: `http://127.0.0.1:${t2cConfig.proxyPort}/v1`,
+        apiKey,
+        api: "openai-completions",
+        models: gateModels.length > 0 ? gateModels : DEFAULT_MODELS,
+    };
+    return config;
+}
+export const openclawConnector = {
+    id: "openclaw",
+    name: "OpenClaw",
+    description: "Configure OpenClaw gateway to use Token2Chat",
+    async detect() {
+        const dir = path.join(os.homedir(), OPENCLAW_CONFIG_DIR);
+        for (const file of OPENCLAW_CONFIG_FILES) {
+            try {
+                await fs.access(path.join(dir, file));
+                return true;
+            }
+            catch {
+                // try next
+            }
+        }
+        return false;
+    },
+    async connect(config) {
+        // Check if OpenClaw is installed
+        const detected = await this.detect();
+        if (!detected) {
+            const defaultPath = path.join(os.homedir(), OPENCLAW_CONFIG_DIR, OPENCLAW_CONFIG_FILES[0]);
+            console.error("❌ OpenClaw not detected");
+            console.error(`   Expected config at: ${defaultPath}`);
+            console.error("\n   Install OpenClaw first: https://openclaw.dev\n");
+            return;
+        }
+        const configPath = await getConfigPath();
+        // Read existing config
+        let existingContent = "";
+        let existingConfig = {};
+        try {
+            existingContent = await fs.readFile(configPath, "utf-8");
+            existingConfig = JSON.parse(existingContent);
+        }
+        catch {
+            existingContent = "";
+            existingConfig = {};
+        }
+        // Load proxy secret for authentication
+        const apiKey = await loadOrCreateProxySecret();
+        // Fetch available models from Gate
+        console.log("   Fetching available models from Gate...");
+        const gateModels = await fetchGateModels(config.gateUrl);
+        if (gateModels.length > 0) {
+            console.log(`   Found ${gateModels.length} models`);
+        }
+        else {
+            console.log(`   Gate unreachable, using ${DEFAULT_MODELS.length} default models`);
+        }
+        // Merge our config
+        const mergedConfig = mergeToken2ChatConfig(existingConfig, config, gateModels, apiKey);
+        // Serialize to JSON with pretty formatting
+        const newContent = JSON.stringify(mergedConfig, null, 2) + "\n";
+        // Backup existing config
+        const backupPath = `${configPath}.backup.${Date.now()}`;
+        if (existingContent) {
+            await fs.writeFile(backupPath, existingContent);
+        }
+        // Write new config
+        await fs.writeFile(configPath, newContent);
+        console.log("✅ OpenClaw configured for Token2Chat\n");
+        console.log(`   Config: ${configPath}`);
+        if (existingContent) {
+            console.log(`   Backup: ${backupPath}`);
+        }
+        console.log("\n📋 Next steps:\n");
+        console.log("   1. Restart OpenClaw gateway:");
+        console.log("      openclaw gateway restart\n");
+        console.log("   2. Start the t2c proxy:");
+        console.log("      t2c service start\n");
+        console.log("   3. Use Token2Chat models with:");
+        console.log("      token2chat/anthropic-claude-sonnet-4\n");
+    },
+    async verify() {
+        // Check if config has our entries
+        try {
+            const configPath = await getConfigPath();
+            const content = await fs.readFile(configPath, "utf-8");
+            const doc = JSON.parse(content);
+            const plugins = doc?.plugins;
+            const entries = plugins?.entries;
+            const models = doc?.models;
+            const providers = models?.providers;
+            return (entries?.token2chat !== undefined && providers?.token2chat !== undefined);
+        }
+        catch {
+            return false;
+        }
+    },
+};

package/dist/gate-discovery.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Gate auto-discovery and failover.
+ *
+ * Fetches available Gates from token2.cash/gates.json,
+ * tracks health per Gate, and selects the best one per request.
+ */
+export interface GateEntry {
+    name: string;
+    url: string;
+    mint: string;
+    providers: string[];
+    models: string[];
+    markup: string;
+    description: string;
+}
+export declare class GateRegistry {
+    private gates;
+    private health;
+    private lastFetch;
+    private primaryUrl;
+    private discoveryUrl;
+    constructor(primaryUrl: string, discoveryUrl?: string);
+    /**
+     * Fetch gates.json and update registry.
+     * Cached for CACHE_TTL_MS.
+     */
+    discover(): Promise<GateEntry[]>;
+    /**
+     * Select the best gate for a given model.
+     * Priority: primary gate > healthy gates that support the model > any healthy gate.
+     */
+    selectGate(model?: string): Promise<string[]>;
+    /**
+     * Mark a gate as having failed.
+     */
+    markFailed(gateUrl: string): void;
+    /**
+     * Mark a gate as having succeeded.
+     */
+    markSuccess(gateUrl: string): void;
+    /**
+     * Get list of all known gates with health status.
+     */
+    getAll(): Array<GateEntry & {
+        healthy: boolean;
+    }>;
+    private isHealthy;
+    private getHealth;
+}