@wopr-network/platform-ui-core 1.27.8 → 1.27.9

package/src/lib/api.ts

@@ -234,11 +234,7 @@ export function parseChannelsFromEnv(env: Record<string, string> | undefined): s
 export function parsePluginsFromEnv(env: Record<string, string> | undefined): PluginInfo[] {
   if (!env) return [];
   const ids = new Set<string>();
-  for (const key of [
-    envKey("PLUGINS_OTHER"),
-    envKey("PLUGINS_VOICE"),
-    envKey("PLUGINS_PROVIDERS"),
-  ]) {
+  for (const key of [envKey("PLUGINS_OTHER"), envKey("PLUGINS_VOICE"), envKey("PLUGINS_PROVIDERS")]) {
     const raw = env[key];
     if (raw) {
       for (const id of raw
@@ -345,10 +341,14 @@ export async function createInstance(data: {
   provider: string;
   channels: string[];
   plugins: string[];
+  /** Product-specific data passed through to provisioning. */
+  extra?: Record<string, unknown>;
 }): Promise<Instance> {
+  const { extra, ...rest } = data;
   const result = await trpcVanilla.fleet.createInstance.mutate({
-    ...data,
+    ...rest,
     image: data.image ?? "ghcr.io/wopr-network/wopr:latest",
+    extra,
   });
   const profile = result as Record<string, unknown>;
   return {
@@ -453,11 +453,29 @@ export async function listChannels(botId: string): Promise<ChannelInfo[]> {
 
 export async function controlInstance(
   id: string,
-  action: "start" | "stop" | "restart" | "destroy",
+  action: "start" | "stop" | "restart" | "destroy" | "roll",
 ): Promise<void> {
   await trpcVanilla.fleet.controlInstance.mutate({ id, action });
 }
 
+/**
+ * Result of checking whether an instance is running the latest image.
+ * `latestImageId` is null if the tag isn't resolvable locally; in that
+ * case we treat the instance as up to date (no newer version known).
+ */
+export interface InstanceVersionCheck {
+  upToDate: boolean;
+  currentImageId: string;
+  latestImageId: string | null;
+  tag: string;
+}
+
+/** Whether a newer image has been pulled since this instance started. */
+export async function instanceVersionCheck(id: string): Promise<InstanceVersionCheck | null> {
+  const result = (await trpcVanilla.fleet.instanceVersionCheck.query({ id })) as InstanceVersionCheck | null;
+  return result;
+}
+
 /** PATCH /fleet/bots/:id — Update bot env config. */
 export async function updateInstanceConfig(id: string, env: Record<string, string>): Promise<void> {
   await fleetFetch(`/bots/${id}`, {
@@ -490,10 +508,7 @@ export async function getInstanceSecretKeys(id: string): Promise<string[]> {
 }
 
 /** PUT /fleet/bots/:id/secrets — Write secret values. */
-export async function updateInstanceSecrets(
-  id: string,
-  secrets: Record<string, string>,
-): Promise<void> {
+export async function updateInstanceSecrets(id: string, secrets: Record<string, string>): Promise<void> {
   await fleetFetch(`/bots/${id}/secrets`, {
     method: "PUT",
     body: JSON.stringify({ secrets }),
@@ -501,11 +516,7 @@ export async function updateInstanceSecrets(
 }
 
 /** Toggle a plugin's enabled/disabled state on a bot instance. */
-export async function toggleInstancePlugin(
-  botId: string,
-  pluginId: string,
-  enabled: boolean,
-): Promise<void> {
+export async function toggleInstancePlugin(botId: string, pluginId: string, enabled: boolean): Promise<void> {
   await fleetFetch(`/bots/${botId}/plugins/${pluginId}`, {
     method: "PATCH",
     body: JSON.stringify({ enabled }),
@@ -818,14 +829,10 @@ export interface Organization {
 // --- Settings API ---
 
 export async function getProfile(): Promise<UserProfile> {
-  // NOTE: add tRPC procedure
   return apiFetch<UserProfile>("/settings/profile");
 }
 
-export async function updateProfile(
-  data: Partial<Pick<UserProfile, "name" | "email">>,
-): Promise<UserProfile> {
-  // NOTE: add tRPC procedure
+export async function updateProfile(data: Partial<Pick<UserProfile, "name" | "email">>): Promise<UserProfile> {
   return apiFetch<UserProfile>("/settings/profile", {
     method: "PATCH",
     body: JSON.stringify(data),
@@ -833,38 +840,29 @@ export async function updateProfile(
 }
 
 export async function uploadAvatar(file: File): Promise<UserProfile> {
-  const tenantId = getActiveTenantId();
-  const form = new FormData();
-  form.append("avatar", file);
-  const res = await fetch(`${API_BASE_URL}/settings/profile/avatar`, {
-    method: "POST",
-    credentials: "include",
-    headers: {
-      ...(tenantId ? { "x-tenant-id": tenantId } : {}),
-    },
-    body: form,
+  const dataUrl = await new Promise<string>((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = () => reject(new Error("Failed to read file"));
+    reader.readAsDataURL(file);
+  });
+  return apiFetch<UserProfile>("/settings/profile", {
+    method: "PATCH",
+    body: JSON.stringify({ image: dataUrl }),
   });
-  if (res.status === 401) {
-    handleUnauthorized();
-  }
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    throw new ApiError(res.status, res.statusText, (body as { error?: string }).error ?? undefined);
-  }
-  return res.json() as Promise<UserProfile>;
 }
 
-export async function changePassword(data: {
-  currentPassword: string;
-  newPassword: string;
-}): Promise<void> {
-  // NOTE: add tRPC procedure
-  await apiFetch("/settings/profile/password", { method: "POST", body: JSON.stringify(data) });
+export async function changePassword(data: { currentPassword: string; newPassword: string }): Promise<void> {
+  await apiFetch<void>("/settings/change-password", {
+    method: "POST",
+    body: JSON.stringify(data),
+  });
 }
 
 export async function deleteAccount(): Promise<void> {
-  // NOTE: add tRPC procedure
-  await apiFetch("/settings/profile", { method: "DELETE" });
+  await apiFetch<void>("/settings/delete-account", {
+    method: "DELETE",
+  });
 }
 
 export async function listProviderKeys(): Promise<ProviderKey[]> {
@@ -972,9 +970,7 @@ export async function createSecret(data: {
 
 // NOTE: migrate to tRPC when secrets router is extended
 /** POST /settings/secrets/:id/rotate — Rotate a secret. */
-export async function rotateSecret(
-  id: string,
-): Promise<{ secret: SecretSummary; plaintextValue: string }> {
+export async function rotateSecret(id: string): Promise<{ secret: SecretSummary; plaintextValue: string }> {
   return apiFetch<{ secret: SecretSummary; plaintextValue: string }>(
     `/settings/secrets/${encodeURIComponent(id)}/rotate`,
     { method: "POST" },
@@ -1225,6 +1221,7 @@ export type CreditTransactionType =
   | "purchase"
   | "signup_credit"
   | "bot_runtime"
+  | "adapter_usage"
   | "refund"
   | "bonus"
   | "adjustment"
@@ -1234,6 +1231,7 @@ export interface CreditTransaction {
   id: string;
   type: CreditTransactionType;
   description: string;
+  /** Amount in dollars. Positive = credit (green), negative = debit (red). */
   amount: number;
   createdAt: string;
 }
@@ -1285,39 +1283,75 @@ export async function getCreditBalance(): Promise<CreditBalance> {
   };
 }
 
-function mapTransactionType(backendType: string): CreditTransactionType {
+function mapEntryType(entryType: string): CreditTransactionType {
   const map: Record<string, CreditTransactionType> = {
-    grant: "purchase",
+    purchase: "purchase",
+    signup_credit: "signup_credit",
+    bot_runtime: "bot_runtime",
+    adapter_usage: "adapter_usage",
     refund: "refund",
+    bonus: "bonus",
     correction: "adjustment",
     community_dividend: "community_dividend",
+    // Legacy mappings
+    grant: "purchase",
   };
-  return map[backendType] ?? "adjustment";
+  return map[entryType] ?? "adjustment";
+}
+
+/** Nanodollars per dollar (10^9). */
+const NANO_PER_DOLLAR = 1_000_000_000;
+
+/** Clean up ledger descriptions for user-facing display. */
+function cleanDescription(raw: string, entryType: string, entryCount: number, amountDollars: number): string {
+  // Aggregated usage: "LLM Inference — 25 requests"
+  if (entryCount > 1) return `${raw} — ${entryCount} requests`;
+  // Stripe purchases: strip session ID noise
+  if (entryType === "purchase" && raw.includes("session:")) {
+    const dollars = Math.abs(amountDollars).toFixed(2);
+    return `Credit purchase — $${dollars}`;
+  }
+  // Welcome bonus / signup credit
+  if (raw.toLowerCase().includes("welcome bonus") || raw.toLowerCase().includes("email verification")) {
+    return "Signup credit";
+  }
+  return raw;
+}
+
+/**
+ * Fetch transaction history from the SQL-aggregated endpoint.
+ * Inference costs are GROUP BY day + SUM'd in the DB.
+ * Credits (purchases, refunds, bonuses) are returned individually.
+ */
+/** Map raw tRPC creditsDailySummary rows to CreditTransaction[]. Reusable by both vanilla and React Query callers. */
+export function mapTransactionRows(
+  rows: Array<{
+    id: string;
+    entryType: string;
+    description: string;
+    postedAt: string;
+    signedAmountNano: number;
+    entryCount: number;
+  }>,
+): CreditTransaction[] {
+  return rows.map((r) => {
+    let type = mapEntryType(r.entryType);
+    const amount = r.signedAmountNano / NANO_PER_DOLLAR;
+    if (
+      r.description.toLowerCase().includes("welcome bonus") ||
+      r.description.toLowerCase().includes("email verification")
+    ) {
+      type = "signup_credit";
+    }
+    const description = cleanDescription(r.description, r.entryType, r.entryCount, amount);
+    return { id: r.id, type, description, amount, createdAt: r.postedAt };
+  });
 }
 
 export async function getCreditHistory(_cursor?: string): Promise<CreditHistoryResponse> {
-  const res = await trpcVanilla.billing.creditsHistory.query({});
-  const entries = Array.isArray(res?.entries) ? res.entries : [];
-  return {
-    transactions: (
-      entries as Array<{
-        id?: string;
-        type?: string;
-        reason?: string;
-        amount_cents?: number;
-        created_at?: number;
-      }>
-    ).map((e) => ({
-      id: e.id ?? "",
-      type: mapTransactionType(e.type ?? ""),
-      description: e.reason ?? "",
-      amount: (e.amount_cents ?? 0) / 100,
-      createdAt: e.created_at
-        ? new Date(e.created_at * 1000).toISOString()
-        : new Date().toISOString(),
-    })),
-    nextCursor: null, // NOTE(WOP-687): implement cursor-based pagination
-  };
+  const res = await trpcVanilla.billing.creditsDailySummary.query({});
+  const rows = Array.isArray(res?.rows) ? res.rows : [];
+  return { transactions: mapTransactionRows(rows), nextCursor: null };
 }
 
 export async function getCreditOptions(): Promise<CreditOption[]> {
@@ -1361,6 +1395,14 @@ export interface CheckoutResult {
   token: string;
   chain: string;
   referenceId: string;
+  /** "native" or "erc20" */
+  type?: string;
+  /** ERC-20 contract address (null for native tokens). */
+  contractAddress?: string | null;
+  /** Token decimals. */
+  decimals?: number;
+  /** Expected amount in native base units. */
+  expectedAmount?: string;
   priceCents?: number;
 }
 
@@ -1375,12 +1417,16 @@ export interface ChargeStatusResult {
   status: "pending" | "partial" | "confirmed" | "expired" | "failed";
   amountExpectedCents: number;
   amountReceivedCents: number;
+  /** Native crypto amount expected (base units as string). */
+  expectedAmount?: string | null;
+  /** Native crypto amount received so far (base units as string). */
+  receivedAmount?: string | null;
+  token?: string;
+  decimals?: number;
   confirmations: number;
   confirmationsRequired: number;
   txHash?: string;
   credited: boolean;
-  /** @deprecated Use amountExpectedCents. Removed next major. */
-  amountUsdCents: number;
 }
 
 export async function getChargeStatus(referenceId: string): Promise<ChargeStatusResult> {
@@ -1410,16 +1456,11 @@ export async function adminListPaymentMethods(): Promise<PaymentMethodAdmin[]> {
   return trpcVanilla.billing.adminListPaymentMethods.query(undefined);
 }
 
-export async function adminUpsertPaymentMethod(
-  method: PaymentMethodAdmin,
-): Promise<{ ok: boolean }> {
+export async function adminUpsertPaymentMethod(method: PaymentMethodAdmin): Promise<{ ok: boolean }> {
   return trpcVanilla.billing.adminUpsertPaymentMethod.mutate(method);
 }
 
-export async function adminTogglePaymentMethod(
-  id: string,
-  enabled: boolean,
-): Promise<{ ok: boolean }> {
+export async function adminTogglePaymentMethod(id: string, enabled: boolean): Promise<{ ok: boolean }> {
   return trpcVanilla.billing.adminTogglePaymentMethod.mutate({ id, enabled });
 }
 
@@ -1679,9 +1720,7 @@ export async function validateDeepgramKey(key: string): Promise<KeyValidationRes
   const { testProviderKey: testProviderKeyViaTrpc } = await import("./settings-api");
   try {
     const result = await testProviderKeyViaTrpc("transcription", key);
-    return result.valid
-      ? { valid: true }
-      : { valid: false, message: "Invalid API key. Please check and try again." };
+    return result.valid ? { valid: true } : { valid: false, message: "Invalid API key. Please check and try again." };
   } catch (e) {
     log.warn("Key validation request failed", e);
     return { valid: false, message: "Could not validate key. Please try again." };
@@ -1689,9 +1728,7 @@ export async function validateDeepgramKey(key: string): Promise<KeyValidationRes
 }
 
 export async function validateElevenLabsKey(key: string): Promise<KeyValidationResult> {
-  const { testProviderKey, saveProviderKey: saveProviderKeyViaTrpc } = await import(
-    "./settings-api"
-  );
+  const { testProviderKey, saveProviderKey: saveProviderKeyViaTrpc } = await import("./settings-api");
   try {
     const result = await testProviderKey("elevenlabs", key);
     if (result.valid) {
@@ -1778,21 +1815,17 @@ export async function createSnapshot(
   instanceId: string,
   name?: string,
 ): Promise<{ snapshot: Snapshot; estimatedMonthlyCost: string }> {
-  return apiFetch<{ snapshot: Snapshot; estimatedMonthlyCost: string }>(
-    `/bots/${instanceId}/snapshots`,
-    {
-      method: "POST",
-      body: JSON.stringify(name ? { name } : {}),
-    },
-  );
+  return apiFetch<{ snapshot: Snapshot; estimatedMonthlyCost: string }>(`/bots/${instanceId}/snapshots`, {
+    method: "POST",
+    body: JSON.stringify(name ? { name } : {}),
+  });
 }
 
 /** Restore an instance from a snapshot. Uses the /instances/ route. */
 export async function restoreSnapshot(instanceId: string, snapshotId: string): Promise<void> {
-  await apiFetch<{ ok: boolean; restored: string }>(
-    `/instances/${instanceId}/snapshots/${snapshotId}/restore`,
-    { method: "POST" },
-  );
+  await apiFetch<{ ok: boolean; restored: string }>(`/instances/${instanceId}/snapshots/${snapshotId}/restore`, {
+    method: "POST",
+  });
 }
 
 /** Delete a snapshot. Backend returns 204 no content. */
@@ -1856,10 +1889,9 @@ export async function listFriends(instanceId: string): Promise<Friend[]> {
 }
 
 export async function listDiscoveredBots(instanceId: string): Promise<DiscoveredBot[]> {
-  const data = await apiFetch<{ discovered: DiscoveredBot[] }>(
-    `/instances/${instanceId}/friends/discovered`,
-    { method: "GET" },
-  );
+  const data = await apiFetch<{ discovered: DiscoveredBot[] }>(`/instances/${instanceId}/friends/discovered`, {
+    method: "GET",
+  });
   return data.discovered;
 }
 
@@ -1871,10 +1903,9 @@ export async function sendFriendRequest(instanceId: string, targetBotId: string)
 }
 
 export async function listFriendRequests(instanceId: string): Promise<FriendRequest[]> {
-  const data = await apiFetch<{ requests: FriendRequest[] }>(
-    `/instances/${instanceId}/friends/requests`,
-    { method: "GET" },
-  );
+  const data = await apiFetch<{ requests: FriendRequest[] }>(`/instances/${instanceId}/friends/requests`, {
+    method: "GET",
+  });
   return data.requests;
 }
 
@@ -1913,10 +1944,7 @@ export async function getAutoAcceptConfig(instanceId: string): Promise<AutoAccep
   });
 }
 
-export async function updateAutoAcceptConfig(
-  instanceId: string,
-  config: AutoAcceptConfig,
-): Promise<void> {
+export async function updateAutoAcceptConfig(instanceId: string, config: AutoAcceptConfig): Promise<void> {
   await apiFetch<{ ok: boolean }>(`/instances/${instanceId}/friends/auto-accept`, {
     method: "PUT",
     body: JSON.stringify(config),
@@ -1940,10 +1968,7 @@ export interface LoginHistoryResponse {
   hasMore: boolean;
 }
 
-export async function fetchLoginHistory(params: {
-  limit?: number;
-  offset?: number;
-}): Promise<LoginHistoryResponse> {
+export async function fetchLoginHistory(params: { limit?: number; offset?: number }): Promise<LoginHistoryResponse> {
   const query = new URLSearchParams();
   if (params.limit != null) query.set("limit", String(params.limit));
   if (params.offset != null) query.set("offset", String(params.offset));
@@ -2011,11 +2036,7 @@ export interface VpsUpgradeResult {
 }
 
 /** Initiate a VPS upgrade for a bot. Returns the raw Response for status inspection (409, 402). */
-export async function upgradeToVps(
-  botId: string,
-  successUrl: string,
-  cancelUrl: string,
-): Promise<Response> {
+export async function upgradeToVps(botId: string, successUrl: string, cancelUrl: string): Promise<Response> {
   return apiFetchRaw(`/fleet/bots/${botId}/upgrade-to-vps`, {
     method: "POST",
     body: JSON.stringify({ successUrl, cancelUrl }),

package/src/lib/auth-client.ts

@@ -7,5 +7,4 @@ export const authClient = createAuthClient({
   plugins: [twoFactorClient()],
 });
 
-export const { useSession, signIn, signUp, signOut, linkSocial, unlinkAccount, listAccounts } =
-  authClient;
+export const { useSession, signIn, signUp, signOut, linkSocial, unlinkAccount, listAccounts } = authClient;

package/src/lib/bot-settings-data.ts

@@ -139,24 +139,17 @@ export async function getBotSettings(botId: string): Promise<BotSettings> {
   return apiFetch<BotSettings>(`/fleet/bots/${botId}/settings`);
 }
 
-export async function updateBotIdentity(
-  botId: string,
-  identity: BotIdentity,
-): Promise<BotIdentity> {
+export async function updateBotIdentity(botId: string, identity: BotIdentity): Promise<BotIdentity> {
   return apiFetch<BotIdentity>(`/fleet/bots/${botId}/identity`, {
     method: "PUT",
     body: JSON.stringify(identity),
   });
 }
 
-export async function activateSuperpower(
-  botId: string,
-  superpowerId: string,
-): Promise<{ success: boolean }> {
-  return apiFetch<{ success: boolean }>(
-    `/fleet/bots/${botId}/capabilities/${superpowerId}/activate`,
-    { method: "POST" },
-  );
+export async function activateSuperpower(botId: string, superpowerId: string): Promise<{ success: boolean }> {
+  return apiFetch<{ success: boolean }>(`/fleet/bots/${botId}/capabilities/${superpowerId}/activate`, {
+    method: "POST",
+  });
 }
 
 // --- Storage tier types ---
@@ -199,10 +192,7 @@ export async function getResourceTier(botId: string): Promise<{ tier: string }>
   return apiFetch<{ tier: string }>(`/fleet/bots/${botId}/resource-tier`);
 }
 
-export async function setResourceTier(
-  botId: string,
-  tier: string,
-): Promise<{ tier: string; dailyCostCents: number }> {
+export async function setResourceTier(botId: string, tier: string): Promise<{ tier: string; dailyCostCents: number }> {
   return apiFetch<{ tier: string; dailyCostCents: number }>(`/fleet/bots/${botId}/resource-tier`, {
     method: "PUT",
     body: JSON.stringify({ tier }),
@@ -248,11 +238,7 @@ export async function disconnectChannel(botId: string, channelId: string): Promi
 }
 
 /** Toggle a plugin's enabled/disabled state */
-export async function togglePlugin(
-  botId: string,
-  pluginId: string,
-  enabled: boolean,
-): Promise<void> {
+export async function togglePlugin(botId: string, pluginId: string, enabled: boolean): Promise<void> {
   await apiFetch(`/fleet/bots/${botId}/plugins/${pluginId}`, {
     method: "PATCH",
     body: JSON.stringify({ enabled }),
@@ -280,10 +266,7 @@ export async function uninstallPlugin(botId: string, pluginId: string): Promise<
 }
 
 /** Fetch channel configuration */
-export async function getChannelConfig(
-  botId: string,
-  channelId: string,
-): Promise<Record<string, string>> {
+export async function getChannelConfig(botId: string, channelId: string): Promise<Record<string, string>> {
   return apiFetch<Record<string, string>>(`/fleet/bots/${botId}/channels/${channelId}/config`);
 }
 
@@ -300,10 +283,7 @@ export async function updateChannelConfig(
 }
 
 /** Fetch plugin configuration */
-export async function getPluginConfig(
-  botId: string,
-  pluginId: string,
-): Promise<Record<string, string>> {
+export async function getPluginConfig(botId: string, pluginId: string): Promise<Record<string, string>> {
   return apiFetch<Record<string, string>>(`/fleet/bots/${botId}/plugins/${pluginId}/config`);
 }
 
@@ -320,13 +300,8 @@ export async function updatePluginConfig(
 }
 
 /** Fetch superpower configuration */
-export async function getSuperpowerConfig(
-  botId: string,
-  superpowerId: string,
-): Promise<Record<string, string>> {
-  return apiFetch<Record<string, string>>(
-    `/fleet/bots/${botId}/capabilities/${superpowerId}/config`,
-  );
+export async function getSuperpowerConfig(botId: string, superpowerId: string): Promise<Record<string, string>> {
+  return apiFetch<Record<string, string>>(`/fleet/bots/${botId}/capabilities/${superpowerId}/config`);
 }
 
 /** Save superpower configuration */