@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

package/tests/cli-routing.test.ts

@@ -1,363 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { BuyerStore } from "../src/buyer-store.js";
-import { DEFAULT_CLAWTIP_BOOTSTRAP_URL } from "../src/clawtip-bootstrap.js";
-import { buildCli } from "../src/cli.js";
-
-describe("tb routing set", () => {
-  let storeRoot: string;
-  let previousStoreRoot: string | undefined;
-  let logSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    storeRoot = fs.mkdtempSync(path.join(os.tmpdir(), "tokenbuddy-cli-routing-"));
-    previousStoreRoot = process.env.TOKENBUDDY_BUYER_STORE;
-    process.env.TOKENBUDDY_BUYER_STORE = storeRoot;
-    logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
-  });
-
-  afterEach(() => {
-    logSpy.mockRestore();
-    if (previousStoreRoot === undefined) {
-      delete process.env.TOKENBUDDY_BUYER_STORE;
-    } else {
-      process.env.TOKENBUDDY_BUYER_STORE = previousStoreRoot;
-    }
-    fs.rmSync(storeRoot, { recursive: true, force: true });
-  });
-
-  test("fixed mode requires --seller", async () => {
-    await expect(buildCli().parseAsync(["node", "tb", "routing", "set", "fixed"]))
-      .rejects.toThrow("fixed routing requires --seller");
-  });
-
-  test("fixedSet mode requires --seller-set", async () => {
-    await expect(buildCli().parseAsync(["node", "tb", "routing", "set", "fixedSet", "--seller-set", ""]))
-      .rejects.toThrow("fixedSet routing requires --seller-set");
-  });
-
-  test("rejects unsupported routing mode", async () => {
-    await expect(buildCli().parseAsync(["node", "tb", "routing", "set", "bogus"]))
-      .rejects.toThrow("routing mode must be fixed, fixedSet, or fullAuto");
-  });
-
-  test("fullAuto accepts empty seller options and writes balanced config", async () => {
-    await buildCli().parseAsync(["node", "tb", "routing", "set", "fullAuto"]);
-
-    const store = new BuyerStore({ root: storeRoot });
-    try {
-      expect(store.getDaemonRuntimeConfig("routing")).toMatchObject({
-        config: {
-          mode: "fullAuto",
-          scorer: "balanced",
-        },
-      });
-    } finally {
-      store.close();
-    }
-  });
-
-  test("routing show prints fixed and fixedSet details in text mode", async () => {
-    const output: string[] = [];
-    logSpy.mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-
-    await buildCli().parseAsync(["node", "tb", "routing", "set", "fixed", "--seller", "seller-a"]);
-    output.length = 0;
-    await buildCli().parseAsync(["node", "tb", "routing", "show"]);
-    expect(output.join("\n")).toContain("Seller: seller-a");
-    expect(output.join("\n")).toContain("Updated:");
-
-    await buildCli().parseAsync(["node", "tb", "routing", "set", "fixedSet", "--seller-set", "seller-a,seller-b"]);
-    output.length = 0;
-    await buildCli().parseAsync(["node", "tb", "routing", "show"]);
-    expect(output.join("\n")).toContain("Seller Set: seller-a,seller-b");
-    expect(output.join("\n")).toContain("Updated:");
-  });
-
-  test("doctor rejects invalid configured control port", async () => {
-    const previousControlPort = process.env.TB_PROXYD_CONTROL_PORT;
-    try {
-      process.env.TB_PROXYD_CONTROL_PORT = "not-a-port";
-      await expect(buildCli().parseAsync(["node", "tb", "doctor", "--json"]))
-        .rejects.toThrow("TB_PROXYD_CONTROL_PORT must be an integer port");
-    } finally {
-      restoreEnv("TB_PROXYD_CONTROL_PORT", previousControlPort);
-    }
-  });
-
-  test("doctor --json reports daemon status and v1.2 snapshot", async () => {
-    const output: string[] = [];
-    logSpy.mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockImplementation(async (url: string | URL | Request) => {
-      const href = String(url);
-      if (href.endsWith("/status")) {
-        return response({
-          pid: 123,
-          sellerRoutingMode: "fixed",
-          selectedSellerId: "seller-a",
-          sellerRegistryUrl: "https://registry.example.test/sellers",
-        });
-      }
-      if (href.endsWith("/v1.2/prewarm")) {
-        return response({ pool: { entries: [] } });
-      }
-      if (href.endsWith("/health")) {
-        return response({ ok: true });
-      }
-      if (href.endsWith("/routing/manual-providers")) {
-        return response({
-          providers: [{
-            id: "manual-a",
-            name: "Manual A",
-            kind: "openai-compatible",
-            baseUrl: "https://provider.example.test",
-            models: ["gpt-test"],
-            supportedProtocols: ["chat_completions"],
-            enabled: true,
-            createdAt: "2026-06-10T00:00:00.000Z",
-            updatedAt: "2026-06-10T00:00:00.000Z",
-            keyRef: { kind: "env", name: "TB_TEST_PROVIDER_KEY", configured: true },
-            status: "healthy",
-          }],
-        });
-      }
-      return response({}, false, 404);
-    }) as jest.MockedFunction<typeof fetch>;
-
-    try {
-      await buildCli().parseAsync(["node", "tb", "doctor", "--json"]);
-      const parsed = JSON.parse(output[0]) as any;
-      expect(parsed.daemon.running).toBe(true);
-      expect(parsed.daemon.status.selectedSellerId).toBe("seller-a");
-      expect(parsed.v12).toEqual({ pool: { entries: [] } });
-      expect(parsed.manualProviders.count).toBe(1);
-      expect(parsed.manualProviders.providers[0].keyRef.name).toBe("TB_TEST_PROVIDER_KEY");
-      expect(output.join("\n")).not.toContain("sk-");
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-
-  test("doctor --json reports fetch failures as not running", async () => {
-    const output: string[] = [];
-    logSpy.mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockRejectedValue(new Error("offline"));
-
-    try {
-      await buildCli().parseAsync(["node", "tb", "doctor", "--json"]);
-      const parsed = JSON.parse(output[0]) as any;
-      expect(parsed.daemon.running).toBe(false);
-      expect(parsed.daemon.error).toContain("offline");
-      expect(parsed.v12).toBeNull();
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-
-  test("doctor text mode renders running daemon details and v1.2 section", async () => {
-    const output: string[] = [];
-    logSpy.mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockImplementation(async (url: string | URL | Request) => {
-      const href = String(url);
-      if (href.endsWith("/status")) {
-        return response({
-          pid: 123,
-          controlPort: 17820,
-          proxyPort: 17821,
-          sellerRoutingMode: "fixed",
-          selectedSellerId: "seller-a",
-          sellerRegistryUrl: "https://registry.example.test/sellers",
-        });
-      }
-      if (href.endsWith("/v1.2/prewarm")) {
-        return response({
-          focusSet: ["gpt-5.4"],
-          prewarm: {
-            size: 1,
-            entries: [{
-              modelId: "gpt-5.4",
-              state: "ready",
-              candidateCount: 2,
-              warmedAt: Date.now(),
-              ttlMs: 60000,
-              consecutiveWarmingFailures: 0,
-            }],
-          },
-          pool: {
-            size: 1,
-            entries: [{ sellerId: "seller-a", circuit: "open", healthScore: 10 }],
-          },
-          credit: {
-            totalWastedMicros: 1,
-            wastedSinceLastDoctorRun: 2,
-            purchasesInLastMinute: 0,
-            purchaseBudgetPerMinute: 5,
-            perSeller: [{ sellerId: "seller-a", currentBalanceMicros: 10, leftoverCreditMicros: 1 }],
-          },
-          scheduler: {
-            inFlight: 0,
-            queueDepth: 0,
-            totalSucceeded: 1,
-            totalFailed: 0,
-          },
-        });
-      }
-      if (href.endsWith("/routing/manual-providers")) {
-        return response({
-          providers: [{
-            id: "manual-a",
-            name: "Manual A",
-            kind: "openai-compatible",
-            baseUrl: "https://provider.example.test",
-            models: ["gpt-test"],
-            supportedProtocols: ["chat_completions"],
-            enabled: true,
-            createdAt: "2026-06-10T00:00:00.000Z",
-            updatedAt: "2026-06-10T00:00:00.000Z",
-            keyRef: { kind: "secret", name: "local:manual-a", configured: true },
-            status: "healthy",
-            lastAccess: "2026-06-10T00:01:00.000Z",
-          }],
-        });
-      }
-      return response({}, false, 404);
-    }) as jest.MockedFunction<typeof fetch>;
-
-    try {
-      await buildCli().parseAsync(["node", "tb", "doctor"]);
-      const text = output.join("\n");
-      expect(text).toContain("Daemon tb-proxyd is running");
-      expect(text).toContain("Routing Mode: fixed");
-      expect(text).toContain("Selected Seller: seller-a");
-      expect(text).toContain("--- Manual Providers ---");
-      expect(text).toContain("Manual providers: 1");
-      expect(text).toContain("secret:local:manual-a configured");
-      expect(text).not.toContain("sk-");
-      expect(text).toContain("=== v1.2 Fallback Pipeline ===");
-      expect(text).toContain("seller-a [open]");
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-
-  test("doctor text mode reports offline daemon and repair hint", async () => {
-    const output: string[] = [];
-    logSpy.mockImplementation((message?: unknown) => {
-      output.push(String(message));
-    });
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockRejectedValue(new Error("offline"));
-
-    try {
-      await buildCli().parseAsync(["node", "tb", "doctor"]);
-      const text = output.join("\n");
-      expect(text).toContain("Daemon tb-proxyd is NOT running");
-      expect(text).toContain("tb doctor --fix");
-    } finally {
-      fetchMock.mockRestore();
-    }
-  });
-
-  test("payment commands reject unsupported methods after daemon gate", async () => {
-    const errors: string[] = [];
-    const errorSpy = jest.spyOn(console, "error").mockImplementation((message?: unknown) => {
-      errors.push(String(message));
-    });
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockResolvedValue(response({ ok: true }));
-    const previousExitCode = process.exitCode;
-
-    try {
-      process.exitCode = undefined;
-      await buildCli().parseAsync(["node", "tb", "payment", "add", "card"]);
-      await buildCli().parseAsync(["node", "tb", "payment", "remove", "card"]);
-
-      expect(process.exitCode).toBe(1);
-      expect(errors.join("\n")).toContain("Unsupported payment method: card");
-    } finally {
-      process.exitCode = previousExitCode;
-      fetchMock.mockRestore();
-      errorSpy.mockRestore();
-    }
-  });
-
-  test("payment add clawtip uses the default registry control plane", async () => {
-    const errors: string[] = [];
-    const errorSpy = jest.spyOn(console, "error").mockImplementation((message?: unknown) => {
-      errors.push(String(message));
-    });
-    const fetchMock = jest.spyOn(globalThis, "fetch").mockResolvedValue(response({
-      activationFeeFen: 1,
-      payment: {
-        orderNo: "order_default_bootstrap",
-        amountFen: 1,
-        indicator: "indicator_default_bootstrap",
-        payTo: "pay-to-test",
-        encryptedData: "ciphertext",
-        slug: "tb-registry",
-        skillId: "si-tb-registry",
-        description: "TokenBuddy ClawTip wallet activation",
-        resourceUrl: DEFAULT_CLAWTIP_BOOTSTRAP_URL,
-      }
-    }));
-    const previousExitCode = process.exitCode;
-    const previousBootstrapUrl = process.env.TOKENBUDDY_BOOTSTRAP_URL;
-
-    try {
-      process.exitCode = undefined;
-      delete process.env.TOKENBUDDY_BOOTSTRAP_URL;
-      await buildCli().parseAsync(["node", "tb", "payment", "add", "clawtip"]);
-
-      expect(process.exitCode).toBeUndefined();
-      expect(errors).toEqual([]);
-      expect(fetchMock).toHaveBeenCalledWith(
-        `${DEFAULT_CLAWTIP_BOOTSTRAP_URL}/payments/clawtip/bootstrap`,
-        expect.objectContaining({ method: "POST" })
-      );
-      const store = new BuyerStore({ root: storeRoot });
-      try {
-        expect(store.getPayment("clawtip")).toMatchObject({
-          method: "clawtip",
-          enabled: true,
-          isDefault: true,
-          config: {
-            bootstrapUrl: DEFAULT_CLAWTIP_BOOTSTRAP_URL,
-            orderNo: "order_default_bootstrap",
-            resourceUrl: DEFAULT_CLAWTIP_BOOTSTRAP_URL
-          }
-        });
-      } finally {
-        store.close();
-      }
-    } finally {
-      process.exitCode = previousExitCode;
-      restoreEnv("TOKENBUDDY_BOOTSTRAP_URL", previousBootstrapUrl);
-      fetchMock.mockRestore();
-      errorSpy.mockRestore();
-    }
-  });
-});
-
-function restoreEnv(name: string, value: string | undefined): void {
-  if (value === undefined) {
-    delete process.env[name];
-  } else {
-    process.env[name] = value;
-  }
-}
-
-function response(body: unknown, ok = true, status = 200): Response {
-  return {
-    ok,
-    status,
-    json: async () => body,
-    text: async () => JSON.stringify(body),
-  } as Response;
-}