@gpc-cli/core 0.9.6 → 0.9.8

package/dist/index.js

@@ -492,8 +492,13 @@ async function uploadRelease(client, packageName, filePath, options) {
     };
   }
   if (!validation.valid) {
-    throw new Error(`File validation failed:
-${validation.errors.join("\n")}`);
+    throw new GpcError(
+      `File validation failed:
+${validation.errors.join("\n")}`,
+      "RELEASE_INVALID_FILE",
+      2,
+      "Check that the file is a valid AAB or APK and is not corrupted."
+    );
   }
   const edit = await client.edits.insert(packageName);
   try {
@@ -559,10 +564,20 @@ async function promoteRelease(client, packageName, fromTrack, toTrack, options)
       (r) => r.status === "completed" || r.status === "inProgress"
     );
     if (!currentRelease) {
-      throw new Error(`No active release found on track "${fromTrack}"`);
+      throw new GpcError(
+        `No active release found on track "${fromTrack}"`,
+        "RELEASE_NOT_FOUND",
+        1,
+        `Ensure there is a completed or in-progress release on the "${fromTrack}" track before promoting.`
+      );
     }
     if (options?.userFraction && (options.userFraction <= 0 || options.userFraction > 1)) {
-      throw new Error("Rollout percentage must be between 0 and 1 (e.g., 0.1 for 10%)");
+      throw new GpcError(
+        "Rollout percentage must be between 0 and 1 (e.g., 0.1 for 10%)",
+        "RELEASE_INVALID_FRACTION",
+        2,
+        "Use a decimal value like 0.1 for 10%, 0.5 for 50%, or 1.0 for 100%."
+      );
     }
     const release = {
       versionCodes: currentRelease.versionCodes,
@@ -593,15 +608,30 @@ async function updateRollout(client, packageName, track, action, userFraction) {
       (r) => r.status === "inProgress" || r.status === "halted"
     );
     if (!currentRelease) {
-      throw new Error(`No active rollout found on track "${track}"`);
+      throw new GpcError(
+        `No active rollout found on track "${track}"`,
+        "ROLLOUT_NOT_FOUND",
+        1,
+        `There is no in-progress or halted rollout on the "${track}" track. Start a staged rollout first with: gpc releases upload --track ${track} --status inProgress --fraction 0.1`
+      );
     }
     let newStatus;
     let newFraction;
     switch (action) {
       case "increase":
-        if (!userFraction) throw new Error("--to <percentage> is required for rollout increase");
+        if (!userFraction) throw new GpcError(
+          "--to <percentage> is required for rollout increase",
+          "ROLLOUT_MISSING_FRACTION",
+          2,
+          "Specify the target rollout percentage with --to, e.g.: gpc rollout increase --to 0.5"
+        );
         if (userFraction <= 0 || userFraction > 1) {
-          throw new Error("Rollout percentage must be between 0 and 1 (e.g., 0.1 for 10%)");
+          throw new GpcError(
+            "Rollout percentage must be between 0 and 1 (e.g., 0.1 for 10%)",
+            "RELEASE_INVALID_FRACTION",
+            2,
+            "Use a decimal value like 0.1 for 10%, 0.5 for 50%, or 1.0 for 100%."
+          );
         }
         newStatus = "inProgress";
         newFraction = userFraction;
@@ -898,7 +928,12 @@ function diffListings(local, remote) {
 // src/commands/listings.ts
 function validateLanguage(lang) {
   if (!isValidBcp47(lang)) {
-    throw new Error(`Invalid language tag "${lang}". Must be a valid Google Play BCP 47 code.`);
+    throw new GpcError(
+      `Invalid language tag "${lang}". Must be a valid Google Play BCP 47 code.`,
+      "LISTING_INVALID_LANGUAGE",
+      2,
+      "Use a valid BCP 47 language code such as en-US, de-DE, or ja-JP. See the Google Play Console for supported language codes."
+    );
   }
 }
 async function getListings(client, packageName, language) {
@@ -963,7 +998,12 @@ async function pullListings(client, packageName, dir) {
 async function pushListings(client, packageName, dir, options) {
   const localListings = await readListingsFromDir(dir);
   if (localListings.length === 0) {
-    throw new Error(`No listings found in directory "${dir}"`);
+    throw new GpcError(
+      `No listings found in directory "${dir}"`,
+      "LISTING_DIR_EMPTY",
+      1,
+      `The directory must contain subdirectories named by language code (e.g., en-US/) with listing metadata files. Pull existing listings first with: gpc listings pull --dir "${dir}"`
+    );
   }
   for (const listing of localListings) {
     validateLanguage(listing.language);
@@ -1009,7 +1049,12 @@ async function uploadImage(client, packageName, language, imageType, filePath) {
   validateLanguage(language);
   const imageCheck = await validateImage(filePath, imageType);
   if (!imageCheck.valid) {
-    throw new Error(`Image validation failed: ${imageCheck.errors.join("; ")}`);
+    throw new GpcError(
+      `Image validation failed: ${imageCheck.errors.join("; ")}`,
+      "IMAGE_INVALID",
+      2,
+      "Check image dimensions, file size, and format. Google Play requires PNG or JPEG images within specific size limits per image type."
+    );
   }
   if (imageCheck.warnings.length > 0) {
     for (const w of imageCheck.warnings) {
@@ -1041,6 +1086,19 @@ async function deleteImage(client, packageName, language, imageType, imageId) {
     throw error;
   }
 }
+async function diffListingsCommand(client, packageName, dir) {
+  const localListings = await readListingsFromDir(dir);
+  const edit = await client.edits.insert(packageName);
+  try {
+    const remoteListings = await client.listings.list(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    return diffListings(localListings, remoteListings);
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
 async function getCountryAvailability(client, packageName, track) {
   const edit = await client.edits.insert(packageName);
   try {
@@ -1076,7 +1134,12 @@ async function readReleaseNotesFromDir(dir) {
   try {
     entries = await readdir2(dir);
   } catch {
-    throw new Error(`Release notes directory not found: ${dir}`);
+    throw new GpcError(
+      `Release notes directory not found: ${dir}`,
+      "RELEASE_NOTES_DIR_NOT_FOUND",
+      1,
+      `Create the directory and add .txt files named by language code (e.g., en-US.txt). Path: ${dir}`
+    );
   }
   const notes = [];
   for (const entry of entries) {
@@ -1273,12 +1336,20 @@ async function getReview(client, packageName, reviewId, translationLanguage) {
 var MAX_REPLY_LENGTH = 350;
 async function replyToReview(client, packageName, reviewId, replyText) {
   if (replyText.length > MAX_REPLY_LENGTH) {
-    throw new Error(
-      `Reply text exceeds ${MAX_REPLY_LENGTH} characters (${replyText.length}). Google Play limits replies to ${MAX_REPLY_LENGTH} characters.`
+    throw new GpcError(
+      `Reply text exceeds ${MAX_REPLY_LENGTH} characters (${replyText.length}). Google Play limits replies to ${MAX_REPLY_LENGTH} characters.`,
+      "REVIEW_REPLY_TOO_LONG",
+      2,
+      `Shorten your reply to ${MAX_REPLY_LENGTH} characters or fewer. Current length: ${replyText.length}.`
     );
   }
   if (replyText.length === 0) {
-    throw new Error("Reply text cannot be empty.");
+    throw new GpcError(
+      "Reply text cannot be empty.",
+      "REVIEW_REPLY_EMPTY",
+      2,
+      "Provide a non-empty reply text with --text or -t."
+    );
   }
   return client.reviews.reply(packageName, reviewId, replyText);
 }
@@ -1611,7 +1682,12 @@ async function syncInAppProducts(client, packageName, dir, options) {
     try {
       localProducts.push(JSON.parse(content));
     } catch {
-      throw new Error(`Failed to parse ${file}: invalid JSON`);
+      throw new GpcError(
+        `Failed to parse ${file}: invalid JSON`,
+        "IAP_INVALID_JSON",
+        1,
+        `Check that "${file}" contains valid JSON. You can validate it with: cat "${file}" | jq .`
+      );
     }
   }
   const response = await client.inappproducts.list(packageName);
@@ -1745,12 +1821,22 @@ function isValidStatsDimension(dim) {
 function parseMonth(monthStr) {
   const match = /^(\d{4})-(\d{2})$/.exec(monthStr);
   if (!match) {
-    throw new Error(`Invalid month format "${monthStr}". Expected YYYY-MM (e.g., 2026-03).`);
+    throw new GpcError(
+      `Invalid month format "${monthStr}". Expected YYYY-MM (e.g., 2026-03).`,
+      "REPORT_INVALID_MONTH",
+      2,
+      "Use the format YYYY-MM, for example: --month 2026-03"
+    );
   }
   const year = Number(match[1]);
   const month = Number(match[2]);
   if (month < 1 || month > 12) {
-    throw new Error(`Invalid month "${month}". Must be between 01 and 12.`);
+    throw new GpcError(
+      `Invalid month "${month}". Must be between 01 and 12.`,
+      "REPORT_INVALID_MONTH",
+      2,
+      "The month value must be between 01 and 12."
+    );
   }
   return { year, month };
 }
@@ -1760,21 +1846,31 @@ async function listReports(client, packageName, reportType, year, month) {
 }
 async function downloadReport(client, packageName, reportType, year, month) {
   const reports = await listReports(client, packageName, reportType, year, month);
+  const monthPadded = String(month).padStart(2, "0");
   if (reports.length === 0) {
-    throw new Error(
-      `No ${reportType} reports found for ${year}-${String(month).padStart(2, "0")}.`
+    throw new GpcError(
+      `No ${reportType} reports found for ${year}-${monthPadded}.`,
+      "REPORT_NOT_FOUND",
+      1,
+      `Reports may not be available yet for this period. Financial reports are typically available a few days after the month ends. Try a different month or report type.`
     );
   }
   const bucket = reports[0];
   if (!bucket) {
-    throw new Error(
-      `No ${reportType} reports found for ${year}-${String(month).padStart(2, "0")}.`
+    throw new GpcError(
+      `No ${reportType} reports found for ${year}-${monthPadded}.`,
+      "REPORT_NOT_FOUND",
+      1,
+      `Reports may not be available yet for this period. Try a different month or report type.`
     );
   }
   const uri = bucket.uri;
   const response = await fetch(uri);
   if (!response.ok) {
-    throw new Error(`Failed to download report from signed URI: HTTP ${response.status}`);
+    throw new NetworkError(
+      `Failed to download report from signed URI: HTTP ${response.status}`,
+      "The signed download URL may have expired. Retry the command to generate a fresh URL."
+    );
   }
   return response.text();
 }
@@ -1825,8 +1921,11 @@ async function removeUser(client, developerId, userId) {
 function parseGrantArg(grantStr) {
   const colonIdx = grantStr.indexOf(":");
   if (colonIdx === -1) {
-    throw new Error(
-      `Invalid grant format "${grantStr}". Expected <packageName>:<PERMISSION>[,<PERMISSION>...]`
+    throw new GpcError(
+      `Invalid grant format "${grantStr}". Expected <packageName>:<PERMISSION>[,<PERMISSION>...]`,
+      "USER_INVALID_GRANT",
+      2,
+      "Use the format: com.example.app:VIEW_APP_INFORMATION,MANAGE_STORE_LISTING"
     );
   }
   const packageName = grantStr.slice(0, colonIdx);
@@ -1887,12 +1986,368 @@ async function importTestersFromCsv(client, packageName, track, csvPath) {
   const content = await readFile5(csvPath, "utf-8");
   const emails = content.split(/[,\n\r]+/).map((e) => e.trim()).filter((e) => e.length > 0 && e.includes("@"));
   if (emails.length === 0) {
-    throw new Error(`No valid email addresses found in ${csvPath}.`);
+    throw new GpcError(
+      `No valid email addresses found in ${csvPath}.`,
+      "TESTER_NO_EMAILS",
+      1,
+      "The CSV file must contain email addresses separated by commas or newlines. Each email must contain an @ symbol."
+    );
   }
   const testers = await addTesters(client, packageName, track, emails);
   return { added: emails.length, testers };
 }
 
+// src/utils/git-notes.ts
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+var execFile = promisify(execFileCb);
+var COMMIT_TYPE_HEADERS = {
+  feat: "New",
+  fix: "Fixed",
+  perf: "Improved"
+};
+var DEFAULT_MAX_LENGTH = 500;
+function parseConventionalCommit(subject) {
+  const match = subject.match(/^(\w+)(?:\([^)]*\))?:\s*(.+)$/);
+  if (match) {
+    return { type: match[1], message: match[2].trim() };
+  }
+  return { type: "other", message: subject.trim() };
+}
+function formatNotes(commits, maxLength) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const header = COMMIT_TYPE_HEADERS[commit.type] || "Changes";
+    if (!groups.has(header)) {
+      groups.set(header, []);
+    }
+    groups.get(header).push(commit.message);
+  }
+  const order = ["New", "Fixed", "Improved", "Changes"];
+  const sections = [];
+  for (const header of order) {
+    const items = groups.get(header);
+    if (!items || items.length === 0) continue;
+    const bullets = items.map((m) => `\u2022 ${m}`).join("\n");
+    sections.push(`${header}:
+${bullets}`);
+  }
+  let text = sections.join("\n\n");
+  if (text.length > maxLength) {
+    text = text.slice(0, maxLength - 3) + "...";
+  }
+  return text;
+}
+async function gitExec(args) {
+  try {
+    const { stdout } = await execFile("git", args);
+    return stdout.trim();
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      throw new GpcError(
+        "git is not available on this system",
+        "GIT_NOT_FOUND",
+        1,
+        "Install git and ensure it is in your PATH."
+      );
+    }
+    throw error;
+  }
+}
+async function generateNotesFromGit(options) {
+  const language = options?.language || "en-US";
+  const maxLength = options?.maxLength ?? DEFAULT_MAX_LENGTH;
+  let since = options?.since;
+  if (!since) {
+    try {
+      since = await gitExec(["describe", "--tags", "--abbrev=0"]);
+    } catch (e) {
+      if (e instanceof GpcError && e.code === "GIT_NOT_FOUND") throw e;
+      throw new GpcError(
+        "No git tags found. Cannot determine commit range for release notes.",
+        "GIT_NO_TAGS",
+        1,
+        "Create a tag first (e.g., git tag v1.0.0) or use --since <ref> to specify a starting point."
+      );
+    }
+  }
+  let logOutput;
+  try {
+    logOutput = await gitExec(["log", `${since}..HEAD`, "--format=%s"]);
+  } catch (error) {
+    const err = error;
+    const msg = err.stderr || err.message || String(error);
+    throw new GpcError(
+      `Failed to read git log from "${since}": ${msg}`,
+      "GIT_LOG_FAILED",
+      1,
+      `Verify that "${since}" is a valid git ref (tag, branch, or SHA).`
+    );
+  }
+  if (!logOutput) {
+    return {
+      language,
+      text: "No changes since last release.",
+      commitCount: 0,
+      since
+    };
+  }
+  const subjects = logOutput.split("\n").filter((line) => line.length > 0);
+  const commits = subjects.map(parseConventionalCommit);
+  const text = formatNotes(commits, maxLength);
+  return {
+    language,
+    text,
+    commitCount: subjects.length,
+    since
+  };
+}
+
+// src/commands/app-recovery.ts
+async function listRecoveryActions(client, packageName) {
+  return client.appRecovery.list(packageName);
+}
+async function cancelRecoveryAction(client, packageName, recoveryId) {
+  return client.appRecovery.cancel(packageName, recoveryId);
+}
+async function deployRecoveryAction(client, packageName, recoveryId) {
+  return client.appRecovery.deploy(packageName, recoveryId);
+}
+async function createRecoveryAction(client, packageName, request) {
+  return client.appRecovery.create(packageName, request);
+}
+async function addRecoveryTargeting(client, packageName, actionId, targeting) {
+  return client.appRecovery.addTargeting(packageName, actionId, targeting);
+}
+
+// src/commands/data-safety.ts
+import { readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
+async function getDataSafety(client, packageName) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const dataSafety = await client.dataSafety.get(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    return dataSafety;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function updateDataSafety(client, packageName, data) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const result = await client.dataSafety.update(packageName, edit.id, data);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return result;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function exportDataSafety(client, packageName, outputPath) {
+  const dataSafety = await getDataSafety(client, packageName);
+  await writeFile2(outputPath, JSON.stringify(dataSafety, null, 2) + "\n", "utf-8");
+  return dataSafety;
+}
+async function importDataSafety(client, packageName, filePath) {
+  const content = await readFile6(filePath, "utf-8");
+  let data;
+  try {
+    data = JSON.parse(content);
+  } catch {
+    throw new Error(`Failed to parse data safety JSON from "${filePath}"`);
+  }
+  return updateDataSafety(client, packageName, data);
+}
+
+// src/commands/external-transactions.ts
+async function createExternalTransaction(client, packageName, data) {
+  return client.externalTransactions.create(packageName, data);
+}
+async function getExternalTransaction(client, packageName, transactionId) {
+  return client.externalTransactions.get(packageName, transactionId);
+}
+async function refundExternalTransaction(client, packageName, transactionId, refundData) {
+  return client.externalTransactions.refund(packageName, transactionId, refundData);
+}
+
+// src/commands/device-tiers.ts
+async function listDeviceTiers(client, packageName) {
+  if (!packageName) {
+    throw new GpcError(
+      "Package name is required",
+      "MISSING_PACKAGE_NAME",
+      2,
+      "Provide a package name with --app or set it in config."
+    );
+  }
+  return client.deviceTiers.list(packageName);
+}
+async function getDeviceTier(client, packageName, configId) {
+  if (!packageName) {
+    throw new GpcError(
+      "Package name is required",
+      "MISSING_PACKAGE_NAME",
+      2,
+      "Provide a package name with --app or set it in config."
+    );
+  }
+  if (!configId) {
+    throw new GpcError(
+      "Config ID is required",
+      "MISSING_CONFIG_ID",
+      2,
+      "Provide a device tier config ID."
+    );
+  }
+  return client.deviceTiers.get(packageName, configId);
+}
+async function createDeviceTier(client, packageName, config) {
+  if (!packageName) {
+    throw new GpcError(
+      "Package name is required",
+      "MISSING_PACKAGE_NAME",
+      2,
+      "Provide a package name with --app or set it in config."
+    );
+  }
+  if (!config || !config.deviceGroups || config.deviceGroups.length === 0) {
+    throw new GpcError(
+      "Device tier config must include at least one device group",
+      "INVALID_DEVICE_TIER_CONFIG",
+      2,
+      "Provide a valid config with deviceGroups."
+    );
+  }
+  return client.deviceTiers.create(packageName, config);
+}
+
+// src/commands/one-time-products.ts
+async function listOneTimeProducts(client, packageName) {
+  try {
+    return await client.oneTimeProducts.list(packageName);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to list one-time products: ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_LIST_FAILED",
+      4,
+      "Check your package name and API credentials."
+    );
+  }
+}
+async function getOneTimeProduct(client, packageName, productId) {
+  try {
+    return await client.oneTimeProducts.get(packageName, productId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to get one-time product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_GET_FAILED",
+      4,
+      "Check that the product ID exists."
+    );
+  }
+}
+async function createOneTimeProduct(client, packageName, data) {
+  try {
+    return await client.oneTimeProducts.create(packageName, data);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to create one-time product: ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_CREATE_FAILED",
+      4,
+      "Verify the product data and ensure the product ID is unique."
+    );
+  }
+}
+async function updateOneTimeProduct(client, packageName, productId, data) {
+  try {
+    return await client.oneTimeProducts.update(packageName, productId, data);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to update one-time product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_UPDATE_FAILED",
+      4,
+      "Check that the product ID exists and the data is valid."
+    );
+  }
+}
+async function deleteOneTimeProduct(client, packageName, productId) {
+  try {
+    await client.oneTimeProducts.delete(packageName, productId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to delete one-time product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_DELETE_FAILED",
+      4,
+      "Check that the product ID exists and is not active."
+    );
+  }
+}
+async function listOneTimeOffers(client, packageName, productId) {
+  try {
+    return await client.oneTimeProducts.listOffers(packageName, productId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to list offers for product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_OFFERS_LIST_FAILED",
+      4,
+      "Check the product ID and your API credentials."
+    );
+  }
+}
+async function getOneTimeOffer(client, packageName, productId, offerId) {
+  try {
+    return await client.oneTimeProducts.getOffer(packageName, productId, offerId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to get offer "${offerId}" for product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_OFFER_GET_FAILED",
+      4,
+      "Check that the product and offer IDs exist."
+    );
+  }
+}
+async function createOneTimeOffer(client, packageName, productId, data) {
+  try {
+    return await client.oneTimeProducts.createOffer(packageName, productId, data);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to create offer for product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_OFFER_CREATE_FAILED",
+      4,
+      "Verify the offer data and ensure the offer ID is unique."
+    );
+  }
+}
+async function updateOneTimeOffer(client, packageName, productId, offerId, data) {
+  try {
+    return await client.oneTimeProducts.updateOffer(packageName, productId, offerId, data);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to update offer "${offerId}" for product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_OFFER_UPDATE_FAILED",
+      4,
+      "Check that the product and offer IDs exist and the data is valid."
+    );
+  }
+}
+async function deleteOneTimeOffer(client, packageName, productId, offerId) {
+  try {
+    await client.oneTimeProducts.deleteOffer(packageName, productId, offerId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to delete offer "${offerId}" for product "${productId}": ${error instanceof Error ? error.message : String(error)}`,
+      "OTP_OFFER_DELETE_FAILED",
+      4,
+      "Check that the product and offer IDs exist."
+    );
+  }
+}
+
 // src/utils/safe-path.ts
 import { resolve, normalize } from "path";
 function safePath(userPath) {
@@ -1902,13 +2357,58 @@ function safePathWithin(userPath, baseDir) {
   const resolved = safePath(userPath);
   const base = safePath(baseDir);
   if (!resolved.startsWith(base + "/") && resolved !== base) {
-    throw new Error(`Path "${userPath}" resolves outside the expected directory "${baseDir}"`);
+    throw new GpcError(
+      `Path "${userPath}" resolves outside the expected directory "${baseDir}"`,
+      "PATH_TRAVERSAL",
+      2,
+      "The path must stay within the target directory. Remove any ../ segments or use an absolute path within the expected directory."
+    );
   }
   return resolved;
 }
 
+// src/utils/sort.ts
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function compare(a, b) {
+  if (a === void 0 && b === void 0) return 0;
+  if (a === void 0) return 1;
+  if (b === void 0) return -1;
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  return String(a).localeCompare(String(b));
+}
+function sortResults(items, sortSpec) {
+  if (!sortSpec || items.length === 0) {
+    return items;
+  }
+  const descending = sortSpec.startsWith("-");
+  const field = descending ? sortSpec.slice(1) : sortSpec;
+  const hasField = items.some((item) => getNestedValue(item, field) !== void 0);
+  if (!hasField) {
+    return items;
+  }
+  const sorted = [...items].sort((a, b) => {
+    const aVal = getNestedValue(a, field);
+    const bVal = getNestedValue(b, field);
+    const result = compare(aVal, bVal);
+    return descending ? -result : result;
+  });
+  return sorted;
+}
+
 // src/commands/plugin-scaffold.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
 import { join as join4 } from "path";
 async function scaffoldPlugin(options) {
   const { name, dir, description = `GPC plugin: ${name}` } = options;
@@ -1951,7 +2451,7 @@ async function scaffoldPlugin(options) {
       vitest: "^3.0.0"
     }
   };
-  await writeFile2(join4(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+  await writeFile3(join4(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
   files.push("package.json");
   const tsconfig = {
     compilerOptions: {
@@ -1967,7 +2467,7 @@ async function scaffoldPlugin(options) {
     },
     include: ["src"]
   };
-  await writeFile2(join4(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+  await writeFile3(join4(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
   files.push("tsconfig.json");
   const srcContent = `import { definePlugin } from "@gpc-cli/plugin-sdk";
 import type { CommandEvent, CommandResult } from "@gpc-cli/plugin-sdk";
@@ -2000,7 +2500,7 @@ export const plugin = definePlugin({
   },
 });
 `;
-  await writeFile2(join4(srcDir, "index.ts"), srcContent);
+  await writeFile3(join4(srcDir, "index.ts"), srcContent);
   files.push("src/index.ts");
   const testContent = `import { describe, it, expect, vi } from "vitest";
 import { plugin } from "../src/index";
@@ -2025,7 +2525,7 @@ describe("${pluginName}", () => {
   });
 });
 `;
-  await writeFile2(join4(testDir, "plugin.test.ts"), testContent);
+  await writeFile3(join4(testDir, "plugin.test.ts"), testContent);
   files.push("tests/plugin.test.ts");
   return { dir, files };
 }
@@ -2078,6 +2578,186 @@ function createAuditEntry(command, args, app) {
     args
   };
 }
+
+// src/utils/webhooks.ts
+function formatSlackPayload(payload) {
+  const status = payload.success ? "\u2713" : "\u2717";
+  const color = payload.success ? "#2eb886" : "#e01e5a";
+  const durationSec = (payload.duration / 1e3).toFixed(1);
+  const fields = [
+    { title: "Command", value: payload.command, short: true },
+    { title: "Duration", value: `${durationSec}s`, short: true }
+  ];
+  if (payload.app) {
+    fields.push({ title: "App", value: payload.app, short: true });
+  }
+  if (payload.error) {
+    fields.push({ title: "Error", value: payload.error, short: false });
+  }
+  if (payload.details) {
+    for (const [key, value] of Object.entries(payload.details)) {
+      fields.push({ title: key, value: String(value), short: true });
+    }
+  }
+  return {
+    attachments: [
+      {
+        color,
+        fallback: `GPC: ${payload.command} ${status}`,
+        title: `GPC: ${payload.command} ${status}`,
+        fields,
+        footer: "GPC CLI",
+        ts: Math.floor(Date.now() / 1e3)
+      }
+    ]
+  };
+}
+function formatDiscordPayload(payload) {
+  const status = payload.success ? "\u2713" : "\u2717";
+  const color = payload.success ? 3061894 : 14687834;
+  const durationSec = (payload.duration / 1e3).toFixed(1);
+  const fields = [
+    { name: "Command", value: payload.command, inline: true },
+    { name: "Duration", value: `${durationSec}s`, inline: true }
+  ];
+  if (payload.app) {
+    fields.push({ name: "App", value: payload.app, inline: true });
+  }
+  if (payload.error) {
+    fields.push({ name: "Error", value: payload.error, inline: false });
+  }
+  if (payload.details) {
+    for (const [key, value] of Object.entries(payload.details)) {
+      fields.push({ name: key, value: String(value), inline: true });
+    }
+  }
+  return {
+    embeds: [
+      {
+        title: `GPC: ${payload.command} ${status}`,
+        color,
+        fields,
+        footer: { text: "GPC CLI" },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+}
+function formatCustomPayload(payload) {
+  return { ...payload };
+}
+var FORMATTERS = {
+  slack: formatSlackPayload,
+  discord: formatDiscordPayload,
+  custom: formatCustomPayload
+};
+var WEBHOOK_TIMEOUT_MS = 5e3;
+async function sendSingle(url, body) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), WEBHOOK_TIMEOUT_MS);
+  try {
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function sendWebhook(config, payload, target) {
+  try {
+    const targets = target ? [target] : Object.keys(FORMATTERS);
+    const promises = [];
+    for (const t of targets) {
+      const url = config[t];
+      if (!url) continue;
+      const formatter = FORMATTERS[t];
+      if (!formatter) continue;
+      const body = formatter(payload);
+      promises.push(sendSingle(url, body).catch(() => {
+      }));
+    }
+    await Promise.all(promises);
+  } catch {
+  }
+}
+
+// src/commands/internal-sharing.ts
+import { extname as extname4 } from "path";
+async function uploadInternalSharing(client, packageName, filePath, fileType) {
+  const resolvedType = fileType ?? detectFileType(filePath);
+  const validation = await validateUploadFile(filePath);
+  if (!validation.valid) {
+    throw new GpcError(
+      `File validation failed:
+${validation.errors.join("\n")}`,
+      "INTERNAL_SHARING_INVALID_FILE",
+      2,
+      "Check that the file is a valid AAB or APK and is not corrupted."
+    );
+  }
+  let artifact;
+  if (resolvedType === "bundle") {
+    artifact = await client.internalAppSharing.uploadBundle(packageName, filePath);
+  } else {
+    artifact = await client.internalAppSharing.uploadApk(packageName, filePath);
+  }
+  return {
+    downloadUrl: artifact.downloadUrl,
+    sha256: artifact.sha256,
+    certificateFingerprint: artifact.certificateFingerprint,
+    fileType: resolvedType
+  };
+}
+function detectFileType(filePath) {
+  const ext = extname4(filePath).toLowerCase();
+  if (ext === ".aab") return "bundle";
+  if (ext === ".apk") return "apk";
+  throw new GpcError(
+    `Cannot detect file type from extension "${ext}". Use --type to specify bundle or apk.`,
+    "INTERNAL_SHARING_UNKNOWN_TYPE",
+    2,
+    "Use --type bundle for .aab files or --type apk for .apk files."
+  );
+}
+
+// src/commands/generated-apks.ts
+import { writeFile as writeFile4 } from "fs/promises";
+async function listGeneratedApks(client, packageName, versionCode) {
+  if (!Number.isInteger(versionCode) || versionCode <= 0) {
+    throw new GpcError(
+      `Invalid version code: ${versionCode}`,
+      "GENERATED_APKS_INVALID_VERSION",
+      2,
+      "Provide a positive integer version code."
+    );
+  }
+  return client.generatedApks.list(packageName, versionCode);
+}
+async function downloadGeneratedApk(client, packageName, versionCode, apkId, outputPath) {
+  if (!Number.isInteger(versionCode) || versionCode <= 0) {
+    throw new GpcError(
+      `Invalid version code: ${versionCode}`,
+      "GENERATED_APKS_INVALID_VERSION",
+      2,
+      "Provide a positive integer version code."
+    );
+  }
+  if (!apkId) {
+    throw new GpcError(
+      "APK ID is required",
+      "GENERATED_APKS_MISSING_ID",
+      2,
+      "Provide the generated APK ID. Use 'gpc generated-apks list <version-code>' to see available APKs."
+    );
+  }
+  const buffer = await client.generatedApks.download(packageName, versionCode, apkId);
+  const bytes = new Uint8Array(buffer);
+  await writeFile4(outputPath, bytes);
+  return { path: outputPath, sizeBytes: bytes.byteLength };
+}
 export {
   ApiError,
   ConfigError,
@@ -2089,15 +2769,22 @@ export {
   acknowledgeProductPurchase,
   activateBasePlan,
   activateOffer,
+  addRecoveryTargeting,
   addTesters,
+  cancelRecoveryAction,
   cancelSubscriptionPurchase,
   checkThreshold,
   compareVitalsTrend,
   consumeProductPurchase,
   convertRegionPrices,
   createAuditEntry,
+  createDeviceTier,
+  createExternalTransaction,
   createInAppProduct,
   createOffer,
+  createOneTimeOffer,
+  createOneTimeProduct,
+  createRecoveryAction,
   createSubscription,
   deactivateBasePlan,
   deactivateOffer,
@@ -2107,18 +2794,33 @@ export {
   deleteInAppProduct,
   deleteListing,
   deleteOffer,
+  deleteOneTimeOffer,
+  deleteOneTimeProduct,
   deleteSubscription,
+  deployRecoveryAction,
   detectOutputFormat,
   diffListings,
+  diffListingsCommand,
   discoverPlugins,
+  downloadGeneratedApk,
   downloadReport,
+  exportDataSafety,
   exportReviews,
+  formatCustomPayload,
+  formatDiscordPayload,
   formatOutput,
+  formatSlackPayload,
+  generateNotesFromGit,
   getAppInfo,
   getCountryAvailability,
+  getDataSafety,
+  getDeviceTier,
+  getExternalTransaction,
   getInAppProduct,
   getListings,
   getOffer,
+  getOneTimeOffer,
+  getOneTimeProduct,
   getProductPurchase,
   getReleasesStatus,
   getReview,
@@ -2133,6 +2835,7 @@ export {
   getVitalsOverview,
   getVitalsRendering,
   getVitalsStartup,
+  importDataSafety,
   importTestersFromCsv,
   initAudit,
   inviteUser,
@@ -2141,9 +2844,14 @@ export {
   isValidBcp47,
   isValidReportType,
   isValidStatsDimension,
+  listDeviceTiers,
+  listGeneratedApks,
   listImages,
   listInAppProducts,
   listOffers,
+  listOneTimeOffers,
+  listOneTimeProducts,
+  listRecoveryActions,
   listReports,
   listReviews,
   listSubscriptions,
@@ -2161,6 +2869,7 @@ export {
   readListingsFromDir,
   readReleaseNotesFromDir,
   redactSensitive,
+  refundExternalTransaction,
   refundOrder,
   removeTesters,
   removeUser,
@@ -2170,15 +2879,21 @@ export {
   safePathWithin,
   scaffoldPlugin,
   searchVitalsErrors,
+  sendWebhook,
+  sortResults,
   syncInAppProducts,
   updateAppDetails,
+  updateDataSafety,
   updateInAppProduct,
   updateListing,
   updateOffer,
+  updateOneTimeOffer,
+  updateOneTimeProduct,
   updateRollout,
   updateSubscription,
   updateUser,
   uploadImage,
+  uploadInternalSharing,
   uploadRelease,
   validateImage,
   validatePreSubmission,