@tokenbuddy/tokenbuddy 1.0.4 → 1.0.6

package/dist/src/cli.js

@@ -6,10 +6,13 @@ import * as os from "os";
 import { execSync, spawn } from "child_process";
 import Table from "cli-table3";
 import { BuyerStore } from "./buyer-store.js";
-import { applyProviderInstall, detectProviders } from "./provider-install.js";
+import { applyProviderInstall, detectProviders, getProviderModelSelectionKind, getProviderProtocolPreference, } from "./provider-install.js";
 import { createModuleLogger } from "@tokenbuddy/logging";
 import * as crypto from "crypto";
 import { fileURLToPath } from "url";
+import { discoverSellerBackedModels, filterCatalogByProtocol, filterCatalogBySeller, } from "./seller-catalog.js";
+import { collectDoctorDiagnostics, collectDoctorModelsSummary, printDoctorProviders, printDoctorModelsSummary, readDoctorProviders, renderDoctorDiagnosticsProgressively, } from "./doctor-diagnostics.js";
+import { buildInitTerminalOptions, buildInitSuccessMessage, detectExistingClawtipBinding, INIT_PAYMENT_OPTIONS, noteInitComingSoonPayments, OTHER_TERMINAL_OPTION, validateInitTerminalSelection, } from "./init-payment-options.js";
 // @ts-ignore
 import qrcode from "qrcode-terminal";
 const CONTROL_PORT = 17820;
@@ -262,6 +265,210 @@ function readProof(options) {
     }
     return proof;
 }
