@tokenbuddy/tokenbuddy 1.0.36 → 1.0.37

package/tests/control-plane-ui-endpoints.test.ts

@@ -1,1630 +0,0 @@
-import * as http from "http";
-import * as fs from "fs";
-import * as path from "path";
-import { AddressInfo } from "net";
-import { TokenbuddyDaemon, type DaemonConfig } from "../src/daemon.js";
-import { DEFAULT_INIT_RECOMMENDED_MODELS } from "../src/init-setup.js";
-import type { SellerRegistryDocument } from "../src/seller-catalog.js";
-
-jest.setTimeout(30000);
-
-/**
- * tb-ui v1 (PR-0) 控制平面写端点集成测试。
- *
- * 覆盖:
- * - GET /routing/strategy  默认 + store 写入 + 来源标记
- * - GET /routing/preview   合法 query + 非法 mode + 空 registry
- * - PUT /routing/strategy  fixed 缺 sellerId / 非法 mode / 合法 fullAuto + 热更新验证
- * - PUT /prewarm/focus-set 设置 + clear + 热更新触达
- *
- * 跳过:
- * - POST /daemon/restart  spawn() monkey-patch 在 ESM binding 下不稳,留到 PR-1
- *   浏览器手动验证(`tb ui` 页面点 Restart 按钮)。
- */
-describe("TokenbuddyDaemon control-plane UI endpoints (PR-0)", () => {
-  const TEMP_DB = path.resolve(__dirname, "../../data-test/ui-endpoints-test.db");
-  const TEMP_HOME = path.resolve(__dirname, "../../data-test/ui-endpoints-home");
-  const TEST_REGISTRY: SellerRegistryDocument = {
-    version: 1,
-    defaultSeller: "tbs-86d81e",
-    sellers: [
-      {
-        id: "tbs-86d81e",
-        url: "https://tbs-86d81e.example.com",
-        supportedProtocols: ["chat_completions", "messages"],
-        paymentMethods: ["clawtip", "mock"],
-        models: ["claude-sonnet-4-5", "gpt-4o"]
-      },
-      {
-        id: "tbs-719577",
-        url: "https://tbs-719577.example.com",
-        supportedProtocols: ["chat_completions"],
-        paymentMethods: ["clawtip"],
-        models: ["claude-sonnet-4-5"]
-      },
-      {
-        id: "tbs-825edb",
-        url: "https://tbs-825edb.example.com",
-        supportedProtocols: ["chat_completions"],
-        paymentMethods: ["clawtip", "mock"],
-        models: ["gpt-4o"]
-      }
-    ]
-  };
-
-  let daemon: TokenbuddyDaemon;
-  let controlPort: number;
-  let proxyPort: number;
-
-  function rmDb(): void {
-    for (const suffix of ["", "-wal", "-shm"]) {
-      const file = TEMP_DB + suffix;
-      if (fs.existsSync(file)) fs.unlinkSync(file);
-    }
-    fs.rmSync(TEMP_HOME, { recursive: true, force: true });
-    fs.rmSync(path.join(path.dirname(TEMP_DB), "static"), { recursive: true, force: true });
-  }
-
-  async function startDaemon(overrides: Partial<DaemonConfig> = {}): Promise<void> {
-    rmDb();
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath: TEMP_DB,
-      sellerRegistryUrl: "http://127.0.0.1:1/registry/sellers", // 不会真正被触发
-      clawtipHomeDir: TEMP_HOME,
-      providerHomeDir: TEMP_HOME,
-      ...overrides
-    });
-    daemon.start();
-    // 注入 test-only registry snapshot,避开网络拉取
-    daemon.setLastRegistrySnapshotForTest(TEST_REGISTRY);
-    const controlServer = (daemon as unknown as { controlServer: { address(): AddressInfo } }).controlServer;
-    const proxyServer = (daemon as unknown as { proxyServer: { address(): AddressInfo } }).proxyServer;
-    controlPort = controlServer.address().port;
-    proxyPort = proxyServer.address().port;
-  }
-
-  function controlUrl(path: string): string {
-    return `http://127.0.0.1:${controlPort}${path}`;
-  }
-
-  function proxyUrl(path: string): string {
-    return `http://127.0.0.1:${proxyPort}${path}`;
-  }
-
-  async function startJsonServer(handler: http.RequestListener): Promise<{ server: http.Server; url: string }> {
-    const server = http.createServer(handler);
-    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
-    const address = server.address() as AddressInfo;
-    return {
-      server,
-      url: `http://127.0.0.1:${address.port}`
-    };
-  }
-
-  async function closeServer(server: http.Server): Promise<void> {
-    await new Promise<void>((resolve) => server.close(() => resolve()));
-  }
-
-  beforeEach(async () => {
-    await startDaemon();
-  });
-
-  afterEach(async () => {
-    daemon.stop();
-    // Drain any in-flight prewarm scheduler work to avoid jest open-handle
-    // warnings. The daemon's stop() is fire-and-forget.
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-    rmDb();
-  });
-
-  function markClawtipReady(): void {
-    const store = (daemon as unknown as { tokenStore: { savePayment(input: unknown): void } }).tokenStore;
-    const configsDir = path.join(TEMP_HOME, ".openclaw", "configs");
-    fs.mkdirSync(configsDir, { recursive: true });
-    fs.writeFileSync(path.join(configsDir, "config.json"), "{}", "utf8");
-    store.savePayment({
-      method: "clawtip",
-      enabled: true,
-      isDefault: true,
-      config: {
-        resourceUrl: "https://tb-registry.example.test",
-        walletConfigPresent: true
-      }
-    });
-  }
-
-  // ─── ClawTip payment QR endpoints ─────────────────────────────
-  describe("ClawTip payment QR endpoints", () => {
-    it("selects a configured payment method as default", async () => {
-      const store = (daemon as unknown as { tokenStore: { savePayment(input: unknown): void; listPayments(): Array<{ method: string; isDefault: boolean }> } }).tokenStore;
-      store.savePayment({
-        method: "clawtip",
-        enabled: false,
-        isDefault: true,
-        config: {
-          walletConfigPresent: false
-        }
-      });
-      store.savePayment({
-        method: "invoice",
-        enabled: true,
-        isDefault: false,
-        config: {
-          walletConfigPresent: true
-        }
-      });
-
-      const res = await fetch(controlUrl("/payments/default"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ method: "invoice" })
-      });
-      expect(res.status).toBe(200);
-      const body = await res.json() as { payments: Array<{ method: string; isDefault: boolean }> };
-      expect(body.payments.find((payment) => payment.method === "invoice")?.isDefault).toBe(true);
-      expect(body.payments.find((payment) => payment.method === "clawtip")?.isDefault).toBe(false);
-      expect(store.listPayments().find((payment) => payment.method === "invoice")?.isDefault).toBe(true);
-    });
-
-    it("rejects selecting an unbound payment method as default", async () => {
-      const store = (daemon as unknown as { tokenStore: { savePayment(input: unknown): void } }).tokenStore;
-      store.savePayment({
-        method: "invoice",
-        enabled: false,
-        isDefault: false,
-        config: {
-          walletConfigPresent: false
-        }
-      });
-
-      const res = await fetch(controlUrl("/payments/default"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ method: "invoice" })
-      });
-      expect(res.status).toBe(400);
-      const body = await res.json() as { error: { code: string } };
-      expect(body.error.code).toBe("payment_default_not_ready");
-    });
-
-    it("reflects a renamed wallet config as unbound in /payments", async () => {
-      const store = (daemon as unknown as { tokenStore: { savePayment(input: unknown): void } }).tokenStore;
-      const configsDir = path.join(TEMP_HOME, ".openclaw", "configs");
-      fs.mkdirSync(configsDir, { recursive: true });
-      fs.writeFileSync(path.join(configsDir, "config.json.bak"), "{}", "utf8");
-      store.savePayment({
-        method: "clawtip",
-        enabled: true,
-        isDefault: true,
-        config: {
-          resourceUrl: "https://tb-registry.example.test",
-          walletConfigPresent: true
-        }
-      });
-
-      const res = await fetch(controlUrl("/payments"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as { payments: Array<{ method: string; enabled: boolean; config: Record<string, unknown> }> };
-      const clawtip = body.payments.find((payment) => payment.method === "clawtip");
-      expect(clawtip?.enabled).toBe(false);
-      expect(clawtip?.config.walletConfigPresent).toBe(false);
-      expect(clawtip?.config.nearbyWalletConfigPaths).toEqual([path.join(configsDir, "config.json.bak")]);
-    });
-
-    it("reuses the tb init ClawTip flow and exposes the returned QR image as static UI asset", async () => {
-      daemon.stop();
-      const qrSource = path.join(TEMP_HOME, "source-qrcode.png");
-      await startDaemon({
-        clawtipBootstrapFetcher: async () => ({
-          activationFeeFen: 1,
-          payment: {
-            orderNo: "order_ui_qr",
-            amountFen: 1,
-            payTo: "real-pay-to",
-            encryptedData: "ciphertext",
-            indicator: "indicator_ui_qr",
-            slug: "tb-registry",
-            skillId: "si-tb-registry",
-            description: "TokenBuddy ClawTip wallet activation",
-            resourceUrl: "https://tb-registry.example.test"
-          }
-        }),
-        clawtipWalletBootstrapStarter: async (payment) => ({
-          orderFile: path.join(TEMP_HOME, ".openclaw", "skills", "orders", payment.indicator, `${payment.orderNo}.json`),
-          parsedOutput: {
-            mediaPath: qrSource,
-            authUrl: "https://idt.jd.com/unifiedAuthM/plat/safeMonitor/?authFlowUid=abc",
-            clawtipId: "device-ui",
-            requiresWalletAuth: true,
-            walletReady: false
-          }
-        }),
-        clawtipActivationWaiter: async () => false
-      });
-      fs.mkdirSync(path.dirname(qrSource), { recursive: true });
-      fs.writeFileSync(qrSource, "png-bytes", "utf8");
-
-      const res = await fetch(controlUrl("/payments/clawtip/activate"), { method: "POST" });
-      expect(res.status).toBe(200);
-      const body = await res.json() as { qrImageUrl: string; sourceImagePath: string; orderNo: string };
-      expect(body.orderNo).toBe("order_ui_qr");
-      expect(body.sourceImagePath).toBe(qrSource);
-      expect(body.qrImageUrl).toMatch(/^\/static\/clawtip\/order_ui_qr-/);
-
-      const imageRes = await fetch(controlUrl(body.qrImageUrl));
-      expect(imageRes.status).toBe(200);
-      expect(await imageRes.text()).toBe("png-bytes");
-    });
-
-    it("updates ClawTip payment readiness after the activation wait detects wallet config", async () => {
-      daemon.stop();
-      const qrSource = path.join(TEMP_HOME, "source-qrcode.png");
-      const configsDir = path.join(TEMP_HOME, ".openclaw", "configs");
-      await startDaemon({
-        clawtipBootstrapFetcher: async () => ({
-          activationFeeFen: 1,
-          payment: {
-            orderNo: "order_wait_qr",
-            amountFen: 1,
-            payTo: "real-pay-to",
-            encryptedData: "ciphertext",
-            indicator: "indicator_wait_qr",
-            resourceUrl: "https://tb-registry.example.test"
-          }
-        }),
-        clawtipWalletBootstrapStarter: async (payment) => ({
-          orderFile: path.join(TEMP_HOME, ".openclaw", "skills", "orders", payment.indicator, `${payment.orderNo}.json`),
-          parsedOutput: {
-            mediaPath: qrSource,
-            clawtipId: "device-wait",
-            requiresWalletAuth: true,
-            walletReady: false
-          }
-        }),
-        clawtipActivationWaiter: async () => {
-          fs.mkdirSync(configsDir, { recursive: true });
-          fs.writeFileSync(path.join(configsDir, "config.json"), "{}", "utf8");
-          return true;
-        }
-      });
-      fs.mkdirSync(path.dirname(qrSource), { recursive: true });
-      fs.writeFileSync(qrSource, "png-bytes", "utf8");
-
-      const activateRes = await fetch(controlUrl("/payments/clawtip/activate"), { method: "POST" });
-      expect(activateRes.status).toBe(200);
-      await new Promise<void>((resolve) => setTimeout(resolve, 10));
-
-      const paymentsRes = await fetch(controlUrl("/payments"));
-      expect(paymentsRes.status).toBe(200);
-      const body = await paymentsRes.json() as { payments: Array<{ method: string; enabled: boolean; config: Record<string, unknown> }> };
-      const clawtip = body.payments.find((payment) => payment.method === "clawtip");
-      expect(clawtip?.enabled).toBe(true);
-      expect(clawtip?.config.walletConfigPresent).toBe(true);
-      expect(clawtip?.config.activationCompletedBy).toBe("wallet-config");
-    });
-
-    it("fails activation when the reused ClawTip flow does not return a QR media file", async () => {
-      daemon.stop();
-      await startDaemon({
-        clawtipBootstrapFetcher: async () => ({
-          activationFeeFen: 1,
-          payment: {
-            orderNo: "order_no_media",
-            amountFen: 1,
-            payTo: "real-pay-to",
-            encryptedData: "ciphertext",
-            indicator: "indicator_no_media",
-            resourceUrl: "https://tb-registry.example.test"
-          }
-        }),
-        clawtipWalletBootstrapStarter: async (payment) => ({
-          orderFile: path.join(TEMP_HOME, ".openclaw", "skills", "orders", payment.indicator, `${payment.orderNo}.json`),
-          parsedOutput: {
-            authUrl: "https://clawtip.jd.com/qrcode?clawtipId=device-no-media",
-            clawtipId: "device-no-media",
-            requiresWalletAuth: true,
-            walletReady: false
-          }
-        })
-      });
-
-      const res = await fetch(controlUrl("/payments/clawtip/activate"), { method: "POST" });
-      expect(res.status).toBe(500);
-      const body = await res.json() as { error: { code: string; message: string } };
-      expect(body.error.code).toBe("clawtip_activate_qr_failed");
-      expect(body.error.message).toContain("did not return a QR image");
-    });
-
-    it("does not reuse the activation QR when the fixed recharge asset is missing", async () => {
-      daemon.stop();
-      await startDaemon({ clawtipBundledStaticDir: false });
-      const store = (daemon as unknown as { tokenStore: { savePayment(input: unknown): void } }).tokenStore;
-      const activationQr = path.join(TEMP_HOME, "activation-qrcode.png");
-      fs.mkdirSync(path.dirname(activationQr), { recursive: true });
-      fs.writeFileSync(activationQr, "activation-png-bytes", "utf8");
-      store.savePayment({
-        method: "clawtip",
-        enabled: true,
-        isDefault: true,
-        config: {
-          orderNo: "order_activation_only",
-          activationQrImagePath: activationQr,
-          walletConfigPresent: true
-        }
-      });
-
-      const res = await fetch(controlUrl("/payments/clawtip/recharge"), { method: "POST" });
-      expect(res.status).toBe(500);
-      const body = await res.json() as { error: { code: string; message: string } };
-      expect(body.error.code).toBe("clawtip_recharge_qr_failed");
-      expect(body.error.message).toContain("fixed recharge QR image is missing");
-    });
-
-    it("returns the fixed ClawTip recharge static asset", async () => {
-      const store = (daemon as unknown as { tokenStore: { savePayment(input: unknown): void } }).tokenStore;
-      store.savePayment({
-        method: "clawtip",
-        enabled: true,
-        isDefault: true,
-        config: {
-          orderNo: "order_recharge_static",
-          resourceUrl: "https://tb-registry.example.test",
-          walletConfigPresent: true
-        }
-      });
-      const staticDir = path.join(path.dirname(TEMP_DB), "static", "clawtip");
-      fs.mkdirSync(staticDir, { recursive: true });
-      fs.writeFileSync(path.join(staticDir, "recharge.png"), "fixed-recharge-png", "utf8");
-
-      const res = await fetch(controlUrl("/payments/clawtip/recharge"), { method: "POST" });
-      expect(res.status).toBe(200);
-      const body = await res.json() as { qrImageUrl: string; sourceImagePath: string; staticImagePath: string; orderNo: string };
-      expect(body.orderNo).toBe("order_recharge_static");
-      expect(body.qrImageUrl).toBe("/static/clawtip/recharge.png");
-      expect(body.sourceImagePath).toBe(path.join(staticDir, "recharge.png"));
-      expect(body.staticImagePath).toBe(path.join(staticDir, "recharge.png"));
-
-      const imageRes = await fetch(controlUrl(body.qrImageUrl));
-      expect(imageRes.status).toBe(200);
-      expect(await imageRes.text()).toBe("fixed-recharge-png");
-    });
-  });
-
-  // ─── Bundled PWA Static Assets ────────────────────────────────
-  describe("bundled tb-ui static assets", () => {
-    it("serves the installable PWA shell from the control plane", async () => {
-      const overviewRes = await fetch(controlUrl("/overview"));
-      expect(overviewRes.status).toBe(200);
-      expect(overviewRes.headers.get("content-type")).toContain("text/html");
-      expect(await overviewRes.text()).toContain("/manifest.webmanifest");
-
-      const manifestRes = await fetch(controlUrl("/manifest.webmanifest"));
-      expect(manifestRes.status).toBe(200);
-      expect(manifestRes.headers.get("content-type")).toContain("application/manifest+json");
-      const manifest = await manifestRes.json() as { start_url: string; icons: Array<{ src: string; sizes: string }> };
-      expect(manifest).toMatchObject({ name: "TokenBuddy", short_name: "TokenBuddy" });
-      expect(manifest.start_url).toBe("/overview");
-      expect(manifest.icons).toEqual(expect.arrayContaining([
-        expect.objectContaining({ src: "/icons/tokenbuddy-192.png", sizes: "192x192" }),
-        expect.objectContaining({ src: "/icons/tokenbuddy-512.png", sizes: "512x512" })
-      ]));
-
-      const serviceWorkerRes = await fetch(controlUrl("/sw.js"));
-      expect(serviceWorkerRes.status).toBe(200);
-      expect(serviceWorkerRes.headers.get("content-type")).toContain("application/javascript");
-      expect(await serviceWorkerRes.text()).toContain("tokenbuddy-ui-v2");
-
-      const iconRes = await fetch(controlUrl("/icons/tokenbuddy-192.png"));
-      expect(iconRes.status).toBe(200);
-      expect(iconRes.headers.get("content-type")).toContain("image/png");
-      expect(Number(iconRes.headers.get("content-length"))).toBeGreaterThan(1_000);
-    });
-  });
-
-  // ─── Init Wizard State ────────────────────────────────────────
-  describe("web init wizard state", () => {
-    it("returns a fresh-machine setup snapshot for the web wizard", async () => {
-      daemon.stop();
-      await startDaemon({ providerHomeDir: TEMP_HOME });
-
-      const res = await fetch(controlUrl("/init/state"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        setup: { status: string; completedSteps: string[] };
-        freshMachine: boolean;
-        runtime: { status: string; controlPort: number; proxyPort: number };
-        payments: unknown[];
-        clients: Array<{ id: string; name: string }>;
-        clientsSummary: { installCommand: string; totalCount: number };
-        routing: { strategy: { mode: string; scorer: string }; source: string };
-        focusSet: string[];
-        recommendedModels: string[];
-      };
-
-      expect(body.setup).toMatchObject({
-        status: "not_started",
-        completedSteps: []
-      });
-      expect(body.freshMachine).toBe(true);
-      expect(body.runtime).toMatchObject({
-        status: "running",
-        controlPort,
-        proxyPort
-      });
-      expect(body.payments).toEqual([]);
-      expect(body.clients).toEqual(expect.arrayContaining([
-        expect.objectContaining({ id: "custom", name: "Custom client" })
-      ]));
-      expect(body.clientsSummary.installCommand).toBe("tb init");
-      expect(body.clientsSummary.totalCount).toBe(body.clients.length);
-      expect(body.routing.strategy).toMatchObject({ mode: "fullAuto", scorer: "balanced" });
-      expect(body.routing.source).toBe("default");
-      expect(body.focusSet).toEqual([]);
-      expect(body.recommendedModels).toEqual([...DEFAULT_INIT_RECOMMENDED_MODELS]);
-    });
-
-    it("returns configured init recommended models in stable order", async () => {
-      daemon.stop();
-      await startDaemon({
-        providerHomeDir: TEMP_HOME,
-        initRecommendedModels: [" custom-a ", "", "custom-b", "custom-a"]
-      });
-
-      const res = await fetch(controlUrl("/init/state"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as { recommendedModels: string[] };
-
-      expect(body.recommendedModels).toEqual(["custom-a", "custom-b"]);
-    });
-
-    it("marks the web init wizard as completed and rejects unknown steps", async () => {
-      const badRes = await fetch(controlUrl("/init/complete"), {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ completedSteps: ["gateway_intro", "unknown_step"] })
-      });
-      expect(badRes.status).toBe(400);
-      const badBody = await badRes.json() as { error: { code: string; message: string } };
-      expect(badBody.error.code).toBe("init_setup_complete_failed");
-      expect(badBody.error.message).toContain("unknown init setup step");
-
-      const completeRes = await fetch(controlUrl("/init/complete"), {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ completedSteps: ["gateway_intro", "model_access"] })
-      });
-      expect(completeRes.status).toBe(200);
-      const completed = await completeRes.json() as {
-        setup: { status: string; completedSteps: string[]; completedAt?: string };
-        freshMachine: boolean;
-        repairMode: boolean;
-        repairReasons: string[];
-      };
-      expect(completed.setup.status).toBe("completed");
-      expect(completed.setup.completedSteps).toEqual(["gateway_intro", "model_access"]);
-      expect(completed.setup.completedAt).toEqual(expect.any(String));
-      expect(completed.freshMachine).toBe(false);
-      expect(completed.repairMode).toBe(true);
-      expect(completed.repairReasons).toEqual(expect.arrayContaining([
-        expect.stringContaining("missing_steps:"),
-        "missing_focus_models",
-        "missing_payment_method",
-        "missing_connected_tools"
-      ]));
-
-      const stateRes = await fetch(controlUrl("/init/state"));
-      expect(stateRes.status).toBe(200);
-      const state = await stateRes.json() as {
-        setup: { status: string; completedSteps: string[] };
-        freshMachine: boolean;
-        repairMode: boolean;
-        repairReasons: string[];
-      };
-      expect(state.setup.status).toBe("completed");
-      expect(state.setup.completedSteps).toEqual(["gateway_intro", "model_access"]);
-      expect(state.freshMachine).toBe(false);
-      expect(state.repairMode).toBe(true);
-      expect(state.repairReasons).toEqual(completed.repairReasons);
-    });
-
-    it("keeps completed setup out of repair mode when key wizard outputs exist", async () => {
-      daemon.stop();
-      await startDaemon({ providerHomeDir: TEMP_HOME });
-      const codexConfig = path.join(TEMP_HOME, ".codex", "config.toml");
-      fs.mkdirSync(path.dirname(codexConfig), { recursive: true });
-      fs.writeFileSync(codexConfig, "[tokenbuddy]\nproxy_url = \"http://127.0.0.1:17821\"\n", "utf8");
-
-      const store = (daemon as unknown as { tokenStore: { savePayment(input: unknown): void } }).tokenStore;
-      store.savePayment({
-        method: "mock",
-        enabled: true,
-        isDefault: true,
-        config: { source: "test" }
-      });
-
-      const focusRes = await fetch(controlUrl("/prewarm/focus-set"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ models: ["gpt-4o"] })
-      });
-      expect(focusRes.status).toBe(200);
-
-      const completeRes = await fetch(controlUrl("/init/complete"), {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({})
-      });
-      expect(completeRes.status).toBe(200);
-
-      const stateRes = await fetch(controlUrl("/init/state"));
-      expect(stateRes.status).toBe(200);
-      const state = await stateRes.json() as {
-        setup: { status: string; completedSteps: string[] };
-        freshMachine: boolean;
-        repairMode: boolean;
-        repairReasons: string[];
-        focusSet: string[];
-        payments: Array<{ method: string; enabled: boolean }>;
-        clientsSummary: { configuredCount: number };
-      };
-      expect(state.setup.status).toBe("completed");
-      expect(state.setup.completedSteps).toEqual([
-        "gateway_intro",
-        "model_access",
-        "supplier_routing",
-        "auto_purchase",
-        "connect_tools",
-        "verify_gateway",
-        "install_app"
-      ]);
-      expect(state.freshMachine).toBe(false);
-      expect(state.repairMode).toBe(false);
-      expect(state.repairReasons).toEqual([]);
-      expect(state.focusSet).toEqual(["gpt-4o"]);
-      expect(state.payments).toEqual(expect.arrayContaining([
-        expect.objectContaining({ method: "mock", enabled: true })
-      ]));
-      expect(state.clientsSummary.configuredCount).toBeGreaterThanOrEqual(1);
-    });
-
-    it("runs structured init doctor checks for the web wizard", async () => {
-      const res = await fetch(controlUrl("/init/doctor/run"), { method: "POST" });
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        status: "passed" | "warning" | "failed";
-        generatedAt: string;
-        checks: Array<{ id: string; label: string; status: string; message: string; details: string[] }>;
-      };
-
-      expect(body.generatedAt).toEqual(expect.any(String));
-      expect(body.status).toBe("warning");
-      expect(body.checks).toEqual(expect.arrayContaining([
-        expect.objectContaining({ id: "local_service", label: "本地服务", status: "passed" }),
-        expect.objectContaining({ id: "model_catalog", label: "模型目录", status: "passed" }),
-        expect.objectContaining({ id: "routing_strategy", label: "路由策略", status: "passed" }),
-        expect.objectContaining({ id: "payment_method", label: "支付方式", status: "warning" }),
-        expect.objectContaining({ id: "connected_tools", label: "已连接工具", status: "warning" })
-      ]));
-      const routing = body.checks.find((check) => check.id === "routing_strategy");
-      expect(routing?.details.join(" ")).toContain("fullAuto");
-    });
-  });
-
-  // ─── GET /providers/status ───────────────────────────────────
-  describe("GET /providers/status", () => {
-    it("returns read-only client tool status with a CLI install command", async () => {
-      daemon.stop();
-      await startDaemon({ providerHomeDir: TEMP_HOME });
-      const codexConfig = path.join(TEMP_HOME, ".codex", "config.toml");
-      fs.mkdirSync(path.dirname(codexConfig), { recursive: true });
-      fs.writeFileSync(codexConfig, "[tokenbuddy]\nproxy_url = \"http://127.0.0.1:17821\"\n", "utf8");
-
-      const res = await fetch(controlUrl("/providers/status"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        clients: Array<{ id: string; status: string; configured: boolean; reason: string; manualConfig?: { openaiBaseUrl: string; anthropicBaseUrl: string; apiKey: string } }>;
-        summary: { configuredCount: number; installCommand: string };
-      };
-      const codex = body.clients.find((client) => client.id === "codex");
-      const custom = body.clients.find((client) => client.id === "custom");
-      expect(codex).toMatchObject({ status: "configured", configured: true });
-      expect(custom).toMatchObject({ status: "manual", configured: false });
-      expect(custom?.reason).toContain("http://127.0.0.1:");
-      expect(custom?.manualConfig).toEqual({
-        openaiBaseUrl: `http://127.0.0.1:${proxyPort}/v1`,
-        anthropicBaseUrl: `http://127.0.0.1:${proxyPort}`,
-        apiKey: "TOKENBUDDY_PROXY"
-      });
-      expect(body.summary.configuredCount).toBeGreaterThanOrEqual(1);
-      expect(body.summary.installCommand).toBe("tb init");
-    });
-
-    it("applies tb-ui provider install requests to active OpenClaw and Hermes config files", async () => {
-      daemon.stop();
-      await startDaemon({ providerHomeDir: TEMP_HOME });
-
-      const res = await fetch(controlUrl("/providers/install/apply"), {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          home: TEMP_HOME,
-          providers: ["openclaw", "hermes"],
-          proxyUrl: `http://127.0.0.1:${proxyPort}`,
-          providerSelections: {
-            openclaw: {
-              selectionKind: "single-model",
-              protocolPreference: "chat_completions",
-              defaultModel: "gpt-5.4"
-            },
-            hermes: {
-              selectionKind: "single-model",
-              protocolPreference: "chat_completions",
-              defaultModel: "gpt-5.4"
-            }
-          }
-        })
-      });
-
-      expect(res.status).toBe(200);
-      const body = await res.json() as { applied: Array<{ providerId: string; path: string; action: string }> };
-      expect(body.applied).toEqual(expect.arrayContaining([
-        expect.objectContaining({
-          providerId: "openclaw",
-          path: path.join(TEMP_HOME, ".openclaw", "openclaw.json")
-        }),
-        expect.objectContaining({
-          providerId: "hermes",
-          path: path.join(TEMP_HOME, ".hermes", "config.yaml")
-        })
-      ]));
-
-      const openclaw = JSON.parse(fs.readFileSync(path.join(TEMP_HOME, ".openclaw", "openclaw.json"), "utf8"));
-      expect(openclaw.models.providers.tokenbuddy.baseUrl).toBe(`http://127.0.0.1:${proxyPort}/v1`);
-      expect(openclaw.models.providers.tokenbuddy.apiKey).toBe("TOKENBUDDY_PROXY");
-      expect(openclaw.models.providers.tokenbuddy.auth).toBe("api-key");
-      expect(openclaw.models.providers.tokenbuddy.api).toBe("openai-completions");
-      expect(openclaw.models.providers.tokenbuddy.models).toEqual(expect.arrayContaining([
-        expect.objectContaining({ id: "gpt-5.4", api: "openai-completions" })
-      ]));
-      expect(openclaw.agents.defaults.model).toBe("tokenbuddy/gpt-5.4");
-
-      const hermes = fs.readFileSync(path.join(TEMP_HOME, ".hermes", "config.yaml"), "utf8");
-      expect(hermes).toContain("default: gpt-5.4");
-      expect(hermes).toContain("provider: custom");
-      expect(hermes).toContain(`base_url: "http://127.0.0.1:${proxyPort}/v1"`);
-      expect(hermes).toContain("api_key: TOKENBUDDY_PROXY");
-      expect(hermes).toContain("api_mode: chat_completions");
-
-      const statusRes = await fetch(controlUrl("/providers/status"));
-      expect(statusRes.status).toBe(200);
-      const statusBody = await statusRes.json() as { clients: Array<{ id: string; configured: boolean; configPath?: string }> };
-      expect(statusBody.clients).toEqual(expect.arrayContaining([
-        expect.objectContaining({
-          id: "openclaw",
-          configured: true,
-          configPath: path.join(TEMP_HOME, ".openclaw", "openclaw.json")
-        }),
-        expect.objectContaining({
-          id: "hermes",
-          configured: true,
-          configPath: path.join(TEMP_HOME, ".hermes", "config.yaml")
-        })
-      ]));
-    });
-  });
-
-  describe("provider mode and provider configs", () => {
-    it("defaults to manual mode and reports auto as locked without payment", async () => {
-      const res = await fetch(controlUrl("/routing/provider-mode"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        mode: string;
-        manualEnabled: boolean;
-        autoEnabled: boolean;
-        paymentReady: boolean;
-        paymentRequired: boolean;
-        locked: { auto: boolean };
-      };
-      expect(body.mode).toBe("manual");
-      expect(body.manualEnabled).toBe(true);
-      expect(body.autoEnabled).toBe(false);
-      expect(body.paymentReady).toBe(false);
-      expect(body.paymentRequired).toBe(true);
-      expect(body.locked.auto).toBe(true);
-    });
-
-    it("rejects enabling auto mode until a non-mock payment is ready", async () => {
-      const res = await fetch(controlUrl("/routing/provider-mode"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "auto" })
-      });
-      expect(res.status).toBe(409);
-      const body = await res.json() as { error: { code: string }; bindTarget: string };
-      expect(body.error.code).toBe("payment_required");
-      expect(body.bindTarget).toBe("/overview?bind=clawtip");
-    });
-
-    it("enables auto mode after ClawTip is bound", async () => {
-      markClawtipReady();
-      const res = await fetch(controlUrl("/routing/provider-mode"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "auto" })
-      });
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        applied: boolean;
-        mode: string;
-        manualEnabled: boolean;
-        autoEnabled: boolean;
-        paymentReady: boolean;
-        paymentLabel?: string;
-      };
-      expect(body.applied).toBe(true);
-      expect(body.mode).toBe("auto");
-      expect(body.manualEnabled).toBe(false);
-      expect(body.autoEnabled).toBe(true);
-      expect(body.paymentReady).toBe(true);
-      expect(body.paymentLabel).toBe("ClawTip");
-    });
-
-    it("creates, lists, and deletes manual providers without exposing secret fields", async () => {
-      const createRes = await fetch(controlUrl("/routing/manual-providers"), {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          id: "local-openai",
-          name: "Local OpenAI",
-          baseUrl: "https://api.openai.example/v1/",
-          apiKeyEnv: "TB_TEST_PROVIDER_OPENAI_KEY",
-          models: ["gpt-4o", "gpt-4o"],
-          supportedProtocols: ["chat_completions"],
-          enabled: true
-        })
-      });
-      expect(createRes.status).toBe(201);
-      const created = await createRes.json() as {
-        provider: { id: string; baseUrl: string; keyRef?: { kind: string; name: string; configured: boolean }; apiKeyEnv?: string };
-      };
-      expect(created.provider.id).toBe("local-openai");
-      expect(created.provider.baseUrl).toBe("https://api.openai.example/v1");
-      expect(created.provider.keyRef).toEqual({
-        kind: "env",
-        name: "TB_TEST_PROVIDER_OPENAI_KEY",
-        configured: false
-      });
-      expect(created.provider.apiKeyEnv).toBeUndefined();
-
-      const listRes = await fetch(controlUrl("/routing/manual-providers"));
-      expect(listRes.status).toBe(200);
-      const listBody = await listRes.json() as { providers: Array<{ id: string; apiKeyEnv?: string }> };
-      expect(listBody.providers.map((provider) => provider.id)).toEqual(["local-openai"]);
-      expect(listBody.providers[0].apiKeyEnv).toBeUndefined();
-
-      const deleteRes = await fetch(controlUrl("/routing/manual-providers/local-openai"), { method: "DELETE" });
-      expect(deleteRes.status).toBe(200);
-      const afterDeleteRes = await fetch(controlUrl("/routing/manual-providers"));
-      const afterDelete = await afterDeleteRes.json() as { providers: unknown[] };
-      expect(afterDelete.providers).toEqual([]);
-    });
-
-    it("rejects manual providers with raw API keys", async () => {
-      const res = await fetch(controlUrl("/routing/manual-providers"), {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          id: "local-openai",
-          name: "Local OpenAI",
-          baseUrl: "https://api.openai.example/v1",
-          apiKey: "sk-secret",
-          models: ["gpt-4o"]
-        })
-      });
-      expect(res.status).toBe(400);
-      const body = await res.json() as { error: { code: string; message: string } };
-      expect(body.error.code).toBe("manual_provider_create_failed");
-      expect(body.error.message).toMatch(/raw apiKey/);
-      expect(body.error.message).not.toContain("sk-secret");
-    });
-
-    it("probes and creates a local manual provider without exposing the raw API key", async () => {
-      const providerKey = "provider-local-ui-key";
-      const provider = await startJsonServer((req, res) => {
-        expect(req.headers.authorization).toBe(`Bearer ${providerKey}`);
-        if (req.method === "GET" && req.url === "/v1/models") {
-          res.writeHead(200, { "content-type": "application/json" });
-          res.end(JSON.stringify({
-            object: "list",
-            data: [
-              { id: "gpt-local-ui", object: "model" },
-              { id: "gpt-local-ui-fast", object: "model" }
-            ]
-          }));
-          return;
-        }
-        if (req.method === "POST" && req.url === "/v1/chat/completions") {
-          res.writeHead(200, { "content-type": "application/json" });
-          res.end(JSON.stringify({
-            id: "chatcmpl-local-ui",
-            object: "chat.completion",
-            choices: [{ index: 0, message: { role: "assistant", content: "ok" }, finish_reason: "stop" }],
-            usage: { prompt_tokens: 4, completion_tokens: 3 }
-          }));
-          return;
-        }
-        res.writeHead(404, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: { message: "not found" } }));
-      });
-
-      try {
-        const probeRes = await fetch(controlUrl("/routing/manual-providers/probe"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            baseUrl: `${provider.url}/v1`,
-            apiKey: providerKey
-          })
-        });
-        expect(probeRes.status).toBe(200);
-        const probeBody = await probeRes.json() as { modelIds: string[] };
-        expect(probeBody.modelIds).toEqual(["gpt-local-ui", "gpt-local-ui-fast"]);
-
-        const createRes = await fetch(controlUrl("/routing/manual-providers/local"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            id: "local-ui",
-            name: "Local UI",
-            baseUrl: `${provider.url}/v1`,
-            apiKey: providerKey
-          })
-        });
-        expect(createRes.status).toBe(201);
-        const created = await createRes.json() as {
-          provider: { id: string; models: string[]; keyRef?: { kind: string; name: string; configured: boolean }; apiKey?: string };
-        };
-        expect(created.provider).toMatchObject({
-          id: "local-ui",
-          models: ["gpt-local-ui", "gpt-local-ui-fast"],
-          keyRef: { kind: "secret", name: "local:local-ui", configured: true }
-        });
-        expect(created.provider.apiKey).toBeUndefined();
-        expect(JSON.stringify(created)).not.toContain(providerKey);
-
-        const modelsRes = await fetch(proxyUrl("/v1/models"));
-        expect(modelsRes.status).toBe(200);
-        const models = await modelsRes.json() as { data: Array<{ id: string; sellerId: string }> };
-        expect(models.data).toEqual(expect.arrayContaining([
-          expect.objectContaining({ id: "gpt-local-ui", sellerId: "local-ui" })
-        ]));
-
-        const chatRes = await fetch(proxyUrl("/v1/chat/completions"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            model: "gpt-local-ui",
-            messages: [{ role: "user", content: "hello" }]
-          })
-        });
-        expect(chatRes.status).toBe(200);
-      } finally {
-        await closeServer(provider.server);
-      }
-    });
-
-    it("updates a local manual provider using the stored secret", async () => {
-      const providerKey = "provider-local-edit-key";
-      const provider = await startJsonServer((req, res) => {
-        expect(req.headers.authorization).toBe(`Bearer ${providerKey}`);
-        if (req.method === "GET" && req.url === "/v1/models") {
-          res.writeHead(200, { "content-type": "application/json" });
-          res.end(JSON.stringify({
-            object: "list",
-            data: [
-              { id: "gpt-local-edited", object: "model" },
-              { id: "gpt-local-edited-fast", object: "model" }
-            ]
-          }));
-          return;
-        }
-        res.writeHead(404, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: { message: "not found" } }));
-      });
-
-      try {
-        const createRes = await fetch(controlUrl("/routing/manual-providers/local"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            id: "local-edit",
-            name: "Local Edit",
-            baseUrl: `${provider.url}/v1`,
-            apiKey: providerKey
-          })
-        });
-        expect(createRes.status).toBe(201);
-
-        const updateRes = await fetch(controlUrl("/routing/manual-providers/local/local-edit"), {
-          method: "PUT",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            name: "Local Edited",
-            baseUrl: `${provider.url}/v1`
-          })
-        });
-        expect(updateRes.status).toBe(200);
-        const updated = await updateRes.json() as {
-          provider: { id: string; name: string; models: string[]; keyRef?: { kind: string; name: string; configured: boolean }; apiKey?: string };
-        };
-        expect(updated.provider).toMatchObject({
-          id: "local-edit",
-          name: "Local Edited",
-          models: ["gpt-local-edited", "gpt-local-edited-fast"],
-          keyRef: { kind: "secret", name: "local:local-edit", configured: true }
-        });
-        expect(updated.provider.apiKey).toBeUndefined();
-        expect(JSON.stringify(updated)).not.toContain(providerKey);
-      } finally {
-        await closeServer(provider.server);
-      }
-    });
-
-    it("blocks local manual provider creation when model probing fails", async () => {
-      const providerKey = "provider-local-bad-key";
-      const provider = await startJsonServer((_req, res) => {
-        res.writeHead(401, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: { message: "unauthorized" } }));
-      });
-
-      try {
-        const createRes = await fetch(controlUrl("/routing/manual-providers/local"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            id: "local-bad",
-            name: "Local Bad",
-            baseUrl: `${provider.url}/v1`,
-            apiKey: providerKey
-          })
-        });
-        expect(createRes.status).toBe(400);
-        const body = await createRes.json() as { error: { code: string; message: string } };
-        expect(body.error.code).toBe("manual_provider_local_create_failed");
-        expect(body.error.message).toContain("authentication failed");
-        expect(body.error.message).not.toContain(providerKey);
-
-        const listRes = await fetch(controlUrl("/routing/manual-providers"));
-        const listBody = await listRes.json() as { providers: unknown[] };
-        expect(listBody.providers).toEqual([]);
-      } finally {
-        await closeServer(provider.server);
-      }
-    });
-
-    it("saves disabled auto provider drafts without payment but gates enabled configs", async () => {
-      const draftRes = await fetch(controlUrl("/routing/auto-provider"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          enabled: false,
-          range: "custom",
-          scorer: "discount",
-          modelIds: ["gpt-4o"],
-          sellerIds: ["tbs-86d81e"]
-        })
-      });
-      expect(draftRes.status).toBe(200);
-      const draft = await draftRes.json() as { config: { enabled: boolean; range: string; maxConcurrentProviders: number }; paymentRequired: boolean };
-      expect(draft.config.enabled).toBe(false);
-      expect(draft.config.range).toBe("custom");
-      expect(draft.config.maxConcurrentProviders).toBe(10);
-      expect(draft.paymentRequired).toBe(true);
-
-      const blockedRes = await fetch(controlUrl("/routing/auto-provider"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          enabled: true,
-          range: "recommended",
-          scorer: "balanced",
-          modelIds: ["gpt-4o"]
-        })
-      });
-      expect(blockedRes.status).toBe(409);
-      const blocked = await blockedRes.json() as { error: { code: string } };
-      expect(blocked.error.code).toBe("payment_required");
-    });
-
-    it("applies enabled auto provider configs to the active routing strategy", async () => {
-      markClawtipReady();
-
-      const emptyCustomRes = await fetch(controlUrl("/routing/auto-provider"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          enabled: true,
-          range: "custom",
-          scorer: "balanced",
-          modelIds: ["gpt-4o"],
-          sellerIds: []
-        })
-      });
-      expect(emptyCustomRes.status).toBe(200);
-      const emptyCustom = await emptyCustomRes.json() as { config: { enabled: boolean; range: string; sellerIds: string[] }; autoEnabled: boolean; strategy?: unknown };
-      expect(emptyCustom.config).toMatchObject({ enabled: false, range: "custom", sellerIds: [] });
-      expect(emptyCustom.autoEnabled).toBe(false);
-      expect(emptyCustom.strategy).toBeUndefined();
-
-      const emptyCustomModeRes = await fetch(controlUrl("/routing/provider-mode"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "auto" })
-      });
-      expect(emptyCustomModeRes.status).toBe(200);
-      const emptyCustomMode = await emptyCustomModeRes.json() as { autoEnabled: boolean; strategy?: unknown };
-      expect(emptyCustomMode.autoEnabled).toBe(false);
-      expect(emptyCustomMode.strategy).toBeUndefined();
-
-      const recommendedRes = await fetch(controlUrl("/routing/auto-provider"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          enabled: true,
-          range: "recommended",
-          scorer: "speed",
-          modelIds: ["gpt-4o"]
-        })
-      });
-      expect(recommendedRes.status).toBe(200);
-      const recommended = await recommendedRes.json() as { strategy: { mode: string; scorer: string }; mode: string; autoEnabled: boolean };
-      expect(recommended.mode).toBe("auto");
-      expect(recommended.autoEnabled).toBe(true);
-      expect(recommended.strategy).toMatchObject({ mode: "fullAuto", scorer: "speed" });
-
-      const customRes = await fetch(controlUrl("/routing/auto-provider"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          enabled: true,
-          range: "custom",
-          scorer: "discount",
-          modelIds: ["gpt-4o"],
-          sellerIds: ["tbs-86d81e", "tbs-719577"]
-        })
-      });
-      expect(customRes.status).toBe(200);
-      const custom = await customRes.json() as { strategy: { mode: string; scorer: string; sellerIds?: string[] } };
-      expect(custom.strategy).toMatchObject({
-        mode: "fixedSet",
-        scorer: "discount",
-        sellerIds: ["tbs-86d81e", "tbs-719577"]
-      });
-
-      const strategyRes = await fetch(controlUrl("/routing/strategy"));
-      const strategy = await strategyRes.json() as { strategy: { mode: string; scorer: string; sellerIds?: string[] } };
-      expect(strategy.strategy).toMatchObject({
-        mode: "fixedSet",
-        scorer: "discount",
-        sellerIds: ["tbs-86d81e", "tbs-719577"]
-      });
-    });
-
-    it("routes manual provider requests with ordered fallback and records local observations", async () => {
-      const previousA = process.env.TB_TEST_PROVIDER_A_KEY;
-      const previousB = process.env.TB_TEST_PROVIDER_B_KEY;
-      process.env.TB_TEST_PROVIDER_A_KEY = "provider-a-test-key";
-      process.env.TB_TEST_PROVIDER_B_KEY = "provider-b-test-key";
-
-      const providerA = await startJsonServer((req, res) => {
-        expect(req.headers.authorization).toBe("Bearer provider-a-test-key");
-        res.writeHead(500, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: { message: "temporary upstream failure" } }));
-      });
-      const providerB = await startJsonServer((req, res) => {
-        expect(req.headers.authorization).toBe("Bearer provider-b-test-key");
-        let body = "";
-        req.on("data", (chunk) => {
-          body += chunk.toString("utf8");
-        });
-        req.on("end", () => {
-          const parsed = JSON.parse(body) as { model: string };
-          expect(parsed.model).toBe("gpt-manual");
-          res.writeHead(200, { "content-type": "application/json" });
-          res.end(JSON.stringify({
-            id: "chatcmpl-manual",
-            object: "chat.completion",
-            choices: [{ index: 0, message: { role: "assistant", content: "ok" }, finish_reason: "stop" }],
-            usage: { prompt_tokens: 3, completion_tokens: 2 }
-          }));
-        });
-      });
-
-      try {
-        for (const provider of [
-          { id: "local-a", name: "Local A", baseUrl: `${providerA.url}/v1`, apiKeyEnv: "TB_TEST_PROVIDER_A_KEY" },
-          { id: "local-b", name: "Local B", baseUrl: `${providerB.url}/v1`, apiKeyEnv: "TB_TEST_PROVIDER_B_KEY" }
-        ]) {
-          const createRes = await fetch(controlUrl("/routing/manual-providers"), {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({
-              ...provider,
-              models: ["gpt-manual"],
-              supportedProtocols: ["chat_completions"],
-              enabled: true
-            })
-          });
-          expect(createRes.status).toBe(201);
-        }
-
-        const modelsRes = await fetch(proxyUrl("/v1/models"));
-        expect(modelsRes.status).toBe(200);
-        const models = await modelsRes.json() as { data: Array<{ id: string; sellerId: string; paymentMethods: string[] }> };
-        expect(models.data.map((model) => [model.id, model.sellerId, model.paymentMethods[0]])).toEqual([
-          ["gpt-manual", "local-a", "provider_key"],
-          ["gpt-manual", "local-b", "provider_key"]
-        ]);
-
-        const response = await fetch(proxyUrl("/v1/chat/completions"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            model: "gpt-manual",
-            messages: [{ role: "user", content: "hello" }]
-          })
-        });
-        expect(response.status).toBe(200);
-        const body = await response.json() as { choices: unknown[] };
-        expect(body.choices.length).toBe(1);
-
-        const purchases = await (await fetch(controlUrl("/ledger/purchases"))).json() as { purchases: unknown[] };
-        expect(purchases.purchases).toEqual([]);
-        const inferences = await (await fetch(controlUrl("/ledger/inferences"))).json() as {
-          inferences: Array<{ sellerKey: string; paymentMethod?: string; priceVersion?: string; routeReason?: string; fallbackCount?: number }>;
-        };
-        expect(inferences.inferences).toHaveLength(1);
-        expect(inferences.inferences[0]).toMatchObject({
-          sellerKey: "local-b",
-          paymentMethod: "provider_key",
-          priceVersion: "local-provider:local-b",
-          routeReason: "manual:fallback:routes_2",
-          fallbackCount: 1
-        });
-
-        const providersRes = await fetch(controlUrl("/routing/manual-providers"));
-        const providersBody = await providersRes.json() as {
-          providers: Array<{ id: string; current?: boolean; lastAccess?: string; status?: string; errorClass?: string }>;
-        };
-        expect(providersBody.providers).toEqual([
-          expect.objectContaining({ id: "local-a", current: false, status: "degraded", errorClass: "upstream_5xx" }),
-          expect.objectContaining({ id: "local-b", current: true, status: "healthy" })
-        ]);
-        expect(providersBody.providers[0].lastAccess).toBeTruthy();
-        expect(providersBody.providers[1].lastAccess).toBeTruthy();
-      } finally {
-        await closeServer(providerA.server);
-        await closeServer(providerB.server);
-        if (previousA === undefined) {
-          delete process.env.TB_TEST_PROVIDER_A_KEY;
-        } else {
-          process.env.TB_TEST_PROVIDER_A_KEY = previousA;
-        }
-        if (previousB === undefined) {
-          delete process.env.TB_TEST_PROVIDER_B_KEY;
-        } else {
-          process.env.TB_TEST_PROVIDER_B_KEY = previousB;
-        }
-      }
-    });
-
-    it("locks manual routing to one provider without falling back", async () => {
-      const previousA = process.env.TB_TEST_PROVIDER_LOCK_A_KEY;
-      const previousB = process.env.TB_TEST_PROVIDER_LOCK_B_KEY;
-      process.env.TB_TEST_PROVIDER_LOCK_A_KEY = "provider-lock-a-key";
-      process.env.TB_TEST_PROVIDER_LOCK_B_KEY = "provider-lock-b-key";
-      let providerBHits = 0;
-
-      const providerA = await startJsonServer((req, res) => {
-        expect(req.headers.authorization).toBe("Bearer provider-lock-a-key");
-        res.writeHead(500, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: { message: "locked upstream failed" } }));
-      });
-      const providerB = await startJsonServer((req, res) => {
-        providerBHits += 1;
-        expect(req.headers.authorization).toBe("Bearer provider-lock-b-key");
-        res.writeHead(200, { "content-type": "application/json" });
-        res.end(JSON.stringify({
-          id: "chatcmpl-should-not-use-backup",
-          object: "chat.completion",
-          choices: [{ index: 0, message: { role: "assistant", content: "backup" }, finish_reason: "stop" }],
-          usage: { prompt_tokens: 1, completion_tokens: 1 }
-        }));
-      });
-
-      try {
-        for (const provider of [
-          { id: "lock-a", name: "Lock A", baseUrl: `${providerA.url}/v1`, apiKeyEnv: "TB_TEST_PROVIDER_LOCK_A_KEY" },
-          { id: "lock-b", name: "Lock B", baseUrl: `${providerB.url}/v1`, apiKeyEnv: "TB_TEST_PROVIDER_LOCK_B_KEY" }
-        ]) {
-          const createRes = await fetch(controlUrl("/routing/manual-providers"), {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({
-              ...provider,
-              models: ["gpt-locked"],
-              supportedProtocols: ["chat_completions"],
-              enabled: true
-            })
-          });
-          expect(createRes.status).toBe(201);
-        }
-
-        const lockRes = await fetch(controlUrl("/routing/manual-providers/routing"), {
-          method: "PUT",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ policy: "locked", lockedProviderId: "lock-a" })
-        });
-        expect(lockRes.status).toBe(200);
-        const lockBody = await lockRes.json() as { routing: { policy: string; lockedProviderId?: string } };
-        expect(lockBody.routing).toEqual({ policy: "locked", lockedProviderId: "lock-a" });
-
-        const response = await fetch(proxyUrl("/v1/chat/completions"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            model: "gpt-locked",
-            messages: [{ role: "user", content: "hello" }]
-          })
-        });
-        expect(response.status).toBe(500);
-        expect(providerBHits).toBe(0);
-
-        const providersRes = await fetch(controlUrl("/routing/manual-providers"));
-        const providersBody = await providersRes.json() as {
-          routing: { policy: string; lockedProviderId?: string };
-          providers: Array<{ id: string; current?: boolean; status?: string; errorClass?: string }>;
-        };
-        expect(providersBody.routing).toEqual({ policy: "locked", lockedProviderId: "lock-a" });
-        expect(providersBody.providers).toEqual([
-          expect.objectContaining({ id: "lock-a", current: false, status: "degraded", errorClass: "upstream_5xx" }),
-          expect.objectContaining({ id: "lock-b" })
-        ]);
-
-        const fallbackRes = await fetch(controlUrl("/routing/manual-providers/routing"), {
-          method: "PUT",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ policy: "fallback" })
-        });
-        expect(fallbackRes.status).toBe(200);
-        const fallbackBody = await fallbackRes.json() as { routing: { policy: string; lockedProviderId?: string } };
-        expect(fallbackBody.routing).toEqual({ policy: "fallback" });
-      } finally {
-        await closeServer(providerA.server);
-        await closeServer(providerB.server);
-        if (previousA === undefined) {
-          delete process.env.TB_TEST_PROVIDER_LOCK_A_KEY;
-        } else {
-          process.env.TB_TEST_PROVIDER_LOCK_A_KEY = previousA;
-        }
-        if (previousB === undefined) {
-          delete process.env.TB_TEST_PROVIDER_LOCK_B_KEY;
-        } else {
-          process.env.TB_TEST_PROVIDER_LOCK_B_KEY = previousB;
-        }
-      }
-    });
-
-    it("reorders manual provider fallback priority", async () => {
-      const previousA = process.env.TB_TEST_PROVIDER_ORDER_A_KEY;
-      const previousB = process.env.TB_TEST_PROVIDER_ORDER_B_KEY;
-      process.env.TB_TEST_PROVIDER_ORDER_A_KEY = "provider-order-a-key";
-      process.env.TB_TEST_PROVIDER_ORDER_B_KEY = "provider-order-b-key";
-      let providerAHits = 0;
-      let providerBHits = 0;
-
-      const providerA = await startJsonServer((req, res) => {
-        providerAHits += 1;
-        expect(req.headers.authorization).toBe("Bearer provider-order-a-key");
-        res.writeHead(200, { "content-type": "application/json" });
-        res.end(JSON.stringify({
-          id: "chatcmpl-order-a",
-          object: "chat.completion",
-          choices: [{ index: 0, message: { role: "assistant", content: "a" }, finish_reason: "stop" }],
-          usage: { prompt_tokens: 1, completion_tokens: 1 }
-        }));
-      });
-      const providerB = await startJsonServer((req, res) => {
-        providerBHits += 1;
-        expect(req.headers.authorization).toBe("Bearer provider-order-b-key");
-        res.writeHead(200, { "content-type": "application/json" });
-        res.end(JSON.stringify({
-          id: "chatcmpl-order-b",
-          object: "chat.completion",
-          choices: [{ index: 0, message: { role: "assistant", content: "b" }, finish_reason: "stop" }],
-          usage: { prompt_tokens: 1, completion_tokens: 1 }
-        }));
-      });
-
-      try {
-        for (const provider of [
-          { id: "order-a", name: "Order A", baseUrl: `${providerA.url}/v1`, apiKeyEnv: "TB_TEST_PROVIDER_ORDER_A_KEY" },
-          { id: "order-b", name: "Order B", baseUrl: `${providerB.url}/v1`, apiKeyEnv: "TB_TEST_PROVIDER_ORDER_B_KEY" }
-        ]) {
-          const createRes = await fetch(controlUrl("/routing/manual-providers"), {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({
-              ...provider,
-              models: ["gpt-order"],
-              supportedProtocols: ["chat_completions"],
-              enabled: true
-            })
-          });
-          expect(createRes.status).toBe(201);
-        }
-
-        const orderRes = await fetch(controlUrl("/routing/manual-providers/order"), {
-          method: "PUT",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ providerIds: ["order-b", "order-a"] })
-        });
-        expect(orderRes.status).toBe(200);
-        const orderBody = await orderRes.json() as { providers: Array<{ id: string }> };
-        expect(orderBody.providers.map((provider) => provider.id)).toEqual(["order-b", "order-a"]);
-
-        const response = await fetch(proxyUrl("/v1/chat/completions"), {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({
-            model: "gpt-order",
-            messages: [{ role: "user", content: "hello" }]
-          })
-        });
-        expect(response.status).toBe(200);
-        expect(providerBHits).toBe(1);
-        expect(providerAHits).toBe(0);
-      } finally {
-        await closeServer(providerA.server);
-        await closeServer(providerB.server);
-        if (previousA === undefined) {
-          delete process.env.TB_TEST_PROVIDER_ORDER_A_KEY;
-        } else {
-          process.env.TB_TEST_PROVIDER_ORDER_A_KEY = previousA;
-        }
-        if (previousB === undefined) {
-          delete process.env.TB_TEST_PROVIDER_ORDER_B_KEY;
-        } else {
-          process.env.TB_TEST_PROVIDER_ORDER_B_KEY = previousB;
-        }
-      }
-    });
-  });
-
-  // ─── GET /routing/strategy ────────────────────────────────────
-  describe("GET /routing/strategy", () => {
-    it("returns default strategy with source=default when no store value", async () => {
-      const res = await fetch(controlUrl("/routing/strategy"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        strategy: { mode: string; scorer: string };
-        source: string;
-      };
-      expect(body.strategy.mode).toBe("fullAuto");
-      expect(body.strategy.scorer).toBe("balanced");
-      expect(body.source).toBe("default");
-    });
-
-    it("returns source=store after PUT /routing/strategy writes a value", async () => {
-      // 写入策略
-      const putRes = await fetch(controlUrl("/routing/strategy"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "fixedSet", scorer: "speed", sellerIds: ["tbs-86d81e", "tbs-719577"] })
-      });
-      expect(putRes.status).toBe(200);
-      // 再读
-      const getRes = await fetch(controlUrl("/routing/strategy"));
-      const body = await getRes.json() as { strategy: { mode: string; scorer: string; sellerIds?: string[] }; source: string };
-      expect(body.strategy.mode).toBe("fixedSet");
-      expect(body.strategy.scorer).toBe("speed");
-      expect(body.strategy.sellerIds).toEqual(["tbs-86d81e", "tbs-719577"]);
-      expect(body.source).toBe("store");
-    });
-  });
-
-  // ─── GET /routing/preview ─────────────────────────────────────
-  describe("GET /routing/preview", () => {
-    it("returns a plan with the default (fullAuto, balanced) strategy", async () => {
-      const res = await fetch(controlUrl("/routing/preview?modelId=claude-sonnet-4-5"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        modelId: string;
-        plan: { mode: string; scorer: string; routes: Array<{ sellerId: string }>; reason: string };
-      };
-      expect(body.modelId).toBe("claude-sonnet-4-5");
-      expect(body.plan.mode).toBe("fullAuto");
-      expect(body.plan.scorer).toBe("balanced");
-      expect(body.plan.routes.length).toBeGreaterThan(0);
-      expect(body.plan.reason).toMatch(/^fullAuto:balanced:routes_\d+$/);
-    });
-
-    it("resolves fixedByModel for the requested model", async () => {
-      const res = await fetch(controlUrl("/routing/preview?mode=fixed&scorer=speed&fixedByModel=claude-sonnet-4-5:tbs-719577,gpt-4o:tbs-825edb&modelId=gpt-4o"));
-      expect(res.status).toBe(200);
-      const body = await res.json() as {
-        plan: { mode: string; scorer: string; routes: Array<{ seller: { id: string } }>; reason: string };
-      };
-      expect(body.plan.mode).toBe("fixed");
-      expect(body.plan.scorer).toBe("speed");
-      expect(body.plan.routes.map((route) => route.seller.id)).toEqual(["tbs-825edb"]);
-      expect(body.plan.reason).toBe("fixed:speed:routes_1");
-    });
-
-    it("rejects an invalid mode in the query string", async () => {
-      const res = await fetch(controlUrl("/routing/preview?mode=invalid"));
-      expect(res.status).toBe(400);
-      const body = await res.json() as { error: { code: string } };
-      expect(body.error.code).toBe("routing_preview_failed");
-    });
-
-    it("returns 409 with registry_not_loaded when snapshot is cleared", async () => {
-      daemon.setLastRegistrySnapshotForTest(null);
-      const res = await fetch(controlUrl("/routing/preview?modelId=claude-sonnet-4-5"));
-      expect(res.status).toBe(409);
-      const body = await res.json() as { error: { code: string } };
-      expect(body.error.code).toBe("registry_not_loaded");
-    });
-  });
-
-  // ─── PUT /routing/strategy ────────────────────────────────────
-  describe("PUT /routing/strategy", () => {
-    it("rejects fixed mode without sellerId", async () => {
-      const res = await fetch(controlUrl("/routing/strategy"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "fixed", scorer: "balanced" })
-      });
-      expect(res.status).toBe(400);
-      const body = await res.json() as { error: { code: string; message: string } };
-      expect(body.error.code).toBe("routing_strategy_apply_failed");
-      expect(body.error.message).toMatch(/fixed/);
-    });
-
-    it("rejects an invalid mode value", async () => {
-      const res = await fetch(controlUrl("/routing/strategy"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "auto", scorer: "balanced" })
-      });
-      expect(res.status).toBe(400);
-    });
-
-    it("applies a valid fullAuto strategy and returns the preview", async () => {
-      const res = await fetch(controlUrl("/routing/strategy"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "fullAuto", scorer: "discount" })
-      });
-      expect(res.status).toBe(200);
-      const body = await res.json() as Record<string, unknown>;
-      const body2 = body as {
-        applied: boolean;
-        strategy: { mode: string; scorer: string };
-        preview: { modelId?: string; mode?: string; scorer?: string; routes?: unknown[]; error?: string };
-      };
-      expect(body2.applied).toBe(true);
-      expect(body2.strategy.mode).toBe("fullAuto");
-      expect(body2.strategy.scorer).toBe("discount");
-      expect(body2.preview.mode).toBe("fullAuto");
-      expect(body2.preview.scorer).toBe("discount");
-      expect((body2.preview.routes ?? []).length).toBeGreaterThan(0);
-    });
-
-    it("persists applied strategy across GET requests (hot reload)", async () => {
-      await fetch(controlUrl("/routing/strategy"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ mode: "fixed", scorer: "balanced", sellerId: "tbs-86d81e" })
-      });
-      // 再读,daemon 内部 routing 应当是 fixed
-      const res = await fetch(controlUrl("/routing/strategy"));
-      const body = await res.json() as { strategy: { mode: string; sellerId?: string } };
-      expect(body.strategy.mode).toBe("fixed");
-      expect(body.strategy.sellerId).toBe("tbs-86d81e");
-    });
-
-    it("persists fixed sellers per model and previews the matching seller", async () => {
-      const putRes = await fetch(controlUrl("/routing/strategy"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          mode: "fixed",
-          scorer: "speed",
-          fixedByModel: {
-            "claude-sonnet-4-5": "tbs-719577",
-            "gpt-4o": "tbs-825edb"
-          }
-        })
-      });
-      expect(putRes.status).toBe(200);
-
-      const getRes = await fetch(controlUrl("/routing/strategy"));
-      const strategyBody = await getRes.json() as {
-        strategy: { mode: string; fixedByModel?: Record<string, string> };
-      };
-      expect(strategyBody.strategy.mode).toBe("fixed");
-      expect(strategyBody.strategy.fixedByModel).toEqual({
-        "claude-sonnet-4-5": "tbs-719577",
-        "gpt-4o": "tbs-825edb"
-      });
-
-      const previewRes = await fetch(controlUrl("/routing/preview?modelId=claude-sonnet-4-5"));
-      expect(previewRes.status).toBe(200);
-      const previewBody = await previewRes.json() as {
-        plan: { routes: Array<{ seller: { id: string } }>; reason: string };
-      };
-      expect(previewBody.plan.routes.map((route) => route.seller.id)).toEqual(["tbs-719577"]);
-      expect(previewBody.plan.reason).toBe("fixed:speed:routes_1");
-    });
-  });
-
-  // ─── PUT /prewarm/focus-set ───────────────────────────────────
-  describe("PUT /prewarm/focus-set", () => {
-    it("sets an explicit focus set and reports source=explicit", async () => {
-      const res = await fetch(controlUrl("/prewarm/focus-set"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ models: ["claude-sonnet-4-5", "gpt-4o"] })
-      });
-      expect(res.status).toBe(200);
-      const body = await res.json() as { ok: boolean; focusSet: string[]; source: string };
-      expect(body.ok).toBe(true);
-      expect(body.focusSet).toEqual(["claude-sonnet-4-5", "gpt-4o"]);
-      expect(body.source).toBe("explicit");
-    });
-
-    it("dedupes and trims the models array", async () => {
-      const res = await fetch(controlUrl("/prewarm/focus-set"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ models: ["  gpt-4o  ", "gpt-4o", "claude-sonnet-4-5", ""] })
-      });
-      expect(res.status).toBe(200);
-      const body = await res.json() as { focusSet: string[] };
-      expect(body.focusSet).toEqual(["gpt-4o", "claude-sonnet-4-5"]);
-    });
-
-    it("rejects a body without models and without clear flag", async () => {
-      const res = await fetch(controlUrl("/prewarm/focus-set"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({})
-      });
-      expect(res.status).toBe(400);
-      const body = await res.json() as { error: { code: string } };
-      expect(body.error.code).toBe("invalid_focus_set");
-    });
-
-    it("clear=true falls back to env/historical (not explicit)", async () => {
-      // 先设置一个 explicit
-      await fetch(controlUrl("/prewarm/focus-set"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ models: ["gpt-4o"] })
-      });
-      // clear
-      const res = await fetch(controlUrl("/prewarm/focus-set"), {
-        method: "PUT",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ clear: true })
-      });
-      expect(res.status).toBe(200);
-      const body = await res.json() as { ok: boolean; source: string };
-      expect(body.ok).toBe(true);
-      expect(body.source).not.toBe("explicit");
-    });
-  });
-});