@gpc-cli/core 0.9.20 → 0.9.22

package/dist/index.js

@@ -244,7 +244,7 @@ function buildTestCase(item, commandName, index = 0) {
   const record = item;
   const name = escapeXml(
     String(
-      record["name"] ?? record["title"] ?? record["sku"] ?? record["id"] ?? record["productId"] ?? record["packageName"] ?? record["trackId"] ?? record["region"] ?? record["languageCode"] ?? `item-${index + 1}`
+      record["name"] ?? record["title"] ?? record["sku"] ?? record["id"] ?? record["reviewId"] ?? record["productId"] ?? record["packageName"] ?? record["track"] ?? record["trackId"] ?? record["versionCode"] ?? record["region"] ?? record["languageCode"] ?? `item-${index + 1}`
     )
   );
   const classname = `gpc.${escapeXml(commandName)}`;
@@ -1329,8 +1329,8 @@ var ALL_IMAGE_TYPES = [
   "tvBanner"
 ];
 async function exportImages(client, packageName, dir, options) {
-  const { mkdir: mkdir5, writeFile: writeFile7 } = await import("fs/promises");
-  const { join: join7 } = await import("path");
+  const { mkdir: mkdir6, writeFile: writeFile8 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
   const edit = await client.edits.insert(packageName);
   try {
     let languages;
@@ -1361,12 +1361,12 @@ async function exportImages(client, packageName, dir, options) {
       const batch = tasks.slice(i, i + concurrency);
       const results = await Promise.all(
         batch.map(async (task) => {
-          const dirPath = join7(dir, task.language, task.imageType);
-          await mkdir5(dirPath, { recursive: true });
+          const dirPath = join8(dir, task.language, task.imageType);
+          await mkdir6(dirPath, { recursive: true });
           const response = await fetch(task.url);
           const buffer = Buffer.from(await response.arrayBuffer());
-          const filePath = join7(dirPath, `${task.index}.png`);
-          await writeFile7(filePath, buffer);
+          const filePath = join8(dirPath, `${task.index}.png`);
+          await writeFile8(filePath, buffer);
           return buffer.length;
         })
       );
@@ -1404,6 +1404,7 @@ async function updateAppDetails(client, packageName, details) {
 // src/commands/migrate.ts
 import { readdir as readdir2, readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, access } from "fs/promises";
 import { join as join2 } from "path";
+var COMPLEX_RUBY_RE = /\b(begin|rescue|ensure|if |unless |case |while |until |for )\b/;
 async function fileExists(path) {
   try {
     await access(path);
@@ -1419,7 +1420,8 @@ async function detectFastlane(cwd) {
     hasMetadata: false,
     hasGemfile: false,
     lanes: [],
-    metadataLanguages: []
+    metadataLanguages: [],
+    parseWarnings: []
   };
   const fastlaneDir = join2(cwd, "fastlane");
   const hasFastlaneDir = await fileExists(fastlaneDir);
@@ -1435,13 +1437,20 @@ async function detectFastlane(cwd) {
       const entries = await readdir2(metadataDir, { withFileTypes: true });
       result.metadataLanguages = entries.filter((e) => e.isDirectory()).map((e) => e.name);
     } catch {
+      result.parseWarnings.push("Could not read metadata directory \u2014 check permissions");
     }
   }
   if (result.hasFastfile) {
     try {
       const content = await readFile3(fastfilePath, "utf-8");
       result.lanes = parseFastfile(content);
+      if (COMPLEX_RUBY_RE.test(content)) {
+        result.parseWarnings.push(
+          "Fastfile contains complex Ruby constructs (begin/rescue/if/unless/case). Lane detection may be incomplete \u2014 review MIGRATION.md and adjust manually."
+        );
+      }
     } catch {
+      result.parseWarnings.push("Could not read Fastfile \u2014 check permissions");
     }
   }
   if (result.hasAppfile) {
@@ -1451,6 +1460,7 @@ async function detectFastlane(cwd) {
       result.packageName = parsed.packageName;
       result.jsonKeyPath = parsed.jsonKeyPath;
     } catch {
+      result.parseWarnings.push("Could not read Appfile \u2014 check permissions");
     }
   }
   return result;
@@ -1481,8 +1491,9 @@ function mapLaneToGpc(name, actions, body) {
     const trackMatch = body.match(/track\s*:\s*["'](\w+)["']/);
     const rolloutMatch = body.match(/rollout\s*:\s*["']?([\d.]+)["']?/);
     if (rolloutMatch) {
-      const percentage = Math.round(parseFloat(rolloutMatch[1] ?? "0") * 100);
-      return `gpc releases promote --rollout ${percentage}`;
+      const raw = parseFloat(rolloutMatch[1] ?? "0");
+      const pct = raw > 1 ? Math.round(raw) : Math.round(raw * 100);
+      return `gpc releases upload --rollout ${pct}${trackMatch ? ` --track ${trackMatch[1]}` : ""}`;
     }
     if (trackMatch) {
       return `gpc releases upload --track ${trackMatch[1]}`;
@@ -1512,7 +1523,7 @@ function parseAppfile(content) {
 function generateMigrationPlan(detection) {
   const config = {};
   const checklist = [];
-  const warnings = [];
+  const warnings = [...detection.parseWarnings];
   if (detection.packageName) {
     config["app"] = detection.packageName;
   } else {
@@ -1521,44 +1532,61 @@ function generateMigrationPlan(detection) {
   if (detection.jsonKeyPath) {
     config["auth"] = { serviceAccount: detection.jsonKeyPath };
   } else {
-    checklist.push("Configure authentication: gpc auth setup");
+    checklist.push("Configure authentication: gpc auth login");
   }
   for (const lane of detection.lanes) {
     if (lane.gpcEquivalent) {
-      checklist.push(`Replace Fastlane lane "${lane.name}" with: ${lane.gpcEquivalent}`);
+      checklist.push(
+        `Replace Fastlane lane "${lane.name}" with: ${lane.gpcEquivalent} <your.aab>`
+      );
     }
     if (lane.actions.includes("capture_android_screenshots")) {
       warnings.push(
-        `Lane "${lane.name}" uses capture_android_screenshots which has no GPC equivalent. You will need to continue using Fastlane for screenshot capture or use a separate tool.`
+        `Lane "${lane.name}" uses capture_android_screenshots which has no GPC equivalent. Use a separate screenshot tool or check gpc plugins list for community plugins.`
+      );
+    }
+    if (lane.actions.length === 0 || lane.gpcEquivalent === void 0 && !lane.actions.includes("capture_android_screenshots")) {
+      warnings.push(
+        `Lane "${lane.name}" has no automatic GPC equivalent. Check \`gpc plugins list\` or the plugin SDK docs to build a custom command.`
       );
     }
   }
   if (detection.hasMetadata && detection.metadataLanguages.length > 0) {
+    const langs = detection.metadataLanguages.slice(0, 3).join(", ");
+    const more = detection.metadataLanguages.length > 3 ? ` (+${detection.metadataLanguages.length - 3} more)` : "";
+    checklist.push(
+      `Pull current metadata for ${detection.metadataLanguages.length} language(s) (${langs}${more}): gpc listings pull --dir fastlane/metadata/android`
+    );
     checklist.push(
-      `Migrate metadata for ${detection.metadataLanguages.length} language(s): gpc listings pull --dir metadata`
+      "Review pulled metadata, then push back: gpc listings push --dir fastlane/metadata/android"
     );
-    checklist.push("Review and push metadata: gpc listings push --dir metadata");
   }
   checklist.push("Run gpc doctor to verify your setup");
-  checklist.push("Test with --dry-run before making real changes");
+  checklist.push("Test each command with --dry-run before making real changes");
   if (detection.hasGemfile) {
     checklist.push("Remove Fastlane from your Gemfile once migration is complete");
   }
-  if (detection.lanes.some((l) => l.actions.includes("supply") || l.actions.includes("upload_to_play_store"))) {
-    checklist.push("Update CI/CD pipelines to use gpc commands instead of Fastlane lanes");
+  if (detection.lanes.some(
+    (l) => l.actions.includes("supply") || l.actions.includes("upload_to_play_store")
+  )) {
+    checklist.push("Update CI/CD pipelines to call gpc commands instead of Fastlane lanes");
   }
   return { config, checklist, warnings };
 }
 async function writeMigrationOutput(result, dir) {
   await mkdir2(dir, { recursive: true });
   const files = [];
-  const configPath = join2(dir, ".gpcrc.json");
-  await writeFile2(configPath, JSON.stringify(result.config, null, 2) + "\n", "utf-8");
-  files.push(configPath);
+  if (Object.keys(result.config).length > 0) {
+    const configPath = join2(dir, ".gpcrc.json");
+    await writeFile2(configPath, JSON.stringify(result.config, null, 2) + "\n", "utf-8");
+    files.push(configPath);
+  }
   const migrationPath = join2(dir, "MIGRATION.md");
   const lines = [
     "# Fastlane to GPC Migration",
     "",
+    "Generated by `gpc migrate fastlane`. Review and adjust before applying.",
+    "",
     "## Migration Checklist",
     ""
   ];
@@ -1570,7 +1598,7 @@ async function writeMigrationOutput(result, dir) {
     lines.push("## Warnings");
     lines.push("");
     for (const warning of result.warnings) {
-      lines.push(`- ${warning}`);
+      lines.push(`> \u26A0 ${warning}`);
     }
   }
   lines.push("");
@@ -1581,8 +1609,11 @@ async function writeMigrationOutput(result, dir) {
   lines.push("| `fastlane supply` | `gpc releases upload` / `gpc listings push` |");
   lines.push("| `upload_to_play_store` | `gpc releases upload` |");
   lines.push('| `supply(track: "internal")` | `gpc releases upload --track internal` |');
-  lines.push('| `supply(rollout: "0.1")` | `gpc releases promote --rollout 10` |');
-  lines.push("| `capture_android_screenshots` | No equivalent (use separate tool) |");
+  lines.push('| `supply(rollout: "0.1")` | `gpc releases upload --rollout 10` |');
+  lines.push("| `supply(skip_upload_aab: true)` | `gpc listings push` |");
+  lines.push("| `capture_android_screenshots` | No equivalent \u2014 use separate tool |");
+  lines.push("");
+  lines.push("See the full migration guide: https://yasserstudio.github.io/gpc/migration/from-fastlane");
   lines.push("");
   await writeFile2(migrationPath, lines.join("\n"), "utf-8");
   files.push(migrationPath);
@@ -1729,12 +1760,16 @@ var STANDARD_TRACKS = /* @__PURE__ */ new Set([
 var TRACK_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_:-]*$/;
 async function validatePreSubmission(options) {
   const checks = [];
+  const resultWarnings = [];
   const fileResult = await validateUploadFile(options.filePath);
   checks.push({
     name: "file",
     passed: fileResult.valid,
-    message: fileResult.valid ? `Valid ${fileResult.fileType} file (${formatSize3(fileResult.sizeBytes)})` : fileResult.errors.join("; ")
+    message: fileResult.valid ? `Valid ${fileResult.fileType.toUpperCase()} (${formatSize3(fileResult.sizeBytes)})` : fileResult.errors.join("; ")
   });
+  for (const w of fileResult.warnings) {
+    resultWarnings.push(w);
+  }
   if (options.mappingFile) {
     try {
       const stats = await stat5(options.mappingFile);
@@ -1786,7 +1821,8 @@ async function validatePreSubmission(options) {
   }
   return {
     valid: checks.every((c) => c.passed),
-    checks
+    checks,
+    warnings: resultWarnings
   };
 }
 function formatSize3(bytes) {
@@ -1955,23 +1991,22 @@ var METRIC_SET_METRICS = {
 function buildQuery(metricSet, options) {
   const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
   const days = options?.days ?? 30;
-  const end = /* @__PURE__ */ new Date();
-  end.setDate(end.getDate() - 1);
-  const start = new Date(end);
-  start.setDate(start.getDate() - days);
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const end = new Date(Date.now() - DAY_MS);
+  const start = new Date(Date.now() - DAY_MS - days * DAY_MS);
   const query = {
     metrics,
     timelineSpec: {
       aggregationPeriod: options?.aggregation ?? "DAILY",
       startTime: {
-        year: start.getFullYear(),
-        month: start.getMonth() + 1,
-        day: start.getDate()
+        year: start.getUTCFullYear(),
+        month: start.getUTCMonth() + 1,
+        day: start.getUTCDate()
       },
       endTime: {
-        year: end.getFullYear(),
-        month: end.getMonth() + 1,
-        day: end.getDate()
+        year: end.getUTCFullYear(),
+        month: end.getUTCMonth() + 1,
+        day: end.getUTCDate()
       }
     }
   };
@@ -2036,21 +2071,25 @@ async function searchVitalsErrors(reporting, packageName, options) {
   return reporting.searchErrorIssues(packageName, options?.filter, options?.maxResults);
 }
 async function compareVitalsTrend(reporting, packageName, metricSet, days = 7) {
-  const now = /* @__PURE__ */ new Date();
-  now.setDate(now.getDate() - 1);
-  const currentEnd = new Date(now);
-  const currentStart = new Date(now);
-  currentStart.setDate(currentStart.getDate() - days);
-  const previousEnd = new Date(currentStart);
-  const previousStart = new Date(previousEnd);
-  previousStart.setDate(previousStart.getDate() - days);
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const nowMs = Date.now();
+  const baseMs = nowMs - 2 * DAY_MS;
+  const currentEnd = new Date(baseMs);
+  const currentStart = new Date(baseMs - days * DAY_MS);
+  const previousEnd = new Date(baseMs - days * DAY_MS - DAY_MS);
+  const previousStart = new Date(baseMs - days * DAY_MS - DAY_MS - days * DAY_MS);
   const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
+  const toApiDate2 = (d) => ({
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate()
+  });
   const makeQuery = (start, end) => ({
     metrics,
     timelineSpec: {
       aggregationPeriod: "DAILY",
-      startTime: { year: start.getFullYear(), month: start.getMonth() + 1, day: start.getDate() },
-      endTime: { year: end.getFullYear(), month: end.getMonth() + 1, day: end.getDate() }
+      startTime: toApiDate2(start),
+      endTime: toApiDate2(end)
     }
   });
   const [currentResult, previousResult] = await Promise.all([
@@ -2797,10 +2836,12 @@ function formatNotes(commits, maxLength) {
 ${bullets}`);
   }
   let text = sections.join("\n\n");
+  let truncated = false;
   if (text.length > maxLength) {
     text = text.slice(0, maxLength - 3) + "...";
+    truncated = true;
   }
-  return text;
+  return { text, truncated };
 }
 async function gitExec(args) {
   try {
@@ -2854,17 +2895,19 @@ async function generateNotesFromGit(options) {
       language,
       text: "No changes since last release.",
       commitCount: 0,
-      since
+      since,
+      truncated: false
     };
   }
   const subjects = logOutput.split("\n").filter((line) => line.length > 0);
   const commits = subjects.map(parseConventionalCommit);
-  const text = formatNotes(commits, maxLength);
+  const { text, truncated } = formatNotes(commits, maxLength);
   return {
     language,
     text,
     commitCount: subjects.length,
-    since
+    since,
+    truncated
   };
 }
 
@@ -3759,6 +3802,382 @@ async function deactivatePurchaseOption(client, packageName, purchaseOptionId) {
     );
   }
 }
+
+// src/commands/bundle-analysis.ts
+import { readFile as readFile9, stat as stat6 } from "fs/promises";
+var EOCD_SIGNATURE = 101010256;
+var CD_SIGNATURE = 33639248;
+var MODULE_SUBDIRS = /* @__PURE__ */ new Set(["dex", "manifest", "res", "assets", "lib", "resources.pb", "root"]);
+function detectCategory(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".dex") || /\/dex\/[^/]+\.dex$/.test(lower)) return "dex";
+  if (lower === "resources.arsc" || lower.endsWith("/resources.arsc") || lower.endsWith("/resources.pb") || /^(([^/]+\/)?res\/)/.test(lower)) return "resources";
+  if (/^(([^/]+\/)?assets\/)/.test(lower)) return "assets";
+  if (/^(([^/]+\/)?lib\/)/.test(lower)) return "native-libs";
+  if (lower === "androidmanifest.xml" || lower.endsWith("/androidmanifest.xml") || /^(([^/]+\/)?manifest\/)/.test(lower)) return "manifest";
+  if (lower.startsWith("meta-inf/") || lower === "meta-inf") return "signing";
+  return "other";
+}
+function detectModule(path, isAab) {
+  if (!isAab) return "(root)";
+  const slashIdx = path.indexOf("/");
+  if (slashIdx === -1) return "(root)";
+  const topDir = path.substring(0, slashIdx);
+  const rest = path.substring(slashIdx + 1);
+  if (topDir === "base") return "base";
+  if (topDir === "BUNDLE-METADATA" || topDir === "META-INF") return "(root)";
+  if (path === "BundleConfig.pb") return "(root)";
+  const subDir = rest.split("/")[0] || "";
+  if (MODULE_SUBDIRS.has(subDir)) return topDir;
+  return "(root)";
+}
+function parseCentralDirectory(buf) {
+  let eocdOffset = -1;
+  for (let i = buf.length - 22; i >= 0 && i >= buf.length - 65557; i--) {
+    if (buf.readUInt32LE(i) === EOCD_SIGNATURE) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) {
+    throw new Error("Not a valid ZIP file: EOCD signature not found");
+  }
+  const cdSize = buf.readUInt32LE(eocdOffset + 12);
+  let cdOffset = buf.readUInt32LE(eocdOffset + 16);
+  if (cdOffset === 4294967295) {
+    const zip64LocatorOffset = eocdOffset - 20;
+    if (zip64LocatorOffset >= 0 && buf.readUInt32LE(zip64LocatorOffset) === 117853008) {
+      const zip64EocdOffset = Number(buf.readBigUInt64LE(zip64LocatorOffset + 8));
+      if (zip64EocdOffset >= 0 && zip64EocdOffset < buf.length) {
+        cdOffset = Number(buf.readBigUInt64LE(zip64EocdOffset + 48));
+      }
+    }
+  }
+  const entries = [];
+  let pos = cdOffset;
+  const end = cdOffset + cdSize;
+  while (pos < end && pos + 46 <= buf.length) {
+    const sig = buf.readUInt32LE(pos);
+    if (sig !== CD_SIGNATURE) break;
+    const compressedSize = buf.readUInt32LE(pos + 20);
+    const uncompressedSize = buf.readUInt32LE(pos + 24);
+    const filenameLen = buf.readUInt16LE(pos + 28);
+    const extraLen = buf.readUInt16LE(pos + 30);
+    const commentLen = buf.readUInt16LE(pos + 32);
+    const filename = buf.toString("utf-8", pos + 46, pos + 46 + filenameLen);
+    if (!filename.endsWith("/")) {
+      entries.push({ filename, compressedSize, uncompressedSize });
+    }
+    pos += 46 + filenameLen + extraLen + commentLen;
+  }
+  return entries;
+}
+function detectFileType2(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".aab")) return "aab";
+  return "apk";
+}
+async function analyzeBundle(filePath) {
+  const fileInfo = await stat6(filePath).catch(() => null);
+  if (!fileInfo || !fileInfo.isFile()) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const buf = await readFile9(filePath);
+  const cdEntries = parseCentralDirectory(buf);
+  const fileType = detectFileType2(filePath);
+  const isAab = fileType === "aab";
+  const entries = cdEntries.map((e) => ({
+    path: e.filename,
+    module: detectModule(e.filename, isAab),
+    category: detectCategory(e.filename),
+    compressedSize: e.compressedSize,
+    uncompressedSize: e.uncompressedSize
+  }));
+  const moduleMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = moduleMap.get(entry.module) ?? { compressedSize: 0, uncompressedSize: 0, entries: 0 };
+    existing.compressedSize += entry.compressedSize;
+    existing.uncompressedSize += entry.uncompressedSize;
+    existing.entries += 1;
+    moduleMap.set(entry.module, existing);
+  }
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = categoryMap.get(entry.category) ?? { compressedSize: 0, uncompressedSize: 0, entries: 0 };
+    existing.compressedSize += entry.compressedSize;
+    existing.uncompressedSize += entry.uncompressedSize;
+    existing.entries += 1;
+    categoryMap.set(entry.category, existing);
+  }
+  const modules = [...moduleMap.entries()].map(([name, data]) => ({ name, ...data })).sort((a, b) => b.compressedSize - a.compressedSize);
+  const categories = [...categoryMap.entries()].map(([name, data]) => ({ name, ...data })).sort((a, b) => b.compressedSize - a.compressedSize);
+  const totalCompressed = entries.reduce((sum, e) => sum + e.compressedSize, 0);
+  const totalUncompressed = entries.reduce((sum, e) => sum + e.uncompressedSize, 0);
+  return {
+    filePath,
+    fileType,
+    totalCompressed,
+    totalUncompressed,
+    entryCount: entries.length,
+    modules,
+    categories,
+    entries
+  };
+}
+function compareBundles(before, after) {
+  const sizeDelta = after.totalCompressed - before.totalCompressed;
+  const sizeDeltaPercent = before.totalCompressed > 0 ? Math.round(sizeDelta / before.totalCompressed * 100 * 10) / 10 : 0;
+  const allModules = /* @__PURE__ */ new Set([
+    ...before.modules.map((m) => m.name),
+    ...after.modules.map((m) => m.name)
+  ]);
+  const moduleDeltas = [...allModules].map((module) => {
+    const b = before.modules.find((m) => m.name === module)?.compressedSize ?? 0;
+    const a = after.modules.find((m) => m.name === module)?.compressedSize ?? 0;
+    return { module, before: b, after: a, delta: a - b };
+  }).sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+  const allCategories = /* @__PURE__ */ new Set([
+    ...before.categories.map((c) => c.name),
+    ...after.categories.map((c) => c.name)
+  ]);
+  const categoryDeltas = [...allCategories].map((category) => {
+    const b = before.categories.find((c) => c.name === category)?.compressedSize ?? 0;
+    const a = after.categories.find((c) => c.name === category)?.compressedSize ?? 0;
+    return { category, before: b, after: a, delta: a - b };
+  }).sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+  return {
+    before: { path: before.filePath, totalCompressed: before.totalCompressed },
+    after: { path: after.filePath, totalCompressed: after.totalCompressed },
+    sizeDelta,
+    sizeDeltaPercent,
+    moduleDeltas,
+    categoryDeltas
+  };
+}
+
+// src/commands/status.ts
+import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
+import { join as join7 } from "path";
+import { getCacheDir } from "@gpc-cli/config";
+var DEFAULT_TTL_SECONDS = 3600;
+function cacheFilePath(packageName) {
+  return join7(getCacheDir(), `status-${packageName}.json`);
+}
+async function loadStatusCache(packageName, ttlSeconds = DEFAULT_TTL_SECONDS) {
+  try {
+    const raw = await readFile10(cacheFilePath(packageName), "utf-8");
+    const entry = JSON.parse(raw);
+    const age = (Date.now() - new Date(entry.fetchedAt).getTime()) / 1e3;
+    if (age > (entry.ttl ?? ttlSeconds)) return null;
+    return { ...entry.data, cached: true };
+  } catch {
+    return null;
+  }
+}
+async function saveStatusCache(packageName, data, ttlSeconds = DEFAULT_TTL_SECONDS) {
+  try {
+    const dir = getCacheDir();
+    await mkdir5(dir, { recursive: true });
+    const entry = {
+      fetchedAt: data.fetchedAt,
+      ttl: ttlSeconds,
+      data
+    };
+    await writeFile7(cacheFilePath(packageName), JSON.stringify(entry, null, 2), { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+}
+var METRIC_SET_METRICS2 = {
+  crashRateMetricSet: ["crashRate", "userPerceivedCrashRate", "distinctUsers"],
+  anrRateMetricSet: ["anrRate", "userPerceivedAnrRate", "distinctUsers"],
+  slowStartRateMetricSet: ["slowStartRate", "distinctUsers"],
+  slowRenderingRateMetricSet: ["slowRenderingRate", "distinctUsers"]
+};
+var DEFAULT_THRESHOLDS = {
+  crashRate: 0.02,
+  anrRate: 0.01,
+  slowStartRate: 0.05,
+  slowRenderingRate: 0.1
+};
+var WARN_MARGIN = 0.2;
+function toApiDate(d) {
+  return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate() };
+}
+async function queryVitalForStatus(reporting, packageName, metricSet, days) {
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const baseMs = Date.now() - 2 * DAY_MS;
+  const end = new Date(baseMs);
+  const start = new Date(baseMs - days * DAY_MS);
+  const metrics = METRIC_SET_METRICS2[metricSet] ?? ["distinctUsers"];
+  const query = {
+    metrics,
+    timelineSpec: {
+      aggregationPeriod: "DAILY",
+      startTime: toApiDate(start),
+      endTime: toApiDate(end)
+    }
+  };
+  const result = await reporting.queryMetricSet(packageName, metricSet, query);
+  if (!result.rows || result.rows.length === 0) return void 0;
+  const values = result.rows.map((row) => {
+    const firstKey = Object.keys(row.metrics)[0];
+    return firstKey ? Number(row.metrics[firstKey]?.decimalValue?.value) : NaN;
+  }).filter((v) => !isNaN(v));
+  if (values.length === 0) return void 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function toVitalMetric(value, threshold) {
+  if (value === void 0) {
+    return { value: void 0, threshold, status: "unknown" };
+  }
+  if (value > threshold) return { value, threshold, status: "breach" };
+  if (value > threshold * (1 - WARN_MARGIN)) return { value, threshold, status: "warn" };
+  return { value, threshold, status: "ok" };
+}
+function computeReviewSentiment(reviews, windowDays) {
+  const now = Date.now();
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const windowMs = windowDays * DAY_MS;
+  const prevWindowStart = now - 2 * windowMs;
+  const curWindowStart = now - windowMs;
+  const current = reviews.filter((r) => {
+    const uc = r.comments?.[0]?.userComment;
+    if (!uc) return false;
+    const ts = Number(uc.lastModified.seconds) * 1e3;
+    return ts >= curWindowStart;
+  });
+  const previous = reviews.filter((r) => {
+    const uc = r.comments?.[0]?.userComment;
+    if (!uc) return false;
+    const ts = Number(uc.lastModified.seconds) * 1e3;
+    return ts >= prevWindowStart && ts < curWindowStart;
+  });
+  const avgRating = (items) => {
+    const ratings = items.map((r) => r.comments?.[0]?.userComment?.starRating).filter((v) => v !== void 0 && v > 0);
+    if (ratings.length === 0) return void 0;
+    return Math.round(ratings.reduce((a, b) => a + b, 0) / ratings.length * 10) / 10;
+  };
+  const positiveCount = current.filter(
+    (r) => (r.comments?.[0]?.userComment?.starRating ?? 0) >= 4
+  ).length;
+  const positivePercent = current.length > 0 ? Math.round(positiveCount / current.length * 100) : void 0;
+  return {
+    windowDays,
+    averageRating: avgRating(current),
+    previousAverageRating: avgRating(previous),
+    totalNew: current.length,
+    positivePercent
+  };
+}
+async function getAppStatus(client, reporting, packageName, options = {}) {
+  const days = options.days ?? 7;
+  const thresholds = {
+    crashRate: options.vitalThresholds?.crashRate ?? DEFAULT_THRESHOLDS.crashRate,
+    anrRate: options.vitalThresholds?.anrRate ?? DEFAULT_THRESHOLDS.anrRate,
+    slowStartRate: options.vitalThresholds?.slowStartRate ?? DEFAULT_THRESHOLDS.slowStartRate,
+    slowRenderingRate: options.vitalThresholds?.slowRenderingRate ?? DEFAULT_THRESHOLDS.slowRenderingRate
+  };
+  const [releasesResult, crashesResult, anrResult, slowStartResult, slowRenderResult, reviewsResult] = await Promise.allSettled([
+    getReleasesStatus(client, packageName),
+    queryVitalForStatus(reporting, packageName, "crashRateMetricSet", days),
+    queryVitalForStatus(reporting, packageName, "anrRateMetricSet", days),
+    queryVitalForStatus(reporting, packageName, "slowStartRateMetricSet", days),
+    queryVitalForStatus(reporting, packageName, "slowRenderingRateMetricSet", days),
+    listReviews(client, packageName, { maxResults: 500 })
+  ]);
+  const rawReleases = releasesResult.status === "fulfilled" ? releasesResult.value : [];
+  const releases = rawReleases.map((r) => ({
+    track: r.track,
+    versionCode: r.versionCodes[r.versionCodes.length - 1] ?? "\u2014",
+    status: r.status,
+    userFraction: r.userFraction ?? null
+  }));
+  const crashValue = crashesResult.status === "fulfilled" ? crashesResult.value : void 0;
+  const anrValue = anrResult.status === "fulfilled" ? anrResult.value : void 0;
+  const slowStartValue = slowStartResult.status === "fulfilled" ? slowStartResult.value : void 0;
+  const slowRenderValue = slowRenderResult.status === "fulfilled" ? slowRenderResult.value : void 0;
+  const rawReviews = reviewsResult.status === "fulfilled" ? reviewsResult.value : [];
+  const reviews = computeReviewSentiment(rawReviews, 30);
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    packageName,
+    fetchedAt,
+    cached: false,
+    releases,
+    vitals: {
+      windowDays: days,
+      crashes: toVitalMetric(crashValue, thresholds.crashRate),
+      anr: toVitalMetric(anrValue, thresholds.anrRate),
+      slowStarts: toVitalMetric(slowStartValue, thresholds.slowStartRate),
+      slowRender: toVitalMetric(slowRenderValue, thresholds.slowRenderingRate)
+    },
+    reviews
+  };
+}
+function vitalIndicator(metric) {
+  if (metric.status === "unknown") return "?";
+  if (metric.status === "breach") return "\u2717";
+  if (metric.status === "warn") return "\u26A0";
+  return "\u2713";
+}
+function formatVitalValue(metric) {
+  if (metric.value === void 0) return "n/a";
+  return `${(metric.value * 100).toFixed(2)}%`;
+}
+function formatFraction(fraction) {
+  if (fraction === null) return "\u2014";
+  return `${Math.round(fraction * 100)}%`;
+}
+function formatRating(rating) {
+  if (rating === void 0) return "n/a";
+  return `\u2605 ${rating.toFixed(1)}`;
+}
+function formatTrend(current, previous) {
+  if (current === void 0 || previous === void 0) return "";
+  if (current > previous) return `  \u2191 from ${previous.toFixed(1)}`;
+  if (current < previous) return `  \u2193 from ${previous.toFixed(1)}`;
+  return "";
+}
+function formatStatusTable(status) {
+  const lines = [];
+  const cachedLabel = status.cached ? `  (cached ${new Date(status.fetchedAt).toLocaleTimeString()})` : `  (fetched ${new Date(status.fetchedAt).toLocaleTimeString()})`;
+  lines.push(`App: ${status.packageName}${cachedLabel}`);
+  lines.push("");
+  lines.push("RELEASES");
+  if (status.releases.length === 0) {
+    lines.push("  No releases found.");
+  } else {
+    const trackW = Math.max(10, ...status.releases.map((r) => r.track.length));
+    const versionW = Math.max(7, ...status.releases.map((r) => r.versionCode.length));
+    const statusW = Math.max(8, ...status.releases.map((r) => r.status.length));
+    for (const r of status.releases) {
+      lines.push(
+        `  ${r.track.padEnd(trackW)}  ${r.versionCode.padEnd(versionW)}  ${r.status.padEnd(statusW)}  ${formatFraction(r.userFraction)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(`VITALS  (last ${status.vitals.windowDays} days)`);
+  const { crashes, anr, slowStarts, slowRender } = status.vitals;
+  lines.push(
+    `  crashes     ${formatVitalValue(crashes).padEnd(8)}  ${vitalIndicator(crashes)}    anr         ${formatVitalValue(anr).padEnd(8)}  ${vitalIndicator(anr)}`
+  );
+  lines.push(
+    `  slow starts ${formatVitalValue(slowStarts).padEnd(8)}  ${vitalIndicator(slowStarts)}    slow render ${formatVitalValue(slowRender).padEnd(8)}  ${vitalIndicator(slowRender)}`
+  );
+  lines.push("");
+  lines.push(`REVIEWS  (last ${status.reviews.windowDays} days)`);
+  const { averageRating, previousAverageRating, totalNew, positivePercent } = status.reviews;
+  const trend = formatTrend(averageRating, previousAverageRating);
+  const positiveStr = positivePercent !== void 0 ? `  ${positivePercent}% positive` : "";
+  lines.push(
+    `  ${formatRating(averageRating)}   ${totalNew} new${positiveStr}${trend}`
+  );
+  return lines.join("\n");
+}
+function statusHasBreach(status) {
+  return status.vitals.crashes.status === "breach" || status.vitals.anr.status === "breach" || status.vitals.slowStarts.status === "breach" || status.vitals.slowRender.status === "breach";
+}
 export {
   ApiError,
   ConfigError,
@@ -3775,11 +4194,13 @@ export {
   activatePurchaseOption,
   addRecoveryTargeting,
   addTesters,
+  analyzeBundle,
   batchSyncInAppProducts,
   cancelRecoveryAction,
   cancelSubscriptionPurchase,
   checkThreshold,
   clearAuditLog,
+  compareBundles,
   compareVitalsTrend,
   consumeProductPurchase,
   convertRegionPrices,
@@ -3826,9 +4247,11 @@ export {
   formatJunit,
   formatOutput,
   formatSlackPayload,
+  formatStatusTable,
   generateMigrationPlan,
   generateNotesFromGit,
   getAppInfo,
+  getAppStatus,
   getCountryAvailability,
   getDataSafety,
   getDeviceTier,
@@ -3879,6 +4302,7 @@ export {
   listTracks,
   listUsers,
   listVoidedPurchases,
+  loadStatusCache,
   migratePrices,
   parseAppfile,
   parseFastfile,
@@ -3900,11 +4324,13 @@ export {
   revokeSubscriptionPurchase,
   safePath,
   safePathWithin,
+  saveStatusCache,
   scaffoldPlugin,
   searchAuditEvents,
   searchVitalsErrors,
   sendWebhook,
   sortResults,
+  statusHasBreach,
   syncInAppProducts,
   updateAppDetails,
   updateDataSafety,