@tokenbuddy/tokenbuddy 1.0.5 → 1.0.7

package/src/cli.ts

@@ -6,10 +6,54 @@ import * as os from "os";
 import { execSync, spawn } from "child_process";
 import Table from "cli-table3";
 import { BuyerStore, PaymentConfig } from "./buyer-store.js";
-import { applyProviderInstall, detectProviders } from "./provider-install.js";
+import {
+  applyProviderInstall,
+  detectProviders,
+  getProviderModelSelectionKind,
+  getProviderProtocolPreference,
+  type ClaudeCodeModelMappingConfig,
+  type ProviderId,
+  type ProviderSelections,
+  type SingleModelProviderRuntimeConfig,
+} from "./provider-install.js";
 import { createModuleLogger } from "@tokenbuddy/logging";
 import * as crypto from "crypto";
 import { fileURLToPath } from "url";
+import {
+  discoverSellerBackedModels,
+  filterCatalogByProtocol,
+  filterCatalogBySeller,
+  type ModelCatalogEntry,
+  type SellerCatalogResult,
+  type SellerRoutingPreference,
+} 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,
+  type InitPaymentMethod,
+  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";
@@ -53,6 +97,12 @@ interface ClawtipBootstrapResponse {
   };
 }
 
+interface SelectOption {
+  value: string;
+  label: string;
+  hint?: string;
+}
+
 function isSupportedPaymentMethod(method: string): method is SupportedPaymentMethod {
   return (SUPPORTED_PAYMENT_METHODS as readonly string[]).includes(method);
 }
@@ -121,6 +171,20 @@ async function probeDaemonStatus(controlPort: number): Promise<DaemonProbeResult
   }
 }
 
+interface NormalizedClawtipPaymentPayload {
+  orderNo: string;
+  amountFen?: number;
+  payTo?: string;
+  encryptedData?: string;
+  indicator: string;
+  slug?: string;
+  skillId?: string;
+  description?: string;
+  resourceUrl: string;
+}
+
+const CLAWTIP_BOOTSTRAP_PLACEHOLDER_PAY_TO = "bootstrap-pay-to";
+
 async function waitForDaemonStatus(controlPort: number, timeoutMs: number): Promise<DaemonProbeResult> {
   const deadline = Date.now() + timeoutMs;
   let latest: DaemonProbeResult = { running: false, error: "not checked" };
@@ -294,7 +358,7 @@ function printPaymentList(payments: PaymentConfig[], asJson: boolean): void {
   console.log(table.toString());
 }
 
-async function fetchClawtipBootstrap(bootstrapUrl: string): Promise<ClawtipBootstrapResponse> {
+export async function fetchClawtipBootstrap(bootstrapUrl: string): Promise<ClawtipBootstrapResponse> {
   const response = await fetch(`${bootstrapUrl.replace(/\/+$/, "")}/payments/clawtip/bootstrap`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -307,9 +371,35 @@ async function fetchClawtipBootstrap(bootstrapUrl: string): Promise<ClawtipBoots
   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: string, resourceUrl: string): string {
+  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: { proofFile?: string; requireProof?: boolean }): string | undefined {
   const proofFile = options.proofFile || process.env.TOKENBUDDY_CLAWTIP_PROOF_FILE;
   if (!proofFile) {
@@ -328,6 +418,251 @@ function readProof(options: { proofFile?: string; requireProof?: boolean }): str
   return proof;
 }
 
+function sellerRegistryUrlForInit(): string {
+  return process.env.TB_PROXYD_SELLER_REGISTRY_URL || "https://tb-wallet-bootstrap.fly.dev/registry/sellers";
+}
+
+function stableModelChoices(models: ModelCatalogEntry[]): SelectOption[] {
+  const grouped = new Map<string, ModelCatalogEntry[]>();
+  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: SellerCatalogResult): Promise<SellerRoutingPreference> {
+  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.",
+      },
+    ],
+  }) as SellerRoutingPreference["mode"] | symbol;
+
+  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,
+    })),
+  }) as string | symbol;
+
+  if (typeof sellerId !== "string") {
+    throw new Error("fixed seller selection was cancelled");
+  }
+  return {
+    mode,
+    sellerId,
+  };
+}
+
+async function promptSingleModelSelection(
+  providerId: ProviderId,
+  models: ModelCatalogEntry[],
+  sellerRouting: SellerRoutingPreference,
+): Promise<SingleModelProviderRuntimeConfig> {
+  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: Record<string, string> = {
+    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,
+  }) as string | symbol;
+
+  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: string): string {
+  return modelId.trim();
+}
+
+function makeClaudeRoleMapping(modelId: string): ClaudeCodeModelMappingConfig {
+  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: ModelCatalogEntry[],
+): Promise<ClaudeCodeModelMappingConfig> {
+  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,
+  }) as string | symbol;
+
+  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,
+  }) as string | symbol;
+  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,
+  }) as string | symbol;
+  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: ProviderId[],
+  catalog: SellerCatalogResult,
+  sellerRouting: SellerRoutingPreference,
+): Promise<ProviderSelections> {
+  const baseModels = sellerRouting.mode === "fixed"
+    ? filterCatalogBySeller(catalog.models, sellerRouting.sellerId)
+    : catalog.models;
+
+  const selections: ProviderSelections = {};
+  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(): Command {
   const program = new Command();
   program
@@ -352,7 +687,6 @@ export function buildCli(): Command {
       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: DaemonRepairResult = { attempted: false, fixed: false };
       if (!probe.running && options.fix) {
@@ -363,11 +697,23 @@ export function buildCli(): Command {
       const daemonInfo = probe.status;
       const daemonRunning = probe.running;
       const daemonError = probe.error;
+      const daemonStatus = daemonInfo && typeof daemonInfo === "object"
+        ? daemonInfo as { selectionMode?: string; sellerRoutingMode?: string; selectedSellerId?: string; sellerRegistryUrl?: string }
+        : 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,
@@ -387,7 +733,7 @@ export function buildCli(): Command {
             plistPath,
             plistExists: plistPath ? fs.existsSync(plistPath) : false
           },
-          providers: candidates
+          ...diagnostics,
         }, null, 2));
         return;
       }
@@ -422,12 +768,29 @@ export function buildCli(): Command {
         }
       }
 
