@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

package/tests/daemon-classify.test.ts

@@ -1,452 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { TokenbuddyDaemon } from "../src/daemon.js";
-
-describe("TokenbuddyDaemon classifyFailureStatus", () => {
-  let daemon: TokenbuddyDaemon;
-
-  beforeEach(() => {
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath: ":memory:",
-      sellerRegistryUrl: "http://127.0.0.1:1/registry",
-    });
-  });
-
-  afterEach(() => {
-    daemon.stop();
-  });
-
-  test("classifies auth failures", () => {
-    expect((daemon as any).classifyFailureStatus(401)).toBe("auth_invalid");
-    expect((daemon as any).classifyFailureStatus(403)).toBe("auth_invalid");
-  });
-
-  test("classifies insufficient funds", () => {
-    expect((daemon as any).classifyFailureStatus(402)).toBe("insufficient_funds");
-  });
-
-  test("classifies hard request 4xx failures", () => {
-    expect((daemon as any).classifyFailureStatus(400)).toBe("hard_4xx");
-    expect((daemon as any).classifyFailureStatus(404)).toBe("hard_4xx");
-    expect((daemon as any).classifyFailureStatus(422)).toBe("hard_4xx");
-  });
-
-  test("classifies retryable upstream failures", () => {
-    expect((daemon as any).classifyFailureStatus(429)).toBe("soft_5xx");
-    expect((daemon as any).classifyFailureStatus(500)).toBe("soft_5xx");
-    expect((daemon as any).classifyFailureStatus(502)).toBe("soft_5xx");
-    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");
-    expect((daemon as any).endpointProtocol("/v1/messages")).toBe("messages");
-    expect((daemon as any).endpointProtocol("/messages")).toBe("messages");
-    expect((daemon as any).endpointProtocol("/v1/images/generations")).toBe("images_generations");
-    expect((daemon as any).endpointProtocol("/v1/unknown")).toBeUndefined();
-  });
-
-  test("extracts model ids from supported body shapes", () => {
-    expect((daemon as any).extractModelId("/v1/chat/completions", { model: " gpt-5.4 " })).toBe("gpt-5.4");
-    expect((daemon as any).extractModelId("/v1/chat/completions", { model: " " })).toBeUndefined();
-    expect((daemon as any).extractModelId("/v1/responses", { model_id: " resp-model " })).toBe("resp-model");
-    expect((daemon as any).extractModelId("/v1/responses", { model_id: 42 })).toBeUndefined();
-    expect((daemon as any).extractModelId("/v1/images/generations", { model: " gpt-image-2 " })).toBe("gpt-image-2");
-    expect((daemon as any).extractModelId("/v1/responses", null)).toBeUndefined();
-  });
-
-  test("resolves and applies route model ids", () => {
-    expect((daemon as any).resolveRouteModelId("/v1/chat/completions", { model: "gpt-5.4" })).toEqual({
-      requestedModelId: "gpt-5.4",
-      resolvedModelId: "gpt-5.4",
-    });
-    expect((daemon as any).resolveRouteModelId("/v1/chat/completions", {})).toEqual({});
-    expect((daemon as any).applyResolvedModelToBody("/v1/chat/completions", { model: "old" }, "new")).toEqual({
-      model: "new",
-    });
-    expect((daemon as any).applyResolvedModelToBody("/v1/responses", { model_id: "old" }, "new")).toEqual({
-      model_id: "new",
-    });
-    expect((daemon as any).applyResolvedModelToBody("/v1/responses", { input: "hi" }, "new")).toEqual({
-      input: "hi",
-    });
-  });
-
-  test("chooses the default enabled payment method", () => {
-    expect((daemon as any).defaultPaymentMethod()).toBeUndefined();
-    (daemon as any).tokenStore.savePayment({ method: "mock", enabled: true, isDefault: false });
-    expect((daemon as any).defaultPaymentMethod()).toBe("mock");
-    (daemon as any).tokenStore.savePayment({ method: "clawtip", enabled: true, isDefault: true });
-    expect((daemon as any).defaultPaymentMethod()).toBe("clawtip");
-  });
-
-  test("reads usage from chat and responses style bodies", () => {
-    expect((daemon as any).readUsage("")).toEqual({
-      promptTokens: 0,
-      completionTokens: 0,
-      cacheReadTokens: 0,
-      billedMicros: 0,
-    });
-    expect((daemon as any).readUsage("not-json")).toEqual({
-      promptTokens: 0,
-      completionTokens: 0,
-      cacheReadTokens: 0,
-      billedMicros: 0,
-    });
-    expect((daemon as any).readUsage(JSON.stringify({ usage: { prompt_tokens: 2, completion_tokens: 3 } }))).toEqual({
-      promptTokens: 2,
-      completionTokens: 3,
-      cacheReadTokens: 0,
-      billedMicros: 20,
-    });
-    expect((daemon as any).readUsage(JSON.stringify({ usage: { input_tokens: 5, output_tokens: 7, prompt_tokens_details: { cached_tokens: 4 } } }))).toEqual({
-      promptTokens: 5,
-      completionTokens: 7,
-      cacheReadTokens: 4,
-      billedMicros: 48,
-    });
-    expect((daemon as any).readUsage(JSON.stringify({ usage: { input_tokens: 25, output_tokens: 75, total_tokens: 100 } }))).toEqual({
-      promptTokens: 25,
-      completionTokens: 75,
-      cacheReadTokens: 0,
-      billedMicros: 400,
-    });
-  });
-
-  test("parses seller settlement headers", () => {
-    expect((daemon as any).parseSellerSettlementSummary(new Headers())).toBeUndefined();
-    expect((daemon as any).parseSellerSettlementSummary(new Headers({
-      "x-tokenbuddy-settlement": JSON.stringify({
-        request_id: "req-1",
-        settled_micros: "20",
-        remaining_credit_micros: "980",
-        reserved_balance_micros: 1,
-        spent_micros: 19,
-        price_version: "v1",
-      }),
-    }))).toEqual({
-      requestId: "req-1",
-      settledMicros: 20,
-      settledUsdMicros: undefined,
-      remainingCreditMicros: 980,
-      reservedBalanceMicros: 1,
-      spentMicros: 19,
-      priceVersion: "v1",
-    });
-    expect((daemon as any).parseSellerSettlementSummary(new Headers({
-      "x-tokenbuddy-settlement": "{bad",
-    }))).toBeUndefined();
-    expect((daemon as any).parseSellerSettlementSummary(new Headers({
-      "x-tokenbuddy-settlement": JSON.stringify({ requestId: "missing-numbers" }),
-    }))).toBeUndefined();
-  });
-
-  test("detects insufficient funds responses", () => {
-    expect((daemon as any).isInsufficientFundsResponse(500, "insufficient funds")).toBe(false);
-    expect((daemon as any).isInsufficientFundsResponse(402, JSON.stringify({ error: { code: "insufficient_funds" } }))).toBe(true);
-    expect((daemon as any).isInsufficientFundsResponse(402, JSON.stringify({ error: { message: "Insufficient funds available" } }))).toBe(true);
-    expect((daemon as any).isInsufficientFundsResponse(402, "{not-json insufficient funds")).toBe(true);
-    expect((daemon as any).isInsufficientFundsResponse(402, JSON.stringify({ error: { code: "other" } }))).toBe(false);
-  });
-
-  test("uses validated numeric environment defaults", () => {
-    const previousPurchase = process.env.TB_PROXYD_AUTO_PURCHASE_AMOUNT_USD_MICROS;
-    const previousRebuy = process.env.TB_PROXYD_TOKEN_REBUY_MIN_BALANCE_MICROS;
-    const previousProof = process.env.TB_PROXYD_CLAWTIP_PROOF_TIMEOUT_MS;
-    try {
-      delete process.env.TB_PROXYD_AUTO_PURCHASE_AMOUNT_USD_MICROS;
-      delete process.env.TB_PROXYD_TOKEN_REBUY_MIN_BALANCE_MICROS;
-      delete process.env.TB_PROXYD_CLAWTIP_PROOF_TIMEOUT_MS;
-      expect((daemon as any).autoPurchaseAmountUsdMicros()).toBe(2000000);
-      expect((daemon as any).tokenRebuyMinBalanceMicros()).toBe(200000);
-      expect((daemon as any).clawtipProofTimeoutMs()).toBe(120000);
-
-      process.env.TB_PROXYD_AUTO_PURCHASE_AMOUNT_USD_MICROS = "300";
-      process.env.TB_PROXYD_TOKEN_REBUY_MIN_BALANCE_MICROS = "0";
-      process.env.TB_PROXYD_CLAWTIP_PROOF_TIMEOUT_MS = "1000";
-      expect((daemon as any).autoPurchaseAmountUsdMicros()).toBe(300);
-      expect((daemon as any).tokenRebuyMinBalanceMicros()).toBe(0);
-      expect((daemon as any).clawtipProofTimeoutMs()).toBe(1000);
-
-      process.env.TB_PROXYD_AUTO_PURCHASE_AMOUNT_USD_MICROS = "0";
-      process.env.TB_PROXYD_TOKEN_REBUY_MIN_BALANCE_MICROS = "-1";
-      process.env.TB_PROXYD_CLAWTIP_PROOF_TIMEOUT_MS = "999";
-      expect((daemon as any).autoPurchaseAmountUsdMicros()).toBe(2000000);
-      expect((daemon as any).tokenRebuyMinBalanceMicros()).toBe(200000);
-      expect((daemon as any).clawtipProofTimeoutMs()).toBe(120000);
-    } finally {
-      restoreEnv("TB_PROXYD_AUTO_PURCHASE_AMOUNT_USD_MICROS", previousPurchase);
-      restoreEnv("TB_PROXYD_TOKEN_REBUY_MIN_BALANCE_MICROS", previousRebuy);
-      restoreEnv("TB_PROXYD_CLAWTIP_PROOF_TIMEOUT_MS", previousProof);
-    }
-  });
-
-  test("uses validated request deadline and token expiry margin defaults", () => {
-    const previousDeadline = process.env.TB_PROXYD_REQUEST_DEADLINE_MS;
-    const previousMargin = process.env.TB_PROXYD_TOKEN_EXPIRY_SAFETY_MARGIN_MS;
-    try {
-      delete process.env.TB_PROXYD_REQUEST_DEADLINE_MS;
-      delete process.env.TB_PROXYD_TOKEN_EXPIRY_SAFETY_MARGIN_MS;
-      expect((daemon as any).requestDeadlineMs()).toBe(180000);
-      expect((daemon as any).tokenExpirySafetyMarginMs()).toBe(60000);
-
-      process.env.TB_PROXYD_REQUEST_DEADLINE_MS = "2500";
-      process.env.TB_PROXYD_TOKEN_EXPIRY_SAFETY_MARGIN_MS = "0";
-      expect((daemon as any).requestDeadlineMs()).toBe(2500);
-      expect((daemon as any).tokenExpirySafetyMarginMs()).toBe(0);
-
-      process.env.TB_PROXYD_REQUEST_DEADLINE_MS = "999";
-      process.env.TB_PROXYD_TOKEN_EXPIRY_SAFETY_MARGIN_MS = "-1";
-      expect((daemon as any).requestDeadlineMs()).toBe(180000);
-      expect((daemon as any).tokenExpirySafetyMarginMs()).toBe(60000);
-    } finally {
-      restoreEnv("TB_PROXYD_REQUEST_DEADLINE_MS", previousDeadline);
-      restoreEnv("TB_PROXYD_TOKEN_EXPIRY_SAFETY_MARGIN_MS", previousMargin);
-    }
-  });
-
-  test("infers prompt hash input for object bodies only", () => {
-    expect((daemon as any).inferPromptForHash(null)).toBeUndefined();
-    expect((daemon as any).inferPromptForHash("text")).toBeUndefined();
-    expect((daemon as any).inferPromptForHash({ model: "gpt-5.4", messages: [] })).toBe(JSON.stringify({
-      model: "gpt-5.4",
-      messages: [],
-    }));
-  });
-
-  test("resolves payment proof from supported mock and ClawTip sources", async () => {
-    const previousProof = process.env.TOKENBUDDY_CLAWTIP_PAYMENT_PROOF;
-    const previousOldProof = process.env.TOKENBUDDY_CLAWTIP_PROOF_FILE;
-    const previousProofFile = process.env.TOKENBUDDY_CLAWTIP_PAYMENT_PROOF_FILE;
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tokenbuddy-proof-"));
-    const proofFile = path.join(tempDir, "proof.txt");
-    const route = routeFor("clawtip");
-    try {
-      expect(await (daemon as any).resolvePaymentProof(routeFor("mock"), {}, "req-1")).toBe("mock-proof-data");
-      await expect((daemon as any).resolvePaymentProof(routeFor("card"), {}, "req-1"))
-        .rejects.toThrow("unsupported payment method");
-
-      process.env.TOKENBUDDY_CLAWTIP_PAYMENT_PROOF = " proof-from-env ";
-      expect(await (daemon as any).resolvePaymentProof(route, {}, "req-1")).toBe("proof-from-env");
-
-      delete process.env.TOKENBUDDY_CLAWTIP_PAYMENT_PROOF;
-      fs.writeFileSync(proofFile, " proof-from-file\n");
-      process.env.TOKENBUDDY_CLAWTIP_PAYMENT_PROOF_FILE = proofFile;
-      expect(await (daemon as any).resolvePaymentProof(route, {}, "req-1")).toBe("proof-from-file");
-
-      delete process.env.TOKENBUDDY_CLAWTIP_PAYMENT_PROOF_FILE;
-      await expect((daemon as any).resolvePaymentProof(route, {}, "req-1"))
-        .rejects.toThrow("clawtip auto purchase requires");
-    } finally {
-      restoreEnv("TOKENBUDDY_CLAWTIP_PAYMENT_PROOF", previousProof);
-      restoreEnv("TOKENBUDDY_CLAWTIP_PROOF_FILE", previousOldProof);
-      restoreEnv("TOKENBUDDY_CLAWTIP_PAYMENT_PROOF_FILE", previousProofFile);
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  test("copies only safe upstream headers", () => {
-    const upstream = {
-      headers: new Headers({
-        "content-type": "application/json",
-        "content-length": "20",
-        connection: "keep-alive",
-        "x-tokenbuddy-test": "ok",
-      }),
-    } as Response;
-    const res = {
-      setHeader: jest.fn(),
-    };
-
-    (daemon as any).copyUpstreamHeaders(upstream, res);
-
-    expect(res.setHeader).toHaveBeenCalledWith("content-type", "application/json");
-    expect(res.setHeader).toHaveBeenCalledWith("x-tokenbuddy-test", "ok");
-    expect(res.setHeader).not.toHaveBeenCalledWith("content-length", expect.anything());
-    expect(res.setHeader).not.toHaveBeenCalledWith("connection", expect.anything());
-  });
-
-  test("resolves focus sets from explicit config and environment", () => {
-    const explicitDaemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath: ":memory:",
-      sellerRegistryUrl: "http://127.0.0.1:1/registry",
-      warmupModels: ["explicit-a", "explicit-b"],
-    });
-    const previousWarmup = process.env.TB_BUYER_WARMUP_MODELS;
-    try {
-      expect((explicitDaemon as any).resolveFocusSet()).toEqual(["explicit-a", "explicit-b"]);
-
-      process.env.TB_BUYER_WARMUP_MODELS = " env-a, ,env-b ";
-      expect((daemon as any).resolveFocusSet()).toEqual(["env-a", "env-b"]);
-
-      delete process.env.TB_BUYER_WARMUP_MODELS;
-      expect((daemon as any).resolveFocusSet()).toEqual([]);
-    } finally {
-      explicitDaemon.stop();
-      restoreEnv("TB_BUYER_WARMUP_MODELS", previousWarmup);
-    }
-  });
-
-  test("resolves prewarm protocol from the model index", () => {
-    (daemon as any).modelIndex.rebuild([
-      {
-        id: "seller-chat",
-        url: "https://seller-chat.example.com",
-        models: ["chat-model"],
-        supportedProtocols: ["chat_completions"],
-        paymentMethods: ["clawtip"],
-      },
-      {
-        id: "seller-messages",
-        url: "https://seller-messages.example.com",
-        models: ["message-model"],
-        supportedProtocols: ["messages"],
-        paymentMethods: ["clawtip"],
-      },
-      {
-        id: "seller-responses",
-        url: "https://seller-responses.example.com",
-        models: ["response-model"],
-        supportedProtocols: ["responses"],
-        paymentMethods: ["clawtip"],
-      },
-    ]);
-
-    expect((daemon as any).resolvePrewarmProtocol("chat-model")).toBe("chat_completions");
-    expect((daemon as any).resolvePrewarmProtocol("message-model")).toBe("messages");
-    expect((daemon as any).resolvePrewarmProtocol("response-model")).toBe("responses");
-    expect((daemon as any).resolvePrewarmProtocol("missing-model")).toBeUndefined();
-  });
-
-  test("reuses fresh cached seller tokens", async () => {
-    (daemon as any).tokenStore.saveToken(
-      "seller-a",
-      "cached-token",
-      "model:gpt-5.4",
-      900000,
-      "2099-01-01T00:00:00.000Z"
-    );
-
-    await expect((daemon as any).getOrPurchaseToken(routeFor("mock"), "req-cache"))
-      .resolves.toBe("cached-token");
-  });
-
-  test("purchases and persists a token when cache is missing", async () => {
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockImplementation(async (url: string | URL | Request) => {
-      const href = String(url);
-      if (href === "https://seller-a.example.com/purchase/create") {
-        return response({
-          purchase_id: "purchase-1",
-          status: "pending",
-          payment_reference: "pay-ref",
-          expires_at: "2099-01-01T00:00:00.000Z",
-          credit_micros: 500000,
-          currency: "USD",
-          payment_instructions: { type: "mock" },
-          quote: { amount: 5 },
-        });
-      }
-      if (href === "https://seller-a.example.com/purchase/complete") {
-        return response({
-          access_token: "new-token",
-          token_class: "model:gpt-5.4",
-          credit_micros: 500000,
-          currency: "USD",
-          payment_reference: "pay-ref",
-          status: "funded",
-        });
-      }
-      throw new Error(`unexpected fetch ${href}`);
-    }) as jest.MockedFunction<typeof fetch>;
-
-    try {
-      await expect((daemon as any).getOrPurchaseToken(routeFor("mock"), "req-buy"))
-        .resolves.toBe("new-token");
-      expect((daemon as any).tokenStore.getToken("seller-a")).toMatchObject({
-        token: "new-token",
-        balanceMicros: 500000,
-      });
-      expect((daemon as any).tokenStore.listPurchaseLedger()).toHaveLength(1);
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-
-  test("surfaces purchase create and complete failures", async () => {
-    const fetchMock = jest.spyOn(globalThis, "fetch");
-    try {
-      fetchMock.mockResolvedValueOnce(response({ error: { message: "create denied" } }, false, 402));
-      await expect((daemon as any).getOrPurchaseToken(routeFor("mock"), "req-create-fail"))
-        .rejects.toThrow("create denied");
-
-      fetchMock
-        .mockResolvedValueOnce(response({ purchaseId: "purchase-2" }))
-        .mockResolvedValueOnce(response({ error: { message: "complete denied" } }, false, 500));
-      await expect((daemon as any).getOrPurchaseToken(routeFor("mock"), "req-complete-fail"))
-        .rejects.toThrow("complete denied");
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-
-  test("validates required purchase response fields", async () => {
-    const fetchMock = jest.spyOn(globalThis, "fetch");
-    try {
-      fetchMock.mockResolvedValueOnce(response({ status: "pending" }));
-      await expect((daemon as any).getOrPurchaseToken(routeFor("mock"), "req-no-purchase"))
-        .rejects.toThrow("purchase/create response missing purchaseId");
-
-      fetchMock
-        .mockResolvedValueOnce(response({ purchaseId: "purchase-3" }))
-        .mockResolvedValueOnce(response({ status: "funded" }));
-      await expect((daemon as any).getOrPurchaseToken(routeFor("mock"), "req-no-token"))
-        .rejects.toThrow("purchase/complete response missing accessToken");
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-});
-
-function restoreEnv(name: string, value: string | undefined): void {
-  if (value === undefined) {
-    delete process.env[name];
-  } else {
-    process.env[name] = value;
-  }
-}
-
-function routeFor(paymentMethod: string): unknown {
-  return {
-    seller: {
-      id: "seller-a",
-      url: "https://seller-a.example.com",
-    },
-    manifest: null,
-    protocol: "chat_completions",
-    modelId: "gpt-5.4",
-    paymentMethod,
-  };
-}
-
-function response(body: unknown, ok = true, status = 200): Response {
-  return {
-    ok,
-    status,
-    json: async () => body,
-  } as Response;
-}

package/tests/daemon-roles.test.ts

@@ -1,92 +0,0 @@
-import { TokenbuddyDaemon } from "../src/daemon.js";
-import type { ClaudeCodeModelMappingConfig, SingleModelProviderRuntimeConfig } from "../src/provider-install.js";
-
-describe("TokenbuddyDaemon resolveClaudeRoleModel", () => {
-  let daemon: TokenbuddyDaemon;
-
-  beforeEach(() => {
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath: ":memory:",
-      sellerRegistryUrl: "http://127.0.0.1:1/registry",
-    });
-  });
-
-  afterEach(() => {
-    daemon.stop();
-  });
-
-  function saveConfig(config: ClaudeCodeModelMappingConfig | SingleModelProviderRuntimeConfig): void {
-    (daemon as any).tokenStore.saveProviderRuntimeConfig("claude-code", config);
-  }
-
-  test("returns stripped model id when runtime config is absent", () => {
-    expect((daemon as any).resolveClaudeRoleModel("claude-sonnet-4-6 [1M]")).toBe("claude-sonnet-4-6");
-  });
-
-  test("returns stripped model id when selection kind is not role mapping", () => {
-    saveConfig({
-      selectionKind: "single-model",
-      defaultModel: "upstream-default",
-    });
-
-    expect((daemon as any).resolveClaudeRoleModel("sonnet [1M]")).toBe("sonnet");
-  });
-
-  test("maps haiku aliases to haiku upstream model", () => {
-    saveConfig({
-      selectionKind: "claude-role-mapping",
-      roles: {
-        haiku: { upstreamModel: "upstream-haiku" },
-      },
-    });
-
-    expect((daemon as any).resolveClaudeRoleModel("haiku")).toBe("upstream-haiku");
-    expect((daemon as any).resolveClaudeRoleModel("claude-haiku-4-5 [1M]")).toBe("upstream-haiku");
-  });
-
-  test("maps sonnet aliases to sonnet upstream model", () => {
-    saveConfig({
-      selectionKind: "claude-role-mapping",
-      roles: {
-        sonnet: { upstreamModel: "upstream-sonnet" },
-      },
-    });
-
-    expect((daemon as any).resolveClaudeRoleModel("sonnet")).toBe("upstream-sonnet");
-    expect((daemon as any).resolveClaudeRoleModel("claude-sonnet-4-6")).toBe("upstream-sonnet");
-  });
-
-  test("maps opus aliases to opus upstream model", () => {
-    saveConfig({
-      selectionKind: "claude-role-mapping",
-      roles: {
-        opus: { upstreamModel: "upstream-opus" },
-      },
-    });
-
-    expect((daemon as any).resolveClaudeRoleModel("opus")).toBe("upstream-opus");
-    expect((daemon as any).resolveClaudeRoleModel("claude-opus-4-7")).toBe("upstream-opus");
-  });
-
-  test("uses fallback for unknown roles and missing role bindings", () => {
-    saveConfig({
-      selectionKind: "claude-role-mapping",
-      fallbackModel: "upstream-fallback",
-      roles: {},
-    });
-
-    expect((daemon as any).resolveClaudeRoleModel("custom-role")).toBe("upstream-fallback");
-    expect((daemon as any).resolveClaudeRoleModel("haiku")).toBe("upstream-fallback");
-  });
-
-  test("returns stripped model id when role mapping has no match or fallback", () => {
-    saveConfig({
-      selectionKind: "claude-role-mapping",
-      roles: {},
-    });
-
-    expect((daemon as any).resolveClaudeRoleModel("custom-role [1M]")).toBe("custom-role");
-  });
-});

package/tests/daemon-trusted-registry-cache.test.ts

@@ -1,132 +0,0 @@
-import * as http from "http";
-import * as fs from "fs";
-import * as path from "path";
-import { AddressInfo } from "net";
-import { TokenbuddyDaemon } from "../src/daemon.js";
-import { BuyerStore } from "../src/buyer-store.js";
-
-describe("TokenbuddyDaemon trusted registry cache", () => {
-  const TEMP_DB = path.resolve(__dirname, "../../data-test/trusted-registry-cache-test.db");
-  let server: http.Server;
-  let serverPort: number;
-  let registryAvailable = true;
-  let daemon: TokenbuddyDaemon | undefined;
-
-  function rmDb(): void {
-    for (const suffix of ["", "-wal", "-shm"]) {
-      fs.rmSync(`${TEMP_DB}${suffix}`, { force: true });
-    }
-  }
-
-  function startDaemon(): { controlPort: number; proxyPort: number } {
-    daemon = new TokenbuddyDaemon({
-      controlPort: 0,
-      proxyPort: 0,
-      dbPath: TEMP_DB,
-      sellerRegistryUrl: `http://127.0.0.1:${serverPort}/registry/sellers`
-    });
-    daemon.start();
-    return {
-      controlPort: ((daemon as unknown as { controlServer: { address(): AddressInfo } }).controlServer.address()).port,
-      proxyPort: ((daemon as unknown as { proxyServer: { address(): AddressInfo } }).proxyServer.address()).port
-    };
-  }
-
-  async function stopDaemon(): Promise<void> {
-    daemon?.stop();
-    daemon = undefined;
-    await new Promise<void>((resolve) => setTimeout(resolve, 50));
-  }
-
-  beforeAll((done) => {
-    server = http.createServer((req, res) => {
-      res.setHeader("Content-Type", "application/json");
-      if (req.url === "/registry/sellers") {
-        if (!registryAvailable) {
-          res.statusCode = 500;
-          res.end(JSON.stringify({ error: "registry unavailable" }));
-          return;
-        }
-        res.statusCode = 200;
-        res.end(JSON.stringify({
-          version: 7,
-          defaultSeller: "cached-seller",
-          sellers: [
-            {
-              id: "cached-seller",
-              name: "Cached Seller",
-              status: "active",
-              url: `http://127.0.0.1:${serverPort}/cached-seller`,
-              supportedProtocols: ["chat_completions"],
-              paymentMethods: ["mock"],
-              models: ["gpt-cache"]
-            }
-          ]
-        }));
-        return;
-      }
-      if (req.url === "/cached-seller/manifest") {
-        res.statusCode = 200;
-        res.end(JSON.stringify({
-          sellerId: "cached-seller",
-          supportedProtocols: ["chat_completions"],
-          paymentMethods: ["mock"],
-          models: [{ id: "gpt-cache" }]
-        }));
-        return;
-      }
-      res.statusCode = 404;
-      res.end(JSON.stringify({ error: "not found" }));
-    });
-    server.listen(0, "127.0.0.1", () => {
-      serverPort = (server.address() as AddressInfo).port;
-      done();
-    });
-  });
-
-  afterAll((done) => {
-    server.close(() => done());
-  });
-
-  beforeEach(() => {
-    rmDb();
-    registryAvailable = true;
-  });
-
-  afterEach(async () => {
-    await stopDaemon();
-    rmDb();
-  });
-
-  test("persists a trusted registry snapshot and reuses it after daemon restart", async () => {
-    let ports = startDaemon();
-    const firstModels = await (await fetch(`http://127.0.0.1:${ports.proxyPort}/v1/models`)).json() as any;
-    expect(firstModels.data).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "gpt-cache", sellerId: "cached-seller" })
-    ]));
-
-    const store = new BuyerStore({ dbPath: TEMP_DB });
-    const cache = store.getDaemonRuntimeConfig<any>("trusted-registry-snapshot")?.config;
-    store.close();
-    expect(cache).toMatchObject({
-      schemaVersion: 1,
-      registryUrl: `http://127.0.0.1:${serverPort}/registry/sellers`,
-      version: 7,
-      trust: {
-        verified: false
-      }
-    });
-    expect(cache.registrySha256).toMatch(/^[a-f0-9]{64}$/);
-
-    await stopDaemon();
-    registryAvailable = false;
-
-    ports = startDaemon();
-    const secondModelsResponse = await fetch(`http://127.0.0.1:${ports.proxyPort}/v1/models`);
-    expect(secondModelsResponse.status).toBe(200);
-    const secondModels = await secondModelsResponse.json() as any;
-    expect(secondModels.data).toEqual([
-      expect.objectContaining({ id: "gpt-cache", sellerId: "cached-seller" })
-    ]);
-  });
-});