+function sellerRegistryUrlForInit() {
+    return process.env.TB_PROXYD_SELLER_REGISTRY_URL || "https://tb-wallet-bootstrap.fly.dev/registry/sellers";
+}
+function stableModelChoices(models) {
+    const grouped = new Map();
+    for (const entry of models) {
+        const list = grouped.get(entry.id) || [];
+        list.push(entry);
+        grouped.set(entry.id, list);
+    }
+    return Array.from(grouped.entries()).map(([modelId, entries]) => {
+        const sellerIds = Array.from(new Set(entries.map((entry) => entry.sellerId)));
+        const protocols = Array.from(new Set(entries.flatMap((entry) => entry.supportedProtocols)));
+        return {
+            value: modelId,
+            label: modelId,
+            hint: `${sellerIds.join(",")} · ${protocols.join(",") || "no-protocol"}`,
+        };
+    });
+}
+async function promptSellerRoutingPreference(catalog) {
+    const healthySellers = catalog.sellers.filter((seller) => seller.status === "ok");
+    const mode = await p.select({
+        message: "Choose seller routing mode for tb-proxyd:",
+        options: [
+            {
+                value: "auto",
+                label: "Auto",
+                hint: "Automatically choose a compatible seller based on the requested model.",
+            },
+            {
+                value: "fixed",
+                label: "Fixed Seller",
+                hint: "Pin tb-proxyd to one seller and only use models from that seller.",
+            },
+        ],
+    });
+    if (typeof mode !== "string") {
+        throw new Error("seller routing selection was cancelled");
+    }
+    if (mode === "auto") {
+        return { mode };
+    }
+    if (healthySellers.length === 0) {
+        throw new Error("no healthy sellers available for fixed routing");
+    }
+    const sellerId = await p.select({
+        message: "Choose the seller to pin tb-proxyd to:",
+        options: healthySellers.map((seller) => ({
+            value: seller.id,
+            label: seller.name ? `${seller.name} (${seller.id})` : seller.id,
+            hint: [
+                seller.discountRatio != null ? `discount x${seller.discountRatio}` : null,
+                seller.modelCount != null ? `${seller.modelCount} models` : null,
+                seller.supportedProtocols?.length ? seller.supportedProtocols.join(",") : null,
+                seller.paymentMethods?.length ? seller.paymentMethods.join(",") : null,
+            ]
+                .filter(Boolean)
+                .join(" · ") || seller.url,
+        })),
+    });
+    if (typeof sellerId !== "string") {
+        throw new Error("fixed seller selection was cancelled");
+    }
+    return {
+        mode,
+        sellerId,
+    };
+}
+async function promptSingleModelSelection(providerId, models, sellerRouting) {
+    const protocolPreference = getProviderProtocolPreference(providerId);
+    const protocolFiltered = protocolPreference
+        ? filterCatalogByProtocol(models, protocolPreference)
+        : models;
+    const choices = stableModelChoices(protocolFiltered);
+    if (choices.length === 0) {
+        throw new Error(`no compatible models available for ${providerId}`);
+    }
+    const labelMap = {
+        opencode: "OpenCode",
+        codex: "Codex",
+        openclaw: "OpenClaw",
+        hermes: "Hermes",
+        "claude-desktop": "Claude Desktop",
+        "claude-code": "Claude Code",
+    };
+    const selectedModel = await p.select({
+        message: `Choose the default model for ${labelMap[providerId] || providerId}:`,
+        options: choices,
+    });
+    if (typeof selectedModel !== "string") {
+        throw new Error(`default model selection was cancelled for ${providerId}`);
+    }
+    const selectedEntry = protocolFiltered.find((entry) => entry.id === selectedModel);
+    return {
+        selectionKind: "single-model",
+        protocolPreference,
+        defaultModel: selectedModel,
+        sellerId: sellerRouting.mode === "fixed" ? selectedEntry?.sellerId : undefined,
+    };
+}
+function defaultClaudeDisplayName(modelId) {
+    return modelId.trim();
+}
+function makeClaudeRoleMapping(modelId) {
+    const displayName = defaultClaudeDisplayName(modelId);
+    return {
+        selectionKind: "claude-role-mapping",
+        protocolPreference: "messages",
+        fallbackModel: modelId,
+        roles: {
+            sonnet: {
+                upstreamModel: modelId,
+                displayName,
+                declareOneM: true,
+            },
+            opus: {
+                upstreamModel: modelId,
+                displayName,
+                declareOneM: true,
+            },
+            haiku: {
+                upstreamModel: modelId,
+                displayName,
+                declareOneM: false,
+            },
+        },
+    };
+}
+async function promptClaudeCodeModelSelection(models) {
+    const protocolFiltered = filterCatalogByProtocol(models, "messages");
+    const choices = stableModelChoices(protocolFiltered);
+    if (choices.length === 0) {
+        throw new Error("no compatible message models available for Claude Code");
+    }
+    const sonnetModel = await p.select({
+        message: "Choose the default Sonnet model for Claude Code:",
+        options: choices,
+    });
+    if (typeof sonnetModel !== "string") {
+        throw new Error("Claude Code model selection was cancelled");
+    }
+    const mirrorAllRoles = await p.confirm({
+        message: "Use the same model for Opus and Haiku as well?",
+        initialValue: true,
+    });
+    if (typeof mirrorAllRoles !== "boolean") {
+        throw new Error("Claude Code role mapping confirmation was cancelled");
+    }
+    if (mirrorAllRoles) {
+        return makeClaudeRoleMapping(sonnetModel);
+    }
+    const opusModel = await p.select({
+        message: "Choose the default Opus model for Claude Code:",
+        options: choices,
+    });
+    if (typeof opusModel !== "string") {
+        throw new Error("Claude Code Opus model selection was cancelled");
+    }
+    const haikuModel = await p.select({
+        message: "Choose the default Haiku model for Claude Code:",
+        options: choices,
+    });
+    if (typeof haikuModel !== "string") {
+        throw new Error("Claude Code Haiku model selection was cancelled");
+    }
+    return {
+        selectionKind: "claude-role-mapping",
+        protocolPreference: "messages",
+        fallbackModel: sonnetModel,
+        roles: {
+            sonnet: {
+                upstreamModel: sonnetModel,
+                displayName: defaultClaudeDisplayName(sonnetModel),
+                declareOneM: true,
+            },
+            opus: {
+                upstreamModel: opusModel,
+                displayName: defaultClaudeDisplayName(opusModel),
+                declareOneM: true,
+            },
+            haiku: {
+                upstreamModel: haikuModel,
+                displayName: defaultClaudeDisplayName(haikuModel),
+                declareOneM: false,
+            },
+        },
+    };
+}
+async function promptProviderSelections(providerIds, catalog, sellerRouting) {
+    const baseModels = sellerRouting.mode === "fixed"
+        ? filterCatalogBySeller(catalog.models, sellerRouting.sellerId)
+        : catalog.models;
+    const selections = {};
+    for (const providerId of providerIds) {
+        const selectionKind = getProviderModelSelectionKind(providerId);
+        if (selectionKind === "claude-role-mapping") {
+            selections[providerId] = await promptClaudeCodeModelSelection(baseModels);
+            continue;
+        }
+        selections[providerId] = await promptSingleModelSelection(providerId, baseModels, sellerRouting);
+    }
+    return selections;
+}
 export function buildCli() {
     const program = new Command();
     program
@@ -284,7 +491,6 @@ export function buildCli() {
         const plistPath = process.platform === "darwin"
             ? path.join(os.homedir(), "Library", "LaunchAgents", "com.tokenbuddy.proxyd.plist")
             : undefined;
-        const candidates = detectProviders();
         let probe = await probeDaemonStatus(controlPort);
         let repair = { attempted: false, fixed: false };
         if (!probe.running && options.fix) {
@@ -295,10 +501,22 @@ export function buildCli() {
         const daemonInfo = probe.status;
         const daemonRunning = probe.running;
         const daemonError = probe.error;
+        const daemonStatus = daemonInfo && typeof daemonInfo === "object"
+            ? daemonInfo
+            : undefined;
+        const providers = readDoctorProviders();
         if (options.fix && repair.attempted && !repair.fixed) {
             process.exitCode = 1;
         }
         if (options.json) {
+            const diagnostics = await collectDoctorDiagnostics({
+                controlPort,
+                proxyPort,
+                daemonRunning,
+                daemonError,
+                providers,
+                sellerRegistryUrl: daemonStatus?.sellerRegistryUrl,
+            });
             console.log(JSON.stringify({
                 daemon: {
                     running: daemonRunning,
@@ -318,7 +536,7 @@ export function buildCli() {
                     plistPath,
                     plistExists: plistPath ? fs.existsSync(plistPath) : false
                 },
-                providers: candidates
+                ...diagnostics,
             }, null, 2));
             return;
         }
@@ -351,12 +569,28 @@ export function buildCli() {
                 console.log("⚠️ LaunchAgent plist does NOT exist. Run `tb init` to install it as service.");
             }
         }
-        // 3. Detect terminals
-        console.log("\n--- Programming Terminals Detection ---");
-        for (const c of candidates) {
-            const icon = c.detected ? "✅" : "🔘";
-            console.log(`${icon} ${c.name}: ${c.reason}`);
+        if (daemonStatus) {
+            console.log(`   Control Plane URL: ${controlUrl}`);
+            console.log(`   Proxy Plane URL: http://127.0.0.1:${proxyPort}`);
+            if (daemonStatus.sellerRoutingMode || daemonStatus.selectionMode) {
+                console.log(`   Routing Mode: ${daemonStatus.sellerRoutingMode || daemonStatus.selectionMode}`);
+            }
+            if (daemonStatus.selectedSellerId) {
+                console.log(`   Selected Seller: ${daemonStatus.selectedSellerId}`);
+            }
+            if (daemonStatus.sellerRegistryUrl) {
+                console.log(`   Registry URL: ${daemonStatus.sellerRegistryUrl}`);
+            }
         }
+        printDoctorProviders(providers);
+        await renderDoctorDiagnosticsProgressively({
+            controlPort,
+            proxyPort,
+            daemonRunning,
+            daemonError,
+            sellerRegistryUrl: daemonStatus?.sellerRegistryUrl,
+            providers,
+        });
     });
     // 2. tb payment
     const payment = program.command("payment").description("Manage payment methods");
@@ -481,21 +715,30 @@ export function buildCli() {
         .option("--json", "Output model list as JSON")
         .action(async (options) => {
         try {
+            const controlPort = configuredControlPort();
+            const proxyPort = configuredProxyPort();
+            const status = await probeDaemonStatus(controlPort);
+            const daemonInfo = status.status && typeof status.status === "object"
+                ? status.status
+                : undefined;
+            const models = await collectDoctorModelsSummary({
+                controlPort,
+                proxyPort,
+                daemonRunning: status.running,
+                daemonError: status.error,
+                sellerRegistryUrl: daemonInfo?.sellerRegistryUrl,
+            });
             if (options.json) {
-                const response = await fetch(`http://127.0.0.1:${configuredControlPort()}/models`);
-                const body = await response.text();
-                if (!response.ok) {
-                    throw new Error(body || `HTTP ${response.status}`);
+                console.log(JSON.stringify(models, null, 2));
+                if (!models.available) {
+                    process.exitCode = 1;
                 }
-                JSON.parse(body);
-                console.log(body);
                 return;
             }
-            const table = new Table({ head: ["Model ID", "Input Price/1M", "Output Price/1M", "Supported Protocols"] });
-            // Sample static model config from seller mock
-            table.push(["gpt-4", "1.0 USD (or equivalent points)", "3.0 USD", "OpenAI, Direct"]);
-            console.log("=== Available LLM Models Matrix ===");
-            console.log(table.toString());
+            printDoctorModelsSummary(models);
+            if (!models.available) {
+                process.exitCode = 1;
+            }
         }
         catch (err) {
             console.error("Error connecting to local proxy:", err.message);
@@ -508,82 +751,165 @@ export function buildCli() {
         .description("Launch step-by-step interactive setup wizard")
         .action(async () => {
         p.intro("🚀 Welcome to TokenBuddy Interactive Wizard!");
+        const setupSummaryLines = [];
         // Step 1: Scan coding terminals
         const spinner = p.spinner();
         spinner.start("Scanning local system for programming terminals...");
         const candidates = detectProviders();
-        const detected = candidates.filter(c => c.detected);
+        const terminalOptions = buildInitTerminalOptions(candidates);
         spinner.stop("Scan completed.");
-        if (detected.length === 0) {
-            p.note("No active programming terminals detected. Install one of Codex, Claude Code, Claude Desktop, OpenClaw or Hermes first.");
+        if (terminalOptions.length === 1 && terminalOptions[0].value === OTHER_TERMINAL_OPTION.value) {
+            p.note("No active programming terminals detected. Install one of Codex, Claude Code, Claude Desktop, OpenCode, OpenClaw or Hermes first.");
         }
         else {
-            const choices = detected.map(c => ({
-                value: c.id,
-                label: c.name,
-                hint: c.configPath
-            }));
             const selected = await p.multiselect({
                 message: "Select programming terminals to route via TokenBuddy (use Space to select, Enter to confirm):",
-                options: choices,
+                options: terminalOptions,
                 required: false
             });
-            if (selected && selected.length > 0) {
-                spinner.start("Configuring proxy routing in selected terminals...");
+            const selectionError = validateInitTerminalSelection(selected);
+            if (selectionError) {
+                throw new Error(selectionError);
+            }
+            const selectedActionable = selected.filter((value) => !value.endsWith(":installed"));
+            const selectedOther = selectedActionable.includes(OTHER_TERMINAL_OPTION.value);
+            const selectedProviders = selectedActionable.filter((value) => value !== OTHER_TERMINAL_OPTION.value);
+            if (selectedOther) {
+                p.note([
+                    "✅ OpenAI-compatible Proxy",
+                    "   URL: http://127.0.0.1:17821/v1",
+                    "   Probe: http://127.0.0.1:17821/v1/models",
+                    "   Token: TOKENBUDDY_PROXY",
+                    "",
+                    "✅ Anthropic-compatible Proxy",
+                    "   URL: http://127.0.0.1:17821"
+                ].join("\n"), "TokenBuddy Proxy Interfaces");
+                setupSummaryLines.push("Manual terminal setup selected via Other.");
+            }
+            if (selectedProviders.length > 0) {
+                spinner.start("Fetching seller-backed model catalog...");
                 const proxyUrl = `http://127.0.0.1:${PROXY_PORT}`;
-                const defaultModel = "gpt-4";
+                const registryUrl = sellerRegistryUrlForInit();
+                let catalog;
+                try {
+                    catalog = await discoverSellerBackedModels(registryUrl);
+                }
+                catch (error) {
+                    spinner.stop("Failed to fetch seller-backed models.");
+                    throw error;
+                }
+                spinner.stop("Seller-backed model catalog loaded.");
+                const providerIds = selectedProviders.filter((provider) => {
+                    return [
+                        "codex",
+                        "claude-code",
+                        "claude-desktop",
+                        "openclaw",
+                        "opencode",
+                        "hermes",
+                    ].includes(provider);
+                });
+                const sellerRouting = await promptSellerRoutingPreference(catalog);
+                const providerSelections = await promptProviderSelections(providerIds, catalog, sellerRouting);
+                spinner.start("Configuring proxy routing in selected terminals...");
                 const store = openBuyerStore();
                 try {
                     applyProviderInstall({
-                        providers: selected,
+                        providers: providerIds,
                         proxyUrl,
-                        model: defaultModel
+                        providerSelections,
+                        sellerRouting,
                     }, store);
                 }
                 finally {
                     store.close();
                 }
                 spinner.stop("Selected terminals successfully configured.");
+                setupSummaryLines.push(`${providerIds.length} programming terminal${providerIds.length === 1 ? "" : "s"} configured for TokenBuddy.`);
             }
         }
         // Step 2: Choose Payment Method & Scan QR Activation
+        noteInitComingSoonPayments();
         const payMethod = await p.select({
             message: "Choose your primary payment method for LLM token purchases:",
-            options: [
-                { value: "clawtip", label: "JD ClawTip Pay (Scan QR Code to activate)", hint: "1 Fen activation fee" },
-                { value: "mock", label: "Mock Wallet (For local development and tests)" }
-            ]
+            options: INIT_PAYMENT_OPTIONS
         });
         if (payMethod === "clawtip") {
-            spinner.start("Requesting payment activation payload from public bootstrap registry...");
+            const store = openBuyerStore();
             try {
-                const bootstrapUrl = process.env.TOKENBUDDY_BOOTSTRAP_URL || "https://tb-wallet-bootstrap.fly.dev";
-                const res = await fetch(`${bootstrapUrl}/payments/clawtip/bootstrap`, {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({ clientTag: "cli-init" })
-                });
-                const data = await res.json();
-                spinner.stop("Bootstrap payload received.");
-                const qrUrl = data.payment?.resourceUrl || "https://example.com";
-                p.note("Scan the QR code below using your JD / WeChat App to complete the 1 Fen payment activation:");
-                // 💡 High fidelity QR code rendering directly inside the CLI terminal
-                qrcode.generate(qrUrl, { small: true });
-                // Start 5-second polling interval
-                spinner.start("Waiting for JD收银台 payment confirmation (polling activation status)...");
-                let activated = false;
-                for (let i = 0; i < 5; i++) {
-                    await new Promise(resolve => setTimeout(resolve, 3000));
-                    // Simulate/Wait confirmed. For real deployment, poll actual backend
+                const existingClawtip = detectExistingClawtipBinding(store.getPayment("clawtip"));
+                if (existingClawtip) {
+                    store.savePayment({
+                        method: "clawtip",
+                        enabled: true,
+                        isDefault: true,
+                        config: existingClawtip.config
+                    });
+                    const details = [
+                        existingClawtip.orderNo ? `Order: ${existingClawtip.orderNo}` : undefined,
+                        existingClawtip.resourceUrl ? `ResourceUrl: ${existingClawtip.resourceUrl}` : undefined
+                    ].filter(Boolean).join("\n");
+                    logger.info("payment.channel.reused", "clawtip payment channel already configured locally", {
+                        method: "clawtip",
+                        hasOrderNo: Boolean(existingClawtip.orderNo),
+                        hasResourceUrl: Boolean(existingClawtip.resourceUrl)
+                    });
+                    p.note(details
+                        ? `ClawTip wallet is already configured locally.\n${details}`
+                        : "ClawTip wallet is already configured locally.", "ClawTip");
+                    setupSummaryLines.push("ClawTip wallet already bound locally; activation skipped.");
+                }
+                else {
+                    spinner.start("Requesting payment activation payload from public bootstrap registry...");
+                    const bootstrapUrl = process.env.TOKENBUDDY_BOOTSTRAP_URL || "https://tb-wallet-bootstrap.fly.dev";
+                    const res = await fetch(`${bootstrapUrl}/payments/clawtip/bootstrap`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ clientTag: "cli-init" })
+                    });
+                    const data = await res.json();
+                    spinner.stop("Bootstrap payload received.");
+                    const qrUrl = data.payment?.resourceUrl || "https://example.com";
+                    p.note("Scan the QR code below using your JD / WeChat App to complete the 1 Fen payment activation:");
+                    // 💡 High fidelity QR code rendering directly inside the CLI terminal
+                    qrcode.generate(qrUrl, { small: true });
+                    // Start 5-second polling interval
+                    spinner.start("Waiting for JD收银台 payment confirmation (polling activation status)...");
+                    for (let i = 0; i < 5; i++) {
+                        await new Promise(resolve => setTimeout(resolve, 3000));
+                        // Simulate/Wait confirmed. For real deployment, poll actual backend
+                    }
+                    spinner.stop("JD收银台 confirmed payment. ClawTip wallet is active! 🚀");
+                    store.savePayment({
+                        method: "clawtip",
+                        enabled: true,
+                        isDefault: true,
+                        config: {
+                            bootstrapUrl,
+                            orderNo: data.payment?.orderNo,
+                            amountFen: data.payment?.amountFen ?? data.activationFeeFen,
+                            indicator: data.payment?.indicator,
+                            slug: data.payment?.slug,
+                            skillId: data.payment?.skillId,
+                            description: data.payment?.description,
+                            resourceUrl: data.payment?.resourceUrl,
+                            proofRequired: false
+                        }
+                    });
+                    logger.info("payment.channel.added", "clawtip payment channel added during init", {
+                        method: "clawtip",
+                        orderNo: data.payment?.orderNo
+                    });
+                    setupSummaryLines.push("ClawTip wallet activated and set as the default payment method.");
                 }
-                spinner.stop("JD收银台 confirmed payment. ClawTip wallet is active! 🚀");
             }
             catch (err) {
-                spinner.stop(`Failed to fetch activation QR: ${err.message}`);
+                spinner.stop(`Failed to finish ClawTip setup: ${err.message}`);
+                setupSummaryLines.push("ClawTip activation requires follow-up because the bootstrap step did not complete.");
+            }
+            finally {
+                store.close();
             }
-        }
-        else {
-            p.note("Mock Wallet selected. No real payments will be made. Status is active.");
         }
         // Step 3: Install Launchd Daemon Service
         if (process.platform === "darwin") {
@@ -631,6 +957,7 @@ export function buildCli() {
                     catch { }
                     execSync(`launchctl load ${plistPath}`);
                     spinner.stop("LaunchAgent daemon successfully registered and started! 🚀");
+                    setupSummaryLines.push("Background tb-proxyd launchd service installed.");
                 }
                 catch (err) {
                     spinner.stop(`Failed to write launchd plist: ${err.message}`);
@@ -640,8 +967,9 @@ export function buildCli() {
         else {
             // Run background dettached child process in linux/windows
             p.note("System daemon is active. Process runs in dettached background.");
+            setupSummaryLines.push("Background daemon mode is available on this system.");
         }
-        p.outro("🎉 Setup complete! Run `tb doctor` to audit status anytime. Let's code!");
+        p.outro(buildInitSuccessMessage(setupSummaryLines));
     });
     return program;
 }