@huoye/app-ship 0.1.0

package/dist/cli.js

@@ -0,0 +1,4298 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/upload-manager.ts
+import path9 from "path";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var ConsoleLogger = class {
+  info(message) {
+    console.log(chalk.blue("\u2139\uFE0F  " + message));
+  }
+  success(message) {
+    console.log(chalk.green("\u2705 " + message));
+  }
+  warn(message) {
+    console.log(chalk.yellow("\u26A0\uFE0F  " + message));
+  }
+  error(message) {
+    console.log(chalk.red("\u274C " + message));
+  }
+  title(message) {
+    console.log(chalk.bold.cyan("\n" + message + "\n"));
+  }
+  newLine() {
+    console.log("");
+  }
+};
+var logger = new ConsoleLogger();
+
+// src/adapters/pgyer_uploader.ts
+import fs3 from "fs-extra";
+import axios from "axios";
+import FormData from "form-data";
+
+// src/utils/retry-strategy.ts
+var RetryStrategy = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      maxRetries: config.maxRetries ?? 3,
+      initialDelayMs: config.initialDelayMs ?? 1e3,
+      backoffMultiplier: config.backoffMultiplier ?? 2,
+      maxDelayMs: config.maxDelayMs ?? 3e4
+    };
+  }
+  /**
+   * 根据错误类型判断是否应该重试
+   */
+  shouldRetry(error, retryCount) {
+    if (retryCount >= this.config.maxRetries) {
+      return false;
+    }
+    const category = this.classifyError(error);
+    return this.isRetryableCategory(category);
+  }
+  /**
+   * 对错误进行分类
+   */
+  classifyError(error) {
+    const message = error.message.toLowerCase();
+    const errorStr = JSON.stringify(error).toLowerCase();
+    if (message.includes("econnrefused") || message.includes("enotfound") || message.includes("etimedout") || message.includes("network") || message.includes("socket hang up") || message.includes("socket") || message.includes("econnreset") || message.includes("epipe") || message.includes("hang up")) {
+      return "NETWORK_ERROR" /* NETWORK_ERROR */;
+    }
+    if (message.includes("401") || message.includes("403") || message.includes("unauthorized") || message.includes("forbidden") || message.includes("invalid") || message.includes("token")) {
+      return "AUTH_ERROR" /* AUTH_ERROR */;
+    }
+    if (message.includes("500") || message.includes("502") || message.includes("503") || message.includes("504") || message.includes("server error") || message.includes("\u670D\u52A1\u5668\u7AEF\u5F02\u5E38")) {
+      return "SERVER_ERROR" /* SERVER_ERROR */;
+    }
+    if (message.includes("400") || message.includes("404") || message.includes("bad request") || message.includes("not found")) {
+      return "CLIENT_ERROR" /* CLIENT_ERROR */;
+    }
+    if (message.includes("timeout") || message.includes("rate limit") || message.includes("too many") || message.includes("429")) {
+      return "TEMPORARY_ERROR" /* TEMPORARY_ERROR */;
+    }
+    return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+  }
+  /**
+   * 判断错误类别是否可重试
+   */
+  isRetryableCategory(category) {
+    const retryableCategories = [
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TEMPORARY_ERROR" /* TEMPORARY_ERROR */,
+      "SERVER_ERROR" /* SERVER_ERROR */
+    ];
+    return retryableCategories.includes(category);
+  }
+  /**
+   * 计算延迟时间（使用指数退避策略）
+   */
+  calculateDelay(retryCount) {
+    const exponentialDelay = this.config.initialDelayMs * Math.pow(this.config.backoffMultiplier, retryCount);
+    const jitter = exponentialDelay * (Math.random() * 0.2);
+    const delay = Math.min(exponentialDelay + jitter, this.config.maxDelayMs);
+    return Math.round(delay);
+  }
+  /**
+   * 等待指定时间
+   */
+  async sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 执行带重试的异步函数
+   */
+  async execute(fn, operationName = "Operation") {
+    let lastError;
+    let attempt = 0;
+    while (attempt <= this.config.maxRetries) {
+      attempt++;
+      try {
+        logger.info(`${operationName} (Attempt ${attempt}/${this.config.maxRetries + 1})`);
+        const result = await fn();
+        if (attempt > 1) {
+          logger.success(`${operationName} succeeded after ${attempt} attempts`);
+        }
+        return {
+          success: true,
+          data: result,
+          totalAttempts: attempt
+        };
+      } catch (error) {
+        lastError = error;
+        const errorMessage = error.message || String(error);
+        const category = this.classifyError(error);
+        logger.warn(`${operationName} failed (Attempt ${attempt}): ${errorMessage} [${category}]`);
+        if (!this.shouldRetry(error, attempt)) {
+          logger.error(`${operationName} failed with non-retryable error: ${errorMessage}`);
+          return {
+            success: false,
+            error,
+            totalAttempts: attempt,
+            lastError: errorMessage
+          };
+        }
+        if (attempt <= this.config.maxRetries) {
+          const delayMs = this.calculateDelay(attempt - 1);
+          logger.info(
+            `Retrying ${operationName} after ${delayMs}ms (${this.config.maxRetries - attempt + 1} retries left)...`
+          );
+          await this.sleep(delayMs);
+        }
+      }
+    }
+    return {
+      success: false,
+      error: lastError || new Error(`${operationName} failed after all retries`),
+      totalAttempts: attempt,
+      lastError: lastError?.message
+    };
+  }
+};
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelayMs: 1e3,
+  backoffMultiplier: 2,
+  maxDelayMs: 3e4
+};
+function createUploadRetryStrategy(config) {
+  return new RetryStrategy({
+    ...DEFAULT_RETRY_CONFIG,
+    ...config
+  });
+}
+
+// src/utils/apple-jwt-generator.ts
+import crypto from "crypto";
+import fs from "fs-extra";
+var AppleJWTGenerator = class _AppleJWTGenerator {
+  issuerId;
+  keyId;
+  privateKey;
+  constructor(issuerId, keyId, privateKey) {
+    this.issuerId = issuerId;
+    this.keyId = keyId;
+    this.privateKey = privateKey;
+  }
+  /**
+   * 从文件路径加载私钥内容
+   */
+  static async fromFile(issuerId, keyId, privateKeyPath) {
+    try {
+      const privateKey = await fs.readFile(privateKeyPath, "utf-8");
+      return new _AppleJWTGenerator(issuerId, keyId, privateKey);
+    } catch (error) {
+      throw new Error(`Failed to load Apple private key from ${privateKeyPath}: ${error.message}`);
+    }
+  }
+  /**
+   * 从内容字符串创建生成器
+   */
+  static fromContent(issuerId, keyId, privateKeyContent) {
+    return new _AppleJWTGenerator(issuerId, keyId, privateKeyContent);
+  }
+  /**
+   * 生成 JWT 令牌
+   * @returns Base64URL 编码的 JWT 字符串
+   */
+  generate() {
+    try {
+      const header = this.createHeader();
+      const headerEncoded = this.base64urlEncode(JSON.stringify(header));
+      const payload = this.createPayload();
+      const payloadEncoded = this.base64urlEncode(JSON.stringify(payload));
+      const signatureInput = `${headerEncoded}.${payloadEncoded}`;
+      const signature = this.sign(signatureInput);
+      return `${signatureInput}.${signature}`;
+    } catch (error) {
+      logger.error(`Failed to generate Apple JWT: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * 创建 JWT Header
+   */
+  createHeader() {
+    return {
+      alg: "ES256",
+      kid: this.keyId,
+      typ: "JWT"
+    };
+  }
+  /**
+   * 创建 JWT Payload
+   * 有效期: 20 分钟（1200 秒）
+   */
+  createPayload() {
+    const now = Math.floor(Date.now() / 1e3);
+    return {
+      iss: this.issuerId,
+      aud: "appstoreconnect-v1",
+      exp: now + 1200,
+      // 20 minutes
+      iat: now
+    };
+  }
+  /**
+   * 使用 ES256 算法签名
+   * ES256 = ECDSA with SHA-256
+   */
+  sign(data) {
+    const sign = crypto.createSign("SHA256");
+    sign.update(data);
+    sign.end();
+    const signature = sign.sign({
+      key: this.privateKey,
+      format: "pem"
+    });
+    const { r, s } = this.parseDERSignature(signature);
+    const combined = Buffer.concat([r, s]);
+    return this.base64urlEncode(combined);
+  }
+  /**
+   * 解析 DER 格式的签名并提取 r 和 s
+   */
+  parseDERSignature(derSignature) {
+    let offset = 0;
+    offset += 2;
+    if (derSignature[offset] === 129 || derSignature[offset] === 130) {
+      offset += 1;
+    } else {
+      offset += 1;
+    }
+    offset += 1;
+    const rLength = derSignature[offset];
+    offset += 1;
+    let r = derSignature.subarray(offset, offset + rLength);
+    offset += rLength;
+    if (r[0] === 0 && r.length > 32) {
+      r = r.subarray(1);
+    }
+    r = this.padBuffer(r, 32);
+    offset += 1;
+    const sLength = derSignature[offset];
+    offset += 1;
+    let s = derSignature.subarray(offset, offset + sLength);
+    if (s[0] === 0 && s.length > 32) {
+      s = s.subarray(1);
+    }
+    s = this.padBuffer(s, 32);
+    return { r: Buffer.from(r), s: Buffer.from(s) };
+  }
+  /**
+   * 将 Buffer 填充或截断到指定长度
+   */
+  padBuffer(buf, length) {
+    if (buf.length === length) return buf;
+    if (buf.length > length) return buf.subarray(buf.length - length);
+    const padded = Buffer.alloc(length);
+    buf.copy(padded, length - buf.length);
+    return padded;
+  }
+  /**
+   * Base64URL 编码 (RFC 4648)
+   */
+  base64urlEncode(data) {
+    const base64 = Buffer.from(data).toString("base64");
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+};
+
+// src/utils/package-parser.ts
+import path from "path";
+import fs2 from "fs";
+import crypto2 from "crypto";
+async function parsePackageInfo(filePath, options) {
+  const ext = path.extname(filePath).toLowerCase();
+  try {
+    switch (ext) {
+      case ".apk":
+        return await parseApk(filePath, options);
+      case ".ipa":
+        return await parseIpa(filePath);
+      case ".hap":
+        return await parseHap(filePath);
+      default:
+        logger.warn(`[PackageParser] \u4E0D\u652F\u6301\u7684\u6587\u4EF6\u683C\u5F0F: ${ext}`);
+        return null;
+    }
+  } catch (error) {
+    logger.warn(`[PackageParser] \u89E3\u6790\u5931\u8D25: ${error.message}`);
+    return null;
+  }
+}
+function exec(cmd, args, timeoutMs = 15e3) {
+  const { execFile } = __require("child_process");
+  return new Promise((resolve, reject) => {
+    execFile(
+      cmd,
+      args,
+      { timeout: timeoutMs, maxBuffer: 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(stdout);
+        }
+      }
+    );
+  });
+}
+async function getAaptPath(options) {
+  if (options?.androidSdkPath && fs2.existsSync(options.androidSdkPath)) {
+    const buildToolsDir = path.join(options.androidSdkPath, "build-tools");
+    if (fs2.existsSync(buildToolsDir)) {
+      const tool = findInBuildTools(buildToolsDir);
+      if (tool) return tool;
+    }
+  }
+  if (await commandExists("aapt2")) return "aapt2";
+  if (await commandExists("aapt")) return "aapt";
+  const sdkRoot = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || path.join(process.env.HOME || "", "Library/Android/sdk");
+  if (sdkRoot && fs2.existsSync(sdkRoot)) {
+    const buildToolsDir = path.join(sdkRoot, "build-tools");
+    if (fs2.existsSync(buildToolsDir)) {
+      const tool = findInBuildTools(buildToolsDir);
+      if (tool) return tool;
+    }
+  }
+  return null;
+}
+function findInBuildTools(buildToolsDir) {
+  const versions = fs2.readdirSync(buildToolsDir).filter((dir) => fs2.lstatSync(path.join(buildToolsDir, dir)).isDirectory()).sort((a, b) => b.localeCompare(a, void 0, { numeric: true }));
+  for (const version of versions) {
+    const aapt2 = path.join(buildToolsDir, version, "aapt2");
+    if (fs2.existsSync(aapt2)) return aapt2;
+    const aapt = path.join(buildToolsDir, version, "aapt");
+    if (fs2.existsSync(aapt)) return aapt;
+  }
+  return null;
+}
+async function commandExists(cmd) {
+  try {
+    await exec("which", [cmd], 3e3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function parseApk(filePath, options) {
+  const tool = await getAaptPath(options);
+  if (!tool) {
+    logger.warn(
+      "[PackageParser] \u26A0\uFE0F aapt2/aapt \u4E0D\u53EF\u7528 (\u8BF7\u68C0\u67E5 ANDROID_HOME \u6216\u52A0\u5165 PATH)\uFF0C\u65E0\u6CD5\u89E3\u6790 APK \u7248\u672C\u4FE1\u606F"
+    );
+    return null;
+  }
+  const output = await exec(tool, ["dump", "badging", filePath]);
+  const packageMatch = output.match(
+    /package:\s+name='([^']*)'.*?versionCode='([^']*)'.*?versionName='([^']*)'/
+  );
+  if (!packageMatch) {
+    logger.warn("[PackageParser] APK badging \u8F93\u51FA\u4E2D\u672A\u627E\u5230\u7248\u672C\u4FE1\u606F");
+    return null;
+  }
+  const info = {
+    packageName: packageMatch[1] || void 0,
+    versionCode: packageMatch[2] || void 0,
+    versionName: packageMatch[3] || void 0
+  };
+  const nativeCodeMatch = output.match(/native-code:\s+((?:'[^']*'\s*)*)/);
+  if (nativeCodeMatch) {
+    info.nativeCode = nativeCodeMatch[1].split(/\s+/).filter((s) => s.startsWith("'") && s.endsWith("'")).map((s) => s.slice(1, -1));
+  }
+  try {
+    const fileBuffer = fs2.readFileSync(filePath);
+    info.md5 = crypto2.createHash("md5").update(fileBuffer).digest("hex").toLowerCase();
+  } catch (e) {
+    logger.warn(`[PackageParser] \u8BA1\u7B97 MD5 \u5931\u8D25: ${e.message}`);
+  }
+  logger.info(
+    `[PackageParser] APK: ${info.packageName} v${info.versionName}+${info.versionCode} arch:${info.nativeCode?.join(",") || "none"}`
+  );
+  return info;
+}
+async function parseIpa(filePath) {
+  if (!await commandExists("plutil")) {
+    logger.warn("[PackageParser] plutil \u4E0D\u53EF\u7528\uFF08\u975E macOS\uFF1F\uFF09\uFF0C\u65E0\u6CD5\u89E3\u6790 IPA");
+    return null;
+  }
+  const listOutput = await exec("unzip", ["-Z1", filePath]);
+  const plistPath = listOutput.split("\n").find((line) => /^Payload\/[^/]+\.app\/Info\.plist$/.test(line.trim()));
+  if (!plistPath) {
+    logger.warn("[PackageParser] IPA \u4E2D\u672A\u627E\u5230 Info.plist");
+    return null;
+  }
+  const plistData = await exec("unzip", ["-p", filePath, plistPath.trim()]);
+  const jsonStr = await new Promise((resolve, reject) => {
+    const child = __require("child_process").spawn("plutil", ["-convert", "json", "-o", "-", "-"], {
+      timeout: 1e4
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(`plutil \u5931\u8D25: ${stderr}`));
+    });
+    child.stdin.write(plistData);
+    child.stdin.end();
+  });
+  const plist = JSON.parse(jsonStr);
+  const info = {
+    versionName: plist.CFBundleShortVersionString || void 0,
+    versionCode: plist.CFBundleVersion || void 0,
+    packageName: plist.CFBundleIdentifier || void 0
+  };
+  logger.info(`[PackageParser] IPA: ${info.packageName} v${info.versionName}+${info.versionCode}`);
+  return info;
+}
+async function parseHap(filePath) {
+  let jsonStr = null;
+  try {
+    jsonStr = await exec("unzip", ["-p", filePath, "module.json"]);
+  } catch {
+    try {
+      jsonStr = await exec("unzip", ["-p", filePath, "config.json"]);
+    } catch {
+      logger.warn("[PackageParser] HAP \u4E2D\u672A\u627E\u5230 module.json \u6216 config.json");
+      return null;
+    }
+  }
+  const config = JSON.parse(jsonStr);
+  const app = config.app || {};
+  const info = {
+    versionName: app.versionName || app.version?.name || void 0,
+    versionCode: String(app.versionCode ?? app.version?.code ?? ""),
+    packageName: app.bundleName || void 0
+  };
+  if (!info.versionCode) info.versionCode = void 0;
+  logger.info(`[PackageParser] HAP: ${info.packageName} v${info.versionName}+${info.versionCode}`);
+  return info;
+}
+
+// src/adapters/pgyer_uploader.ts
+var PgyerUploader = class _PgyerUploader {
+  name = "Pgyer";
+  static UPLOAD_API = "https://www.pgyer.com/apiv2/app/upload";
+  /**
+   * 验证配置
+   * @param config 配置对象
+   */
+  validateConfig(config) {
+    if (!config?.publish?.pgyer?.enable) {
+      return false;
+    }
+    if (!config.publish.pgyer.apiKey) {
+      logger.error("Pgyer apiKey is missing in config");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 判断是否支持该文件
+   * @param filePath 文件路径
+   */
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "apk" || ext === "ipa" || ext === "aab";
+  }
+  /**
+   * 上传文件到蒲公英
+   * @param filePath 文件路径
+   * @param config 配置
+   * @param metadata 元数据
+   */
+  async upload(filePath, config, metadata) {
+    const pgyerConfig = config.publish?.pgyer;
+    const apiKey = pgyerConfig?.apiKey;
+    const desc = metadata.changelog || pgyerConfig?.description || "";
+    const retryConfig = config.retry;
+    if (!fs3.existsSync(filePath)) {
+      return {
+        platform: "pgyer",
+        success: false,
+        message: `File not found: ${filePath}`
+      };
+    }
+    logger.info(`Uploading to Pgyer...`);
+    logger.info(`File: ${filePath}`);
+    logger.info(`Changelog: ${desc.replace(/\n/g, " ")}`);
+    const retryStrategy = createUploadRetryStrategy(retryConfig);
+    const result = await retryStrategy.execute(
+      () => this.performUpload(filePath, apiKey, desc),
+      "Pgyer upload"
+    );
+    if (result.success) {
+      const pgyerData = result.data;
+      return {
+        platform: "pgyer",
+        success: true,
+        message: "Upload success",
+        url: pgyerData.fullUrl,
+        link: pgyerData.fullUrl,
+        qrCode: pgyerData.qrCodeUrl,
+        data: pgyerData,
+        consoleUrl: "https://www.pgyer.com/my"
+      };
+    } else {
+      const lastError = result.lastError;
+      const errorMsg = lastError instanceof Error ? lastError.message : String(lastError || "Upload failed");
+      return {
+        platform: "pgyer",
+        success: false,
+        message: errorMsg,
+        // ✅ 必填且为字符串
+        error: result.error
+      };
+    }
+  }
+  /**
+   * 执行实际上传操作
+   * @param filePath 文件路径
+   * @param apiKey API Key
+   * @param desc 描述
+   */
+  async performUpload(filePath, apiKey, desc) {
+    const form = new FormData();
+    form.append("_api_key", apiKey);
+    form.append("buildUpdateDescription", desc);
+    form.append("file", fs3.createReadStream(filePath));
+    const response = await axios.post(_PgyerUploader.UPLOAD_API, form, {
+      headers: {
+        ...form.getHeaders()
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+    const data = response.data;
+    if (data.code !== 0) {
+      logger.error(`Pgyer API Error: ${data.message}`);
+      throw new Error(`Pgyer API Error: ${data.message}`);
+    }
+    const shortcutUrl = data.data.buildShortcutUrl;
+    let qrCodeUrl = data.data.buildQRCodeURL;
+    const fullUrl = `https://www.pgyer.com/${shortcutUrl}`;
+    if (qrCodeUrl && qrCodeUrl.startsWith("//")) {
+      qrCodeUrl = `https:${qrCodeUrl}`;
+    } else if (qrCodeUrl && !qrCodeUrl.startsWith("http")) {
+    }
+    logger.success(`Upload to Pgyer success!`);
+    logger.info(`Download URL: ${fullUrl}`);
+    return {
+      fullUrl,
+      qrCodeUrl,
+      shortcutUrl
+    };
+  }
+};
+
+// src/adapters/huawei_uploader.ts
+import fs4 from "fs-extra";
+import path2 from "path";
+import { promisify } from "util";
+import axios2 from "axios";
+import FormData2 from "form-data";
+var HUAWEI_SUPPORTED_SUFFIXES = {
+  image: ["jpg", "jpeg", "png", "bmp"],
+  video: ["mp4", "mov"],
+  package: ["apk", "aab", "rpk"]
+};
+var HuaweiUploader = class _HuaweiUploader {
+  name = "Huawei";
+  // 华为上传器默认 API 基础地址
+  static DEFAULT_API_BASE = "https://connect-api.cloud.huawei.com";
+  // 华为上传器获取 Token 路径
+  static TOKEN_PATH = "/api/oauth2/v1/token";
+  // 华为上传器发布 API 根路径
+  static PUBLISH_API_PATH = "/api/publish/v2";
+  /** 获取 API 基础地址 */
+  getApiBase(config) {
+    return config?.publish?.huawei?.apiBaseUrl || _HuaweiUploader.DEFAULT_API_BASE;
+  }
+  /** 获取 Token URL */
+  getTokenUrl(config) {
+    return `${this.getApiBase(config)}${_HuaweiUploader.TOKEN_PATH}`;
+  }
+  /** 获取 Publish API 根路径 */
+  getApiRoot(config) {
+    return `${this.getApiBase(config)}${_HuaweiUploader.PUBLISH_API_PATH}`;
+  }
+  /** 创建 API 请求头（消除 7 处重复） */
+  headers(ctx) {
+    return {
+      Authorization: `Bearer ${ctx.token}`,
+      client_id: ctx.clientId
+    };
+  }
+  /** 检查 API 响应（消除 6 处重复） */
+  checkResponse(res, operation) {
+    const code = res.data.ret?.code ?? res.data.code;
+    if (code !== 0) {
+      throw new Error(`${operation} failed: ${res.data.ret?.msg || res.data.msg}`);
+    }
+    return res.data;
+  }
+  /**
+   * 验证配置
+   * @param config 配置对象
+   * @returns 是否有效
+   */
+  validateConfig(config) {
+    if (!config?.publish?.huawei?.enable) return false;
+    const h = config.publish.huawei;
+    if (!h.auth?.clientId || !h.auth?.clientSecret || !h.appId) {
+      logger.error("Huawei config missing: clientId, clientSecret, or appId");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 判断是否支持该文件
+   * @param filePath 文件路径
+   * @returns 是否支持
+   */
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "apk" || ext === "aab";
+  }
+  /**
+   * 执行上传
+   * @param filePath 文件路径
+   * @param config 配置
+   * @param metadata 元数据
+   */
+  async upload(filePath, config, metadata) {
+    const hwConfig = config.publish.huawei;
+    const clientId = hwConfig.auth.clientId;
+    const clientSecret = hwConfig.auth.clientSecret;
+    const appId = hwConfig.appId;
+    const releaseType = hwConfig.releaseType || "draft";
+    const suffix = path2.extname(filePath).substring(1);
+    const retryConfig = config.retry;
+    const tokenUrl = this.getTokenUrl(config);
+    const publishApiRoot = this.getApiRoot(config);
+    logger.info("Starting Huawei AppGallery upload...");
+    try {
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      logger.info("Authenticating...");
+      const tokenResult = await retryStrategy.execute(
+        () => this.getAccessToken(tokenUrl, clientId, clientSecret),
+        "Huawei authentication"
+      );
+      if (!tokenResult.success || !tokenResult.data) {
+        throw tokenResult.error || new Error("Failed to get access token");
+      }
+      const ctx = {
+        apiRoot: publishApiRoot,
+        token: tokenResult.data,
+        clientId,
+        appId
+      };
+      logger.info("Requesting upload URL...");
+      const uploadInfoResult = await retryStrategy.execute(
+        () => this.getUploadUrl(ctx, suffix),
+        "Huawei get upload URL"
+      );
+      if (!uploadInfoResult.success || !uploadInfoResult.data) {
+        throw uploadInfoResult.error || new Error("Failed to get upload URL");
+      }
+      const uploadInfo = uploadInfoResult.data;
+      logger.info("Uploading file (this may take a while)...");
+      const uploadFileResult = await retryStrategy.execute(
+        () => this.uploadFile(uploadInfo.uploadUrl, uploadInfo.authCode, filePath),
+        "Huawei file upload"
+      );
+      if (!uploadFileResult.success || !uploadFileResult.data) {
+        throw uploadFileResult.error || new Error("File upload failed");
+      }
+      const fileDestUrl = uploadFileResult.data.fileDestUrl;
+      logger.info("Linking file to app...");
+      const updateInfoResult = await retryStrategy.execute(
+        () => this.updateAppFileInfo(ctx, fileDestUrl, filePath),
+        "Huawei update file info"
+      );
+      if (!updateInfoResult.success) {
+        throw updateInfoResult.error || new Error("Failed to update file info");
+      }
+      if (metadata.changelog) {
+        try {
+          logger.info("Updating release notes...");
+          await retryStrategy.execute(
+            () => this.updateReleaseNotes(ctx, metadata.changelog, metadata.version),
+            "Huawei update release notes"
+          );
+        } catch (error) {
+          logger.warn(`Failed to update release notes: ${error.message}. Continuing...`);
+        }
+      }
+      const assets = hwConfig.assets;
+      if (assets) {
+        await this.uploadStoreAssets(ctx, assets, retryStrategy);
+      }
+      if (releaseType === "submit") {
+        try {
+          logger.info("Submitting app for review...");
+          const submitResult = await retryStrategy.execute(
+            () => this.submitForReview(ctx, metadata.version),
+            "Huawei submit for review"
+          );
+          if (!submitResult.success) {
+            throw submitResult.error || new Error("Failed to submit for review");
+          }
+          logger.success("Huawei upload successful and submitted for review!");
+          return {
+            platform: "huawei",
+            success: true,
+            message: "Upload and review submission successful",
+            url: "https://developer.huawei.com/consumer/cn/service/josp/agc/index.html",
+            consoleUrl: "https://developer.huawei.com/consumer/cn/service/josp/agc/index.html"
+          };
+        } catch (error) {
+          logger.warn(
+            `Failed to submit for review: ${error.message}. App uploaded but not submitted.`
+          );
+          return {
+            platform: "huawei",
+            success: true,
+            message: "Upload successful but review submission failed. Please submit manually.",
+            url: "https://developer.huawei.com/consumer/cn/service/josp/agc/index.html",
+            consoleUrl: "https://developer.huawei.com/consumer/cn/service/josp/agc/index.html"
+          };
+        }
+      }
+      logger.success("Huawei upload successful (Draft status).");
+      return {
+        platform: "huawei",
+        success: true,
+        message: "Upload success (Draft)",
+        url: "https://developer.huawei.com/consumer/cn/service/josp/agc/index.html",
+        consoleUrl: "https://developer.huawei.com/consumer/cn/service/josp/agc/index.html"
+      };
+    } catch (error) {
+      logger.error(`Huawei upload failed: ${error.message}`);
+      const safeError = {
+        message: error.message,
+        name: error.name,
+        code: error.code,
+        status: error.response?.status
+      };
+      if (error.response?.data) {
+        safeError.responseData = error.response.data;
+        logger.info(`Error Data: ${JSON.stringify(error.response.data)}`);
+      }
+      return {
+        platform: "huawei",
+        success: false,
+        message: error.message,
+        error: safeError
+      };
+    }
+  }
+  /**
+   * 查询审核状态
+   * @param clientId 客户端 ID
+   * @param clientSecret 客户端密钥
+   * @param appId 应用 ID
+   * @param apiBaseUrl API 基础地址（可选）
+   */
+  async queryReviewStatus(clientId, clientSecret, appId, apiBaseUrl) {
+    const baseUrl = apiBaseUrl || _HuaweiUploader.DEFAULT_API_BASE;
+    const tokenUrl = `${baseUrl}${_HuaweiUploader.TOKEN_PATH}`;
+    const apiRoot = `${baseUrl}${_HuaweiUploader.PUBLISH_API_PATH}`;
+    try {
+      logger.info("Querying review status...");
+      const token = await this.getAccessToken(tokenUrl, clientId, clientSecret);
+      const ctx = { apiRoot, token, clientId, appId };
+      const res = await axios2.get(`${apiRoot}/app-information`, {
+        params: { appId },
+        headers: this.headers(ctx)
+      });
+      this.checkResponse(res, "Query review status");
+      const status = res.data.data?.app?.auditStatus || "unknown";
+      logger.info(`Current review status: ${status}`);
+      return status;
+    } catch (error) {
+      logger.error(`Failed to query review status: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * 获取 Access Token
+   * @param tokenUrl Token URL
+   * @param clientId 客户端 ID
+   * @param clientSecret 客户端密钥
+   */
+  async getAccessToken(tokenUrl, clientId, clientSecret) {
+    const data = {
+      client_id: clientId,
+      client_secret: clientSecret,
+      grant_type: "client_credentials"
+    };
+    logger.info(`[Huawei Auth] Requesting token with clientId: ${clientId}`);
+    try {
+      const res = await axios2.post(tokenUrl, data, {
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      logger.info(
+        `[Huawei Auth] Token response received, keys: ${Object.keys(res.data).join(", ")}`
+      );
+      const token = res.data.access_token || res.data.token;
+      if (!token) {
+        logger.error(
+          `[Huawei Auth] No token in response. Full response: ${JSON.stringify(res.data)}`
+        );
+        throw new Error(`Invalid token response: ${JSON.stringify(res.data)}`);
+      }
+      logger.info(`[Huawei Auth] Token obtained successfully`);
+      return token;
+    } catch (error) {
+      logger.error(`[Huawei Auth] Token request failed: ${error.message}`);
+      if (error.response?.data) {
+        logger.error(`[Huawei Auth] Error response: ${JSON.stringify(error.response.data)}`);
+      }
+      throw error;
+    }
+  }
+  /** 获取上传 URL */
+  async getUploadUrl(ctx, suffix) {
+    logger.info(`[Huawei Upload] Requesting upload URL for appId: ${ctx.appId}, suffix: ${suffix}`);
+    const res = await axios2.get(`${ctx.apiRoot}/upload-url`, {
+      params: { appId: ctx.appId, suffix },
+      headers: this.headers(ctx)
+    });
+    this.checkResponse(res, "Get upload URL");
+    return {
+      uploadUrl: res.data.uploadUrl,
+      authCode: res.data.authCode
+    };
+  }
+  /** 通用文件上传（FormData 方式，无需 API 认证头） */
+  async executeUploadRequest(uploadUrl, authCode, filePath) {
+    const fileName = path2.basename(filePath);
+    const fileSize = fs4.statSync(filePath).size;
+    const form = new FormData2();
+    form.append("file", fs4.createReadStream(filePath), {
+      filename: fileName,
+      contentType: "application/octet-stream",
+      knownLength: fileSize
+    });
+    form.append("authCode", authCode);
+    form.append("fileCount", "1");
+    form.append("parseType", "1");
+    const length = await promisify(form.getLength).bind(form)();
+    logger.info(
+      `[Huawei Upload] Uploading: ${fileName} (${(fileSize / 1024 / 1024).toFixed(2)} MB)`
+    );
+    const res = await axios2.post(uploadUrl, form, {
+      headers: { ...form.getHeaders(), "Content-Length": length },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+    if (res.data.result?.resultCode !== "0") {
+      throw new Error(`File upload failed: ${JSON.stringify(res.data.result)}`);
+    }
+    const fileInfoList = res.data.result?.UploadFileRsp?.fileInfoList || res.data.result?.uploadFileRsp?.fileInfoList || [];
+    if (fileInfoList.length === 0) {
+      throw new Error("No file info returned from upload");
+    }
+    return fileInfoList.map((f) => ({
+      fileName: f.name || fileName,
+      fileDestUrl: f.fileDestUlr || f.fileDestUrl || authCode
+    }));
+  }
+  /** 上传文件 (APK/AAB) */
+  async uploadFile(uploadUrl, authCode, filePath) {
+    const files = await this.executeUploadRequest(uploadUrl, authCode, filePath);
+    if (files.length > 0 && files[0].fileDestUrl) {
+      logger.info(`[Huawei Upload] App package uploaded, fileDestUrl: ${files[0].fileDestUrl}`);
+      return { fileDestUrl: files[0].fileDestUrl };
+    }
+    throw new Error("Upload succeeded but fileDestUrl not found in response");
+  }
+  /** 更新应用文件信息 */
+  async updateAppFileInfo(ctx, fileDestUrl, filePath) {
+    const fileName = path2.basename(filePath);
+    const fileType = path2.extname(filePath).toLowerCase() === ".aab" ? 7 : 5;
+    const res = await axios2.put(
+      `${ctx.apiRoot}/app-file-info`,
+      {
+        fileType,
+        files: [{ fileName, fileDestUrl }]
+      },
+      {
+        params: { appId: ctx.appId },
+        headers: this.headers(ctx)
+      }
+    );
+    this.checkResponse(res, "Update file info");
+  }
+  /** 更新发布说明（支持多语言） */
+  async updateReleaseNotes(ctx, changelog, version) {
+    const notes = typeof changelog === "string" ? { zh_CN: changelog, en_US: changelog } : changelog;
+    const body = {
+      defaultLanguage: "zh_CN",
+      languages: [
+        {
+          lang: "zh_CN",
+          appName: "",
+          appDesc: "",
+          newFeatures: notes["zh_CN"] || ""
+        },
+        {
+          lang: "en_US",
+          appName: "",
+          appDesc: "",
+          newFeatures: notes["en_US"] || ""
+        }
+      ]
+    };
+    const res = await axios2.put(`${ctx.apiRoot}/app-info`, body, {
+      params: { appId: ctx.appId },
+      headers: this.headers(ctx)
+    });
+    this.checkResponse(res, "Update release notes");
+    logger.info("Release notes updated successfully");
+  }
+  /** 提交审核 */
+  async submitForReview(ctx, version) {
+    const appInfo = await this.getAppInfo(ctx);
+    if (!appInfo?.releaseId) {
+      throw new Error("Could not get release ID for submission");
+    }
+    try {
+      const res = await axios2.post(
+        `${ctx.apiRoot}/app-submit`,
+        {
+          releaseId: appInfo.releaseId,
+          auditDesc: `Version ${version}`
+        },
+        {
+          params: { appId: ctx.appId },
+          headers: this.headers(ctx)
+        }
+      );
+      this.checkResponse(res, "Submit for review");
+      logger.success("App submitted for review successfully");
+    } catch (error) {
+      if (error.response?.status === 404) {
+        logger.warn("Huawei review submission API not yet available. Please submit manually.");
+      } else {
+        throw error;
+      }
+    }
+  }
+  /** 获取应用信息 */
+  async getAppInfo(ctx) {
+    const res = await axios2.get(`${ctx.apiRoot}/app-information`, {
+      params: { appId: ctx.appId },
+      headers: this.headers(ctx)
+    });
+    this.checkResponse(res, "Get app info");
+    return res.data.data;
+  }
+  /** 上传商店素材（图标、截图、视频） */
+  async uploadStoreAssets(ctx, assets, retryStrategy) {
+    const tasks = [];
+    if (assets.icon) {
+      tasks.push({
+        label: "icon",
+        files: [assets.icon],
+        type: 0 /* ICON */
+      });
+    }
+    if (assets.screenshots?.length) {
+      tasks.push({
+        label: `${assets.screenshots.length} screenshot(s)`,
+        files: assets.screenshots,
+        type: 1 /* SCREENSHOT */
+      });
+    }
+    if (assets.video) {
+      tasks.push({
+        label: "preview video",
+        files: [assets.video],
+        type: 2 /* VIDEO */
+      });
+    }
+    for (const task of tasks) {
+      try {
+        logger.info(`Uploading ${task.label}...`);
+        await this.uploadAssetFiles(ctx, task.files, task.type, retryStrategy);
+        logger.success(`${task.label} uploaded successfully`);
+      } catch (error) {
+        logger.warn(`Failed to upload ${task.label}: ${error.message}`);
+      }
+    }
+  }
+  /** 批量上传素材文件 */
+  async uploadAssetFiles(ctx, filePaths, fileType, retryStrategy) {
+    const allFileInfos = [];
+    for (const filePath of filePaths) {
+      if (!await fs4.pathExists(filePath)) {
+        logger.warn(`Asset file not found, skipping: ${filePath}`);
+        continue;
+      }
+      const suffix = path2.extname(filePath).substring(1).toLowerCase();
+      if (!HUAWEI_SUPPORTED_SUFFIXES.image.includes(suffix)) {
+        logger.warn(`Unsupported file type ${suffix}, skipping: ${filePath}`);
+        continue;
+      }
+      const uploadInfoResult = await retryStrategy.execute(
+        () => this.getUploadUrl(ctx, suffix),
+        "Huawei get upload URL for asset"
+      );
+      if (!uploadInfoResult.success || !uploadInfoResult.data) {
+        logger.warn(`Failed to get upload URL for: ${filePath}`);
+        continue;
+      }
+      const uploadInfo = uploadInfoResult.data;
+      const uploadResult = await retryStrategy.execute(
+        () => this.executeUploadRequest(uploadInfo.uploadUrl, uploadInfo.authCode, filePath),
+        "Huawei upload asset"
+      );
+      if (!uploadResult.success || !uploadResult.data) {
+        logger.warn(`Failed to upload: ${filePath}`);
+        continue;
+      }
+      allFileInfos.push(...uploadResult.data);
+    }
+    if (allFileInfos.length === 0) {
+      throw new Error("No assets were uploaded successfully");
+    }
+    await retryStrategy.execute(
+      () => this.updateAssetFileInfo(ctx, allFileInfos, fileType),
+      "Huawei update asset file info"
+    );
+  }
+  /** 更新素材文件信息（关联到应用） */
+  async updateAssetFileInfo(ctx, files, fileType) {
+    const res = await axios2.put(
+      `${ctx.apiRoot}/app-file-info`,
+      {
+        fileType,
+        lang: "zh-CN",
+        files: files.map((f) => ({
+          fileName: f.fileName,
+          fileDestUrl: f.fileDestUrl
+        }))
+      },
+      {
+        params: { appId: ctx.appId },
+        headers: this.headers(ctx)
+      }
+    );
+    this.checkResponse(res, "Update asset file info");
+  }
+};
+
+// src/adapters/xiaomi_uploader.ts
+import fs5 from "fs-extra";
+import axios3 from "axios";
+import FormData3 from "form-data";
+import crypto3 from "crypto";
+var XiaomiUploader = class _XiaomiUploader {
+  name = "Xiaomi";
+  static API_BASE = "https://api.developer.xiaomi.com/devupload";
+  static PUSH_API = `${_XiaomiUploader.API_BASE}/dev/push`;
+  static QUERY_API = `${_XiaomiUploader.API_BASE}/dev/query`;
+  static CATEGORY_API = `${_XiaomiUploader.API_BASE}/dev/category`;
+  /**
+   * RSA 公钥分段加密 (PKCS1Padding)
+   *
+   * 小米要求: 使用平台分配的 RSA 公钥加密 SIG JSON,
+   * 输出小写十六进制字符串。RSA 1024-bit 密钥单次最多加密 117 字节,
+   * 超出需分段加密后拼接。
+   */
+  rsaEncryptWithPublicKey(data, publicKey) {
+    const buffer = Buffer.from(data, "utf-8");
+    const maxBlock = 117;
+    const chunks = [];
+    for (let offset = 0; offset < buffer.length; offset += maxBlock) {
+      const chunk = buffer.subarray(offset, offset + maxBlock);
+      const encrypted = crypto3.publicEncrypt(
+        {
+          key: publicKey,
+          padding: crypto3.constants.RSA_PKCS1_PADDING
+        },
+        chunk
+      );
+      chunks.push(encrypted);
+    }
+    return Buffer.concat(chunks).toString("hex");
+  }
+  /**
+   * 从 X.509 证书或 PEM 公钥中提取可用于加密的公钥
+   * 优先使用 crypto.X509Certificate，因为它能同时处理 DER 和 PEM 格式的证书
+   */
+  extractPublicKey(buffer) {
+    try {
+      const x509 = new crypto3.X509Certificate(buffer);
+      return x509.publicKey;
+    } catch (e) {
+      try {
+        const content = buffer.toString();
+        if (content.includes("-----BEGIN")) {
+          return crypto3.createPublicKey(content);
+        }
+        return crypto3.createPublicKey(this.normalizePEM(content));
+      } catch (e2) {
+        throw new Error(`\u65E0\u6CD5\u63D0\u53D6\u516C\u94A5: ${e instanceof Error ? e.message : "\u672A\u77E5\u9519\u8BEF"}`);
+      }
+    }
+  }
+  /**
+   * 计算文件 MD5 (小写十六进制)
+   */
+  async calculateFileMD5(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto3.createHash("md5");
+      const stream = fs5.createReadStream(filePath);
+      stream.on("data", (data) => hash.update(data));
+      stream.on("end", () => resolve(hash.digest("hex")));
+      stream.on("error", reject);
+    });
+  }
+  /**
+   * 计算字符串 MD5 (小写十六进制)
+   */
+  calculateStringMD5(str) {
+    return crypto3.createHash("md5").update(str, "utf-8").digest("hex");
+  }
+  /**
+   * 构建 RequestData JSON
+   */
+  buildRequestData(params) {
+    const { userName, packageName, appName, updateDesc, uploadType } = params;
+    const synchroType = uploadType === "new" ? 0 : 1;
+    const appInfo = {
+      appName,
+      packageName
+    };
+    if (uploadType === "new") {
+      if (params.category != null) appInfo.category = params.category;
+      if (params.keyWords) appInfo.keyWords = params.keyWords;
+      if (params.desc) appInfo.desc = params.desc;
+      if (params.brief) appInfo.brief = params.brief;
+      if (params.privacyUrl) appInfo.privacyUrl = params.privacyUrl;
+    }
+    if (updateDesc) {
+      appInfo.updateDesc = updateDesc;
+    }
+    const requestDataObj = {
+      userName,
+      appInfo,
+      synchroType
+    };
+    const result = JSON.stringify(requestDataObj);
+    logger.info(`[XIAOMI] \u8C03\u8BD5 - RequestData \u5B57\u7B26\u4E32: ${result}`);
+    return result;
+  }
+  /**
+   * 生成只包含 RequestData 的 SIG（用于查询接口）
+   */
+  generateQuerySIG(requestDataMD5, privateKey, publicKey) {
+    const sigObj = {
+      sig: [{ name: "RequestData", hash: requestDataMD5 }],
+      password: privateKey.trim()
+    };
+    const sigJson = JSON.stringify(sigObj);
+    logger.info(`[XIAOMI] \u8C03\u8BD5 - Query SIG \u5F85\u52A0\u5BC6\u5B57\u7B26\u4E32: ${sigJson}`);
+    const encrypted = this.rsaEncryptWithPublicKey(sigJson, publicKey);
+    logger.info(
+      `[XIAOMI] \u8C03\u8BD5 - Query SIG \u52A0\u5BC6\u7ED3\u679C (Hex, \u524D 20\u4F4D): ${encrypted.substring(0, 20)}...`
+    );
+    return encrypted;
+  }
+  /**
+   * 生成包含 RequestData + apk 的加密 SIG 字符串（用于上传接口）
+   */
+  generateUploadSIG(requestDataMD5, apkFileMD5, privateKey, publicKey, extraFiles) {
+    const sigItems = [
+      { name: "RequestData", hash: requestDataMD5 },
+      { name: "apk", hash: apkFileMD5 }
+    ];
+    if (extraFiles) {
+      sigItems.push(...extraFiles);
+    }
+    const sigObj = {
+      sig: sigItems,
+      password: privateKey.trim()
+    };
+    const sigJson = JSON.stringify(sigObj);
+    logger.info(`[XIAOMI] \u8C03\u8BD5 - Upload SIG \u5F85\u52A0\u5BC6\u5B57\u7B26\u4E32: ${sigJson}`);
+    const encrypted = this.rsaEncryptWithPublicKey(sigJson, publicKey);
+    logger.info(
+      `[XIAOMI] \u8C03\u8BD5 - Upload SIG \u52A0\u5BC6\u7ED3\u679C (Hex, \u524D 20\u4F4D): ${encrypted.substring(0, 20)}...`
+    );
+    return encrypted;
+  }
+  /**
+   * 将用户输入的公钥字符串规范化为 PEM 格式
+   */
+  normalizePEM(publicKey) {
+    if (publicKey.includes("-----BEGIN")) {
+      return publicKey.trim();
+    }
+    const clean = publicKey.replace(/[\s\n\r]+/g, "");
+    const lines = clean.match(/.{1,64}/g) || [];
+    return `-----BEGIN PUBLIC KEY-----
+${lines.join("\n")}
+-----END PUBLIC KEY-----`;
+  }
+  validateConfig(config) {
+    if (!config?.publish?.xiaomi?.enable) return false;
+    const x = config.publish.xiaomi;
+    if (!x.auth?.userName || !x.auth?.privateKey) {
+      logger.error("Xiaomi config missing: userName or privateKey");
+      return false;
+    }
+    if (!x.auth?.publicKeyPath) {
+      logger.error("Xiaomi config missing: publicKeyPath");
+      return false;
+    }
+    return true;
+  }
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "apk";
+  }
+  /**
+   * 查询应用状态
+   * 使用 POST /dev/query 接口，需要 SIG 签名认证
+   *
+   * 返回值说明:
+   * - create: true → 需要通过新增方式上传 (synchroType=0)
+   * - updateVersion: true → 可以更新包 (synchroType=1)
+   * - updateInfo: true → 可以仅更新信息 (synchroType=2)
+   */
+  async queryAppStatus(userName, packageName, privateKey, publicKeyObj) {
+    try {
+      const queryData = {
+        packageName,
+        userName
+      };
+      const requestData = JSON.stringify(queryData);
+      logger.info(`Query RequestData: ${requestData}`);
+      const requestDataMD5 = this.calculateStringMD5(requestData);
+      logger.info(`Query RequestData MD5: ${requestDataMD5}`);
+      const sig = this.generateQuerySIG(requestDataMD5, privateKey, publicKeyObj);
+      const params = new URLSearchParams();
+      params.append("RequestData", requestData);
+      params.append("SIG", sig);
+      const response = await axios3.post(_XiaomiUploader.QUERY_API, params.toString(), {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        timeout: 15e3
+      });
+      const data = response.data;
+      logger.info(`\u67E5\u8BE2\u5E94\u7528\u54CD\u5E94: ${JSON.stringify(data)}`);
+      if (data?.result === -20014) {
+        throw new Error(
+          `\u5C0F\u7C73\u8BA4\u8BC1\u5931\u8D25: \u5BC6\u7801\u9519\u8BEF (result=-20014)\u3002\u8BF7\u68C0\u67E5 publish.xiaomi.auth.privateKey \u662F\u5426\u4E3A\u6700\u65B0\u7684 API \u79C1\u94A5\u3002`
+        );
+      }
+      if (data?.result !== 0) {
+        logger.warn(`\u67E5\u8BE2\u8FD4\u56DE\u975E\u96F6: result=${data?.result}, ${data?.message}`);
+        return { type: "new", queried: false };
+      }
+      const appInfo = data.appInfo || null;
+      if (data.updateVersion === true) {
+        return { type: "update", queried: true, appInfo };
+      }
+      if (data.create === true) {
+        logger.info("\u5E94\u7528\u5DF2\u5728\u540E\u53F0\u521B\u5EFA\u4F46\u5C1A\u672A\u4E0A\u4F20\u8FC7\u5305\uFF0C\u5C06\u8FDB\u5165\u9996\u6B21\u63D0\u5BA1\u6A21\u5F0F");
+        return { type: "new", queried: true, appInfo };
+      }
+      return { type: "update", queried: true, appInfo };
+    } catch (error) {
+      if (error.message.includes("\u5C0F\u7C73\u8BA4\u8BC1\u5931\u8D25")) {
+        throw error;
+      }
+      logger.warn(`\u67E5\u8BE2\u5E94\u7528\u8FDE\u63A5\u5F02\u5E38: ${error.message}\uFF0C\u5C06\u63A8\u6D4B\u4E3A\u65B0\u589E\u5E94\u7528\u6A21\u5F0F`);
+      return { type: "new", queried: false };
+    }
+  }
+  /**
+   * 查询小米应用商店分类列表
+   * POST /dev/category, 无需参数
+   */
+  async queryCategories() {
+    try {
+      const response = await axios3.post(_XiaomiUploader.CATEGORY_API, null, {
+        timeout: 1e4
+      });
+      const data = response.data;
+      if (data?.result === 0 && Array.isArray(data.categories)) {
+        return data.categories;
+      }
+      logger.warn(`\u83B7\u53D6\u5206\u7C7B\u5217\u8868\u5931\u8D25: ${JSON.stringify(data)}`);
+      return null;
+    } catch (error) {
+      logger.warn(`\u83B7\u53D6\u5206\u7C7B\u5217\u8868\u5F02\u5E38: ${error.message}`);
+      return null;
+    }
+  }
+  async upload(filePath, config, metadata) {
+    const xiaomiConfig = config.publish?.xiaomi;
+    const { userName, privateKey, publicKeyPath } = xiaomiConfig.auth;
+    const updateDesc = metadata.changelog || xiaomiConfig?.description || "App Update";
+    const retryConfig = config.retry;
+    if (!fs5.existsSync(filePath)) {
+      return {
+        platform: "xiaomi",
+        success: false,
+        message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`
+      };
+    }
+    const resolvedPublicKey = await this.resolvePublicKey(publicKeyPath);
+    if (!resolvedPublicKey) {
+      return {
+        platform: "xiaomi",
+        success: false,
+        message: "\u65E0\u6CD5\u83B7\u53D6 RSA \u516C\u94A5: publicKeyPath \u672A\u63D0\u4F9B\u6216\u6587\u4EF6\u4E0D\u5B58\u5728"
+      };
+    }
+    const packageName = xiaomiConfig.packageName || this.inferPackageName(filePath);
+    if (!packageName) {
+      return {
+        platform: "xiaomi",
+        success: false,
+        message: "\u7F3A\u5C11 packageName \u914D\u7F6E, \u4E14\u65E0\u6CD5\u4ECE\u6587\u4EF6\u540D\u63A8\u65AD\u5E94\u7528\u5305\u540D"
+      };
+    }
+    const appName = xiaomiConfig.appName || this.inferAppName(packageName);
+    if (!appName) {
+      return {
+        platform: "xiaomi",
+        success: false,
+        message: "\u7F3A\u5C11 appName \u914D\u7F6E, \u4E14\u65E0\u6CD5\u4ECE\u5305\u540D\u63A8\u65AD\u5E94\u7528\u540D\u79F0"
+      };
+    }
+    logger.info("\u5F00\u59CB\u4E0A\u4F20\u5230\u5C0F\u7C73\u5E94\u7528\u5546\u5E97...");
+    logger.info(`\u6587\u4EF6: ${filePath}`);
+    logger.info(`\u5305\u540D: ${packageName}`);
+    logger.info(`\u5E94\u7528\u540D: ${appName}`);
+    const publicKeyObj = this.extractPublicKey(resolvedPublicKey);
+    const configUploadType = xiaomiConfig.uploadType || "auto";
+    let uploadType;
+    let existingAppInfo = null;
+    if (configUploadType === "auto") {
+      logger.info("\u6B63\u5728\u67E5\u8BE2\u5E94\u7528\u4FE1\u606F...");
+      const status = await this.queryAppStatus(userName, packageName, privateKey, publicKeyObj);
+      uploadType = status.type;
+      existingAppInfo = status.appInfo;
+    } else {
+      uploadType = configUploadType;
+    }
+    const uploadTypeDesc = uploadType === "update" ? "\u5E94\u7528\u66F4\u65B0 (synchroType=1)" : "\u65B0\u589E\u5E94\u7528 (synchroType=0)";
+    logger.info(`\u4E0A\u4F20\u7C7B\u578B: ${uploadTypeDesc}`);
+    if (uploadType === "new" && xiaomiConfig.uploadType === "new") {
+      const missing = [];
+      if (xiaomiConfig.category == null) missing.push("category (\u5206\u7C7BID)");
+      if (!xiaomiConfig.desc) missing.push("desc (\u5E94\u7528\u4ECB\u7ECD)");
+      if (missing.length > 0) {
+        return {
+          platform: "xiaomi",
+          success: false,
+          message: `\u9996\u6B21\u63D0\u5BA1\u6A21\u5F0F\u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5: ${missing.join(", ")}\u3002\u8BF7\u5728\u540E\u53F0\u8865\u5168\u6216\u5728\u914D\u7F6E\u4E2D\u6DFB\u52A0\u3002`
+        };
+      }
+    }
+    try {
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      const result = await retryStrategy.execute(
+        () => this.performUpload({
+          filePath,
+          userName,
+          privateKey,
+          publicKey: resolvedPublicKey,
+          packageName,
+          appName,
+          updateDesc,
+          uploadType,
+          category: xiaomiConfig.category || existingAppInfo?.category,
+          keyWords: xiaomiConfig.keyWords || existingAppInfo?.keyWords,
+          desc: xiaomiConfig.desc || existingAppInfo?.desc,
+          brief: xiaomiConfig.brief || existingAppInfo?.brief,
+          privacyUrl: xiaomiConfig.privacyUrl || existingAppInfo?.privacyUrl,
+          assets: xiaomiConfig.assets
+        }),
+        "Xiaomi push upload"
+      );
+      if (!result.success) {
+        throw result.error || new Error("Upload failed");
+      }
+      logger.success("\u4E0A\u4F20\u5230\u5C0F\u7C73\u5E94\u7528\u5546\u5E97\u6210\u529F!");
+      return {
+        platform: "xiaomi",
+        success: true,
+        message: "\u4E0A\u4F20\u6210\u529F, \u7B49\u5F85\u5BA1\u6838",
+        data: result.data,
+        consoleUrl: "https://dev.mi.com/distribute/app/details"
+      };
+    } catch (error) {
+      logger.error(`\u4E0A\u4F20\u5230\u5C0F\u7C73\u5931\u8D25: ${error.message}`);
+      if (error.response?.data) {
+        logger.info(`\u9519\u8BEF\u8BE6\u60C5: ${JSON.stringify(error.response.data)}`);
+      }
+      return {
+        platform: "xiaomi",
+        success: false,
+        message: error.message,
+        error
+      };
+    }
+  }
+  /**
+   * 执行实际的上传操作
+   */
+  async performUpload(params) {
+    const {
+      filePath,
+      userName,
+      privateKey,
+      publicKey,
+      packageName,
+      appName,
+      updateDesc,
+      uploadType,
+      category,
+      keyWords,
+      desc,
+      brief,
+      privacyUrl,
+      assets
+    } = params;
+    const publicKeyObj = this.extractPublicKey(publicKey);
+    const requestData = this.buildRequestData({
+      userName,
+      packageName,
+      appName,
+      updateDesc,
+      uploadType,
+      category,
+      keyWords,
+      desc,
+      brief,
+      privacyUrl
+    });
+    logger.info("RequestData \u5DF2\u6784\u5EFA");
+    logger.info(`RequestData: ${requestData}`);
+    const requestDataMD5 = this.calculateStringMD5(requestData);
+    const apkFileMD5 = await this.calculateFileMD5(filePath);
+    logger.info(`APK MD5: ${apkFileMD5}`);
+    const extraSigItems = [];
+    let iconPath;
+    if (assets?.icon && fs5.existsSync(assets.icon)) {
+      iconPath = assets.icon;
+      const iconMD5 = await this.calculateFileMD5(iconPath);
+      extraSigItems.push({ name: "icon", hash: iconMD5 });
+    }
+    const screenshotPaths = [];
+    if (assets?.screenshots) {
+      for (let i = 0; i < assets.screenshots.length && i < 4; i++) {
+        const ssPath = assets.screenshots[i];
+        if (fs5.existsSync(ssPath)) {
+          screenshotPaths.push(ssPath);
+          const ssMD5 = await this.calculateFileMD5(ssPath);
+          extraSigItems.push({ name: `screenshot_${i + 1}`, hash: ssMD5 });
+        }
+      }
+    }
+    const sig = this.generateUploadSIG(
+      requestDataMD5,
+      apkFileMD5,
+      privateKey,
+      publicKeyObj,
+      extraSigItems.length > 0 ? extraSigItems : void 0
+    );
+    logger.info("SIG \u7B7E\u540D\u5DF2\u751F\u6210");
+    const form = new FormData3();
+    form.append("RequestData", requestData);
+    form.append("SIG", sig);
+    form.append("apk", fs5.createReadStream(filePath));
+    if (iconPath) {
+      form.append("icon", fs5.createReadStream(iconPath));
+      logger.info(`\u9644\u52A0 icon: ${iconPath}`);
+    }
+    for (let i = 0; i < screenshotPaths.length; i++) {
+      form.append(`screenshot_${i + 1}`, fs5.createReadStream(screenshotPaths[i]));
+      logger.info(`\u9644\u52A0 screenshot_${i + 1}: ${screenshotPaths[i]}`);
+    }
+    logger.info(`POST ${_XiaomiUploader.PUSH_API}`);
+    const response = await axios3.post(_XiaomiUploader.PUSH_API, form, {
+      headers: {
+        ...form.getHeaders()
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      timeout: 6e4
+      // 60 秒请求超时
+    });
+    const data = response.data;
+    logger.info(`\u5C0F\u7C73 API \u539F\u59CB\u54CD\u5E94: ${JSON.stringify(data)}`);
+    if (data?.result !== 0) {
+      const errMsg = data?.message || data?.msg || JSON.stringify(data);
+      throw new Error(`\u5C0F\u7C73 API \u8FD4\u56DE\u9519\u8BEF (result=${data?.result}): ${errMsg}`);
+    }
+    logger.info(`\u5C0F\u7C73 API \u54CD\u5E94: ${JSON.stringify(data)}`);
+    return data;
+  }
+  /**
+   * 解析公钥: 优先使用内容字段, 其次从文件路径读取
+   */
+  async resolvePublicKey(publicKeyPath) {
+    if (publicKeyPath) {
+      if (!fs5.existsSync(publicKeyPath)) {
+        logger.error(`\u516C\u94A5\u6587\u4EF6\u4E0D\u5B58\u5728: ${publicKeyPath}`);
+        return null;
+      }
+      return await fs5.readFile(publicKeyPath);
+    }
+    return null;
+  }
+  /**
+   * 尝试从文件名推断包名
+   * 例如: com.example.app-release.apk → com.example.app
+   */
+  inferPackageName(filePath) {
+    const fileName = filePath.split("/").pop()?.split("\\").pop() || "";
+    const match = fileName.match(/^([\w.]+?)(?:-(?:release|debug|unsigned))?\.apk$/i);
+    if (match && match[1].includes(".")) {
+      return match[1];
+    }
+    return null;
+  }
+  /**
+   * 从包名推断应用名称
+   * 例如: com.example.app → app 或 com.app → app
+   */
+  inferAppName(packageName) {
+    const parts = packageName.split(".");
+    if (parts.length === 0) return null;
+    const lastPart = parts[parts.length - 1];
+    const humanized = lastPart.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+    return humanized || null;
+  }
+};
+
+// src/adapters/apple_store_uploader.ts
+import fs6 from "fs-extra";
+import path3 from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import axios4 from "axios";
+var execAsync = promisify2(exec2);
+var APP_STORE_CONNECT_API = "https://api.appstoreconnect.apple.com/v1";
+var TRANSPORTER_APP_PATH = "/Applications/Transporter.app/Contents/itms/bin/iTMSTransporter";
+var AppleStoreUploader = class {
+  name = "AppStore";
+  /**
+   * 验证配置是否有效
+   * 至少需要一种认证方式：
+   * - appleId + appPassword（CLI 上传）
+   * - apiKeyId + apiIssuerId + privateKey（API 调用，也可用于 CLI 上传）
+   */
+  validateConfig(config) {
+    if (!config?.publish?.app_store?.enable) return false;
+    const auth = config.publish.app_store?.auth;
+    const hasCliAuth = auth?.appleId && auth?.appPassword;
+    const hasApiAuth = this.hasApiCredentials(auth);
+    if (!hasCliAuth && !hasApiAuth) {
+      logger.error(
+        "Apple \u914D\u7F6E\u7F3A\u5931\uFF1A\u9700\u8981 (appleId + appPassword) \u6216 (apiKeyId + apiIssuerId + privateKey) \u4E2D\u7684\u4E00\u79CD\u3002"
+      );
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 判断是否支持处理该文件
+   */
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "ipa";
+  }
+  /**
+   * 执行上传流程
+   */
+  async upload(filePath, config, metadata) {
+    const appConfig = config.publish.app_store;
+    const auth = appConfig.auth;
+    const retryConfig = config.retry;
+    logger.info("\u5F00\u59CB\u4E0A\u4F20\u5230 App Store...");
+    try {
+      const exists = await fs6.pathExists(filePath);
+      if (!exists) {
+        throw new Error(`IPA \u6587\u4EF6\u672A\u627E\u5230: ${filePath}`);
+      }
+      const fileSize = (await fs6.stat(filePath)).size;
+      logger.info(`IPA \u6587\u4EF6\u5927\u5C0F: ${(fileSize / (1024 * 1024)).toFixed(2)} MB`);
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      const uploadResult = await retryStrategy.execute(
+        () => this.uploadWithAvailableTool(filePath, auth),
+        "App Store \u4E0A\u4F20"
+      );
+      if (!uploadResult.success) {
+        throw uploadResult.error || new Error("\u4E0A\u4F20\u5931\u8D25");
+      }
+      logger.success("App Store IPA \u4E0A\u4F20\u6210\u529F\uFF01");
+      if (metadata.changelog && this.hasApiCredentials(auth)) {
+        await this.tryUpdateReleaseNotes(auth, appConfig.appId, metadata.changelog, retryStrategy);
+      } else if (metadata.changelog && !this.hasApiCredentials(auth)) {
+        logger.info(
+          "\u8DF3\u8FC7\u66F4\u65B0\u53D1\u884C\u8BF4\u660E\uFF1A\u672A\u914D\u7F6E API Key \u51ED\u636E\u3002\u5982\u9700\u542F\u7528\uFF0C\u8BF7\u5728\u914D\u7F6E\u4E2D\u6DFB\u52A0 apiKeyId + apiIssuerId + privateKeyPath\u3002"
+        );
+      }
+      return {
+        platform: "app_store",
+        success: true,
+        message: "\u4E0A\u4F20\u6210\u529F\u3002\u8BF7\u524D\u5F80 App Store Connect \u67E5\u770B\u3002",
+        url: "https://appstoreconnect.apple.com/apps",
+        consoleUrl: "https://appstoreconnect.apple.com/apps"
+      };
+    } catch (error) {
+      return {
+        platform: "app_store",
+        success: false,
+        message: error.message,
+        error
+      };
+    }
+  }
+  // ───── CLI 上传 ─────
+  /**
+   * 使用可用的工具上传
+   * 策略: 优先 Transporter → 降级 altool → 都失败
+   */
+  async uploadWithAvailableTool(ipaPath, auth) {
+    const appleId = auth.appleId;
+    const appPassword = auth.appPassword;
+    try {
+      logger.info("\u6B63\u5728\u5C1D\u8BD5\u4F7F\u7528 Transporter CLI...");
+      const transporterTool = await this.resolveToolPath("transporter");
+      if (transporterTool) {
+        await this.uploadViaTransporter(transporterTool, ipaPath, appleId, appPassword);
+        logger.success("\u901A\u8FC7 Transporter \u4E0A\u4F20\u5B8C\u6210");
+        return;
+      }
+    } catch (error) {
+      logger.warn(`Transporter \u8C03\u7528\u5931\u8D25: ${error.message}\u3002\u5C1D\u8BD5\u964D\u7EA7\u5230 altool...`);
+    }
+    let altoolTool = null;
+    try {
+      logger.info("\u6B63\u5728\u5C1D\u8BD5\u4F7F\u7528 xcrun altool...");
+      altoolTool = await this.resolveToolPath("altool");
+    } catch (error) {
+      logger.warn(`altool \u68C0\u6D4B\u5931\u8D25: ${error.message}`);
+    }
+    if (altoolTool) {
+      await this.uploadViaAltool(altoolTool, ipaPath, appleId, appPassword);
+      logger.success("\u901A\u8FC7 altool \u4E0A\u4F20\u5B8C\u6210");
+      return;
+    }
+    throw new Error(this.getToolInstallationGuide());
+  }
+  /**
+   * 解析工具路径结果
+   */
+  async resolveToolPath(tool) {
+    if (tool === "transporter") {
+      try {
+        await execAsync("transporter -version", { timeout: 5e3 });
+        return { command: "transporter", useShell: false };
+      } catch {
+      }
+      if (await fs6.pathExists(TRANSPORTER_APP_PATH)) {
+        return { command: `"${TRANSPORTER_APP_PATH}"`, useShell: false };
+      }
+    } else {
+      const xcrunPath = await fs6.pathExists("/usr/bin/xcrun") ? "/usr/bin/xcrun" : "xcrun";
+      try {
+        await execAsync(`${xcrunPath} altool --version`, {
+          timeout: 1e4
+        });
+        return { command: `${xcrunPath} altool`, useShell: false };
+      } catch (error) {
+        logger.warn(
+          `[AppleStore] Direct altool check failed: ${error.message}. Trying shell mode...`
+        );
+      }
+      try {
+        await execAsync(`bash -l -c "xcrun altool --version"`, {
+          timeout: 1e4
+        });
+        return { command: "xcrun altool", useShell: true };
+      } catch (error) {
+        logger.warn(`[AppleStore] Shell altool check failed: ${error.message}`);
+      }
+      return null;
+    }
+    return null;
+  }
+  /**
+   * 通过 Transporter CLI 上传
+   */
+  async uploadViaTransporter(tool, ipaPath, appleId, appPassword) {
+    const command = [
+      tool.command,
+      "-uploadFile",
+      `"${ipaPath}"`,
+      "-username",
+      appleId,
+      "-password",
+      appPassword,
+      "-showTransferRate"
+    ].join(" ");
+    logger.info(`[Transporter] Uploading: ${path3.basename(ipaPath)}`);
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        timeout: 30 * 60 * 1e3,
+        // 30 分钟
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB
+      });
+      if (stdout) {
+        logger.info(`[Transporter] ${stdout}`);
+      }
+      if (stderr && (stderr.includes("error") || stderr.includes("failed") || stderr.includes("ERROR"))) {
+        const errorMessage = this.parseAltoolError(stderr);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      throw new Error(`Transporter upload failed: ${error.message}
+Stderr: ${error.stderr || ""}`);
+    }
+  }
+  /**
+   * 通过 altool 上传
+   */
+  async uploadViaAltool(tool, ipaPath, appleId, appPassword) {
+    const args = [
+      "xcrun altool",
+      // 占位符
+      "--upload-app",
+      "-f",
+      "__IPA_PATH__",
+      // 占位符
+      "-t",
+      "ios",
+      "-u",
+      appleId,
+      "-p",
+      appPassword
+      // '--verbose', // 禁用 verbose
+    ];
+    let command = "";
+    if (tool.useShell) {
+      const innerCommand = args.slice(1).join(" ").replace("__IPA_PATH__", `\\"${ipaPath}\\"`);
+      command = `bash -l -c "${tool.command} ${innerCommand}"`;
+    } else {
+      const innerArgs = args.map((arg) => {
+        if (arg === "xcrun altool") return tool.command;
+        if (arg === "__IPA_PATH__") return `"${ipaPath}"`;
+        return arg;
+      });
+      command = innerArgs.join(" ");
+    }
+    logger.info(`[altool] Uploading: ${path3.basename(ipaPath)}`);
+    logger.info(`[altool] Command prefix: ${tool.command}`);
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        timeout: 30 * 60 * 1e3,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      if (stdout) {
+        if (stdout.includes("No errors uploading") || stdout.includes("Request UUID")) {
+          logger.info(`[altool] ${stdout}`);
+        }
+      }
+      if (stderr && (stderr.includes("error") || stderr.includes("failed") || stderr.includes("ERROR"))) {
+        const errorMessage = this.parseAltoolError(stderr);
+        throw new Error(errorMessage);
+      }
+    } catch (error) {
+      const errorMsg = this.parseAltoolError(error.stderr || error.message);
+      throw new Error(errorMsg);
+    }
+  }
+  /**
+   * 解析 altool/Transporter 错误信息，翻译为用户友好的语言
+   */
+  parseAltoolError(stderr) {
+    if (!stderr) return "Unknown error";
+    if (stderr.includes("previousBundleVersion") || stderr.includes("ENTITY_ERROR.ATTRIBUTE.INVALID.DUPLICATE") || stderr.includes("Redundant Binary Upload") || stderr.includes("already been used")) {
+      const match = stderr.match(/previously uploaded version: ‘(.*?)’/);
+      const prevVersion = match ? match[1] : "unknown";
+      return `\u7248\u672C\u53F7\u51B2\u7A81 (Version Conflict): \u6784\u5EFA\u7248\u672C ${prevVersion} \u5DF2\u5B58\u5728\u4E8E App Store Connect\u3002
+\u89E3\u51B3\u65B9\u6848: \u8BF7\u5728 pubspec.yaml \u4E2D\u589E\u52A0 'version: x.y.z+N' \u4E2D\u7684 N (build number)\uFF0C\u7136\u540E\u91CD\u65B0\u6784\u5EFA IPA\u3002`;
+    }
+    if (stderr.includes("Authentication failed") || stderr.includes("password is incorrect") || stderr.includes("NOT_AUTHORIZED")) {
+      return `\u8BA4\u8BC1\u5931\u8D25 (Auth Failed): Apple ID \u6216 App-specific Password \u9519\u8BEF\u3002
+\u89E3\u51B3\u65B9\u6848: \u8BF7\u68C0\u67E5\u914D\u7F6E\u3002\u6CE8\u610F\u5FC5\u987B\u4F7F\u7528 App \u4E13\u7528\u5BC6\u7801\uFF0C\u4E0D\u80FD\u4F7F\u7528 Apple ID \u767B\u5F55\u5BC6\u7801\u3002`;
+    }
+    if (stderr.includes("Asset validation failed")) {
+      return `\u8D44\u4EA7\u9A8C\u8BC1\u5931\u8D25 (Validation Failed): IPA \u6587\u4EF6\u53EF\u80FD\u4E0D\u7B26\u5408 App Store \u8981\u6C42\u3002
+\u8BE6\u7EC6\u9519\u8BEF: ${stderr}`;
+    }
+    return `\u4E0A\u4F20\u5DE5\u5177\u62A5\u9519: ${stderr.substring(0, 800)}...`;
+  }
+  // ───── 发行说明 API ─────
+  /**
+   * 检查是否配置了 API Key 凭据
+   */
+  hasApiCredentials(auth) {
+    return !!(auth?.apiKeyId && auth?.apiIssuerId && (auth?.privateKeyPath || auth?.privateKeyContent));
+  }
+  /**
+   * 创建 JWT 生成器
+   */
+  async createJWTGenerator(auth) {
+    if (auth.privateKeyContent) {
+      return AppleJWTGenerator.fromContent(auth.apiIssuerId, auth.apiKeyId, auth.privateKeyContent);
+    }
+    return AppleJWTGenerator.fromFile(auth.apiIssuerId, auth.apiKeyId, auth.privateKeyPath);
+  }
+  /**
+   * 获取 API 请求头
+   */
+  apiHeaders(token) {
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * 尝试更新发行说明（失败不影响上传结果）
+   */
+  async tryUpdateReleaseNotes(auth, appId, changelog, retryStrategy) {
+    if (!appId) {
+      logger.info(
+        "\u8DF3\u8FC7\u66F4\u65B0\u53D1\u884C\u8BF4\u660E\uFF1A\u672A\u914D\u7F6E App ID\u3002\u8BF7\u6DFB\u52A0 app_store.appId \u4EE5\u542F\u7528\u81EA\u52A8\u66F4\u65B0\u53D1\u884C\u8BF4\u660E\u3002"
+      );
+      return;
+    }
+    try {
+      logger.info("\u6B63\u5728\u901A\u8FC7 App Store Connect API \u66F4\u65B0\u53D1\u884C\u8BF4\u660E...");
+      const jwtGenerator = await this.createJWTGenerator(auth);
+      const token = jwtGenerator.generate();
+      const version = await this.getPrepareForSubmissionVersion(token, appId);
+      if (!version) {
+        logger.warn(
+          '\u672A\u627E\u5230\u5904\u4E8E"\u51C6\u5907\u63D0\u4EA4 (PREPARE_FOR_SUBMISSION)"\u72B6\u6001\u7684\u7248\u672C\u3002\u5DF2\u8DF3\u8FC7\u66F4\u65B0\u53D1\u884C\u8BF4\u660E\u3002\u8BF7\u5728 App Store Connect \u624B\u52A8\u66F4\u65B0\u3002'
+        );
+        return;
+      }
+      const localizations = await this.getVersionLocalizations(token, version.id);
+      if (localizations.length === 0) {
+        logger.warn("\u8BE5\u7248\u672C\u6CA1\u6709\u627E\u5230\u672C\u5730\u5316\u4FE1\u606F\u3002\u8DF3\u8FC7\u66F4\u65B0\u53D1\u884C\u8BF4\u660E\u3002");
+        return;
+      }
+      for (const loc of localizations) {
+        const locale = loc.attributes?.locale || "unknown";
+        await retryStrategy.execute(
+          () => this.updateLocalizationWhatsNew(token, loc.id, changelog),
+          `\u66F4\u65B0\u53D1\u884C\u8BF4\u660E (${locale})`
+        );
+        logger.info(`\u5DF2\u66F4\u65B0\u53D1\u884C\u8BF4\u660E: ${locale}`);
+      }
+      logger.success("\u6240\u6709\u53D1\u884C\u8BF4\u660E\u66F4\u65B0\u6210\u529F\uFF01");
+    } catch (error) {
+      logger.warn(`\u66F4\u65B0\u53D1\u884C\u8BF4\u660E\u5931\u8D25: ${error.message}\u3002IPA \u4E0A\u4F20\u5DF2\u6210\u529F\u3002\u8BF7\u624B\u52A8\u66F4\u65B0\u53D1\u884C\u8BF4\u660E\u3002`);
+    }
+  }
+  /**
+   * 获取处于"准备提交"状态的版本
+   * 只有此状态下的版本才能修改发行说明
+   */
+  async getPrepareForSubmissionVersion(token, appId) {
+    const res = await axios4.get(`${APP_STORE_CONNECT_API}/apps/${appId}/appStoreVersions`, {
+      params: {
+        "filter[appStoreState]": "PREPARE_FOR_SUBMISSION",
+        limit: 1
+      },
+      headers: this.apiHeaders(token)
+    });
+    const versions = res.data?.data;
+    if (versions && versions.length > 0) {
+      logger.info(
+        `Found version: ${versions[0].attributes?.versionString} (PREPARE_FOR_SUBMISSION)`
+      );
+      return versions[0];
+    }
+    return null;
+  }
+  /**
+   * 获取版本的本地化信息列表
+   */
+  async getVersionLocalizations(token, versionId) {
+    const res = await axios4.get(
+      `${APP_STORE_CONNECT_API}/appStoreVersions/${versionId}/appStoreVersionLocalizations`,
+      {
+        headers: this.apiHeaders(token)
+      }
+    );
+    return res.data?.data || [];
+  }
+  /**
+   * 更新本地化版本的 What's New 内容
+   */
+  async updateLocalizationWhatsNew(token, localizationId, whatsNew) {
+    await axios4.patch(
+      `${APP_STORE_CONNECT_API}/appStoreVersionLocalizations/${localizationId}`,
+      {
+        data: {
+          type: "appStoreVersionLocalizations",
+          id: localizationId,
+          attributes: {
+            whatsNew
+          }
+        }
+      },
+      {
+        headers: this.apiHeaders(token)
+      }
+    );
+  }
+  // ───── 工具安装指引 ─────
+  /**
+   * 获取工具安装指引
+   */
+  getToolInstallationGuide() {
+    return `
+Neither Transporter nor altool CLI found. Please install one:
+
+\u3010\u63A8\u8350\u3011 Transporter CLI (\u5B98\u65B9\u63A8\u8350):
+  Mac:     https://apps.apple.com/app/transporter/id1450874784
+  Windows: https://www.microsoft.com/store/apps/9NBLGGH52RM5
+
+\u3010\u5907\u9009\u3011 xcrun altool (Xcode \u81EA\u5E26):
+  Install Xcode Command Line Tools:
+  xcode-select --install
+
+Note:
+  - \u9700\u8981\u4F7F\u7528 Apple ID \u548C App-specific Password (\u5728 appleid.apple.com \u751F\u6210)
+  - \u4E0D\u80FD\u4F7F\u7528\u666E\u901A Apple ID \u5BC6\u7801
+        `.trim();
+  }
+};
+
+// src/adapters/testflight_uploader.ts
+import fs7 from "fs-extra";
+import axios5 from "axios";
+import FormData4 from "form-data";
+var TestFlightUploader = class _TestFlightUploader {
+  name = "TestFlight";
+  static API_ROOT = "https://api.appstoreconnect.apple.com/v1";
+  static API_TIMEOUT = 3e4;
+  static BUILD_PROCESSING_TIMEOUT = 10 * 60 * 1e3;
+  // 10 minutes
+  static BUILD_POLLING_INTERVAL = 10 * 1e3;
+  // 10 seconds
+  /**
+   * 验证配置
+   * @param config 配置对象
+   */
+  validateConfig(config) {
+    if (!config?.publish?.app_store?.enable) return false;
+    if (config.publish.app_store.mode !== "testflight") return false;
+    const auth = config.publish.app_store.auth;
+    if (!auth?.apiKeyId || !auth?.apiIssuerId) {
+      logger.error("TestFlight config missing: apiKeyId or apiIssuerId");
+      return false;
+    }
+    if (!auth.privateKeyPath && !auth.privateKeyContent) {
+      logger.error("TestFlight config missing: privateKeyPath or privateKeyContent");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 判断是否支持该文件
+   * @param filePath 文件路径
+   */
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "ipa";
+  }
+  /**
+   * 执行上传到 TestFlight
+   * @param filePath 文件路径
+   * @param config 配置
+   * @param metadata 元数据
+   */
+  async upload(filePath, config, metadata) {
+    const appConfig = config.publish.app_store;
+    const auth = appConfig.auth;
+    const testflightConfig = appConfig.testflight;
+    const retryConfig = config.retry;
+    logger.info("Starting TestFlight upload...");
+    try {
+      const exists = await fs7.pathExists(filePath);
+      if (!exists) {
+        throw new Error(`IPA file not found: ${filePath}`);
+      }
+      const fileSize = (await fs7.stat(filePath)).size;
+      logger.info(`IPA file size: ${(fileSize / (1024 * 1024)).toFixed(2)} MB`);
+      const jwtGenerator = await this.loadJWTGenerator(auth);
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      logger.info("Generating JWT token...");
+      const jwt = jwtGenerator.generate();
+      const bundleId = metadata.platform?.includes("ios") ? this.extractBundleId(filePath) : null;
+      if (!bundleId) {
+        throw new Error("Could not determine app bundle ID from IPA");
+      }
+      logger.info(`App bundle ID: ${bundleId}`);
+      logger.info("Creating build record for TestFlight...");
+      const buildResult = await retryStrategy.execute(
+        () => this.createBuild(jwt, bundleId, metadata.version),
+        "TestFlight create build"
+      );
+      if (!buildResult.success || !buildResult.data) {
+        throw buildResult.error || new Error("Failed to create build record");
+      }
+      const buildId = buildResult.data;
+      logger.info(`Build created: ${buildId}`);
+      logger.info("Uploading IPA file to TestFlight (this may take a while)...");
+      const uploadResult = await retryStrategy.execute(
+        () => this.uploadIPAFile(jwt, buildId, filePath),
+        "TestFlight upload file"
+      );
+      if (!uploadResult.success) {
+        throw uploadResult.error || new Error("IPA upload failed");
+      }
+      logger.info("Waiting for build processing (this may take 5-10 minutes)...");
+      await this.waitForBuildProcessing(jwt, buildId, _TestFlightUploader.BUILD_PROCESSING_TIMEOUT);
+      logger.success("Build processing completed");
+      logger.info("Creating Beta Build Version...");
+      const betaBuildResult = await retryStrategy.execute(
+        () => this.createBetaBuildVersion(jwt, buildId),
+        "TestFlight create beta version"
+      );
+      if (!betaBuildResult.success) {
+        logger.warn("Could not create Beta Build Version automatically");
+      }
+      if (testflightConfig?.betaTesters && testflightConfig.betaTesters.length > 0) {
+        logger.info("Adding beta testers...");
+        await this.addBetaTesters(jwt, buildId, testflightConfig.betaTesters, retryStrategy);
+        logger.success("Beta testers added");
+      }
+      if (testflightConfig?.betaBuildLocalization && testflightConfig.betaBuildLocalization.length > 0) {
+        logger.info("Adding beta build localization...");
+        await this.addBetaBuildLocalization(
+          jwt,
+          buildId,
+          testflightConfig.betaBuildLocalization,
+          retryStrategy
+        );
+        logger.success("Beta build localization added");
+      }
+      if (testflightConfig?.autoNotify !== false && testflightConfig?.betaTesters?.length) {
+        logger.info("Notifying beta testers...");
+        await this.notifyBetaTesters(jwt, buildId, metadata.changelog || "New TestFlight build");
+        logger.success("Beta testers notified");
+      }
+      logger.success("TestFlight upload successful!");
+      return {
+        platform: "testflight",
+        success: true,
+        message: "Build uploaded to TestFlight and configured for beta testing",
+        url: `https://appstoreconnect.apple.com/apps/${bundleId}/testflight/builds`
+      };
+    } catch (error) {
+      logger.error(`TestFlight upload failed: ${error.message}`);
+      if (error.response?.data) {
+        logger.info(`Error Data: ${JSON.stringify(error.response.data)}`);
+      }
+      return {
+        platform: "testflight",
+        success: false,
+        message: error.message,
+        error
+      };
+    }
+  }
+  /**
+   * 加载 JWT 生成器
+   * @param auth 认证信息
+   */
+  async loadJWTGenerator(auth) {
+    if (auth.privateKeyContent) {
+      return AppleJWTGenerator.fromContent(auth.apiIssuerId, auth.apiKeyId, auth.privateKeyContent);
+    } else if (auth.privateKeyPath) {
+      return await AppleJWTGenerator.fromFile(auth.apiIssuerId, auth.apiKeyId, auth.privateKeyPath);
+    } else {
+      throw new Error("No Apple private key provided");
+    }
+  }
+  /**
+   * 提取 Bundle ID
+   * @param ipaPath IPA 路径
+   */
+  extractBundleId(ipaPath) {
+    return null;
+  }
+  /**
+   * 创建构建记录
+   * @param jwt JWT
+   * @param bundleId Bundle ID
+   * @param version 版本号
+   */
+  async createBuild(jwt, bundleId, version) {
+    try {
+      const response = await axios5.post(
+        `${_TestFlightUploader.API_ROOT}/builds`,
+        {
+          data: {
+            type: "builds",
+            attributes: {
+              version,
+              uploadedDate: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            relationships: {
+              app: {
+                data: {
+                  type: "apps",
+                  id: bundleId
+                }
+              }
+            }
+          }
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${jwt}`,
+            "Content-Type": "application/json"
+          },
+          timeout: _TestFlightUploader.API_TIMEOUT
+        }
+      );
+      return response.data.data.id;
+    } catch (error) {
+      if (error.response?.status === 401) {
+        throw new Error("Authentication failed: Invalid JWT or API credentials");
+      }
+      throw error;
+    }
+  }
+  /**
+   * 上传 IPA 文件
+   * @param jwt JWT
+   * @param buildId 构建 ID
+   * @param filePath 文件路径
+   */
+  async uploadIPAFile(jwt, buildId, filePath) {
+    const form = new FormData4();
+    form.append("file", fs7.createReadStream(filePath));
+    try {
+      await axios5.post(
+        `${_TestFlightUploader.API_ROOT}/builds/${buildId}/appStoreVersionExternalTestingBuilds`,
+        form,
+        {
+          headers: {
+            Authorization: `Bearer ${jwt}`,
+            ...form.getHeaders()
+          },
+          timeout: 5 * 60 * 1e3,
+          maxContentLength: Infinity,
+          maxBodyLength: Infinity
+        }
+      );
+    } catch (error) {
+      throw new Error(`Failed to upload IPA: ${error.message}`);
+    }
+  }
+  /**
+   * 等待构建处理
+   * @param jwt JWT
+   * @param buildId 构建 ID
+   * @param timeoutMs 超时时间
+   */
+  async waitForBuildProcessing(jwt, buildId, timeoutMs) {
+    const startTime = Date.now();
+    let lastStatus = "PROCESSING";
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        const response = await axios5.get(`${_TestFlightUploader.API_ROOT}/builds/${buildId}`, {
+          headers: {
+            Authorization: `Bearer ${jwt}`,
+            "Content-Type": "application/json"
+          },
+          timeout: _TestFlightUploader.API_TIMEOUT
+        });
+        const processingState = response.data.data.attributes.processingState;
+        if (processingState === "READY_FOR_DISTRIBUTION") {
+          logger.success("Build ready for distribution");
+          return;
+        }
+        if (processingState === "FAILED" || processingState === "INVALID") {
+          throw new Error(`Build processing failed with status: ${processingState}`);
+        }
+        if (processingState !== lastStatus) {
+          logger.info(`Build status: ${processingState}`);
+          lastStatus = processingState;
+        }
+        await new Promise(
+          (resolve) => setTimeout(resolve, _TestFlightUploader.BUILD_POLLING_INTERVAL)
+        );
+      } catch (error) {
+        logger.warn(`Error checking build status: ${error.message}`);
+        await new Promise(
+          (resolve) => setTimeout(resolve, _TestFlightUploader.BUILD_POLLING_INTERVAL)
+        );
+      }
+    }
+    throw new Error(`Build processing timeout after ${(timeoutMs / 1e3 / 60).toFixed(1)} minutes.`);
+  }
+  /**
+   * 创建 Beta 版本（使其可测试）
+   * @param jwt JWT
+   * @param buildId 构建 ID
+   */
+  async createBetaBuildVersion(jwt, buildId) {
+    try {
+      const response = await axios5.post(
+        `${_TestFlightUploader.API_ROOT}/betaBuildVersions`,
+        {
+          data: {
+            type: "betaBuildVersions",
+            attributes: {},
+            relationships: {
+              build: {
+                data: {
+                  type: "builds",
+                  id: buildId
+                }
+              }
+            }
+          }
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${jwt}`,
+            "Content-Type": "application/json"
+          },
+          timeout: _TestFlightUploader.API_TIMEOUT
+        }
+      );
+      return response.data.data.id;
+    } catch (error) {
+      throw new Error(`Failed to create Beta Build Version: ${error.message}`);
+    }
+  }
+  /**
+   * Add beta testers to the build
+   */
+  async addBetaTesters(jwt, buildId, testers, retryStrategy) {
+    for (const testerEmail of testers) {
+      try {
+        await retryStrategy.execute(
+          () => this.addBetaTesterToGroup(jwt, testerEmail, buildId),
+          `TestFlight add tester ${testerEmail}`
+        );
+        logger.info(`\u2713 Added tester: ${testerEmail}`);
+      } catch (error) {
+        logger.warn(`Failed to add tester ${testerEmail}: ${error.message}`);
+      }
+    }
+  }
+  /**
+   * 添加单个测试员到组
+   * @param jwt JWT
+   * @param testerEmail 测试员邮箱
+   * @param buildId 构建 ID
+   */
+  async addBetaTesterToGroup(jwt, testerEmail, buildId) {
+    try {
+      logger.info(`Attempting to add ${testerEmail} to beta testers...`);
+    } catch (error) {
+      throw new Error(`Failed to add beta tester: ${error.message}`);
+    }
+  }
+  /**
+   * Add localization for beta build
+   */
+  async addBetaBuildLocalization(jwt, buildId, localizations, retryStrategy) {
+    for (const localization of localizations) {
+      try {
+        await retryStrategy.execute(
+          () => this.addLocalizationToBuilder(jwt, buildId, localization),
+          `TestFlight add localization ${localization.locale}`
+        );
+        logger.info(`\u2713 Added localization: ${localization.locale}`);
+      } catch (error) {
+        logger.warn(`Failed to add localization ${localization.locale}: ${error.message}`);
+      }
+    }
+  }
+  /**
+   * Add single localization
+   */
+  async addLocalizationToBuilder(jwt, buildId, localization) {
+    try {
+      await axios5.post(
+        `${_TestFlightUploader.API_ROOT}/betaBuildLocalizations`,
+        {
+          data: {
+            type: "betaBuildLocalizations",
+            attributes: {
+              locale: localization.locale,
+              description: localization.description,
+              keywords: localization.keywords?.join(",") || ""
+            },
+            relationships: {
+              build: {
+                data: {
+                  type: "betaBuildVersions",
+                  id: buildId
+                }
+              }
+            }
+          }
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${jwt}`,
+            "Content-Type": "application/json"
+          },
+          timeout: _TestFlightUploader.API_TIMEOUT
+        }
+      );
+    } catch (error) {
+      throw new Error(`Failed to add localization: ${error.message}`);
+    }
+  }
+  /**
+   * 通知测试员
+   * @param jwt JWT
+   * @param buildId 构建 ID
+   * @param message 消息
+   */
+  async notifyBetaTesters(jwt, buildId, message) {
+    try {
+      logger.info("Sending notification to beta testers...");
+    } catch (error) {
+      logger.warn(`Failed to notify testers: ${error.message}`);
+    }
+  }
+};
+
+// src/adapters/adhoc_uploader.ts
+import fs8 from "fs-extra";
+import path4 from "path";
+import { execSync } from "child_process";
+var AdHocUploader = class {
+  name = "AdHoc";
+  /**
+   * 验证配置
+   * @param config 配置对象
+   * @returns 是否有效
+   */
+  validateConfig(config) {
+    if (!config?.publish?.app_store?.enable) return false;
+    const appConfig = config.publish.app_store;
+    const mode = appConfig?.mode;
+    if (mode !== "adhoc") return false;
+    const adhocConfig = appConfig?.adhoc;
+    if (!adhocConfig) {
+      logger.error("Ad Hoc config missing: adhoc configuration");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 判断是否支持该文件
+   * @param filePath 文件路径
+   * @returns 是否支持
+   */
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "ipa";
+  }
+  /**
+   * 执行上传（生成 Ad Hoc 分发包）
+   * @param filePath 文件路径
+   * @param config 配置
+   * @param metadata 元数据
+   */
+  async upload(filePath, config, metadata) {
+    const appConfig = config.publish.app_store;
+    const adhocConfig = appConfig.adhoc;
+    const retryConfig = config.retry;
+    logger.info("Starting Ad Hoc distribution setup...");
+    try {
+      const exists = await fs8.pathExists(filePath);
+      if (!exists) {
+        throw new Error(`IPA file not found: ${filePath}`);
+      }
+      const fileSize = (await fs8.stat(filePath)).size;
+      logger.info(`IPA file size: ${(fileSize / (1024 * 1024)).toFixed(2)} MB`);
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      const bundleId = this.extractBundleId(filePath);
+      if (!bundleId) {
+        logger.warn("Could not determine app bundle ID from IPA");
+      } else {
+        logger.info(`App bundle ID: ${bundleId}`);
+      }
+      logger.info("Verifying Ad Hoc provisioning profile...");
+      const profileInfo = this.verifyProvisioningProfile(
+        adhocConfig.provisioningProfileSpecifier,
+        adhocConfig.teamId
+      );
+      logger.info("Creating Ad Hoc distribution manifest...");
+      const manifestPath = await this.createManifest(
+        filePath,
+        metadata.version,
+        bundleId,
+        metadata.changelog
+      );
+      logger.info("Setting up distribution directory...");
+      const distributionPath = await this.setupDistributionDirectory(filePath, manifestPath);
+      logger.info("Generating installation links...");
+      const installUrl = this.generateInstallUrl(distributionPath, bundleId);
+      const qrCodePath = await this.generateQRCode(installUrl, distributionPath);
+      this.outputDistributionInfo(installUrl, qrCodePath, distributionPath, profileInfo);
+      logger.success("Ad Hoc distribution setup completed!");
+      return {
+        platform: "adhoc",
+        success: true,
+        message: `Ad Hoc package ready for distribution. Install link and QR code generated.`,
+        url: installUrl
+      };
+    } catch (error) {
+      logger.error(`Ad Hoc setup failed: ${error.message}`);
+      return {
+        platform: "adhoc",
+        success: false,
+        message: error.message,
+        error
+      };
+    }
+  }
+  /**
+   * 从 IPA 提取 Bundle ID
+   * @param ipaPath IPA 路径
+   */
+  extractBundleId(ipaPath) {
+    try {
+      return null;
+    } catch (error) {
+      logger.warn(`Failed to extract bundle ID: ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * 验证 Provisioning Profile
+   * @param profileSpecifier Profile 名称
+   * @param teamId 团队 ID
+   */
+  verifyProvisioningProfile(profileSpecifier, teamId) {
+    if (!profileSpecifier) {
+      logger.warn("No provisioning profile specified, will use automatic signing");
+      return {
+        name: "Automatic",
+        teamId: teamId || "Unknown",
+        capacity: 100,
+        usedSlots: 0
+      };
+    }
+    logger.info(`Using provisioning profile: ${profileSpecifier}`);
+    return {
+      name: profileSpecifier,
+      teamId: teamId || "Unknown",
+      capacity: 100,
+      usedSlots: 0
+    };
+  }
+  /**
+   * 创建 manifest.plist 文件
+   * @param ipaPath IPA 路径
+   * @param version 版本号
+   * @param bundleId Bundle ID
+   * @param changelog 更新日志
+   */
+  async createManifest(ipaPath, version, bundleId, changelog) {
+    const ipaFileName = path4.basename(ipaPath);
+    const appName = bundleId || path4.parse(ipaFileName).name;
+    const ipaUrl = `itms-services://?action=download-manifest&url=https://your-distribution-server.com/manifests/${ipaFileName}.plist`;
+    const manifestContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>items</key>
+    <array>
+        <dict>
+            <key>assets</key>
+            <array>
+                <dict>
+                    <key>kind</key>
+                    <string>software-package</string>
+                    <key>url</key>
+                    <string>https://your-distribution-server.com/apps/${ipaFileName}</string>
+                </dict>
+                <dict>
+                    <key>kind</key>
+                    <string>display-image</string>
+                    <key>url</key>
+                    <string>https://your-distribution-server.com/icons/app-icon.png</string>
+                </dict>
+                <dict>
+                    <key>kind</key>
+                    <string>full-size-image</string>
+                    <key>url</key>
+                    <string>https://your-distribution-server.com/icons/app-icon-large.png</string>
+                </dict>
+            </array>
+            <key>metadata</key>
+            <dict>
+                <key>bundle-identifier</key>
+                <string>${bundleId || "com.example.app"}</string>
+                <key>bundle-version</key>
+                <string>${version}</string>
+                <key>kind</key>
+                <string>software</string>
+                <key>title</key>
+                <string>${appName}</string>
+                <key>subtitle</key>
+                <string>${changelog || "New release"}</string>
+            </dict>
+        </dict>
+    </array>
+</dict>
+</plist>`;
+    const manifestPath = `${ipaPath}.plist`;
+    await fs8.writeFile(manifestPath, manifestContent);
+    logger.info(`Manifest created: ${manifestPath}`);
+    return manifestPath;
+  }
+  /**
+   * 设置分发目录结构
+   * @param ipaPath IPA 路径
+   * @param manifestPath Manifest 路径
+   */
+  async setupDistributionDirectory(ipaPath, manifestPath) {
+    const projectRoot = process.cwd();
+    const distributionDir = path4.join(projectRoot, "build", "adhoc-distribution");
+    await fs8.ensureDir(distributionDir);
+    await fs8.ensureDir(path4.join(distributionDir, "apps"));
+    await fs8.ensureDir(path4.join(distributionDir, "manifests"));
+    await fs8.ensureDir(path4.join(distributionDir, "icons"));
+    const ipaFileName = path4.basename(ipaPath);
+    await fs8.copy(ipaPath, path4.join(distributionDir, "apps", ipaFileName));
+    await fs8.copy(manifestPath, path4.join(distributionDir, "manifests", `${ipaFileName}.plist`));
+    logger.info(`Distribution directory: ${distributionDir}`);
+    return distributionDir;
+  }
+  /**
+   * 生成安装链接 (itms-services)
+   * @param distributionPath 分发目录
+   * @param bundleId Bundle ID
+   */
+  generateInstallUrl(distributionPath, bundleId) {
+    const manifestPath = path4.join(distributionPath, "manifests", `*.plist`);
+    return `itms-services://?action=download-manifest&url=file://${manifestPath}`;
+  }
+  /**
+   * 生成二维码
+   * @param url 安装链接
+   * @param distributionPath 分发目录
+   */
+  async generateQRCode(url, distributionPath) {
+    const qrCodePath = path4.join(distributionPath, "install-qrcode.png");
+    try {
+      logger.info(`QR code would be saved to: ${qrCodePath}`);
+      logger.info(`Install URL: ${url}`);
+      return qrCodePath;
+    } catch (error) {
+      logger.warn(`Failed to generate QR code: ${error.message}`);
+      return "";
+    }
+  }
+  /**
+   * 输出分发信息
+   * @param installUrl 安装链接
+   * @param qrCodePath 二维码路径
+   * @param distributionPath 分发目录
+   * @param profileInfo Profile 信息
+   */
+  outputDistributionInfo(installUrl, qrCodePath, distributionPath, profileInfo) {
+    logger.newLine();
+    logger.title("\u{1F4F1} Ad Hoc Distribution Setup Complete");
+    logger.info(`App Name: ${profileInfo.name}`);
+    logger.info(`Team ID: ${profileInfo.teamId}`);
+    logger.info(`Device Capacity: ${profileInfo.capacity}`);
+    logger.info(`Used Slots: ${profileInfo.usedSlots}/${profileInfo.capacity}`);
+    logger.newLine();
+    logger.info("\u{1F4E6} Distribution Files:");
+    logger.info(`  Directory: ${distributionPath}`);
+    logger.info(`  IPA: ${path4.join(distributionPath, "apps", "*.ipa")}`);
+    logger.info(`  Manifest: ${path4.join(distributionPath, "manifests", "*.plist")}`);
+    logger.info(`  QR Code: ${qrCodePath}`);
+    logger.newLine();
+    logger.info("\u{1F517} Installation Link:");
+    logger.info(`  ${installUrl}`);
+    logger.newLine();
+    logger.info("\u{1F4E4} Distribution Options:");
+    logger.info("  1. Share via\u84B2\u516C\u82F1: Upload to Pgyer for easy distribution");
+    logger.info("  2. Share QR code with testers");
+    logger.info("  3. Host manifest and IPA on your server");
+    logger.info("  4. Use enterprise distribution service");
+    logger.newLine();
+    logger.info("\u26A0\uFE0F  Important:");
+    logger.info("  \u2022 Devices must be registered in your Apple Developer account");
+    logger.info("  \u2022 Maximum 100 devices per app, per year");
+    logger.info("  \u2022 App must be signed with Ad Hoc provisioning profile");
+    logger.info("  \u2022 Cannot be distributed via App Store");
+  }
+  /**
+   * 检查是否安装了 Xcode
+   * @returns 是否安装
+   */
+  checkXcodeInstalled() {
+    try {
+      execSync("xcode-select -p", { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 生成 Ad Hoc 导出选项 (ExportOptions.plist)
+   * @param teamId 团队 ID
+   * @param signingIdentity 签名证书
+   * @param provisioningProfile Profile 名称
+   */
+  generateExportOptions(teamId, signingIdentity, provisioningProfile) {
+    const options = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>method</key>
+    <string>ad-hoc</string>
+    <key>signingStyle</key>
+    <string>automatic</string>
+    <key>stripSwiftSymbols</key>
+    <true/>
+    <key>teamID</key>
+    <string>${teamId || ""}</string>
+    ${signingIdentity ? `<key>signingCertificate</key><string>${signingIdentity}</string>` : ""}
+    ${provisioningProfile ? `<key>provisioningProfileSpecifier</key><string>${provisioningProfile}</string>` : ""}
+</dict>
+</plist>`;
+    return options;
+  }
+};
+
+// src/adapters/harmony_uploader.ts
+import fs9 from "fs-extra";
+import path5 from "path";
+import axios6 from "axios";
+import FormData5 from "form-data";
+var HarmonyUploader = class _HarmonyUploader {
+  name = "HarmonyOS";
+  static TOKEN_URL = "https://connect-api.cloud.huawei.com/api/oauth2/v1/token";
+  static PUBLISH_API_ROOT = "https://connect-api.cloud.huawei.com/api/publish/v2";
+  validateConfig(config) {
+    if (!config?.publish?.harmony?.enable) return false;
+    const h = config.publish.harmony;
+    if (!h.auth?.clientId || !h.auth?.clientSecret || !h.appId) {
+      logger.error("Harmony config missing: clientId, clientSecret, or appId");
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 判断是否支持该文件
+   * @param filePath 文件路径
+   */
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "hap" || ext === "app";
+  }
+  async upload(filePath, config, metadata) {
+    const harmonyConfig = config.publish.harmony;
+    const clientId = harmonyConfig.auth.clientId;
+    const clientSecret = harmonyConfig.auth.clientSecret;
+    const appId = harmonyConfig.appId;
+    const releaseType = harmonyConfig.releaseType || "draft";
+    const suffix = path5.extname(filePath).substring(1);
+    const retryConfig = config.retry;
+    logger.info("Starting HarmonyOS AppGallery upload...");
+    try {
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      logger.info("Authenticating...");
+      const tokenResult = await retryStrategy.execute(
+        () => this.getAccessToken(clientId, clientSecret),
+        "Harmony authentication"
+      );
+      if (!tokenResult.success || !tokenResult.data) {
+        throw tokenResult.error || new Error("Failed to get access token");
+      }
+      const token = tokenResult.data;
+      logger.info("Requesting upload URL...");
+      const uploadInfoResult = await retryStrategy.execute(
+        () => this.getUploadUrl(token, appId, suffix),
+        "Harmony get upload URL"
+      );
+      if (!uploadInfoResult.success || !uploadInfoResult.data) {
+        throw uploadInfoResult.error || new Error("Failed to get upload URL");
+      }
+      const uploadInfo = uploadInfoResult.data;
+      logger.info("Uploading HarmonyOS package...");
+      const uploadFileResult = await retryStrategy.execute(
+        () => this.uploadFile(uploadInfo.uploadUrl, uploadInfo.authCode, filePath),
+        "Harmony file upload"
+      );
+      if (!uploadFileResult.success) {
+        throw uploadFileResult.error || new Error("File upload failed");
+      }
+      logger.info("Linking file to app...");
+      const updateInfoResult = await retryStrategy.execute(
+        () => this.updateAppFileInfo(token, appId, uploadInfo.authCode, filePath),
+        "Harmony update file info"
+      );
+      if (!updateInfoResult.success) {
+        throw updateInfoResult.error || new Error("Failed to update file info");
+      }
+      if (releaseType === "submit") {
+        logger.info("Submitting to review...");
+      }
+      logger.success("HarmonyOS upload successful!");
+      return {
+        platform: "harmony",
+        success: true,
+        message: "Upload success",
+        url: "https://developer.huawei.com/consumer/cn/service/josp/agc/index.html"
+      };
+    } catch (error) {
+      logger.error(`HarmonyOS upload failed: ${error.message}`);
+      return {
+        platform: "harmony",
+        success: false,
+        message: error.message,
+        error
+      };
+    }
+  }
+  /**
+   * 获取 Access Token
+   * @param clientId 客户端 ID
+   * @param clientSecret 客户端密钥
+   */
+  async getAccessToken(clientId, clientSecret) {
+    const data = {
+      client_id: clientId,
+      client_secret: clientSecret,
+      grant_type: "client_credentials"
+    };
+    const res = await axios6.post(_HarmonyUploader.TOKEN_URL, data);
+    if (!res.data.access_token) {
+      throw new Error("Failed to get access token");
+    }
+    return res.data.access_token;
+  }
+  /**
+   * 获取上传 URL
+   * @param token Token
+   * @param appId 应用 ID
+   * @param suffix 后缀
+   */
+  async getUploadUrl(token, appId, suffix) {
+    const res = await axios6.get(`${_HarmonyUploader.PUBLISH_API_ROOT}/upload-url`, {
+      params: { appId, suffix },
+      headers: { Authorization: `Bearer ${token}`, client_id: appId }
+    });
+    if (res.data.code != "0") {
+      throw new Error(`Get upload url failed: ${res.data.msg}`);
+    }
+    return {
+      uploadUrl: res.data.uploadUrl,
+      authCode: res.data.authCode
+    };
+  }
+  async uploadFile(uploadUrl, authCode, filePath) {
+    const form = new FormData5();
+    form.append("file", fs9.createReadStream(filePath));
+    form.append("authCode", authCode);
+    form.append("fileCount", "1");
+    const res = await axios6.post(uploadUrl, form, {
+      headers: { ...form.getHeaders() },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+    if (res.data.result.resultCode != "0") {
+      throw new Error(`File upload failed: ${JSON.stringify(res.data.result)}`);
+    }
+  }
+  /**
+   * 更新应用文件信息
+   * @param token Token
+   * @param appId 应用 ID
+   * @param authCode 授权码
+   * @param filePath 文件路径
+   */
+  async updateAppFileInfo(token, appId, authCode, filePath) {
+    const fileName = path5.basename(filePath);
+    const body = {
+      fileType: 7,
+      // 鸿蒙包的 fileType（需要根据华为最新文档确认）
+      files: [
+        {
+          fileName,
+          fileDestUrl: authCode
+        }
+      ]
+    };
+    const res = await axios6.put(`${_HarmonyUploader.PUBLISH_API_ROOT}/app-file-info`, body, {
+      params: { appId },
+      headers: { Authorization: `Bearer ${token}`, client_id: appId }
+    });
+    if (res.data.ret.code != 0) {
+      throw new Error(`Update file info failed: ${res.data.ret.msg}`);
+    }
+  }
+};
+
+// src/adapters/oppo_uploader.ts
+import fs10 from "fs-extra";
+import path6 from "path";
+import axios7 from "axios";
+import FormData6 from "form-data";
+import crypto4 from "crypto";
+var OppoUploader = class _OppoUploader {
+  name = "OPPO";
+  /** OPPO 开放 API 基础地址 */
+  static API_BASE = "https://oop-openapi-cn.heytapmobi.com";
+  /** 获取 token 接口 */
+  static TOKEN_API = `${_OppoUploader.API_BASE}/developer/v1/token`;
+  /** 获取上传 URL 接口 */
+  static UPLOAD_URL_API = `${_OppoUploader.API_BASE}/resource/v1/upload/get-upload-url`;
+  /** 上传完成后提交版本 */
+  static SUBMIT_API = `${_OppoUploader.API_BASE}/resource/v1/app/upd`;
+  /** 查询应详情接口 */
+  static APP_INFO_API = `${_OppoUploader.API_BASE}/resource/v1/app/info`;
+  /**
+   * OPPO API 签名生成
+   * OPPO 使用 HMAC-SHA256 签名机制
+   */
+  generateSign(params, clientSecret) {
+    const sorted = Object.keys(params).sort().filter((key) => params[key] !== void 0 && params[key] !== null).map((key) => `${key}=${params[key]}`).join("&");
+    return crypto4.createHmac("sha256", clientSecret).update(sorted).digest("hex");
+  }
+  validateConfig(config) {
+    if (!config?.publish?.oppo?.enable) return false;
+    const oppo = config.publish.oppo;
+    if (!oppo.auth?.clientId || !oppo.auth?.clientSecret) {
+      logger.error("OPPO config missing: clientId or clientSecret");
+      return false;
+    }
+    return true;
+  }
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "apk";
+  }
+  /**
+   * 尝试从文件名推断包名
+   */
+  inferPackageName(filePath) {
+    const fileName = path6.basename(filePath);
+    const match = fileName.match(/^([\w.]+?)(?:-(?:release|debug|unsigned))?\.apk$/i);
+    if (match && match[1].includes(".")) {
+      return match[1];
+    }
+    return null;
+  }
+  /**
+   * 从包名推断应用名称
+   */
+  inferAppName(packageName) {
+    const parts = packageName.split(".");
+    if (parts.length === 0) return null;
+    const lastPart = parts[parts.length - 1];
+    return lastPart.charAt(0).toUpperCase() + lastPart.slice(1);
+  }
+  async upload(filePath, config, metadata) {
+    const oppoConfig = config.publish.oppo;
+    const clientId = oppoConfig.auth.clientId;
+    const clientSecret = oppoConfig.auth.clientSecret;
+    const packageName = oppoConfig.packageName || this.inferPackageName(filePath);
+    if (!packageName) {
+      return {
+        platform: "oppo",
+        success: false,
+        message: "\u65E0\u6CD5\u83B7\u53D6\u5305\u540D (packageName)\uFF0C\u8BF7\u5728\u914D\u7F6E\u4E2D\u6307\u5B9A\u6216\u786E\u4FDD\u6587\u4EF6\u540D\u5305\u542B\u5305\u540D",
+        consoleUrl: "https://open.oppomobile.com/new/ecology/app"
+      };
+    }
+    const retryConfig = config.retry;
+    const consoleUrl = "https://open.oppomobile.com/new/ecology/app";
+    if (!fs10.existsSync(filePath)) {
+      return {
+        platform: "oppo",
+        success: false,
+        message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`,
+        consoleUrl
+      };
+    }
+    logger.info("\u5F00\u59CB\u4E0A\u4F20\u5230 OPPO \u5E94\u7528\u5546\u5E97...");
+    logger.info(`\u6587\u4EF6: ${filePath}`);
+    try {
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      logger.info("\u6B63\u5728\u83B7\u53D6 access_token...");
+      const tokenResult = await retryStrategy.execute(
+        () => this.getAccessToken(clientId, clientSecret),
+        "OPPO authentication"
+      );
+      if (!tokenResult.success || !tokenResult.data) {
+        throw tokenResult.error || new Error("Failed to get access token");
+      }
+      const accessToken = tokenResult.data;
+      logger.info("\u6B63\u5728\u83B7\u53D6\u73B0\u6709\u5E94\u7528\u8BE6\u60C5...");
+      const appInfoResult = await retryStrategy.execute(
+        () => this.getAppInfo(accessToken, clientSecret, packageName),
+        "OPPO get app info"
+      );
+      const onlineAppInfo = appInfoResult.data || {};
+      if (onlineAppInfo) {
+        logger.info(
+          `\u83B7\u53D6\u5230\u7EBF\u4E0A\u4FE1\u606F: ${onlineAppInfo.app_name} (Category: ${onlineAppInfo.second_category_id})`
+        );
+        logger.info(`[OPPO AppInfo Full] ${JSON.stringify(onlineAppInfo)}`);
+      }
+      logger.info("\u6B63\u5728\u83B7\u53D6\u4E0A\u4F20\u5730\u5740...");
+      const uploadUrlResult = await retryStrategy.execute(
+        () => this.getUploadUrl(accessToken, clientSecret),
+        "OPPO get upload URL"
+      );
+      if (!uploadUrlResult.success || !uploadUrlResult.data) {
+        throw uploadUrlResult.error || new Error("Failed to get upload URL");
+      }
+      const { uploadUrl, sign: uploadSign } = uploadUrlResult.data;
+      logger.info("\u6B63\u5728\u4E0A\u4F20 APK \u6587\u4EF6...");
+      const uploadFileResult = await retryStrategy.execute(
+        () => this.uploadFile(uploadUrl, uploadSign, filePath),
+        "OPPO file upload"
+      );
+      if (!uploadFileResult.success || !uploadFileResult.data) {
+        throw uploadFileResult.error || new Error("File upload failed");
+      }
+      const rawUrl = uploadFileResult.data.url;
+      const fileUrl = rawUrl.replace(/^http:\/\//i, "https://").replace("storedl1.nearme.com.cn", "storedl.nearme.com.cn");
+      const md5 = uploadFileResult.data.md5;
+      logger.info("\u6B63\u5728\u63D0\u4EA4\u7248\u672C\u4FE1\u606F...");
+      const submitResult = await retryStrategy.execute(
+        () => this.submitVersion({
+          accessToken,
+          clientSecret,
+          packageName,
+          appName: oppoConfig.appName || metadata.appName || onlineAppInfo.app_name || this.inferAppName(packageName),
+          fileUrl,
+          fileMd5: md5,
+          versionName: metadata.version,
+          versionCode: metadata.buildNumber,
+          updateDesc: metadata.changelog || "App Update",
+          onlineType: oppoConfig.onlineType,
+          // 从配置读取
+          onlineAppInfo
+          // 传入线上信息
+        }),
+        "OPPO submit version"
+      );
+      if (!submitResult.success) {
+        throw submitResult.error || new Error("Submit version failed");
+      }
+      logger.success("\u4E0A\u4F20\u5230 OPPO \u5E94\u7528\u5546\u5E97\u6210\u529F!");
+      return {
+        platform: "oppo",
+        success: true,
+        message: "\u4E0A\u4F20\u6210\u529F, \u8BF7\u524D\u5F80\u540E\u53F0\u786E\u8BA4\u5E76\u63D0\u4EA4\u5BA1\u6838",
+        consoleUrl
+      };
+    } catch (error) {
+      logger.error(`\u4E0A\u4F20\u5230 OPPO \u5931\u8D25: ${error.message}`);
+      return {
+        platform: "oppo",
+        success: false,
+        message: this.formatError(error),
+        error,
+        consoleUrl
+      };
+    }
+  }
+  /**
+   * 获取 access_token
+   * 官方文档: https://open.oppomobile.com/documentation/page/info?id=10998
+   */
+  async getAccessToken(clientId, clientSecret) {
+    const params = {
+      client_id: clientId,
+      client_secret: clientSecret
+    };
+    logger.info(`[OPPO Auth Debug] clientId: ${clientId}`);
+    logger.info(`[OPPO Auth Debug] clientSecret length: ${clientSecret?.length || 0}`);
+    logger.info(`[OPPO Auth Debug] params: ${JSON.stringify(params)}`);
+    const res = await axios7.get(_OppoUploader.TOKEN_API, {
+      params,
+      timeout: 15e3
+    });
+    logger.info(`[OPPO Auth Response] status: ${res.status}, data: ${JSON.stringify(res.data)}`);
+    if (res.data.errno !== 0) {
+      throw new Error(`\u83B7\u53D6 token \u5931\u8D25: ${res.data.data?.message || JSON.stringify(res.data)}`);
+    }
+    return res.data.data.access_token;
+  }
+  /**
+   * 获取应用详情
+   */
+  async getAppInfo(accessToken, clientSecret, packageName) {
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const params = {
+      access_token: accessToken,
+      pkg_name: packageName,
+      timestamp
+    };
+    const apiSign = this.generateSign(params, clientSecret);
+    try {
+      const res = await axios7.get(_OppoUploader.APP_INFO_API, {
+        params: {
+          ...params,
+          api_sign: apiSign
+        },
+        timeout: 15e3
+      });
+      if (res.data.errno !== 0) {
+        logger.warn(`\u83B7\u53D6\u5E94\u7528\u8BE6\u60C5\u5931\u8D25 (\u975E\u81F4\u547D): ${JSON.stringify(res.data)}`);
+        return null;
+      }
+      return res.data.data;
+    } catch (error) {
+      logger.warn(`\u83B7\u53D6\u5E94\u7528\u8BE6\u60C5\u8BF7\u6C42\u5F02\u5E38 (\u975E\u81F4\u547D): ${error.message}`);
+      return null;
+    }
+  }
+  /**
+   * 获取上传地址
+   */
+  async getUploadUrl(accessToken, clientSecret) {
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const params = {
+      access_token: accessToken,
+      timestamp
+    };
+    const apiSign = this.generateSign(params, clientSecret);
+    const res = await axios7.get(_OppoUploader.UPLOAD_URL_API, {
+      params: {
+        ...params,
+        api_sign: apiSign
+      },
+      timeout: 15e3
+    });
+    if (res.data.errno !== 0) {
+      throw new Error(`\u83B7\u53D6\u4E0A\u4F20\u5730\u5740\u5931\u8D25: ${res.data.data?.message || JSON.stringify(res.data)}`);
+    }
+    return {
+      uploadUrl: res.data.data.upload_url,
+      sign: res.data.data.sign
+    };
+  }
+  /**
+   * 上传 APK 文件
+   */
+  async uploadFile(uploadUrl, sign, filePath) {
+    const form = new FormData6();
+    form.append("file", fs10.createReadStream(filePath));
+    form.append("sign", sign);
+    form.append("type", "apk");
+    const res = await axios7.post(uploadUrl, form, {
+      headers: form.getHeaders(),
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      timeout: 3e5
+      // 5 分钟超时
+    });
+    if (res.data.errno !== 0) {
+      throw new Error(`\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25: ${res.data.data?.message || JSON.stringify(res.data)}`);
+    }
+    return {
+      url: res.data.data.url,
+      md5: res.data.data.md5
+    };
+  }
+  /**
+   * 提交版本信息
+   */
+  async submitVersion(params) {
+    logger.info(`[OPPO Submit Params] ${JSON.stringify(params)}`);
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const online = params.onlineAppInfo || {};
+    let vCode = params.versionCode;
+    if (!vCode || vCode === "0" || vCode === "") {
+      const parts = params.versionName.split("+");
+      if (parts.length > 1) {
+        vCode = parts[1];
+      } else {
+        vCode = "1";
+      }
+    }
+    const signParams = {
+      access_token: params.accessToken,
+      timestamp,
+      // OPPO 官方要求 apk_url 为 JSON 数组格式：[{url, md5, cpu_code}]
+      // cpu_code: 0=通用包, 3=arm64-v8a, 4=armeabi-v7a, 5=x86_64
+      apk_url: JSON.stringify([
+        {
+          url: params.fileUrl,
+          md5: params.fileMd5,
+          cpu_code: 0
+          // 通用包
+        }
+      ]),
+      version_name: params.versionName.split("+")[0],
+      // 仅保留版本名部分
+      version_code: vCode,
+      update_desc: params.updateDesc,
+      pkg_name: params.packageName,
+      app_name: params.appName,
+      // 补充 OPPO 提交审核的必填项 (优先复用线上数据)
+      summary: online.summary || params.updateDesc.slice(0, 15),
+      detail_desc: online.detail_desc || (params.updateDesc.length >= 20 ? params.updateDesc : `${params.updateDesc}, \u6B64\u7248\u672C\u4F18\u5316\u4E86\u7528\u6237\u4F53\u9A8C\u5E76\u4FEE\u590D\u4E86\u5DF2\u77E5\u95EE\u9898\u3002`),
+      privacy_source_url: online.privacy_source_url || `https://open.oppomobile.com/privacy/${params.packageName}`
+    };
+    const mapField = (key, onlineKey) => {
+      const val = online[onlineKey || key];
+      if (val !== void 0 && val !== null && val !== "") {
+        signParams[key] = val;
+      }
+    };
+    mapField("first_category_id");
+    mapField("second_category_id");
+    mapField("third_category_id");
+    if (params.onlineType) {
+      signParams.online_type = params.onlineType;
+    } else {
+      mapField("online_type");
+    }
+    if (!signParams.online_type) {
+      signParams.online_type = "1";
+    }
+    mapField("version_type");
+    mapField("adaptive_equipment");
+    {
+      const val = online["adaptive_type"];
+      if (val !== void 0 && val !== null && val !== "" && String(val) !== "0") {
+        signParams.adaptive_type = val;
+      }
+    }
+    mapField("test_desc");
+    if (!signParams.test_desc) {
+      signParams.test_desc = "\u65E0\u7279\u6B8A\u6D4B\u8BD5\u8BF4\u660E";
+    }
+    mapField("business_username");
+    mapField("business_email");
+    mapField("business_mobile");
+    mapField("customer_contact");
+    if (!signParams.business_username) signParams.business_username = "\u5F00\u53D1\u8D1F\u8D23\u4EBA";
+    if (!signParams.business_email) signParams.business_email = "developer@example.com";
+    if (!signParams.business_mobile) signParams.business_mobile = "13800138000";
+    mapField("copyright_url");
+    mapField("age_level");
+    if (!signParams.age_level) {
+      signParams.age_level = "18";
+    }
+    mapField("icon_url");
+    if (online.pic_url_material && Array.isArray(online.pic_url_material)) {
+      const MAX_SIZE = 1 * 1024 * 1024;
+      const validPicUrls = online.pic_url_material.filter((item) => {
+        return !item.size || Number(item.size) <= MAX_SIZE;
+      }).map((item) => item.url).filter(Boolean);
+      if (validPicUrls.length > 0) {
+        signParams.pic_url = validPicUrls.join(",");
+      } else {
+        mapField("pic_url");
+      }
+    } else {
+      mapField("pic_url");
+    }
+    mapField("is_safe_check");
+    const apiSign = this.generateSign(signParams, params.clientSecret);
+    const data = new URLSearchParams();
+    Object.entries(signParams).forEach(([key, value]) => {
+      data.append(key, String(value));
+    });
+    data.append("api_sign", apiSign);
+    logger.info(`[OPPO Submit Debug] URL: ${_OppoUploader.SUBMIT_API}`);
+    logger.info(`[OPPO Submit Debug] Body: ${data.toString()}`);
+    const res = await axios7.post(_OppoUploader.SUBMIT_API, data.toString(), {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      timeout: 3e4
+    });
+    logger.info(`[OPPO Submit Response] status: ${res.status}, data: ${JSON.stringify(res.data)}`);
+    if (res.data.errno !== 0) {
+      throw new Error(`\u63D0\u4EA4\u7248\u672C\u5931\u8D25: ${res.data.data?.message || JSON.stringify(res.data)}`);
+    }
+    logger.info("\u7248\u672C\u4FE1\u606F\u5DF2\u63D0\u4EA4");
+  }
+  /**
+   * 格式化错误信息
+   */
+  formatError(error) {
+    if (error.response?.data) {
+      const data = error.response.data;
+      return data.data?.message || data.message || error.message;
+    }
+    return error.message;
+  }
+};
+
+// src/adapters/vivo_uploader.ts
+import fs11 from "fs-extra";
+import path7 from "path";
+import axios8 from "axios";
+import FormData7 from "form-data";
+import crypto5 from "crypto";
+var VivoUploader = class _VivoUploader {
+  name = "vivo";
+  /** vivo 开放 API 基础地址 */
+  static API_BASE = "https://developer-api.vivo.com.cn/router/rest";
+  /**
+   * vivo API 签名生成
+   * 规则: 所有参数按 ASCII 码排序后拼接为 key=val&... 字符串，
+   *       以 accessSecret 为密钥进行 HMAC-SHA256 加密，结果转为小写 16 进制字符串
+   */
+  generateSign(params, accessSecret) {
+    const sorted = Object.keys(params).sort().filter((key) => params[key] !== void 0 && params[key] !== null).map((key) => `${key}=${params[key]}`).join("&");
+    const sign = crypto5.createHmac("sha256", accessSecret).update(sorted).digest("hex");
+    logger.info(`[VIVO DEBUG] \u5F85\u7B7E\u540D\u4E32: ${sorted} 
+ -> \u7B7E\u540D\u7ED3\u679C: ${sign}`);
+    return sign;
+  }
+  validateConfig(config) {
+    if (!config?.publish?.vivo?.enable) return false;
+    const vivo = config.publish.vivo;
+    if (!vivo.auth?.accessKey || !vivo.auth?.accessSecret) {
+      logger.error("vivo config missing: accessKey or accessSecret");
+      return false;
+    }
+    return true;
+  }
+  canHandle(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    return ext === "apk";
+  }
+  async upload(filePath, config, metadata) {
+    const vivoConfig = config.publish.vivo;
+    const accessKey = vivoConfig.auth.accessKey;
+    const accessSecret = vivoConfig.auth.accessSecret;
+    const retryConfig = config.retry;
+    const consoleUrl = "https://dev.vivo.com.cn/manage/app";
+    if (!fs11.existsSync(filePath)) {
+      return {
+        platform: "vivo",
+        success: false,
+        message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`,
+        consoleUrl
+      };
+    }
+    const fileSize = fs11.statSync(filePath).size;
+    logger.info("\u5F00\u59CB\u4E0A\u4F20\u5230 vivo \u5E94\u7528\u5546\u5E97...");
+    logger.info(`\u6587\u4EF6: ${filePath} (${(fileSize / 1024 / 1024).toFixed(2)} MB)`);
+    try {
+      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      const fileMd5 = await this.calculateFileMD5(filePath);
+      logger.info("\u6B63\u5728\u4E0A\u4F20 APK \u6587\u4EF6...");
+      const packageName = vivoConfig.packageName || "";
+      const uploadFileResult = await retryStrategy.execute(
+        () => this.uploadApk(accessKey, accessSecret, filePath, packageName, fileMd5),
+        "vivo file upload"
+      );
+      if (!uploadFileResult.success || !uploadFileResult.data) {
+        throw uploadFileResult.error || new Error("File upload failed or no serialnumber returned");
+      }
+      const serialnumber = uploadFileResult.data;
+      logger.info("\u6B63\u5728\u63D0\u4EA4\u7248\u672C\u4FE1\u606F...");
+      const submitResult = await retryStrategy.execute(
+        () => this.submitVersion(accessKey, accessSecret, {
+          serialnumber,
+          packageName: vivoConfig.packageName,
+          versionCode: parseInt(metadata.buildNumber) || 1,
+          fileMd5,
+          updateDesc: metadata.changelog || "App Update"
+        }),
+        "vivo submit version"
+      );
+      if (!submitResult.success) {
+        throw submitResult.error || new Error("Submit version failed");
+      }
+      logger.success("\u4E0A\u4F20\u5230 vivo \u5E94\u7528\u5546\u5E97\u6210\u529F!");
+      return {
+        platform: "vivo",
+        success: true,
+        message: "\u4E0A\u4F20\u6210\u529F, \u8BF7\u524D\u5F80\u540E\u53F0\u786E\u8BA4\u5E76\u63D0\u4EA4\u5BA1\u6838",
+        consoleUrl
+      };
+    } catch (error) {
+      logger.error(`\u4E0A\u4F20\u5230 vivo \u5931\u8D25: ${error.message}`);
+      return {
+        platform: "vivo",
+        success: false,
+        message: this.formatError(error),
+        error,
+        consoleUrl
+      };
+    }
+  }
+  /**
+   * 计算文件 MD5
+   */
+  calculateFileMD5(filePath) {
+    return new Promise((resolve, reject) => {
+      const hash = crypto5.createHash("md5");
+      const stream = fs11.createReadStream(filePath);
+      stream.on("data", (data) => hash.update(data));
+      stream.on("end", () => resolve(hash.digest("hex")));
+      stream.on("error", reject);
+    });
+  }
+  /**
+   * 上传 APK 文件并获取流水号
+   * 将公共参数与业务参数放入一个 multipart 请求中直接上传至 API_BASE
+   */
+  async uploadApk(accessKey, accessSecret, filePath, packageName, fileMd5) {
+    const timestamp = String(Date.now());
+    const paramsForSign = {
+      // 公共参数
+      access_key: accessKey,
+      timestamp,
+      format: "json",
+      v: "1.0",
+      sign_method: "hmac",
+      target_app_key: "developer",
+      method: "app.upload.apk.app",
+      // 业务参数
+      packageName,
+      fileMd5
+    };
+    const sign = this.generateSign(paramsForSign, accessSecret);
+    const form = new FormData7();
+    for (const [key, value] of Object.entries(paramsForSign)) {
+      form.append(key, value);
+    }
+    form.append("sign", sign);
+    form.append("file", fs11.createReadStream(filePath), {
+      filename: path7.basename(filePath),
+      contentType: "application/vnd.android.package-archive"
+    });
+    logger.info(
+      `[VIVO DEBUG] \u5F00\u59CB\u4E0A\u4F20 APK (API\u8BF7\u6C42) \u53C2\u6570(\u4E0D\u542B\u6587\u4EF6): ${JSON.stringify({ ...paramsForSign, sign })}`
+    );
+    const res = await axios8.post(_VivoUploader.API_BASE, form, {
+      headers: form.getHeaders(),
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      timeout: 3e5
+    });
+    logger.info(`[VIVO DEBUG] \u4E0A\u4F20\u54CD\u5E94: ${JSON.stringify(res.data)}`);
+    if (res.data.code !== 0) {
+      throw new Error(`\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25: ${res.data.msg || JSON.stringify(res.data)}`);
+    }
+    const serialnumber = res.data.data?.serialnumber || res.data.data;
+    logger.info(`APK \u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210\uFF0C\u6D41\u6C34\u53F7: ${serialnumber}`);
+    return serialnumber;
+  }
+  /**
+   * 提交版本更新信息
+   */
+  async submitVersion(accessKey, accessSecret, params) {
+    const timestamp = String(Date.now());
+    const reqParams = {
+      access_key: accessKey,
+      timestamp,
+      format: "json",
+      v: "1.0",
+      sign_method: "hmac",
+      target_app_key: "developer",
+      method: "app.sync.update.app",
+      packageName: params.packageName || "",
+      // 文档必填
+      versionCode: String(params.versionCode),
+      // 文档必填 (Integer)
+      apk: params.serialnumber,
+      // 文档中的 apk 字段即为上传接口返回的 serialnumber
+      fileMd5: params.fileMd5,
+      // 文档必填
+      onlineType: "1",
+      // 1:立即上架 2:定时上架 (必填)
+      compatibleDevice: "1",
+      // 1:手机 2:手机和平板 3:平板 (必填)
+      updateDesc: params.updateDesc
+    };
+    reqParams.sign = this.generateSign(reqParams, accessSecret);
+    const formData = new URLSearchParams();
+    for (const [key, value] of Object.entries(reqParams)) {
+      formData.append(key, value);
+    }
+    const res = await axios8.post(_VivoUploader.API_BASE, formData.toString(), {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      timeout: 3e4
+    });
+    if (res.data.code !== 0) {
+      throw new Error(`\u63D0\u4EA4\u7248\u672C\u5931\u8D25: ${res.data.msg || JSON.stringify(res.data)}`);
+    }
+    logger.info("\u7248\u672C\u4FE1\u606F\u5DF2\u63D0\u4EA4");
+  }
+  /**
+   * 格式化错误信息
+   */
+  formatError(error) {
+    if (error.response?.data) {
+      const data = error.response.data;
+      return data.msg || data.message || error.message;
+    }
+    return error.message;
+  }
+};
+
+// src/adapters/tencent_uploader.ts
+import fs12 from "fs-extra";
+import path8 from "path";
+import axios9 from "axios";
+import crypto6 from "crypto";
+var TencentUploader = class _TencentUploader {
+  name = "Tencent";
+  /** 腾讯开放平台 API 基础地址 */
+  static API_BASE = "https://p.open.qq.com/open_file/developer_api";
+  /**
+   * 接口签名生成 (HmacSHA256)
+   * 规则: 所有参数按字典序排序拼接为 k1=v1&k2=v2... (不要进行 URL 编码)
+   *       使用 accessSecret 计算 HmacSHA256，转小写 16 进制
+   */
+  generateSign(params, accessSecret) {
+    const sortedKeys = Object.keys(params).sort();
+    const signStr = sortedKeys.filter((key) => params[key] !== void 0 && params[key] !== null).map((key) => `${key}=${params[key]}`).join("&");
+    return crypto6.createHmac("sha256", accessSecret).update(signStr).digest("hex").toLowerCase();
+  }
+  validateConfig(config) {
+    if (!config?.publish?.tencent?.enable) return false;
+    const auth = config.publish.tencent.auth;
+    if (!auth?.userId || !auth?.appId || !auth?.accessSecret) {
+      logger.error("Tencent config missing: userId, appId or accessSecret");
+      return false;
+    }
+    return true;
+  }
+  canHandle(filePath) {
+    return filePath.toLowerCase().endsWith(".apk");
+  }
+  async upload(filePath, config, metadata) {
+    const tencentConfig = config.publish.tencent;
+    const auth = tencentConfig.auth;
+    logger.info(`Tencent \u8FD0\u884C\u65F6\u914D\u7F6E: ${JSON.stringify(tencentConfig)}`);
+    const consoleUrl = "https://app.open.qq.com";
+    if (!fs12.existsSync(filePath)) {
+      return { platform: "tencent", success: false, message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, consoleUrl };
+    }
+    try {
+      const stats = fs12.statSync(filePath);
+      const fileName = path8.basename(filePath);
+      logger.info("\u6B63\u5728\u83B7\u53D6\u9884\u7B7E\u540D\u4E0A\u4F20\u5730\u5740...");
+      const pkgName = tencentConfig.packageName || "";
+      const uploadInfo = await this.getFileUploadInfo(auth, stats.size, fileName, pkgName);
+      logger.info(`\u83B7\u53D6\u6587\u4EF6\u4E0A\u4F20\u4FE1\u606F\u7ED3\u679C ${JSON.stringify(uploadInfo)}`);
+      logger.info("\u6B63\u5728\u4E0A\u4F20\u6587\u4EF6\u5230\u817E\u8BAF\u4E91 COS (\u7ED5\u8FC7 API \u7F51\u5173\u9650\u5236)...");
+      await this.uploadToCos(uploadInfo.pre_sign_url, filePath, stats.size);
+      logger.info("\u6B63\u5728\u83B7\u53D6\u7EBF\u4E0A\u5E94\u7528\u8BE6\u60C5\u4EE5\u4FDD\u7559\u73B0\u6709\u914D\u7F6E...");
+      const pkgInfo = await parsePackageInfo(filePath, {
+        androidSdkPath: config.globalSettings?.androidSdkPath
+      });
+      const nativeCodes = pkgInfo?.nativeCode || [];
+      const has64Bit = nativeCodes.includes("arm64-v8a") || nativeCodes.includes("x86_64");
+      const has32Bit = nativeCodes.includes("armeabi-v7a") || nativeCodes.includes("armeabi") || nativeCodes.includes("x86");
+      const is64Bit = has64Bit && !has32Bit;
+      const md5 = pkgInfo?.md5;
+      const onlineDetail = await this.queryAppDetail(
+        auth,
+        tencentConfig.packageName || pkgInfo?.packageName || ""
+      );
+      logger.info(`\u83B7\u53D6\u7EBF\u4E0A\u8BE6\u60C5\u6210\u529F: ${onlineDetail.app_name || "\u672A\u547D\u540D"}`);
+      logger.info("\u6B63\u5728\u63D0\u4EA4\u6D41\u6C34\u53F7\u5B8C\u6210\u5BA1\u6838\u7533\u62A5...");
+      const submitResult = await this.submitModifyAppInfo(
+        auth,
+        {
+          ...onlineDetail,
+          // 以前序详情为蓝本
+          pkg_name: tencentConfig.packageName || pkgInfo?.packageName || onlineDetail.pkg_name || "",
+          serial_number: uploadInfo.serial_number,
+          update_desc: metadata.changelog || "\u7248\u672C\u66F4\u65B0",
+          is64Bit,
+          md5
+        },
+        { timeout: tencentConfig.timeout || 6e4 }
+      );
+      logger.info(`\u63D0\u4EA4\u6D41\u6C34\u53F7\u5B8C\u6210\u5BA1\u6838\u7533\u62A5\u7ED3\u679C: ${JSON.stringify(submitResult)}`);
+      logger.success("\u817E\u8BAF\u5E94\u7528\u5B9D\u4E0A\u4F20\u5E76\u63D0\u4EA4\u6210\u529F!");
+      return { platform: "tencent", success: true, message: "\u4E0A\u4F20\u5E76\u63D0\u4EA4\u5BA1\u6838\u6210\u529F", consoleUrl };
+    } catch (error) {
+      logger.error(`\u817E\u8BAF\u4E0A\u4F20\u5931\u8D25: ${JSON.stringify(error)}`);
+      logger.error(`\u817E\u8BAF\u4E0A\u4F20\u5931\u8D25: ${error.stack}`);
+      return { platform: "tencent", success: false, message: error.message, error, consoleUrl };
+    }
+  }
+  /**
+   * 阶段 1: 获取文件上传信息
+   */
+  async getFileUploadInfo(auth, fileSize, fileName, pkgName) {
+    logger.info(`Tencent getFileUploadInfo: ${JSON.stringify(auth)}`);
+    const userId = String(auth.userId || "");
+    const accessSecret = String(auth.accessSecret || "");
+    const signParams = {
+      user_id: userId,
+      timestamp: String(Math.floor(Date.now() / 1e3)),
+      pkg_name: pkgName,
+      app_id: String(auth.appId || ""),
+      file_size: String(fileSize),
+      file_name: fileName,
+      file_type: "apk"
+    };
+    const sign = this.generateSign(signParams, accessSecret);
+    const formParams = {
+      ...signParams,
+      sign
+    };
+    const url = `${_TencentUploader.API_BASE}/get_file_upload_info`;
+    logger.info(`\u6B63\u5728\u8BF7\u6C42 Tencent API: ${url}`);
+    logger.info(`formParams: ${JSON.stringify(formParams)}`);
+    const res = await axios9.post(url, new URLSearchParams(formParams).toString(), {
+      headers: { "Content-Type": "application/x-www-form-urlencoded" }
+    });
+    if (res.data.ret !== 0) {
+      throw new Error(`\u83B7\u53D6\u4E0A\u4F20\u4FE1\u606F\u5931\u8D25: ${res.data.msg} (ret:${res.data.ret})`);
+    }
+    return res.data;
+  }
+  /**
+   * 获取应用详情
+   */
+  async queryAppDetail(auth, pkgName) {
+    const userId = auth.userId || "";
+    const accessSecret = auth.accessSecret || "";
+    const signParams = {
+      user_id: userId,
+      timestamp: String(Math.floor(Date.now() / 1e3)),
+      app_id: String(auth.appId || ""),
+      pkg_name: pkgName
+    };
+    const sign = this.generateSign(signParams, accessSecret);
+    const formParams = { ...signParams, sign };
+    const url = `${_TencentUploader.API_BASE}/query_app_detail`;
+    const res = await axios9.post(url, new URLSearchParams(formParams).toString(), {
+      headers: { "Content-Type": "application/x-www-form-urlencoded" }
+    });
+    if (res.data.ret !== 0) {
+      logger.warn(`\u67E5\u8BE2\u5E94\u7528\u8BE6\u60C5\u5931\u8D25: ${res.data.msg}\uFF0C\u5C06\u4F7F\u7528\u7A7A\u914D\u7F6E\u7EE7\u7EED`);
+      return {};
+    }
+    return res.data;
+  }
+  /**
+   * 阶段 2: 直接上传到 COS (PUT)
+   */
+  async uploadToCos(url, filePath, size) {
+    await axios9.put(url, fs12.createReadStream(filePath), {
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "Content-Length": size
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      timeout: 9e5,
+      // 15 分钟
+      onUploadProgress: (p) => {
+        if (p.total) {
+          const percent = Math.round(p.loaded * 100 / p.total);
+          if (percent % 20 === 0) logger.info(`\u4E0A\u4F20\u8FDB\u5EA6: ${percent}%`);
+        }
+      }
+    });
+  }
+  /**
+   * 阶段 3: 提交流水号信息
+   */
+  async submitModifyAppInfo(auth, data, options) {
+    const userId = auth.userId || "";
+    const accessSecret = auth.accessSecret || "";
+    const signParams = {
+      user_id: userId,
+      timestamp: String(Math.floor(Date.now() / 1e3)),
+      app_id: String(auth.appId || ""),
+      pkg_name: String(data.pkg_name || ""),
+      feature: String(data.update_desc || ""),
+      deploy_type: String(data.deploy_type || "1")
+      // 默认审核后立即发布
+    };
+    const skipFields = [
+      "ret",
+      "msg",
+      "user_id",
+      "timestamp",
+      "sign",
+      "app_id",
+      "pkg_name",
+      "feature",
+      "is64Bit",
+      "md5",
+      "serial_number"
+    ];
+    Object.keys(data).forEach((key) => {
+      if (!skipFields.includes(key) && data[key] !== void 0 && data[key] !== null) {
+        signParams[key] = String(data[key]);
+      }
+    });
+    if (data.is64Bit) {
+      signParams.apk64_file_serial_number = String(data.serial_number || "");
+      if (data.md5) signParams.apk64_file_md5 = data.md5;
+      delete signParams.apk32_file_serial_number;
+      delete signParams.apk32_file_md5;
+    } else {
+      signParams.apk32_file_serial_number = String(data.serial_number || "");
+      if (data.md5) signParams.apk32_file_md5 = data.md5;
+      delete signParams.apk64_file_serial_number;
+      delete signParams.apk64_file_md5;
+    }
+    const sign = this.generateSign(signParams, accessSecret);
+    const formParams = {
+      ...signParams,
+      sign
+    };
+    logger.info(`formParams: ${JSON.stringify(formParams)}`);
+    const url = `${_TencentUploader.API_BASE}/update_app`;
+    const res = await axios9.post(url, new URLSearchParams(formParams).toString(), {
+      headers: { "Content-Type": "application/x-www-form-urlencoded" }
+    });
+    if (res.data.ret !== 0) {
+      throw new Error(`\u63D0\u4EA4\u6D41\u6C34\u53F7\u5931\u8D25: ${res.data.msg} (ret:${res.data.ret})`);
+    }
+    return res.data;
+  }
+};
+
+// src/utils/upload-manager.ts
+var UploadManager = class {
+  uploaders;
+  config;
+  constructor(config = {}) {
+    this.uploaders = /* @__PURE__ */ new Map();
+    this.config = {
+      maxConcurrent: config.maxConcurrent ?? 3,
+      continueOnError: config.continueOnError ?? true,
+      verbose: config.verbose ?? false,
+      cancellationToken: config.cancellationToken
+    };
+    this.registerUploader("pgyer", new PgyerUploader());
+    this.registerUploader("huawei", new HuaweiUploader());
+    this.registerUploader("xiaomi", new XiaomiUploader());
+    this.registerUploader("app_store", new AppleStoreUploader());
+    this.registerUploader("testflight", new TestFlightUploader());
+    this.registerUploader("adhoc", new AdHocUploader());
+    this.registerUploader("harmony", new HarmonyUploader());
+    this.registerUploader("oppo", new OppoUploader());
+    this.registerUploader("vivo", new VivoUploader());
+    this.registerUploader("tencent", new TencentUploader());
+  }
+  /**
+   * 注册上传器
+   */
+  registerUploader(platform, uploader) {
+    this.uploaders.set(platform, uploader);
+  }
+  /**
+   * 获取启用的平台列表（根据配置）
+   */
+  getEnabledPlatforms(config) {
+    const enabled = [];
+    if (config?.publish?.pgyer?.enable) enabled.push("pgyer");
+    if (config?.publish?.huawei?.enable) enabled.push("huawei");
+    if (config?.publish?.xiaomi?.enable) enabled.push("xiaomi");
+    if (config?.publish?.oppo?.enable) enabled.push("oppo");
+    if (config?.publish?.vivo?.enable) enabled.push("vivo");
+    if (config?.publish?.tencent?.enable) enabled.push("tencent");
+    if (config?.publish?.app_store?.enable) {
+      const mode = config.publish.app_store.mode || "app_store";
+      enabled.push(mode);
+    }
+    return enabled;
+  }
+  /**
+   * 获取可用的平台列表
+   */
+  getAvailablePlatforms() {
+    return Array.from(this.uploaders.keys());
+  }
+  /**
+   * 执行并行上传（支持多文件智能分发）
+   */
+  async uploadToMultiplePlatforms(filePaths, config, metadata, targetPlatforms) {
+    const startTime = Date.now();
+    let platforms = targetPlatforms && targetPlatforms.length > 0 ? targetPlatforms : this.getEnabledPlatforms(config);
+    if (platforms.length === 0) {
+      logger.warn("No platforms enabled for upload");
+      return {
+        totalUploads: 0,
+        successCount: 0,
+        failureCount: 0,
+        successPlatforms: [],
+        failurePlatforms: [],
+        results: [],
+        totalDurationMs: 0,
+        summary: "No platforms configured for upload"
+      };
+    }
+    logger.info(
+      `Starting parallel uploads to ${platforms.length} platform(s): ${platforms.join(", ")}`
+    );
+    const validPlatforms = platforms.filter((platform) => {
+      const uploader = this.uploaders.get(platform);
+      if (!uploader) {
+        logger.warn(`Platform '${platform}' is not supported`);
+        return false;
+      }
+      if (!uploader.validateConfig(config)) {
+        logger.warn(`Configuration for '${platform}' is invalid`);
+        return false;
+      }
+      return true;
+    });
+    if (validPlatforms.length === 0) {
+      logger.error("No valid platforms to upload to");
+      return {
+        totalUploads: platforms.length,
+        successCount: 0,
+        failureCount: platforms.length,
+        successPlatforms: [],
+        failurePlatforms: platforms,
+        results: [],
+        totalDurationMs: Date.now() - startTime,
+        summary: "All platforms failed configuration validation"
+      };
+    }
+    const files = Array.isArray(filePaths) ? filePaths : [filePaths];
+    logger.info(`Processing ${files.length} file(s) for ${validPlatforms.length} platform(s)`);
+    const uploadPromises = validPlatforms.map((platform) => {
+      const uploader = this.uploaders.get(platform);
+      const targetFile = files.find((f) => uploader.canHandle(f));
+      if (!targetFile) {
+        logger.warn(`[${platform}] No compatible file found in provided files`);
+        return Promise.resolve({
+          platform,
+          success: false,
+          message: `No compatible file found for ${platform}`
+        });
+      }
+      logger.info(`[${platform}] Matched file: ${path9.basename(targetFile)}`);
+      return this.uploadToPlatform(platform, targetFile, config, metadata);
+    });
+    const results = await Promise.all(uploadPromises);
+    const report = this.aggregateResults(results, validPlatforms.length, startTime);
+    this.printReport(report);
+    return report;
+  }
+  /**
+   * 上传到单个平台
+   */
+  async uploadToPlatform(platform, filePath, config, metadata) {
+    if (this.config.cancellationToken?.isCancelled) {
+      logger.warn(`[${platform.toUpperCase()}] Upload skipped due to cancellation`);
+      return {
+        platform,
+        success: false,
+        message: "Upload cancelled by user"
+      };
+    }
+    const uploader = this.uploaders.get(platform);
+    if (!uploader) {
+      return {
+        platform,
+        success: false,
+        message: `Platform '${platform}' is not supported`
+      };
+    }
+    try {
+      if (this.config.verbose) {
+        logger.info(`[${platform.toUpperCase()}] Starting upload...`);
+      }
+      const pkgInfo = await parsePackageInfo(filePath, {
+        androidSdkPath: metadata.globalSettings?.androidSdkPath
+      });
+      if (pkgInfo) {
+        if (pkgInfo.versionName) {
+          metadata.version = pkgInfo.versionName;
+        }
+        if (pkgInfo.versionCode) {
+          metadata.buildNumber = pkgInfo.versionCode;
+        }
+        if (pkgInfo.packageName) {
+          ;
+          metadata.packageName = pkgInfo.packageName;
+        }
+        logger.info(
+          `[${platform.toUpperCase()}] \u5DF2\u6821\u51C6\u7248\u672C\u4FE1\u606F: v${metadata.version}+${metadata.buildNumber}`
+        );
+      }
+      const result = await uploader.upload(filePath, config, metadata);
+      return result;
+    } catch (error) {
+      const errorMessage = error.message || String(error);
+      logger.error(`[${platform.toUpperCase()}] Upload error: ${errorMessage}`);
+      return {
+        platform,
+        success: false,
+        message: errorMessage,
+        error
+      };
+    }
+  }
+  /**
+   * 聚合上传结果
+   */
+  aggregateResults(results, totalPlatforms, startTime) {
+    const successResults = results.filter((r) => r.success);
+    const failureResults = results.filter((r) => !r.success);
+    const successPlatforms = successResults.map((r) => r.platform || "unknown");
+    const failurePlatforms = failureResults.map((r) => r.platform || "unknown");
+    const totalDurationMs = Date.now() - startTime;
+    let summary = "";
+    if (successResults.length === totalPlatforms) {
+      summary = `\u2705 All ${totalPlatforms} platforms uploaded successfully!`;
+    } else if (failureResults.length === totalPlatforms) {
+      summary = `\u274C Upload failed on all ${totalPlatforms} platforms`;
+    } else {
+      summary = `\u26A0\uFE0F Partial success: ${successResults.length} succeeded, ${failureResults.length} failed`;
+    }
+    return {
+      totalUploads: totalPlatforms,
+      successCount: successResults.length,
+      failureCount: failureResults.length,
+      successPlatforms,
+      failurePlatforms,
+      results,
+      totalDurationMs,
+      summary
+    };
+  }
+  /**
+   * 输出上传报告
+   */
+  printReport(report) {
+    logger.info("");
+    logger.info("\u2550".repeat(60));
+    logger.info("\u{1F4CA} Upload Report");
+    logger.info("\u2550".repeat(60));
+    logger.info(`Total Platforms: ${report.totalUploads}`);
+    logger.info(`\u2705 Success: ${report.successCount}`);
+    logger.info(`\u274C Failure: ${report.failureCount}`);
+    if (report.successPlatforms.length > 0) {
+      logger.info(`Successful: ${report.successPlatforms.join(", ")}`);
+    }
+    if (report.failurePlatforms.length > 0) {
+      logger.info(`Failed: ${report.failurePlatforms.join(", ")}`);
+    }
+    logger.info(`Total Duration: ${this.formatDuration(report.totalDurationMs)}`);
+    logger.info("");
+    logger.info(report.summary);
+    logger.info("\u2550".repeat(60));
+    logger.info("");
+    logger.info("\u{1F4CB} Detailed Results:");
+    report.results.forEach((result) => {
+      if (result.success) {
+        if (this.config.verbose) {
+          logger.success(`[${result.platform}] \u2705 ${result.message}`);
+          if (result.url) {
+            logger.info(`  Download: ${result.url}`);
+          }
+        }
+      } else {
+        logger.error(`[${result.platform}] \u274C ${result.message}`);
+        if (result.error && result.error.stack && this.config.verbose) {
+          logger.error(result.error.stack);
+        }
+      }
+    });
+    logger.info("");
+  }
+  /**
+   * 格式化持续时间
+   */
+  formatDuration(ms) {
+    if (ms < 1e3) {
+      return `${ms}ms`;
+    }
+    if (ms < 6e4) {
+      return `${(ms / 1e3).toFixed(1)}s`;
+    }
+    return `${(ms / 6e4).toFixed(1)}m`;
+  }
+  /**
+   * 获取可重试的失败平台
+   */
+  getRetryablePlatforms(report) {
+    return report.failurePlatforms;
+  }
+  /**
+   * 重试失败的平台
+   */
+  async retryFailedPlatforms(failedPlatforms, filePath, config, metadata) {
+    if (failedPlatforms.length === 0) {
+      logger.info("No platforms to retry");
+      return {
+        totalUploads: 0,
+        successCount: 0,
+        failureCount: 0,
+        successPlatforms: [],
+        failurePlatforms: [],
+        results: [],
+        totalDurationMs: 0,
+        summary: "No platforms to retry"
+      };
+    }
+    logger.info(`Retrying ${failedPlatforms.length} failed platform(s)...`);
+    return this.uploadToMultiplePlatforms(filePath, config, metadata, failedPlatforms);
+  }
+};
+
+// src/validators/config_validator.ts
+import fs13 from "fs-extra";
+import yaml from "js-yaml";
+
+// src/validators/env_validator.ts
+var EnvValidator = class {
+  /**
+   * 验证环境变量
+   * @param requiredVars 必需的环境变量列表
+   */
+  static validate(requiredVars) {
+    const missing = requiredVars.filter((v) => !process.env[v]);
+    if (missing.length > 0) {
+      logger.error(`Missing environment variables: ${missing.join(", ")}`);
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/validators/config_validator.ts
+var ConfigValidator = class {
+  /**
+   * 加载并验证配置文件
+   * @param filePath 配置文件路径
+   */
+  static loadAndValidate(filePath) {
+    if (!fs13.existsSync(filePath)) {
+      logger.error(`Config file not found: ${filePath}`);
+      return null;
+    }
+    let content = fs13.readFileSync(filePath, "utf8");
+    const envRegex = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+    const matches = [...content.matchAll(envRegex)];
+    const requiredEnvs = Array.from(new Set(matches.map((m) => m[1])));
+    if (!EnvValidator.validate(requiredEnvs)) {
+      return null;
+    }
+    content = content.replace(envRegex, (_, varName) => process.env[varName] || "");
+    try {
+      const config = yaml.load(content);
+      if (!this.validateSchema(config)) {
+        return null;
+      }
+      return config;
+    } catch (e) {
+      logger.error(`Failed to parse YAML: ${e.message}`);
+      return null;
+    }
+  }
+  /**
+   * 验证配置 Schema
+   * @param config 配置对象
+   */
+  static validateSchema(config) {
+    if (config.publish?.app_store?.enable) {
+      const auth = config.publish.app_store.auth;
+      if (!auth?.apiKeyId || !auth?.apiIssuerId) {
+        logger.error("App Store enabled but missing auth info (apiKeyId, apiIssuerId)");
+        return false;
+      }
+    }
+    if (config.publish?.huawei?.enable) {
+      const auth = config.publish.huawei.auth;
+      if (!auth?.clientId || !auth?.clientSecret) {
+        logger.error("Huawei enabled but missing auth info (clientId, clientSecret)");
+        return false;
+      }
+    }
+    if (config.publish?.xiaomi?.enable) {
+      const auth = config.publish.xiaomi.auth;
+      if (!auth?.userName || !auth?.privateKey) {
+        logger.error("Xiaomi enabled but missing auth info (userName, privateKey)");
+        return false;
+      }
+    }
+    if (config.publish?.oppo?.enable) {
+      const auth = config.publish.oppo.auth;
+      if (!auth?.clientId || !auth?.clientSecret) {
+        logger.error("OPPO enabled but missing auth info (clientId, clientSecret)");
+        return false;
+      }
+    }
+    if (config.publish?.vivo?.enable) {
+      const auth = config.publish.vivo.auth;
+      if (!auth?.accessKey || !auth?.accessSecret) {
+        logger.error("vivo enabled but missing auth info (accessKey, accessSecret)");
+        return false;
+      }
+    }
+    if (config.publish?.tencent?.enable) {
+      const auth = config.publish.tencent.auth;
+      if (!auth?.userId || !auth?.appId || !auth?.accessSecret) {
+        logger.error("Tencent enabled but missing auth info (userId, appId, accessSecret)");
+        return false;
+      }
+    }
+    if (config.publish?.harmony?.enable) {
+      const auth = config.publish.harmony.auth;
+      if (!auth?.clientId || !auth?.clientSecret) {
+        logger.error("Harmony enabled but missing auth info (clientId, clientSecret)");
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/cli.ts
+import path10 from "path";
+import fs14 from "fs-extra";
+import yaml2 from "js-yaml";
+var VERSION = "0.1.0";
+function printHelp() {
+  console.log(`
+app-ship v${VERSION} \u2014 Multi-platform app store uploader
+
+Usage:
+  app-ship upload   -c <config> -f <file> [--platform pgyer,huawei]
+  app-ship platforms                  List supported platforms
+  app-ship init                       Generate sample config file
+  app-ship --help                     Show this help
+  app-ship --version                  Show version
+
+Upload Options:
+  -c, --config <path>     Config file path (YAML)
+  -f, --file <path>       App package file (APK/IPA/AAB/HAP)
+  -p, --platform <list>   Comma-separated platform list (optional, uses config if omitted)
+  -v, --version <ver>     Version string (default: from config or "1.0.0")
+  -b, --build-number <n>  Build number (default: "1")
+  --changelog <text>      Changelog / release notes
+  --verbose               Show detailed output
+`);
+}
+function parseArgs(argv) {
+  const args = {};
+  let i = 2;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+    } else if (arg === "--version") {
+      args.showVersion = true;
+    } else if (arg === "--verbose") {
+      args.verbose = true;
+    } else if ((arg === "-c" || arg === "--config") && argv[i + 1]) {
+      args.config = argv[++i];
+    } else if ((arg === "-f" || arg === "--file") && argv[i + 1]) {
+      args.file = argv[++i];
+    } else if ((arg === "-p" || arg === "--platform") && argv[i + 1]) {
+      args.platform = argv[++i];
+    } else if ((arg === "-v" || arg === "--ver") && argv[i + 1]) {
+      args.ver = argv[++i];
+    } else if ((arg === "-b" || arg === "--build-number") && argv[i + 1]) {
+      args.buildNumber = argv[++i];
+    } else if (arg === "--changelog" && argv[i + 1]) {
+      args.changelog = argv[++i];
+    } else if (!arg.startsWith("-")) {
+      args.command = arg;
+    }
+    i++;
+  }
+  return args;
+}
+async function cmdUpload(args) {
+  const configPath = args.config;
+  const filePath = args.file;
+  if (!configPath) {
+    logger.error("Missing config file. Use: app-ship upload -c <config.yaml> -f <file>");
+    process.exit(1);
+  }
+  if (!filePath) {
+    logger.error("Missing file path. Use: app-ship upload -c <config.yaml> -f <file>");
+    process.exit(1);
+  }
+  const absConfig = path10.resolve(configPath);
+  const absFile = path10.resolve(filePath);
+  if (!fs14.existsSync(absFile)) {
+    logger.error(`File not found: ${absFile}`);
+    process.exit(1);
+  }
+  const config = ConfigValidator.loadAndValidate(absConfig);
+  if (!config) {
+    logger.error("Config validation failed");
+    process.exit(1);
+  }
+  const platforms = args.platform ? args.platform.split(",").map((s) => s.trim()) : void 0;
+  const metadata = {
+    version: args.ver || config.version || "1.0.0",
+    buildNumber: args.buildNumber || "1",
+    changelog: args.changelog || ""
+  };
+  logger.title("App Ship \u2014 Starting Upload");
+  logger.info(`File: ${absFile}`);
+  logger.info(`Config: ${absConfig}`);
+  if (platforms) {
+    logger.info(`Platforms: ${platforms.join(", ")}`);
+  }
+  logger.newLine();
+  const manager = new UploadManager({
+    maxConcurrent: 3,
+    continueOnError: true,
+    verbose: !!args.verbose
+  });
+  const report = await manager.uploadToMultiplePlatforms(absFile, config, metadata, platforms);
+  process.exit(report.failureCount > 0 ? 1 : 0);
+}
+function cmdPlatforms() {
+  const manager = new UploadManager();
+  const platforms = manager.getAvailablePlatforms();
+  logger.title("Supported Platforms");
+  for (const p of platforms) {
+    console.log(`  \u2022 ${p}`);
+  }
+  console.log(`
+Total: ${platforms.length} platforms`);
+}
+function cmdInit() {
+  const filename = "app-ship.yaml";
+  if (fs14.existsSync(filename)) {
+    logger.warn(`${filename} already exists. Skipping.`);
+    return;
+  }
+  const sample = {
+    version: "1.0.0",
+    publish: {
+      pgyer: {
+        enable: true,
+        apiKey: "YOUR_PGYER_API_KEY"
+      },
+      huawei: {
+        enable: false,
+        auth: {
+          clientId: "",
+          clientSecret: ""
+        },
+        appId: ""
+      },
+      xiaomi: {
+        enable: false,
+        auth: {
+          userName: "",
+          privateKey: ""
+        },
+        packageName: "com.example.app"
+      },
+      oppo: {
+        enable: false,
+        auth: {
+          clientId: "",
+          clientSecret: ""
+        }
+      },
+      vivo: {
+        enable: false,
+        auth: {
+          accessKey: "",
+          accessSecret: ""
+        }
+      },
+      tencent: {
+        enable: false,
+        auth: {
+          appId: "",
+          accessSecret: ""
+        }
+      },
+      harmony: {
+        enable: false,
+        auth: {
+          clientId: "",
+          clientSecret: ""
+        },
+        appId: ""
+      },
+      app_store: {
+        enable: false,
+        auth: {
+          appleId: "",
+          appPassword: ""
+        }
+      }
+    }
+  };
+  fs14.writeFileSync(filename, yaml2.dump(sample, { indent: 2 }), "utf8");
+  logger.success(`Created ${filename}`);
+  logger.info("Edit the file to configure your platform credentials.");
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (args.showVersion) {
+    console.log(`app-ship v${VERSION}`);
+    return;
+  }
+  const command = args.command;
+  switch (command) {
+    case "upload":
+      await cmdUpload(args);
+      break;
+    case "platforms":
+      cmdPlatforms();
+      break;
+    case "init":
+      cmdInit();
+      break;
+    default:
+      printHelp();
+      break;
+  }
+}
+main().catch((err) => {
+  logger.error(err.message || String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map