@tokenbuddy/tb-admin 1.0.15 → 1.0.28

package/dist/src/ui-static.js.map

@@ -1 +1 @@
-{"version":3,"file":"ui-static.js","sourceRoot":"","sources":["../../src/ui-static.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,WAAW;IACzB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA+CG,aAAa,EAAE;;QAEnB,CAAC;AACT,CAAC;AAED,SAAS,aAAa;IACpB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFR,CAAC;AACF,CAAC"}
+{"version":3,"file":"ui-static.js","sourceRoot":"","sources":["../../src/ui-static.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,EAAE;AACF,qEAAqE;AACrE,qEAAqE;AACrE,0DAA0D;AAE1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,UAAU,WAAW;IACzB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA8RG,aAAa,EAAE;;QAEnB,CAAC;AACT,CAAC;AAED,SAAS,aAAa;IACpB,gFAAgF;IAChF,OAAO;EACP,mBAAmB,EAAE;EACrB,mBAAmB,EAAE;CACtB,CAAC;AACF,CAAC;AAED,SAAS,mBAAmB;IAC1B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiKR,CAAC;AACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenbuddy/tb-admin",
-  "version": "1.0.15",
+  "version": "1.0.28",
   "description": "Remote admin CLI for TokenBuddy seller apps",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/src/cli.ts

@@ -10,6 +10,8 @@ import {
 } from "./bootstrap-registry.js";
 import Table from "cli-table3";
 import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
 import YAML from "js-yaml";
 
 interface BootstrapConfigDocument {
@@ -33,6 +35,44 @@ interface BootstrapConfigDocument {
 
 type SellerConfigDocument = Record<string, any>;
 
+function currentModuleDir(): string {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+
+  const stack = new Error().stack || "";
+  const fileUrlMatch = stack.match(/(file:\/\/\/[^)\n]+\/cli\.js):\d+:\d+/);
+  if (fileUrlMatch) {
+    return path.dirname(fileURLToPath(fileUrlMatch[1]));
+  }
+
+  const filePathMatch = stack.match(/(\/[^)\n]+\/cli\.(?:js|ts)):\d+:\d+/);
+  if (filePathMatch) {
+    return path.dirname(filePathMatch[1]);
+  }
+
+  return process.cwd();
+}
+
+function readAdminPackageVersion(): string {
+  let current = path.resolve(currentModuleDir(), "..");
+  const seen = new Set<string>();
+  while (!seen.has(current)) {
+    seen.add(current);
+    const packageJsonPath = path.join(current, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")) as { version?: unknown };
+      if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+        return packageJson.version;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "0.0.0";
+}
+
 function requireString(value: unknown, field: string): string {
   const normalized = String(value || "").trim();
   if (!normalized) {
@@ -143,11 +183,48 @@ function loadYamlOrJsonFile(filePath: string): any {
   return YAML.load(fs.readFileSync(filePath, "utf8"));
 }
 
+function loadSellerRegistryEntryFile(filePath: string): any {
+  const parsed = loadYamlOrJsonFile(filePath);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("seller registry entry document is required");
+  }
+  validateRegistryDocument({ version: 1, sellers: [parsed as any] });
+  return parsed;
+}
+
+function loadSellerRegistryPatchFile(filePath: string): any {
+  const parsed = loadYamlOrJsonFile(filePath);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("seller registry patch document is required");
+  }
+  if ("id" in parsed) {
+    throw new Error("seller registry patch must not include id");
+  }
+  return parsed;
+}
+
+function withExpectedVersion(body: Record<string, any>, expectedVersion: unknown): Record<string, any> {
+  if (expectedVersion === undefined) {
+    return body;
+  }
+  const version = Number(expectedVersion);
+  if (!Number.isInteger(version) || version < 1) {
+    throw new Error("expected version must be >= 1");
+  }
+  return { ...body, expectedVersion: version };
+}
+
 function requireUpstreamModels(data: any): any[] {
-  if (!Array.isArray(data?.models)) {
-    throw new Error("operator upstream summary must contain top-level models array");
+  if (Array.isArray(data?.models)) {
+    return data.models;
+  }
+  if (Array.isArray(data?.upstreams)) {
+    const firstWithModels = data.upstreams.find((entry: any) => Array.isArray(entry?.models));
+    if (firstWithModels) {
+      return firstWithModels.models;
+    }
   }
-  return data.models;
+  throw new Error("operator upstream summary must contain models array");
 }
 
 /**
@@ -162,7 +239,7 @@ export function buildAdminCli(configManager: ConfigManager): Command {
   program
     .name("tb-admin")
     .description("Remote admin CLI for TokenBuddy seller apps")
-    .version("1.0.0")
+    .version(readAdminPackageVersion())
     .option("--url <url>", "Remote seller core API url")
     .option("--token <token>", "Operator Bearer token")
     .option("--profile <profile>", "Use custom profile instead of default")
@@ -614,14 +691,19 @@ export function buildAdminCli(configManager: ConfigManager): Command {
   // 6. Bootstrap Registry Command
   const bootstrap = program.command("bootstrap").description("Manage wallet bootstrap service");
   const bootstrapSellers = bootstrap.command("sellers").description("Manage public seller registry");
+  const bootstrapDefaultSeller = bootstrap.command("default-seller").description("Manage bootstrap default seller");
+  const bootstrapRegistry = bootstrap.command("registry").description("Manage signed registry versions and publishing");
   const bootstrapConfig = bootstrap.command("config").description("Manage wallet bootstrap YAML config");
 
   bootstrapSellers
     .command("get")
-    .description("Fetch public seller registry")
-    .action(async () => {
+    .description("Fetch public seller registry or one seller by id")
+    .argument("[id]", "Seller id")
+    .action(async (id?: string) => {
       try {
-        const data = await publicGet("/registry/sellers") as SellerRegistryDocument;
+        const data = id
+          ? await getClient().get(`/operator/registry/sellers/${encodeURIComponent(id)}`)
+          : await publicGet("/registry/sellers") as SellerRegistryDocument;
         console.log(JSON.stringify(data, null, 2));
       } catch (err: any) {
         console.error("Error:", err.message);
@@ -629,16 +711,129 @@ export function buildAdminCli(configManager: ConfigManager): Command {
       }
     });
 
+  bootstrapSellers
+    .command("list")
+    .description("List seller entries from the operator registry")
+    .action(async () => {
+      try {
+        const data = await getClient().get("/operator/registry/sellers") as { sellers: any[] };
+        const table = new Table({ head: ["ID", "Status", "URL", "Models", "Protocols", "Payments"] });
+        for (const seller of data.sellers || []) {
+          table.push([
+            seller.id,
+            seller.status || "active",
+            seller.url,
+            String(seller.models?.length || seller.modelsCount || 0),
+            (seller.supportedProtocols || []).join(","),
+            (seller.paymentMethods || []).join(",")
+          ]);
+        }
+        console.log(table.toString());
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapSellers
+    .command("add")
+    .description("Add one seller entry without replacing the full registry")
+    .requiredOption("--file <path>", "Seller entry YAML/JSON file")
+    .requiredOption("--expect-version <n>", "Expected current registry version")
+    .option("--idempotency-key <key>", "Idempotency key for retry-safe writes")
+    .action(async (options) => {
+      try {
+        const seller = loadSellerRegistryEntryFile(options.file);
+        const headers = options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : undefined;
+        const response = await getClient().post(
+          "/operator/registry/sellers",
+          withExpectedVersion(seller, options.expectVersion),
+          headers
+        ) as SellerRegistryDocument;
+        console.log(`Added seller ${seller.id}: version=${response.version} sellers=${response.sellers.length} publish=pending`);
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapSellers
+    .command("update <id>")
+    .description("Patch one seller entry without replacing the full registry")
+    .requiredOption("--file <path>", "Seller patch YAML/JSON file")
+    .requiredOption("--expect-version <n>", "Expected current registry version")
+    .option("--idempotency-key <key>", "Idempotency key for retry-safe writes")
+    .action(async (id, options) => {
+      try {
+        const patch = loadSellerRegistryPatchFile(options.file);
+        const headers = options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : undefined;
+        const response = await getClient().patch(
+          `/operator/registry/sellers/${encodeURIComponent(id)}`,
+          withExpectedVersion(patch, options.expectVersion),
+          headers
+        ) as SellerRegistryDocument;
+        console.log(`Updated seller ${id}: version=${response.version} publish=pending`);
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapSellers
+    .command("status <id> <status>")
+    .description("Set one seller registry status: active, draining, or offline")
+    .requiredOption("--expect-version <n>", "Expected current registry version")
+    .option("--idempotency-key <key>", "Idempotency key for retry-safe writes")
+    .action(async (id, status, options) => {
+      try {
+        const headers = options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : undefined;
+        const response = await getClient().put(
+          `/operator/registry/sellers/${encodeURIComponent(id)}/status`,
+          withExpectedVersion({ status }, options.expectVersion),
+          headers
+        ) as SellerRegistryDocument;
+        console.log(`Set seller ${id} status=${status}: version=${response.version} publish=pending`);
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapSellers
+    .command("remove <id>")
+    .description("Remove one non-active seller entry")
+    .requiredOption("--expect-version <n>", "Expected current registry version")
+    .option("--force", "Allow forced removal when the service permits it")
+    .option("--idempotency-key <key>", "Idempotency key for retry-safe writes")
+    .action(async (id, options) => {
+      try {
+        const headers = options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : undefined;
+        const response = await getClient().delete(
+          `/operator/registry/sellers/${encodeURIComponent(id)}`,
+          withExpectedVersion({ force: Boolean(options.force) }, options.expectVersion),
+          headers
+        ) as SellerRegistryDocument;
+        console.log(`Removed seller ${id}: version=${response.version} sellers=${response.sellers.length} publish=pending`);
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
   bootstrapSellers
     .command("put")
-    .description("Update public seller registry")
+    .description("Deprecated: dangerously replace public seller registry")
     .requiredOption("--file <path>", "Seller registry JSON file")
+    .option("--force", "Acknowledge this full replacement is dangerous")
     .action(async (options) => {
       try {
+        if (!options.force) {
+          throw new Error("bootstrap sellers put is deprecated; use bootstrap registry import --dry-run first, then --force");
+        }
         const document = loadRegistryFile(options.file);
         const client = getClient();
         const response = await client.put("/operator/registry/sellers", document) as SellerRegistryDocument;
-        console.log(`Updated seller registry: version=${response.version} sellers=${response.sellers.length}`);
+        console.log(`Dangerously replaced seller registry: version=${response.version} sellers=${response.sellers.length} publish=pending`);
       } catch (err: any) {
         console.error("Error:", err.message);
         process.exit(1);
@@ -660,6 +855,159 @@ export function buildAdminCli(configManager: ConfigManager): Command {
       }
     });
 
+  bootstrapDefaultSeller
+    .command("set <id>")
+    .description("Set default seller")
+    .requiredOption("--expect-version <n>", "Expected current registry version")
+    .option("--idempotency-key <key>", "Idempotency key for retry-safe writes")
+    .action(async (id, options) => {
+      try {
+        const headers = options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : undefined;
+        const response = await getClient().put(
+          "/operator/registry/default-seller",
+          withExpectedVersion({ sellerId: id }, options.expectVersion),
+          headers
+        ) as SellerRegistryDocument;
+        console.log(`Set default seller ${id}: version=${response.version} publish=pending`);
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapRegistry
+    .command("diff")
+    .description("Compare a local registry JSON file against the operator registry")
+    .requiredOption("--file <path>", "Seller registry JSON file")
+    .action(async (options) => {
+      try {
+        const local = loadRegistryFile(options.file);
+        const remote = await getClient().get("/operator/registry") as SellerRegistryDocument;
+        const localIds = new Set(local.sellers.map((seller) => seller.id));
+        const remoteIds = new Set(remote.sellers.map((seller) => seller.id));
+        const added = local.sellers.filter((seller) => !remoteIds.has(seller.id)).map((seller) => seller.id);
+        const removed = remote.sellers.filter((seller) => !localIds.has(seller.id)).map((seller) => seller.id);
+        const changed = local.sellers
+          .filter((seller) => remoteIds.has(seller.id))
+          .filter((seller) => JSON.stringify(seller) !== JSON.stringify(remote.sellers.find((entry) => entry.id === seller.id)))
+          .map((seller) => seller.id);
+        console.log(JSON.stringify({
+          remoteVersion: remote.version,
+          localVersion: local.version,
+          added,
+          removed,
+          changed,
+          defaultSellerChanged: remote.defaultSeller !== local.defaultSeller
+        }, null, 2));
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapRegistry
+    .command("import")
+    .description("Import a full registry JSON as a dangerous disaster-recovery operation")
+    .requiredOption("--file <path>", "Seller registry JSON file")
+    .option("--dry-run", "Only validate and show diff")
+    .option("--force", "Actually perform the full replacement")
+    .option("--expect-version <n>", "Expected current registry version before import")
+    .option("--force-delete-count <n>", "Maximum allowed delete count when forcing", "1")
+    .action(async (options) => {
+      try {
+        const local = loadRegistryFile(options.file);
+        const remote = await getClient().get("/operator/registry") as SellerRegistryDocument;
+        const localIds = new Set(local.sellers.map((seller) => seller.id));
+        const removed = remote.sellers.filter((seller) => !localIds.has(seller.id));
+        const forceDeleteCount = Number(options.forceDeleteCount);
+        if (!Number.isInteger(forceDeleteCount) || forceDeleteCount < 0) {
+          throw new Error("--force-delete-count must be >= 0");
+        }
+        console.log(`Import diff: remoteVersion=${remote.version} localVersion=${local.version} removes=${removed.length}`);
+        if (options.dryRun || !options.force) {
+          if (!options.dryRun) {
+            throw new Error("refusing full import without --force; run with --dry-run first");
+          }
+          return;
+        }
+        if (removed.length > forceDeleteCount) {
+          throw new Error(`import would remove ${removed.length} sellers; pass --force-delete-count ${removed.length} to allow`);
+        }
+        const body = withExpectedVersion(local as any, options.expectVersion);
+        const response = await getClient().put("/operator/registry/sellers", body) as SellerRegistryDocument;
+        console.log(`Imported seller registry: version=${response.version} sellers=${response.sellers.length} publish=pending`);
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapRegistry
+    .command("publish")
+    .description("Publish the current signed registry to R2")
+    .option("--version <n>", "Registry version to publish")
+    .action(async (options) => {
+      try {
+        const version = options.version ? Number(options.version) : undefined;
+        if (version !== undefined && (!Number.isInteger(version) || version < 1)) {
+          throw new Error("--version must be a positive integer");
+        }
+        const body = version === undefined ? {} : { version };
+        const response = await getClient().post("/operator/registry/publish", body) as {
+          version: number;
+          registrySha256: string;
+          signingKeyId: string;
+          artifacts?: Array<{ key: string; url: string }>;
+        };
+        console.log(`Published registry version=${response.version} sha256=${response.registrySha256} signingKey=${response.signingKeyId}`);
+        for (const artifact of response.artifacts || []) {
+          console.log(`  ${artifact.key} -> ${artifact.url}`);
+        }
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
+  bootstrapRegistry
+    .command("versions")
+    .description("List registry versions")
+    .option("--limit <n>", "Maximum versions to list", "20")
+    .action(async (options) => {
+      try {
+        const limit = Number(options.limit);
+        if (!Number.isInteger(limit) || limit < 1) {
+          throw new Error("--limit must be a positive integer");
+        }
+        const response = await getClient().get(`/operator/registry/versions?limit=${encodeURIComponent(String(limit))}`) as {
+          versions?: Array<{
+            version: number;
+            registrySha256: string;
+            signingKeyId?: string;
+            signed?: boolean;
+            sellerCount?: number;
+            defaultSeller?: string;
+            createdAt?: string;
+            publishedAt?: string;
+          }>;
+        };
+        for (const version of response.versions || []) {
+          console.log([
+            `version=${version.version}`,
+            `sellers=${version.sellerCount ?? "?"}`,
+            `default=${version.defaultSeller || "-"}`,
+            `signed=${version.signed ? "yes" : "no"}`,
+            `published=${version.publishedAt || "pending"}`,
+            `sha256=${version.registrySha256}`,
+            `key=${version.signingKeyId || "-"}`
+          ].join(" "));
+        }
+      } catch (err: any) {
+        console.error("Error:", err.message);
+        process.exit(1);
+      }
+    });
+
   bootstrapConfig
     .command("get")
     .description("Fetch wallet bootstrap runtime config")
@@ -765,14 +1113,19 @@ export function buildAdminCli(configManager: ConfigManager): Command {
 
   // 8. Seller Command (Fly.io)
   const sellerCmd = program.command("seller").description("Deploy and manage seller containers on Fly.io");
-  const flyProvider = new FlyProvider();
+
+  function getFlyProvider(): FlyProvider {
+    const opts = program.opts();
+    const mgr = opts.config ? new ConfigManager(opts.config) : configManager;
+    return new FlyProvider(mgr.getSellerProvider("fly"));
+  }
 
   sellerCmd
     .command("ls")
     .description("List all deployed apps on Fly.io")
     .action(() => {
       try {
-        const out = flyProvider.listApps();
+        const out = getFlyProvider().listApps();
         console.log(out);
       } catch (err: any) {
         console.error("Error:", err.message);
@@ -796,7 +1149,7 @@ export function buildAdminCli(configManager: ConfigManager): Command {
     .option("--dry-run", "Dry run display without actual execution")
     .action((name, options) => {
       try {
-        const res = flyProvider.createSeller({
+        const res = getFlyProvider().createSeller({
           name,
           app: options.app,
           region: options.region,
@@ -824,7 +1177,7 @@ export function buildAdminCli(configManager: ConfigManager): Command {
     .option("--dry-run", "Dry run")
     .action((app, options) => {
       try {
-        const res = flyProvider.deploySeller({
+        const res = getFlyProvider().deploySeller({
           app,
           image: options.image,
           dryRun: options.dryRun
@@ -845,7 +1198,7 @@ export function buildAdminCli(configManager: ConfigManager): Command {
     .action((name, options) => {
       try {
         const appName = options.app || name;
-        const res = flyProvider.removeSeller(appName, options.dryRun);
+        const res = getFlyProvider().removeSeller(appName, options.dryRun);
         console.log(res);
         if (options.removeProfile && !options.dryRun) {
           const appBase = appName.includes("-") ? appName.replace(/^tb-seller-/, "") : appName;

package/src/client.ts

@@ -11,11 +11,12 @@ export class AdminClient {
     this.token = token;
   }
 
-  private async request(path: string, method: string, body?: any): Promise<any> {
+  private async request(path: string, method: string, body?: any, extraHeaders: { [key: string]: string } = {}): Promise<any> {
     const url = `${this.baseUrl}${path}`;
     const headers: { [key: string]: string } = {
       "Content-Type": "application/json",
-      "Authorization": `Bearer ${this.token}`
+      "Authorization": `Bearer ${this.token}`,
+      ...extraHeaders
     };
 
     const options: RequestInit = {
@@ -44,15 +45,19 @@ export class AdminClient {
     return this.request(path, "GET");
   }
 
-  public async put(path: string, body?: any): Promise<any> {
-    return this.request(path, "PUT", body);
+  public async put(path: string, body?: any, headers?: { [key: string]: string }): Promise<any> {
+    return this.request(path, "PUT", body, headers);
   }
 
-  public async post(path: string, body?: any): Promise<any> {
-    return this.request(path, "POST", body);
+  public async post(path: string, body?: any, headers?: { [key: string]: string }): Promise<any> {
+    return this.request(path, "POST", body, headers);
   }
 
-  public async delete(path: string): Promise<any> {
-    return this.request(path, "DELETE");
+  public async patch(path: string, body?: any, headers?: { [key: string]: string }): Promise<any> {
+    return this.request(path, "PATCH", body, headers);
+  }
+
+  public async delete(path: string, body?: any, headers?: { [key: string]: string }): Promise<any> {
+    return this.request(path, "DELETE", body, headers);
   }
 }