@tokenbuddy/tokenbuddy 1.0.6 → 1.0.7

package/src/cli.ts

@@ -36,15 +36,24 @@ import {
   renderDoctorDiagnosticsProgressively,
 } from "./doctor-diagnostics.js";
 import {
-  buildInitTerminalOptions,
   buildInitSuccessMessage,
-  detectExistingClawtipBinding,
+  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";
@@ -162,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" };
@@ -335,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" },
@@ -348,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) {
@@ -913,15 +962,21 @@ export function buildCli(): Command {
       const spinner = p.spinner();
       spinner.start("Scanning local system for programming terminals...");
       const candidates = detectProviders();
-      const terminalOptions = buildInitTerminalOptions(candidates);
+      const terminalSelection = buildInitTerminalSelectionState(candidates);
       spinner.stop("Scan completed.");
 
-      if (terminalOptions.length === 1 && terminalOptions[0].value === OTHER_TERMINAL_OPTION.value) {
+      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: terminalOptions,
+          options: terminalSelection.options,
           required: false
         }) as string[];
 
@@ -1008,7 +1063,9 @@ export function buildCli(): Command {
       if (payMethod === "clawtip") {
         const store = openBuyerStore();
         try {
-          const existingClawtip = detectExistingClawtipBinding(store.getPayment("clawtip"));
+          let walletConfig = inspectOpenClawWalletConfig();
+          const clawtipReadiness = inspectClawtipWalletReadiness(store.getPayment("clawtip"), walletConfig);
+          const existingClawtip = clawtipReadiness.reusableBinding;
           if (existingClawtip) {
             store.savePayment({
               method: "clawtip",
@@ -1033,30 +1090,159 @@ export function buildCli(): Command {
             );
             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 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();
+            const bootstrap = await fetchClawtipBootstrap(bootstrapUrl);
             spinner.stop("Bootstrap payload received.");
 
-            const qrUrl = data.payment?.resourceUrl || "https://example.com";
+            if (!bootstrap.payment?.orderNo || !bootstrap.payment?.indicator) {
+              throw new Error("ClawTip bootstrap response missing orderNo or indicator.");
+            }
 
-            p.note("Scan the QR code below using your JD / WeChat App to complete the 1 Fen payment activation:");
+            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();
+              }
 
-            // 💡 High fidelity QR code rendering directly inside the CLI terminal
-            qrcode.generate(qrUrl, { small: true });
+              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;
+              }
+            }
 
-            // 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
+            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(" ")
+              );
             }
-            spinner.stop("JD收银台 confirmed payment. ClawTip wallet is active! 🚀");
+            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",
@@ -1064,21 +1250,53 @@ export function buildCli(): Command {
               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
+                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: data.payment?.orderNo
+              orderNo: bootstrap.payment?.orderNo,
+              payCredentialWritten: Boolean(payCredential),
+              activationCompletedBy
             });
-            setupSummaryLines.push("ClawTip wallet activated and set as the default payment method.");
+            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.");
+            }
           }
         } catch (err: any) {
           spinner.stop(`Failed to finish ClawTip setup: ${err.message}`);