@tokenbuddy/tb-admin 1.0.32 → 1.0.34

package/tests/seller.test.ts

@@ -20,7 +20,8 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ConfigManager } from "../src/config.js";
 import { SellerCommandRunner, parseFlyListJson, parseFlyStatusJson } from "../src/seller.js";
@@ -28,16 +29,28 @@ import { FlyProvider, type FlyProviderRuntime } from "../src/server-cmd.js";
 
 const TB_ADMIN_BIN = join(__dirname, "..", "bin", "tb-admin.js");
 const FLYCTL = "flyctl";
+const RUN_LIVE_FLY_TESTS = process.env.TOKENBUDDY_ADMIN_LIVE_FLY_TESTS === "1";
 
 function flyctlInstalled(): boolean {
   try {
-    execFileSync(`which ${FLYCTL}`, { stdio: "ignore" });
+    execFileSync("which", [FLYCTL], { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
 
+function makeEmptyConfigManager(): ConfigManager {
+  const dir = mkdtempSync(join(tmpdir(), "tb-admin-test-"));
+  return new ConfigManager(join(dir, "admin.toml"));
+}
+
+function makeMissingFlyctlConfigManager(): ConfigManager {
+  const manager = makeEmptyConfigManager();
+  manager.setSellerProvider("fly", { flyctl_path: "/tmp/tokenbuddy-missing-flyctl" });
+  return manager;
+}
+
 function tbAdminBinInstalled(): boolean {
   return existsSync(TB_ADMIN_BIN);
 }
@@ -98,6 +111,10 @@ describe("tb-admin seller CLI real spawn (no mock)", () => {
   // 每个 test 进来时现场探测.
   const itRequires = (name: string, fn: () => void | Promise<void>) => {
     test(name, async () => {
+      if (!RUN_LIVE_FLY_TESTS) {
+        console.warn(`[skipped] ${name}: set TOKENBUDDY_ADMIN_LIVE_FLY_TESTS=1 to run live Fly.io checks`);
+        return;
+      }
       const hasFlyctl = flyctlInstalled();
       const hasBin = tbAdminBinInstalled();
       if (!hasFlyctl || !hasBin) {
@@ -205,6 +222,57 @@ describe("tb-admin seller CLI real spawn (no mock)", () => {
     });
     expect(parsed.commands[0]).toContain("apps destroy tbs-86d81e");
   });
+
+  itRequires("roll --dry-run text path lists all live tbs-* candidates from fly apps list", () => {
+    const result = runTbAdminReal([
+      "seller", "roll",
+      "--image", "registry.fly.io/tb-seller:1.0.33",
+      "--dry-run"
+    ]);
+    expect(result.ok).toBe(true);
+    expect(result.stdout).toMatch(/\[Fly\.io\] roll candidates \(tbs-\*, excludes applied\): \d+/);
+    // 至少要有 tbs-86d81e (live 1.0.31 已知)
+    expect(result.stdout).toMatch(/tbs-86d81e/);
+    // dry-run 模式: 每台都是 [DRY-RUN] 而非真 flyctl
+    expect(result.stdout).toMatch(/\[DRY-RUN\] would update tbs-86d81e image to/);
+  });
+
+  itRequires("roll --dry-run --json returns structured candidates/excluded/attempts", () => {
+    const result = runTbAdminReal([
+      "seller", "roll",
+      "--image", "registry.fly.io/tb-seller:1.0.33",
+      "--exclude", "tbs-anpin-ai-0d7517,tbs-openrouter-ai-06vry",
+      "--dry-run", "--json"
+    ]);
+    expect(result.ok).toBe(true);
+    const parsed = JSON.parse(result.stdout);
+    expect(parsed).toMatchObject({
+      ok: true,
+      provider: "fly",
+      action: "roll",
+      image: "registry.fly.io/tb-seller:1.0.33",
+      dryRun: true,
+      completed: true
+    });
+    expect(Array.isArray(parsed.candidates)).toBe(true);
+    expect(parsed.candidates).toContain("tbs-86d81e");
+    expect(parsed.candidates).not.toContain("tbs-anpin-ai-0d7517");
+    expect(parsed.excluded).toEqual(expect.arrayContaining(["tbs-anpin-ai-0d7517", "tbs-openrouter-ai-06vry"]));
+    // attempts 顺序应该跟 candidates 顺序一致
+    expect(parsed.attempts.length).toBe(parsed.candidates.length);
+    for (let i = 0; i < parsed.attempts.length; i++) {
+      expect(parsed.attempts[i].app).toBe(parsed.candidates[i]);
+      expect(parsed.attempts[i].ok).toBe(true);
+    }
+  });
+
+  itRequires("roll rejects empty image and returns 1 (with usage error)", () => {
+    const result = runTbAdminReal([
+      "seller", "roll", "--dry-run", "--json"
+    ]);
+    // commander requiredOption 失败时, 进程退出非 0
+    expect(result.ok).toBe(false);
+  });
 });
 
 describe("SellerCommandRunner integration with real ConfigManager (no mock)", () => {
@@ -219,10 +287,15 @@ describe("SellerCommandRunner integration with real ConfigManager (no mock)", ()
   }
 
   test("ls(false) returns flyctl stdout string via real FlyProvider (no mock)", () => {
+    if (!RUN_LIVE_FLY_TESTS) {
+      const runner = new SellerCommandRunner(makeMissingFlyctlConfigManager());
+      expect(() => runner.ls(false)).toThrow(/flyctl|not installed|seller_providers/);
+      return;
+    }
     const mgr = tryRealConfigManager();
     if (!mgr) {
       // 环境无 admin profile, 用空 ConfigManager 走 fallback
-      const tmp = new ConfigManager("/tmp/tb-admin-no-config-" + Date.now() + ".toml");
+      const tmp = makeEmptyConfigManager();
       const runner = new SellerCommandRunner(tmp);
       // 没有 provider config -> 走 FlyProvider -> flyctl not installed (test env) -> throw
       try {
@@ -245,6 +318,14 @@ describe("FlyProvider dry-run paths (no mock, real flyctl required)", () => {
   // 只输出 plan. 这是 FlyProvider 的核心契约.
 
   function makeRealProvider(): FlyProvider | null {
+    if (!RUN_LIVE_FLY_TESTS) {
+      return new FlyProvider({
+        default_region: "sin",
+        operator_secret: "test-secret",
+        volume_name: "tb_seller_data",
+        volume_size_gb: 1
+      });
+    }
     const home = process.env.HOME || "";
     const adminToml = join(home, ".config", "tokenbuddy", "admin.toml");
     if (!existsSync(adminToml)) {

package/tests/ui-state-fleet.test.ts

@@ -40,22 +40,44 @@ interface FakeServerHandle {
   url: string;
   setManifest: (sellerId: string, resp: FakeManifestResponse) => void;
   setManifestPath: (path: string, resp: FakeManifestResponse) => void;
+  setOperatorJson: (path: string, resp: unknown) => void;
   setRegistry: (resp: { sellers: any[]; version: number }) => void;
+  setManagedSellers: (sellers: any[]) => void;
+  requests: () => Array<{ path: string; authorization?: string }>;
   close: () => Promise<void>;
 }
 
 function startFakeRegistry(): Promise<FakeServerHandle> {
   let registryDoc: { sellers: any[]; version: number } = { sellers: [], version: 0 };
+  let managedSellers: any[] | undefined;
   const manifests = new Map<string, FakeManifestResponse>();
+  const operatorJson = new Map<string, unknown>();
+  const requests: Array<{ path: string; authorization?: string }> = [];
 
   return new Promise((resolve) => {
     const server = createServer((req, res) => {
       const url = new URL(req.url || "/", "http://localhost");
+      requests.push({ path: url.pathname, authorization: req.headers.authorization });
+      if (url.pathname === "/platform/sellers") {
+        if (req.headers.authorization !== "Bearer fake-vendor-token") {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "vendor_auth_required" }));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ sellers: managedSellers ?? registryDoc.sellers }));
+        return;
+      }
       if (url.pathname === "/registry/sellers") {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(registryDoc));
         return;
       }
+      if (operatorJson.has(url.pathname)) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(operatorJson.get(url.pathname)));
+        return;
+      }
       // 1) 按 path 查 (setManifestPath 注册的)
       if (manifests.has(url.pathname)) {
         const resp = manifests.get(url.pathname)!;
@@ -85,9 +107,16 @@ function startFakeRegistry(): Promise<FakeServerHandle> {
         setManifestPath: (path, resp) => {
           manifests.set(path, resp);
         },
+        setOperatorJson: (path, resp) => {
+          operatorJson.set(path, resp);
+        },
         setRegistry: (doc) => {
           registryDoc = doc;
         },
+        setManagedSellers: (sellers) => {
+          managedSellers = sellers;
+        },
+        requests: () => requests.slice(),
         close: () => new Promise<void>((r) => server.close(() => r()))
       };
       resolve(handle);
@@ -100,7 +129,8 @@ let tmpConfigPath: string;
 
 function makeState(
   registryUrl: string,
-  flyApps: Omit<SellerAppJson, "raw">[]
+  flyApps: Omit<SellerAppJson, "raw">[],
+  token = "fake-vendor-token"
 ): AdminUiState {
   if (!tmpDir) {
     tmpDir = mkdtempSync(join(tmpdir(), "ui-fleet-test-"));
@@ -110,7 +140,7 @@ function makeState(
     tmpConfigPath,
     `[profiles.default]
 url = "${registryUrl}"
-token = "fake-vendor-token"
+token = "${token}"
 `,
     "utf8"
   );
@@ -119,10 +149,13 @@ token = "fake-vendor-token"
     configManager,
     profile: "default",
     url: registryUrl,
-    token: "fake-vendor-token",
+    token,
     flyApps: async () => flyApps.map((a) => ({ ...a, raw: {} })),
     fetchJson: (async (target: string, init?: RequestInit) => {
       const res = await fetch(target, init);
+      if (!res.ok) {
+        throw new Error(`HTTP Error ${res.status}: ${await res.text()}`);
+      }
       return await res.json();
     }) as any
   });
@@ -174,6 +207,242 @@ describe("AdminUiState 双源 seller list (v1.1 spec)", () => {
     expect(rows[0].registryAlert).toBeFalsy();
     // 绿点: /manifest 200 → nodeStatus=active (manifest ok 映射 active)
     expect(rows[0].nodeStatus).toBe("active");
+    expect(fake.requests()).toContainEqual({
+      path: "/platform/sellers",
+      authorization: "Bearer fake-vendor-token"
+    });
+  });
+
+  test("sellerRegistryRows returns registry publish-checking rows before Fly inventory", async () => {
+    fake.setRegistry({
+      version: 7,
+      sellers: [
+        {
+          id: "alpha",
+          name: "Alpha Seller",
+          app: "tb-seller-alpha",
+          url: `${fake.url}/alpha-base`,
+          status: "active",
+          supportedProtocols: ["chat_completions"],
+          paymentMethods: ["clawtip"],
+          models: ["gpt-5.4"]
+        }
+      ]
+    });
+    const state = makeState(fake.url, [
+      { name: "tb-seller-alpha", status: "running", owner: "vendor-a" }
+    ]);
+
+    const rows = await state.sellerRegistryRows();
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      id: "alpha",
+      publishStatus: "checking",
+      detailStatus: "pending",
+      nodeStatus: "unknown"
+    });
+    expect(fake.requests().some((request) => request.path.includes("/manifest"))).toBe(false);
+  });
+
+  test("sellerInventory merges registry + Fly without probing seller details", async () => {
+    fake.setRegistry({
+      version: 7,
+      sellers: [
+        {
+          id: "alpha",
+          name: "Alpha Seller",
+          app: "tb-seller-alpha",
+          url: `${fake.url}/alpha-base`,
+          status: "active",
+          supportedProtocols: ["chat_completions"],
+          paymentMethods: ["clawtip"],
+          models: ["gpt-5.4"]
+        }
+      ]
+    });
+    fake.setManifestPath("/alpha-base/manifest", { status: 200, body: { ok: true } });
+    const state = makeState(fake.url, [
+      { name: "tb-seller-alpha", status: "running", owner: "vendor-a" },
+      { name: "tb-seller-flyonly", status: "running", owner: "vendor-a" }
+    ]);
+
+    const rows = await state.sellerInventory();
+    expect(rows).toHaveLength(2);
+    expect(rows.find((row) => row.id === "alpha")).toMatchObject({
+      dataSource: "both",
+      publishStatus: "published",
+      detailStatus: "pending",
+      nodeStatus: "unknown"
+    });
+    expect(rows.find((row) => row.id === "tb-seller-flyonly")).toMatchObject({
+      dataSource: "fly",
+      publishStatus: "unpublished",
+      detailStatus: "pending"
+    });
+    expect(fake.requests().some((request) => request.path.includes("/manifest"))).toBe(false);
+  });
+
+  test("sellerInventory filters non-seller Fly apps", async () => {
+    fake.setRegistry({ version: 7, sellers: [] });
+    const state = makeState(fake.url, [
+      { name: "tb-registry", status: "running", owner: "vendor-a" },
+      { name: "tb-seller", status: "running", owner: "vendor-a" },
+      { name: "tbs-valid", status: "running", owner: "vendor-a" }
+    ]);
+
+    const rows = await state.sellerInventory();
+    expect(rows.map((row) => row.app)).toEqual(["tbs-valid"]);
+  });
+
+  test("refreshSellerRows hydrates upstream domain from seller config", async () => {
+    fake.setManifestPath("/manifest", { status: 200, body: { ok: true } });
+    fake.setOperatorJson("/operator/status", {
+      status: "healthy",
+      upstream: { status: "healthy" },
+      capacity: { activeConnections: 2, maxConnections: 8 },
+      runtime: { cpuPercent: 12.5, memoryPercent: 48, memoryRssMb: 246, memoryLimitMb: 512 }
+    });
+    fake.setOperatorJson("/operator/admin/upstreams", {
+      upstreams: [{
+        upstreamUrl: "https://openrouter.ai/api/v1",
+        discountRatio: 1,
+        models: [{ id: "openai/gpt-5.4" }]
+      }]
+    });
+    fake.setOperatorJson("/operator/admin/config", {
+      config: {
+        upstreamUrl: "https://openrouter.ai/api/v1",
+        discountRatio: 1
+      }
+    });
+    const state = makeState(fake.url, []);
+
+    const rows = await state.refreshSellerRows([{
+      id: "tbs-openrouter",
+      name: "tbs-openrouter",
+      app: "tbs-openrouter",
+      url: fake.url,
+      registryStatus: "active",
+      nodeStatus: "unknown",
+      upstreamDomain: "tbs-openrouter.fly.dev",
+      upstreamStatus: "unknown",
+      dataSource: "both",
+      publishStatus: "published",
+      detailStatus: "queued"
+    }]);
+
+    expect(rows[0]).toMatchObject({
+      upstreamDomain: "openrouter.ai",
+      upstreamStatus: "healthy",
+      capacityUsed: 2,
+      capacityLimit: 8,
+      resourceCpuPercent: 12.5,
+      resourceMemoryPercent: 48,
+      modelsCount: 1,
+      detailStatus: "fresh"
+    });
+  });
+
+  test("case 1b: empty vendor-managed list keeps public registry publish state", async () => {
+    fake.setRegistry({
+      version: 9,
+      sellers: [
+        {
+          id: "public-alpha",
+          name: "Public Alpha",
+          app: "tb-seller-alpha",
+          url: `${fake.url}/alpha-base`,
+          status: "active",
+          supportedProtocols: ["chat_completions"],
+          paymentMethods: ["clawtip"],
+          models: ["gpt-5.4"]
+        }
+      ]
+    });
+    fake.setManagedSellers([]);
+    fake.setManifestPath("/alpha-base/manifest", { status: 200, body: { ok: true } });
+    const state = makeState(fake.url, [
+      { name: "tb-seller-alpha", status: "running", owner: "vendor-a" }
+    ]);
+
+    const rows = await state.sellers();
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      id: "public-alpha",
+      dataSource: "both",
+      registryStatus: "active",
+      nodeStatus: "active"
+    });
+    expect(rows[0].publishHint).toBeUndefined();
+  });
+
+  test("case 1c: vendor-managed auth failure falls back to public registry", async () => {
+    fake.setRegistry({
+      version: 9,
+      sellers: [
+        {
+          id: "public-alpha",
+          name: "Public Alpha",
+          app: "tb-seller-alpha",
+          url: `${fake.url}/alpha-base`,
+          status: "active",
+          supportedProtocols: ["chat_completions"],
+          paymentMethods: ["clawtip"],
+          models: ["gpt-5.4"]
+        }
+      ]
+    });
+    fake.setManifestPath("/alpha-base/manifest", { status: 200, body: { ok: true } });
+    const state = makeState(fake.url, [
+      { name: "tb-seller-alpha", status: "running", owner: "vendor-a" }
+    ], "wrong-vendor-token");
+
+    const rows = await state.sellers();
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      id: "public-alpha",
+      dataSource: "both",
+      registryStatus: "active",
+      nodeStatus: "active"
+    });
+    expect(fake.requests()).toContainEqual({
+      path: "/platform/sellers",
+      authorization: "Bearer wrong-vendor-token"
+    });
+    expect(fake.requests()).toContainEqual({
+      path: "/registry/sellers",
+      authorization: undefined
+    });
+  });
+
+  test("case 1d: registry entry without app matches Fly app by id", async () => {
+    fake.setRegistry({
+      version: 9,
+      sellers: [
+        {
+          id: "tb-seller-alpha",
+          name: "Alpha Seller",
+          url: `${fake.url}/alpha-base`,
+          status: "active",
+          supportedProtocols: ["chat_completions"],
+          paymentMethods: ["clawtip"],
+          models: ["gpt-5.4"]
+        }
+      ]
+    });
+    fake.setManifestPath("/alpha-base/manifest", { status: 200, body: { ok: true } });
+    const state = makeState(fake.url, [
+      { name: "tb-seller-alpha", status: "running", owner: "vendor-a" }
+    ]);
+
+    const rows = await state.sellers();
+    expect(rows).toHaveLength(1);
+    expect(rows[0]).toMatchObject({
+      id: "tb-seller-alpha",
+      dataSource: "both",
+      registryStatus: "active",
+      nodeStatus: "active"
+    });
   });
 
   test("case 2: fly only → dataSource=fly, 灰点, registryAlert=undefined", async () => {