@tokenbuddy/tb-admin 1.0.36 → 1.0.38

package/dist/src/init-command.js

@@ -0,0 +1,347 @@
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { resolveAdminWorkdir, resolveWorkdirPath } from "./workdir.js";
+import { flyIoProviderDefinition } from "./providers/fly-io.js";
+const providerDefinitions = {
+    "fly.io": flyIoProviderDefinition
+};
+const requiredWorkdirFiles = [
+    "tokenbuddy-admin-workdir.json",
+    "admin.toml",
+    "providers/fly.io.toml",
+    "env/deploy.env",
+    "fly/fly.tb-seller.toml",
+    "fly/fly.tb-registry.toml",
+    "deploy-secrets/seller-configs/seller.example.yaml",
+    "deploy-secrets/bootstrap/tb-registry.example.yaml"
+];
+function currentModuleDir() {
+    if (typeof __dirname !== "undefined") {
+        return __dirname;
+    }
+    const stack = new Error().stack || "";
+    const fileUrlMatch = stack.match(/(file:\/\/\/[^)\n]+\/init-command\.js):\d+:\d+/);
+    if (fileUrlMatch) {
+        return path.dirname(fileURLToPath(fileUrlMatch[1]));
+    }
+    const filePathMatch = stack.match(/(\/[^)\n]+\/init-command\.(?:js|ts)):\d+:\d+/);
+    if (filePathMatch) {
+        return path.dirname(filePathMatch[1]);
+    }
+    return process.cwd();
+}
+function readPackageJson(packageRoot) {
+    return JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+}
+function findAdminPackageRoot(startDir = currentModuleDir()) {
+    let current = path.resolve(startDir);
+    const seen = new Set();
+    while (!seen.has(current)) {
+        seen.add(current);
+        const packageJsonPath = path.join(current, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = readPackageJson(current);
+            if (packageJson.name === "@tokenbuddy/tb-admin") {
+                return current;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    throw new Error("Could not locate @tokenbuddy/tb-admin package root for templates");
+}
+function getProviderDefinition(provider) {
+    const id = (provider || "fly.io");
+    const definition = providerDefinitions[id];
+    if (!definition) {
+        throw new Error(`Unknown provider: ${provider}. Supported providers: ${Object.keys(providerDefinitions).join(", ")}`);
+    }
+    return definition;
+}
+function packageTemplateContext(definition, options) {
+    const packageRoot = options.packageRoot || findAdminPackageRoot();
+    const packageJson = readPackageJson(packageRoot);
+    const templateRoot = options.templateRoot || path.join(packageRoot, definition.templateRelativeRoot);
+    if (!fs.existsSync(templateRoot)) {
+        throw new Error(`Provider template directory not found: ${templateRoot}`);
+    }
+    return {
+        packageRoot,
+        packageVersion: options.packageVersion || String(packageJson.version || "0.0.0"),
+        templateRoot
+    };
+}
+function listTemplateFiles(root) {
+    const entries = fs.readdirSync(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            for (const child of listTemplateFiles(fullPath)) {
+                files.push(path.join(entry.name, child));
+            }
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(entry.name);
+        }
+    }
+    return files.sort();
+}
+function targetForTemplate(relativePath) {
+    if (relativePath === "admin.toml.example") {
+        return "admin.toml";
+    }
+    if (relativePath === "provider.toml.example") {
+        return "providers/fly.io.toml";
+    }
+    if (relativePath === "env/deploy.env.example") {
+        return "env/deploy.env";
+    }
+    return relativePath;
+}
+function isForceOverwritable(relativeTarget) {
+    return (relativeTarget.startsWith("fly/") ||
+        relativeTarget.endsWith(".example.yaml") ||
+        relativeTarget.endsWith(".example.json") ||
+        relativeTarget.endsWith(".example.env") ||
+        path.basename(relativeTarget) === "README.md");
+}
+function isPrivateTarget(relativeTarget) {
+    return (relativeTarget === "admin.toml" ||
+        relativeTarget === "env/deploy.env" ||
+        relativeTarget.startsWith("deploy-secrets/"));
+}
+function templateCopyPlans(templateRoot, workdir) {
+    return listTemplateFiles(templateRoot).map((relativeSource) => {
+        const relativeTarget = targetForTemplate(relativeSource);
+        return {
+            source: path.join(templateRoot, relativeSource),
+            target: resolveWorkdirPath(workdir, relativeTarget),
+            overwriteWithForce: isForceOverwritable(relativeTarget),
+            chmodPrivate: isPrivateTarget(relativeTarget)
+        };
+    });
+}
+function chmodPrivate(filePath) {
+    try {
+        fs.chmodSync(filePath, 0o600);
+    }
+    catch {
+        // Best effort only; chmod is not available on every platform.
+    }
+}
+function copyTemplates(templateRoot, workdir, force) {
+    const results = [];
+    for (const plan of templateCopyPlans(templateRoot, workdir)) {
+        const exists = fs.existsSync(plan.target);
+        if (exists && !(force && plan.overwriteWithForce)) {
+            results.push({ path: plan.target, status: "skipped" });
+            continue;
+        }
+        fs.mkdirSync(path.dirname(plan.target), { recursive: true });
+        fs.copyFileSync(plan.source, plan.target);
+        if (plan.chmodPrivate) {
+            chmodPrivate(plan.target);
+        }
+        results.push({ path: plan.target, status: exists ? "updated" : "created" });
+    }
+    return results;
+}
+function writeManifest(workdir, provider, templateVersion, now) {
+    const manifestPath = path.join(workdir, "tokenbuddy-admin-workdir.json");
+    const existed = fs.existsSync(manifestPath);
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    fs.writeFileSync(manifestPath, `${JSON.stringify({
+        schemaVersion: 1,
+        provider,
+        templateVersion,
+        createdBy: "@tokenbuddy/tb-admin",
+        createdAt: now.toISOString()
+    }, null, 2)}\n`, "utf8");
+    return {
+        path: manifestPath,
+        status: existed ? "updated" : "created"
+    };
+}
+function ensureWorkdirDirectories(workdir) {
+    for (const relative of ["providers", "env", "fly", "deploy-secrets/seller-configs", "deploy-secrets/bootstrap", "artifacts"]) {
+        fs.mkdirSync(path.join(workdir, relative), { recursive: true });
+    }
+}
+function checkContext(options) {
+    return {
+        env: options.env || process.env,
+        spawnSync: options.spawnSync || spawnSync
+    };
+}
+export function runAdminInitCommand(options = {}) {
+    const definition = getProviderDefinition(options.provider);
+    const workdir = resolveAdminWorkdir({
+        cliWorkdir: options.cliWorkdir,
+        env: options.env || process.env
+    });
+    const template = packageTemplateContext(definition, options);
+    const checks = definition.check(checkContext(options));
+    const files = [];
+    let install;
+    const flyMissing = checks.some((check) => check.id === "fly" && check.status === "missing");
+    if (options.installTools && flyMissing && definition.install) {
+        const installResult = definition.install({
+            ...checkContext(options),
+            dryRun: false
+        });
+        install = {
+            attempted: true,
+            ok: installResult.ok,
+            message: installResult.message
+        };
+    }
+    if (!options.checkOnly) {
+        ensureWorkdirDirectories(workdir);
+        files.push(...copyTemplates(template.templateRoot, workdir, Boolean(options.force)));
+        files.push(writeManifest(workdir, definition.id, template.packageVersion, options.now || new Date()));
+    }
+    return {
+        provider: definition.id,
+        workdir,
+        templateVersion: template.packageVersion,
+        checkOnly: Boolean(options.checkOnly),
+        checks,
+        files,
+        install,
+        next: [
+            `export TB_ADMIN_WORKDIR=${workdir}`,
+            `edit ${path.join(workdir, definition.defaultPaths.deployEnv)}`,
+            `edit ${path.join(workdir, "admin.toml")}`
+        ]
+    };
+}
+function fileCheck(id, label, filePath) {
+    return {
+        id,
+        label,
+        status: fs.existsSync(filePath) ? "ok" : "missing",
+        message: fs.existsSync(filePath) ? `${label} exists` : `${label} missing: ${filePath}`
+    };
+}
+function deploySecretsGitCheck(workdir, runner) {
+    const deploySecretsPath = path.join(workdir, "deploy-secrets");
+    if (!fs.existsSync(deploySecretsPath)) {
+        return {
+            id: "deploy-secrets-git",
+            label: "deploy-secrets git",
+            status: "missing",
+            message: `deploy-secrets directory missing: ${deploySecretsPath}`
+        };
+    }
+    const rootResult = runner("git", ["-C", workdir, "rev-parse", "--show-toplevel"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (rootResult.error || rootResult.status !== 0 || !rootResult.stdout) {
+        return {
+            id: "deploy-secrets-git",
+            label: "deploy-secrets git",
+            status: "ok",
+            message: "deploy-secrets is outside a git worktree"
+        };
+    }
+    const gitRoot = String(rootResult.stdout).trim();
+    const relative = path.relative(gitRoot, deploySecretsPath);
+    if (relative.startsWith("..")) {
+        return {
+            id: "deploy-secrets-git",
+            label: "deploy-secrets git",
+            status: "ok",
+            message: "deploy-secrets is outside the current git root"
+        };
+    }
+    const trackedResult = runner("git", ["-C", gitRoot, "ls-files", "--error-unmatch", relative], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (!trackedResult.error && trackedResult.status === 0) {
+        return {
+            id: "deploy-secrets-git",
+            label: "deploy-secrets git",
+            status: "warning",
+            message: `deploy-secrets appears to be tracked by git: ${deploySecretsPath}`
+        };
+    }
+    return {
+        id: "deploy-secrets-git",
+        label: "deploy-secrets git",
+        status: "ok",
+        message: "deploy-secrets is not tracked by git"
+    };
+}
+export function runWorkdirDoctor(options = {}) {
+    const definition = getProviderDefinition(options.provider);
+    const workdir = resolveAdminWorkdir({
+        cliWorkdir: options.cliWorkdir,
+        env: options.env || process.env
+    });
+    const runner = options.spawnSync || spawnSync;
+    const checks = [
+        ...requiredWorkdirFiles.map((relative) => fileCheck(`file:${relative}`, relative, path.join(workdir, relative))),
+        deploySecretsGitCheck(workdir, runner),
+        ...definition.check({
+            env: options.env || process.env,
+            spawnSync: runner
+        })
+    ];
+    return {
+        provider: definition.id,
+        workdir,
+        checks
+    };
+}
+export function formatAdminInitResult(result) {
+    const lines = [
+        result.checkOnly ? "TokenBuddy admin workdir check complete" : "TokenBuddy admin workdir initialized",
+        `  provider : ${result.provider}`,
+        `  workdir  : ${result.workdir}`,
+        `  templates: @tokenbuddy/tb-admin@${result.templateVersion}`,
+        "",
+        "Checks"
+    ];
+    for (const check of result.checks) {
+        const suffix = check.command ? ` (run: ${check.command})` : "";
+        lines.push(`  ${check.label.padEnd(10)} ${check.status}${suffix}`);
+    }
+    if (result.install) {
+        lines.push("", `Install: ${result.install.ok ? "ok" : "failed"} - ${result.install.message}`);
+    }
+    if (result.files.length > 0) {
+        lines.push("", "Files");
+        for (const file of result.files) {
+            lines.push(`  ${file.status.padEnd(7)} ${file.path}`);
+        }
+    }
+    lines.push("", "Next");
+    for (const next of result.next) {
+        lines.push(`  ${next}`);
+    }
+    return lines.join("\n");
+}
+export function formatWorkdirDoctorResult(result) {
+    const lines = [
+        "TokenBuddy admin workdir doctor",
+        `  provider : ${result.provider}`,
+        `  workdir  : ${result.workdir}`,
+        "",
+        "Checks"
+    ];
+    for (const check of result.checks) {
+        const suffix = check.command ? ` (run: ${check.command})` : "";
+        lines.push(`  ${check.label.padEnd(24)} ${check.status}${suffix}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=init-command.js.map

package/dist/src/providers/fly-io.d.ts

@@ -0,0 +1,3 @@
+import type { AdminProviderDefinition } from "./provider-definition.js";
+export declare const flyIoProviderDefinition: AdminProviderDefinition;
+//# sourceMappingURL=fly-io.d.ts.map

package/dist/src/providers/fly-io.js

@@ -0,0 +1,137 @@
+function commandOk(ctx, command, args) {
+    const result = ctx.spawnSync(command, args, {
+        encoding: "utf8",
+        env: ctx.env,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    return !result.error && result.status === 0;
+}
+function flyctlCandidates(ctx) {
+    const configured = ctx.flyctlPath ? [ctx.flyctlPath] : [];
+    return [...configured, "flyctl", "fly"].filter((item, index, all) => all.indexOf(item) === index);
+}
+function findFlyctl(ctx) {
+    return flyctlCandidates(ctx).find((candidate) => commandOk(ctx, candidate, ["version"]));
+}
+function flyCliCheck(ctx) {
+    const flyctl = findFlyctl(ctx);
+    if (flyctl) {
+        return {
+            id: "fly",
+            label: "fly",
+            status: "ok",
+            message: `${flyctl} is available`
+        };
+    }
+    return {
+        id: "fly",
+        label: "fly",
+        status: "missing",
+        message: "Fly.io CLI is missing",
+        command: "curl -fsSL https://fly.io/install.sh | sh"
+    };
+}
+function flyAuthCheck(ctx) {
+    if (ctx.env.FLY_API_TOKEN || ctx.env.FLY_ACCESS_TOKEN) {
+        return {
+            id: "fly-auth",
+            label: "fly auth",
+            status: "ok",
+            message: "Fly auth token is present in the environment"
+        };
+    }
+    const flyctl = findFlyctl(ctx);
+    if (flyctl && commandOk(ctx, flyctl, ["auth", "whoami"])) {
+        return {
+            id: "fly-auth",
+            label: "fly auth",
+            status: "ok",
+            message: "fly auth whoami succeeded"
+        };
+    }
+    return {
+        id: "fly-auth",
+        label: "fly auth",
+        status: "missing",
+        message: "Fly auth is missing",
+        command: "fly auth login, or set FLY_API_TOKEN"
+    };
+}
+function dockerCheck(ctx) {
+    if (commandOk(ctx, "docker", ["info"])) {
+        return {
+            id: "docker",
+            label: "docker",
+            status: "ok",
+            message: "Docker daemon is available"
+        };
+    }
+    return {
+        id: "docker",
+        label: "docker",
+        status: "missing",
+        message: "Docker daemon is not available",
+        command: "Start Docker Desktop or your Docker daemon"
+    };
+}
+function buildxCheck(ctx) {
+    if (commandOk(ctx, "docker", ["buildx", "version"])) {
+        return {
+            id: "buildx",
+            label: "buildx",
+            status: "ok",
+            message: "Docker buildx is available"
+        };
+    }
+    return {
+        id: "buildx",
+        label: "buildx",
+        status: "missing",
+        message: "Docker buildx is not available",
+        command: "Install or upgrade Docker Desktop"
+    };
+}
+function installFlyCli(ctx) {
+    const command = "curl -fsSL https://fly.io/install.sh | sh";
+    if (ctx.dryRun) {
+        return { ok: true, message: command };
+    }
+    console.log(`Installing Fly.io CLI with: ${command}`);
+    const result = ctx.spawnSync("sh", ["-c", command], {
+        encoding: "utf8",
+        env: ctx.env,
+        stdio: "inherit"
+    });
+    if (result.error) {
+        return { ok: false, message: result.error.message };
+    }
+    if (result.status !== 0) {
+        return { ok: false, message: `Fly.io CLI install exited with code ${result.status}` };
+    }
+    return {
+        ok: true,
+        message: "Fly.io CLI install finished. If fly is still not found, run: export PATH=\"$HOME/.fly/bin:$PATH\""
+    };
+}
+export const flyIoProviderDefinition = {
+    id: "fly.io",
+    displayName: "Fly.io",
+    templateRelativeRoot: "templates/providers/fly.io",
+    defaultPaths: {
+        providerConfig: "providers/fly.io.toml",
+        sellerFlyConfig: "fly/fly.tb-seller.toml",
+        registryFlyConfig: "fly/fly.tb-registry.toml",
+        deployEnv: "env/deploy.env",
+        artifactsDir: "artifacts"
+    },
+    check(ctx) {
+        return [
+            flyCliCheck(ctx),
+            flyAuthCheck(ctx),
+            dockerCheck(ctx),
+            buildxCheck(ctx)
+        ];
+    },
+    install: installFlyCli
+};
+//# sourceMappingURL=fly-io.js.map

package/dist/src/providers/provider-definition.d.ts

@@ -0,0 +1,38 @@
+import type { SpawnSyncOptions, SpawnSyncReturns } from "child_process";
+export type AdminProviderId = "fly.io";
+export type ProviderCheckStatus = "ok" | "missing" | "warning";
+export type SpawnSyncRunner = (command: string, args?: string[], options?: SpawnSyncOptions) => SpawnSyncReturns<string | Buffer>;
+export interface ProviderCheckContext {
+    env: NodeJS.ProcessEnv;
+    spawnSync: SpawnSyncRunner;
+    flyctlPath?: string;
+}
+export interface ProviderInstallContext extends ProviderCheckContext {
+    dryRun?: boolean;
+}
+export interface ProviderCheckResult {
+    id: string;
+    label: string;
+    status: ProviderCheckStatus;
+    message: string;
+    command?: string;
+}
+export interface ProviderInstallResult {
+    ok: boolean;
+    message: string;
+}
+export interface AdminProviderDefinition {
+    id: AdminProviderId;
+    displayName: string;
+    templateRelativeRoot: string;
+    defaultPaths: {
+        providerConfig: string;
+        sellerFlyConfig: string;
+        registryFlyConfig: string;
+        deployEnv: string;
+        artifactsDir: string;
+    };
+    check(ctx: ProviderCheckContext): ProviderCheckResult[];
+    install?(ctx: ProviderInstallContext): ProviderInstallResult;
+}
+//# sourceMappingURL=provider-definition.d.ts.map

package/dist/src/providers/provider-definition.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provider-definition.js.map

package/dist/src/seller.d.ts

@@ -121,8 +121,10 @@ export declare class SellerCommandRunner {
     private configManager;
     constructor(configManager: ConfigManager);
     private getProviderConfig;
+    private getWorkdir;
     private getProvider;
     private getFlyctl;
+    private resolveCreateOptions;
     ls(json: boolean): SellerListResult | string;
     status(appName: string, json: boolean): SellerStatusResult | string;
     machineSpecs(appName: string): SellerMachineSpecs | undefined;

package/dist/src/seller.js

@@ -20,6 +20,7 @@
  */
 import { execSync, spawnSync } from "node:child_process";
 import { FlyProvider } from "./server-cmd.js";
+import { resolveWorkdirPath } from "./workdir.js";
 export class FlyCliMissingError extends Error {
     flyctl;
     constructor(flyctl) {
@@ -158,12 +159,31 @@ export class SellerCommandRunner {
     getProviderConfig() {
         return this.configManager.getSellerProvider("fly");
     }
+    getWorkdir() {
+        return this.configManager.getWorkdir();
+    }
     getProvider() {
         return new FlyProvider(this.getProviderConfig());
     }
     getFlyctl() {
         return this.getProviderConfig()?.flyctl_path || "flyctl";
     }
+    resolveCreateOptions(options) {
+        const workdir = this.getWorkdir();
+        const providerConfig = this.getProviderConfig();
+        const flyConfig = resolveWorkdirPath(workdir, options.flyConfig || "fly/fly.tb-seller.toml");
+        const initialConfigPath = options.initialConfigPath
+            ? resolveWorkdirPath(workdir, options.initialConfigPath)
+            : providerConfig?.default_config
+                ? resolveWorkdirPath(workdir, providerConfig.default_config)
+                : undefined;
+        return {
+            ...options,
+            flyConfig,
+            initialConfigPath,
+            resolvedWorkdir: workdir
+        };
+    }
     // -- ls --
     ls(json) {
         const provider = this.getProvider();
@@ -207,27 +227,28 @@ export class SellerCommandRunner {
     // -- create --
     create(options, json) {
         const provider = this.getProvider();
+        const resolvedOptions = this.resolveCreateOptions(options);
         if (!json) {
-            return provider.createSeller(options);
+            return provider.createSeller(resolvedOptions);
         }
         // --json 路径: dry-run 模式直接列命令, 不实际调 flyctl
-        if (options.dryRun) {
+        if (resolvedOptions.dryRun) {
             return {
                 ok: true,
                 provider: "fly",
                 action: "create",
-                app: options.app || `tb-seller-${options.name}`,
+                app: resolvedOptions.app || `tb-seller-${resolvedOptions.name}`,
                 dryRun: true,
-                commands: buildCreateCommands(options)
+                commands: buildCreateCommands(resolvedOptions)
             };
         }
         // 非 dry-run: 调 FlyProvider (它已经会跑 flyctl), 包装 stdout
-        const summary = provider.createSeller(options);
+        const summary = provider.createSeller(resolvedOptions);
         return {
             ok: true,
             provider: "fly",
             action: "create",
-            app: options.app || `tb-seller-${options.name}`,
+            app: resolvedOptions.app || `tb-seller-${resolvedOptions.name}`,
             dryRun: false,
             summary: String(summary)
         };
@@ -399,13 +420,9 @@ function buildCreateCommands(options) {
     const appName = options.app || `tb-seller-${options.name}`;
     const region = options.region || "sin";
     const lines = [];
-    if (options.flyConfig) {
-        lines.push(`fly apps create ${appName}`);
-    }
-    lines.push(`fly deploy --config ${options.flyConfig} --app ${appName} --region ${region}`);
-    if (options.image) {
-        lines.push(`fly machine update <machine-id> --app ${appName} --image ${options.image} --yes`);
-    }
+    lines.push(`fly apps create ${appName}`);
+    lines.push(`fly secrets import --stage --app ${appName}`);
+    lines.push(`fly deploy --config ${options.flyConfig} --image ${options.image} --app ${appName} --primary-region ${region} --now`);
     return lines;
 }
 // re-exports 方便测试

package/dist/src/server-cmd.d.ts

@@ -40,6 +40,7 @@ export interface SellerCreateOptions {
     volumeId?: string;
     volumeSnapshotRetentionDays?: number;
     initialConfigPath?: string;
+    resolvedWorkdir?: string;
     dryRun?: boolean;
 }
 /**

package/dist/src/server-cmd.js

@@ -150,7 +150,8 @@ export class FlyProvider {
             throw new Error("seller create requires --image registry.fly.io/tb-seller:<v>");
         }
         if (!flyConfig) {
-            throw new Error("seller create requires --fly-config deploy/fly.io/fly.tb-seller.toml");
+            const suffix = options.resolvedWorkdir ? ` --workdir ${options.resolvedWorkdir}` : "";
+            throw new Error(`Fly config not found. Run: tb-admin init --provider fly.io${suffix}`);
         }
         if (dryRun) {
             const lines = [
@@ -176,7 +177,13 @@ export class FlyProvider {
         if (!operatorSecret) {
             throw new Error("operator_secret is required. Provide --operator-secret or configure seller_providers.fly.operator_secret");
         }
-        requireReadableFile(flyConfig, "Fly config");
+        try {
+            requireReadableFile(flyConfig, "Fly config");
+        }
+        catch (err) {
+            const suffix = options.resolvedWorkdir ? ` --workdir ${options.resolvedWorkdir}` : "";
+            throw new Error(`${err.message}. Run: tb-admin init --provider fly.io${suffix}`);
+        }
         if (initialConfigPath) {
             requireReadableFile(initialConfigPath, "Initial seller config");
         }

package/dist/src/ui-actions.d.ts

@@ -18,6 +18,7 @@ export interface CreateSellerRequest {
     upstreamWebsite: string;
     upstreamUrl: string;
     upstreamApiKey: string;
+    upstreamProtocolPreset?: string;
     upstreamBalanceProbeTemplate?: string;
     upstreamBalanceProbeUrl?: string;
     upstreamBalanceProbeUserId?: string;
@@ -97,6 +98,7 @@ export declare class UiActions {
     private waitForSellerReady;
     private refreshSellerModelsWithRetry;
     private publishCreatedSellerRegistryEntry;
+    private submitCreatedSellerRelease;
     private fetchSellerOperatorJson;
     private fetchSellerOperatorJsonOptional;
 }
@@ -113,5 +115,6 @@ export declare function runTbAdmin(args: string[], timeoutMs: number): Promise<U
  * stdout 仍是原始字符串, ok=false (CLI exit 0 但 stdout 不可解析视为可恢复错).
  */
 export declare function runTbAdminJson(args: string[], timeoutMs: number): Promise<UiActionResult>;
+export declare function parseJsonSafely(text: string): unknown | undefined;
 export {};
 //# sourceMappingURL=ui-actions.d.ts.map