@tokenbuddy/tokenbuddy 1.0.11 → 1.0.13

package/tests/cli-routing.test.ts

@@ -0,0 +1,287 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { BuyerStore } from "../src/buyer-store.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 });
+      }
+      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: [] } });
+    } 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,
+          },
+        });
+      }
+      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("=== 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 requires a bootstrap url", 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;
+    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).toBe(1);
+      expect(errors.join("\n")).toContain("ClawTip bootstrap URL is required");
+    } 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,
+  } as Response;
+}