@huoye/app-ship 0.1.2 → 0.2.1

package/dist/cli.js

@@ -7,7 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/utils/upload-manager.ts
-import path10 from "path";
+import path12 from "path";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -965,6 +965,280 @@ async function parseHap(filePath) {
   return info;
 }
 
+// src/utils/release-receipt.ts
+import { createHash, randomUUID } from "crypto";
+import { createReadStream } from "fs";
+import { chmod, mkdir, readFile, realpath, rename, stat, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path2 from "path";
+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 path2.resolve(projectRoot || path2.dirname(path2.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: 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 = path2.resolve(options.storageRoot || path2.join(homedir(), ".flu-cli", "release-receipts"));
+    this.maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_RELEASE_RECEIPT_LIMIT);
+  }
+  async append(receipt) {
+    await mkdir(this.storageRoot, { recursive: true, mode: 448 });
+    await 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}.${randomUUID()}.tmp`;
+    await writeFile(
+      tempPath,
+      `${JSON.stringify({
+        schemaVersion: RELEASE_RECEIPT_SCHEMA_VERSION,
+        projectKey: receipt.projectKey,
+        receipts
+      }, null, 2)}
+`,
+      { encoding: "utf8", mode: 384 }
+    );
+    await rename(tempPath, filePath);
+    await 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 path2.join(this.storageRoot, `${projectKey}.json`);
+  }
+  async readFile(filePath, projectKey) {
+    try {
+      const raw = JSON.parse(await 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 createHash("sha256").update(path2.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) => path2.resolve(item))));
+  return Promise.all(paths.map(inspectArtifact));
+}
+async function inspectArtifact(filePath) {
+  const base = { path: filePath, name: path2.basename(filePath) };
+  try {
+    const info = await 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 = createHash("sha256");
+    const stream = 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 = path2.resolve(projectRoot);
+  try {
+    return await 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";
@@ -1083,7 +1357,7 @@ var PgyerUploader = class _PgyerUploader {
 
 // src/adapters/huawei_uploader.ts
 import fs4 from "fs-extra";
-import path2 from "path";
+import path3 from "path";
 import { promisify } from "util";
 import axios2 from "axios";
 import FormData2 from "form-data";
@@ -1162,7 +1436,7 @@ var HuaweiUploader = class _HuaweiUploader {
     const clientSecret = hwConfig.auth.clientSecret;
     const appId = hwConfig.appId;
     const releaseType = hwConfig.releaseType || "draft";
-    const suffix = path2.extname(filePath).substring(1);
+    const suffix = path3.extname(filePath).substring(1);
     const retryConfig = config.retry;
     const tokenUrl = this.getTokenUrl(config);
     const publishApiRoot = this.getApiRoot(config);
@@ -1188,8 +1462,8 @@ var HuaweiUploader = class _HuaweiUploader {
       const uploadResults = [];
       const uploadPromises = Object.entries(artifacts).map(async ([abi, p]) => {
         if (!p || !fs4.existsSync(p)) return;
-        const currentSuffix = path2.extname(p).substring(1);
-        logger.info(`[Huawei] \u6B63\u5728\u4E0A\u4F20 ${abi} \u5305: ${path2.basename(p)}`);
+        const currentSuffix = path3.extname(p).substring(1);
+        logger.info(`[Huawei] \u6B63\u5728\u4E0A\u4F20 ${abi} \u5305: ${path3.basename(p)}`);
         const uploadInfo = await retryStrategy.execute(
           () => this.getUploadUrl(ctx, currentSuffix),
           `Huawei get upload URL for ${abi}`
@@ -1205,7 +1479,7 @@ var HuaweiUploader = class _HuaweiUploader {
           throw uploadFileRes.error || new Error(`File upload failed for ${abi}`);
         }
         uploadResults.push({
-          fileName: path2.basename(p),
+          fileName: path3.basename(p),
           fileDestUrl: uploadFileRes.data[0].fileDestUrl
         });
       });
@@ -1377,7 +1651,7 @@ var HuaweiUploader = class _HuaweiUploader {
   }
   /** 通用文件上传（FormData 方式，无需 API 认证头） */
   async executeUploadRequest(uploadUrl, authCode, filePath) {
-    const fileName = path2.basename(filePath);
+    const fileName = path3.basename(filePath);
     const fileSize = fs4.statSync(filePath).size;
     const form = new FormData2();
     form.append("file", fs4.createReadStream(filePath), {
@@ -1544,7 +1818,7 @@ var HuaweiUploader = class _HuaweiUploader {
         logger.warn(`Asset file not found, skipping: ${filePath}`);
         continue;
       }
-      const suffix = path2.extname(filePath).substring(1).toLowerCase();
+      const suffix = path3.extname(filePath).substring(1).toLowerCase();
       if (!HUAWEI_SUPPORTED_SUFFIXES.image.includes(suffix)) {
         logger.warn(`Unsupported file type ${suffix}, skipping: ${filePath}`);
         continue;
@@ -1599,7 +1873,7 @@ var HuaweiUploader = class _HuaweiUploader {
 
 // src/adapters/xiaomi_uploader.ts
 import fs5 from "fs-extra";
-import path3 from "path";
+import path4 from "path";
 import axios3 from "axios";
 import FormData3 from "form-data";
 import crypto3 from "crypto";
@@ -1927,14 +2201,14 @@ ${lines.join("\n")}
     if (arm64 && arm32) {
       mainPath = arm64[1];
       secondPath = arm32[1];
-      logger.info(`[Xiaomi] \u8BC6\u522B\u5230\u591A\u67B6\u6784\u5206\u5305: \u4E3B\u5305(64\u4F4D)=${path3.basename(mainPath)}, \u6B21\u5305(32\u4F4D)=${path3.basename(secondPath)}`);
+      logger.info(`[Xiaomi] \u8BC6\u522B\u5230\u591A\u67B6\u6784\u5206\u5305: \u4E3B\u5305(64\u4F4D)=${path4.basename(mainPath)}, \u6B21\u5305(32\u4F4D)=${path4.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=${path3.basename(mainPath)}, \u6B21\u5305=${path3.basename(secondPath)}`);
+        logger.info(`[Xiaomi] \u8BC6\u522B\u5230\u591A\u4E2A\u5305\uFF08\u975E\u6807\u51C6\u540D\uFF09\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u987A\u5E8F: \u4E3B\u5305=${path4.basename(mainPath)}, \u6B21\u5305=${path4.basename(secondPath)}`);
       } else {
-        logger.info(`[Xiaomi] \u4F7F\u7528\u5355\u5305\u6A21\u5F0F: ${path3.basename(mainPath)}`);
+        logger.info(`[Xiaomi] \u4F7F\u7528\u5355\u5305\u6A21\u5F0F: ${path4.basename(mainPath)}`);
       }
     }
     const mainMD5 = await this.calculateFileMD5(mainPath);
@@ -2008,7 +2282,7 @@ ${lines.join("\n")}
 
 // src/adapters/apple_store_uploader.ts
 import fs6 from "fs-extra";
-import path4 from "path";
+import path5 from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 import axios4 from "axios";
@@ -2174,7 +2448,7 @@ var AppleStoreUploader = class {
       appPassword,
       "-showTransferRate"
     ].join(" ");
-    logger.info(`[Transporter] Uploading: ${path4.basename(ipaPath)}`);
+    logger.info(`[Transporter] Uploading: ${path5.basename(ipaPath)}`);
     try {
       const { stdout, stderr } = await execAsync(command, {
         timeout: 30 * 60 * 1e3,
@@ -2225,7 +2499,7 @@ Stderr: ${error.stderr || ""}`);
       });
       command = innerArgs.join(" ");
     }
