@tokenbuddy/tb-admin 1.0.14 → 1.0.27

package/dist/src/ui-actions.js

@@ -0,0 +1,823 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import YAML from "js-yaml";
+import { AdminUiState } from "./ui-state.js";
+export class UiActions {
+    state;
+    options;
+    commandRunner;
+    constructor(options) {
+        this.options = options;
+        this.commandRunner = options.commandRunner;
+        this.state = new AdminUiState(options);
+    }
+    async updateSellerConfig(id, patch) {
+        const { entry, profileName, config } = await this.state.rawSellerConfig(id);
+        const next = mergeSellerConfigPatch(config, patch);
+        return this.withTempYaml(next, async (filePath) => {
+            const validateArgs = profileName
+                ? profileArgs(this.options, profileName, ["seller-config", "validate", "--file", filePath])
+                : sellerOperatorArgs(this.options, entry, ["seller-config", "validate", "--file", filePath]);
+            const validate = await this.runAdmin(validateArgs, 30000);
+            if (!validate.ok) {
+                return validate;
+            }
+            const putArgs = profileName
+                ? profileArgs(this.options, profileName, ["seller-config", "put", "--file", filePath])
+                : sellerOperatorArgs(this.options, entry, ["seller-config", "put", "--file", filePath]);
+            return this.runAdmin(putArgs, 30000);
+        });
+    }
+    async createSeller(request, progress) {
+        const normalizedRequest = normalizeCreateSellerRequest(request);
+        const report = progress || (() => undefined);
+        validateCreateSellerRequest(normalizedRequest);
+        report({ stepId: "check_registry", status: "running", title: "Check bootstrap registry", message: "Checking seller name conflicts before creating Fly resources." });
+        const registry = await this.state.fetchRegistry();
+        const appName = normalizedRequest.app || normalizedRequest.sellerName;
+        const conflict = registry.sellers.find((seller) => {
+            return seller.id === normalizedRequest.sellerName || seller.name === normalizedRequest.sellerName || seller.app === appName;
+        });
+        if (conflict) {
+            throw new Error(`seller \`${normalizedRequest.sellerName}\` already exists in bootstrap registry`);
+        }
+        report({ stepId: "check_registry", status: "succeeded", title: "Check bootstrap registry", message: "No registry conflict found." });
+        const provider = this.options.configManager.getSellerProvider("fly");
+        const operatorSecret = normalizedRequest.operatorSecret || provider?.operator_secret;
+        const flyConfig = normalizedRequest.flyConfig;
+        if (!operatorSecret) {
+            throw new Error("operatorSecret is required in local admin config seller_providers.fly.operator_secret or request body");
+        }
+        if (!flyConfig) {
+            throw new Error("flyConfig is required before creating a seller deployment");
+        }
+        const configRequest = {
+            ...normalizedRequest,
+            operatorSecret
+        };
+        return this.withTempYaml(initialSellerConfig(configRequest, false), async (filePath) => {
+            const normalizedUpstreamMessage = normalizedRequest.upstreamUrl !== request.upstreamUrl
+                ? `Normalized upstreamUrl to ${normalizedRequest.upstreamUrl} before validation.`
+                : "";
+            report({ stepId: "validate_config", status: "running", title: "Validate seller config", message: normalizedUpstreamMessage || "Validating generated seller config." });
+            const configValidation = await this.runAdmin(globalArgs(this.options, ["seller-config", "validate", "--file", filePath]), 30000);
+            report({
+                stepId: "validate_config",
+                status: configValidation.ok ? "succeeded" : "failed",
+                title: "Validate seller config",
+                message: configValidation.ok ? `${normalizedUpstreamMessage} Seller config is valid.`.trim() : "Seller config validation failed.",
+                result: configValidation
+            });
+            if (!configValidation.ok) {
+                return {
+                    result: configValidation,
+                    configValidation,
+                    configPreview: initialSellerConfig(configRequest, true),
+                    publishRegistry: "skipped"
+                };
+            }
+            const args = [
+                "seller",
+                "create",
+                normalizedRequest.sellerName,
+                "--region",
+                normalizedRequest.region,
+                "--image",
+                normalizedRequest.image,
+                "--fly-config",
+                flyConfig,
+                "--initial-config",
+                filePath,
+                "--operator-secret",
+                operatorSecret
+            ];
+            if (normalizedRequest.app) {
+                args.push("--app", normalizedRequest.app);
+            }
+            if (normalizedRequest.dryRun) {
+                args.push("--dry-run");
+            }
+            report({ stepId: "create_deployment", status: "running", title: "Create Fly deployment", message: `Creating ${appName} in ${normalizedRequest.region}.` });
+            const result = await this.runAdmin(globalArgs(this.options, args), 10 * 60 * 1000);
+            report({
+                stepId: "create_deployment",
+                status: result.ok ? "succeeded" : "failed",
+                title: "Create Fly deployment",
+                message: result.ok ? "Fly deployment command completed." : "Fly deployment command failed.",
+                result
+            });
+            let configPut;
+            let modelsRefresh;
+            let readiness;
+            if (result.ok && !normalizedRequest.dryRun) {
+                readiness = await this.waitForSellerReady(appName, operatorSecret, report);
+                if (!readiness.ok) {
+                    return {
+                        result,
+                        configValidation,
+                        readiness,
+                        configPreview: initialSellerConfig(configRequest, true),
+                        publishRegistry: "skipped"
+                    };
+                }
+                report({ stepId: "apply_config", status: "running", title: "Apply seller config", message: `Writing config to ${sellerOperatorUrl(appName)}.` });
+                configPut = await this.runAdmin(globalArgs({
+                    ...this.options,
+                    profile: undefined,
+                    url: sellerOperatorUrl(appName),
+                    token: operatorSecret
+                }, ["seller-config", "put", "--file", filePath]), 30000);
+                report({
+                    stepId: "apply_config",
+                    status: configPut.ok ? "succeeded" : "failed",
+                    title: "Apply seller config",
+                    message: configPut.ok ? "Seller config was written to the deployment." : "Seller config write failed.",
+                    result: configPut
+                });
+                if (configPut.ok) {
+                    report({ stepId: "refresh_models", status: "running", title: "Refresh upstream models", message: `Refreshing model catalog from ${sellerOperatorUrl(appName)}.` });
+                    modelsRefresh = await this.refreshSellerModelsWithRetry(appName, operatorSecret, report);
+                    report({
+                        stepId: "refresh_models",
+                        status: modelsRefresh.ok ? "succeeded" : "failed",
+                        title: "Refresh upstream models",
+                        message: modelsRefresh.ok ? "Upstream model catalog was refreshed." : "Upstream model refresh failed.",
+                        result: modelsRefresh
+                    });
+                }
+            }
+            else if (normalizedRequest.dryRun) {
+                report({ stepId: "apply_config", status: "skipped", title: "Apply seller config", message: "Skipped because this is a dry run." });
+                report({ stepId: "refresh_models", status: "skipped", title: "Refresh upstream models", message: "Skipped because this is a dry run." });
+            }
+            const registryPublish = await this.publishCreatedSellerRegistryEntry({
+                registry,
+                request: normalizedRequest,
+                appName,
+                operatorSecret,
+                enabled: Boolean(result.ok && !normalizedRequest.dryRun && readiness?.ok && configPut?.ok && modelsRefresh?.ok),
+                report
+            });
+            if (registryPublish?.ok) {
+                this.options.configManager.setProfile(appName, {
+                    url: sellerOperatorUrl(appName),
+                    token: operatorSecret
+                });
+            }
+            return {
+                result,
+                configValidation,
+                readiness,
+                configPut,
+                modelsRefresh,
+                registryPublish,
+                configPreview: initialSellerConfig(configRequest, true),
+                publishRegistry: registryPublish ? (registryPublish.ok ? "completed" : "failed") : "skipped"
+            };
+        });
+    }
+    async setRegistryStatus(id, status) {
+        const registry = await this.state.fetchRegistry();
+        const target = registry.sellers.find((seller) => seller.id === id || seller.name === id || seller.app === id);
+        if (!target) {
+            throw new Error(`seller \`${id}\` not found in bootstrap registry`);
+        }
+        return this.runAdmin(globalArgs(this.options, [
+            "bootstrap",
+            "sellers",
+            "status",
+            target.id,
+            status,
+            "--expect-version",
+            String(registry.version)
+        ]), 30000);
+    }
+    async deleteDeployment(id, confirm) {
+        const registry = await this.state.fetchRegistry();
+        const target = registry.sellers.find((seller) => seller.id === id || seller.name === id || seller.app === id);
+        if (!target) {
+            throw new Error(`seller \`${id}\` not found in bootstrap registry`);
+        }
+        const app = target.app || target.id || target.name;
+        const args = ["seller", "remove", app, "--app", app];
+        if (!confirm) {
+            args.push("--dry-run");
+        }
+        return this.runAdmin(globalArgs(this.options, args), confirm ? 10 * 60 * 1000 : 30000);
+    }
+    async withTempYaml(document, callback) {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tb-admin-ui-"));
+        const filePath = path.join(dir, "seller-config.yaml");
+        try {
+            fs.writeFileSync(filePath, YAML.dump(document, { lineWidth: 120, noRefs: true, sortKeys: false }), "utf8");
+            return await callback(filePath);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    async withTempJson(document, callback) {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "tb-admin-ui-"));
+        const filePath = path.join(dir, "registry.json");
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(document, null, 2), "utf8");
+            return await callback(filePath);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    runAdmin(args, timeoutMs) {
+        if (this.commandRunner) {
+            return this.commandRunner(args, timeoutMs);
+        }
+        return runTbAdmin(args, timeoutMs);
+    }
+    async waitForSellerReady(appName, operatorSecret, report) {
+        const maxAttempts = 18;
+        const delayMs = 5000;
+        let last;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            report({
+                stepId: "wait_seller",
+                status: "running",
+                title: "Wait for seller service",
+                message: `Waiting for operator API to become ready (${attempt}/${maxAttempts}).`
+            });
+            last = await this.runAdmin(globalArgs({
+                ...this.options,
+                profile: undefined,
+                url: sellerOperatorUrl(appName),
+                token: operatorSecret
+            }, ["status"]), 30000);
+            if (last.ok) {
+                report({
+                    stepId: "wait_seller",
+                    status: "succeeded",
+                    title: "Wait for seller service",
+                    message: "Seller operator API is ready.",
+                    result: last
+                });
+                return last;
+            }
+            if (attempt < maxAttempts) {
+                await sleep(delayMs);
+            }
+        }
+        const failed = last || {
+            ok: false,
+            stdout: "",
+            stderr: "seller service did not become ready",
+            command: []
+        };
+        report({
+            stepId: "wait_seller",
+            status: "failed",
+            title: "Wait for seller service",
+            message: "Seller operator API did not become ready before config write.",
+            result: failed
+        });
+        return failed;
+    }
+    async refreshSellerModelsWithRetry(appName, operatorSecret, report) {
+        const maxAttempts = 6;
+        const baseDelayMs = 3000;
+        let last;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            if (attempt > 1) {
+                report({
+                    stepId: "refresh_models",
+                    status: "running",
+                    title: "Refresh upstream models",
+                    message: `Retrying model catalog refresh (${attempt}/${maxAttempts}).`
+                });
+            }
+            last = await this.runAdmin(globalArgs({
+                ...this.options,
+                profile: undefined,
+                url: sellerOperatorUrl(appName),
+                token: operatorSecret
+            }, ["upstreams", "refresh", "--auto-models"]), 45000);
+            if (last.ok) {
+                return last;
+            }
+            if (attempt < maxAttempts) {
+                await sleep(baseDelayMs * attempt);
+            }
+        }
+        return last || {
+            ok: false,
+            stdout: "",
+            stderr: "model catalog refresh did not run",
+            command: ["tb-admin", "upstreams", "refresh", "--auto-models"]
+        };
+    }
+    async publishCreatedSellerRegistryEntry(options) {
+        const { registry, request, appName, operatorSecret, enabled, report } = options;
+        if (!enabled) {
+            report({
+                stepId: "publish_registry",
+                status: "skipped",
+                title: "Publish bootstrap registry",
+                message: "Skipped because the deployment workflow did not complete successfully."
+            });
+            return undefined;
+        }
+        report({
+            stepId: "publish_registry",
+            status: "running",
+            title: "Update bootstrap registry",
+            message: `Adding ${request.sellerName} to bootstrap registry.`
+        });
+        let entry;
+        try {
+            const upstreams = await this.fetchSellerOperatorJson(appName, operatorSecret, "/operator/admin/upstreams");
+            const service = await this.fetchSellerOperatorJson(appName, operatorSecret, "/operator/admin/service");
+            const manifest = await this.fetchSellerOperatorJsonOptional(appName, operatorSecret, "/manifest");
+            entry = registryEntryFromCreatedSeller(request, appName, upstreams, service, manifest);
+        }
+        catch (err) {
+            const failed = {
+                ok: false,
+                stdout: "",
+                stderr: redactSensitive(err.message || "failed to build bootstrap registry entry"),
+                command: ["fetch", `${sellerOperatorUrl(appName)}/operator/admin/upstreams`]
+            };
+            report({
+                stepId: "publish_registry",
+                status: "failed",
+                title: "Update bootstrap registry",
+                message: "Failed to read seller metadata for bootstrap registry.",
+                result: failed
+            });
+            return failed;
+        }
+        return this.withTempJson(entry, async (filePath) => {
+            const put = await this.runAdmin(globalArgs(this.options, [
+                "bootstrap",
+                "sellers",
+                "add",
+                "--file",
+                filePath,
+                "--expect-version",
+                String(registry.version)
+            ]), 30000);
+            report({
+                stepId: "publish_registry",
+                status: put.ok ? "succeeded" : "failed",
+                title: "Update bootstrap registry",
+                message: put.ok ? "Bootstrap registry entry was added. Run registry publish to update R2." : "Bootstrap registry update failed.",
+                result: put
+            });
+            return put;
+        });
+    }
+    async fetchSellerOperatorJson(appName, operatorSecret, pathName) {
+        const fetchJson = this.options.fetchJson || defaultFetchJson;
+        const response = await fetchJson(`${sellerOperatorUrl(appName)}${pathName}`, {
+            headers: { Authorization: `Bearer ${operatorSecret}` }
+        });
+        if (response && typeof response === "object" && !Array.isArray(response)) {
+            return response;
+        }
+        return {};
+    }
+    async fetchSellerOperatorJsonOptional(appName, operatorSecret, pathName) {
+        try {
+            return await this.fetchSellerOperatorJson(appName, operatorSecret, pathName);
+        }
+        catch {
+            return {};
+        }
+    }
+}
+function registryEntryFromCreatedSeller(request, appName, upstreams, service, manifest) {
+    const wrappedUpstreams = upstreamPayload(upstreams);
+    const models = modelIdsFrom(upstreams.models)
+        || modelIdsFrom(wrappedUpstreams?.models)
+        || modelIdsFrom(service.models)
+        || modelIdsFrom(manifest.models);
+    if (!models || models.length === 0) {
+        throw new Error("seller operator upstreams did not return models for bootstrap registry");
+    }
+    const supportedProtocols = supportedProtocolsFrom(service.supportedProtocols)
+        || supportedProtocolsFrom(upstreams.supportedProtocols)
+        || supportedProtocolsFrom(wrappedUpstreams?.supportedProtocols)
+        || supportedProtocolsFrom(manifest.supportedProtocols)
+        || supportedProtocolsFrom(manifest.supported_protocols)
+        || ["chat_completions"];
+    const paymentMethods = paymentMethodsFromRequest(request);
+    return {
+        id: appName,
+        name: appName,
+        app: appName,
+        url: sellerOperatorUrl(appName),
+        status: "active",
+        region: stringValue(request.region),
+        modelsCount: models.length || undefined,
+        sampleModels: models.slice(0, 5),
+        models,
+        supportedProtocols,
+        paymentMethods,
+        recommendedFor: models.slice(0, 5)
+    };
+}
+function modelIdsFrom(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return Array.from(new Set(value.map((entry) => {
+        if (typeof entry === "string") {
+            return entry;
+        }
+        if (entry && typeof entry === "object" && "id" in entry) {
+            const id = entry.id;
+            return typeof id === "string" && id.trim() ? id.trim() : undefined;
+        }
+        return undefined;
+    }).filter((entry) => Boolean(entry))));
+}
+function upstreamPayload(value) {
+    const wrapped = value.upstreams;
+    if (Array.isArray(wrapped)) {
+        return objectValue(wrapped[0]);
+    }
+    return objectValue(wrapped);
+}
+function supportedProtocolsFrom(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const protocols = value.map((entry) => stringValue(entry)).filter((entry) => Boolean(entry));
+    return protocols.length > 0 ? Array.from(new Set(protocols)) : undefined;
+}
+export function runTbAdmin(args, timeoutMs) {
+    const entry = adminEntryPath();
+    const command = [process.execPath, entry, ...args];
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [entry, ...args], {
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+        }, timeoutMs);
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({
+                ok: code === 0,
+                stdout: redactSensitive(stdout),
+                stderr: redactSensitive(stderr),
+                command: redactCommand(command)
+            });
+        });
+    });
+}
+async function defaultFetchJson(url, init) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP Error ${response.status}: ${redactSensitive(text || response.statusText)}`);
+    }
+    const text = await response.text();
+    return text ? JSON.parse(text) : {};
+}
+function adminEntryPath() {
+    const current = process.argv[1] || "";
+    if ((path.basename(current) === "tb-admin" || path.basename(current) === "tb-admin.js") && fs.existsSync(current)) {
+        return current;
+    }
+    const candidates = [
+        path.resolve(process.cwd(), "packages/admin-cli/bin/tb-admin.js"),
+        path.resolve(process.cwd(), "bin/tb-admin.js")
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[candidates.length - 1];
+}
+function globalArgs(options, args) {
+    const output = [];
+    if (options.configPath) {
+        output.push("--config", options.configPath);
+    }
+    if (options.profile) {
+        output.push("--profile", options.profile);
+    }
+    if (options.url) {
+        output.push("--url", options.url);
+    }
+    if (options.token) {
+        output.push("--token", options.token);
+    }
+    output.push(...args);
+    return output;
+}
+function profileArgs(options, profileName, args) {
+    return globalArgs({ ...options, profile: profileName, url: undefined, token: undefined }, args);
+}
+function sellerOperatorArgs(options, entry, args) {
+    const operatorSecret = options.configManager.getSellerProvider("fly")?.operator_secret;
+    if (!operatorSecret) {
+        throw new Error(`seller \`${entry.id}\` has no local profile and seller_providers.fly.operator_secret is not configured`);
+    }
+    return globalArgs({
+        ...options,
+        profile: undefined,
+        url: entry.url,
+        token: operatorSecret
+    }, args);
+}
+function mergeSellerConfigPatch(config, patch) {
+    const next = { ...config };
+    copyIfPresent(next, patch, "upstreamUrl");
+    copyIfPresent(next, patch, "upstreamApiKey");
+    applyBalanceProbePatch(next, patch);
+    copyIfPresent(next, patch, "upstreamBalanceUrl");
+    copyIfPresent(next, patch, "upstreamUserId");
+    copyIfPresent(next, patch, "upstreamRechargeUrl");
+    copyIfPresent(next, patch, "markupRatio");
+    copyIfPresent(next, patch, "discountRatio");
+    copyIfPresent(next, patch, "maxConnections");
+    copyIfPresent(next, patch, "maxQueueDepth");
+    if (Array.isArray(patch.models)) {
+        next.models = patch.models;
+    }
+    if (patch.modelAliases && typeof patch.modelAliases === "object" && !Array.isArray(patch.modelAliases)) {
+        next.modelAliases = patch.modelAliases;
+    }
+    return next;
+}
+function copyIfPresent(target, source, key) {
+    if (source[key] !== undefined) {
+        target[key] = source[key];
+    }
+}
+function validateCreateSellerRequest(request) {
+    requireString(request.sellerName, "sellerName");
+    requireString(request.region, "region");
+    requireString(request.image, "image");
+    requireString(request.upstreamWebsite, "upstreamWebsite");
+    requireString(request.upstreamUrl, "upstreamUrl");
+    requireString(request.upstreamApiKey, "upstreamApiKey");
+    if (stringValue(request.upstreamBalanceProbeTemplate) !== "none") {
+        requireString(balanceProbeUrl(request), "upstreamBalanceProbeUrl");
+    }
+    requirePositiveInteger(request.maxConnections, "maxConnections");
+    requirePositiveInteger(request.maxQueueDepth, "maxQueueDepth");
+    requireFiniteNumber(request.markupRatio, "markupRatio");
+    requireFiniteNumber(request.discountRatio, "discountRatio");
+    const paymentMethods = paymentMethodsFromRequest(request);
+    const invalidPaymentMethod = paymentMethods.find((method) => !["clawtip", "mock"].includes(method));
+    if (invalidPaymentMethod) {
+        throw new Error("paymentMethods must contain only clawtip or mock");
+    }
+    if (paymentMethods.includes("clawtip")) {
+        requireString(request.clawtipPayTo, "clawtipPayTo");
+        requireString(request.clawtipSm4KeyBase64, "clawtipSm4KeyBase64");
+    }
+}
+function normalizeCreateSellerRequest(request) {
+    const upstreamUrl = stripTrailingV1(request.upstreamUrl);
+    const app = stringValue(request.app) || request.sellerName;
+    const normalized = {
+        ...request,
+        app,
+        image: stringValue(request.image) || "registry.fly.io/tb-seller:latest",
+        flyConfig: stringValue(request.flyConfig) || "deploy/fly.io/fly.tb-seller.toml",
+        upstreamUrl
+    };
+    if (paymentMethodsFromRequest(normalized).includes("clawtip")) {
+        normalized.clawtipSkillSlug = stringValue(normalized.clawtipSkillSlug) || app;
+        normalized.clawtipSkillId = stringValue(normalized.clawtipSkillId) || `si-${app}`;
+        normalized.clawtipDescription = stringValue(normalized.clawtipDescription) || `TokenBuddy Seller ${request.sellerName}`;
+        normalized.clawtipResourceUrl = stringValue(normalized.clawtipResourceUrl) || sellerOperatorUrl(app);
+        normalized.clawtipActivationFeeFen = Number(normalized.clawtipActivationFeeFen || 1);
+        normalized.clawtipMicrosPerFen = Number(normalized.clawtipMicrosPerFen || 10000);
+    }
+    return normalized;
+}
+function initialSellerConfig(request, masked) {
+    const upstreamBalanceProbe = balanceProbeConfigFromRequest(request);
+    const upstreamBalanceUrl = balanceProbeUrl(request);
+    const upstreamUserId = balanceProbeUserId(request);
+    const upstreamRechargeUrl = balanceProbeRechargeUrl(request);
+    const paymentConfig = paymentConfigFromRequest(request, masked);
+    return {
+        sellerId: request.app || request.sellerName,
+        manifestVersion: "manifest.v1",
+        upstreamUrl: request.upstreamUrl,
+        upstreamApiKey: masked ? "********" : request.upstreamApiKey,
+        upstreamWebsite: request.upstreamWebsite,
+        upstreamBalanceUrl,
+        upstreamUserId,
+        upstreamRechargeUrl,
+        upstreamBalanceProbe,
+        maxConnections: request.maxConnections,
+        maxQueueDepth: request.maxQueueDepth,
+        markupRatio: request.markupRatio,
+        discountRatio: request.discountRatio,
+        operatorSecret: masked ? "********" : stringValue(request.operatorSecret),
+        ...paymentConfig
+    };
+}
+function paymentConfigFromRequest(request, masked) {
+    const paymentMethods = paymentMethodsFromRequest(request);
+    const config = {
+        allowMock: paymentMethods.includes("mock")
+    };
+    if (!paymentMethods.includes("clawtip")) {
+        return config;
+    }
+    return {
+        ...config,
+        clawtip: {
+            payTo: stringValue(request.clawtipPayTo),
+            sm4KeyBase64: masked ? "********" : stringValue(request.clawtipSm4KeyBase64),
+            skillSlug: stringValue(request.clawtipSkillSlug),
+            skillId: stringValue(request.clawtipSkillId),
+            description: stringValue(request.clawtipDescription),
+            resourceUrl: stringValue(request.clawtipResourceUrl),
+            activationFeeFen: Number(request.clawtipActivationFeeFen),
+            microsPerFen: Number(request.clawtipMicrosPerFen)
+        }
+    };
+}
+function paymentMethodsFromRequest(request) {
+    const values = request.paymentMethods !== undefined
+        ? arrayStringValues(request.paymentMethods)
+        : legacyPaymentMethodsFromRequest(request);
+    return Array.from(new Set(values));
+}
+function legacyPaymentMethodsFromRequest(request) {
+    const paymentMethod = stringValue(request.paymentMethod);
+    if (paymentMethod === "none") {
+        return [];
+    }
+    return [paymentMethod || "clawtip"];
+}
+function arrayStringValues(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => stringValue(entry)).filter((entry) => Boolean(entry));
+    }
+    const single = stringValue(value);
+    return single ? single.split(",").map((entry) => entry.trim()).filter(Boolean) : [];
+}
+function applyBalanceProbePatch(target, patch) {
+    const template = stringValue(patch.upstreamBalanceProbeTemplate);
+    const url = stringValue(patch.upstreamBalanceProbeUrl) || stringValue(patch.upstreamBalanceUrl);
+    const userId = stringValue(patch.upstreamBalanceProbeUserId) || stringValue(patch.upstreamUserId);
+    const rechargeUrl = stringValue(patch.upstreamBalanceProbeRechargeUrl) || stringValue(patch.upstreamRechargeUrl);
+    if (template === undefined && url === undefined && userId === undefined && rechargeUrl === undefined) {
+        return;
+    }
+    const current = objectValue(target.upstreamBalanceProbe) || {};
+    target.upstreamBalanceProbe = {
+        ...current,
+        ...(template !== undefined ? { template } : {}),
+        ...(url !== undefined ? { url } : {}),
+        ...(userId !== undefined ? { userId } : {}),
+        ...(rechargeUrl !== undefined ? { rechargeUrl } : {})
+    };
+    if (url !== undefined) {
+        target.upstreamBalanceUrl = url;
+    }
+    if (userId !== undefined) {
+        target.upstreamUserId = userId;
+    }
+    if (rechargeUrl !== undefined) {
+        target.upstreamRechargeUrl = rechargeUrl;
+    }
+}
+function balanceProbeConfigFromRequest(request) {
+    return {
+        template: stringValue(request.upstreamBalanceProbeTemplate) || "auto",
+        url: balanceProbeUrl(request),
+        userId: balanceProbeUserId(request),
+        rechargeUrl: balanceProbeRechargeUrl(request)
+    };
+}
+function balanceProbeUrl(request) {
+    const explicit = stringValue(request.upstreamBalanceProbeUrl) || stringValue(request.upstreamBalanceUrl);
+    if (explicit) {
+        return explicit;
+    }
+    const template = stringValue(request.upstreamBalanceProbeTemplate) || "auto";
+    const upstreamUrl = stringValue(request.upstreamUrl);
+    const host = hostName(upstreamUrl);
+    if (template === "none") {
+        return undefined;
+    }
+    if (template === "openrouter") {
+        return "https://openrouter.ai/api/v1/credits";
+    }
+    if (template === "deepseek") {
+        return "https://api.deepseek.com/user/balance";
+    }
+    if (template === "stepfun") {
+        return "https://api.stepfun.com/v1/accounts";
+    }
+    if (template === "novita") {
+        return "https://api.novita.ai/v3/user/balance";
+    }
+    if (template === "siliconflow") {
+        return host.endsWith(".com") ? "https://api.siliconflow.com/v1/user/info" : "https://api.siliconflow.cn/v1/user/info";
+    }
+    if (template === "usage_generic") {
+        return upstreamUrl ? usageUrl(upstreamUrl) : undefined;
+    }
+    if (template === "auto") {
+        if (host === "api.deepseek.com") {
+            return "https://api.deepseek.com/user/balance";
+        }
+        if (host === "api.stepfun.ai" || host === "api.stepfun.com") {
+            return "https://api.stepfun.com/v1/accounts";
+        }
+        if (host === "api.siliconflow.cn") {
+            return "https://api.siliconflow.cn/v1/user/info";
+        }
+        if (host === "api.siliconflow.com") {
+            return "https://api.siliconflow.com/v1/user/info";
+        }
+        if (host === "openrouter.ai") {
+            return "https://openrouter.ai/api/v1/credits";
+        }
+        if (host === "api.novita.ai") {
+            return "https://api.novita.ai/v3/user/balance";
+        }
+        return upstreamUrl ? usageUrl(upstreamUrl) : undefined;
+    }
+    return undefined;
+}
+function balanceProbeUserId(request) {
+    return stringValue(request.upstreamBalanceProbeUserId) || stringValue(request.upstreamUserId);
+}
+function balanceProbeRechargeUrl(request) {
+    return stringValue(request.upstreamBalanceProbeRechargeUrl) || stringValue(request.upstreamRechargeUrl);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stripTrailingV1(value) {
+    return String(value || "").trim().replace(/\/v1\/?$/i, "");
+}
+function usageUrl(value) {
+    const base = String(value || "").trim().replace(/\/+$/, "");
+    return /\/v1$/i.test(base) ? `${base}/usage` : `${base}/v1/usage`;
+}
+function hostName(value) {
+    try {
+        return new URL(String(value || "")).hostname.toLowerCase();
+    }
+    catch {
+        return "";
+    }
+}
+function sellerOperatorUrl(appName) {
+    return `https://${appName}.fly.dev`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function requireString(value, field) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${field} is required`);
+    }
+}
+function requirePositiveInteger(value, field) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`${field} must be >= 1`);
+    }
+}
+function requireFiniteNumber(value, field) {
+    if (!Number.isFinite(Number(value))) {
+        throw new Error(`${field} must be a number`);
+    }
+}
+function redactCommand(command) {
+    return command.map((part, index) => {
+        const prev = command[index - 1];
+        if (prev === "--operator-secret" || prev === "--token" || prev === "--api-key") {
+            return "********";
+        }
+        return redactSensitive(part);
+    });
+}
+function redactSensitive(value) {
+    return value.replace(/(sk-[A-Za-z0-9_-]+)/g, "********")
+        .replace(/(operatorSecret|upstreamApiKey|token|apiKey|sm4KeyBase64|clawtipSm4KeyBase64)["'=:\s]+([^"',\s]+)/gi, "$1=********");
+}
+//# sourceMappingURL=ui-actions.js.map