@tokenbuddy/tb-admin 1.0.14 → 1.0.27

package/src/display-format.ts

@@ -0,0 +1,398 @@
+// Shared display formatters for TokenBuddy UI surfaces.
+//
+// This module is a portable copy of `packages/tb-ui/src/lib/display-format.ts`
+// and the canonical formatter functions declared in `DESIGN.md`
+// ("Formatter Implementation" section). Keep both files in sync — the
+// rule from DESIGN.md is:
+//   "Do not add new per-page formatting helpers for these domains.
+//    If a page needs a different display, add an explicit option
+//    to the shared formatter."
+//
+// Differences vs. the React copy:
+//   1. No React-only imports.
+//   2. Adds `formatBalanceAmount` and `formatSellerStatus` for the
+//      admin surface, because the admin UI surfaces live balance
+//      numbers and node-status dots that the buyer UI never shows.
+
+export const UNKNOWN_VALUE = "—";
+
+const PAD2 = (n: number) => (n < 10 ? `0${n}` : `${n}`);
+
+export function formatTokenCount(
+  value: number | undefined | null,
+  options: { compact?: boolean } = {}
+): string {
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  const numeric = value as number;
+  if (options.compact === false) return Math.round(numeric).toLocaleString("en-US");
+  if (numeric < 10_000) return Math.round(numeric).toLocaleString("en-US");
+  if (numeric < 1_000_000) return `${(numeric / 1_000).toFixed(1)}K`;
+  if (numeric < 1_000_000_000) return `${(numeric / 1_000_000).toFixed(1)}M`;
+  return `${(numeric / 1_000_000_000).toFixed(2)}B`;
+}
+
+export function formatTokenPair(
+  input: number | undefined | null,
+  output: number | undefined | null,
+  options: { compact?: boolean; separator?: string } = {}
+): string {
+  const separator = options.separator ?? " / ";
+  return `In ${formatTokenCount(input, options)}${separator}Out ${formatTokenCount(output, options)}`;
+}
+
+export function formatCount(value: number | undefined | null): string {
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  return Math.round(value as number).toLocaleString("en-US");
+}
+
+export function formatMoney(
+  micros: number | undefined | null,
+  options: { digits?: number; ledger?: boolean; signed?: boolean } = {}
+): string {
+  if (!Number.isFinite(micros)) return UNKNOWN_VALUE;
+  const amount = Math.abs((micros as number) / 1_000_000);
+  const digits = options.digits ?? (options.ledger && amount < 0.01 ? 6 : 4);
+  const formatted = `$${((micros as number) / 1_000_000).toFixed(digits)}`;
+  return options.signed && (micros as number) >= 0 ? `+${formatted}` : formatted;
+}
+
+export function formatMoneyPair(
+  actualMicros: number | undefined | null,
+  referenceMicros: number | undefined | null,
+  options: { digits?: number } = {}
+): string {
+  if (!Number.isFinite(actualMicros) && !Number.isFinite(referenceMicros)) return UNKNOWN_VALUE;
+  return `${formatMoney(actualMicros, options)} / ${formatMoney(referenceMicros, options)}`;
+}
+
+export function formatDuration(valueMs: number | undefined | null): string {
+  if (!Number.isFinite(valueMs)) return UNKNOWN_VALUE;
+  const ms = Math.max(0, Math.round(valueMs as number));
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+export function formatPercent(value: number | undefined | null): string {
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  return `${Math.round((value as number) * 100)}%`;
+}
+
+export function formatDiscountRatio(discountRatio: number | undefined | null): string {
+  if (!Number.isFinite(discountRatio)) return UNKNOWN_VALUE;
+  const discount = Math.max(0, 1 - (discountRatio as number));
+  return formatPercent(discount);
+}
+
+export function formatPriceMicrosPerMillion(value: number | undefined | null): string {
+  return formatMoney(value, { digits: 4 });
+}
+
+export function formatPricePair(
+  inputMicros: number | undefined | null,
+  outputMicros: number | undefined | null
+): string {
+  return formatMoneyPair(inputMicros, outputMicros, { digits: 4 });
+}
+
+export function normalizeStatusLabel(status: string | undefined | null): string {
+  if (!status) return UNKNOWN_VALUE;
+  return status.trim().toLowerCase().replaceAll("_", " ");
+}
+
+export type StatusTone = "green" | "amber" | "red" | "blue" | "gray";
+
+export function statusTone(status: string | undefined | null): StatusTone {
+  const normalized = normalizeStatusLabel(status);
+  if (
+    normalized === "ok" ||
+    normalized === "online" ||
+    normalized === "configured" ||
+    normalized === "settled" ||
+    normalized === "completed" ||
+    normalized === "success" ||
+    normalized === "active" ||
+    normalized === "healthy"
+  ) {
+    return "green";
+  }
+  if (
+    normalized === "fallback" ||
+    normalized === "pending" ||
+    normalized === "degraded" ||
+    normalized === "preview" ||
+    normalized === "draining" ||
+    normalized === "busy capacity" ||
+    normalized === "auth unknown"
+  ) {
+    return "amber";
+  }
+  if (
+    normalized === "failed" ||
+    normalized === "error" ||
+    normalized === "canceled" ||
+    normalized === "unhealthy" ||
+    normalized === "offline"
+  ) {
+    return "red";
+  }
+  if (normalized === "running") return "blue";
+  return "gray";
+}
+
+export function formatHash(value: string | undefined | null, length = 32): string {
+  if (!value) return UNKNOWN_VALUE;
+  return value.length > length ? `${value.slice(0, length)}...` : value;
+}
+
+export function formatSellerId(value: string | undefined | null): string {
+  if (!value) return UNKNOWN_VALUE;
+  if (value.startsWith("tbs-") && value.length > 10) return value.slice(0, 10);
+  if (value.length <= 12) return value;
+  return value.slice(0, 12);
+}
+
+export function formatTimeCompact(iso: string | undefined | null): string {
+  if (!iso) return UNKNOWN_VALUE;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return UNKNOWN_VALUE;
+  const now = new Date();
+  const sameDay =
+    d.getFullYear() === now.getFullYear() &&
+    d.getMonth() === now.getMonth() &&
+    d.getDate() === now.getDate();
+  const time = `${PAD2(d.getHours())}:${PAD2(d.getMinutes())}`;
+  if (sameDay) return time;
+  return `${PAD2(d.getMonth() + 1)}/${PAD2(d.getDate())} ${time}`;
+}
+
+export function formatTimeFull(iso: string | undefined | null): string {
+  if (!iso) return UNKNOWN_VALUE;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return UNKNOWN_VALUE;
+  return (
+    `${d.getFullYear()}-${PAD2(d.getMonth() + 1)}-${PAD2(d.getDate())} ` +
+    `${PAD2(d.getHours())}:${PAD2(d.getMinutes())}:${PAD2(d.getSeconds())}`
+  );
+}
+
+export function formatTimeLedger(iso: string | undefined | null): string {
+  if (!iso) return UNKNOWN_VALUE;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return UNKNOWN_VALUE;
+  return (
+    `${d.getFullYear()}/${PAD2(d.getMonth() + 1)}/${PAD2(d.getDate())} ` +
+    `${PAD2(d.getHours())}:${PAD2(d.getMinutes())}:${PAD2(d.getSeconds())}`
+  );
+}
+
+export function formatRouteSwitchTime(iso: string | undefined | null): string {
+  return formatTimeCompact(iso);
+}
+
+// --- admin-only extensions ---------------------------------------------------
+
+export function formatBalanceAmount(
+  usdMicros: number | undefined | null,
+  currency: string | undefined | null
+): string {
+  if (!Number.isFinite(usdMicros)) return UNKNOWN_VALUE;
+  const amount = (usdMicros as number) / 1_000_000;
+  const digits = Math.abs(amount) >= 100 ? 0 : 2;
+  const code = (currency || "USD").toUpperCase();
+  return `${code} ${amount.toFixed(digits)}`;
+}
+
+export function formatSellerCapacity(
+  used: number | undefined | null,
+  limit: number | undefined | null
+): string {
+  if (!Number.isFinite(used) && !Number.isFinite(limit)) return UNKNOWN_VALUE;
+  const u = Number.isFinite(used) ? Math.round(used as number) : UNKNOWN_VALUE;
+  const l = Number.isFinite(limit) ? Math.round(limit as number) : UNKNOWN_VALUE;
+  return `${u} / ${l}`;
+}
+
+export function formatSpeed(value: number | undefined | null): string {
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  return `${(value as number).toFixed(1)} tok/s`;
+}
+
+export type CanonicalStatus =
+  | "ok"
+  | "online"
+  | "configured"
+  | "pending"
+  | "degraded"
+  | "error"
+  | "unknown";
+
+const SELLER_STATUS_MAP: Record<string, CanonicalStatus> = {
+  active: "ok",
+  healthy: "ok",
+  online: "online",
+  configured: "configured",
+  pending: "pending",
+  draining: "degraded",
+  degraded: "degraded",
+  busy_capacity: "degraded",
+  offline: "error",
+  unhealthy: "error",
+  error: "error",
+  auth_unknown: "unknown",
+  unknown: "unknown"
+};
+
+export function formatSellerStatus(status: string | undefined | null): CanonicalStatus {
+  const key = String(status || "unknown")
+    .trim()
+    .toLowerCase()
+    .replace(/-/g, "_");
+  return SELLER_STATUS_MAP[key] || "unknown";
+}
+
+export function sellerStatusTone(status: string | undefined | null): StatusTone {
+  return statusTone(formatSellerStatus(status));
+}
+
+// Inlined browser bundle — emits a self-invoking function that
+// attaches the same formatter API to `window.__tbFmt`. The HTML
+// served by `tb-admin ui` includes this bundle verbatim so the
+// page can use the shared spec-compliant helpers without an
+// extra <script src> round-trip. The JS bodies below MUST stay
+// in lockstep with the TS implementations above.
+export function displayFormatBundle(): string {
+  return `(() => {
+const UNKNOWN_VALUE = ${JSON.stringify(UNKNOWN_VALUE)};
+const PAD2 = (n) => (n < 10 ? "0" + n : "" + n);
+function formatTokenCount(value, options) {
+  options = options || {};
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  const numeric = value;
+  if (options.compact === false) return Math.round(numeric).toLocaleString("en-US");
+  if (numeric < 10000) return Math.round(numeric).toLocaleString("en-US");
+  if (numeric < 1000000) return (numeric / 1000).toFixed(1) + "K";
+  if (numeric < 1000000000) return (numeric / 1000000).toFixed(1) + "M";
+  return (numeric / 1000000000).toFixed(2) + "B";
+}
+function formatTokenPair(input, output, options) {
+  options = options || {};
+  const separator = options.separator == null ? " / " : options.separator;
+  return "In " + formatTokenCount(input, options) + separator + "Out " + formatTokenCount(output, options);
+}
+function formatCount(value) {
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  return Math.round(value).toLocaleString("en-US");
+}
+function formatMoney(micros, options) {
+  options = options || {};
+  if (!Number.isFinite(micros)) return UNKNOWN_VALUE;
+  const amount = Math.abs(micros / 1000000);
+  const digits = options.digits != null ? options.digits : (options.ledger && amount < 0.01 ? 6 : 4);
+  const formatted = "$" + (micros / 1000000).toFixed(digits);
+  return options.signed && micros >= 0 ? "+" + formatted : formatted;
+}
+function formatMoneyPair(actualMicros, referenceMicros, options) {
+  options = options || {};
+  if (!Number.isFinite(actualMicros) && !Number.isFinite(referenceMicros)) return UNKNOWN_VALUE;
+  return formatMoney(actualMicros, options) + " / " + formatMoney(referenceMicros, options);
+}
+function formatDuration(valueMs) {
+  if (!Number.isFinite(valueMs)) return UNKNOWN_VALUE;
+  const ms = Math.max(0, Math.round(valueMs));
+  if (ms < 1000) return ms + "ms";
+  return (ms / 1000).toFixed(2) + "s";
+}
+function formatPercent(value) {
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  return Math.round(value * 100) + "%";
+}
+function formatDiscountRatio(discountRatio) {
+  if (!Number.isFinite(discountRatio)) return UNKNOWN_VALUE;
+  const discount = Math.max(0, 1 - discountRatio);
+  return formatPercent(discount);
+}
+function formatPriceMicrosPerMillion(value) { return formatMoney(value, { digits: 4 }); }
+function formatPricePair(inputMicros, outputMicros) { return formatMoneyPair(inputMicros, outputMicros, { digits: 4 }); }
+function normalizeStatusLabel(status) {
+  if (!status) return UNKNOWN_VALUE;
+  return String(status).trim().toLowerCase().replaceAll("_", " ");
+}
+function statusTone(status) {
+  const n = normalizeStatusLabel(status);
+  if (n === "ok" || n === "online" || n === "configured" || n === "settled" || n === "completed" || n === "success" || n === "active" || n === "healthy") return "green";
+  if (n === "fallback" || n === "pending" || n === "degraded" || n === "preview" || n === "draining" || n === "busy capacity" || n === "auth unknown") return "amber";
+  if (n === "failed" || n === "error" || n === "canceled" || n === "unhealthy" || n === "offline") return "red";
+  if (n === "running") return "blue";
+  return "gray";
+}
+function formatHash(value, length) {
+  if (length == null) length = 32;
+  if (!value) return UNKNOWN_VALUE;
+  return value.length > length ? value.slice(0, length) + "..." : value;
+}
+function formatSellerId(value) {
+  if (!value) return UNKNOWN_VALUE;
+  if (value.startsWith("tbs-") && value.length > 10) return value.slice(0, 10);
+  if (value.length <= 12) return value;
+  return value.slice(0, 12);
+}
+function formatTimeCompact(iso) {
+  if (!iso) return UNKNOWN_VALUE;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return UNKNOWN_VALUE;
+  const now = new Date();
+  const sameDay = d.getFullYear() === now.getFullYear() && d.getMonth() === now.getMonth() && d.getDate() === now.getDate();
+  const time = PAD2(d.getHours()) + ":" + PAD2(d.getMinutes());
+  if (sameDay) return time;
+  return PAD2(d.getMonth() + 1) + "/" + PAD2(d.getDate()) + " " + time;
+}
+function formatTimeFull(iso) {
+  if (!iso) return UNKNOWN_VALUE;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return UNKNOWN_VALUE;
+  return d.getFullYear() + "-" + PAD2(d.getMonth() + 1) + "-" + PAD2(d.getDate()) + " " + PAD2(d.getHours()) + ":" + PAD2(d.getMinutes()) + ":" + PAD2(d.getSeconds());
+}
+function formatTimeLedger(iso) {
+  if (!iso) return UNKNOWN_VALUE;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return UNKNOWN_VALUE;
+  return d.getFullYear() + "/" + PAD2(d.getMonth() + 1) + "/" + PAD2(d.getDate()) + " " + PAD2(d.getHours()) + ":" + PAD2(d.getMinutes()) + ":" + PAD2(d.getSeconds());
+}
+function formatRouteSwitchTime(iso) { return formatTimeCompact(iso); }
+function formatBalanceAmount(usdMicros, currency) {
+  if (!Number.isFinite(usdMicros)) return UNKNOWN_VALUE;
+  const amount = usdMicros / 1000000;
+  const digits = Math.abs(amount) >= 100 ? 0 : 2;
+  const code = (currency || "USD").toUpperCase();
+  return code + " " + amount.toFixed(digits);
+}
+function formatSellerCapacity(used, limit) {
+  if (!Number.isFinite(used) && !Number.isFinite(limit)) return UNKNOWN_VALUE;
+  const u = Number.isFinite(used) ? Math.round(used) : UNKNOWN_VALUE;
+  const l = Number.isFinite(limit) ? Math.round(limit) : UNKNOWN_VALUE;
+  return u + " / " + l;
+}
+function formatSpeed(value) {
+  if (!Number.isFinite(value)) return UNKNOWN_VALUE;
+  return value.toFixed(1) + " tok/s";
+}
+const SELLER_STATUS_MAP = {
+  active: "ok", healthy: "ok", online: "online", configured: "configured",
+  pending: "pending", draining: "degraded", degraded: "degraded",
+  busy_capacity: "degraded", offline: "error", unhealthy: "error",
+  error: "error", auth_unknown: "unknown", unknown: "unknown"
+};
+function formatSellerStatus(status) {
+  const key = String(status || "unknown").trim().toLowerCase().replace(/-/g, "_");
+  return SELLER_STATUS_MAP[key] || "unknown";
+}
+function sellerStatusTone(status) { return statusTone(formatSellerStatus(status)); }
+window.__tbFmt = {
+  UNKNOWN_VALUE, formatTokenCount, formatTokenPair, formatCount, formatMoney, formatMoneyPair,
+  formatDuration, formatPercent, formatDiscountRatio, formatPriceMicrosPerMillion, formatPricePair,
+  normalizeStatusLabel, statusTone, formatHash, formatSellerId, formatTimeCompact, formatTimeFull,
+  formatTimeLedger, formatRouteSwitchTime, formatBalanceAmount, formatSellerCapacity, formatSpeed,
+  formatSellerStatus, sellerStatusTone
+};
+})();`;
+}

package/src/server-cmd.ts

@@ -1,6 +1,25 @@
-import { execSync } from "child_process";
+import { execSync, spawnSync, type SpawnSyncReturns } from "child_process";
+import * as fs from "fs";
 import { SellerProviderConfig } from "./config.js";
 
+type ExecRunner = (command: string, options?: Parameters<typeof execSync>[1]) => string | Buffer;
+type SpawnRunner = (command: string, args?: string[], options?: Parameters<typeof spawnSync>[2]) => SpawnSyncReturns<string | Buffer>;
+
+export interface DockerImageInspection {
+  ok: boolean;
+  error?: string;
+  exitCode?: number;
+}
+
+export type ImageInspectRunner = (image: string) => DockerImageInspection;
+
+export interface FlyProviderRuntime {
+  checkFlyctlInstalled?: (flyctlPath?: string) => boolean;
+  execSync?: ExecRunner;
+  spawnSync?: SpawnRunner;
+  imageInspector?: ImageInspectRunner;
+}
+
 /**
  * 检查 flyctl 是否在 PATH 中（或在指定路径）。
  *
@@ -16,6 +35,41 @@ export function checkFlyctlInstalled(flyctlPath?: string): boolean {
   }
 }
 
+export function inspectDockerImage(image: string): DockerImageInspection {
+  const result = spawnSync("docker", ["buildx", "imagetools", "inspect", image], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return dockerImageInspectionFromResult(result);
+}
+
+export function requirePublishedDockerImage(image: string, inspectImage: ImageInspectRunner = inspectDockerImage): void {
+  const inspection = inspectImage(image);
+  if (inspection.ok) {
+    return;
+  }
+  const detail = inspection.error ? ` Detail: ${inspection.error.trim()}` : "";
+  throw new Error(
+    `seller image is not published or is not accessible: ${image}. ` +
+    `Publish it first with RELEASE_VERSION=<v> bash scripts/release/all.sh, or pass an existing registry.fly.io/tb-seller:<v> tag. ` +
+    `No Fly app was created.${detail}`
+  );
+}
+
+function dockerImageInspectionFromResult(result: SpawnSyncReturns<string>): DockerImageInspection {
+  if (result.error) {
+    return { ok: false, error: result.error.message };
+  }
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      exitCode: result.status ?? undefined,
+      error: (result.stderr || result.stdout || "").toString()
+    };
+  }
+  return { ok: true };
+}
+
 export function parseFlyMachineIds(json: string, app: string): string[] {
   let parsed: unknown;
   try {
@@ -60,6 +114,7 @@ export interface SellerCreateOptions {
   volumeSizeGb?: number;
   volumeId?: string;
   volumeSnapshotRetentionDays?: number;
+  initialConfigPath?: string;
   dryRun?: boolean;
 }
 
@@ -69,23 +124,57 @@ export interface SellerCreateOptions {
  */
 export class FlyProvider {
   private providerConfig?: SellerProviderConfig;
+  private readonly runtime: Required<FlyProviderRuntime>;
 
-  constructor(providerConfig?: SellerProviderConfig) {
+  constructor(providerConfig?: SellerProviderConfig, runtime?: FlyProviderRuntime) {
     this.providerConfig = providerConfig;
+    this.runtime = {
+      checkFlyctlInstalled,
+      execSync,
+      spawnSync,
+      imageInspector: inspectDockerImage,
+      ...runtime
+    };
   }
 
   private get flyctl(): string {
     return this.providerConfig?.flyctl_path || "flyctl";
   }
 
+  private flyExecOptions(options: Parameters<typeof execSync>[1] = {}): Parameters<typeof execSync>[1] {
+    return {
+      ...options,
+      env: this.flyEnv(options.env)
+    };
+  }
+
+  private flySpawnOptions(options: Parameters<typeof spawnSync>[2] = {}): Parameters<typeof spawnSync>[2] {
+    return {
+      ...options,
+      env: this.flyEnv(options.env)
+    };
+  }
+
+  private flyEnv(env: NodeJS.ProcessEnv | undefined): NodeJS.ProcessEnv {
+    const configuredToken = this.providerConfig?.token;
+    const merged = {
+      ...process.env,
+      ...(env || {})
+    };
+    if (configuredToken && !merged.FLY_API_TOKEN) {
+      merged.FLY_API_TOKEN = configuredToken;
+    }
+    return merged;
+  }
+
   /**
    * List apps on Fly.io
    */
   public listApps(): string {
-    if (!checkFlyctlInstalled(this.flyctl)) {
+    if (!this.runtime.checkFlyctlInstalled(this.flyctl)) {
       throw new Error(`\`${this.flyctl}\` is not installed on your system PATH.`);
     }
-    return execSync(`${this.flyctl} apps list`, { encoding: "utf8" });
+    return this.runtime.execSync(`${this.flyctl} apps list`, this.flyExecOptions({ encoding: "utf8" })) as string;
   }
 
   /**
@@ -112,6 +201,7 @@ export class FlyProvider {
       || 1;
     const volumeSnapshotRetentionDays = options.volumeSnapshotRetentionDays;
     const volumeId = options.volumeId;
+    const initialConfigPath = options.initialConfigPath;
 
     if (!targetImage) {
       throw new Error("seller create requires --image registry.fly.io/tb-seller:<v>");
@@ -129,35 +219,59 @@ export class FlyProvider {
         `  Volume: ${volumeName} (${volumeSizeGb}GB)`,
       ];
       if (flyConfig) lines.push(`  Fly config: ${flyConfig}`);
+      if (initialConfigPath) lines.push(`  Initial config secret: TOKENBUDDY_SELLER_CONFIG_B64 from ${initialConfigPath}`);
       if (volumeId) lines.push(`  Volume ID: ${volumeId}`);
       if (volumeSnapshotRetentionDays !== undefined) lines.push(`  Volume snapshot retention: ${volumeSnapshotRetentionDays} days`);
       return lines.join("\n");
     }
 
-    if (!checkFlyctlInstalled(this.flyctl)) {
+    if (!this.runtime.checkFlyctlInstalled(this.flyctl)) {
       throw new Error(`\`${this.flyctl}\` is not installed on PATH.`);
     }
 
     if (!operatorSecret) {
       throw new Error("operator_secret is required. Provide --operator-secret or configure seller_providers.fly.operator_secret");
     }
+    requireReadableFile(flyConfig, "Fly config");
+    if (initialConfigPath) {
+      requireReadableFile(initialConfigPath, "Initial seller config");
+    }
+    requirePublishedDockerImage(targetImage, this.runtime.imageInspector);
 
     console.log(`[Fly.io] Creating app ${appName}...`);
-    execSync(`${this.flyctl} apps create ${appName} --machines`, { stdio: "inherit" });
+    this.runtime.execSync(`${this.flyctl} apps create ${appName} --machines`, this.flyExecOptions({ stdio: "inherit" }));
 
     console.log(`[Fly.io] Setting secrets...`);
-    execSync(
-      `${this.flyctl} secrets set ALLOW_MOCK=false OPERATOR_SECRET=${operatorSecret} --app ${appName}`,
-      { stdio: "inherit" }
-    );
+    this.importCreateSecrets(appName, operatorSecret, initialConfigPath);
 
     console.log(`[Fly.io] Deploying image ${targetImage}...`);
-    const deployCmd = `${this.flyctl} deploy -c ${flyConfig} --image ${targetImage} --region ${targetRegion} --app ${appName} --now`;
-    execSync(deployCmd, { stdio: "inherit" });
+    const deployCmd = `${this.flyctl} deploy -c ${flyConfig} --image ${targetImage} --primary-region ${targetRegion} --app ${appName} --now`;
+    this.runtime.execSync(deployCmd, this.flyExecOptions({ stdio: "inherit" }));
 
     return `Successfully deployed ${appName} on Fly.io`;
   }
 
+  private importCreateSecrets(appName: string, operatorSecret: string, initialConfigPath: string | undefined): void {
+    const lines = [
+      "ALLOW_MOCK=false",
+      `OPERATOR_SECRET=${operatorSecret}`
+    ];
+    if (initialConfigPath) {
+      const configContent = fs.readFileSync(initialConfigPath, "utf8");
+      lines.push(`TOKENBUDDY_SELLER_CONFIG_B64=${Buffer.from(configContent, "utf8").toString("base64")}`);
+    }
+    const result = this.runtime.spawnSync(this.flyctl, ["secrets", "import", "--stage", "--app", appName], this.flySpawnOptions({
+      input: `${lines.join("\n")}\n`,
+      stdio: ["pipe", "inherit", "inherit"]
+    }));
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      throw new Error(`flyctl secrets import failed with exit code ${result.status}`);
+    }
+  }
+
   /**
    * Destroy a seller app on Fly.io.
    * @param nameOrApp  Either a bare name (e.g. "86d81e") or a full app name (e.g. "tbs-86d81e").
@@ -170,12 +284,12 @@ export class FlyProvider {
       return `[DRY-RUN] Will destroy fly app: ${appName}`;
     }
 
-    if (!checkFlyctlInstalled(this.flyctl)) {
+    if (!this.runtime.checkFlyctlInstalled(this.flyctl)) {
       throw new Error(`\`${this.flyctl}\` is not installed.`);
     }
 
     console.log(`[Fly.io] Destroying app ${appName}...`);
-    execSync(`${this.flyctl} apps destroy ${appName} --yes`, { stdio: "inherit" });
+    this.runtime.execSync(`${this.flyctl} apps destroy ${appName} --yes`, this.flyExecOptions({ stdio: "inherit" }));
 
     return `Successfully destroyed ${appName} on Fly.io`;
   }
@@ -185,10 +299,10 @@ export class FlyProvider {
    */
   public statusApp(name: string): string {
     const appName = name.includes("-") ? name : `tb-seller-${name}`;
-    if (!checkFlyctlInstalled(this.flyctl)) {
+    if (!this.runtime.checkFlyctlInstalled(this.flyctl)) {
       throw new Error(`\`${this.flyctl}\` is not installed.`);
     }
-    return execSync(`${this.flyctl} status --app ${appName}`, { encoding: "utf8" });
+    return this.runtime.execSync(`${this.flyctl} status --app ${appName}`, this.flyExecOptions({ encoding: "utf8" })) as string;
   }
 
   /**
@@ -218,20 +332,31 @@ export class FlyProvider {
       return lines.join("\n");
     }
 
-    if (!checkFlyctlInstalled(this.flyctl)) {
+    if (!this.runtime.checkFlyctlInstalled(this.flyctl)) {
       throw new Error(`\`${this.flyctl}\` is not installed.`);
     }
 
-    const machinesJson = execSync(`${this.flyctl} machines list --app ${app} --json`, { encoding: "utf8" });
+    const machinesJson = this.runtime.execSync(`${this.flyctl} machines list --app ${app} --json`, this.flyExecOptions({ encoding: "utf8" })) as string;
     const machineIds = parseFlyMachineIds(machinesJson, app);
 
     console.log(`[Fly.io] Updating ${app} image on ${machineIds.length} machine(s)...`);
     for (const machineId of machineIds) {
-      execSync(
+      this.runtime.execSync(
         `${this.flyctl} machine update ${machineId} --app ${app} --image ${targetImage} --yes`,
-        { stdio: "inherit" }
+        this.flyExecOptions({ stdio: "inherit" })
       );
     }
     return `Successfully updated ${app} image`;
   }
 }
+
+function requireReadableFile(filePath: string, label: string): void {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`${label} file does not exist: ${filePath}`);
+  }
+  const stat = fs.statSync(filePath);
+  if (!stat.isFile()) {
+    throw new Error(`${label} path is not a file: ${filePath}`);
+  }
+  fs.accessSync(filePath, fs.constants.R_OK);
+}