@tokenbuddy/tokenbuddy 1.0.6 → 1.0.8

package/src/init-clawtip-activation.ts

@@ -0,0 +1,487 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { spawn } from "child_process";
+import {
+  inspectOpenClawWalletConfig,
+  type OpenClawWalletConfigState,
+} from "./init-payment-options.js";
+
+const DEFAULT_POLL_INTERVAL_MS = 2_000;
+const SLEEP_SLICE_MS = 200;
+const CLAWTIP_MIN_CLI_VERSION = "1.0.4";
+const CLAWTIP_MIN_SKILL_VERSION = "1.0.12";
+
+export interface ClawtipBootstrapPayment {
+  orderNo: string;
+  amountFen: number;
+  payTo?: string;
+  encryptedData?: string;
+  indicator: string;
+  slug?: string;
+  skillId?: string;
+  description?: string;
+  resourceUrl?: string;
+}
+
+export interface ParsedClawtipOutput {
+  authUrl?: string;
+  clawtipId?: string;
+  mediaPath?: string;
+  failureMessage?: string;
+  requiresWalletAuth: boolean;
+  walletReady: boolean;
+}
+
+export interface WaitForClawtipActivationOptions {
+  inspectWalletConfig?: () => OpenClawWalletConfigState;
+  isCancelled?: () => boolean;
+  clawtipId?: string;
+  checkRegister?: (clawtipId: string) => Promise<void>;
+  cancel?: (message?: string) => void;
+  pollIntervalMs?: number;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+export interface StartClawtipWalletBootstrapOptions {
+  home?: string;
+  runClawtipCommand?: (args: string[]) => Promise<string>;
+}
+
+export interface CheckOpenClawRuntimeOptions {
+  runOpenClawCommand?: (args: string[]) => Promise<string>;
+}
+
+function defaultSleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function defaultHomeDir(): string {
+  return process.env.HOME || os.homedir();
+}
+
+function clawtipOrderFilePath(home: string, indicator: string, orderNo: string): string {
+  return path.join(home, ".openclaw", "skills", "orders", indicator, `${orderNo}.json`);
+}
+
+function sanitizeClawtipOutput(output: string): string {
+  return output
+    .split("\n")
+    .map((line) => {
+      if (line.includes("\"u\"") || line.includes("payCredential") || line.includes("access_token")) {
+        return "<redacted sensitive ClawTip output>";
+      }
+      return line;
+    })
+    .join("\n");
+}
+
+function isClawtipPayWalletAuthOutput(args: string[], output: string): boolean {
+  if (!args.includes("pay")) {
+    return false;
+  }
+  const lower = output.toLowerCase();
+  return lower.includes("authurl")
+    || output.includes("MEDIA:")
+    || lower.includes("clawtipid")
+    || lower.includes("qrcode")
+    || lower.includes("扫码");
+}
+
+async function runClawtipCli(args: string[]): Promise<string> {
+  return await new Promise((resolve, reject) => {
+    const child = spawn("npx", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      const combined = `${stdout}${stderr}`;
+      if (code === 0) {
+        resolve(combined);
+        return;
+      }
+      if (isClawtipPayWalletAuthOutput(args, combined)) {
+        resolve(combined);
+        return;
+      }
+      reject(new Error(`ClawTip command failed with exit ${code}: ${sanitizeClawtipOutput(combined)}`));
+    });
+  });
+}
+
+async function runOpenClawCli(args: string[]): Promise<string> {
+  return await new Promise((resolve, reject) => {
+    const child = spawn("openclaw", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      const combined = `${stdout}${stderr}`;
+      if (code === 0) {
+        resolve(combined);
+        return;
+      }
+      reject(new Error(`OpenClaw command failed with exit ${code}: ${combined.trim()}`));
+    });
+  });
+}
+
+function findValueAfterKeys(output: string, keys: string[]): string | undefined {
+  for (const line of output.split("\n")) {
+    for (const key of keys) {
+      const index = line.indexOf(key);
+      if (index < 0) {
+        continue;
+      }
+      const raw = line.slice(index + key.length);
+      const value = raw
+        .replace(/^[:=\s]+/, "")
+        .replace(/^["']+|["',\s]+$/g, "")
+        .trim();
+      if (value) {
+        return value;
+      }
+    }
+  }
+  return undefined;
+}
+
+function lineContainsWalletAuthCue(line: string): boolean {
+  const lower = line.toLowerCase();
+  return lower.includes("authurl")
+    || lower.includes("scan")
+    || lower.includes("扫码")
+    || lower.includes("授权")
+    || lower.includes("qrcode")
+    || lower.includes("clawtipid")
+    || lower.includes("safeMonitor".toLowerCase())
+    || lower.includes("unifiedauthm");
+}
+
+function findUrlInOutput(output: string): string | undefined {
+  for (const line of output.split("\n")) {
+    if (line.includes("process.env.CLAWTIP_PAY")
+      || line.includes("process.env.GET_PUBLIC_KEY")
+      || line.includes("process.env.QUERY_TOKEN")) {
+      continue;
+    }
+    const matches = line.match(/https?:\/\/\S+/g) || [];
+    for (const match of matches) {
+      const value = match.trim().replace(/^["'`([{\s]+|["'`)\]},.\s]+$/g, "");
+      if (!(value.startsWith("https://") || value.startsWith("http://"))) {
+        continue;
+      }
+      const lower = value.toLowerCase();
+      if (value.includes("clawtipId")
+        || lower.includes("/qrcode")
+        || lower.includes("safemonitor")
+        || lower.includes("unifiedauthm")
+        || lineContainsWalletAuthCue(line)) {
+        return value;
+      }
+    }
+  }
+  return undefined;
+}
+
+function findMediaPathInOutput(output: string): string | undefined {
+  const keyedPath = findValueAfterKeys(output, ["MEDIA", "media", "mediaPath", "media_path"]);
+  if (keyedPath) {
+    return keyedPath;
+  }
+
+  for (const line of output.split("\n").reverse()) {
+    const value = line.trim().replace(/^["'`]+|["'`,\s]+$/g, "");
+    if (path.isAbsolute(value) && /\.(png|jpe?g|webp)$/i.test(value)) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function findClawtipFailureMessage(output: string): string | undefined {
+  for (const line of output.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed.includes("商家信息有误")
+      || trimmed.includes("商户信息有误")
+      || trimmed.includes("支付失败")
+      || trimmed.includes("下单失败")) {
+      return sanitizeClawtipOutput(trimmed);
+    }
+  }
+  return undefined;
+}
+
+function decodeClawtipValue(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function clawtipQrWorkspaceDir(home: string): string {
+  return path.join(home, ".openclaw", "workspace", "clawtip", "qrcode");
+}
+
+function findLatestGeneratedQrMediaPath(home: string, createdAfterMs: number): string | undefined {
+  const qrDir = clawtipQrWorkspaceDir(home);
+  if (!fs.existsSync(qrDir)) {
+    return undefined;
+  }
+
+  const candidates = fs.readdirSync(qrDir)
+    .filter((fileName) => /^qrcode-.*\.(png|jpe?g|webp)$/i.test(fileName))
+    .map((fileName) => {
+      const filePath = path.join(qrDir, fileName);
+      return {
+        filePath,
+        mtimeMs: fs.statSync(filePath).mtimeMs,
+      };
+    })
+    .filter((entry) => entry.mtimeMs >= createdAfterMs - 1_000)
+    .sort((left, right) => right.mtimeMs - left.mtimeMs);
+
+  return candidates[0]?.filePath;
+}
+
+function extractClawtipIdFromUrl(value: string): string | undefined {
+  const decoded = decodeClawtipValue(value);
+  for (const segment of decoded.split(/[?&]/)) {
+    const [key, rawValue] = segment.split("=", 2);
+    if (!key || !rawValue) {
+      continue;
+    }
+    if (["clawtipId", "clawtip_id", "deviceId", "device_id"].includes(key)) {
+      const trimmed = rawValue.trim();
+      if (trimmed) {
+        return trimmed;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function parseClawtipCliOutput(output: string): ParsedClawtipOutput {
+  const authUrl = findValueAfterKeys(output, ["authUrl", "auth_url", "auth url"]) || findUrlInOutput(output);
+  const mediaPath = findMediaPathInOutput(output);
+  const clawtipId = authUrl
+    ? extractClawtipIdFromUrl(authUrl)
+    : findValueAfterKeys(output, ["clawtipId", "clawtip_id", "deviceId", "device_id"]);
+  const lower = output.toLowerCase();
+  const failureMessage = findClawtipFailureMessage(output);
+
+  return {
+    authUrl,
+    clawtipId: clawtipId ? decodeClawtipValue(clawtipId) : undefined,
+    mediaPath,
+    failureMessage,
+    requiresWalletAuth: Boolean(authUrl || clawtipId || mediaPath
+      || lower.includes("authurl")
+      || lower.includes("qrcode")
+      || lower.includes("scan")
+      || lower.includes("扫码")),
+    walletReady: lower.includes("register success")
+      || lower.includes("注册成功")
+      || lower.includes("tokeninfo")
+      || lower.includes("config.json")
+      || lower.includes("status: successful")
+      || lower.includes("saved u"),
+  };
+}
+
+export function resolveClawtipQrMediaPath(parsedOutput: ParsedClawtipOutput, orderFile: string): string {
+  if (parsedOutput.mediaPath) {
+    return parsedOutput.mediaPath;
+  }
+  throw new Error(
+    [
+      "ClawTip pay did not return a QR media file.",
+      `Order file: ${orderFile}`,
+      "For first-time wallet binding, run the ClawTip wallet QR flow before paying.",
+    ].join(" ")
+  );
+}
+
+export function readClawtipPayCredential(orderFile: string): string | undefined {
+  if (!fs.existsSync(orderFile)) {
+    return undefined;
+  }
+  const order = JSON.parse(fs.readFileSync(orderFile, "utf8")) as Record<string, unknown>;
+  const credential = order.payCredential || order.pay_credential;
+  return typeof credential === "string" && credential.trim() ? credential : undefined;
+}
+
+export function writeClawtipOrderFile(
+  payment: ClawtipBootstrapPayment,
+  home: string = defaultHomeDir(),
+): string {
+  const orderFile = clawtipOrderFilePath(home, payment.indicator, payment.orderNo);
+  fs.mkdirSync(path.dirname(orderFile), { recursive: true });
+  const orderJson = {
+    "skill-id": payment.skillId,
+    order_no: payment.orderNo,
+    amount: payment.amountFen,
+    question: "LLM inference purchase",
+    encrypted_data: payment.encryptedData,
+    pay_to: payment.payTo,
+    description: payment.description,
+    slug: payment.slug,
+    resource_url: payment.resourceUrl,
+  };
+  fs.writeFileSync(orderFile, JSON.stringify(orderJson, null, 2), "utf8");
+  return orderFile;
+}
+
+export async function startClawtipWalletBootstrap(
+  payment: ClawtipBootstrapPayment,
+  options: StartClawtipWalletBootstrapOptions = {},
+): Promise<{ orderFile: string; parsedOutput: ParsedClawtipOutput; payCredential?: string }> {
+  const orderFile = writeClawtipOrderFile(payment, options.home);
+  const home = options.home || defaultHomeDir();
+  const payStartedAt = Date.now();
+  const runCommand = options.runClawtipCommand || runClawtipCli;
+  const output = await runCommand([
+    "--yes",
+    `@clawtip/clawtip-cli@${CLAWTIP_MIN_CLI_VERSION}`,
+    "pay",
+    "-o",
+    payment.orderNo,
+    "-i",
+    payment.indicator,
+    "-v",
+    CLAWTIP_MIN_SKILL_VERSION,
+  ]);
+  const parsedOutput = parseClawtipCliOutput(output);
+  if (parsedOutput.failureMessage) {
+    throw new Error(`ClawTip pay failed: ${parsedOutput.failureMessage}`);
+  }
+  if (!parsedOutput.mediaPath) {
+    parsedOutput.mediaPath = findLatestGeneratedQrMediaPath(home, payStartedAt);
+    if (parsedOutput.mediaPath) {
+      parsedOutput.requiresWalletAuth = true;
+    }
+  }
+
+  return {
+    orderFile,
+    parsedOutput,
+    payCredential: readClawtipPayCredential(orderFile),
+  };
+}
+
+export async function checkOpenClawRuntime(
+  options: CheckOpenClawRuntimeOptions = {},
+): Promise<string> {
+  const runOpenClawCommand = options.runOpenClawCommand || runOpenClawCli;
+  try {
+    return (await runOpenClawCommand(["--version"])).trim();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `OpenClaw CLI is required before ClawTip wallet registration. Ensure \`openclaw --version\` works. ${message}`
+    );
+  }
+}
+
+async function defaultCheckRegister(clawtipId: string): Promise<void> {
+  try {
+    await runClawtipCli([
+      "--yes",
+      `@clawtip/clawtip-cli@${CLAWTIP_MIN_CLI_VERSION}`,
+      "check-register",
+      "-d",
+      clawtipId,
+    ]);
+  } catch {
+    // The Rust version treats failed check-register polls as normal pending state.
+  }
+}
+
+async function sleepUntilNextPoll(
+  ms: number,
+  sleep: (ms: number) => Promise<void>,
+  isCancelled: () => boolean,
+): Promise<boolean> {
+  let remaining = ms;
+  while (remaining > 0) {
+    if (isCancelled()) {
+      return false;
+    }
+    const slice = Math.min(remaining, SLEEP_SLICE_MS);
+    await sleep(slice);
+    remaining -= slice;
+  }
+  return !isCancelled();
+}
+
+export async function waitForClawtipActivationConfirmation(
+  options: WaitForClawtipActivationOptions = {},
+): Promise<boolean> {
+  let cancelled = false;
+  const signalHandler = () => {
+    cancelled = true;
+  };
+  process.once("SIGINT", signalHandler);
+
+  const inspectWalletConfig = options.inspectWalletConfig || inspectOpenClawWalletConfig;
+  const externalCancelled = options.isCancelled || (() => false);
+  const isCancelled = () => cancelled || externalCancelled();
+  const checkRegister = options.checkRegister || defaultCheckRegister;
+  const cancel = options.cancel || p.cancel;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const sleep = options.sleep || defaultSleep;
+
+  try {
+    for (;;) {
+      if (isCancelled()) {
+        cancel("ClawTip activation cancelled.");
+        return false;
+      }
+
+      const walletConfig = inspectWalletConfig();
+      if (walletConfig.exists) {
+        return true;
+      }
+
+      if (options.clawtipId) {
+        await checkRegister(options.clawtipId);
+        if (inspectWalletConfig().exists) {
+          return true;
+        }
+      }
+
+      const shouldContinue = await sleepUntilNextPoll(pollIntervalMs, sleep, isCancelled);
+      if (!shouldContinue) {
+        cancel("ClawTip activation cancelled.");
+        return false;
+      }
+    }
+  } finally {
+    process.removeListener("SIGINT", signalHandler);
+  }
+}

package/src/init-payment-options.ts

@@ -1,4 +1,7 @@
 import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
 import type { PaymentConfig } from "./buyer-store.js";
 import type { ProviderCandidate } from "./provider-install.js";
 
@@ -27,6 +30,32 @@ export interface InitTerminalOption {
   hint?: string;
 }
 
+export interface InitTerminalSelectionState {
+  installed: InitTerminalOption[];
+  options: InitTerminalOption[];
+}
+
+export interface OpenClawWalletConfigState {
+  expectedPath: string;
+  configsDirExists: boolean;
+  exists: boolean;
+  alternatePaths: string[];
+}
+
+export type ClawtipWalletStatus =
+  | "ready"
+  | "metadata_missing_wallet"
+  | "wallet_missing_metadata"
+  | "missing";
+
+export interface ClawtipWalletReadiness {
+  status: ClawtipWalletStatus;
+  walletConfig: OpenClawWalletConfigState;
+  savedBinding?: ExistingClawtipBinding;
+  reusableBinding?: ExistingClawtipBinding;
+  message: string;
+}
+
 export const OTHER_TERMINAL_OPTION: InitTerminalOption = {
   value: "other",
   label: "Other",
@@ -65,38 +94,76 @@ export function noteInitComingSoonPayments(
   );
 }
 
-export function buildInitTerminalOptions(providers: ProviderCandidate[]): InitTerminalOption[] {
-  const detected = providers
-    .filter((provider) => provider.detected)
-    .map((provider) => {
-      if (provider.status === "configured") {
-        return {
-          value: `${provider.id}:installed`,
-          label: `${provider.name}（已安装）`,
-          hint: provider.reason
-        };
-      }
-      return {
-        value: provider.id,
-        label: provider.name,
-        hint: provider.reason
-      };
-    });
+export function buildInitTerminalSelectionState(providers: ProviderCandidate[]): InitTerminalSelectionState {
+  const installed = providers
+    .filter((provider) => provider.detected && provider.status === "configured")
+    .map((provider) => ({
+      value: provider.id,
+      label: `${provider.name}（已安装）`,
+      hint: provider.reason
+    }));
+
+  const options = providers
+    .filter((provider) => provider.detected && provider.status !== "configured")
+    .map((provider) => ({
+      value: provider.id,
+      label: provider.name,
+      hint: provider.reason
+    }));
 
-  return [...detected, OTHER_TERMINAL_OPTION];
+  return {
+    installed,
+    options: [...options, OTHER_TERMINAL_OPTION]
+  };
 }
 
 export function validateInitTerminalSelection(selected: string[] | undefined): string | undefined {
   if (!selected || selected.length === 0) {
     return "Select at least one terminal or choose Other.";
   }
-  const actionable = selected.filter((value) => !value.endsWith(":installed"));
-  if (actionable.length === 0) {
-    return "Installed terminals are already configured. Select another terminal or choose Other.";
-  }
   return undefined;
 }
 
+export function buildInstalledTerminalMessage(installed: InitTerminalOption[]): string | undefined {
+  if (installed.length === 0) {
+    return undefined;
+  }
+  return installed
+    .map((entry) => `- ${entry.label}${entry.hint ? `\n  ${entry.hint}` : ""}`)
+    .join("\n");
+}
+
+function defaultHomeDir(): string {
+  return process.env.HOME || os.homedir();
+}
+
+export function inspectOpenClawWalletConfig(home: string = defaultHomeDir()): OpenClawWalletConfigState {
+  const configsDir = path.join(home, ".openclaw", "configs");
+  const expectedPath = path.join(configsDir, "config.json");
+  const configsDirExists = fs.existsSync(configsDir);
+  const alternatePaths: string[] = [];
+
+  if (configsDirExists) {
+    try {
+      const entries = fs.readdirSync(configsDir)
+        .filter((entry) => entry !== "config.json" && !entry.startsWith("."))
+        .sort();
+      for (const entry of entries) {
+        alternatePaths.push(path.join(configsDir, entry));
+      }
+    } catch {
+      // Ignore directory read failures and treat as no alternates.
+    }
+  }
+
+  return {
+    expectedPath,
+    configsDirExists,
+    exists: fs.existsSync(expectedPath),
+    alternatePaths
+  };
+}
+
 function stringField(value: unknown): string | undefined {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
@@ -118,6 +185,57 @@ export function detectExistingClawtipBinding(payment: PaymentConfig | undefined)
   };
 }
 
+export function detectReusableClawtipBinding(
+  payment: PaymentConfig | undefined,
+  walletConfig: OpenClawWalletConfigState
+): ExistingClawtipBinding | undefined {
+  if (!walletConfig.exists) {
+    return undefined;
+  }
+  return detectExistingClawtipBinding(payment);
+}
+
+export function inspectClawtipWalletReadiness(
+  payment: PaymentConfig | undefined,
+  walletConfig: OpenClawWalletConfigState = inspectOpenClawWalletConfig(),
+): ClawtipWalletReadiness {
+  const savedBinding = detectExistingClawtipBinding(payment);
+  const reusableBinding = detectReusableClawtipBinding(payment, walletConfig);
+
+  if (reusableBinding) {
+    return {
+      status: "ready",
+      walletConfig,
+      savedBinding,
+      reusableBinding,
+      message: "ClawTip payment metadata and local OpenClaw wallet config are both present.",
+    };
+  }
+
+  if (savedBinding) {
+    return {
+      status: "metadata_missing_wallet",
+      walletConfig,
+      savedBinding,
+      message: "Saved ClawTip payment metadata exists, but the local OpenClaw wallet config is missing.",
+    };
+  }
+
+  if (walletConfig.exists) {
+    return {
+      status: "wallet_missing_metadata",
+      walletConfig,
+      message: "Local OpenClaw wallet config exists, but TokenBuddy ClawTip payment metadata is not saved.",
+    };
+  }
+
+  return {
+    status: "missing",
+    walletConfig,
+    message: "ClawTip payment metadata and local OpenClaw wallet config are not configured.",
+  };
+}
+
 export function buildInitSuccessMessage(summaryLines: string[] = []): string {
   const lines = ["✅ TokenBuddy setup completed successfully."];
   for (const line of summaryLines) {