@tokenbuddy/tb-admin 1.0.14 → 1.0.27

package/src/ui-state.ts

@@ -0,0 +1,614 @@
+import { AdminClient } from "./client.js";
+import { ConfigManager, type AdminProfile } from "./config.js";
+import type { SellerRegistryDocument, SellerRegistryEntry } from "./bootstrap-registry.js";
+import {
+  BalanceProbeCache,
+  type BalanceSnapshot,
+  probeUpstreamBalance
+} from "./upstream-balance-probe.js";
+
+export type RegistryStatus = "active" | "draining" | "offline" | "pending" | "unknown";
+export type NodeStatus = RegistryStatus | "busy_capacity" | "auth_unknown";
+export type UpstreamStatus = "healthy" | "degraded" | "unhealthy" | "unknown";
+
+export interface SellerRow {
+  id: string;
+  name: string;
+  description?: string;
+  app?: string;
+  profile?: string;
+  url: string;
+  registryStatus: RegistryStatus;
+  nodeStatus: NodeStatus;
+  region?: string;
+  upstreamDomain: string;
+  upstreamStatus: UpstreamStatus;
+  upstreamBalanceUsdMicros?: number;
+  upstreamBalanceCurrency?: string;
+  upstreamBalanceSource?: string;
+  upstreamBalanceFetchedAt?: string;
+  upstreamBalanceError?: string;
+  upstreamRechargeUrl?: string;
+  discountRatio?: number;
+  capacityUsed?: number;
+  capacityLimit?: number;
+  ttftMs?: number;
+  avgInferenceMs?: number;
+  lastInferenceMs?: number;
+  avgTokensPerSecond?: number;
+  lastTokensPerSecond?: number;
+  latencySamples?: number;
+  lastSwitchAt?: string;
+  modelsCount?: number;
+  specs?: {
+    memoryGb?: number;
+    machines?: number;
+    region?: string;
+    modelsCount?: number;
+  };
+  error?: string;
+}
+
+export interface SellerModelRow {
+  upstreamModel: string;
+  billingModel: string;
+  inputPrice?: string;
+  outputPrice?: string;
+  ttftMs?: number;
+  avgInferenceMs?: number;
+  avgTokensPerSecond?: number;
+  latencySamples?: number;
+}
+
+export interface SellerDetail {
+  row: SellerRow;
+  configuration: {
+    registryStatus: string;
+    region?: string;
+    upstreamUrl?: string;
+    upstreamApiKeyMasked?: string;
+    upstreamStatus: UpstreamStatus;
+    upstreamBalance?: string;
+    upstreamBalanceSource?: string;
+    upstreamBalanceFetchedAt?: string;
+    upstreamBalanceError?: string;
+    upstreamBalanceProbeTemplate?: string;
+    upstreamBalanceProbeUrl?: string;
+    upstreamBalanceProbeUserId?: string;
+    upstreamBalanceProbeRechargeUrl?: string;
+    upstreamBalanceUrl?: string;
+    upstreamUserId?: string;
+    upstreamRechargeUrl?: string;
+    markupRatio?: number;
+    discountRatio?: number;
+    maxConnections?: number;
+    maxQueueDepth?: number;
+  };
+  models: SellerModelRow[];
+}
+
+export interface BootstrapSummary {
+  status: "available" | "unavailable";
+  url?: string;
+  profile?: string;
+  registryVersion?: number;
+  registryUpdatedAt?: string;
+  sellerEntries: number;
+  defaultSeller?: string;
+  regions: string[];
+  error?: string;
+}
+
+export interface BootstrapConfigSummary {
+  status: "available" | "unavailable";
+  sellerRegistryPath?: string;
+  bindHost?: string;
+  bindPort?: number;
+  allowLocalSellerUrls?: boolean;
+  clawtip?: {
+    payToMasked?: string;
+    sm4KeyMasked?: string;
+    skillSlug?: string;
+    skillId?: string;
+    description?: string;
+    resourceUrl?: string;
+    activationFeeFen?: number;
+    microsPerFen?: number;
+  };
+  error?: string;
+}
+
+export interface AdminUiStateOptions {
+  configManager: ConfigManager;
+  configPath?: string;
+  profile?: string;
+  url?: string;
+  token?: string;
+  fetchJson?: (url: string, init?: RequestInit) => Promise<unknown>;
+  balanceFetch?: typeof fetch;
+}
+
+interface ProfileMatch {
+  name?: string;
+  profile?: AdminProfile;
+  localProfile?: boolean;
+}
+
+interface SellerSnapshot {
+  row: SellerRow;
+  status?: any;
+  service?: any;
+  upstreams?: any;
+  config?: any;
+  balance?: BalanceSnapshot;
+}
+
+export class AdminUiState {
+  private readonly configManager: ConfigManager;
+  private readonly options: AdminUiStateOptions;
+  private readonly fetchJson: (url: string, init?: RequestInit) => Promise<unknown>;
+  private readonly balanceCache = new BalanceProbeCache();
+
+  constructor(options: AdminUiStateOptions) {
+    this.options = options;
+    this.configManager = options.configPath ? new ConfigManager(options.configPath) : options.configManager;
+    this.fetchJson = options.fetchJson || defaultFetchJson;
+  }
+
+  public async bootstrap(): Promise<BootstrapSummary> {
+    try {
+      const document = await this.fetchRegistry();
+      const profile = this.activeBootstrapProfile();
+      return {
+        status: "available",
+        url: profile.profile?.url || this.options.url,
+        profile: profile.name,
+        registryVersion: document.version,
+        registryUpdatedAt: document.updatedAt,
+        sellerEntries: document.sellers.length,
+        defaultSeller: document.defaultSeller,
+        regions: Array.from(new Set(document.sellers.map((seller) => seller.region).filter((region): region is string => Boolean(region)))).sort()
+      };
+    } catch (err: any) {
+      const profile = this.activeBootstrapProfile();
+      return {
+        status: "unavailable",
+        url: profile.profile?.url || this.options.url,
+        profile: profile.name,
+        sellerEntries: 0,
+        regions: [],
+        error: err.message
+      };
+    }
+  }
+
+  public async bootstrapConfig(): Promise<BootstrapConfigSummary> {
+    try {
+      const profile = this.activeBootstrapProfile();
+      if (!profile.profile) {
+        throw new Error("No bootstrap profile found. Configure an admin profile or pass --url and --token.");
+      }
+      const client = new AdminClient(profile.profile.url, profile.profile.token);
+      const config = await client.get("/operator/config");
+      return {
+        status: "available",
+        sellerRegistryPath: stringValue(config.sellerRegistryPath),
+        bindHost: stringValue(config.bind?.host),
+        bindPort: numberValue(config.bind?.port),
+        allowLocalSellerUrls: Boolean(config.allowLocalSellerUrls),
+        clawtip: {
+          payToMasked: maskSecret(config.clawtip?.payTo),
+          sm4KeyMasked: maskSecret(config.clawtip?.sm4KeyBase64),
+          skillSlug: stringValue(config.clawtip?.skillSlug),
+          skillId: stringValue(config.clawtip?.skillId),
+          description: stringValue(config.clawtip?.description),
+          resourceUrl: stringValue(config.clawtip?.resourceUrl),
+          activationFeeFen: numberValue(config.clawtip?.activationFeeFen),
+          microsPerFen: numberValue(config.clawtip?.microsPerFen)
+        }
+      };
+    } catch (err: any) {
+      return {
+        status: "unavailable",
+        error: err.message
+      };
+    }
+  }
+
+  public async sellers(): Promise<SellerRow[]> {
+    const document = await this.fetchRegistry();
+    const snapshots = await Promise.all(document.sellers.map((seller) => this.sellerSnapshot(seller)));
+    return snapshots.map((snapshot) => snapshot.row);
+  }
+
+  public async sellerDetail(id: string): Promise<SellerDetail> {
+    const document = await this.fetchRegistry();
+    const entry = document.sellers.find((seller) => seller.id === id || seller.name === id || seller.app === id);
+    if (!entry) {
+      throw new Error(`seller \`${id}\` not found in bootstrap registry`);
+    }
+    const snapshot = await this.sellerSnapshot(entry);
+    const config = snapshot.config?.config || snapshot.config || {};
+    const upstreams = snapshot.upstreams || {};
+    return {
+      row: snapshot.row,
+      configuration: {
+        registryStatus: snapshot.row.registryStatus,
+        region: entry.region,
+        upstreamUrl: stringValue(config.upstreamUrl || upstreams.upstreamUrl),
+        upstreamApiKeyMasked: maskApiKey(config.upstreamApiKey || upstreams.upstreamApiKey),
+        upstreamStatus: snapshot.row.upstreamStatus,
+        upstreamBalance: balanceString(snapshot.balance),
+        upstreamBalanceSource: snapshot.row.upstreamBalanceSource,
+        upstreamBalanceFetchedAt: snapshot.row.upstreamBalanceFetchedAt,
+        upstreamBalanceError: snapshot.row.upstreamBalanceError,
+        upstreamBalanceProbeTemplate: stringValue(config.upstreamBalanceProbe?.template),
+        upstreamBalanceProbeUrl: stringValue(config.upstreamBalanceProbe?.url || config.upstreamBalanceUrl),
+        upstreamBalanceProbeUserId: stringValue(config.upstreamBalanceProbe?.userId || config.upstreamUserId),
+        upstreamBalanceProbeRechargeUrl: stringValue(config.upstreamBalanceProbe?.rechargeUrl || config.upstreamRechargeUrl),
+        upstreamBalanceUrl: stringValue(config.upstreamBalanceUrl),
+        upstreamUserId: stringValue(config.upstreamUserId),
+        upstreamRechargeUrl: snapshot.row.upstreamRechargeUrl,
+        markupRatio: numberValue(config.markupRatio ?? upstreams.markupRatio),
+        discountRatio: numberValue(config.discountRatio ?? upstreams.discountRatio),
+        maxConnections: numberValue(config.maxConnections ?? snapshot.service?.capacity?.maxConnections ?? snapshot.status?.capacity?.maxConnections),
+        maxQueueDepth: numberValue(config.maxQueueDepth ?? snapshot.service?.capacity?.maxQueueDepth ?? snapshot.status?.capacity?.maxQueueDepth)
+      },
+      models: modelRows(upstreams, config, snapshot.status)
+    };
+  }
+
+  public async rawSellerConfig(id: string): Promise<{ entry: SellerRegistryEntry; profileName?: string; config: any }> {
+    const document = await this.fetchRegistry();
+    const entry = document.sellers.find((seller) => seller.id === id || seller.name === id || seller.app === id);
+    if (!entry) {
+      throw new Error(`seller \`${id}\` not found in bootstrap registry`);
+    }
+    const match = this.matchSellerProfile(entry);
+    if (!match.profile) {
+      throw new Error(`seller \`${entry.id}\` has no matching local admin profile`);
+    }
+    const response = await this.fetchSellerAdminJson(match.profile, "/operator/admin/config");
+    return { entry, profileName: match.localProfile ? match.name : undefined, config: response.config || response };
+  }
+
+  public async fetchRegistry(): Promise<SellerRegistryDocument> {
+    const profile = this.activeBootstrapProfile();
+    const baseUrl = this.options.url || profile.profile?.url;
+    if (!baseUrl) {
+      throw new Error("No bootstrap profile found. Configure an admin profile or pass --url.");
+    }
+    const document = await this.fetchJson(`${trimSlash(baseUrl)}/registry/sellers`) as SellerRegistryDocument;
+    if (!document || !Array.isArray(document.sellers)) {
+      throw new Error("bootstrap registry response did not include sellers");
+    }
+    return document;
+  }
+
+  private activeBootstrapProfile(): ProfileMatch {
+    const envProfile = process.env.TOKENBUDDY_ADMIN_PROFILE;
+    const target = this.options.profile || envProfile;
+    if (this.options.url) {
+      return {
+        name: target,
+        profile: this.options.token ? { url: this.options.url, token: this.options.token } : undefined,
+        localProfile: false
+      };
+    }
+    const config = this.configManager.load();
+    const name = target || config.default_profile || Object.keys(config.profiles)[0];
+    return {
+      name,
+      profile: name ? config.profiles[name] : undefined,
+      localProfile: Boolean(name && config.profiles[name])
+    };
+  }
+
+  private matchSellerProfile(entry: SellerRegistryEntry): ProfileMatch {
+    const config = this.configManager.load();
+    if (entry.profile && config.profiles[entry.profile]) {
+      return { name: entry.profile, profile: config.profiles[entry.profile], localProfile: true };
+    }
+    const byUrl = Object.entries(config.profiles).find(([, profile]) => trimSlash(profile.url) === trimSlash(entry.url));
+    if (byUrl) {
+      return { name: byUrl[0], profile: byUrl[1], localProfile: true };
+    }
+    const entryHost = hostName(entry.url);
+    const near = Object.entries(config.profiles).find(([name, profile]) => {
+      const haystack = `${name} ${profile.url} ${hostName(profile.url)}`.toLowerCase();
+      return [entry.id, entry.app, entryHost].some((value) => value && haystack.includes(value.toLowerCase()));
+    });
+    if (near) {
+      return { name: near[0], profile: near[1], localProfile: true };
+    }
+    const provider = this.configManager.getSellerProvider("fly");
+    if (provider?.operator_secret) {
+      return {
+        name: entry.app || entry.id,
+        profile: {
+          url: entry.url,
+          token: provider.operator_secret
+        },
+        localProfile: false
+      };
+    }
+    return {};
+  }
+
+  private async sellerSnapshot(entry: SellerRegistryEntry): Promise<SellerSnapshot> {
+    const match = this.matchSellerProfile(entry);
+    const baseRow = baseSellerRow(entry, match.name);
+    if (!match.profile) {
+      return {
+        row: {
+          ...baseRow,
+          nodeStatus: "auth_unknown",
+          error: "No matching local admin profile"
+        }
+      };
+    }
+
+    try {
+      const [status, service, upstreams, config] = await Promise.all([
+        this.fetchSellerAdminJson(match.profile, "/operator/status").catch((err: any) => ({ error: err.message })),
+        this.fetchSellerAdminJson(match.profile, "/operator/admin/service").catch((err: any) => ({ error: err.message })),
+        this.fetchSellerAdminJson(match.profile, "/operator/admin/upstreams").catch((err: any) => ({ error: err.message })),
+        this.fetchSellerAdminJson(match.profile, "/operator/admin/config").catch((err: any) => ({ error: err.message }))
+      ]);
+      const configDocument = config?.config || config || {};
+      const balance = await this.balanceSnapshot(configDocument, upstreams);
+      return {
+        status,
+        service,
+        upstreams,
+        config,
+        balance,
+        row: mergeSellerRow(baseRow, entry, status, service, upstreams, configDocument, balance)
+      };
+    } catch (err: any) {
+      return {
+        row: {
+          ...baseRow,
+          nodeStatus: "unknown",
+          error: err.message
+        }
+      };
+    }
+  }
+
+  private async fetchSellerAdminJson(profile: AdminProfile, pathName: string): Promise<any> {
+    return this.fetchJson(`${trimSlash(profile.url)}${pathName}`, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${profile.token}`
+      }
+    });
+  }
+
+  private async balanceSnapshot(config: any, upstreams: any): Promise<BalanceSnapshot | undefined> {
+    if (config?.error) {
+      return undefined;
+    }
+    if (stringValue(config.upstreamBalanceProbe?.template) === "none") {
+      return undefined;
+    }
+    return probeUpstreamBalance({
+      upstreamUrl: stringValue(config.upstreamUrl || upstreams?.upstreamUrl),
+      upstreamBalanceUrl: stringValue(config.upstreamBalanceUrl || upstreams?.upstreamBalanceUrl),
+      upstreamApiKey: stringValue(config.upstreamApiKey),
+      upstreamUserId: stringValue(config.upstreamUserId),
+      upstreamBalanceProbe: objectValue(config.upstreamBalanceProbe)
+    }, {
+      fetch: this.options.balanceFetch,
+      cache: this.balanceCache
+    });
+  }
+}
+
+async function defaultFetchJson(url: string, init?: RequestInit): Promise<unknown> {
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`HTTP Error ${response.status}: ${text || response.statusText}`);
+  }
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+
+function baseSellerRow(entry: SellerRegistryEntry, profile?: string): SellerRow {
+  return {
+    id: entry.id,
+    name: entry.id,
+    description: entry.name && entry.name !== entry.id ? entry.name : undefined,
+    app: entry.app,
+    profile: profile || entry.profile,
+    url: entry.url,
+    registryStatus: registryStatus(entry.status),
+    nodeStatus: registryStatus(entry.status),
+    region: entry.region,
+    upstreamDomain: hostName(entry.url) || "unknown",
+    upstreamStatus: "unknown",
+    modelsCount: entry.modelsCount ?? entry.models?.length ?? entry.sampleModels?.length,
+    specs: {
+      region: entry.region,
+      modelsCount: entry.modelsCount ?? entry.models?.length ?? entry.sampleModels?.length
+    }
+  };
+}
+
+function mergeSellerRow(
+  base: SellerRow,
+  entry: SellerRegistryEntry,
+  status: any,
+  service: any,
+  upstreams: any,
+  config: any,
+  balance: BalanceSnapshot | undefined
+): SellerRow {
+  const normalizedUpstreams = upstreamDocument(upstreams);
+  const capacity = status?.capacity || service?.capacity || {};
+  const upstreamUrl = stringValue(config?.upstreamUrl || normalizedUpstreams?.upstreamUrl || service?.upstreamUrl) || entry.url;
+  const error = firstError(status, service, upstreams);
+  return {
+    ...base,
+    nodeStatus: error ? "unknown" : nodeStatus(status?.status || entry.status),
+    upstreamDomain: hostName(upstreamUrl) || base.upstreamDomain,
+    upstreamStatus: upstreamStatus(status?.upstream?.status || normalizedUpstreams?.status),
+    discountRatio: numberValue(config?.discountRatio ?? normalizedUpstreams?.discountRatio),
+    capacityUsed: numberValue(capacity.activeConnections),
+    capacityLimit: numberValue(capacity.maxConnections),
+    ttftMs: numberValue(status?.latency?.ttftMs),
+    avgInferenceMs: numberValue(status?.latency?.avgInferenceMs),
+    lastInferenceMs: numberValue(status?.latency?.lastInferenceMs),
+    avgTokensPerSecond: numberValue(status?.latency?.avgTokensPerSecond),
+    lastTokensPerSecond: numberValue(status?.latency?.lastTokensPerSecond),
+    latencySamples: numberValue(status?.latency?.sampleCount),
+    upstreamBalanceUsdMicros: balance && Number.isFinite(balance.amountUsdMicros ?? NaN) ? (balance.amountUsdMicros as number) : undefined,
+    upstreamBalanceCurrency: typeof balance?.currency === "string" ? balance.currency : undefined,
+    upstreamBalanceSource: balance?.source,
+    upstreamBalanceFetchedAt: balance ? new Date(balance.fetchedAt).toISOString() : undefined,
+    upstreamBalanceError: balance?.error?.message,
+    upstreamRechargeUrl: stringValue(config?.upstreamBalanceProbe?.rechargeUrl || config?.upstreamRechargeUrl || normalizedUpstreams?.upstreamRechargeUrl),
+    modelsCount: numberValue(service?.modelsCount ?? normalizedUpstreams?.models?.length ?? base.modelsCount),
+    specs: {
+      ...base.specs,
+      region: entry.region,
+      modelsCount: numberValue(service?.modelsCount ?? normalizedUpstreams?.models?.length ?? base.modelsCount)
+    },
+    error
+  };
+}
+
+function modelRows(upstreams: any, config: any, status: any): SellerModelRow[] {
+  const normalizedUpstreams = upstreamDocument(upstreams);
+  const aliases = config.modelAliases || normalizedUpstreams.modelAliases || {};
+  const models = Array.isArray(normalizedUpstreams.models)
+    ? normalizedUpstreams.models
+    : Array.isArray(config.models)
+      ? config.models
+      : [];
+  return models.map((model: any) => {
+    const id = stringValue(model.id || model.name) || "unknown";
+    return {
+      upstreamModel: id,
+      billingModel: stringValue(aliases[id]) || id,
+      inputPrice: priceString(model.inputPriceMicrosPer1m),
+      outputPrice: priceString(model.outputPriceMicrosPer1m),
+      ttftMs: numberValue(model.ttftMs ?? status?.latency?.ttftMs),
+      avgInferenceMs: numberValue(model.avgInferenceMs ?? status?.latency?.avgInferenceMs),
+      avgTokensPerSecond: numberValue(model.avgTokensPerSecond ?? status?.latency?.avgTokensPerSecond),
+      latencySamples: numberValue(model.latencySamples ?? status?.latency?.sampleCount)
+    };
+  });
+}
+
+function upstreamDocument(value: any): any {
+  if (Array.isArray(value?.upstreams)) {
+    return objectValue(value.upstreams[0]) || {};
+  }
+  return objectValue(value?.upstreams) || value || {};
+}
+
+function registryStatus(value: unknown): RegistryStatus {
+  const normalized = String(value || "unknown").toLowerCase();
+  if (normalized === "active" || normalized === "draining" || normalized === "offline" || normalized === "pending") {
+    return normalized;
+  }
+  return "unknown";
+}
+
+function nodeStatus(value: unknown): NodeStatus {
+  const normalized = String(value || "unknown").toLowerCase();
+  if (normalized === "active" || normalized === "busy_capacity" || normalized === "draining" || normalized === "pending" || normalized === "offline") {
+    return normalized;
+  }
+  if (normalized === "healthy") {
+    return "active";
+  }
+  return "unknown";
+}
+
+function upstreamStatus(value: unknown): UpstreamStatus {
+  const normalized = String(value || "unknown").toLowerCase();
+  if (normalized === "healthy" || normalized === "degraded" || normalized === "unhealthy") {
+    return normalized;
+  }
+  return "unknown";
+}
+
+export function maskApiKey(value: unknown): string | undefined {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    return undefined;
+  }
+  const tail = normalized.replace(/\s+/g, "").slice(-4);
+  return tail ? `**** **** **** ${tail}` : "****";
+}
+
+function maskSecret(value: unknown): string | undefined {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    return undefined;
+  }
+  const compact = normalized.replace(/\s+/g, "");
+  if (compact.length <= 8) {
+    return "********";
+  }
+  return `${compact.slice(0, 4)}...${compact.slice(-4)}`;
+}
+
+function trimSlash(value: string): string {
+  return value.replace(/\/+$/, "");
+}
+
+function hostName(value: string | undefined): string {
+  if (!value) {
+    return "";
+  }
+  try {
+    return new URL(value).hostname.replace(/^www\./, "");
+  } catch {
+    return "";
+  }
+}
+
+function numberValue(value: unknown): number | undefined {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function objectValue(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function priceString(value: unknown): string | undefined {
+  const parsed = numberValue(value);
+  if (parsed === undefined) {
+    return undefined;
+  }
+  return `$${(parsed / 1000000).toFixed(4)}/1M`;
+}
+
+function balanceString(balance: BalanceSnapshot | undefined): string | undefined {
+  if (!balance) {
+    return undefined;
+  }
+  if (balance.rawAmount === null) {
+    return balance.error?.message;
+  }
+  const amount = Math.abs(balance.rawAmount) >= 100
+    ? balance.rawAmount.toFixed(0)
+    : balance.rawAmount.toFixed(2);
+  return `${balance.currency || "USD"} ${amount}`;
+}
+
+function firstError(...values: any[]): string | undefined {
+  const hit = values.find((value) => value?.error);
+  return hit?.error;
+}