@gpc-cli/core 0.9.7 → 0.9.9

package/dist/index.js

@@ -54,6 +54,8 @@ function formatOutput(data, format, redact = true) {
       return formatMarkdown(safe);
     case "table":
       return formatTable(safe);
+    case "junit":
+      return formatJunit(safe);
     default:
       return formatJson(safe);
   }
@@ -182,6 +184,73 @@ function toRows(data) {
   }
   return [];
 }
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function toTestCases(data, commandName) {
+  const cases = [];
+  let failures = 0;
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      const tc = buildTestCase(item, commandName);
+      cases.push(tc.xml);
+      if (tc.failed) failures++;
+    }
+  } else if (typeof data === "object" && data !== null) {
+    const tc = buildTestCase(data, commandName);
+    cases.push(tc.xml);
+    if (tc.failed) failures++;
+  } else if (typeof data === "string") {
+    cases.push(
+      `    <testcase name="${escapeXml(data)}" classname="gpc.${escapeXml(commandName)}" />`
+    );
+  }
+  return { cases, failures };
+}
+function buildTestCase(item, commandName) {
+  if (typeof item !== "object" || item === null) {
+    const text = String(item);
+    return {
+      xml: `    <testcase name="${escapeXml(text)}" classname="gpc.${escapeXml(commandName)}" />`,
+      failed: false
+    };
+  }
+  const record = item;
+  const name = escapeXml(
+    String(record["name"] ?? record["title"] ?? record["sku"] ?? record["id"] ?? JSON.stringify(item))
+  );
+  const classname = `gpc.${escapeXml(commandName)}`;
+  const breached = record["breached"];
+  if (breached === true) {
+    const message = escapeXml(String(record["message"] ?? "threshold breached"));
+    const details = escapeXml(
+      String(record["details"] ?? record["metric"] ?? JSON.stringify(item))
+    );
+    return {
+      xml: `    <testcase name="${name}" classname="${classname}">
+      <failure message="${message}">${details}</failure>
+    </testcase>`,
+      failed: true
+    };
+  }
+  return {
+    xml: `    <testcase name="${name}" classname="${classname}" />`,
+    failed: false
+  };
+}
+function formatJunit(data, commandName = "command") {
+  const { cases, failures } = toTestCases(data, commandName);
+  const tests = cases.length;
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<testsuites name="gpc" tests="${tests}" failures="${failures}" time="0">`,
+    `  <testsuite name="${escapeXml(commandName)}" tests="${tests}" failures="${failures}">`,
+    ...cases,
+    "  </testsuite>",
+    "</testsuites>"
+  ];
+  return lines.join("\n");
+}
 
 // src/plugins.ts
 var PluginManager = class {
@@ -682,6 +751,90 @@ async function listTracks(client, packageName) {
     throw error;
   }
 }
+async function createTrack(client, packageName, trackName) {
+  if (!trackName || trackName.trim().length === 0) {
+    throw new GpcError(
+      "Track name must not be empty",
+      "TRACK_INVALID_NAME",
+      2,
+      "Provide a valid custom track name, e.g.: gpc tracks create my-qa-track"
+    );
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const track = await client.tracks.create(packageName, edit.id, trackName);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return track;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function updateTrackConfig(client, packageName, trackName, config) {
+  if (!trackName || trackName.trim().length === 0) {
+    throw new GpcError(
+      "Track name must not be empty",
+      "TRACK_INVALID_NAME",
+      2,
+      "Provide a valid track name."
+    );
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const release = {
+      versionCodes: config["versionCodes"] || [],
+      status: config["status"] || "completed"
+    };
+    if (config["userFraction"] !== void 0) {
+      release.userFraction = config["userFraction"];
+    }
+    if (config["releaseNotes"]) {
+      release.releaseNotes = config["releaseNotes"];
+    }
+    if (config["name"]) {
+      release.name = config["name"];
+    }
+    const track = await client.tracks.update(packageName, edit.id, trackName, release);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return track;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function uploadExternallyHosted(client, packageName, data) {
+  if (!data.externallyHostedUrl) {
+    throw new GpcError(
+      "externallyHostedUrl is required",
+      "EXTERNAL_APK_MISSING_URL",
+      2,
+      "Provide a valid URL for the externally hosted APK."
+    );
+  }
+  if (!data.packageName) {
+    throw new GpcError(
+      "packageName is required in externally hosted APK data",
+      "EXTERNAL_APK_MISSING_PACKAGE",
+      2,
+      "Include the packageName field in the APK configuration."
+    );
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const result = await client.apks.addExternallyHosted(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;
+  }
+}
 
 // src/utils/bcp47.ts
 var GOOGLE_PLAY_LANGUAGES = [
@@ -1111,6 +1264,75 @@ async function getCountryAvailability(client, packageName, track) {
     throw error;
   }
 }
+var ALL_IMAGE_TYPES = [
+  "phoneScreenshots",
+  "sevenInchScreenshots",
+  "tenInchScreenshots",
+  "tvScreenshots",
+  "wearScreenshots",
+  "icon",
+  "featureGraphic",
+  "tvBanner"
+];
+async function exportImages(client, packageName, dir, options) {
+  const { mkdir: mkdir5, writeFile: writeFile6 } = await import("fs/promises");
+  const { join: join7 } = await import("path");
+  const edit = await client.edits.insert(packageName);
+  try {
+    let languages;
+    if (options?.lang) {
+      validateLanguage(options.lang);
+      languages = [options.lang];
+    } else {
+      const listings = await client.listings.list(packageName, edit.id);
+      languages = listings.map((l) => l.language);
+    }
+    const imageTypes = options?.type ? [options.type] : ALL_IMAGE_TYPES;
+    let totalImages = 0;
+    let totalSize = 0;
+    const tasks = [];
+    for (const language of languages) {
+      for (const imageType of imageTypes) {
+        const images = await client.images.list(packageName, edit.id, language, imageType);
+        for (let i = 0; i < images.length; i++) {
+          const img = images[i];
+          if (img && img.url) {
+            tasks.push({ language, imageType, url: img.url, index: i + 1 });
+          }
+        }
+      }
+    }
+    const concurrency = 5;
+    for (let i = 0; i < tasks.length; i += concurrency) {
+      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 response = await fetch(task.url);
+          const buffer = Buffer.from(await response.arrayBuffer());
+          const filePath = join7(dirPath, `${task.index}.png`);
+          await writeFile6(filePath, buffer);
+          return buffer.length;
+        })
+      );
+      for (const size of results) {
+        totalImages++;
+        totalSize += size;
+      }
+    }
+    await client.edits.delete(packageName, edit.id);
+    return {
+      languages: languages.length,
+      images: totalImages,
+      totalSize
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
 async function updateAppDetails(client, packageName, details) {
   const edit = await client.edits.insert(packageName);
   try {
@@ -1125,14 +1347,202 @@ 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";
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectFastlane(cwd) {
+  const result = {
+    hasFastfile: false,
+    hasAppfile: false,
+    hasMetadata: false,
+    hasGemfile: false,
+    lanes: [],
+    metadataLanguages: []
+  };
+  const fastlaneDir = join2(cwd, "fastlane");
+  const hasFastlaneDir = await fileExists(fastlaneDir);
+  const fastfilePath = hasFastlaneDir ? join2(fastlaneDir, "Fastfile") : join2(cwd, "Fastfile");
+  const appfilePath = hasFastlaneDir ? join2(fastlaneDir, "Appfile") : join2(cwd, "Appfile");
+  result.hasFastfile = await fileExists(fastfilePath);
+  result.hasAppfile = await fileExists(appfilePath);
+  result.hasGemfile = await fileExists(join2(cwd, "Gemfile"));
+  const metadataDir = hasFastlaneDir ? join2(fastlaneDir, "metadata", "android") : join2(cwd, "metadata", "android");
+  result.hasMetadata = await fileExists(metadataDir);
+  if (result.hasMetadata) {
+    try {
+      const entries = await readdir2(metadataDir, { withFileTypes: true });
+      result.metadataLanguages = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+    }
+  }
+  if (result.hasFastfile) {
+    try {
+      const content = await readFile3(fastfilePath, "utf-8");
+      result.lanes = parseFastfile(content);
+    } catch {
+    }
+  }
+  if (result.hasAppfile) {
+    try {
+      const content = await readFile3(appfilePath, "utf-8");
+      const parsed = parseAppfile(content);
+      result.packageName = parsed.packageName;
+      result.jsonKeyPath = parsed.jsonKeyPath;
+    } catch {
+    }
+  }
+  return result;
+}
+function parseFastfile(content) {
+  const lanes = [];
+  const laneRegex = /lane\s+:(\w+)\s+do([\s\S]*?)(?=\bend\b)/g;
+  let match;
+  while ((match = laneRegex.exec(content)) !== null) {
+    const name = match[1] ?? "";
+    const body = match[2] ?? "";
+    const actions = [];
+    const actionRegex = /\b(supply|upload_to_play_store|capture_android_screenshots|deliver|gradle)\b/g;
+    let actionMatch;
+    while ((actionMatch = actionRegex.exec(body)) !== null) {
+      const action = actionMatch[1] ?? "";
+      if (!actions.includes(action)) {
+        actions.push(action);
+      }
+    }
+    const gpcEquivalent = mapLaneToGpc(name, actions, body);
+    lanes.push({ name, actions, gpcEquivalent });
+  }
+  return lanes;
+}
+function mapLaneToGpc(name, actions, body) {
+  if (actions.includes("upload_to_play_store") || actions.includes("supply")) {
+    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}`;
+    }
+    if (trackMatch) {
+      return `gpc releases upload --track ${trackMatch[1]}`;
+    }
+    if (body.match(/skip_upload_apk\s*:\s*true/) || body.match(/skip_upload_aab\s*:\s*true/)) {
+      return "gpc listings push";
+    }
+    return "gpc releases upload";
+  }
+  if (actions.includes("capture_android_screenshots")) {
+    return void 0;
+  }
+  return void 0;
+}
+function parseAppfile(content) {
+  const result = {};
+  const pkgMatch = content.match(/package_name\s*\(?\s*["']([^"']+)["']\s*\)?/);
+  if (pkgMatch) {
+    result.packageName = pkgMatch[1];
+  }
+  const keyMatch = content.match(/json_key_file\s*\(?\s*["']([^"']+)["']\s*\)?/);
+  if (keyMatch) {
+    result.jsonKeyPath = keyMatch[1];
+  }
+  return result;
+}
+function generateMigrationPlan(detection) {
+  const config = {};
+  const checklist = [];
+  const warnings = [];
+  if (detection.packageName) {
+    config["app"] = detection.packageName;
+  } else {
+    checklist.push("Set your package name: gpc config set app <package-name>");
+  }
+  if (detection.jsonKeyPath) {
+    config["auth"] = { serviceAccount: detection.jsonKeyPath };
+  } else {
+    checklist.push("Configure authentication: gpc auth setup");
+  }
+  for (const lane of detection.lanes) {
+    if (lane.gpcEquivalent) {
+      checklist.push(`Replace Fastlane lane "${lane.name}" with: ${lane.gpcEquivalent}`);
+    }
+    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.`
+      );
+    }
+  }
+  if (detection.hasMetadata && detection.metadataLanguages.length > 0) {
+    checklist.push(
+      `Migrate metadata for ${detection.metadataLanguages.length} language(s): gpc listings pull --dir metadata`
+    );
+    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");
+  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");
+  }
+  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);
+  const migrationPath = join2(dir, "MIGRATION.md");
+  const lines = [
+    "# Fastlane to GPC Migration",
+    "",
+    "## Migration Checklist",
+    ""
+  ];
+  for (const item of result.checklist) {
+    lines.push(`- [ ] ${item}`);
+  }
+  if (result.warnings.length > 0) {
+    lines.push("");
+    lines.push("## Warnings");
+    lines.push("");
+    for (const warning of result.warnings) {
+      lines.push(`- ${warning}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Quick Reference");
+  lines.push("");
+  lines.push("| Fastlane | GPC |");
+  lines.push("|----------|-----|");
+  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("");
+  await writeFile2(migrationPath, lines.join("\n"), "utf-8");
+  files.push(migrationPath);
+  return files;
+}
+
 // src/utils/release-notes.ts
-import { readdir as readdir2, readFile as readFile3, stat as stat4 } from "fs/promises";
-import { extname as extname3, basename, join as join2 } from "path";
+import { readdir as readdir3, readFile as readFile4, stat as stat4 } from "fs/promises";
+import { extname as extname3, basename, join as join3 } from "path";
 var MAX_NOTES_LENGTH = 500;
 async function readReleaseNotesFromDir(dir) {
   let entries;
   try {
-    entries = await readdir2(dir);
+    entries = await readdir3(dir);
   } catch {
     throw new GpcError(
       `Release notes directory not found: ${dir}`,
@@ -1145,10 +1555,10 @@ async function readReleaseNotesFromDir(dir) {
   for (const entry of entries) {
     if (extname3(entry) !== ".txt") continue;
     const language = basename(entry, ".txt");
-    const filePath = join2(dir, entry);
+    const filePath = join3(dir, entry);
     const stats = await stat4(filePath);
     if (!stats.isFile()) continue;
-    const text = (await readFile3(filePath, "utf-8")).trim();
+    const text = (await readFile4(filePath, "utf-8")).trim();
     if (text.length === 0) continue;
     notes.push({ language, text });
   }
@@ -1633,8 +2043,8 @@ async function deactivateOffer(client, packageName, productId, basePlanId, offer
 }
 
 // src/commands/iap.ts
-import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
-import { join as join3 } from "path";
+import { readdir as readdir4, readFile as readFile5 } from "fs/promises";
+import { join as join4 } from "path";
 import { paginateAll as paginateAll3 } from "@gpc-cli/api";
 async function listInAppProducts(client, packageName, options) {
   if (options?.limit || options?.nextPage) {
@@ -1671,14 +2081,59 @@ async function deleteInAppProduct(client, packageName, sku) {
   return client.inappproducts.delete(packageName, sku);
 }
 async function syncInAppProducts(client, packageName, dir, options) {
-  const files = await readdir3(dir);
-  const jsonFiles = files.filter((f) => f.endsWith(".json"));
-  if (jsonFiles.length === 0) {
+  const localProducts = await readProductsFromDir(dir);
+  if (localProducts.length === 0) {
     return { created: 0, updated: 0, unchanged: 0, skus: [] };
   }
+  const response = await client.inappproducts.list(packageName);
+  const remoteSkus = new Set((response.inappproduct || []).map((p) => p.sku));
+  const toUpdate = localProducts.filter((p) => remoteSkus.has(p.sku));
+  const toCreate = localProducts.filter((p) => !remoteSkus.has(p.sku));
+  const skus = localProducts.map((p) => p.sku);
+  if (options?.dryRun) {
+    return { created: toCreate.length, updated: toUpdate.length, unchanged: 0, skus };
+  }
+  if (toUpdate.length > 1) {
+    try {
+      await batchUpdateProducts(client, packageName, toUpdate);
+    } catch {
+      for (const product of toUpdate) {
+        await client.inappproducts.update(packageName, product.sku, product);
+      }
+    }
+  } else {
+    for (const product of toUpdate) {
+      await client.inappproducts.update(packageName, product.sku, product);
+    }
+  }
+  for (const product of toCreate) {
+    await client.inappproducts.create(packageName, product);
+  }
+  return { created: toCreate.length, updated: toUpdate.length, unchanged: 0, skus };
+}
+var BATCH_CHUNK_SIZE = 100;
+async function batchUpdateProducts(client, packageName, products) {
+  const results = [];
+  for (let i = 0; i < products.length; i += BATCH_CHUNK_SIZE) {
+    const chunk = products.slice(i, i + BATCH_CHUNK_SIZE);
+    const request = {
+      requests: chunk.map((p) => ({
+        inappproduct: p,
+        packageName,
+        sku: p.sku
+      }))
+    };
+    const response = await client.inappproducts.batchUpdate(packageName, request);
+    results.push(...response.inappproducts || []);
+  }
+  return results;
+}
+async function readProductsFromDir(dir) {
+  const files = await readdir4(dir);
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
   const localProducts = [];
   for (const file of jsonFiles) {
-    const content = await readFile4(join3(dir, file), "utf-8");
+    const content = await readFile5(join4(dir, file), "utf-8");
     try {
       localProducts.push(JSON.parse(content));
     } catch {
@@ -1690,27 +2145,56 @@ async function syncInAppProducts(client, packageName, dir, options) {
       );
     }
   }
+  return localProducts;
+}
+async function batchSyncInAppProducts(client, packageName, dir, options) {
+  const localProducts = await readProductsFromDir(dir);
+  if (localProducts.length === 0) {
+    return { created: 0, updated: 0, unchanged: 0, skus: [], batchUsed: false, batchErrors: 0 };
+  }
   const response = await client.inappproducts.list(packageName);
   const remoteSkus = new Set((response.inappproduct || []).map((p) => p.sku));
-  let created = 0;
-  let updated = 0;
-  const unchanged = 0;
-  const skus = [];
-  for (const product of localProducts) {
-    skus.push(product.sku);
-    if (remoteSkus.has(product.sku)) {
-      if (!options?.dryRun) {
+  const toUpdate = localProducts.filter((p) => remoteSkus.has(p.sku));
+  const toCreate = localProducts.filter((p) => !remoteSkus.has(p.sku));
+  const skus = localProducts.map((p) => p.sku);
+  if (options?.dryRun) {
+    return {
+      created: toCreate.length,
+      updated: toUpdate.length,
+      unchanged: 0,
+      skus,
+      batchUsed: toUpdate.length > 1,
+      batchErrors: 0
+    };
+  }
+  let batchUsed = false;
+  let batchErrors = 0;
+  if (toUpdate.length > 1) {
+    batchUsed = true;
+    try {
+      await batchUpdateProducts(client, packageName, toUpdate);
+    } catch {
+      batchErrors++;
+      for (const product of toUpdate) {
         await client.inappproducts.update(packageName, product.sku, product);
       }
-      updated++;
-    } else {
-      if (!options?.dryRun) {
-        await client.inappproducts.create(packageName, product);
-      }
-      created++;
     }
+  } else {
+    for (const product of toUpdate) {
+      await client.inappproducts.update(packageName, product.sku, product);
+    }
+  }
+  for (const product of toCreate) {
+    await client.inappproducts.create(packageName, product);
   }
-  return { created, updated, unchanged, skus };
+  return {
+    created: toCreate.length,
+    updated: toUpdate.length,
+    unchanged: 0,
+    skus,
+    batchUsed,
+    batchErrors
+  };
 }
 
 // src/commands/purchases.ts
@@ -1934,7 +2418,7 @@ function parseGrantArg(grantStr) {
 }
 
 // src/commands/testers.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 async function listTesters(client, packageName, track) {
   const edit = await client.edits.insert(packageName);
   try {
@@ -1983,7 +2467,7 @@ async function removeTesters(client, packageName, track, groupEmails) {
   }
 }
 async function importTestersFromCsv(client, packageName, track, csvPath) {
-  const content = await readFile5(csvPath, "utf-8");
+  const content = await readFile6(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 GpcError(
@@ -2114,9 +2598,15 @@ async function cancelRecoveryAction(client, 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";
+import { readFile as readFile7, writeFile as writeFile3 } from "fs/promises";
 async function getDataSafety(client, packageName) {
   const edit = await client.edits.insert(packageName);
   try {
@@ -2144,16 +2634,21 @@ async function updateDataSafety(client, packageName, data) {
 }
 async function exportDataSafety(client, packageName, outputPath) {
   const dataSafety = await getDataSafety(client, packageName);
-  await writeFile2(outputPath, JSON.stringify(dataSafety, null, 2) + "\n", "utf-8");
+  await writeFile3(outputPath, JSON.stringify(dataSafety, null, 2) + "\n", "utf-8");
   return dataSafety;
 }
 async function importDataSafety(client, packageName, filePath) {
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   let data;
   try {
     data = JSON.parse(content);
   } catch {
-    throw new Error(`Failed to parse data safety JSON from "${filePath}"`);
+    throw new GpcError(
+      `Failed to parse data safety JSON from "${filePath}"`,
+      "INVALID_JSON",
+      1,
+      "Ensure the file contains valid JSON matching the data safety schema."
+    );
   }
   return updateDataSafety(client, packageName, data);
 }
@@ -2169,6 +2664,251 @@ async function refundExternalTransaction(client, packageName, transactionId, ref
   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/spinner.ts
+import process2 from "process";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var INTERVAL_MS = 80;
+function createSpinner(message) {
+  const isTTY = process2.stderr.isTTY === true;
+  let frameIndex = 0;
+  let timer;
+  let currentMessage = message;
+  let started = false;
+  function clearLine() {
+    if (isTTY) {
+      process2.stderr.write("\r\x1B[K");
+    }
+  }
+  function renderFrame() {
+    const frame = FRAMES[frameIndex % FRAMES.length];
+    process2.stderr.write(`\r\x1B[K${frame} ${currentMessage}`);
+    frameIndex++;
+  }
+  return {
+    start() {
+      if (started) return;
+      started = true;
+      if (!isTTY) {
+        process2.stderr.write(`${currentMessage}
+`);
+        return;
+      }
+      renderFrame();
+      timer = setInterval(renderFrame, INTERVAL_MS);
+    },
+    stop(msg) {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      const text = msg ?? currentMessage;
+      if (isTTY) {
+        clearLine();
+        process2.stderr.write(`\u2714 ${text}
+`);
+      } else if (!started) {
+        process2.stderr.write(`${text}
+`);
+      }
+      started = false;
+    },
+    fail(msg) {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      const text = msg ?? currentMessage;
+      if (isTTY) {
+        clearLine();
+        process2.stderr.write(`\u2718 ${text}
+`);
+      } else if (!started) {
+        process2.stderr.write(`${text}
+`);
+      }
+      started = false;
+    },
+    update(msg) {
+      currentMessage = msg;
+      if (!isTTY || !started) return;
+      renderFrame();
+    }
+  };
+}
+
 // src/utils/safe-path.ts
 import { resolve, normalize } from "path";
 function safePath(userPath) {
@@ -2229,16 +2969,16 @@ function sortResults(items, sortSpec) {
 }
 
 // src/commands/plugin-scaffold.ts
-import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import { join as join4 } from "path";
+import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
 async function scaffoldPlugin(options) {
   const { name, dir, description = `GPC plugin: ${name}` } = options;
   const pluginName = name.startsWith("gpc-plugin-") ? name : `gpc-plugin-${name}`;
   const shortName = pluginName.replace(/^gpc-plugin-/, "");
-  const srcDir = join4(dir, "src");
-  const testDir = join4(dir, "tests");
-  await mkdir2(srcDir, { recursive: true });
-  await mkdir2(testDir, { recursive: true });
+  const srcDir = join5(dir, "src");
+  const testDir = join5(dir, "tests");
+  await mkdir3(srcDir, { recursive: true });
+  await mkdir3(testDir, { recursive: true });
   const files = [];
   const pkg = {
     name: pluginName,
@@ -2272,7 +3012,7 @@ async function scaffoldPlugin(options) {
       vitest: "^3.0.0"
     }
   };
-  await writeFile3(join4(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+  await writeFile4(join5(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
   files.push("package.json");
   const tsconfig = {
     compilerOptions: {
@@ -2288,7 +3028,7 @@ async function scaffoldPlugin(options) {
     },
     include: ["src"]
   };
-  await writeFile3(join4(dir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+  await writeFile4(join5(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";
@@ -2321,7 +3061,7 @@ export const plugin = definePlugin({
   },
 });
 `;
-  await writeFile3(join4(srcDir, "index.ts"), srcContent);
+  await writeFile4(join5(srcDir, "index.ts"), srcContent);
   files.push("src/index.ts");
   const testContent = `import { describe, it, expect, vi } from "vitest";
 import { plugin } from "../src/index";
@@ -2346,14 +3086,14 @@ describe("${pluginName}", () => {
   });
 });
 `;
-  await writeFile3(join4(testDir, "plugin.test.ts"), testContent);
+  await writeFile4(join5(testDir, "plugin.test.ts"), testContent);
   files.push("tests/plugin.test.ts");
   return { dir, files };
 }
 
 // src/audit.ts
-import { appendFile, chmod, mkdir as mkdir3 } from "fs/promises";
-import { join as join5 } from "path";
+import { appendFile, chmod, mkdir as mkdir4 } from "fs/promises";
+import { join as join6 } from "path";
 var auditDir = null;
 function initAudit(configDir) {
   auditDir = configDir;
@@ -2361,8 +3101,8 @@ function initAudit(configDir) {
 async function writeAuditLog(entry) {
   if (!auditDir) return;
   try {
-    await mkdir3(auditDir, { recursive: true, mode: 448 });
-    const logPath = join5(auditDir, "audit.log");
+    await mkdir4(auditDir, { recursive: true, mode: 448 });
+    const logPath = join6(auditDir, "audit.log");
     const redactedEntry = redactAuditArgs(entry);
     const line = JSON.stringify(redactedEntry) + "\n";
     await appendFile(logPath, line, { encoding: "utf-8", mode: 384 });
@@ -2504,6 +3244,143 @@ async function sendWebhook(config, payload, target) {
   } 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 writeFile5 } 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 writeFile5(outputPath, bytes);
+  return { path: outputPath, sizeBytes: bytes.byteLength };
+}
+
+// src/commands/purchase-options.ts
+async function listPurchaseOptions(client, packageName) {
+  try {
+    return await client.purchaseOptions.list(packageName);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to list purchase options: ${error instanceof Error ? error.message : String(error)}`,
+      "PURCHASE_OPTIONS_LIST_FAILED",
+      4,
+      "Check your package name and API permissions."
+    );
+  }
+}
+async function getPurchaseOption(client, packageName, purchaseOptionId) {
+  try {
+    return await client.purchaseOptions.get(packageName, purchaseOptionId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to get purchase option "${purchaseOptionId}": ${error instanceof Error ? error.message : String(error)}`,
+      "PURCHASE_OPTION_GET_FAILED",
+      4,
+      "Check that the purchase option ID exists."
+    );
+  }
+}
+async function createPurchaseOption(client, packageName, data) {
+  try {
+    return await client.purchaseOptions.create(packageName, data);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to create purchase option: ${error instanceof Error ? error.message : String(error)}`,
+      "PURCHASE_OPTION_CREATE_FAILED",
+      4,
+      "Check your purchase option data and API permissions."
+    );
+  }
+}
+async function activatePurchaseOption(client, packageName, purchaseOptionId) {
+  try {
+    return await client.purchaseOptions.activate(packageName, purchaseOptionId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to activate purchase option "${purchaseOptionId}": ${error instanceof Error ? error.message : String(error)}`,
+      "PURCHASE_OPTION_ACTIVATE_FAILED",
+      4,
+      "Check that the purchase option exists and is in a valid state for activation."
+    );
+  }
+}
+async function deactivatePurchaseOption(client, packageName, purchaseOptionId) {
+  try {
+    return await client.purchaseOptions.deactivate(packageName, purchaseOptionId);
+  } catch (error) {
+    throw new GpcError(
+      `Failed to deactivate purchase option "${purchaseOptionId}": ${error instanceof Error ? error.message : String(error)}`,
+      "PURCHASE_OPTION_DEACTIVATE_FAILED",
+      4,
+      "Check that the purchase option exists and is in a valid state for deactivation."
+    );
+  }
+}
 export {
   ApiError,
   ConfigError,
@@ -2515,7 +3392,10 @@ export {
   acknowledgeProductPurchase,
   activateBasePlan,
   activateOffer,
+  activatePurchaseOption,
+  addRecoveryTargeting,
   addTesters,
+  batchSyncInAppProducts,
   cancelRecoveryAction,
   cancelSubscriptionPurchase,
   checkThreshold,
@@ -2523,40 +3403,59 @@ export {
   consumeProductPurchase,
   convertRegionPrices,
   createAuditEntry,
+  createDeviceTier,
   createExternalTransaction,
   createInAppProduct,
   createOffer,
+  createOneTimeOffer,
+  createOneTimeProduct,
+  createPurchaseOption,
+  createRecoveryAction,
+  createSpinner,
   createSubscription,
+  createTrack,
   deactivateBasePlan,
   deactivateOffer,
+  deactivatePurchaseOption,
   deferSubscriptionPurchase,
   deleteBasePlan,
   deleteImage,
   deleteInAppProduct,
   deleteListing,
   deleteOffer,
+  deleteOneTimeOffer,
+  deleteOneTimeProduct,
   deleteSubscription,
   deployRecoveryAction,
+  detectFastlane,
   detectOutputFormat,
   diffListings,
   diffListingsCommand,
   discoverPlugins,
+  downloadGeneratedApk,
   downloadReport,
   exportDataSafety,
+  exportImages,
   exportReviews,
   formatCustomPayload,
   formatDiscordPayload,
+  formatJunit,
   formatOutput,
   formatSlackPayload,
+  generateMigrationPlan,
   generateNotesFromGit,
   getAppInfo,
   getCountryAvailability,
   getDataSafety,
+  getDeviceTier,
   getExternalTransaction,
   getInAppProduct,
   getListings,
   getOffer,
+  getOneTimeOffer,
+  getOneTimeProduct,
   getProductPurchase,
+  getPurchaseOption,
   getReleasesStatus,
   getReview,
   getSubscription,
@@ -2579,9 +3478,14 @@ export {
   isValidBcp47,
   isValidReportType,
   isValidStatsDimension,
+  listDeviceTiers,
+  listGeneratedApks,
   listImages,
   listInAppProducts,
   listOffers,
+  listOneTimeOffers,
+  listOneTimeProducts,
+  listPurchaseOptions,
   listRecoveryActions,
   listReports,
   listReviews,
@@ -2591,6 +3495,8 @@ export {
   listUsers,
   listVoidedPurchases,
   migratePrices,
+  parseAppfile,
+  parseFastfile,
   parseGrantArg,
   parseMonth,
   promoteRelease,
@@ -2618,16 +3524,22 @@ export {
   updateInAppProduct,
   updateListing,
   updateOffer,
+  updateOneTimeOffer,
+  updateOneTimeProduct,
   updateRollout,
   updateSubscription,
+  updateTrackConfig,
   updateUser,
+  uploadExternallyHosted,
   uploadImage,
+  uploadInternalSharing,
   uploadRelease,
   validateImage,
   validatePreSubmission,
   validateReleaseNotes,
   validateUploadFile,
   writeAuditLog,
-  writeListingsToDir
+  writeListingsToDir,
+  writeMigrationOutput
 };
 //# sourceMappingURL=index.js.map