@tokenbuddy/tokenbuddy 1.0.5 → 1.0.7

package/dist/src/cli.js

@@ -6,10 +6,15 @@ 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 { buildInitSuccessMessage, buildInitTerminalSelectionState, buildInstalledTerminalMessage, INIT_PAYMENT_OPTIONS, inspectClawtipWalletReadiness, inspectOpenClawWalletConfig, noteInitComingSoonPayments, OTHER_TERMINAL_OPTION, validateInitTerminalSelection, } from "./init-payment-options.js";
+import { checkOpenClawRuntime, readClawtipPayCredential, startClawtipWalletBootstrap, waitForClawtipActivationConfirmation, } from "./init-clawtip-activation.js";
+import { displayTerminalImage } from "./terminal-image.js";
 // @ts-ignore
 import qrcode from "qrcode-terminal";
 const CONTROL_PORT = 17820;
@@ -75,6 +80,7 @@ async function probeDaemonStatus(controlPort) {
         };
     }
 }
+const CLAWTIP_BOOTSTRAP_PLACEHOLDER_PAY_TO = "bootstrap-pay-to";
 async function waitForDaemonStatus(controlPort, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     let latest = { running: false, error: "not checked" };
@@ -230,7 +236,7 @@ function printPaymentList(payments, asJson) {
     console.log("=== TokenBuddy Payment Methods ===");
     console.log(table.toString());
 }
-async function fetchClawtipBootstrap(bootstrapUrl) {
+export async function fetchClawtipBootstrap(bootstrapUrl) {
     const response = await fetch(`${bootstrapUrl.replace(/\/+$/, "")}/payments/clawtip/bootstrap`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -243,8 +249,32 @@ async function fetchClawtipBootstrap(bootstrapUrl) {
     if (!body.payment?.orderNo || !body.payment.indicator || !body.payment.resourceUrl) {
         throw new Error("ClawTip bootstrap response missing payment order fields");
     }
+    if ((body.payment.payTo || "").trim() === CLAWTIP_BOOTSTRAP_PLACEHOLDER_PAY_TO) {
+        throw new Error([
+            `ClawTip bootstrap service is misconfigured: payTo is still the placeholder \`${CLAWTIP_BOOTSTRAP_PLACEHOLDER_PAY_TO}\`.`,
+            `Bootstrap URL: ${bootstrapUrl}`,
+            "Configure the bootstrap service with the real ClawTip merchant pay_to before retrying `tb init`.",
+        ].join(" "));
+    }
+    body.payment.resourceUrl = normalizeClawtipBootstrapResourceUrl(bootstrapUrl, body.payment.resourceUrl);
     return body;
 }
+export function normalizeClawtipBootstrapResourceUrl(bootstrapUrl, resourceUrl) {
+    try {
+        const bootstrap = new URL(bootstrapUrl);
+        const resource = new URL(resourceUrl);
+        if (resource.origin === bootstrap.origin && resource.pathname === "/registry/sellers") {
+            resource.pathname = bootstrap.pathname.replace(/\/+$/, "") || "/";
+            resource.search = "";
+            resource.hash = "";
+            return resource.toString().replace(/\/$/, "");
+        }
+    }
+    catch {
+        // Leave the server-provided value unchanged when URL parsing fails.
+    }
+    return resourceUrl;
+}
 function readProof(options) {
     const proofFile = options.proofFile || process.env.TOKENBUDDY_CLAWTIP_PROOF_FILE;
     if (!proofFile) {
@@ -262,6 +292,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 +518,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 +528,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 +563,7 @@ export function buildCli() {
                     plistPath,
                     plistExists: plistPath ? fs.existsSync(plistPath) : false
                 },
-                providers: candidates
+                ...diagnostics,
             }, null, 2));
             return;
         }
@@ -351,12 +596,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 +742,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 +778,307 @@ 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 terminalSelection = buildInitTerminalSelectionState(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.");
+        const installedTerminalMessage = buildInstalledTerminalMessage(terminalSelection.installed);
+        if (installedTerminalMessage) {
+            p.note(installedTerminalMessage, "Already Configured");
+            setupSummaryLines.push(`${terminalSelection.installed.length} terminal${terminalSelection.installed.length === 1 ? "" : "s"} already configured.`);
+        }
+        if (terminalSelection.options.length === 1 && terminalSelection.options[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: terminalSelection.options,
                 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
+                let walletConfig = inspectOpenClawWalletConfig();
+                const clawtipReadiness = inspectClawtipWalletReadiness(store.getPayment("clawtip"), walletConfig);
+                const existingClawtip = clawtipReadiness.reusableBinding;
+                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 {
+                    if (clawtipReadiness.status === "metadata_missing_wallet") {
+                        p.note([
+                            clawtipReadiness.message,
+                            `Expected: ${walletConfig.expectedPath}`,
+                            walletConfig.alternatePaths.length > 0
+                                ? `Alternates: ${walletConfig.alternatePaths.join(", ")}`
+                                : "Alternates: -"
+                        ].join("\n"), "ClawTip");
+                        setupSummaryLines.push("Saved ClawTip metadata found, but local wallet config is missing; activation restarted.");
+                    }
+                    const walletReadyBeforePay = walletConfig.exists;
+                    let openClawVersion;
+                    if (!walletReadyBeforePay) {
+                        spinner.start("Checking OpenClaw CLI before ClawTip wallet bootstrap...");
+                        openClawVersion = await checkOpenClawRuntime();
+                        spinner.stop("OpenClaw CLI detected.");
+                    }
+                    spinner.start("Requesting payment activation payload from public bootstrap registry...");
+                    const bootstrapUrl = process.env.TOKENBUDDY_BOOTSTRAP_URL || "https://tb-wallet-bootstrap.fly.dev";
+                    const bootstrap = await fetchClawtipBootstrap(bootstrapUrl);
+                    spinner.stop("Bootstrap payload received.");
+                    if (!bootstrap.payment?.orderNo || !bootstrap.payment?.indicator) {
+                        throw new Error("ClawTip bootstrap response missing orderNo or indicator.");
+                    }
+                    const activationPayment = {
+                        orderNo: bootstrap.payment.orderNo,
+                        amountFen: bootstrap.payment.amountFen ?? bootstrap.activationFeeFen ?? 1,
+                        payTo: bootstrap.payment.payTo,
+                        encryptedData: bootstrap.payment.encryptedData,
+                        indicator: bootstrap.payment.indicator,
+                        slug: bootstrap.payment.slug,
+                        skillId: bootstrap.payment.skillId,
+                        description: bootstrap.payment.description,
+                        resourceUrl: bootstrap.payment.resourceUrl,
+                    };
+                    spinner.start("Starting the ClawTip payment activation flow...");
+                    let activation = await startClawtipWalletBootstrap(activationPayment);
+                    spinner.stop("ClawTip payment activation finished.");
+                    let payCredential = activation.payCredential;
+                    for (let authAttempt = 1; (walletReadyBeforePay ? !payCredential : !walletConfig.exists)
+                        && activation.parsedOutput.requiresWalletAuth
+                        && authAttempt <= 3; authAttempt += 1) {
+                        let qrDisplayMessage;
+                        let manualOpenCommand;
+                        if (activation.parsedOutput.mediaPath) {
+                            const qrDisplay = await displayTerminalImage(activation.parsedOutput.mediaPath);
+                            qrDisplayMessage = qrDisplay.message;
+                            manualOpenCommand = qrDisplay.fallbackCommand;
+                        }
+                        if (!activation.parsedOutput.mediaPath && !activation.parsedOutput.authUrl) {
+                            throw new Error(`ClawTip pay requested authorization but did not return QR media or authUrl. Order file: ${activation.orderFile}`);
+                        }
+                        p.note([
+                            activation.parsedOutput.mediaPath
+                                ? `Open or scan this ClawTip wallet QR image with the JD app: ${activation.parsedOutput.mediaPath}`
+                                : undefined,
+                            activation.parsedOutput.authUrl
+                                ? `Open or scan this ClawTip wallet auth URL with the JD app: ${activation.parsedOutput.authUrl}`
+                                : undefined,
+                            qrDisplayMessage,
+                            manualOpenCommand ? `Manual open command: ${manualOpenCommand}` : undefined,
+                            activation.parsedOutput.clawtipId ? `clawtipId: ${activation.parsedOutput.clawtipId}` : undefined,
+                            activation.parsedOutput.clawtipId
+                                ? "After scanning, ClawTip CLI will register the local agent wallet."
+                                : "After scanning, TokenBuddy will retry ClawTip payment activation.",
+                            `Expected wallet config: ${walletConfig.expectedPath}`,
+                            openClawVersion ? `OpenClaw: ${openClawVersion}` : undefined,
+                        ].filter(Boolean).join("\n"), activation.parsedOutput.clawtipId ? "ClawTip Wallet QR" : "ClawTip Authorization QR");
+                        if (activation.parsedOutput.clawtipId && !walletReadyBeforePay) {
+                            spinner.start("Waiting for ClawTip wallet registration. Press Ctrl+C to cancel.");
+                            const walletRegistered = await waitForClawtipActivationConfirmation({
+                                clawtipId: activation.parsedOutput.clawtipId,
+                            });
+                            spinner.stop(walletRegistered
+                                ? "Detected local OpenClaw ClawTip wallet config."
+                                : "ClawTip wallet registration cancelled.");
+                            if (!walletRegistered) {
+                                setupSummaryLines.push("ClawTip wallet registration was cancelled before local wallet config was saved.");
+                                process.exitCode = 1;
+                                return;
+                            }
+                            walletConfig = inspectOpenClawWalletConfig();
+                            if (!walletConfig.exists) {
+                                throw new Error(`ClawTip wallet registration finished but wallet config is still missing: ${walletConfig.expectedPath}`);
+                            }
+                            setupSummaryLines.push("ClawTip wallet registered locally.");
+                        }
+                        else {
+                            const authorized = await p.confirm({
+                                message: "Scan or authorize this ClawTip QR in the JD app, then press Enter to retry payment activation.",
+                                initialValue: true,
+                            });
+                            if (authorized !== true) {
+                                setupSummaryLines.push("ClawTip authorization was cancelled before payment activation completed.");
+                                process.exitCode = 1;
+                                return;
+                            }
+                            walletConfig = inspectOpenClawWalletConfig();
+                        }
+                        payCredential = readClawtipPayCredential(activation.orderFile);
+                        if (!payCredential) {
+                            spinner.start(`Retrying ClawTip payment activation after authorization (${authAttempt}/3)...`);
+                            activation = await startClawtipWalletBootstrap(activationPayment);
+                            spinner.stop("ClawTip payment activation retry finished.");
+                            payCredential = activation.payCredential;
+                        }
+                    }
+                    const refreshedWalletConfig = inspectOpenClawWalletConfig();
+                    if (!walletReadyBeforePay && !refreshedWalletConfig.exists) {
+                        const paymentQrMessage = activation.parsedOutput.mediaPath
+                            ? ` ClawTip pay returned QR media: ${activation.parsedOutput.mediaPath}`
+                            : " ClawTip pay did not return QR media.";
+                        throw new Error([
+                            `ClawTip wallet config is still missing after payment activation: ${refreshedWalletConfig.expectedPath}.`,
+                            `Order file: ${activation.orderFile}.`,
+                            paymentQrMessage.trim(),
+                        ].join(" "));
+                    }
+                    const completedByWalletConfig = !payCredential && !walletReadyBeforePay && refreshedWalletConfig.exists;
+                    if (!payCredential && !completedByWalletConfig) {
+                        const paymentQrMessage = activation.parsedOutput.mediaPath
+                            ? ` ClawTip pay returned QR media: ${activation.parsedOutput.mediaPath}`
+                            : "";
+                        throw new Error(`ClawTip pay did not write payCredential to the order file. Order file: ${activation.orderFile}.${paymentQrMessage}`);
+                    }
+                    const activationCompletedBy = payCredential
+                        ? (refreshedWalletConfig.exists ? "payCredential+wallet-config" : "payCredential")
+                        : "wallet-config";
+                    store.savePayment({
+                        method: "clawtip",
+                        enabled: true,
+                        isDefault: true,
+                        config: {
+                            bootstrapUrl,
+                            orderNo: bootstrap.payment?.orderNo,
+                            amountFen: bootstrap.payment?.amountFen ?? bootstrap.activationFeeFen,
+                            indicator: bootstrap.payment?.indicator,
+                            slug: bootstrap.payment?.slug,
+                            skillId: bootstrap.payment?.skillId,
+                            description: bootstrap.payment?.description,
+                            resourceUrl: bootstrap.payment?.resourceUrl,
+                            proofRequired: false,
+                            activationOrderFile: activation.orderFile,
+                            walletConfigPath: refreshedWalletConfig.expectedPath,
+                            walletConfigPresent: refreshedWalletConfig.exists,
+                            payCredentialWritten: Boolean(payCredential),
+                            activationCompletedBy
+                        }
+                    });
+                    logger.info("payment.channel.added", "clawtip payment channel added during init", {
+                        method: "clawtip",
+                        orderNo: bootstrap.payment?.orderNo,
+                        payCredentialWritten: Boolean(payCredential),
+                        activationCompletedBy
+                    });
+                    if (refreshedWalletConfig.exists) {
+                        if (!payCredential) {
+                            p.note([
+                                "OpenClaw saved the local ClawTip wallet config, but the ClawTip order file did not contain payCredential.",
+                                `Order file: ${activation.orderFile}`,
+                                "TokenBuddy saved the wallet binding metadata and will rely on the local wallet for future ClawTip purchases."
+                            ].join("\n"), "ClawTip");
+                        }
+                        setupSummaryLines.push("ClawTip wallet activated and set as the default payment method.");
+                    }
+                    else {
+                        p.note([
+                            "ClawTip payment metadata was saved, but the local OpenClaw wallet config is still missing.",
+                            `Expected: ${refreshedWalletConfig.expectedPath}`,
+                            refreshedWalletConfig.alternatePaths.length > 0
+                                ? `Nearby files: ${refreshedWalletConfig.alternatePaths.join(", ")}`
+                                : "Nearby files: -",
+                            "Bind or restore the local wallet before using ClawTip-backed purchases."
+                        ].join("\n"), "ClawTip Wallet Required");
+                        setupSummaryLines.push("ClawTip payment metadata saved; local wallet config still needs binding before use.");
+                    }
                 }
-                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 +1126,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 +1136,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;
 }