@huoye/app-ship 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -34,42 +34,546 @@ __export(index_exports, {
   AppleJWTGenerator: () => AppleJWTGenerator,
   AppleStoreUploader: () => AppleStoreUploader,
   ConfigValidator: () => ConfigValidator,
+  DEFAULT_RELEASE_RECEIPT_LIMIT: () => DEFAULT_RELEASE_RECEIPT_LIMIT,
   DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
   EnvValidator: () => EnvValidator,
   ErrorCategory: () => ErrorCategory,
+  GooglePlayUploader: () => GooglePlayUploader,
   HarmonyUploader: () => HarmonyUploader,
   HuaweiUploader: () => HuaweiUploader,
   OppoUploader: () => OppoUploader,
   PgyerUploader: () => PgyerUploader,
+  RELEASE_RECEIPT_SCHEMA_VERSION: () => RELEASE_RECEIPT_SCHEMA_VERSION,
+  ReleaseReceiptStore: () => ReleaseReceiptStore,
   RetryStrategy: () => RetryStrategy,
   TencentUploader: () => TencentUploader,
   TestFlightUploader: () => TestFlightUploader,
   UploadManager: () => UploadManager,
   VivoUploader: () => VivoUploader,
   XiaomiUploader: () => XiaomiUploader,
+  createProjectKey: () => createProjectKey,
+  createReleaseReceipt: () => createReleaseReceipt,
   createUploadManager: () => createUploadManager,
   createUploadRetryStrategy: () => createUploadRetryStrategy,
-  parsePackageInfo: () => parsePackageInfo
+  createUploadTargets: () => createUploadTargets,
+  formatReleaseReceipt: () => formatReleaseReceipt,
+  parsePackageInfo: () => parsePackageInfo,
+  resolveReleaseProjectRoot: () => resolveReleaseProjectRoot,
+  sanitizeReleaseMessage: () => sanitizeReleaseMessage
 });
 module.exports = __toCommonJS(index_exports);
 
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/chalk/source/vendor/supports-color/index.js
+var import_node_process = __toESM(require("process"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_tty = __toESM(require("tty"), 1);
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = import_node_process.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
 // src/utils/logger.ts
-var import_chalk = __toESM(require("chalk"), 1);
 var ConsoleLogger = class {
   info(message) {
-    console.log(import_chalk.default.blue("\u2139\uFE0F  " + message));
+    console.log(source_default.blue("\u2139\uFE0F  " + message));
   }
   success(message) {
-    console.log(import_chalk.default.green("\u2705 " + message));
+    console.log(source_default.green("\u2705 " + message));
   }
   warn(message) {
-    console.log(import_chalk.default.yellow("\u26A0\uFE0F  " + message));
+    console.log(source_default.yellow("\u26A0\uFE0F  " + message));
   }
   error(message) {
-    console.log(import_chalk.default.red("\u274C " + message));
+    console.log(source_default.red("\u274C " + message));
   }
   title(message) {
-    console.log(import_chalk.default.bold.cyan("\n" + message + "\n"));
+    console.log(source_default.bold.cyan("\n" + message + "\n"));
   }
   newLine() {
     console.log("");
@@ -106,16 +610,18 @@ var ConfigValidator = class {
       logger.error(`Config file not found: ${filePath}`);
       return null;
     }
-    let content = import_fs_extra.default.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 = import_js_yaml.default.load(content);
+      const content = import_fs_extra.default.readFileSync(filePath, "utf8");
+      const rawConfig = import_js_yaml.default.load(content);
+      if (!rawConfig || typeof rawConfig !== "object") {
+        logger.error("Config file must contain a YAML object");
+        return null;
+      }
+      const requiredEnvs = this.collectRequiredEnvVars(rawConfig);
+      if (!EnvValidator.validate(requiredEnvs)) {
+        return null;
+      }
+      const config = this.resolveEnvVars(rawConfig);
       if (!this.validateSchema(config)) {
         return null;
       }
@@ -125,15 +631,71 @@ var ConfigValidator = class {
       return null;
     }
   }
+  /**
+   * 只收集本次实际启用配置中的环境变量，避免禁用平台阻塞其它上传任务。
+   */
+  static collectRequiredEnvVars(config) {
+    const activeConfig = {
+      ...config,
+      publish: Object.fromEntries(
+        Object.entries(config.publish || {}).filter(([, value]) => value?.enable === true)
+      )
+    };
+    const requiredEnvs = /* @__PURE__ */ new Set();
+    const envRegex = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+    const visit = (value) => {
+      if (typeof value === "string") {
+        for (const match of value.matchAll(envRegex)) {
+          requiredEnvs.add(match[1]);
+        }
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach(visit);
+        return;
+      }
+      if (value && typeof value === "object") {
+        Object.values(value).forEach(visit);
+      }
+    };
+    visit(activeConfig);
+    return Array.from(requiredEnvs);
+  }
+  /** 在内存中递归解析环境变量，不重新拼接 YAML，避免密钥字符破坏 YAML 结构。 */
+  static resolveEnvVars(value) {
+    if (typeof value === "string") {
+      return value.replace(
+        /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g,
+        (_, varName) => process.env[varName] || ""
+      );
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.resolveEnvVars(item));
+    }
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, item]) => [key, this.resolveEnvVars(item)])
+      );
+    }
+    return value;
+  }
   /**
    * 验证配置 Schema
    * @param config 配置对象
    */
   static validateSchema(config) {
     if (config.publish?.app_store?.enable) {
+      const mode = config.publish.app_store.mode || "app_store";
       const auth = config.publish.app_store.auth;
-      if (!auth?.apiKeyId || !auth?.apiIssuerId) {
-        logger.error("App Store enabled but missing auth info (apiKeyId, apiIssuerId)");
+      const hasCliAuth = Boolean(auth?.appleId && auth?.appPassword);
+      const hasApiAuth = Boolean(
+        auth?.apiKeyId && auth?.apiIssuerId && (auth?.privateKeyPath || auth?.privateKeyContent)
+      );
+      const hasRequiredAuth = mode === "adhoc" || (mode === "testflight" ? hasApiAuth : hasCliAuth || hasApiAuth);
+      if (!hasRequiredAuth) {
+        logger.error(
+          mode === "testflight" ? "TestFlight enabled but missing complete API key credentials" : "App Store enabled but missing Apple ID credentials or complete API key credentials"
+        );
         return false;
       }
     }
@@ -179,6 +741,20 @@ var ConfigValidator = class {
         return false;
       }
     }
+    if (config.publish?.google_play?.enable) {
+      const googlePlay = config.publish.google_play;
+      const auth = googlePlay.auth;
+      if (!googlePlay.packageName || !auth?.serviceAccountJsonPath && !auth?.serviceAccountJsonContent) {
+        logger.error(
+          "Google Play enabled but missing packageName or service account JSON credentials"
+        );
+        return false;
+      }
+      if (googlePlay.track && googlePlay.track !== "internal") {
+        logger.error("Google Play first release only supports the internal track");
+        return false;
+      }
+    }
     return true;
   }
 };
@@ -293,12 +869,7 @@ var RetryStrategy = class {
         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
-          };
+          throw error;
         }
         if (attempt <= this.config.maxRetries) {
           const delayMs = this.calculateDelay(attempt - 1);
@@ -309,12 +880,7 @@ var RetryStrategy = class {
         }
       }
     }
