@tokenbuddy/tokenbuddy 1.0.13 → 1.0.15

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

@@ -0,0 +1,559 @@
+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 type { SellerRegistryDocument } from "../src/seller-catalog.js";
+
+/**
+ * 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,
+      ...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}`;
+  }
+
+  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();
+  });
+
+  // ─── ClawTip payment QR endpoints ─────────────────────────────
+  describe("ClawTip payment QR endpoints", () => {
+    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-wallet-bootstrap.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-wallet-bootstrap",
+            skillId: "si-tb-wallet-bootstrap",
+            description: "TokenBuddy ClawTip wallet activation",
+            resourceUrl: "https://tb-wallet-bootstrap.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-wallet-bootstrap.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-wallet-bootstrap.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-wallet-bootstrap.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");
+    });
+  });
+
+  // ─── 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");
+    });
+  });
+
+  // ─── 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");
+    });
+  });
+});

package/tests/daemon-classify.test.ts

@@ -41,6 +41,15 @@ describe("TokenbuddyDaemon classifyFailureStatus", () => {
     expect((daemon as any).classifyFailureStatus(503)).toBe("soft_5xx");
   });
 
+  test("classifies seller capacity exhaustion separately from generic 429", () => {
+    expect((daemon as any).classifyFailureStatus(429, JSON.stringify({
+      error: { code: "busy_capacity" }
+    }))).toBe("busy_capacity");
+    expect((daemon as any).classifyFailureStatus(429, JSON.stringify({
+      error: { code: "rate_limited" }
+    }))).toBe("soft_5xx");
+  });
+
   test("recognizes supported proxy endpoint protocols", () => {
     expect((daemon as any).endpointProtocol("/v1/chat/completions")).toBe("chat_completions");
     expect((daemon as any).endpointProtocol("/v1/responses")).toBe("responses");

package/tests/model-index.test.ts

@@ -5,6 +5,7 @@ function makeSeller(overrides: Partial<RegistrySeller> & { id: string; models?:
   return {
     id: overrides.id,
     name: overrides.name ?? overrides.id,
+    status: overrides.status,
     url: overrides.url ?? `https://${overrides.id}.example.com`,
     supportedProtocols: overrides.supportedProtocols ?? ["chat_completions"],
     paymentMethods: overrides.paymentMethods ?? ["clawtip"],
@@ -84,6 +85,19 @@ describe("ModelIndex", () => {
     expect(noFilter.map((s) => s.id).sort()).toEqual(["s-chat", "s-msg"]);
   });
 
+  test("indexes only active buyer-visible registry sellers", () => {
+    const index = new ModelIndex();
+    index.rebuild([
+      makeSeller({ id: "legacy-no-status", models: ["gpt-4o"] }),
+      makeSeller({ id: "active", status: "active", models: ["gpt-4o"] }),
+      makeSeller({ id: "pending", status: "pending", models: ["gpt-4o"] }),
+      makeSeller({ id: "offline", status: "offline", models: ["gpt-4o"] })
+    ]);
+
+    expect(index.sellersFor("gpt-4o").map((seller) => seller.id)).toEqual(["legacy-no-status", "active"]);
+    expect(index.getSeller("pending")).toBeUndefined();
+  });
+
   test("sellers missing models field are excluded from lookups but still addressable by id", () => {
     const index = new ModelIndex();
     const sellers: RegistrySeller[] = [

package/tests/route-failover.test.ts

@@ -102,6 +102,22 @@ describe("RouteFailover", () => {
     expect(decision.reason).toBe("soft_failure_fresh_purchase_window");
   });
 
+  test("decide on busy_capacity fails over without retrying or opening the circuit", () => {
+    const { failover, credit, pool } = buildHarness([{ id: "s1" }, { id: "s2" }]);
+    credit.recordPurchase("s1", 1_000_000, 1_000_000);
+    const decision = failover.decide(
+      { sellerId: "s1", status: 429, errorKind: "busy_capacity", errorMessage: "capacity full", attempt: 0 },
+      2
+    );
+
+    expect(decision.action).toBe("failover_next");
+    expect(decision.reason).toBe("busy_capacity");
+    const entry = pool.snapshot().find((candidate) => candidate.sellerId === "s1");
+    expect(entry?.circuit).toBe("closed");
+    expect(entry?.consecutiveFailures).toBe(0);
+    expect(entry?.capacityBlockedUntil).toBeGreaterThan(Date.now());
+  });
+
   test("decide on soft_5xx after exhausting retries returns failover_next", () => {
     const { failover, credit } = buildHarness([{ id: "s1" }]);
     credit.recordPurchase("s1", 1_000_000, 1_000_000);