@gpc-cli/core 0.9.76 → 0.9.78

package/dist/index.js

@@ -3843,6 +3843,255 @@ async function convertRegionPrices(client, packageName, currencyCode, amount) {
   });
 }
 
+// src/reports/errors.ts
+function reportAccessDeniedError(bucket) {
+  return new GpcError(
+    `Access denied reading the Play reports bucket "${bucket}".`,
+    "REPORT_ACCESS_DENIED",
+    4,
+    "Grant the service account access: Play Console -> Users & permissions -> the service account -> Account permissions -> enable 'View app information and download bulk reports (read-only)', then wait a few minutes for it to propagate."
+  );
+}
+function reportAuthRejectedError(bucket) {
+  return new GpcError(
+    `Authentication was rejected reading the Play reports bucket "${bucket}".`,
+    "REPORT_AUTH_REJECTED",
+    3,
+    "The access token was not accepted. Check the service account key is valid (gpc auth status) and that your system clock is accurate, then retry."
+  );
+}
+function reportBucketNotFoundError(bucket) {
+  return new GpcError(
+    `Play reports bucket "${bucket}" was not found.`,
+    "REPORT_BUCKET_NOT_FOUND",
+    4,
+    "Confirm the bucket name. Copy the exact Cloud Storage URI from Play Console -> Download reports, then set it with --bucket or the 'reports.bucket' config key. The default is pubsite_prod_<developerId>."
+  );
+}
+function reportObjectNotFoundError(opts) {
+  const { reportType, month, dimension, available } = opts;
+  const dimPart = dimension ? ` dimension "${dimension}"` : "";
+  const availPart = available && available.length ? ` Available: ${available.join(", ")}.` : " No matching report objects were found for that month.";
+  return new GpcError(
+    `No "${reportType}" report found for ${month}${dimPart}.`,
+    "REPORT_OBJECT_NOT_FOUND",
+    4,
+    `Check the month is complete and the report type/dimension exist.${availPart} Reports for the current month may not be published until it ends.`
+  );
+}
+
+// src/reports/gcs.ts
+var GCS_API_BASE = "https://storage.googleapis.com/storage/v1/b";
+var LIST_TIMEOUT_MS = 6e4;
+var DOWNLOAD_TIMEOUT_MS = 12e4;
+function networkError(bucket, cause) {
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return new GpcError(
+    `Network error reading the Play reports bucket "${bucket}": ${detail}`,
+    "NETWORK_ERROR",
+    5,
+    "Check your internet connection and retry. Google Cloud Storage may also be briefly unavailable."
+  );
+}
+function maxRetries() {
+  const parsed = Number(process.env["GPC_MAX_RETRIES"]);
+  return Number.isInteger(parsed) && parsed >= 0 && parsed <= 10 ? parsed : 3;
+}
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+async function gcsFetch(auth, bucket, url, timeoutMs) {
+  const retries = maxRetries();
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    if (attempt > 0) {
+      await new Promise((r) => setTimeout(r, Math.min(1e3 * 2 ** (attempt - 1), 8e3)));
+    }
+    const token = await auth.getAccessToken();
+    let res;
+    try {
+      res = await fetch(url, {
+        headers: { authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err) {
+      lastError = err;
+      continue;
+    }
+    if (RETRYABLE_STATUSES.has(res.status) && attempt < retries) {
+      continue;
+    }
+    if (res.status === 401) {
+      throw reportAuthRejectedError(bucket);
+    }
+    if (res.status === 403) {
+      throw reportAccessDeniedError(bucket);
+    }
+    return res;
+  }
+  throw networkError(bucket, lastError ?? new Error("retries exhausted"));
+}
+async function listReportObjects(auth, bucket, options) {
+  const params = new URLSearchParams({ prefix: options.prefix });
+  if (options.maxResults) params.set("maxResults", String(options.maxResults));
+  if (options.pageToken) params.set("pageToken", options.pageToken);
+  const url = `${GCS_API_BASE}/${encodeURIComponent(bucket)}/o?${params.toString()}`;
+  const res = await gcsFetch(auth, bucket, url, LIST_TIMEOUT_MS);
+  if (res.status === 404) {
+    throw reportBucketNotFoundError(bucket);
+  }
+  if (!res.ok) {
+    throw new GpcError(
+      `Google Cloud Storage returned HTTP ${res.status} listing the reports bucket "${bucket}".`,
+      "REPORT_LIST_FAILED",
+      4,
+      "Retry in a moment. If the error persists, verify the bucket name and the service account's report access."
+    );
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    throw networkError(bucket, err);
+  }
+  const objects = (body.items ?? []).filter((item) => typeof item.name === "string").map((item) => ({
+    name: item.name,
+    size: Number(item.size ?? 0),
+    updated: item.updated
+  }));
+  return { objects, nextPageToken: body.nextPageToken };
+}
+async function downloadReportObject(auth, bucket, objectName) {
+  const url = `${GCS_API_BASE}/${encodeURIComponent(bucket)}/o/${encodeURIComponent(objectName)}?alt=media`;
+  const res = await gcsFetch(auth, bucket, url, DOWNLOAD_TIMEOUT_MS);
+  if (res.status === 404) {
+    throw new GpcError(
+      `Report object "${objectName}" was not found in bucket "${bucket}".`,
+      "REPORT_OBJECT_NOT_FOUND",
+      4,
+      "List available reports first: gpc reports list <report-type> --month <YYYY-MM>"
+    );
+  }
+  if (!res.ok) {
+    throw new GpcError(
+      `Google Cloud Storage returned HTTP ${res.status} downloading "${objectName}".`,
+      "REPORT_DOWNLOAD_FAILED",
+      4,
+      "Retry in a moment. If the error persists, list the reports to confirm the object still exists."
+    );
+  }
+  try {
+    return Buffer.from(await res.arrayBuffer());
+  } catch (err) {
+    throw networkError(bucket, err);
+  }
+}
+
+// src/reports/decode.ts
+import { gunzipSync } from "zlib";
+import { fromBuffer } from "yauzl";
+var GZIP_MAGIC = [31, 139];
+var ZIP_MAGIC = [80, 75];
+function isGzip(buf) {
+  return buf.length >= 2 && buf[0] === GZIP_MAGIC[0] && buf[1] === GZIP_MAGIC[1];
+}
+function isZip(buf) {
+  return buf.length >= 2 && buf[0] === ZIP_MAGIC[0] && buf[1] === ZIP_MAGIC[1];
+}
+var MAX_INFLATED_BYTES = 512 * 1024 * 1024;
+function gunzipIfNeeded(buf) {
+  return isGzip(buf) ? gunzipSync(buf, { maxOutputLength: MAX_INFLATED_BYTES }) : buf;
+}
+function decodeCsvText(buf) {
+  if (buf.length >= 2 && buf[0] === 255 && buf[1] === 254) {
+    return buf.subarray(2).toString("utf16le");
+  }
+  if (buf.length >= 2 && buf[0] === 254 && buf[1] === 255) {
+    const swapped = Buffer.from(buf.subarray(2));
+    swapped.swap16();
+    return swapped.toString("utf16le");
+  }
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+    return buf.subarray(3).toString("utf8");
+  }
+  return buf.toString("utf8");
+}
+function decodeStatsCsv(buf) {
+  return decodeCsvText(gunzipIfNeeded(buf));
+}
+var ZIP_READ_TIMEOUT_MS = 3e4;
+function extractCsvEntriesFromZip(buffer) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      settleReject(new Error("Timed out reading report archive"));
+    }, ZIP_READ_TIMEOUT_MS);
+    timer.unref?.();
+    function settleResolve(v) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2(v);
+    }
+    function settleReject(e) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(e);
+    }
+    try {
+      fromBuffer(buffer, { lazyEntries: true }, (err, openedZip) => {
+        if (err || !openedZip) {
+          settleReject(err ?? new Error("Failed to open report archive"));
+          return;
+        }
+        const zipfile = openedZip;
+        const entries = [];
+        let pending = 0;
+        let entriesDone = false;
+        function fail(e) {
+          try {
+            zipfile.close();
+          } catch {
+          }
+          settleReject(e);
+        }
+        function maybeResolve() {
+          if (!settled && entriesDone && pending === 0) settleResolve(entries);
+        }
+        zipfile.on("entry", (entry) => {
+          if (/\/$/.test(entry.fileName) || !/\.csv$/i.test(entry.fileName)) {
+            zipfile.readEntry();
+            return;
+          }
+          pending++;
+          zipfile.openReadStream(entry, (streamErr, stream) => {
+            if (streamErr || !stream) {
+              fail(streamErr ?? new Error(`Failed to read ${entry.fileName}`));
+              return;
+            }
+            const chunks = [];
+            stream.on("data", (c) => chunks.push(c));
+            stream.on("error", fail);
+            stream.on("end", () => {
+              entries.push({ name: entry.fileName, text: decodeStatsCsv(Buffer.concat(chunks)) });
+              pending--;
+              zipfile.readEntry();
+              maybeResolve();
+            });
+          });
+        });
+        zipfile.on("end", () => {
+          entriesDone = true;
+          maybeResolve();
+        });
+        zipfile.on("error", fail);
+        zipfile.readEntry();
+      });
+    } catch (e) {
+      settleReject(e instanceof Error ? e : new Error(String(e)));
+    }
+  });
+}
+
 // src/commands/reports.ts
 var FINANCIAL_REPORT_TYPES = /* @__PURE__ */ new Set([
   "earnings",
@@ -3865,6 +4114,7 @@ var VALID_DIMENSIONS = /* @__PURE__ */ new Set([
   "device",
   "app_version",
   "carrier",
+  "traffic_source",
   "overview"
 ]);
 function isFinancialReportType(type) {
@@ -3901,22 +4151,131 @@ function parseMonth(monthStr) {
   }
   return { year, month };
 }
-async function listReports(_client, _packageName, reportType, _year, _month) {
-  throw new GpcError(
-    `Report listing for "${reportType}" is not available through the Google Play Developer API.`,
-    "REPORT_NOT_SUPPORTED",
-    1,
-    isFinancialReportType(reportType) ? "Financial reports are delivered via Google Cloud Storage. Access them from Play Console \u2192 Download reports \u2192 Financial." : "Stats reports are delivered via Google Cloud Storage. For real-time metrics, use 'gpc vitals' commands."
-  );
+function monthToken(parsed) {
+  return `${parsed.year}${String(parsed.month).padStart(2, "0")}`;
+}
+function nameHasMonth(name, token) {
+  return new RegExp(`(?<![0-9])${token}(?![0-9])`).test(name);
 }
-async function downloadReport(_client, _packageName, reportType, _year, _month) {
+function resolveReportsBucket(config) {
+  const explicit = config.reports?.bucket?.trim();
+  if (explicit) {
+    const reduced = explicit.replace(/^gs:\/\//, "").replace(/\/.*$/, "");
+    if (!/^[a-z0-9][a-z0-9._-]{1,221}$/.test(reduced)) {
+      throw new GpcError(
+        `Invalid reports bucket name "${reduced}".`,
+        "REPORT_BUCKET_INVALID",
+        2,
+        "Copy the exact Cloud Storage URI from Play Console -> Download reports. The bucket name looks like pubsite_prod_<developerId>."
+      );
+    }
+    return reduced;
+  }
+  if (config.developerId) {
+    return `pubsite_prod_${config.developerId}`;
+  }
   throw new GpcError(
-    `Report download for "${reportType}" is not available through the Google Play Developer API.`,
-    "REPORT_NOT_SUPPORTED",
-    1,
-    isFinancialReportType(reportType) ? "Financial reports are delivered via Google Cloud Storage. Access them from Play Console \u2192 Download reports \u2192 Financial." : "Stats reports are delivered via Google Cloud Storage. For real-time metrics, use 'gpc vitals' commands."
+    "Cannot determine the Play reports bucket: no bucket configured and no developer id set.",
+    "REPORT_BUCKET_UNKNOWN",
+    2,
+    "Set your developer id (gpc config set developerId <id> or GPC_DEVELOPER_ID) so the default pubsite_prod_<developerId> bucket can be derived, or pass the bucket directly with --bucket / GPC_REPORTS_BUCKET / the reports.bucket config key. The exact URI is shown in Play Console -> Download reports."
   );
 }
+function reportPrefix(reportType, packageName) {
+  switch (reportType) {
+    case "earnings":
+      return "earnings/";
+    case "sales":
+    case "estimated_sales":
+      return "sales/";
+    case "play_balance":
+      return "play_balance/";
+    case "reviews":
+      return packageName ? `reviews/reviews_${packageName}_` : "reviews/";
+    case "subscriptions":
+      return packageName ? `financial-stats/subscriptions/subscriptions_${packageName}_` : "financial-stats/subscriptions/";
+    default:
+      return packageName ? `stats/${reportType}/${reportType}_${packageName}_` : `stats/${reportType}/`;
+  }
+}
+async function listReports(auth, bucket, reportType, options = {}) {
+  const packageName = isStatsReportType(reportType) ? options.packageName : void 0;
+  const basePrefix = reportPrefix(reportType, packageName);
+  const serverSideMonth = Boolean(packageName && options.month);
+  const prefix = serverSideMonth ? `${basePrefix}${monthToken(options.month)}` : basePrefix;
+  const { objects, nextPageToken } = await listReportObjects(auth, bucket, {
+    prefix,
+    maxResults: options.maxResults,
+    pageToken: options.pageToken
+  });
+  const reports = options.month && !serverSideMonth ? objects.filter((o) => nameHasMonth(o.name, monthToken(options.month))) : objects;
+  return { reports, nextPageToken };
+}
+async function downloadStatsReport(auth, bucket, packageName, reportType, month, dimension) {
+  const token = monthToken(month);
+  const prefix = `${reportPrefix(reportType, packageName)}${token}`;
+  const { objects } = await listReportObjects(auth, bucket, { prefix });
+  const wanted = reportType === "reviews" ? objects.find((o) => o.name.endsWith(`${token}.csv`)) : objects.find((o) => o.name.endsWith(`${token}_${dimension}.csv`));
+  if (!wanted) {
+    const available = objects.map((o) => new RegExp(`(?<![0-9])${token}_([a-z_]+)\\.csv$`).exec(o.name)?.[1]).filter((d) => Boolean(d));
+    throw reportObjectNotFoundError({
+      reportType,
+      month: `${month.year}-${String(month.month).padStart(2, "0")}`,
+      dimension: reportType === "reviews" ? void 0 : dimension,
+      available: [...new Set(available)]
+    });
+  }
+  const bytes = await downloadReportObject(auth, bucket, wanted.name);
+  try {
+    return { objectName: wanted.name, csv: decodeStatsCsv(bytes) };
+  } catch (err) {
+    throw new GpcError(
+      `Could not decode the report "${wanted.name}": ${err instanceof Error ? err.message : String(err)}`,
+      "REPORT_DECODE_FAILED",
+      4,
+      "Re-download in case the transfer was corrupted. If the error persists, the object may be malformed; download it from Play Console -> Download reports to compare."
+    );
+  }
+}
+async function downloadFinancialReport(auth, bucket, reportType, month, options = {}) {
+  const token = monthToken(month);
+  const { objects } = await listReportObjects(auth, bucket, {
+    prefix: reportPrefix(reportType)
+  });
+  const matches = objects.filter((o) => nameHasMonth(o.name, token));
+  if (matches.length === 0) {
+    const availableMonths = [
+      ...new Set(
+        objects.map((o) => /(?<![0-9])(\d{4})(\d{2})(?![0-9])/.exec(o.name)).filter((m) => m !== null).map((m) => `${m[1]}-${m[2]}`)
+      )
+    ].slice(-6);
+    throw reportObjectNotFoundError({
+      reportType,
+      month: `${month.year}-${String(month.month).padStart(2, "0")}`,
+      available: availableMonths
+    });
+  }
+  const chosen = matches[matches.length - 1];
+  const bytes = await downloadReportObject(auth, bucket, chosen.name);
+  if (isZip(bytes)) {
+    if (options.extractEntries === false) {
+      return { objectName: chosen.name, kind: "zip", entries: [], raw: bytes };
+    }
+    let entries;
+    try {
+      entries = await extractCsvEntriesFromZip(bytes);
+    } catch (err) {
+      throw new GpcError(
+        `Could not read the report archive "${chosen.name}": ${err instanceof Error ? err.message : String(err)}`,
+        "REPORT_ARCHIVE_UNREADABLE",
+        4,
+        "Save the raw archive instead (--output-file report.zip) and open it locally, or re-download in case the transfer was corrupted."
+      );
+    }
+    return { objectName: chosen.name, kind: "zip", entries, raw: bytes };
+  }
+  return { objectName: chosen.name, kind: "csv", text: decodeStatsCsv(bytes) };
+}
 
 // src/commands/users.ts
 import { paginateAll as paginateAll5 } from "@gpc-cli/api";
@@ -5376,7 +5735,7 @@ async function loadPreflightConfig(configPath) {
 
 // src/preflight/aab-reader.ts
 import { readFile as readFile11 } from "fs/promises";
-import { fromBuffer } from "yauzl";
+import { fromBuffer as fromBuffer2 } from "yauzl";
 
 // src/preflight/manifest-parser.ts
 import protobuf from "protobufjs";
@@ -5637,7 +5996,7 @@ function openAndScan(buffer, manifestPath = AAB_MANIFEST_PATH) {
       reject(error);
     }
     try {
-      fromBuffer(buffer, { lazyEntries: true }, (err, zipfile) => {
+      fromBuffer2(buffer, { lazyEntries: true }, (err, zipfile) => {
         if (err || !zipfile) {
           settleReject(err ?? new Error("Failed to open AAB file"));
           return;
@@ -8925,7 +9284,7 @@ async function sha256File(filePath) {
 }
 
 // src/commands/image-sync.ts
-import { readdir as readdir7 } from "fs/promises";
+import { readdir as readdir7, stat as stat10 } from "fs/promises";
 import { join as join12, extname as extname5 } from "path";
 import { PlayApiError } from "@gpc-cli/api";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
@@ -8955,6 +9314,13 @@ async function scanLanguages(dir) {
     return [];
   }
 }
+async function dirExists(path) {
+  try {
+    return (await stat10(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
 async function syncImages(client, packageName, dir, options) {
   const details = [];
   let uploaded = 0;
@@ -8992,23 +9358,59 @@ async function syncImages(client, packageName, dir, options) {
           const hash = await sha256File(join12(localDir, file));
           localHashes.set(file, hash);
         }
-        const localSha256Set = new Set(localHashes.values());
+        const uploadLocal = async (file, reason) => {
+          if (!options?.dryRun) {
+            const filePath = join12(localDir, file);
+            const check = await validateImage(filePath, imageType);
+            if (!check.valid) {
+              throw new GpcError(
+                `Image validation failed for ${language}/${imageType}/${file}: ${check.errors.join("; ")}`,
+                "IMAGE_INVALID",
+                2,
+                "Check image dimensions, file size, and format."
+              );
+            }
+            await client.images.upload(packageName, edit.id, language, imageType, filePath);
+          }
+          uploaded++;
+          details.push({ language, imageType, file, action: "upload", reason });
+        };
         if (options?.delete) {
-          for (const img of remoteImages) {
-            if (!localSha256Set.has(img.sha256.toLowerCase())) {
-              if (!options?.dryRun) {
-                await client.images.delete(packageName, edit.id, language, imageType, img.id);
-              }
-              deleted++;
+          if (localFiles.length === 0 && remoteImages.length > 0 && !await dirExists(localDir)) {
+            for (const img of remoteImages) {
               details.push({
                 language,
                 imageType,
                 file: img.id,
-                action: "delete",
-                reason: "not in local"
+                action: "skip",
+                reason: "no local directory; remote left untouched"
               });
             }
+            continue;
+          }
+          const localSeq = localFiles.map((file) => localHashes.get(file));
+          const remoteSeq = remoteImages.map((img) => img.sha256.toLowerCase());
+          const inOrder = localSeq.length === remoteSeq.length && localSeq.every((hash, i) => hash === remoteSeq[i]);
+          if (inOrder) {
+            for (const file of localFiles) {
+              skipped++;
+              details.push({ language, imageType, file, action: "skip", reason: "already in order" });
+            }
+            continue;
           }
+          if (remoteImages.length > 0) {
+            if (!options?.dryRun) {
+              await client.images.deleteAll(packageName, edit.id, language, imageType);
+            }
+            for (const img of remoteImages) {
+              deleted++;
+              details.push({ language, imageType, file: img.id, action: "delete", reason: "reordering" });
+            }
+          }
+          for (const file of localFiles) {
+            await uploadLocal(file, "reordering");
+          }
+          continue;
         }
         for (const file of localFiles) {
           const hash = localHashes.get(file);
@@ -9016,21 +9418,7 @@ async function syncImages(client, packageName, dir, options) {
             skipped++;
             details.push({ language, imageType, file, action: "skip", reason: "sha256 match" });
           } else {
-            if (!options?.dryRun) {
-              const filePath = join12(localDir, file);
-              const check = await validateImage(filePath, imageType);
-              if (!check.valid) {
-                throw new GpcError(
-                  `Image validation failed for ${language}/${imageType}/${file}: ${check.errors.join("; ")}`,
-                  "IMAGE_INVALID",
-                  2,
-                  "Check image dimensions, file size, and format."
-                );
-              }
-              await client.images.upload(packageName, edit.id, language, imageType, filePath);
-            }
-            uploaded++;
-            details.push({ language, imageType, file, action: "upload", reason: "new or changed" });
+            await uploadLocal(file, "new or changed");
           }
         }
       }
@@ -9415,7 +9803,9 @@ export {
   createTranslator,
   deactivateBasePlan,
   deactivateOffer,
+  decodeCsvText,
   decodeNotification,
+  decodeStatsCsv,
   defaultGitRunner,
   deferSubscriptionPurchase,
   deferSubscriptionV2,
@@ -9443,10 +9833,13 @@ export {
   diffSubscription,
   discoverPlugins,
   dispatchWebhook,
+  downloadFinancialReport,
   downloadGeneratedApk,
-  downloadReport,
+  downloadReportObject,
+  downloadStatsReport,
   exportImages,
   exportReviews,
+  extractCsvEntriesFromZip,
   fetchAggregateCost,
   fetchChangelog,
   fetchReleaseNotes,
@@ -9505,6 +9898,7 @@ export {
   getVitalsRendering,
   getVitalsStartup,
   gradeFromPercent,
+  gunzipIfNeeded,
   handleBreach,
   importDataSafety,
   importTestersFromCsv,
@@ -9512,11 +9906,13 @@ export {
   initProject,
   inviteUser,
   isFinancialReportType,
+  isGzip,
   isStatsReportType,
   isValidBcp47,
   isValidReportType,
   isValidStatsDimension,
   isVersionedNotesDir,
+  isZip,
   lintListing,
   lintListings,
   lintLocalListings,
@@ -9535,6 +9931,7 @@ export {
   listOneTimeOffers,
   listOneTimeProducts,
   listRecoveryActions,
+  listReportObjects,
   listReports,
   listReviews,
   listSubscriptions,
@@ -9546,6 +9943,7 @@ export {
   loadStatusCache,
   maybePaginate,
   migratePrices,
+  monthToken,
   moreResultsFooter,
   normalizeFingerprint,
   parseAppfile,
@@ -9587,8 +9985,13 @@ export {
   renderPlayStorePrompt,
   renderPrompt,
   replyToReview,
+  reportAccessDeniedError,
+  reportBucketNotFoundError,
+  reportObjectNotFoundError,
+  reportPrefix,
   resolveAiConfig,
   resolveLocales,
+  resolveReportsBucket,
   retryOnUploadNotComplete,
   revokeSubscriptionPurchase,
   runPreflight,