-    logger.info(`[altool] Uploading: ${path4.basename(ipaPath)}`);
+    logger.info(`[altool] Uploading: ${path5.basename(ipaPath)}`);
     logger.info(`[altool] Command prefix: ${tool.command}`);
     try {
       const { stdout, stderr } = await execAsync(command, {
@@ -2809,7 +3083,7 @@ var TestFlightUploader = class _TestFlightUploader {
 
 // src/adapters/adhoc_uploader.ts
 import fs8 from "fs-extra";
-import path5 from "path";
+import path6 from "path";
 import { execSync } from "child_process";
 var AdHocUploader = class {
   name = "AdHoc";
@@ -2942,8 +3216,8 @@ var AdHocUploader = class {
    * @param changelog 更新日志
    */
   async createManifest(ipaPath, version, bundleId, changelog) {
-    const ipaFileName = path5.basename(ipaPath);
-    const appName = bundleId || path5.parse(ipaFileName).name;
+    const ipaFileName = path6.basename(ipaPath);
+    const appName = bundleId || path6.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">
@@ -3002,14 +3276,14 @@ var AdHocUploader = class {
    */
   async setupDistributionDirectory(ipaPath, manifestPath) {
     const projectRoot = process.cwd();
-    const distributionDir = path5.join(projectRoot, "build", "adhoc-distribution");
+    const distributionDir = path6.join(projectRoot, "build", "adhoc-distribution");
     await fs8.ensureDir(distributionDir);
-    await fs8.ensureDir(path5.join(distributionDir, "apps"));
-    await fs8.ensureDir(path5.join(distributionDir, "manifests"));
-    await fs8.ensureDir(path5.join(distributionDir, "icons"));
-    const ipaFileName = path5.basename(ipaPath);
-    await fs8.copy(ipaPath, path5.join(distributionDir, "apps", ipaFileName));
-    await fs8.copy(manifestPath, path5.join(distributionDir, "manifests", `${ipaFileName}.plist`));
+    await fs8.ensureDir(path6.join(distributionDir, "apps"));
+    await fs8.ensureDir(path6.join(distributionDir, "manifests"));
+    await fs8.ensureDir(path6.join(distributionDir, "icons"));
+    const ipaFileName = path6.basename(ipaPath);
+    await fs8.copy(ipaPath, path6.join(distributionDir, "apps", ipaFileName));
+    await fs8.copy(manifestPath, path6.join(distributionDir, "manifests", `${ipaFileName}.plist`));
     logger.info(`Distribution directory: ${distributionDir}`);
     return distributionDir;
   }
@@ -3019,7 +3293,7 @@ var AdHocUploader = class {
    * @param bundleId Bundle ID
    */
   generateInstallUrl(distributionPath, bundleId) {
-    const manifestPath = path5.join(distributionPath, "manifests", `*.plist`);
+    const manifestPath = path6.join(distributionPath, "manifests", `*.plist`);
     return `itms-services://?action=download-manifest&url=file://${manifestPath}`;
   }
   /**
@@ -3028,7 +3302,7 @@ var AdHocUploader = class {
    * @param distributionPath 分发目录
    */
   async generateQRCode(url, distributionPath) {
-    const qrCodePath = path5.join(distributionPath, "install-qrcode.png");
+    const qrCodePath = path6.join(distributionPath, "install-qrcode.png");
     try {
       logger.info(`QR code would be saved to: ${qrCodePath}`);
       logger.info(`Install URL: ${url}`);
@@ -3055,8 +3329,8 @@ var AdHocUploader = class {
     logger.newLine();
     logger.info("\u{1F4E6} Distribution Files:");
     logger.info(`  Directory: ${distributionPath}`);
-    logger.info(`  IPA: ${path5.join(distributionPath, "apps", "*.ipa")}`);
-    logger.info(`  Manifest: ${path5.join(distributionPath, "manifests", "*.plist")}`);
+    logger.info(`  IPA: ${path6.join(distributionPath, "apps", "*.ipa")}`);
+    logger.info(`  Manifest: ${path6.join(distributionPath, "manifests", "*.plist")}`);
     logger.info(`  QR Code: ${qrCodePath}`);
     logger.newLine();
     logger.info("\u{1F517} Installation Link:");
@@ -3115,7 +3389,7 @@ var AdHocUploader = class {
 
 // src/adapters/harmony_uploader.ts
 import fs9 from "fs-extra";
-import path6 from "path";
+import path7 from "path";
 import axios6 from "axios";
 import FormData5 from "form-data";
 var HarmonyUploader = class _HarmonyUploader {
@@ -3145,7 +3419,7 @@ var HarmonyUploader = class _HarmonyUploader {
     const clientSecret = harmonyConfig.auth.clientSecret;
     const appId = harmonyConfig.appId;
     const releaseType = harmonyConfig.releaseType || "draft";
-    const suffix = path6.extname(filePath).substring(1);
+    const suffix = path7.extname(filePath).substring(1);
     const retryConfig = config.retry;
     logger.info("Starting HarmonyOS AppGallery upload...");
     try {
@@ -3262,7 +3536,7 @@ var HarmonyUploader = class _HarmonyUploader {
    * @param filePath 文件路径
    */
   async updateAppFileInfo(token, appId, authCode, filePath) {
-    const fileName = path6.basename(filePath);
+    const fileName = path7.basename(filePath);
     const body = {
       fileType: 7,
       // 鸿蒙包的 fileType（需要根据华为最新文档确认）
@@ -3285,7 +3559,7 @@ var HarmonyUploader = class _HarmonyUploader {
 
 // src/adapters/oppo_uploader.ts
 import fs10 from "fs-extra";
-import path7 from "path";
+import path8 from "path";
 import axios7 from "axios";
 import FormData6 from "form-data";
 import crypto4 from "crypto";
@@ -3326,7 +3600,7 @@ var OppoUploader = class _OppoUploader {
    * 尝试从文件名推断包名
    */
   inferPackageName(filePath) {
-    const fileName = path7.basename(filePath);
+    const fileName = path8.basename(filePath);
     const match = fileName.match(/^([\w.]+?)(?:-(?:release|debug|unsigned))?\.apk$/i);
     if (match && match[1].includes(".")) {
       return match[1];
@@ -3607,7 +3881,7 @@ var OppoUploader = class _OppoUploader {
 
 // src/adapters/vivo_uploader.ts
 import fs11 from "fs-extra";
-import path8 from "path";
+import path9 from "path";
 import axios8 from "axios";
 import FormData7 from "form-data";
 import crypto5 from "crypto";
@@ -3639,7 +3913,7 @@ var VivoUploader = class _VivoUploader {
       const uploadPromises = Object.entries(artifacts).map(async ([abi, p]) => {
         if (!p || !fs11.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: ${path8.basename(p)}`);
+        logger.info(`[vivo] \u6B63\u5728\u5904\u7406 ${abi} \u67B6\u6784\u5305: ${path9.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 || [];
@@ -3703,7 +3977,7 @@ var VivoUploader = class _VivoUploader {
     const form = new FormData7();
     Object.entries(params).forEach(([k, v]) => form.append(k, v));
     form.append("sign", sign);
-    form.append("file", fs11.createReadStream(filePath), { filename: path8.basename(filePath) });
+    form.append("file", fs11.createReadStream(filePath), { filename: path9.basename(filePath) });
     const res = await axios8.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;
@@ -3743,7 +4017,7 @@ var VivoUploader = class _VivoUploader {
 
 // src/adapters/tencent_uploader.ts
 import fs12 from "fs-extra";
-import path9 from "path";
+import path10 from "path";
 import axios9 from "axios";
 import crypto6 from "crypto";
 var TencentUploader = class _TencentUploader {
@@ -3783,7 +4057,7 @@ var TencentUploader = class _TencentUploader {
       const uploadPromises = Object.entries(artifacts).map(async ([abi, p]) => {
         if (!p || !fs12.existsSync(p)) throw new Error(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${p}`);
         const stats = fs12.statSync(p);
-        const fileName = path9.basename(p);
+        const fileName = path10.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);
@@ -3987,6 +4261,225 @@ var TencentUploader = class _TencentUploader {
   }
 };
 
+// src/adapters/google_play_uploader.ts
+import fs13 from "fs-extra";
+import path11 from "path";
+import axios10 from "axios";
+import { GoogleAuth } from "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 || axios10;
+    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 && fs13.existsSync(path11.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 path11.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 (!fs13.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 ${path11.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`,
+        fs13.createReadStream(filePath),
+        {
+          timeout: UPLOAD_TIMEOUT_MS,
+          maxBodyLength: Infinity,
+          maxContentLength: Infinity,
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": "application/octet-stream",
+            "Content-Length": fs13.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 ? path11.resolve(authConfig.serviceAccountJsonPath) : void 0;
+    const auth = new 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
+    };
+  }
+};
+
 // src/utils/upload-manager.ts
 var GROUPED_ARTIFACT_PLATFORMS = /* @__PURE__ */ new Set(["huawei", "xiaomi", "oppo", "vivo", "tencent"]);
 var UploadManager = class {
@@ -4010,6 +4503,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());
   }
   /**
    * 注册上传器
@@ -4028,6 +4522,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);
@@ -4128,7 +4624,7 @@ 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: ${path10.basename(task.file)}`);
+      logger.info(`[${task.platform}] Matched file: ${path12.basename(task.file)}`);
       return this.uploadToPlatform(
         task.platform,
         task.file,
@@ -4171,7 +4667,7 @@ var UploadManager = class {
         artifactPath: artifactSelection
       };
       await this.validateArtifactSelection(platform, artifactSelection, effectiveMetadata);
-      const pkgInfo = await parsePackageInfo(filePath, {
+      const pkgInfo = path12.extname(filePath).toLowerCase() === ".aab" ? null : await parsePackageInfo(filePath, {
         androidSdkPath: effectiveMetadata.globalSettings?.androidSdkPath
       });
       if (pkgInfo) {
@@ -4233,7 +4729,7 @@ var UploadManager = class {
     );
   }
   inferArtifactKey(filePath, index) {
-    const fileName = path10.basename(filePath).toLowerCase();
+    const fileName = path12.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";
@@ -4390,7 +4886,7 @@ var UploadManager = class {
 };
 
 // src/validators/config_validator.ts
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 import yaml from "js-yaml";
 
 // src/validators/env_validator.ts
@@ -4416,20 +4912,22 @@ var ConfigValidator = class {
    * @param filePath 配置文件路径
    */
   static loadAndValidate(filePath) {
-    if (!fs13.existsSync(filePath)) {
+    if (!fs14.existsSync(filePath)) {
       logger.error(`Config file not found: ${filePath}`);
       return null;
     }
-    let content = fs13.readFileSync(filePath, "utf8");
-    const envRegex = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
-    const matches = [...content.matchAll(envRegex)];
-    const requiredEnvs = Array.from(new Set(matches.map((m) => m[1])));
-    if (!EnvValidator.validate(requiredEnvs)) {
-      return null;
-    }
-    content = content.replace(envRegex, (_, varName) => process.env[varName] || "");
     try {
-      const config = yaml.load(content);
+      const content = fs14.readFileSync(filePath, "utf8");
+      const rawConfig = yaml.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;
       }
@@ -4439,15 +4937,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;
       }
     }
@@ -4493,23 +5047,38 @@ 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;
   }
 };
 
 // src/cli.ts
-import path11 from "path";
-import fs14 from "fs-extra";
+import path13 from "path";
+import fs15 from "fs-extra";
 import yaml2 from "js-yaml";
-var VERSION = "0.1.0";
+var VERSION = "0.2.1";
 function printHelp() {
   console.log(`
 app-ship v${VERSION} \u2014 Multi-platform app store uploader
 
 Usage:
-  app-ship upload   -c <config> -f <file> [--platform pgyer,huawei]
+  app-ship upload   -c <config> -f <file> [--platform pgyer,huawei] [--project <dir>]
   app-ship platforms                  List supported platforms
   app-ship init                       Generate sample config file
+  app-ship history [--project <dir>] [--json]
   app-ship --help                     Show this help
   app-ship --version                  Show version
 
@@ -4520,7 +5089,13 @@ Upload Options:
   -v, --version <ver>     Version string (default: from config or "1.0.0")
   -b, --build-number <n>  Build number (default: "1")
   --changelog <text>      Changelog / release notes
+  --project <dir>         Project directory recorded in the release receipt
+  --confirm-google-play   Confirm upload to Google Play internal draft
   --verbose               Show detailed output
+
+History Options:
+  --project <dir>         Project directory (default: current directory)
+  --json                  Print structured receipts as JSON
 `);
 }
 function parseArgs(argv) {
@@ -4534,6 +5109,12 @@ function parseArgs(argv) {
       args.showVersion = true;
     } else if (arg === "--verbose") {
       args.verbose = true;
+    } else if (arg === "--confirm-google-play") {
+      args.confirmGooglePlay = true;
+    } else if (arg === "--json") {
+      args.json = true;
+    } else if (arg === "--project" && argv[i + 1]) {
+      args.project = argv[++i];
     } else if ((arg === "-c" || arg === "--config") && argv[i + 1]) {
       args.config = argv[++i];
     } else if ((arg === "-f" || arg === "--file") && argv[i + 1]) {
@@ -4564,9 +5145,9 @@ async function cmdUpload(args) {
     logger.error("Missing file path. Use: app-ship upload -c <config.yaml> -f <file>");
     process.exit(1);
   }
-  const absConfig = path11.resolve(configPath);
-  const absFile = path11.resolve(filePath);
-  if (!fs14.existsSync(absFile)) {
+  const absConfig = path13.resolve(configPath);
+  const absFile = path13.resolve(filePath);
+  if (!fs15.existsSync(absFile)) {
     logger.error(`File not found: ${absFile}`);
     process.exit(1);
   }
@@ -4575,27 +5156,92 @@ async function cmdUpload(args) {
     logger.error("Config validation failed");
     process.exit(1);
   }
-  const platforms = args.platform ? args.platform.split(",").map((s) => s.trim()) : void 0;
+  const platforms = args.platform ? Array.from(
+    new Set(
+      args.platform.split(",").map((platform) => platform.trim()).filter(Boolean)
+    )
+  ) : void 0;
+  const manager = new UploadManager({
+    maxConcurrent: 3,
+    continueOnError: true,
+    verbose: !!args.verbose
+  });
+  const effectivePlatforms = platforms || manager.getEnabledPlatforms(config);
+  if (effectivePlatforms.length === 0) {
+    logger.error("No upload platform is enabled. Enable one in config or pass --platform.");
+    process.exit(1);
+  }
   const metadata = {
     version: args.ver || config.version || "1.0.0",
     buildNumber: args.buildNumber || "1",
-    changelog: args.changelog || ""
+    changelog: args.changelog || "",
+    platform: effectivePlatforms
   };
   logger.title("App Ship \u2014 Starting Upload");
   logger.info(`File: ${absFile}`);
   logger.info(`Config: ${absConfig}`);
-  if (platforms) {
-    logger.info(`Platforms: ${platforms.join(", ")}`);
+  logger.info(`Platforms: ${effectivePlatforms.join(", ") || "none"}`);
+  if (effectivePlatforms.includes("google_play")) {
+    if (path13.extname(absFile).toLowerCase() !== ".aab") {
+      logger.error("Google Play only accepts Android App Bundle (.aab) files");
+      process.exit(1);
+    }
+    logger.info(`Google Play package: ${config.publish?.google_play?.packageName || "unknown"}`);
+    logger.info("Google Play target: internal draft");
+    if (!args.confirmGooglePlay) {
+      logger.error(
+        "Google Play upload requires explicit confirmation. Review the preview and rerun with --confirm-google-play"
+      );
+      process.exit(1);
+    }
   }
   logger.newLine();
-  const manager = new UploadManager({
-    maxConcurrent: 3,
-    continueOnError: true,
-    verbose: !!args.verbose
-  });
-  const report = await manager.uploadToMultiplePlatforms(absFile, config, metadata, platforms);
+  const startedAt = Date.now();
+  const report = await manager.uploadToMultiplePlatforms(
+    absFile,
+    config,
+    metadata,
+    effectivePlatforms
+  );
+  try {
+    const receipt = await new ReleaseReceiptStore().save({
+      projectRoot: resolveReleaseProjectRoot(args.project, absConfig),
+      kind: "upload",
+      appName: metadata.appName,
+      packageName: resolvePackageName(config),
+      versionName: metadata.version,
+      buildNumber: metadata.buildNumber,
+      changelog: metadata.changelog,
+      artifactPaths: absFile,
+      targets: createUploadTargets(report.results),
+      startedAt
+    });
+    logger.info(`Receipt: ${receipt.id}`);
+  } catch (error) {
+    logger.warn(`Failed to save release receipt: ${error.message}`);
+  }
   process.exit(report.failureCount > 0 ? 1 : 0);
 }
+async function cmdHistory(args) {
+  const projectRoot = path13.resolve(args.project || process.cwd());
+  const receipts = await new ReleaseReceiptStore().list(projectRoot);
+  if (args.json) {
+    console.log(JSON.stringify(receipts, null, 2));
+    return;
+  }
+  if (receipts.length === 0) {
+    logger.info(`No release receipts found for ${projectRoot}`);
+    return;
+  }
+  logger.title(`Release Receipts \u2014 ${projectRoot}`);
+  receipts.forEach((receipt, index) => {
+    if (index > 0) console.log("");
+    console.log(formatReleaseReceipt(receipt));
+  });
+}
+function resolvePackageName(config) {
+  return config.appId || config.publish?.google_play?.packageName || Object.values(config.publish || {}).find((value) => value?.packageName)?.packageName;
+}
 function cmdPlatforms() {
   const manager = new UploadManager();
   const platforms = manager.getAvailablePlatforms();
@@ -4608,7 +5254,7 @@ Total: ${platforms.length} platforms`);
 }
 function cmdInit() {
   const filename = "app-ship.yaml";
-  if (fs14.existsSync(filename)) {
+  if (fs15.existsSync(filename)) {
     logger.warn(`${filename} already exists. Skipping.`);
     return;
   }
@@ -4616,7 +5262,7 @@ function cmdInit() {
     version: "1.0.0",
     publish: {
       pgyer: {
-        enable: true,
+        enable: false,
         apiKey: "YOUR_PGYER_API_KEY"
       },
       huawei: {
@@ -4652,6 +5298,7 @@ function cmdInit() {
       tencent: {
         enable: false,
         auth: {
+          userId: "",
           appId: "",
           accessSecret: ""
         }
@@ -4670,10 +5317,18 @@ function cmdInit() {
           appleId: "",
           appPassword: ""
         }
+      },
+      google_play: {
+        enable: false,
+        auth: {
+          serviceAccountJsonPath: "./service-account.json"
+        },
+        packageName: "com.example.app",
+        track: "internal"
       }
     }
   };
-  fs14.writeFileSync(filename, yaml2.dump(sample, { indent: 2 }), "utf8");
+  fs15.writeFileSync(filename, yaml2.dump(sample, { indent: 2 }), "utf8");
   logger.success(`Created ${filename}`);
   logger.info("Edit the file to configure your platform credentials.");
 }
@@ -4698,6 +5353,9 @@ async function main() {
     case "init":
       cmdInit();
       break;
+    case "history":
+      await cmdHistory(args);
+      break;
     default:
       printHelp();
       break;