@tokenbuddy/tokenbuddy 1.0.4 → 1.0.6

package/src/cli.ts

@@ -6,10 +6,45 @@ 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 {
+  buildInitTerminalOptions,
+  buildInitSuccessMessage,
+  detectExistingClawtipBinding,
+  INIT_PAYMENT_OPTIONS,
+  noteInitComingSoonPayments,
+  OTHER_TERMINAL_OPTION,
+  type InitPaymentMethod,
+  validateInitTerminalSelection,
+} from "./init-payment-options.js";
 
 // @ts-ignore
 import qrcode from "qrcode-terminal";
@@ -53,6 +88,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);
 }
@@ -328,6 +369,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 +638,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 +648,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 +684,7 @@ export function buildCli(): Command {
             plistPath,
             plistExists: plistPath ? fs.existsSync(plistPath) : false
           },
-          providers: candidates
+          ...diagnostics,
         }, null, 2));
         return;
       }
@@ -422,12 +719,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 +869,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 +907,185 @@ 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 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
         }) 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
+          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: 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)...");
+            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: 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 +1137,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 +1145,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;