@tokenbuddy/tb-admin 1.0.31 → 1.0.33

package/tests/vendor-cli.test.ts

@@ -0,0 +1,241 @@
+import request from "supertest";
+import * as fs from "fs";
+import * as path from "path";
+import { buildAdminCli } from "../src/cli.js";
+import { ConfigManager } from "../src/config.js";
+import { execSync } from "child_process";
+
+// Use the workspace-linked package. ts-jest will resolve the
+// `.js` to the compiled `.ts` via the root moduleNameMapper.
+import { buildApp } from "@tokenbuddy/wallet-bootstrap";
+import type { BootstrapConfig } from "@tokenbuddy/wallet-bootstrap";
+import { RegistryAdminClient } from "../src/client.js";
+
+const WALLET_TEST_DIR = path.resolve(__dirname, "../../data-vendor-cli-test");
+const TEMP_REGISTRY_PATH = path.join(WALLET_TEST_DIR, "sellers.json");
+const TEMP_REGISTRY_DB_PATH = path.join(WALLET_TEST_DIR, "bootstrap.sqlite");
+const TEMP_CONFIG_PATH = path.join(WALLET_TEST_DIR, "tb-registry.yaml");
+const TEMP_ADMIN_CONF_PATH = path.join(WALLET_TEST_DIR, "admin-config.json");
+const SUPER_ADMIN_KEY = "platform-super-admin-key-please-rotate-me-1234567890";
+const SESSION_SECRET = "session-secret-32-chars-min-please";
+
+const baseRegistry = {
+  version: 1,
+  defaultSeller: "platform-seed",
+  sellers: [
+    {
+      id: "platform-seed",
+      name: "Platform Seed",
+      url: "https://platform-seed.example.com",
+      status: "active",
+      models: ["seed-model"],
+      supportedProtocols: ["chat_completions"],
+      paymentMethods: ["clawtip"]
+    }
+  ]
+};
+
+const baseConfig: BootstrapConfig = {
+  configPath: TEMP_CONFIG_PATH,
+  payTo: "pay-to-x",
+  sm4KeyBase64: "MDEyMzQ1Njc4OUFCQ0RFRg==",
+  skillSlug: "tb-registry",
+  skillId: "si-tb-registry",
+  description: "Activate",
+  resourceUrl: "https://example.com",
+  activationFeeFen: 1,
+  microsPerFen: 1000000,
+  sellerRegistryPath: TEMP_REGISTRY_PATH,
+  operatorSecret: "op-secret",
+  superAdminKey: SUPER_ADMIN_KEY,
+  superAdminLabel: "ops",
+  sessionSecret: SESSION_SECRET
+};
+
+function buildServer() {
+  fs.mkdirSync(WALLET_TEST_DIR, { recursive: true });
+  fs.writeFileSync(TEMP_REGISTRY_PATH, JSON.stringify(baseRegistry), "utf8");
+  for (const f of [TEMP_REGISTRY_DB_PATH, `${TEMP_REGISTRY_DB_PATH}-wal`, `${TEMP_REGISTRY_DB_PATH}-shm`]) {
+    try { fs.rmSync(f, { force: true }); } catch { /* ignore */ }
+  }
+  return buildApp(baseConfig);
+}
+
+async function createVendorToken(app: ReturnType<typeof buildServer>, name: string): Promise<string> {
+  const response = await request(app)
+    .post("/platform/vendors")
+    .set("X-Registry-Admin-Key", SUPER_ADMIN_KEY)
+    .send({ name });
+  expect(response.status).toBe(200);
+  return response.body.token;
+}
+
+async function runCli(args: string[], env: NodeJS.ProcessEnv): Promise<{ stdout: string; stderr: string; status: number }> {
+  // We invoke the CLI as a child process so the `program` state does
+  // not leak between tests. The package's `dist/` may not exist in
+  // worktrees, so we run from TypeScript source via `tsx` if
+  // available; fall back to requiring the source.
+  const cliEntry = path.resolve(__dirname, "../src/cli.ts");
+  // Try `npx tsx` first, then `node --import tsx`, then fallback
+  // to `node -r ts-node/register`.
+  let cmd: string;
+  let finalArgs: string[];
+  try {
+    execSync("which tsx", { stdio: "ignore" });
+    cmd = "npx";
+    finalArgs = ["tsx", cliEntry, ...args];
+  } catch {
+    cmd = "node";
+    finalArgs = ["--import", "tsx", cliEntry, ...args];
+  }
+  try {
+    const stdout = execSync(`${cmd} ${finalArgs.map((a) => JSON.stringify(a)).join(" ")}`, {
+      env: { ...process.env, ...env },
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf8"
+    });
+    return { stdout, stderr: "", status: 0 };
+  } catch (err: any) {
+    return {
+      stdout: err.stdout?.toString() || "",
+      stderr: err.stderr?.toString() || err.message,
+      status: err.status || 1
+    };
+  }
+}
+
+describe("Vendor CLI integration (Step 5)", () => {
+  beforeEach(() => {
+    fs.mkdirSync(WALLET_TEST_DIR, { recursive: true });
+    for (const f of [TEMP_REGISTRY_PATH, TEMP_REGISTRY_DB_PATH, `${TEMP_REGISTRY_DB_PATH}-wal`, `${TEMP_REGISTRY_DB_PATH}-shm`, TEMP_CONFIG_PATH, TEMP_ADMIN_CONF_PATH]) {
+      try { fs.rmSync(f, { force: true }); } catch { /* ignore */ }
+    }
+  });
+
+  afterAll(() => {
+    fs.rmSync(WALLET_TEST_DIR, { recursive: true, force: true });
+  });
+
+  test("buildAdminCli still constructs without errors after the registry redesign", () => {
+    const config = new ConfigManager(TEMP_ADMIN_CONF_PATH);
+    const cli = buildAdminCli(config);
+    expect(cli.commands.find((c: any) => c.name() === "vendor-bootstrap")).toBeDefined();
+    // The legacy `bootstrap` command is still there for backward compat.
+    expect(cli.commands.find((c: any) => c.name() === "bootstrap")).toBeDefined();
+  });
+
+  test("RegistryVendorClient can authenticate against a live wallet-bootstrap app and stage a seller", async () => {
+    const app = buildServer();
+    const token = await createVendorToken(app, "Acme");
+    // Direct HTTP call to the vendor API as the CLI would do.
+    const stage = await request(app)
+      .post("/platform/sellers/stage")
+      .set("Authorization", `Bearer ${token}`)
+      .send({ seller: {
+        id: "acme-seller-1",
+        name: "Acme Seller 1",
+        url: "https://acme.example.com",
+        status: "active",
+        models: ["m1"],
+        supportedProtocols: ["chat_completions"],
+        paymentMethods: ["clawtip"]
+      } });
+    expect(stage.status).toBe(200);
+    expect(stage.body.pendingSeller.id).toBe("acme-seller-1");
+    expect(stage.body.pendingSeller.status).toBe("staged");
+  });
+
+  test("RegistryVendorClient listPendingSellers only returns this vendor's rows", async () => {
+    const app = buildServer();
+    const tokenA = await createVendorToken(app, "VendorA");
+    const tokenB = await createVendorToken(app, "VendorB");
+    await request(app)
+      .post("/platform/sellers/stage")
+      .set("Authorization", `Bearer ${tokenA}`)
+      .send({ seller: {
+        id: "va-1", name: "VA1", url: "https://va1.example.com", status: "active",
+        models: ["m1"], supportedProtocols: ["chat_completions"], paymentMethods: ["clawtip"]
+      } });
+    await request(app)
+      .post("/platform/sellers/stage")
+      .set("Authorization", `Bearer ${tokenB}`)
+      .send({ seller: {
+        id: "vb-1", name: "VB1", url: "https://vb1.example.com", status: "active",
+        models: ["m1"], supportedProtocols: ["chat_completions"], paymentMethods: ["clawtip"]
+      } });
+    const aList = await request(app)
+      .get("/platform/sellers/pending?status=staged")
+      .set("Authorization", `Bearer ${tokenA}`);
+    const bList = await request(app)
+      .get("/platform/sellers/pending?status=staged")
+      .set("Authorization", `Bearer ${tokenB}`);
+    expect(aList.body.pendingSellers).toHaveLength(1);
+    expect(aList.body.pendingSellers[0].id).toBe("va-1");
+    expect(bList.body.pendingSellers).toHaveLength(1);
+    expect(bList.body.pendingSellers[0].id).toBe("vb-1");
+  });
+
+  test("RegistryVendorClient submitRelease -> listReleaseRequests round-trips", async () => {
+    const app = buildServer();
+    const token = await createVendorToken(app, "VendorC");
+    await request(app)
+      .post("/platform/sellers/stage")
+      .set("Authorization", `Bearer ${token}`)
+      .send({ seller: {
+        id: "vc-1", name: "VC1", url: "https://vc1.example.com", status: "active",
+        models: ["m1"], supportedProtocols: ["chat_completions"], paymentMethods: ["clawtip"]
+      } });
+    const submit = await request(app)
+      .post("/platform/release-requests")
+      .set("Authorization", `Bearer ${token}`)
+      .send({ stagedSellerIds: ["vc-1"], note: "test" });
+    expect(submit.status).toBe(200);
+    const list = await request(app)
+      .get("/platform/release-requests?limit=10")
+      .set("Authorization", `Bearer ${token}`);
+    expect(list.body.releaseRequests).toHaveLength(1);
+    expect(list.body.releaseRequests[0].id).toBe(submit.body.releaseRequest.id);
+  });
+
+  test("RegistryAdminClient uses canonical admin API routes", async () => {
+    const app = buildServer();
+    const server = app.listen(0);
+    const address = server.address();
+    if (!address || typeof address !== "object") {
+      throw new Error("test server did not bind a TCP port");
+    }
+    const client = new RegistryAdminClient(`http://127.0.0.1:${address.port}`, SUPER_ADMIN_KEY);
+    try {
+      const vendor = await client.createVendor("AdminClientVendor");
+      expect(vendor.token).toBeTruthy();
+
+      const vendors = await client.listVendors();
+      expect(vendors.vendors.length).toBeGreaterThan(0);
+
+      const versions = await client.listVersions();
+      expect(versions.versions.length).toBeGreaterThan(0);
+
+      const token = vendor.token;
+      await request(app)
+        .post("/platform/sellers/stage")
+        .set("Authorization", `Bearer ${token}`)
+        .send({ seller: {
+          id: "admin-client-force-1",
+          name: "Admin Client Force",
+          url: "https://admin-client-force.example.com",
+          status: "active",
+          models: ["m1"],
+          supportedProtocols: ["chat_completions"],
+          paymentMethods: ["clawtip"]
+        } });
+      const submit = await request(app)
+        .post("/platform/release-requests")
+        .set("Authorization", `Bearer ${token}`)
+        .send({ stagedSellerIds: ["admin-client-force-1"] });
+      const forced = await client.forcePublish(submit.body.releaseRequest.id);
+      expect(forced.releaseRequest).toMatchObject({ status: "published" });
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+});