-    return {
-      success: false,
-      error: lastError || new Error(`${operationName} failed after all retries`),
-      totalAttempts: attempt,
-      lastError: lastError?.message
-    };
+    throw lastError || new Error(`${operationName} failed after all retries`);
   }
 };
 var DEFAULT_RETRY_CONFIG = {
@@ -508,6 +1074,7 @@ async function parseHap(filePath) {
 }
 
 // src/utils/upload-manager.ts
+var GROUPED_ARTIFACT_PLATFORMS = /* @__PURE__ */ new Set(["huawei", "xiaomi", "oppo", "vivo", "tencent"]);
 var UploadManager = class {
   uploaders;
   config;
@@ -529,6 +1096,7 @@ var UploadManager = class {
     this.registerUploader("oppo", new OppoUploader());
     this.registerUploader("vivo", new VivoUploader());
     this.registerUploader("tencent", new TencentUploader());
+    this.registerUploader("google_play", new GooglePlayUploader());
   }
   /**
    * 注册上传器
@@ -547,6 +1115,8 @@ var UploadManager = class {
     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?.harmony?.enable) enabled.push("harmony");
+    if (config?.publish?.google_play?.enable) enabled.push("google_play");
     if (config?.publish?.app_store?.enable) {
       const mode = config.publish.app_store.mode || "app_store";
       enabled.push(mode);
@@ -614,9 +1184,22 @@ var UploadManager = class {
       if (matchedFiles.length === 0) {
         logger.warn(`[${platform}] No compatible file found in provided files`);
       } else {
-        matchedFiles.forEach((file) => {
-          tasks.push({ platform, file });
-        });
+        if (this.shouldGroupArtifacts(platform)) {
+          const artifactSelection = this.resolveArtifactSelection(platform, matchedFiles, metadata);
+          if (!artifactSelection) {
+            logger.warn(`[${platform}] Failed to build grouped artifact selection`);
+            return;
+          }
+          tasks.push({
+            platform,
+            file: this.getRepresentativeFilePath(artifactSelection),
+            artifactSelection
+          });
+        } else {
+          matchedFiles.forEach((file) => {
+            tasks.push({ platform, file, artifactSelection: file });
+          });
+        }
       }
     });
     if (tasks.length === 0) {
@@ -635,7 +1218,13 @@ var UploadManager = class {
     logger.info(`Scheduled ${tasks.length} upload task(s) for ${validPlatforms.length} platform(s)`);
     const uploadPromises = tasks.map((task) => {
       logger.info(`[${task.platform}] Matched file: ${import_path2.default.basename(task.file)}`);
-      return this.uploadToPlatform(task.platform, task.file, config, metadata);
+      return this.uploadToPlatform(
+        task.platform,
+        task.file,
+        config,
+        metadata,
+        task.artifactSelection
+      );
     });
     const results = await Promise.all(uploadPromises);
     const report = this.aggregateResults(results, tasks.length, startTime);
@@ -645,7 +1234,7 @@ var UploadManager = class {
   /**
    * 上传到单个平台
    */
-  async uploadToPlatform(platform, filePath, config, metadata) {
+  async uploadToPlatform(platform, filePath, config, metadata, artifactSelection = filePath) {
     if (this.config.cancellationToken?.isCancelled) {
       logger.warn(`[${platform.toUpperCase()}] Upload skipped due to cancellation`);
       return {
@@ -666,25 +1255,30 @@ var UploadManager = class {
       if (this.config.verbose) {
         logger.info(`[${platform.toUpperCase()}] Starting upload...`);
       }
-      const pkgInfo = await parsePackageInfo(filePath, {
-        androidSdkPath: metadata.globalSettings?.androidSdkPath
+      const effectiveMetadata = {
+        ...metadata,
+        artifactPath: artifactSelection
+      };
+      await this.validateArtifactSelection(platform, artifactSelection, effectiveMetadata);
+      const pkgInfo = import_path2.default.extname(filePath).toLowerCase() === ".aab" ? null : await parsePackageInfo(filePath, {
+        androidSdkPath: effectiveMetadata.globalSettings?.androidSdkPath
       });
       if (pkgInfo) {
         if (pkgInfo.versionName) {
-          metadata.version = pkgInfo.versionName;
+          effectiveMetadata.version = pkgInfo.versionName;
         }
         if (pkgInfo.versionCode) {
-          metadata.buildNumber = pkgInfo.versionCode;
+          effectiveMetadata.buildNumber = pkgInfo.versionCode;
         }
         if (pkgInfo.packageName) {
           ;
-          metadata.packageName = pkgInfo.packageName;
+          effectiveMetadata.packageName = pkgInfo.packageName;
         }
         logger.info(
-          `[${platform.toUpperCase()}] \u5DF2\u6821\u51C6\u7248\u672C\u4FE1\u606F: v${metadata.version}+${metadata.buildNumber}`
+          `[${platform.toUpperCase()}] \u5DF2\u6821\u51C6\u7248\u672C\u4FE1\u606F: v${effectiveMetadata.version}+${effectiveMetadata.buildNumber}`
         );
       }
-      const result = await uploader.upload(filePath, config, metadata);
+      const result = await uploader.upload(filePath, config, effectiveMetadata);
       return result;
     } catch (error) {
       const errorMessage = error.message || String(error);
@@ -697,6 +1291,85 @@ var UploadManager = class {
       };
     }
   }
+  shouldGroupArtifacts(platform) {
+    return GROUPED_ARTIFACT_PLATFORMS.has(platform);
+  }
+  resolveArtifactSelection(platform, matchedFiles, metadata) {
+    const explicitArtifacts = metadata.platformArtifacts?.[platform];
+    if (explicitArtifacts) {
+      if (typeof explicitArtifacts === "string") {
+        return explicitArtifacts;
+      }
+      if (Object.keys(explicitArtifacts).length > 0) {
+        return explicitArtifacts;
+      }
+    }
+    if (matchedFiles.length === 0) {
+      return null;
+    }
+    if (matchedFiles.length === 1) {
+      return matchedFiles[0];
+    }
+    return this.buildArtifactMapFromFiles(matchedFiles);
+  }
+  buildArtifactMapFromFiles(files) {
+    return files.reduce(
+      (acc, filePath, index) => {
+        acc[this.inferArtifactKey(filePath, index)] = filePath;
+        return acc;
+      },
+      {}
+    );
+  }
+  inferArtifactKey(filePath, index) {
+    const fileName = import_path2.default.basename(filePath).toLowerCase();
+    if (fileName.includes("arm64-v8a")) return "arm64-v8a";
+    if (fileName.includes("armeabi-v7a")) return "armeabi-v7a";
+    if (fileName.includes("x86_64")) return "x86_64";
+    if (fileName.includes("universal")) return "universal";
+    return `artifact_${index + 1}`;
+  }
+  getRepresentativeFilePath(artifactSelection) {
+    if (typeof artifactSelection === "string") {
+      return artifactSelection;
+    }
+    return Object.values(artifactSelection)[0];
+  }
+  async validateArtifactSelection(platform, artifactSelection, metadata) {
+    if (typeof artifactSelection === "string") {
+      return;
+    }
+    const artifactPaths = Object.values(artifactSelection).filter(Boolean);
+    if (artifactPaths.length < 2) {
+      return;
+    }
+    const parsedInfos = await Promise.all(
+      artifactPaths.map(
+        (artifactPath) => parsePackageInfo(artifactPath, {
+          androidSdkPath: metadata.globalSettings?.androidSdkPath
+        })
+      )
+    );
+    const availableInfos = parsedInfos.filter((info) => !!info);
+    if (availableInfos.length < 2) {
+      logger.warn(
+        `[${platform.toUpperCase()}] Unable to fully validate multi-artifact package info; continuing with upload.`
+      );
+      return;
+    }
+    const [baseInfo, ...restInfos] = availableInfos;
+    for (const info of restInfos) {
+      if (baseInfo?.packageName && info?.packageName && baseInfo.packageName !== info.packageName) {
+        throw new Error("\u53CC\u5305\u4E0A\u4F20\u5931\u8D25\uFF1A\u6240\u9009\u5B89\u88C5\u5305\u7684 packageName \u4E0D\u4E00\u81F4");
+      }
+      if (baseInfo?.versionName && info?.versionName && baseInfo.versionName !== info.versionName) {
+        throw new Error("\u53CC\u5305\u4E0A\u4F20\u5931\u8D25\uFF1A\u6240\u9009\u5B89\u88C5\u5305\u7684 versionName \u4E0D\u4E00\u81F4");
+      }
+      if (baseInfo?.versionCode && info?.versionCode && baseInfo.versionCode !== info.versionCode) {
+        throw new Error("\u53CC\u5305\u4E0A\u4F20\u5931\u8D25\uFF1A\u6240\u9009\u5B89\u88C5\u5305\u7684 versionCode \u4E0D\u4E00\u81F4");
+      }
+    }
+  }
   /**
    * 聚合上传结果
    */
@@ -944,6 +1617,280 @@ var AppleJWTGenerator = class _AppleJWTGenerator {
   }
 };
 
+// src/utils/release-receipt.ts
+var import_crypto3 = require("crypto");
+var import_fs2 = require("fs");
+var import_promises = require("fs/promises");
+var import_os = require("os");
+var import_path3 = __toESM(require("path"), 1);
+var RELEASE_RECEIPT_SCHEMA_VERSION = 1;
+var DEFAULT_RELEASE_RECEIPT_LIMIT = 100;
+var REMOTE_IDENTIFIER_KEYS = [
+  "id",
+  "appId",
+  "buildId",
+  "versionId",
+  "releaseId",
+  "editId",
+  "versionCode",
+  "track",
+  "apiTrack",
+  "status",
+  "committed"
+];
+function resolveReleaseProjectRoot(projectRoot, configPath) {
+  return import_path3.default.resolve(projectRoot || import_path3.default.dirname(import_path3.default.resolve(configPath)));
+}
+function sanitizeReleaseMessage(value, maxLength = 500) {
+  let message = typeof value === "string" ? value : String(value ?? "");
+  message = message.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi, "[\u5DF2\u8131\u654F]").replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [\u5DF2\u8131\u654F]").replace(
+    /(["']?(?:access[_-]?token|refresh[_-]?token|client[_-]?secret|private[_-]?key|api[_-]?key|app[_-]?password|authorization|credential|service[_-]?account(?:[_-]?json)?[_-]?content)["']?\s*[:=]\s*)["']?[^\s,"'}]+["']?/gi,
+    "$1[\u5DF2\u8131\u654F]"
+  ).replace(/[\r\n\t]+/g, " ").replace(/\s{2,}/g, " ").trim();
+  return message.length > maxLength ? `${message.slice(0, maxLength - 1)}\u2026` : message;
+}
+function createUploadTargets(results) {
+  return results.map((result) => {
+    const platform = sanitizeReleaseMessage(result.platform, 80) || "unknown";
+    const data = isRecord(result.data) ? result.data : void 0;
+    const isDraft = result.success && platform === "google_play" && String(data?.status || "").toLowerCase() === "draft";
+    const remote = createRemoteReceipt(result, data);
+    return {
+      platform,
+      state: result.success ? isDraft ? "draft_created" : "uploaded" : "failed",
+      outcome: result.success ? "success" : "failed",
+      message: sanitizeReleaseMessage(result.message) || (result.success ? "\u4E0A\u4F20\u6210\u529F" : "\u4E0A\u4F20\u5931\u8D25"),
+      ...remote ? { remote } : {}
+    };
+  });
+}
+async function createReleaseReceipt(input) {
+  const projectRoot = await canonicalizeProjectRoot(input.projectRoot);
+  const startedAt = toDate(input.startedAt ?? Date.now());
+  const finishedAt = toDate(input.finishedAt ?? Date.now());
+  const targets = input.targets.map(sanitizeTarget);
+  return {
+    schemaVersion: RELEASE_RECEIPT_SCHEMA_VERSION,
+    id: (0, import_crypto3.randomUUID)(),
+    projectKey: createProjectKey(projectRoot),
+    projectRoot,
+    kind: input.kind,
+    ...cleanOptionalText(input.appName, 160) ? { appName: cleanOptionalText(input.appName, 160) } : {},
+    ...cleanOptionalText(input.packageName, 240) ? { packageName: cleanOptionalText(input.packageName, 240) } : {},
+    ...cleanOptionalText(input.versionName, 80) ? { versionName: cleanOptionalText(input.versionName, 80) } : {},
+    ...input.buildNumber !== void 0 ? { buildNumber: cleanOptionalText(String(input.buildNumber), 80) } : {},
+    ...cleanOptionalText(input.changelog, 4e3) ? { changelog: cleanOptionalText(input.changelog, 4e3) } : {},
+    artifacts: await inspectArtifacts(input.artifactPaths),
+    targets,
+    outcome: input.outcome ?? inferOutcome(targets),
+    startedAt: startedAt.toISOString(),
+    finishedAt: finishedAt.toISOString(),
+    durationMs: Math.max(0, finishedAt.getTime() - startedAt.getTime())
+  };
+}
+function formatReleaseReceipt(receipt) {
+  const lines = [
+    `${receipt.appName || receipt.packageName || "\u5E94\u7528"} \xB7 ${receipt.kind === "build" ? "\u6784\u5EFA\u56DE\u6267" : "\u4E0A\u4F20\u56DE\u6267"}`,
+    `\u7ED3\u679C\uFF1A${receipt.outcome}`,
+    `\u7248\u672C\uFF1A${receipt.versionName || "-"} (${receipt.buildNumber || "-"})`,
+    `\u5B8C\u6210\u65F6\u95F4\uFF1A${receipt.finishedAt}`
+  ];
+  if (receipt.packageName) lines.push(`\u5305\u540D\uFF1A${receipt.packageName}`);
+  if (receipt.changelog) lines.push(`\u66F4\u65B0\u65E5\u5FD7\uFF1A${receipt.changelog}`);
+  for (const artifact of receipt.artifacts) {
+    lines.push(
+      `\u4EA7\u7269\uFF1A${artifact.path}${artifact.sizeBytes !== void 0 ? ` \xB7 ${artifact.sizeBytes} bytes` : ""}${artifact.sha256 ? ` \xB7 SHA-256 ${artifact.sha256}` : ""}`
+    );
+  }
+  for (const target of receipt.targets) {
+    lines.push(`${target.platform}\uFF1A${target.state} \xB7 ${target.message}`);
+    if (target.remote?.consoleUrl) lines.push(`\u540E\u53F0\uFF1A${target.remote.consoleUrl}`);
+  }
+  return lines.join("\n");
+}
+var ReleaseReceiptStore = class {
+  storageRoot;
+  maxEntries;
+  constructor(options = {}) {
+    this.storageRoot = import_path3.default.resolve(options.storageRoot || import_path3.default.join((0, import_os.homedir)(), ".flu-cli", "release-receipts"));
+    this.maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_RELEASE_RECEIPT_LIMIT);
+  }
+  async append(receipt) {
+    await (0, import_promises.mkdir)(this.storageRoot, { recursive: true, mode: 448 });
+    await (0, import_promises.chmod)(this.storageRoot, 448);
+    const filePath = this.getFilePath(receipt.projectKey);
+    const current = await this.readFile(filePath, receipt.projectKey);
+    const receipts = [receipt, ...current.receipts.filter((item) => item.id !== receipt.id)].slice(
+      0,
+      this.maxEntries
+    );
+    const tempPath = `${filePath}.${process.pid}.${(0, import_crypto3.randomUUID)()}.tmp`;
+    await (0, import_promises.writeFile)(
+      tempPath,
+      `${JSON.stringify({
+        schemaVersion: RELEASE_RECEIPT_SCHEMA_VERSION,
+        projectKey: receipt.projectKey,
+        receipts
+      }, null, 2)}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
+    await (0, import_promises.rename)(tempPath, filePath);
+    await (0, import_promises.chmod)(filePath, 384);
+  }
+  async list(projectRoot, limit = 20) {
+    const canonicalRoot = await canonicalizeProjectRoot(projectRoot);
+    const projectKey = createProjectKey(canonicalRoot);
+    const data = await this.readFile(this.getFilePath(projectKey), projectKey);
+    return data.receipts.slice(0, Math.max(0, limit));
+  }
+  async save(input) {
+    const receipt = await createReleaseReceipt(input);
+    await this.append(receipt);
+    return receipt;
+  }
+  getFilePath(projectKey) {
+    return import_path3.default.join(this.storageRoot, `${projectKey}.json`);
+  }
+  async readFile(filePath, projectKey) {
+    try {
+      const raw = JSON.parse(await (0, import_promises.readFile)(filePath, "utf8"));
+      return {
+        schemaVersion: RELEASE_RECEIPT_SCHEMA_VERSION,
+        projectKey,
+        receipts: Array.isArray(raw.receipts) ? raw.receipts : []
+      };
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        return { schemaVersion: RELEASE_RECEIPT_SCHEMA_VERSION, projectKey, receipts: [] };
+      }
+      throw new Error(`\u8BFB\u53D6\u53D1\u5E03\u56DE\u6267\u5931\u8D25: ${sanitizeReleaseMessage(error?.message || error)}`);
+    }
+  }
+};
+function createProjectKey(projectRoot) {
+  return (0, import_crypto3.createHash)("sha256").update(import_path3.default.resolve(projectRoot)).digest("hex").slice(0, 24);
+}
+function createRemoteReceipt(result, data) {
+  const identifiers = {};
+  for (const key of REMOTE_IDENTIFIER_KEYS) {
+    const value = data?.[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      identifiers[key] = typeof value === "string" ? sanitizeReleaseMessage(value, 240) : value;
+    }
+  }
+  const consoleUrl = cleanHttpUrl(result.consoleUrl);
+  const downloadUrl = cleanHttpUrl(result.url || result.link);
+  if (!consoleUrl && !downloadUrl && Object.keys(identifiers).length === 0) return void 0;
+  return {
+    ...consoleUrl ? { consoleUrl } : {},
+    ...downloadUrl ? { downloadUrl } : {},
+    ...Object.keys(identifiers).length > 0 ? { identifiers } : {}
+  };
+}
+function sanitizeTarget(target) {
+  return {
+    platform: sanitizeReleaseMessage(target.platform, 80) || "unknown",
+    state: target.state,
+    outcome: target.outcome,
+    message: sanitizeReleaseMessage(target.message),
+    ...target.remote ? { remote: sanitizeRemote(target.remote) } : {},
+    ...cleanOptionalText(target.lastKnownRemoteStatus, 120) ? { lastKnownRemoteStatus: cleanOptionalText(target.lastKnownRemoteStatus, 120) } : {},
+    ...cleanOptionalText(target.checkedAt, 80) ? { checkedAt: cleanOptionalText(target.checkedAt, 80) } : {}
+  };
+}
+function sanitizeRemote(remote) {
+  const identifiers = {};
+  for (const [key, value] of Object.entries(remote.identifiers || {})) {
+    if (!REMOTE_IDENTIFIER_KEYS.includes(key)) continue;
+    if (typeof value === "string") identifiers[key] = sanitizeReleaseMessage(value, 240);
+    if (typeof value === "number" || typeof value === "boolean") identifiers[key] = value;
+  }
+  const consoleUrl = cleanHttpUrl(remote.consoleUrl);
+  const downloadUrl = cleanHttpUrl(remote.downloadUrl);
+  return {
+    ...consoleUrl ? { consoleUrl } : {},
+    ...downloadUrl ? { downloadUrl } : {},
+    ...Object.keys(identifiers).length > 0 ? { identifiers } : {}
+  };
+}
+async function inspectArtifacts(value) {
+  const paths = Array.from(new Set(flattenArtifactPaths(value).map((item) => import_path3.default.resolve(item))));
+  return Promise.all(paths.map(inspectArtifact));
+}
+async function inspectArtifact(filePath) {
+  const base = { path: filePath, name: import_path3.default.basename(filePath) };
+  try {
+    const info = await (0, import_promises.stat)(filePath);
+    if (!info.isFile()) return { ...base, available: false };
+    return {
+      ...base,
+      sizeBytes: info.size,
+      sha256: await hashFile(filePath),
+      available: true
+    };
+  } catch {
+    return { ...base, available: false };
+  }
+}
+function hashFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = (0, import_crypto3.createHash)("sha256");
+    const stream = (0, import_fs2.createReadStream)(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+function flattenArtifactPaths(value) {
+  if (typeof value === "string" && value.trim()) return [value];
+  if (Array.isArray(value)) return value.flatMap(flattenArtifactPaths);
+  if (isRecord(value)) return Object.values(value).flatMap(flattenArtifactPaths);
+  return [];
+}
+function inferOutcome(targets) {
+  if (targets.length === 0) return "failed";
+  if (targets.every((target) => target.outcome === "cancelled")) return "cancelled";
+  const successCount = targets.filter((target) => target.outcome === "success").length;
+  if (successCount === targets.length) return "success";
+  if (successCount > 0) return "partial";
+  return "failed";
+}
+async function canonicalizeProjectRoot(projectRoot) {
+  const resolved = import_path3.default.resolve(projectRoot);
+  try {
+    return await (0, import_promises.realpath)(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function toDate(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? /* @__PURE__ */ new Date() : date;
+}
+function cleanOptionalText(value, maxLength) {
+  const cleaned = sanitizeReleaseMessage(value, maxLength);
+  return cleaned || void 0;
+}
+function cleanHttpUrl(value) {
+  if (typeof value !== "string") return void 0;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    for (const key of Array.from(url.searchParams.keys())) {
+      if (/token|secret|password|signature|credential|key/i.test(key)) {
+        url.searchParams.set(key, "[\u5DF2\u8131\u654F]");
+      }
+    }
+    return url.toString();
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/adapters/pgyer_uploader.ts
 var PgyerUploader = class _PgyerUploader {
   name = "Pgyer";
@@ -1062,7 +2009,7 @@ var PgyerUploader = class _PgyerUploader {
 
 // src/adapters/huawei_uploader.ts
 var import_fs_extra4 = __toESM(require("fs-extra"), 1);
-var import_path3 = __toESM(require("path"), 1);
+var import_path4 = __toESM(require("path"), 1);
 var import_util = require("util");
 var import_axios2 = __toESM(require("axios"), 1);
 var import_form_data2 = __toESM(require("form-data"), 1);
@@ -1141,7 +2088,7 @@ var HuaweiUploader = class _HuaweiUploader {
     const clientSecret = hwConfig.auth.clientSecret;
     const appId = hwConfig.appId;
     const releaseType = hwConfig.releaseType || "draft";
-    const suffix = import_path3.default.extname(filePath).substring(1);
+    const suffix = import_path4.default.extname(filePath).substring(1);
     const retryConfig = config.retry;
     const tokenUrl = this.getTokenUrl(config);
     const publishApiRoot = this.getApiRoot(config);
@@ -1162,27 +2109,39 @@ var HuaweiUploader = class _HuaweiUploader {
         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 artifacts = typeof metadata.artifactPath === "object" ? metadata.artifactPath : { universal: filePath || metadata.artifactPath || "" };
+      logger.info(`[Huawei] \u5904\u7406\u4EA7\u7269\u6570\u91CF: ${Object.keys(artifacts).length}`);
+      const uploadResults = [];
+      const uploadPromises = Object.entries(artifacts).map(async ([abi, p]) => {
+        if (!p || !import_fs_extra4.default.existsSync(p)) return;
+        const currentSuffix = import_path4.default.extname(p).substring(1);
+        logger.info(`[Huawei] \u6B63\u5728\u4E0A\u4F20 ${abi} \u5305: ${import_path4.default.basename(p)}`);
+        const uploadInfo = await retryStrategy.execute(
+          () => this.getUploadUrl(ctx, currentSuffix),
+          `Huawei get upload URL for ${abi}`
+        );
+        if (!uploadInfo.success || !uploadInfo.data) {
+          throw uploadInfo.error || new Error(`Failed to get upload URL for ${abi}`);
+        }
+        const uploadFileRes = await retryStrategy.execute(
+          () => this.executeUploadRequest(uploadInfo.data.uploadUrl, uploadInfo.data.authCode, p),
+          `Huawei upload file for ${abi}`
+        );
+        if (!uploadFileRes.success || !uploadFileRes.data || uploadFileRes.data.length === 0) {
+          throw uploadFileRes.error || new Error(`File upload failed for ${abi}`);
+        }
+        uploadResults.push({
+          fileName: import_path4.default.basename(p),
+          fileDestUrl: uploadFileRes.data[0].fileDestUrl
+        });
+      });
+      await Promise.all(uploadPromises);
+      if (uploadResults.length === 0) {
+        throw new Error("No files were successfully uploaded");
       }
-      const fileDestUrl = uploadFileResult.data.fileDestUrl;
-      logger.info("Linking file to app...");
+      logger.info(`[Huawei] \u6B63\u5728\u5173\u8054 ${uploadResults.length} \u4E2A\u6587\u4EF6\u5230\u5E94\u7528...`);
       const updateInfoResult = await retryStrategy.execute(
-        () => this.updateAppFileInfo(ctx, fileDestUrl, filePath),
+        () => this.updateAppFileInfo(ctx, uploadResults, filePath),
         "Huawei update file info"
       );
       if (!updateInfoResult.success) {
@@ -1344,7 +2303,7 @@ var HuaweiUploader = class _HuaweiUploader {
   }
   /** 通用文件上传（FormData 方式，无需 API 认证头） */
   async executeUploadRequest(uploadUrl, authCode, filePath) {
-    const fileName = import_path3.default.basename(filePath);
+    const fileName = import_path4.default.basename(filePath);
     const fileSize = import_fs_extra4.default.statSync(filePath).size;
     const form = new import_form_data2.default();
     form.append("file", import_fs_extra4.default.createReadStream(filePath), {
@@ -1386,14 +2345,17 @@ var HuaweiUploader = class _HuaweiUploader {
     throw new Error("Upload succeeded but fileDestUrl not found in response");
   }
   /** 更新应用文件信息 */
-  async updateAppFileInfo(ctx, fileDestUrl, filePath) {
-    const fileName = import_path3.default.basename(filePath);
-    const fileType = import_path3.default.extname(filePath).toLowerCase() === ".aab" ? 7 : 5;
+  async updateAppFileInfo(ctx, files, anyFilePath) {
+    const hasAab = files.some((f) => f.fileName.toLowerCase().endsWith(".aab"));
+    const fileType = hasAab ? 7 /* AAB */ : 5 /* APP_PACKAGE */;
     const res = await import_axios2.default.put(
       `${ctx.apiRoot}/app-file-info`,
       {
         fileType,
-        files: [{ fileName, fileDestUrl }]
+        files: files.map((f) => ({
+          fileName: f.fileName,
+          fileDestUrl: f.fileDestUrl
+        }))
       },
       {
         params: { appId: ctx.appId },
@@ -1508,7 +2470,7 @@ var HuaweiUploader = class _HuaweiUploader {
         logger.warn(`Asset file not found, skipping: ${filePath}`);
         continue;
       }
-      const suffix = import_path3.default.extname(filePath).substring(1).toLowerCase();
+      const suffix = import_path4.default.extname(filePath).substring(1).toLowerCase();
       if (!HUAWEI_SUPPORTED_SUFFIXES.image.includes(suffix)) {
         logger.warn(`Unsupported file type ${suffix}, skipping: ${filePath}`);
         continue;
@@ -1563,9 +2525,10 @@ var HuaweiUploader = class _HuaweiUploader {
 
 // src/adapters/xiaomi_uploader.ts
 var import_fs_extra5 = __toESM(require("fs-extra"), 1);
+var import_path5 = __toESM(require("path"), 1);
 var import_axios3 = __toESM(require("axios"), 1);
 var import_form_data3 = __toESM(require("form-data"), 1);
-var import_crypto3 = __toESM(require("crypto"), 1);
+var import_crypto4 = __toESM(require("crypto"), 1);
 var XiaomiUploader = class _XiaomiUploader {
   name = "Xiaomi";
   static API_BASE = "https://api.developer.xiaomi.com/devupload";
@@ -1585,10 +2548,10 @@ var XiaomiUploader = class _XiaomiUploader {
     const chunks = [];
     for (let offset = 0; offset < buffer.length; offset += maxBlock) {
       const chunk = buffer.subarray(offset, offset + maxBlock);
-      const encrypted = import_crypto3.default.publicEncrypt(
+      const encrypted = import_crypto4.default.publicEncrypt(
         {
           key: publicKey,
-          padding: import_crypto3.default.constants.RSA_PKCS1_PADDING
+          padding: import_crypto4.default.constants.RSA_PKCS1_PADDING
         },
         chunk
       );
@@ -1602,15 +2565,15 @@ var XiaomiUploader = class _XiaomiUploader {
    */
   extractPublicKey(buffer) {
     try {
-      const x509 = new import_crypto3.default.X509Certificate(buffer);
+      const x509 = new import_crypto4.default.X509Certificate(buffer);
       return x509.publicKey;
     } catch (e) {
       try {
         const content = buffer.toString();
         if (content.includes("-----BEGIN")) {
-          return import_crypto3.default.createPublicKey(content);
+          return import_crypto4.default.createPublicKey(content);
         }
-        return import_crypto3.default.createPublicKey(this.normalizePEM(content));
+        return import_crypto4.default.createPublicKey(this.normalizePEM(content));
       } catch (e2) {
         throw new Error(`\u65E0\u6CD5\u63D0\u53D6\u516C\u94A5: ${e instanceof Error ? e.message : "\u672A\u77E5\u9519\u8BEF"}`);
       }
@@ -1621,7 +2584,7 @@ var XiaomiUploader = class _XiaomiUploader {
    */
   async calculateFileMD5(filePath) {
     return new Promise((resolve, reject) => {
-      const hash = import_crypto3.default.createHash("md5");
+      const hash = import_crypto4.default.createHash("md5");
       const stream = import_fs_extra5.default.createReadStream(filePath);
       stream.on("data", (data) => hash.update(data));
       stream.on("end", () => resolve(hash.digest("hex")));
@@ -1632,7 +2595,7 @@ var XiaomiUploader = class _XiaomiUploader {
    * 计算字符串 MD5 (小写十六进制)
    */
   calculateStringMD5(str) {
-    return import_crypto3.default.createHash("md5").update(str, "utf-8").digest("hex");
+    return import_crypto4.default.createHash("md5").update(str, "utf-8").digest("hex");
   }
   /**
    * 构建 RequestData JSON
@@ -1813,80 +2776,39 @@ ${lines.join("\n")}
     const xiaomiConfig = config.publish?.xiaomi;
     const { userName, privateKey, publicKeyPath } = xiaomiConfig.auth;
     const updateDesc = metadata.changelog || xiaomiConfig?.description || "App Update";
-    const retryConfig = config.retry;
-    if (!import_fs_extra5.default.existsSync(filePath)) {
-      return {
-        platform: "xiaomi",
-        success: false,
-        message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`
-      };
-    }
+    const artifacts = typeof metadata.artifactPath === "object" ? metadata.artifactPath : { universal: filePath || (typeof metadata.artifactPath === "string" ? metadata.artifactPath : "") };
     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"
-      };
+      throw new Error("\u65E0\u6CD5\u83B7\u53D6 RSA \u516C\u94A5");
     }
-    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`
-        };
-      }
-    }
+    const anyPath = Object.values(artifacts)[0];
+    const packageName = xiaomiConfig.packageName || this.inferPackageName(anyPath);
+    if (!packageName) throw new Error("\u7F3A\u5C11 packageName");
+    const appName = xiaomiConfig.appName || this.inferAppName(packageName);
     try {
-      const retryStrategy = createUploadRetryStrategy(retryConfig);
+      logger.info(`\u5F00\u59CB\u4E0A\u4F20\u5230\u5C0F\u7C73\u5E94\u7528\u5546\u5E97 (\u5305\u542B ${Object.keys(artifacts).length} \u4E2A\u5305)...`);
+      let uploadType = xiaomiConfig.uploadType || "auto";
+      let finalUploadType;
+      let existingAppInfo = null;
+      if (uploadType === "auto") {
+        const status = await this.queryAppStatus(userName, packageName, privateKey, publicKeyObj);
+        finalUploadType = status.type;
+        existingAppInfo = status.appInfo;
+      } else {
+        finalUploadType = uploadType;
+      }
+      const retryStrategy = createUploadRetryStrategy(config.retry);
       const result = await retryStrategy.execute(
         () => this.performUpload({
-          filePath,
+          artifacts,
           userName,
           privateKey,
           publicKey: resolvedPublicKey,
+          uploadType: finalUploadType,
           packageName,
-          appName,
+          appName: appName || "",
           updateDesc,
-          uploadType,
           category: xiaomiConfig.category || existingAppInfo?.category,
           keyWords: xiaomiConfig.keyWords || existingAppInfo?.keyWords,
           desc: xiaomiConfig.desc || existingAppInfo?.desc,
@@ -1896,50 +2818,19 @@ ${lines.join("\n")}
         }),
         "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,
+        message: "\u4E0A\u4F20\u6210\u529F",
         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
-      };
+      logger.error(`\u5C0F\u7C73\u4E0A\u4F20\u5931\u8D25: ${error.message}`);
+      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 { artifacts, userName, privateKey, publicKey, packageName, appName, updateDesc, uploadType, category, keyWords, desc, brief, privacyUrl, assets } = params;
     const publicKeyObj = this.extractPublicKey(publicKey);
     const requestData = this.buildRequestData({
       userName,
@@ -1953,67 +2844,55 @@ ${lines.join("\n")}
       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}`);
+    let mainPath;
+    let secondPath = void 0;
+    const artifactEntries = Object.entries(artifacts);
+    const arm64 = artifactEntries.find(([abi]) => abi === "arm64-v8a");
+    const arm32 = artifactEntries.find(([abi]) => abi === "armeabi-v7a");
+    if (arm64 && arm32) {
+      mainPath = arm64[1];
+      secondPath = arm32[1];
+      logger.info(`[Xiaomi] \u8BC6\u522B\u5230\u591A\u67B6\u6784\u5206\u5305: \u4E3B\u5305(64\u4F4D)=${import_path5.default.basename(mainPath)}, \u6B21\u5305(32\u4F4D)=${import_path5.default.basename(secondPath)}`);
+    } else {
+      mainPath = artifactEntries[0][1];
+      if (artifactEntries.length > 1) {
+        secondPath = artifactEntries[1][1];
+        logger.info(`[Xiaomi] \u8BC6\u522B\u5230\u591A\u4E2A\u5305\uFF08\u975E\u6807\u51C6\u540D\uFF09\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u987A\u5E8F: \u4E3B\u5305=${import_path5.default.basename(mainPath)}, \u6B21\u5305=${import_path5.default.basename(secondPath)}`);
+      } else {
+        logger.info(`[Xiaomi] \u4F7F\u7528\u5355\u5305\u6A21\u5F0F: ${import_path5.default.basename(mainPath)}`);
+      }
+    }
+    const mainMD5 = await this.calculateFileMD5(mainPath);
     const extraSigItems = [];
-    let iconPath;
+    if (secondPath) {
+      const secondMD5 = await this.calculateFileMD5(secondPath);
+      extraSigItems.push({ name: "secondApk", hash: secondMD5 });
+    }
     if (assets?.icon && import_fs_extra5.default.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 (import_fs_extra5.default.existsSync(ssPath)) {
-          screenshotPaths.push(ssPath);
-          const ssMD5 = await this.calculateFileMD5(ssPath);
-          extraSigItems.push({ name: `screenshot_${i + 1}`, hash: ssMD5 });
-        }
-      }
+      extraSigItems.push({ name: "icon", hash: await this.calculateFileMD5(assets.icon) });
     }
-    const sig = this.generateUploadSIG(
-      requestDataMD5,
-      apkFileMD5,
-      privateKey,
-      publicKeyObj,
-      extraSigItems.length > 0 ? extraSigItems : void 0
-    );
-    logger.info("SIG \u7B7E\u540D\u5DF2\u751F\u6210");
+    const sig = this.generateUploadSIG(requestDataMD5, mainMD5, privateKey, publicKeyObj, extraSigItems);
     const form = new import_form_data3.default();
     form.append("RequestData", requestData);
     form.append("SIG", sig);
-    form.append("apk", import_fs_extra5.default.createReadStream(filePath));
-    if (iconPath) {
-      form.append("icon", import_fs_extra5.default.createReadStream(iconPath));
-      logger.info(`\u9644\u52A0 icon: ${iconPath}`);
+    form.append("apk", import_fs_extra5.default.createReadStream(mainPath));
+    if (secondPath) {
+      form.append("secondApk", import_fs_extra5.default.createReadStream(secondPath));
     }
-    for (let i = 0; i < screenshotPaths.length; i++) {
-      form.append(`screenshot_${i + 1}`, import_fs_extra5.default.createReadStream(screenshotPaths[i]));
-      logger.info(`\u9644\u52A0 screenshot_${i + 1}: ${screenshotPaths[i]}`);
+    if (assets?.icon && import_fs_extra5.default.existsSync(assets.icon)) {
+      form.append("icon", import_fs_extra5.default.createReadStream(assets.icon));
     }
-    logger.info(`POST ${_XiaomiUploader.PUSH_API}`);
     const response = await import_axios3.default.post(_XiaomiUploader.PUSH_API, form, {
-      headers: {
-        ...form.getHeaders()
-      },
+      headers: form.getHeaders(),
       maxContentLength: Infinity,
       maxBodyLength: Infinity,
-      timeout: 6e4
-      // 60 秒请求超时
+      timeout: 12e4
     });
-    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}`);
+    if (response.data?.result !== 0) {
+      throw new Error(`\u5C0F\u7C73 API \u9519\u8BEF: ${response.data?.message || JSON.stringify(response.data)}`);
     }
-    logger.info(`\u5C0F\u7C73 API \u54CD\u5E94: ${JSON.stringify(data)}`);
-    return data;
+    return response.data;
   }
   /**
    * 解析公钥: 优先使用内容字段, 其次从文件路径读取
@@ -2055,7 +2934,7 @@ ${lines.join("\n")}
 
 // src/adapters/apple_store_uploader.ts
 var import_fs_extra6 = __toESM(require("fs-extra"), 1);
-var import_path4 = __toESM(require("path"), 1);
+var import_path6 = __toESM(require("path"), 1);
 var import_child_process = require("child_process");
 var import_util2 = require("util");
 var import_axios4 = __toESM(require("axios"), 1);
@@ -2221,7 +3100,7 @@ var AppleStoreUploader = class {
       appPassword,
       "-showTransferRate"
     ].join(" ");
-    logger.info(`[Transporter] Uploading: ${import_path4.default.basename(ipaPath)}`);
+    logger.info(`[Transporter] Uploading: ${import_path6.default.basename(ipaPath)}`);
     try {
       const { stdout, stderr } = await execAsync(command, {
         timeout: 30 * 60 * 1e3,
@@ -2272,7 +3151,7 @@ Stderr: ${error.stderr || ""}`);
       });
       command = innerArgs.join(" ");
     }