-      // 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
@@ -555,22 +918,32 @@ export function buildCli(): Command {
     .option("--json", "Output model list as JSON")
     .action(async (options: { json?: boolean }) => {
       try {
+        const controlPort = configuredControlPort();
+        const proxyPort = configuredProxyPort();
+        const status = await probeDaemonStatus(controlPort);
+        const daemonInfo = status.status && typeof status.status === "object"
+          ? status.status as { sellerRegistryUrl?: string }
+          : 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: any) {
         console.error("Error connecting to local proxy:", err.message);
         process.exitCode = 1;
@@ -583,88 +956,354 @@ export function buildCli(): Command {
     .description("Launch step-by-step interactive setup wizard")
     .action(async () => {
       p.intro("🚀 Welcome to TokenBuddy Interactive Wizard!");
+      const setupSummaryLines: string[] = [];
 
       // 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.");
-      } else {
-        const choices = detected.map(c => ({
-          value: c.id,
-          label: c.name,
-          hint: c.configPath
-        }));
+      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 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
         }) as string[];
 
-        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: SellerCatalogResult;
+          try {
+            catalog = await discoverSellerBackedModels(registryUrl);
+          } catch (error: unknown) {
+            spinner.stop("Failed to fetch seller-backed models.");
+            throw error;
+          }
+          spinner.stop("Seller-backed model catalog loaded.");
+
+          const providerIds = selectedProviders.filter((provider): provider is ProviderId => {
+            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)" }
-        ]
-      }) as string;
+        options: INIT_PAYMENT_OPTIONS
+      }) as InitPaymentMethod;
 
       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: any = 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: string | undefined;
+            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: string | undefined;
+              let manualOpenCommand: string | undefined;
+              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: any) {
-          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
@@ -716,6 +1355,7 @@ export function buildCli(): Command {
             } catch {}
             execSync(`launchctl load ${plistPath}`);
             spinner.stop("LaunchAgent daemon successfully registered and started! 🚀");
+            setupSummaryLines.push("Background tb-proxyd launchd service installed.");
           } catch (err: any) {
             spinner.stop(`Failed to write launchd plist: ${err.message}`);
           }
@@ -723,9 +1363,10 @@ export function buildCli(): Command {
       } 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;