-    logger.info(`[altool] Uploading: ${import_path4.default.basename(ipaPath)}`);
+    logger.info(`[altool] Uploading: ${import_path6.default.basename(ipaPath)}`);
     logger.info(`[altool] Command prefix: ${tool.command}`);
     try {
       const { stdout, stderr } = await execAsync(command, {
@@ -2856,7 +3735,7 @@ var TestFlightUploader = class _TestFlightUploader {
 
 // src/adapters/adhoc_uploader.ts
 var import_fs_extra8 = __toESM(require("fs-extra"), 1);
-var import_path5 = __toESM(require("path"), 1);
+var import_path7 = __toESM(require("path"), 1);
 var import_child_process2 = require("child_process");
 var AdHocUploader = class {
   name = "AdHoc";
@@ -2989,8 +3868,8 @@ var AdHocUploader = class {
    * @param changelog 更新日志
    */
   async createManifest(ipaPath, version, bundleId, changelog) {
-    const ipaFileName = import_path5.default.basename(ipaPath);
-    const appName = bundleId || import_path5.default.parse(ipaFileName).name;
+    const ipaFileName = import_path7.default.basename(ipaPath);
+    const appName = bundleId || import_path7.default.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">
@@ -3049,14 +3928,14 @@ var AdHocUploader = class {
    */
   async setupDistributionDirectory(ipaPath, manifestPath) {
     const projectRoot = process.cwd();
-    const distributionDir = import_path5.default.join(projectRoot, "build", "adhoc-distribution");
+    const distributionDir = import_path7.default.join(projectRoot, "build", "adhoc-distribution");
     await import_fs_extra8.default.ensureDir(distributionDir);
-    await import_fs_extra8.default.ensureDir(import_path5.default.join(distributionDir, "apps"));
-    await import_fs_extra8.default.ensureDir(import_path5.default.join(distributionDir, "manifests"));
-    await import_fs_extra8.default.ensureDir(import_path5.default.join(distributionDir, "icons"));
-    const ipaFileName = import_path5.default.basename(ipaPath);
-    await import_fs_extra8.default.copy(ipaPath, import_path5.default.join(distributionDir, "apps", ipaFileName));
-    await import_fs_extra8.default.copy(manifestPath, import_path5.default.join(distributionDir, "manifests", `${ipaFileName}.plist`));
+    await import_fs_extra8.default.ensureDir(import_path7.default.join(distributionDir, "apps"));
+    await import_fs_extra8.default.ensureDir(import_path7.default.join(distributionDir, "manifests"));
+    await import_fs_extra8.default.ensureDir(import_path7.default.join(distributionDir, "icons"));
+    const ipaFileName = import_path7.default.basename(ipaPath);
+    await import_fs_extra8.default.copy(ipaPath, import_path7.default.join(distributionDir, "apps", ipaFileName));
+    await import_fs_extra8.default.copy(manifestPath, import_path7.default.join(distributionDir, "manifests", `${ipaFileName}.plist`));
     logger.info(`Distribution directory: ${distributionDir}`);
     return distributionDir;
   }
@@ -3066,7 +3945,7 @@ var AdHocUploader = class {
    * @param bundleId Bundle ID
    */
   generateInstallUrl(distributionPath, bundleId) {
-    const manifestPath = import_path5.default.join(distributionPath, "manifests", `*.plist`);
+    const manifestPath = import_path7.default.join(distributionPath, "manifests", `*.plist`);
     return `itms-services://?action=download-manifest&url=file://${manifestPath}`;
   }
   /**
@@ -3075,7 +3954,7 @@ var AdHocUploader = class {
    * @param distributionPath 分发目录
    */
   async generateQRCode(url, distributionPath) {
-    const qrCodePath = import_path5.default.join(distributionPath, "install-qrcode.png");
+    const qrCodePath = import_path7.default.join(distributionPath, "install-qrcode.png");
     try {
       logger.info(`QR code would be saved to: ${qrCodePath}`);
       logger.info(`Install URL: ${url}`);
@@ -3102,8 +3981,8 @@ var AdHocUploader = class {
     logger.newLine();
     logger.info("\u{1F4E6} Distribution Files:");
     logger.info(`  Directory: ${distributionPath}`);
-    logger.info(`  IPA: ${import_path5.default.join(distributionPath, "apps", "*.ipa")}`);
-    logger.info(`  Manifest: ${import_path5.default.join(distributionPath, "manifests", "*.plist")}`);
+    logger.info(`  IPA: ${import_path7.default.join(distributionPath, "apps", "*.ipa")}`);
+    logger.info(`  Manifest: ${import_path7.default.join(distributionPath, "manifests", "*.plist")}`);
     logger.info(`  QR Code: ${qrCodePath}`);
     logger.newLine();
     logger.info("\u{1F517} Installation Link:");
@@ -3162,7 +4041,7 @@ var AdHocUploader = class {
 
 // src/adapters/harmony_uploader.ts
 var import_fs_extra9 = __toESM(require("fs-extra"), 1);
-var import_path6 = __toESM(require("path"), 1);
+var import_path8 = __toESM(require("path"), 1);
 var import_axios6 = __toESM(require("axios"), 1);
 var import_form_data5 = __toESM(require("form-data"), 1);
 var HarmonyUploader = class _HarmonyUploader {
@@ -3192,7 +4071,7 @@ var HarmonyUploader = class _HarmonyUploader {
     const clientSecret = harmonyConfig.auth.clientSecret;
     const appId = harmonyConfig.appId;
     const releaseType = harmonyConfig.releaseType || "draft";
-    const suffix = import_path6.default.extname(filePath).substring(1);
+    const suffix = import_path8.default.extname(filePath).substring(1);
     const retryConfig = config.retry;
     logger.info("Starting HarmonyOS AppGallery upload...");
     try {
@@ -3309,7 +4188,7 @@ var HarmonyUploader = class _HarmonyUploader {
    * @param filePath 文件路径
    */
   async updateAppFileInfo(token, appId, authCode, filePath) {
-    const fileName = import_path6.default.basename(filePath);
+    const fileName = import_path8.default.basename(filePath);
     const body = {
       fileType: 7,
       // 鸿蒙包的 fileType（需要根据华为最新文档确认）
@@ -3332,10 +4211,10 @@ var HarmonyUploader = class _HarmonyUploader {
 
 // src/adapters/oppo_uploader.ts
 var import_fs_extra10 = __toESM(require("fs-extra"), 1);
-var import_path7 = __toESM(require("path"), 1);
+var import_path9 = __toESM(require("path"), 1);
 var import_axios7 = __toESM(require("axios"), 1);
 var import_form_data6 = __toESM(require("form-data"), 1);
-var import_crypto4 = __toESM(require("crypto"), 1);
+var import_crypto5 = __toESM(require("crypto"), 1);
 var OppoUploader = class _OppoUploader {
   name = "OPPO";
   /** OPPO 开放 API 基础地址 */
@@ -3354,7 +4233,7 @@ var OppoUploader = class _OppoUploader {
    */
   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 import_crypto4.default.createHmac("sha256", clientSecret).update(sorted).digest("hex");
+    return import_crypto5.default.createHmac("sha256", clientSecret).update(sorted).digest("hex");
   }
   validateConfig(config) {
     if (!config?.publish?.oppo?.enable) return false;
@@ -3373,7 +4252,7 @@ var OppoUploader = class _OppoUploader {
    * 尝试从文件名推断包名
    */
   inferPackageName(filePath) {
-    const fileName = import_path7.default.basename(filePath);
+    const fileName = import_path9.default.basename(filePath);
     const match = fileName.match(/^([\w.]+?)(?:-(?:release|debug|unsigned))?\.apk$/i);
     if (match && match[1].includes(".")) {
       return match[1];
@@ -3391,110 +4270,47 @@ var OppoUploader = class _OppoUploader {
   }
   async upload(filePath, config, metadata) {
     const oppoConfig = config.publish.oppo;
-    const clientId = oppoConfig.auth.clientId;
-    const clientSecret = oppoConfig.auth.clientSecret;
+    const accessToken = await this.getAccessToken(oppoConfig.auth.clientId, 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 (!import_fs_extra10.default.existsSync(filePath)) {
-      return {
-        platform: "oppo",
-        success: false,
-        message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`,
-        consoleUrl
-      };
+    if (!packageName) {
+      return { platform: "oppo", success: false, message: "\u65E0\u6CD5\u83B7\u53D6\u5305\u540D", consoleUrl };
     }
-    logger.info("\u5F00\u59CB\u4E0A\u4F20\u5230 OPPO \u5E94\u7528\u5546\u5E97...");
-    logger.info(`\u6587\u4EF6: ${filePath}`);
+    const artifacts = typeof metadata.artifactPath === "object" ? metadata.artifactPath : { universal: filePath || (typeof metadata.artifactPath === "string" ? metadata.artifactPath : "") };
     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");
-      }
+      const retryStrategy = createUploadRetryStrategy(config.retry);
+      const onlineAppInfo = await this.getAppInfo(accessToken, oppoConfig.auth.clientSecret, packageName) || {};
+      const uploadResults = [];
+      const uploadPromises = Object.entries(artifacts).map(async ([abi, p]) => {
+        if (!p || !import_fs_extra10.default.existsSync(p)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${p}`);
+        logger.info(`[OPPO] \u6B63\u5728\u5904\u7406 ${abi} \u67B6\u6784\u5305...`);
+        const { uploadUrl, sign } = await this.getUploadUrl(accessToken, oppoConfig.auth.clientSecret);
+        const uploadFileResult = await this.uploadFile(uploadUrl, sign, p);
+        const fileUrl = uploadFileResult.url.replace(/^http:\/\//i, "https://").replace("storedl1.nearme.com.cn", "storedl.nearme.com.cn");
+        let cpu_code = 0;
+        if (abi === "arm64-v8a") cpu_code = 3;
+        else if (abi === "armeabi-v7a") cpu_code = 4;
+        uploadResults.push({ url: fileUrl, md5: uploadFileResult.md5, cpu_code });
+      });
+      await Promise.all(uploadPromises);
+      logger.info(`[OPPO] \u6B63\u5728\u63D0\u4EA4\u6D41\u6C34\u53F7\u7EC4: ${JSON.stringify(uploadResults)}`);
+      await this.submitVersion({
+        accessToken,
+        clientSecret: oppoConfig.auth.clientSecret,
+        packageName,
+        appName: oppoConfig.appName || onlineAppInfo.app_name || metadata.appName || this.inferAppName(packageName),
+        apkUrls: uploadResults,
+        versionName: metadata.version,
+        versionCode: metadata.buildNumber,
+        updateDesc: metadata.changelog || "App Update",
+        onlineType: oppoConfig.onlineType,
+        onlineAppInfo
+      });
       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
-      };
+      return { platform: "oppo", success: true, message: "\u4E0A\u4F20\u6210\u529F, \u8BF7\u786E\u8BA4", consoleUrl };
     } catch (error) {
       logger.error(`\u4E0A\u4F20\u5230 OPPO \u5931\u8D25: ${error.message}`);
-      return {
-        platform: "oppo",
-        success: false,
-        message: this.formatError(error),
-        error,
-        consoleUrl
-      };
+      return { platform: "oppo", success: false, message: error.message, error, consoleUrl };
     }
   }
   /**
@@ -3615,16 +4431,7 @@ var OppoUploader = class _OppoUploader {
     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
-          // 通用包
-        }
-      ]),
+      apk_url: JSON.stringify(params.apkUrls),
       version_name: params.versionName.split("+")[0],
       // 仅保留版本名部分
       version_code: vCode,
@@ -3726,34 +4533,22 @@ var OppoUploader = class _OppoUploader {
 
 // src/adapters/vivo_uploader.ts
 var import_fs_extra11 = __toESM(require("fs-extra"), 1);
-var import_path8 = __toESM(require("path"), 1);
+var import_path10 = __toESM(require("path"), 1);
 var import_axios8 = __toESM(require("axios"), 1);
 var import_form_data7 = __toESM(require("form-data"), 1);
-var import_crypto5 = __toESM(require("crypto"), 1);
+var import_crypto6 = __toESM(require("crypto"), 1);
 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 = import_crypto5.default.createHmac("sha256", accessSecret).update(sorted).digest("hex");
-    logger.info(`[VIVO DEBUG] \u5F85\u7B7E\u540D\u4E32: ${sorted} 
- -> \u7B7E\u540D\u7ED3\u679C: ${sign}`);
-    return sign;
+    return import_crypto6.default.createHmac("sha256", accessSecret).update(sorted).digest("hex");
   }
   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;
+    return !!(vivo.auth?.accessKey && vivo.auth?.accessSecret);
   }
   canHandle(filePath) {
     const ext = filePath.split(".").pop()?.toLowerCase();
@@ -3763,84 +4558,63 @@ var VivoUploader = class _VivoUploader {
     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 (!import_fs_extra11.default.existsSync(filePath)) {
-      return {
-        platform: "vivo",
-        success: false,
-        message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`,
-        consoleUrl
-      };
-    }
-    const fileSize = import_fs_extra11.default.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)`);
+    const artifacts = typeof metadata.artifactPath === "object" ? metadata.artifactPath : { universal: filePath || (typeof metadata.artifactPath === "string" ? metadata.artifactPath : "") };
     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 uploadResults = {};
+      const uploadPromises = Object.entries(artifacts).map(async ([abi, p]) => {
+        if (!p || !import_fs_extra11.default.existsSync(p)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${p}`);
+        const md5 = await this.calculateFileMD5(p);
+        logger.info(`[vivo] \u6B63\u5728\u5904\u7406 ${abi} \u67B6\u6784\u5305: ${import_path10.default.basename(p)}`);
+        const serialnumber = await this.uploadApk(accessKey, accessSecret, p, vivoConfig.packageName || "", md5);
+        const pkgInfo = await parsePackageInfo(p, { androidSdkPath: config.globalSettings?.androidSdkPath });
+        const nativeCodes = pkgInfo?.nativeCode || [];
+        const has64Bit = nativeCodes.includes("arm64-v8a") || nativeCodes.includes("x86_64") || abi === "arm64-v8a";
+        const has32Bit = nativeCodes.includes("armeabi-v7a") || nativeCodes.includes("armeabi") || abi === "armeabi-v7a";
+        uploadResults[abi] = { serialnumber, md5, is64Bit: has64Bit && !has32Bit };
+      });
+      await Promise.all(uploadPromises);
+      const arm64Result = uploadResults["arm64-v8a"] || Object.values(uploadResults).find((r) => r.is64Bit);
+      const arm32Result = uploadResults["armeabi-v7a"] || Object.values(uploadResults).find((r) => !r.is64Bit);
+      const submitData = {
+        packageName: vivoConfig.packageName,
+        versionCode: parseInt(metadata.buildNumber) || 1,
+        updateDesc: metadata.changelog || "App Update"
+      };
+      if (arm64Result) {
+        submitData.serialnumber = arm64Result.serialnumber;
+        submitData.fileMd5 = arm64Result.md5;
       }
-      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");
+      if (arm32Result) {
+        submitData.apk32 = arm32Result.serialnumber;
+        submitData.md532 = arm32Result.md5;
+      }
+      if (!submitData.serialnumber && !submitData.apk32) {
+        const single = Object.values(uploadResults)[0];
+        submitData.serialnumber = single.serialnumber;
+        submitData.fileMd5 = single.md5;
       }
+      logger.info(`[vivo] \u6B63\u5728\u63D0\u4EA4\u5BA1\u6838\u7533\u62A5: ${JSON.stringify(submitData)}`);
+      await this.submitVersion(accessKey, accessSecret, submitData);
       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
-      };
+      return { platform: "vivo", success: true, message: "\u4E0A\u4F20\u5E76\u63D0\u4EA4\u5BA1\u6838\u6210\u529F", consoleUrl };
     } catch (error) {
       logger.error(`\u4E0A\u4F20\u5230 vivo \u5931\u8D25: ${error.message}`);
-      return {
-        platform: "vivo",
-        success: false,
-        message: this.formatError(error),
-        error,
-        consoleUrl
-      };
+      return { platform: "vivo", success: false, message: error.message, error, consoleUrl };
     }
   }
-  /**
-   * 计算文件 MD5
-   */
   calculateFileMD5(filePath) {
     return new Promise((resolve, reject) => {
-      const hash = import_crypto5.default.createHash("md5");
+      const hash = import_crypto6.default.createHash("md5");
       const stream = import_fs_extra11.default.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 = {
-      // 公共参数
+    const params = {
       access_key: accessKey,
       timestamp,
       format: "json",
@@ -3848,41 +4622,19 @@ var VivoUploader = class _VivoUploader {
       sign_method: "hmac",
       target_app_key: "developer",
       method: "app.upload.apk.app",
-      // 业务参数
       packageName,
       fileMd5
     };
-    const sign = this.generateSign(paramsForSign, accessSecret);
+    const sign = this.generateSign(params, accessSecret);
     const form = new import_form_data7.default();
-    for (const [key, value] of Object.entries(paramsForSign)) {
-      form.append(key, value);
-    }
+    Object.entries(params).forEach(([k, v]) => form.append(k, v));
     form.append("sign", sign);
-    form.append("file", import_fs_extra11.default.createReadStream(filePath), {
-      filename: import_path8.default.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 import_axios8.default.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;
+    form.append("file", import_fs_extra11.default.createReadStream(filePath), { filename: import_path10.default.basename(filePath) });
+    const res = await import_axios8.default.post(_VivoUploader.API_BASE, form, { headers: form.getHeaders(), timeout: 3e5 });
+    if (res.data.code !== 0) throw new Error(`\u4E0A\u4F20\u5305\u5931\u8D25: ${res.data.msg}`);
+    return res.data.data?.serialnumber || res.data.data;
   }
-  /**
-   * 提交版本更新信息
-   */
-  async submitVersion(accessKey, accessSecret, params) {
+  async submitVersion(accessKey, accessSecret, data) {
     const timestamp = String(Date.now());
     const reqParams = {
       access_key: accessKey,
@@ -3892,53 +4644,34 @@ var VivoUploader = class _VivoUploader {
       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,
-      // 文档必填
+      packageName: data.packageName || "",
+      versionCode: String(data.versionCode),
+      apk: data.serialnumber || "",
+      fileMd5: data.fileMd5 || "",
       onlineType: "1",
-      // 1:立即上架 2:定时上架 (必填)
       compatibleDevice: "1",
-      // 1:手机 2:手机和平板 3:平板 (必填)
-      updateDesc: params.updateDesc
+      updateDesc: data.updateDesc
     };
+    if (data.apk32) {
+      reqParams.apk32 = data.apk32;
+      if (data.md532) reqParams.md532 = data.md532;
+    }
     reqParams.sign = this.generateSign(reqParams, accessSecret);
     const formData = new URLSearchParams();
-    for (const [key, value] of Object.entries(reqParams)) {
-      formData.append(key, value);
-    }
+    Object.entries(reqParams).forEach(([k, v]) => formData.append(k, v));
     const res = await import_axios8.default.post(_VivoUploader.API_BASE, formData.toString(), {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      },
+      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;
+    if (res.data.code !== 0) throw new Error(`\u63D0\u4EA4\u5931\u8D25: ${res.data.msg}`);
   }
 };
 
 // src/adapters/tencent_uploader.ts
 var import_fs_extra12 = __toESM(require("fs-extra"), 1);
-var import_path9 = __toESM(require("path"), 1);
+var import_path11 = __toESM(require("path"), 1);
 var import_axios9 = __toESM(require("axios"), 1);
-var import_crypto6 = __toESM(require("crypto"), 1);
+var import_crypto7 = __toESM(require("crypto"), 1);
 var TencentUploader = class _TencentUploader {
   name = "Tencent";
   /** 腾讯开放平台 API 基础地址 */
@@ -3951,7 +4684,7 @@ var TencentUploader = class _TencentUploader {
   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 import_crypto6.default.createHmac("sha256", accessSecret).update(signStr).digest("hex").toLowerCase();
+    return import_crypto7.default.createHmac("sha256", accessSecret).update(signStr).digest("hex").toLowerCase();
   }
   validateConfig(config) {
     if (!config?.publish?.tencent?.enable) return false;
@@ -3968,54 +4701,71 @@ var TencentUploader = class _TencentUploader {
   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 (!import_fs_extra12.default.existsSync(filePath)) {
-      return { platform: "tencent", success: false, message: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}`, consoleUrl };
-    }
+    const pkgName = tencentConfig.packageName || "";
+    const artifacts = typeof metadata.artifactPath === "object" ? metadata.artifactPath : { universal: filePath || (typeof metadata.artifactPath === "string" ? metadata.artifactPath : "") };
     try {
-      const stats = import_fs_extra12.default.statSync(filePath);
-      const fileName = import_path9.default.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, {
+      const uploadResults = {};
+      const uploadPromises = Object.entries(artifacts).map(async ([abi, p]) => {
+        if (!p || !import_fs_extra12.default.existsSync(p)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${p}`);
+        const stats = import_fs_extra12.default.statSync(p);
+        const fileName = import_path11.default.basename(p);
+        logger.info(`[Tencent] \u6B63\u5728\u5904\u7406 ${abi} \u67B6\u6784\u5305: ${fileName}`);
+        const uploadInfo = await this.getFileUploadInfo(auth, stats.size, fileName, pkgName);
+        await this.uploadToCos(uploadInfo.pre_sign_url, p, stats.size);
+        const pkgInfo = await parsePackageInfo(p, {
+          androidSdkPath: config.globalSettings?.androidSdkPath
+        });
+        const nativeCodes = pkgInfo?.nativeCode || [];
+        const has64Bit = nativeCodes.includes("arm64-v8a") || nativeCodes.includes("x86_64") || abi === "arm64-v8a";
+        const has32Bit = nativeCodes.includes("armeabi-v7a") || nativeCodes.includes("armeabi") || nativeCodes.includes("x86") || abi === "armeabi-v7a";
+        uploadResults[abi] = {
+          serial_number: uploadInfo.serial_number,
+          is64Bit: has64Bit && !has32Bit,
+          md5: pkgInfo?.md5 || ""
+        };
+      });
+      await Promise.all(uploadPromises);
+      logger.info("[Tencent] \u6B63\u5728\u83B7\u53D6\u7EBF\u4E0A\u5E94\u7528\u8BE6\u60C5...");
+      const anyPkgPath = Object.values(artifacts)[0];
+      const samplePkgInfo = await parsePackageInfo(anyPkgPath, {
         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 }
+        pkgName || samplePkgInfo?.packageName || ""
       );
-      logger.info(`\u63D0\u4EA4\u6D41\u6C34\u53F7\u5B8C\u6210\u5BA1\u6838\u7533\u62A5\u7ED3\u679C: ${JSON.stringify(submitResult)}`);
+      const submitData = {
+        ...onlineDetail,
+        pkg_name: pkgName || samplePkgInfo?.packageName || onlineDetail.pkg_name || "",
+        update_desc: metadata.changelog || "\u7248\u672C\u66F4\u65B0"
+      };
+      const arm64Result = uploadResults["arm64-v8a"] || Object.values(uploadResults).find((r) => r.is64Bit);
+      const arm32Result = uploadResults["armeabi-v7a"] || Object.values(uploadResults).find((r) => !r.is64Bit);
+      if (arm64Result) {
+        submitData.apk64_serial_number = arm64Result.serial_number;
+        submitData.apk64_md5 = arm64Result.md5;
+      }
+      if (arm32Result) {
+        submitData.apk32_serial_number = arm32Result.serial_number;
+        submitData.apk32_md5 = arm32Result.md5;
+      }
+      if (Object.keys(uploadResults).length === 1 && !submitData.apk64_serial_number && !submitData.apk32_serial_number) {
+        const single = Object.values(uploadResults)[0];
+        if (single.is64Bit) {
+          submitData.apk64_serial_number = single.serial_number;
+          submitData.apk64_md5 = single.md5;
+        } else {
+          submitData.apk32_serial_number = single.serial_number;
+          submitData.apk32_md5 = single.md5;
+        }
+      }
+      logger.info("[Tencent] \u6B63\u5728\u63D0\u4EA4\u5BA1\u6838\u7533\u62A5...");
+      await this.submitModifyAppInfo(auth, submitData, { timeout: tencentConfig.timeout || 6e4 });
       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}`);
+      logger.error(`\u817E\u8BAF\u4E0A\u4F20\u5931\u8D25: ${error.message}`);
       return { platform: "tencent", success: false, message: error.message, error, consoleUrl };
     }
   }
@@ -4129,16 +4879,22 @@ var TencentUploader = class _TencentUploader {
         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;
+    if (data.apk64_serial_number) {
+      signParams.apk64_file_serial_number = String(data.apk64_serial_number);
+      if (data.apk64_md5) signParams.apk64_file_md5 = data.apk64_md5;
+    }
+    if (data.apk32_serial_number) {
+      signParams.apk32_file_serial_number = String(data.apk32_serial_number);
+      if (data.apk32_md5) signParams.apk32_file_md5 = data.apk32_md5;
+    }
+    if (!data.apk64_serial_number && !data.apk32_serial_number && data.serial_number) {
+      if (data.is64Bit) {
+        signParams.apk64_file_serial_number = String(data.serial_number || "");
+        if (data.md5) signParams.apk64_file_md5 = data.md5;
+      } else {
+        signParams.apk32_file_serial_number = String(data.serial_number || "");
+        if (data.md5) signParams.apk32_file_md5 = data.md5;
+      }
     }
     const sign = this.generateSign(signParams, accessSecret);
     const formParams = {
@@ -4156,27 +4912,256 @@ var TencentUploader = class _TencentUploader {
     return res.data;
   }
 };
+
+// src/adapters/google_play_uploader.ts
+var import_fs_extra13 = __toESM(require("fs-extra"), 1);
+var import_path12 = __toESM(require("path"), 1);
+var import_axios10 = __toESM(require("axios"), 1);
+var import_google_auth_library = require("google-auth-library");
+var ANDROID_PUBLISHER_SCOPE = "https://www.googleapis.com/auth/androidpublisher";
+var PUBLISH_API_ROOT = "https://androidpublisher.googleapis.com/androidpublisher/v3";
+var UPLOAD_API_ROOT = "https://androidpublisher.googleapis.com/upload/androidpublisher/v3";
+var GOOGLE_PLAY_CONSOLE_URL = "https://play.google.com/console/developers";
+var GOOGLE_PLAY_INTERNAL_API_TRACK = "internal";
+var UPLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+var GooglePlayUploader = class {
+  name = "Google Play";
+  httpClient;
+  getAccessToken;
+  constructor(dependencies = {}) {
+    this.httpClient = dependencies.httpClient || import_axios10.default;
+    this.getAccessToken = dependencies.getAccessToken || this.createAccessToken.bind(this);
+  }
+  validateConfig(config) {
+    const googleConfig = config?.publish?.google_play;
+    if (!googleConfig?.enable) return false;
+    if (!googleConfig.packageName || typeof googleConfig.packageName !== "string") {
+      logger.error("Google Play \u914D\u7F6E\u7F3A\u5C11 packageName");
+      return false;
+    }
+    const track = googleConfig.track || "internal";
+    if (track !== "internal") {
+      logger.error("Google Play \u9996\u7248\u4EC5\u652F\u6301 internal \u8F68\u9053");
+      return false;
+    }
+    const auth = googleConfig.auth;
+    const hasCredentialContent = typeof auth?.serviceAccountJsonContent === "string" && auth.serviceAccountJsonContent.trim().length > 0;
+    const credentialPath = auth?.serviceAccountJsonPath;
+    const hasCredentialPath = typeof credentialPath === "string" && credentialPath.trim().length > 0 && import_fs_extra13.default.existsSync(import_path12.default.resolve(credentialPath));
+    if (!hasCredentialContent && !hasCredentialPath) {
+      logger.error("Google Play \u914D\u7F6E\u7F3A\u5C11\u6709\u6548\u7684\u670D\u52A1\u8D26\u53F7 JSON \u6587\u4EF6\u6216\u5185\u5BB9");
+      return false;
+    }
+    return true;
+  }
+  canHandle(filePath) {
+    return import_path12.default.extname(filePath).toLowerCase() === ".aab";
+  }
+  async upload(filePath, config, _metadata) {
+    if (!this.validateConfig(config)) {
+      return this.failure("Google Play \u914D\u7F6E\u65E0\u6548\uFF0C\u8BF7\u68C0\u67E5\u5305\u540D\u3001internal \u8F68\u9053\u548C\u670D\u52A1\u8D26\u53F7\u6587\u4EF6");
+    }
+    if (!this.canHandle(filePath)) {
+      return this.failure("Google Play \u4EC5\u63A5\u53D7 Android App Bundle\uFF08.aab\uFF09");
+    }
+    if (!import_fs_extra13.default.existsSync(filePath)) {
+      return this.failure(`\u672A\u627E\u5230\u5F85\u4E0A\u4F20\u7684 AAB\uFF1A${filePath}`);
+    }
+    const googleConfig = config.publish.google_play;
+    const packageName = googleConfig.packageName.trim();
+    const encodedPackageName = encodeURIComponent(packageName);
+    let editId;
+    let accessToken;
+    let committed = false;
+    let stage = "create_edit";
+    logger.info(`\u51C6\u5907\u5C06 ${import_path12.default.basename(filePath)} \u4E0A\u4F20\u5230 Google Play internal \u8349\u7A3F`);
+    try {
+      accessToken = await this.getAccessToken(googleConfig.auth);
+      const requestConfig = {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      };
+      const editResponse = await this.httpClient.post(
+        `${PUBLISH_API_ROOT}/applications/${encodedPackageName}/edits`,
+        {},
+        requestConfig
+      );
+      editId = editResponse.data.id;
+      if (!editId) {
+        throw new Error("Google Play \u672A\u8FD4\u56DE editId");
+      }
+      stage = "upload_bundle";
+      const encodedEditId = encodeURIComponent(editId);
+      const bundleResponse = await this.httpClient.post(
+        `${UPLOAD_API_ROOT}/applications/${encodedPackageName}/edits/${encodedEditId}/bundles?uploadType=media`,
+        import_fs_extra13.default.createReadStream(filePath),
+        {
+          timeout: UPLOAD_TIMEOUT_MS,
+          maxBodyLength: Infinity,
+          maxContentLength: Infinity,
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": "application/octet-stream",
+            "Content-Length": import_fs_extra13.default.statSync(filePath).size
+          }
+        }
+      );
+      const versionCode = bundleResponse.data.versionCode;
+      if (!Number.isInteger(versionCode)) {
+        throw new Error("Google Play \u4E0A\u4F20\u6210\u529F\u4F46\u672A\u8FD4\u56DE\u6709\u6548\u7684 versionCode");
+      }
+      stage = "update_internal_track";
+      await this.httpClient.put(
+        `${PUBLISH_API_ROOT}/applications/${encodedPackageName}/edits/${encodedEditId}/tracks/${GOOGLE_PLAY_INTERNAL_API_TRACK}`,
+        {
+          track: GOOGLE_PLAY_INTERNAL_API_TRACK,
+          releases: [
+            {
+              versionCodes: [String(versionCode)],
+              status: "draft"
+            }
+          ]
+        },
+        requestConfig
+      );
+      stage = "validate_edit";
+      await this.httpClient.post(
+        `${PUBLISH_API_ROOT}/applications/${encodedPackageName}/edits/${encodedEditId}:validate`,
+        {},
+        requestConfig
+      );
+      stage = "commit_edit";
+      await this.httpClient.post(
+        `${PUBLISH_API_ROOT}/applications/${encodedPackageName}/edits/${encodedEditId}:commit`,
+        {},
+        requestConfig
+      );
+      committed = true;
+      logger.success(`Google Play internal \u8349\u7A3F\u5DF2\u521B\u5EFA\uFF08versionCode ${versionCode}\uFF09`);
+      return {
+        platform: "google_play",
+        success: true,
+        message: `AAB \u5DF2\u4E0A\u4F20\u5230 Google Play internal \u8349\u7A3F\uFF08versionCode ${versionCode}\uFF09`,
+        consoleUrl: GOOGLE_PLAY_CONSOLE_URL,
+        data: {
+          editId,
+          versionCode,
+          track: "internal",
+          apiTrack: GOOGLE_PLAY_INTERNAL_API_TRACK,
+          status: "draft",
+          committed: true
+        }
+      };
+    } catch (error) {
+      if (editId && accessToken && !committed) {
+        await this.deleteEditBestEffort(encodedPackageName, editId, accessToken);
+      }
+      const message = this.describeError(error, stage);
+      logger.error(`Google Play \u4E0A\u4F20\u5931\u8D25\uFF1A${message}`);
+      return this.failure(message, error);
+    }
+  }
+  async createAccessToken(authConfig) {
+    let credentials;
+    if (authConfig.serviceAccountJsonContent?.trim()) {
+      try {
+        credentials = JSON.parse(authConfig.serviceAccountJsonContent);
+      } catch {
+        throw new Error("\u670D\u52A1\u8D26\u53F7 JSON \u5185\u5BB9\u683C\u5F0F\u65E0\u6548");
+      }
+    }
+    const keyFile = !credentials && authConfig.serviceAccountJsonPath ? import_path12.default.resolve(authConfig.serviceAccountJsonPath) : void 0;
+    const auth = new import_google_auth_library.GoogleAuth({
+      scopes: [ANDROID_PUBLISHER_SCOPE],
+      keyFile,
+      credentials
+    });
+    const token = await auth.getAccessToken();
+    if (!token) {
+      throw new Error("Google Play \u8BA4\u8BC1\u672A\u8FD4\u56DE\u8BBF\u95EE\u4EE4\u724C");
+    }
+    return token;
+  }
+  async deleteEditBestEffort(encodedPackageName, editId, accessToken) {
+    try {
+      await this.httpClient.delete(
+        `${PUBLISH_API_ROOT}/applications/${encodedPackageName}/edits/${encodeURIComponent(editId)}`,
+        { headers: { Authorization: `Bearer ${accessToken}` } }
+      );
+    } catch {
+      logger.warn("Google Play \u672A\u63D0\u4EA4 edit \u7684\u81EA\u52A8\u6E05\u7406\u5931\u8D25\uFF0C\u8BF7\u5728 Play Console \u4E2D\u68C0\u67E5\u8349\u7A3F\u72B6\u6001");
+    }
+  }
+  describeError(error, stage) {
+    const status = error?.response?.status;
+    const rawMessage = error?.response?.data?.error?.message || error?.response?.data?.message || error?.message || "\u672A\u77E5\u9519\u8BEF";
+    const safeMessage = this.redactAndTruncate(String(rawMessage));
+    if (/version\s*code|versionCode/i.test(safeMessage)) {
+      return `Google Play \u62D2\u7EDD\u8BE5 versionCode\uFF0C\u8BF7\u63D0\u9AD8 Flutter \u6784\u5EFA\u53F7\u540E\u91CD\u65B0\u751F\u6210 AAB\uFF1A${safeMessage}`;
+    }
+    if (status === 401) {
+      return "Google Play \u8BA4\u8BC1\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u8D26\u53F7 JSON \u662F\u5426\u6709\u6548";
+    }
+    if (status === 403) {
+      return "Google Play \u62D2\u7EDD\u8BBF\u95EE\uFF0C\u8BF7\u786E\u8BA4\u670D\u52A1\u8D26\u53F7\u5DF2\u52A0\u5165 Play Console \u5E76\u5177\u6709\u5185\u90E8\u6D4B\u8BD5\u7248\u672C\u4E0A\u4F20\u6743\u9650";
+    }
+    if (status === 404) {
+      if (stage === "update_internal_track") {
+        return "Google Play \u4E2D\u672A\u627E\u5230 internal \u5185\u90E8\u6D4B\u8BD5\u8F68\u9053\uFF0C\u8BF7\u786E\u8BA4\u5E94\u7528\u5DF2\u5728 Play Console \u521B\u5EFA\u5185\u90E8\u6D4B\u8BD5\u8F68\u9053";
+      }
+      if (stage !== "create_edit") {
+        return `Google Play API \u5728 ${stage} \u9636\u6BB5\u672A\u627E\u5230\u76EE\u6807\u8D44\u6E90\uFF1A${safeMessage}`;
+      }
+      return "Google Play \u4E2D\u672A\u627E\u5230\u53EF\u4F9B API \u7F16\u8F91\u7684\u5E94\u7528\u3002\u8BF7\u786E\u8BA4 packageName \u5B8C\u5168\u4E00\u81F4\uFF1B\u82E5\u8FD9\u662F\u9996\u6B21\u4E0A\u4F20\uFF0C\u8BF7\u5148\u5728 Play Console \u624B\u5DE5\u4E0A\u4F20\u5E76\u4FDD\u5B58\u4E00\u4E2A APK/AAB\uFF0C\u518D\u91CD\u8BD5 API \u4E0A\u4F20";
+    }
+    if (error?.code === "ECONNABORTED" || /timeout/i.test(safeMessage)) {
+      return "Google Play \u4E0A\u4F20\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8BD5\uFF1B\u672C\u5730 AAB \u672A\u88AB\u5220\u9664";
+    }
+    return `Google Play API \u8BF7\u6C42\u5931\u8D25${status ? `\uFF08HTTP ${status}\uFF09` : ""}\uFF1A${safeMessage}`;
+  }
+  redactAndTruncate(message) {
+    return message.replace(/-----BEGIN PRIVATE KEY-----[\s\S]*?-----END PRIVATE KEY-----/gi, "[\u5DF2\u8131\u654F\u79C1\u94A5]").replace(/Bearer\s+[^\s"']+/gi, "Bearer [\u5DF2\u8131\u654F]").replace(/"private_key"\s*:\s*"[^"]*"/gi, '"private_key":"[\u5DF2\u8131\u654F]"').replace(/"access_token"\s*:\s*"[^"]*"/gi, '"access_token":"[\u5DF2\u8131\u654F]"').slice(0, 500);
+  }
+  failure(message, error) {
+    return {
+      platform: "google_play",
+      success: false,
+      message,
+      // 原始 Axios 错误可能包含 Authorization 请求头，只返回脱敏后的 Error。
+      error: error ? new Error(message) : void 0
+    };
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdHocUploader,
   AppleJWTGenerator,
   AppleStoreUploader,
   ConfigValidator,
+  DEFAULT_RELEASE_RECEIPT_LIMIT,
   DEFAULT_RETRY_CONFIG,
   EnvValidator,
   ErrorCategory,
+  GooglePlayUploader,
   HarmonyUploader,
   HuaweiUploader,
   OppoUploader,
   PgyerUploader,
+  RELEASE_RECEIPT_SCHEMA_VERSION,
+  ReleaseReceiptStore,
   RetryStrategy,
   TencentUploader,
   TestFlightUploader,
   UploadManager,
   VivoUploader,
   XiaomiUploader,
+  createProjectKey,
+  createReleaseReceipt,
   createUploadManager,
   createUploadRetryStrategy,
-  parsePackageInfo
+  createUploadTargets,
+  formatReleaseReceipt,
+  parsePackageInfo,
+  resolveReleaseProjectRoot,
+  sanitizeReleaseMessage
 });
 //# sourceMappingURL=index.cjs.map