@gpc-cli/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2118 @@
+// src/errors.ts
+var GpcError = class extends Error {
+  constructor(message, code, exitCode, suggestion) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+    this.suggestion = suggestion;
+    this.name = "GpcError";
+  }
+  toJSON() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        suggestion: this.suggestion
+      }
+    };
+  }
+};
+var ConfigError = class extends GpcError {
+  constructor(message, code, suggestion) {
+    super(message, code, 1, suggestion);
+    this.name = "ConfigError";
+  }
+};
+var ApiError = class extends GpcError {
+  constructor(message, code, statusCode, suggestion) {
+    super(message, code, 4, suggestion);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+var NetworkError = class extends GpcError {
+  constructor(message, suggestion) {
+    super(message, "NETWORK_ERROR", 5, suggestion);
+    this.name = "NetworkError";
+  }
+};
+
+// src/output.ts
+import process from "process";
+function detectOutputFormat() {
+  return process.stdout.isTTY ? "table" : "json";
+}
+function formatOutput(data, format, redact = true) {
+  const safe = redact ? redactSensitive(data) : data;
+  switch (format) {
+    case "json":
+      return formatJson(safe);
+    case "yaml":
+      return formatYaml(safe);
+    case "markdown":
+      return formatMarkdown(safe);
+    case "table":
+      return formatTable(safe);
+    default:
+      return formatJson(safe);
+  }
+}
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "private_key",
+  "privateKey",
+  "private_key_id",
+  "privateKeyId",
+  "accessToken",
+  "access_token",
+  "refreshToken",
+  "refresh_token",
+  "client_secret",
+  "clientSecret",
+  "token",
+  "password",
+  "secret",
+  "credentials"
+]);
+var REDACTED = "[REDACTED]";
+function redactSensitive(data) {
+  if (data === null || data === void 0) return data;
+  if (typeof data === "string") return data;
+  if (typeof data === "number" || typeof data === "boolean") return data;
+  if (Array.isArray(data)) {
+    return data.map((item) => redactSensitive(item));
+  }
+  if (typeof data === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (SENSITIVE_KEYS.has(key) && typeof value === "string") {
+        result[key] = REDACTED;
+      } else {
+        result[key] = redactSensitive(value);
+      }
+    }
+    return result;
+  }
+  return data;
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatYaml(data, indent = 0) {
+  if (data === null || data === void 0) {
+    return "null";
+  }
+  if (typeof data === "string") {
+    return data.includes("\n") ? `|
+${data.split("\n").map((l) => `${"  ".repeat(indent + 1)}${l}`).join("\n")}` : data;
+  }
+  if (typeof data === "number" || typeof data === "boolean") {
+    return String(data);
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) return "[]";
+    return data.map((item) => {
+      const value = formatYaml(item, indent + 1);
+      const prefix = `${"  ".repeat(indent)}- `;
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const lines = value.split("\n");
+        return `${prefix}${lines[0]}
+${lines.slice(1).map((l) => `${"  ".repeat(indent)}  ${l}`).join("\n")}`;
+      }
+      return `${prefix}${value}`;
+    }).join("\n");
+  }
+  if (typeof data === "object") {
+    const entries = Object.entries(data);
+    if (entries.length === 0) return "{}";
+    return entries.map(([key, value]) => {
+      if (typeof value === "object" && value !== null) {
+        return `${"  ".repeat(indent)}${key}:
+${formatYaml(value, indent + 1)}`;
+      }
+      return `${"  ".repeat(indent)}${key}: ${formatYaml(value, indent)}`;
+    }).join("\n");
+  }
+  return String(data);
+}
+function formatTable(data) {
+  const rows = toRows(data);
+  if (rows.length === 0) return "";
+  const keys = Object.keys(rows[0]);
+  if (keys.length === 0) return "";
+  const widths = keys.map(
+    (key) => Math.max(key.length, ...rows.map((row) => String(row[key] ?? "").length))
+  );
+  const header = keys.map((key, i) => key.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  const body = rows.map(
+    (row) => keys.map((key, i) => String(row[key] ?? "").padEnd(widths[i])).join("  ")
+  ).join("\n");
+  return `${header}
+${separator}
+${body}`;
+}
+function formatMarkdown(data) {
+  const rows = toRows(data);
+  if (rows.length === 0) return "";
+  const keys = Object.keys(rows[0]);
+  if (keys.length === 0) return "";
+  const widths = keys.map(
+    (key) => Math.max(key.length, ...rows.map((row) => String(row[key] ?? "").length))
+  );
+  const header = `| ${keys.map((key, i) => key.padEnd(widths[i])).join(" | ")} |`;
+  const separator = `| ${widths.map((w) => "-".repeat(w)).join(" | ")} |`;
+  const body = rows.map(
+    (row) => `| ${keys.map((key, i) => String(row[key] ?? "").padEnd(widths[i])).join(" | ")} |`
+  ).join("\n");
+  return `${header}
+${separator}
+${body}`;
+}
+function toRows(data) {
+  if (Array.isArray(data)) {
+    return data.filter(
+      (item) => typeof item === "object" && item !== null
+    );
+  }
+  if (typeof data === "object" && data !== null) {
+    return [data];
+  }
+  return [];
+}
+
+// src/plugins.ts
+var PluginManager = class {
+  plugins = [];
+  beforeHandlers = [];
+  afterHandlers = [];
+  errorHandlers = [];
+  beforeRequestHandlers = [];
+  afterResponseHandlers = [];
+  registeredCommands = [];
+  /** Load and register a plugin */
+  async load(plugin, manifest) {
+    const isTrusted = manifest?.trusted ?? plugin.name.startsWith("@gpc-cli/");
+    if (!isTrusted && manifest?.permissions) {
+      validatePermissions(manifest.permissions);
+    }
+    const hooks = createHooks(
+      this.beforeHandlers,
+      this.afterHandlers,
+      this.errorHandlers,
+      this.beforeRequestHandlers,
+      this.afterResponseHandlers,
+      this.registeredCommands
+    );
+    await plugin.register(hooks);
+    this.plugins.push({
+      name: plugin.name,
+      version: plugin.version,
+      trusted: isTrusted
+    });
+  }
+  /** Run all beforeCommand handlers */
+  async runBeforeCommand(event) {
+    for (const handler of this.beforeHandlers) {
+      await handler(event);
+    }
+  }
+  /** Run all afterCommand handlers */
+  async runAfterCommand(event, result) {
+    for (const handler of this.afterHandlers) {
+      await handler(event, result);
+    }
+  }
+  /** Run all onError handlers */
+  async runOnError(event, error) {
+    for (const handler of this.errorHandlers) {
+      try {
+        await handler(event, error);
+      } catch {
+      }
+    }
+  }
+  /** Run all beforeRequest handlers */
+  async runBeforeRequest(event) {
+    for (const handler of this.beforeRequestHandlers) {
+      try {
+        await handler(event);
+      } catch {
+      }
+    }
+  }
+  /** Run all afterResponse handlers */
+  async runAfterResponse(event, response) {
+    for (const handler of this.afterResponseHandlers) {
+      try {
+        await handler(event, response);
+      } catch {
+      }
+    }
+  }
+  /** Get commands registered by plugins */
+  getRegisteredCommands() {
+    return [...this.registeredCommands];
+  }
+  /** Get list of loaded plugins */
+  getLoadedPlugins() {
+    return [...this.plugins];
+  }
+  /** Whether any request/response hooks are registered */
+  hasRequestHooks() {
+    return this.beforeRequestHandlers.length > 0 || this.afterResponseHandlers.length > 0;
+  }
+  /** Reset (for testing) */
+  reset() {
+    this.plugins = [];
+    this.beforeHandlers = [];
+    this.afterHandlers = [];
+    this.errorHandlers = [];
+    this.beforeRequestHandlers = [];
+    this.afterResponseHandlers = [];
+    this.registeredCommands = [];
+  }
+};
+function createHooks(beforeHandlers, afterHandlers, errorHandlers, beforeRequestHandlers, afterResponseHandlers, registeredCommands) {
+  return {
+    beforeCommand(handler) {
+      beforeHandlers.push(handler);
+    },
+    afterCommand(handler) {
+      afterHandlers.push(handler);
+    },
+    onError(handler) {
+      errorHandlers.push(handler);
+    },
+    beforeRequest(handler) {
+      beforeRequestHandlers.push(handler);
+    },
+    afterResponse(handler) {
+      afterResponseHandlers.push(handler);
+    },
+    registerCommands(registrar) {
+      const registry = {
+        add(cmd) {
+          registeredCommands.push(cmd);
+        }
+      };
+      registrar(registry);
+    }
+  };
+}
+var VALID_PERMISSIONS = /* @__PURE__ */ new Set([
+  "read:config",
+  "write:config",
+  "read:auth",
+  "api:read",
+  "api:write",
+  "commands:register",
+  "hooks:beforeCommand",
+  "hooks:afterCommand",
+  "hooks:onError",
+  "hooks:beforeRequest",
+  "hooks:afterResponse"
+]);
+function validatePermissions(permissions) {
+  for (const perm of permissions) {
+    if (!VALID_PERMISSIONS.has(perm)) {
+      throw new GpcError(
+        `Unknown plugin permission: "${perm}"`,
+        "PLUGIN_INVALID_PERMISSION",
+        10,
+        `Valid permissions: ${[...VALID_PERMISSIONS].join(", ")}`
+      );
+    }
+  }
+}
+async function discoverPlugins(options) {
+  const plugins = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (options?.configPlugins) {
+    for (const name of options.configPlugins) {
+      if (seen.has(name)) continue;
+      try {
+        const mod = await import(name);
+        const plugin = resolvePlugin(mod);
+        if (plugin) {
+          plugins.push(plugin);
+          seen.add(name);
+        }
+      } catch {
+      }
+    }
+  }
+  return plugins;
+}
+function resolvePlugin(mod) {
+  if (!mod || typeof mod !== "object") return void 0;
+  const m = mod;
+  if (isPlugin(m["default"])) return m["default"];
+  if (isPlugin(m["plugin"])) return m["plugin"];
+  if (isPlugin(m)) return m;
+  return void 0;
+}
+function isPlugin(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const p = obj;
+  return typeof p["name"] === "string" && typeof p["version"] === "string" && typeof p["register"] === "function";
+}
+
+// src/commands/apps.ts
+async function getAppInfo(client, packageName) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const details = await client.details.get(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    return {
+      packageName,
+      title: details.title,
+      defaultLanguage: details.defaultLanguage,
+      contactEmail: details.contactEmail
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+
+// src/utils/file-validation.ts
+import { readFile, stat } from "fs/promises";
+import { extname } from "path";
+var ZIP_MAGIC = Buffer.from([80, 75, 3, 4]);
+var MAX_APK_SIZE = 150 * 1024 * 1024;
+var MAX_AAB_SIZE = 500 * 1024 * 1024;
+var LARGE_FILE_THRESHOLD = 100 * 1024 * 1024;
+async function validateUploadFile(filePath) {
+  const errors = [];
+  const warnings = [];
+  const ext = extname(filePath).toLowerCase();
+  let fileType = "unknown";
+  if (ext === ".aab") {
+    fileType = "aab";
+  } else if (ext === ".apk") {
+    fileType = "apk";
+  } else {
+    errors.push(`Unsupported file extension "${ext}". Expected .aab or .apk`);
+  }
+  let sizeBytes = 0;
+  try {
+    const stats = await stat(filePath);
+    sizeBytes = stats.size;
+    if (sizeBytes === 0) {
+      errors.push("File is empty (0 bytes)");
+    }
+  } catch {
+    errors.push(`File not found: ${filePath}`);
+    return { valid: false, fileType, sizeBytes: 0, errors, warnings };
+  }
+  if (fileType === "apk" && sizeBytes > MAX_APK_SIZE) {
+    errors.push(
+      `APK exceeds 150 MB limit (${formatSize(sizeBytes)}). Consider using AAB format instead.`
+    );
+  }
+  if (fileType === "aab" && sizeBytes > MAX_AAB_SIZE) {
+    errors.push(`AAB exceeds 500 MB limit (${formatSize(sizeBytes)}).`);
+  }
+  if (sizeBytes > LARGE_FILE_THRESHOLD && errors.length === 0) {
+    warnings.push(
+      `Large file (${formatSize(sizeBytes)}). Upload may take a while on slow connections.`
+    );
+  }
+  if (sizeBytes > 0) {
+    try {
+      const fd = await readFile(filePath, { flag: "r" });
+      const header = fd.subarray(0, 4);
+      if (!header.equals(ZIP_MAGIC)) {
+        errors.push(
+          "File does not have valid ZIP magic bytes (PK\\x03\\x04). Both AAB and APK files must be valid ZIP archives."
+        );
+      }
+    } catch {
+      errors.push("Unable to read file header for validation");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    fileType,
+    sizeBytes,
+    errors,
+    warnings
+  };
+}
+function formatSize(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+  }
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
+
+// src/commands/releases.ts
+async function uploadRelease(client, packageName, filePath, options) {
+  const validation = await validateUploadFile(filePath);
+  if (!validation.valid) {
+    throw new Error(`File validation failed:
+${validation.errors.join("\n")}`);
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const bundle = await client.bundles.upload(packageName, edit.id, filePath);
+    if (options.mappingFile) {
+      await client.deobfuscation.upload(
+        packageName,
+        edit.id,
+        bundle.versionCode,
+        options.mappingFile
+      );
+    }
+    const release = {
+      versionCodes: [String(bundle.versionCode)],
+      status: options.status || (options.userFraction ? "inProgress" : "completed"),
+      ...options.userFraction && { userFraction: options.userFraction },
+      ...options.releaseNotes && { releaseNotes: options.releaseNotes },
+      ...options.releaseName && { name: options.releaseName }
+    };
+    await client.tracks.update(packageName, edit.id, options.track, release);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return {
+      versionCode: bundle.versionCode,
+      track: options.track,
+      status: release.status
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function getReleasesStatus(client, packageName, trackFilter) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const tracks = trackFilter ? [await client.tracks.get(packageName, edit.id, trackFilter)] : await client.tracks.list(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    const results = [];
+    for (const track of tracks) {
+      for (const release of track.releases || []) {
+        results.push({
+          track: track.track,
+          status: release.status,
+          versionCodes: release.versionCodes || [],
+          userFraction: release.userFraction,
+          releaseNotes: release.releaseNotes
+        });
+      }
+    }
+    return results;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function promoteRelease(client, packageName, fromTrack, toTrack, options) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const sourceTrack = await client.tracks.get(packageName, edit.id, fromTrack);
+    const currentRelease = sourceTrack.releases?.find(
+      (r) => r.status === "completed" || r.status === "inProgress"
+    );
+    if (!currentRelease) {
+      throw new Error(`No active release found on track "${fromTrack}"`);
+    }
+    const release = {
+      versionCodes: currentRelease.versionCodes,
+      status: options?.userFraction ? "inProgress" : "completed",
+      ...options?.userFraction && { userFraction: options.userFraction },
+      releaseNotes: options?.releaseNotes || currentRelease.releaseNotes || []
+    };
+    await client.tracks.update(packageName, edit.id, toTrack, release);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return {
+      track: toTrack,
+      status: release.status,
+      versionCodes: release.versionCodes,
+      userFraction: release.userFraction
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function updateRollout(client, packageName, track, action, userFraction) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const trackData = await client.tracks.get(packageName, edit.id, track);
+    const currentRelease = trackData.releases?.find(
+      (r) => r.status === "inProgress" || r.status === "halted"
+    );
+    if (!currentRelease) {
+      throw new Error(`No active rollout found on track "${track}"`);
+    }
+    let newStatus;
+    let newFraction;
+    switch (action) {
+      case "increase":
+        if (!userFraction) throw new Error("--to <percentage> is required for rollout increase");
+        newStatus = "inProgress";
+        newFraction = userFraction;
+        break;
+      case "halt":
+        newStatus = "halted";
+        newFraction = currentRelease.userFraction;
+        break;
+      case "resume":
+        newStatus = "inProgress";
+        newFraction = currentRelease.userFraction;
+        break;
+      case "complete":
+        newStatus = "completed";
+        newFraction = void 0;
+        break;
+    }
+    const release = {
+      versionCodes: currentRelease.versionCodes,
+      status: newStatus,
+      ...newFraction !== void 0 && { userFraction: newFraction },
+      releaseNotes: currentRelease.releaseNotes || []
+    };
+    await client.tracks.update(packageName, edit.id, track, release);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return {
+      track,
+      status: newStatus,
+      versionCodes: release.versionCodes,
+      userFraction: newFraction
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function listTracks(client, packageName) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const tracks = await client.tracks.list(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    return tracks;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+
+// src/utils/bcp47.ts
+var GOOGLE_PLAY_LANGUAGES = [
+  "af",
+  "am",
+  "ar",
+  "hy-AM",
+  "az-AZ",
+  "eu-ES",
+  "be",
+  "bn-BD",
+  "bg",
+  "my-MM",
+  "ca",
+  "zh-HK",
+  "zh-CN",
+  "zh-TW",
+  "hr",
+  "cs-CZ",
+  "da-DK",
+  "nl-NL",
+  "en-AU",
+  "en-CA",
+  "en-IN",
+  "en-SG",
+  "en-GB",
+  "en-US",
+  "et",
+  "fil",
+  "fi-FI",
+  "fr-FR",
+  "fr-CA",
+  "gl-ES",
+  "ka-GE",
+  "de-DE",
+  "el-GR",
+  "gu",
+  "iw-IL",
+  "hi-IN",
+  "hu-HU",
+  "is-IS",
+  "id",
+  "it-IT",
+  "ja-JP",
+  "kn-IN",
+  "kk",
+  "km-KH",
+  "ko-KR",
+  "ky-KG",
+  "lo-LA",
+  "lv",
+  "lt",
+  "mk-MK",
+  "ms",
+  "ms-MY",
+  "ml-IN",
+  "mr-IN",
+  "mn-MN",
+  "ne-NP",
+  "no-NO",
+  "fa",
+  "pl-PL",
+  "pt-BR",
+  "pt-PT",
+  "pa",
+  "ro",
+  "rm",
+  "ru-RU",
+  "sr",
+  "si-LK",
+  "sk",
+  "sl",
+  "es-419",
+  "es-ES",
+  "es-US",
+  "sw",
+  "sv-SE",
+  "ta-IN",
+  "te-IN",
+  "th",
+  "tr-TR",
+  "uk",
+  "ur",
+  "vi",
+  "zu"
+];
+function isValidBcp47(tag) {
+  return GOOGLE_PLAY_LANGUAGES.includes(tag);
+}
+
+// src/utils/image-validation.ts
+import { stat as stat2 } from "fs/promises";
+import { extname as extname2 } from "path";
+var IMAGE_SIZE_LIMITS = {
+  icon: { maxBytes: 1024 * 1024, label: "1 MB" },
+  featureGraphic: { maxBytes: 1024 * 1024, label: "1 MB" },
+  tvBanner: { maxBytes: 1024 * 1024, label: "1 MB" },
+  phoneScreenshots: { maxBytes: 8 * 1024 * 1024, label: "8 MB" },
+  sevenInchScreenshots: { maxBytes: 8 * 1024 * 1024, label: "8 MB" },
+  tenInchScreenshots: { maxBytes: 8 * 1024 * 1024, label: "8 MB" },
+  tvScreenshots: { maxBytes: 8 * 1024 * 1024, label: "8 MB" },
+  wearScreenshots: { maxBytes: 8 * 1024 * 1024, label: "8 MB" }
+};
+var VALID_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
+var LARGE_IMAGE_THRESHOLD = 2 * 1024 * 1024;
+async function validateImage(filePath, imageType) {
+  const errors = [];
+  const warnings = [];
+  const ext = extname2(filePath).toLowerCase();
+  if (!VALID_EXTENSIONS.has(ext)) {
+    errors.push(`Unsupported image format "${ext}". Use PNG or JPEG.`);
+  }
+  let sizeBytes = 0;
+  try {
+    const stats = await stat2(filePath);
+    sizeBytes = stats.size;
+    if (sizeBytes === 0) {
+      errors.push("Image file is empty (0 bytes)");
+    }
+  } catch {
+    errors.push(`Image file not found: ${filePath}`);
+    return { valid: false, errors, warnings };
+  }
+  if (imageType && sizeBytes > 0) {
+    const limit = IMAGE_SIZE_LIMITS[imageType];
+    if (limit && sizeBytes > limit.maxBytes) {
+      errors.push(`Image exceeds ${limit.label} limit for ${imageType} (${formatSize2(sizeBytes)})`);
+    }
+  }
+  if (sizeBytes > LARGE_IMAGE_THRESHOLD && errors.length === 0) {
+    warnings.push(
+      `Large image (${formatSize2(sizeBytes)}). Consider optimizing for faster upload and better store performance.`
+    );
+  }
+  if (ext === ".png" && sizeBytes > 512 * 1024) {
+    warnings.push("PNG file is over 512 KB. Consider compressing with tools like pngquant or optipng.");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function formatSize2(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+
+// src/utils/fastlane.ts
+import { readFile as readFile2, writeFile, mkdir, readdir, stat as stat3 } from "fs/promises";
+import { join } from "path";
+var FILE_MAP = {
+  "title.txt": "title",
+  "short_description.txt": "shortDescription",
+  "full_description.txt": "fullDescription",
+  "video.txt": "video"
+};
+var FIELD_TO_FILE = Object.fromEntries(
+  Object.entries(FILE_MAP).map(([file, field]) => [field, file])
+);
+async function exists(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readListingsFromDir(dir) {
+  const listings = [];
+  if (!await exists(dir)) return listings;
+  const entries = await readdir(dir);
+  for (const lang of entries) {
+    const langDir = join(dir, lang);
+    const langStat = await stat3(langDir);
+    if (!langStat.isDirectory()) continue;
+    const listing = {
+      language: lang,
+      title: "",
+      shortDescription: "",
+      fullDescription: ""
+    };
+    for (const [fileName, field] of Object.entries(FILE_MAP)) {
+      const filePath = join(langDir, fileName);
+      if (await exists(filePath)) {
+        const content = await readFile2(filePath, "utf-8");
+        listing[field] = content.trimEnd();
+      }
+    }
+    listings.push(listing);
+  }
+  return listings;
+}
+async function writeListingsToDir(dir, listings) {
+  for (const listing of listings) {
+    const langDir = join(dir, listing.language);
+    await mkdir(langDir, { recursive: true });
+    for (const [field, fileName] of Object.entries(FIELD_TO_FILE)) {
+      const value = listing[field];
+      if (value !== void 0 && value !== "") {
+        await writeFile(join(langDir, fileName), value + "\n", "utf-8");
+      }
+    }
+  }
+}
+function diffListings(local, remote) {
+  const diffs = [];
+  const remoteMap = new Map(remote.map((l) => [l.language, l]));
+  const localMap = new Map(local.map((l) => [l.language, l]));
+  for (const localListing of local) {
+    const remoteListing = remoteMap.get(localListing.language);
+    for (const [field, fileName] of Object.entries(FIELD_TO_FILE)) {
+      const localVal = (localListing[field] ?? "").toString();
+      const remoteVal = remoteListing ? (remoteListing[field] ?? "").toString() : "";
+      if (localVal !== remoteVal) {
+        diffs.push({
+          language: localListing.language,
+          field,
+          local: localVal,
+          remote: remoteVal
+        });
+      }
+    }
+  }
+  for (const remoteListing of remote) {
+    if (!localMap.has(remoteListing.language)) {
+      for (const [field] of Object.entries(FIELD_TO_FILE)) {
+        const remoteVal = (remoteListing[field] ?? "").toString();
+        if (remoteVal) {
+          diffs.push({
+            language: remoteListing.language,
+            field,
+            local: "",
+            remote: remoteVal
+          });
+        }
+      }
+    }
+  }
+  return diffs;
+}
+
+// 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.`);
+  }
+}
+async function getListings(client, packageName, language) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    let listings;
+    if (language) {
+      validateLanguage(language);
+      const listing = await client.listings.get(packageName, edit.id, language);
+      listings = [listing];
+    } else {
+      listings = await client.listings.list(packageName, edit.id);
+    }
+    await client.edits.delete(packageName, edit.id);
+    return listings;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function updateListing(client, packageName, language, data) {
+  validateLanguage(language);
+  const edit = await client.edits.insert(packageName);
+  try {
+    const listing = await client.listings.patch(packageName, edit.id, language, data);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return listing;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function deleteListing(client, packageName, language) {
+  validateLanguage(language);
+  const edit = await client.edits.insert(packageName);
+  try {
+    await client.listings.delete(packageName, edit.id, language);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function pullListings(client, packageName, dir) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const listings = await client.listings.list(packageName, edit.id);
+    await client.edits.delete(packageName, edit.id);
+    await writeListingsToDir(dir, listings);
+    return { listings };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+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}"`);
+  }
+  for (const listing of localListings) {
+    validateLanguage(listing.language);
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    if (options?.dryRun) {
+      const remoteListings = await client.listings.list(packageName, edit.id);
+      await client.edits.delete(packageName, edit.id);
+      const diffs = diffListings(localListings, remoteListings);
+      return { diffs };
+    }
+    for (const listing of localListings) {
+      const { language, ...data } = listing;
+      await client.listings.update(packageName, edit.id, language, data);
+    }
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return {
+      updated: localListings.length,
+      languages: localListings.map((l) => l.language)
+    };
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function listImages(client, packageName, language, imageType) {
+  validateLanguage(language);
+  const edit = await client.edits.insert(packageName);
+  try {
+    const images = await client.images.list(packageName, edit.id, language, imageType);
+    await client.edits.delete(packageName, edit.id);
+    return images;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+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("; ")}`);
+  }
+  if (imageCheck.warnings.length > 0) {
+    for (const w of imageCheck.warnings) {
+      console.warn(`Warning: ${w}`);
+    }
+  }
+  const edit = await client.edits.insert(packageName);
+  try {
+    const image = await client.images.upload(packageName, edit.id, language, imageType, filePath);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return image;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function deleteImage(client, packageName, language, imageType, imageId) {
+  validateLanguage(language);
+  const edit = await client.edits.insert(packageName);
+  try {
+    await client.images.delete(packageName, edit.id, language, imageType, imageId);
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+  } 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 {
+    const availability = await client.countryAvailability.get(packageName, edit.id, track);
+    await client.edits.delete(packageName, edit.id);
+    return availability;
+  } 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 {
+    const result = await client.details.patch(packageName, edit.id, details);
+    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/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";
+var MAX_NOTES_LENGTH = 500;
+async function readReleaseNotesFromDir(dir) {
+  let entries;
+  try {
+    entries = await readdir2(dir);
+  } catch {
+    throw new Error(`Release notes directory not found: ${dir}`);
+  }
+  const notes = [];
+  for (const entry of entries) {
+    if (extname3(entry) !== ".txt") continue;
+    const language = basename(entry, ".txt");
+    const filePath = join2(dir, entry);
+    const stats = await stat4(filePath);
+    if (!stats.isFile()) continue;
+    const text = (await readFile3(filePath, "utf-8")).trim();
+    if (text.length === 0) continue;
+    notes.push({ language, text });
+  }
+  return notes;
+}
+function validateReleaseNotes(notes) {
+  const errors = [];
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    if (seen.has(note.language)) {
+      errors.push(`Duplicate language code: ${note.language}`);
+    }
+    seen.add(note.language);
+    if (note.text.length > MAX_NOTES_LENGTH) {
+      errors.push(
+        `Release notes for "${note.language}" exceed ${MAX_NOTES_LENGTH} chars (${note.text.length} chars)`
+      );
+    }
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+// src/commands/validate.ts
+import { stat as stat5 } from "fs/promises";
+var STANDARD_TRACKS = /* @__PURE__ */ new Set([
+  "internal",
+  "alpha",
+  "beta",
+  "production",
+  // Form factor tracks
+  "wear:internal",
+  "wear:alpha",
+  "wear:beta",
+  "wear:production",
+  "automotive:internal",
+  "automotive:alpha",
+  "automotive:beta",
+  "automotive:production",
+  "tv:internal",
+  "tv:alpha",
+  "tv:beta",
+  "tv:production",
+  "android_xr:internal",
+  "android_xr:alpha",
+  "android_xr:beta",
+  "android_xr:production"
+]);
+var TRACK_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_:-]*$/;
+async function validatePreSubmission(options) {
+  const checks = [];
+  const fileResult = await validateUploadFile(options.filePath);
+  checks.push({
+    name: "file",
+    passed: fileResult.valid,
+    message: fileResult.valid ? `Valid ${fileResult.fileType} file (${formatSize3(fileResult.sizeBytes)})` : fileResult.errors.join("; ")
+  });
+  if (options.mappingFile) {
+    try {
+      const stats = await stat5(options.mappingFile);
+      checks.push({
+        name: "mapping",
+        passed: stats.isFile(),
+        message: stats.isFile() ? `Mapping file found (${formatSize3(stats.size)})` : "Mapping path is not a file"
+      });
+    } catch {
+      checks.push({
+        name: "mapping",
+        passed: false,
+        message: `Mapping file not found: ${options.mappingFile}`
+      });
+    }
+  }
+  if (options.track) {
+    const isValid = STANDARD_TRACKS.has(options.track) || TRACK_PATTERN.test(options.track);
+    checks.push({
+      name: "track",
+      passed: isValid,
+      message: isValid ? `Track "${options.track}" is valid` : `Invalid track name "${options.track}". Use: internal, alpha, beta, production, or a custom track ID`
+    });
+  }
+  let resolvedNotes = options.notes;
+  if (options.notesDir) {
+    try {
+      resolvedNotes = await readReleaseNotesFromDir(options.notesDir);
+      checks.push({
+        name: "notes-dir",
+        passed: true,
+        message: `Read release notes for ${resolvedNotes.length} language(s)`
+      });
+    } catch (err) {
+      checks.push({
+        name: "notes-dir",
+        passed: false,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (resolvedNotes && resolvedNotes.length > 0) {
+    const notesResult = validateReleaseNotes(resolvedNotes);
+    checks.push({
+      name: "notes",
+      passed: notesResult.valid,
+      message: notesResult.valid ? `Release notes valid (${resolvedNotes.length} language(s))` : notesResult.errors.join("; ")
+    });
+  }
+  return {
+    valid: checks.every((c) => c.passed),
+    checks
+  };
+}
+function formatSize3(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+
+// src/commands/publish.ts
+async function publish(client, packageName, filePath, options) {
+  let releaseNotes;
+  if (options.notesDir) {
+    releaseNotes = await readReleaseNotesFromDir(options.notesDir);
+  } else if (options.notes) {
+    releaseNotes = [{ language: "en-US", text: options.notes }];
+  }
+  const validation = await validatePreSubmission({
+    filePath,
+    mappingFile: options.mappingFile,
+    track: options.track || "internal",
+    notes: releaseNotes
+  });
+  if (!validation.valid) {
+    return { validation };
+  }
+  const upload = await uploadRelease(client, packageName, filePath, {
+    track: options.track || "internal",
+    userFraction: options.rolloutPercent ? options.rolloutPercent / 100 : void 0,
+    releaseNotes,
+    releaseName: options.releaseName,
+    mappingFile: options.mappingFile
+  });
+  return { validation, upload };
+}
+
+// src/commands/reviews.ts
+import { paginateAll } from "@gpc-cli/api";
+async function listReviews(client, packageName, options) {
+  const apiOptions = {};
+  if (options?.translationLanguage) apiOptions.translationLanguage = options.translationLanguage;
+  if (options?.maxResults) apiOptions.maxResults = options.maxResults;
+  const response = await client.reviews.list(packageName, apiOptions);
+  let reviews = response.reviews || [];
+  if (options?.stars !== void 0) {
+    reviews = reviews.filter((r) => {
+      const userComment = r.comments?.[0]?.userComment;
+      return userComment && userComment.starRating === options.stars;
+    });
+  }
+  if (options?.language) {
+    reviews = reviews.filter((r) => {
+      const userComment = r.comments?.[0]?.userComment;
+      return userComment?.reviewerLanguage === options.language;
+    });
+  }
+  if (options?.since) {
+    const sinceTime = new Date(options.since).getTime() / 1e3;
+    reviews = reviews.filter((r) => {
+      const userComment = r.comments?.[0]?.userComment;
+      return userComment && Number(userComment.lastModified.seconds) >= sinceTime;
+    });
+  }
+  return reviews;
+}
+async function getReview(client, packageName, reviewId, translationLanguage) {
+  return client.reviews.get(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.`
+    );
+  }
+  if (replyText.length === 0) {
+    throw new Error("Reply text cannot be empty.");
+  }
+  return client.reviews.reply(packageName, reviewId, replyText);
+}
+async function exportReviews(client, packageName, options) {
+  const { items: allReviews } = await paginateAll(
+    async (pageToken) => {
+      const apiOptions = { token: pageToken };
+      if (options?.translationLanguage) apiOptions.translationLanguage = options.translationLanguage;
+      const response = await client.reviews.list(packageName, apiOptions);
+      return { items: response.reviews || [], nextPageToken: response.tokenPagination?.nextPageToken };
+    }
+  );
+  let filtered = allReviews;
+  if (options?.stars !== void 0) {
+    filtered = filtered.filter((r) => {
+      const uc = r.comments?.[0]?.userComment;
+      return uc && uc.starRating === options.stars;
+    });
+  }
+  if (options?.language) {
+    filtered = filtered.filter((r) => {
+      const uc = r.comments?.[0]?.userComment;
+      return uc?.reviewerLanguage === options.language;
+    });
+  }
+  if (options?.since) {
+    const sinceTime = new Date(options.since).getTime() / 1e3;
+    filtered = filtered.filter((r) => {
+      const uc = r.comments?.[0]?.userComment;
+      return uc && Number(uc.lastModified.seconds) >= sinceTime;
+    });
+  }
+  if (options?.format === "csv") {
+    return reviewsToCsv(filtered);
+  }
+  return JSON.stringify(filtered, null, 2);
+}
+function reviewsToCsv(reviews) {
+  const header = "reviewId,authorName,starRating,text,language,date,device,appVersionName";
+  const rows = reviews.map((r) => {
+    const uc = r.comments?.[0]?.userComment;
+    const fields = [
+      r.reviewId,
+      csvEscape(r.authorName),
+      uc?.starRating ?? "",
+      csvEscape(uc?.text ?? ""),
+      uc?.reviewerLanguage ?? "",
+      uc ? new Date(Number(uc.lastModified.seconds) * 1e3).toISOString() : "",
+      csvEscape(uc?.device ?? ""),
+      csvEscape(uc?.appVersionName ?? "")
+    ];
+    return fields.join(",");
+  });
+  return [header, ...rows].join("\n");
+}
+function csvEscape(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+// src/commands/vitals.ts
+function buildQuery(options) {
+  const query = {
+    metrics: ["errorReportCount", "distinctUsers"]
+  };
+  if (options?.dimension) {
+    query.dimensions = [options.dimension];
+  }
+  if (options?.days) {
+    const end = /* @__PURE__ */ new Date();
+    const start = /* @__PURE__ */ new Date();
+    start.setDate(start.getDate() - options.days);
+    query.timelineSpec = {
+      aggregationPeriod: options.aggregation ?? "DAILY",
+      startTime: {
+        year: start.getFullYear(),
+        month: start.getMonth() + 1,
+        day: start.getDate()
+      },
+      endTime: {
+        year: end.getFullYear(),
+        month: end.getMonth() + 1,
+        day: end.getDate()
+      }
+    };
+  }
+  return query;
+}
+async function queryMetric(reporting, packageName, metricSet, options) {
+  const query = buildQuery(options);
+  return reporting.queryMetricSet(packageName, metricSet, query);
+}
+async function getVitalsOverview(reporting, packageName) {
+  const metricSets = [
+    ["vitals.crashrate", "crashRate"],
+    ["vitals.anrrate", "anrRate"],
+    ["vitals.slowstartrate", "slowStartRate"],
+    ["vitals.slowrenderingrate", "slowRenderingRate"],
+    ["vitals.excessivewakeuprate", "excessiveWakeupRate"],
+    ["vitals.stuckbackgroundwakelockrate", "stuckWakelockRate"]
+  ];
+  const results = await Promise.allSettled(
+    metricSets.map(
+      ([metric]) => reporting.queryMetricSet(packageName, metric, {
+        metrics: ["errorReportCount", "distinctUsers"]
+      })
+    )
+  );
+  const overview = {};
+  for (let i = 0; i < metricSets.length; i++) {
+    const entry = metricSets[i];
+    const key = entry[1];
+    const result = results[i];
+    if (result.status === "fulfilled") {
+      overview[key] = result.value.rows || [];
+    }
+  }
+  return overview;
+}
+async function getVitalsCrashes(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "vitals.crashrate", options);
+}
+async function getVitalsAnr(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "vitals.anrrate", options);
+}
+async function getVitalsStartup(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "vitals.slowstartrate", options);
+}
+async function getVitalsRendering(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "vitals.slowrenderingrate", options);
+}
+async function getVitalsBattery(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "vitals.excessivewakeuprate", options);
+}
+async function getVitalsMemory(reporting, packageName, options) {
+  return queryMetric(reporting, packageName, "vitals.stuckbackgroundwakelockrate", options);
+}
+async function getVitalsAnomalies(reporting, packageName) {
+  return reporting.getAnomalies(packageName);
+}
+async function searchVitalsErrors(reporting, packageName, options) {
+  return reporting.searchErrorIssues(
+    packageName,
+    options?.filter,
+    options?.maxResults
+  );
+}
+async function compareVitalsTrend(reporting, packageName, metricSet, days = 7) {
+  const now = /* @__PURE__ */ new Date();
+  const currentEnd = new Date(now);
+  const currentStart = new Date(now);
+  currentStart.setDate(currentStart.getDate() - days);
+  const previousEnd = new Date(currentStart);
+  const previousStart = new Date(previousEnd);
+  previousStart.setDate(previousStart.getDate() - days);
+  const makeQuery = (start, end) => ({
+    metrics: ["errorReportCount", "distinctUsers"],
+    timelineSpec: {
+      aggregationPeriod: "DAILY",
+      startTime: { year: start.getFullYear(), month: start.getMonth() + 1, day: start.getDate() },
+      endTime: { year: end.getFullYear(), month: end.getMonth() + 1, day: end.getDate() }
+    }
+  });
+  const [currentResult, previousResult] = await Promise.all([
+    reporting.queryMetricSet(packageName, metricSet, makeQuery(currentStart, currentEnd)),
+    reporting.queryMetricSet(packageName, metricSet, makeQuery(previousStart, previousEnd))
+  ]);
+  const extractAvg = (rows) => {
+    if (!rows || rows.length === 0) return void 0;
+    const values = rows.map((r) => {
+      const keys = Object.keys(r.metrics);
+      const first = keys[0];
+      return first ? Number(r.metrics[first]?.decimalValue?.value) : NaN;
+    }).filter((v) => !isNaN(v));
+    if (values.length === 0) return void 0;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+  };
+  const current = extractAvg(currentResult.rows);
+  const previous = extractAvg(previousResult.rows);
+  let changePercent;
+  let direction = "unknown";
+  if (current !== void 0 && previous !== void 0 && previous !== 0) {
+    changePercent = (current - previous) / previous * 100;
+    if (Math.abs(changePercent) < 1) {
+      direction = "unchanged";
+    } else if (changePercent < 0) {
+      direction = "improved";
+    } else {
+      direction = "degraded";
+    }
+  }
+  return {
+    metric: metricSet,
+    current,
+    previous,
+    changePercent: changePercent !== void 0 ? Math.round(changePercent * 10) / 10 : void 0,
+    direction
+  };
+}
+function checkThreshold(value, threshold) {
+  return {
+    breached: value !== void 0 && value > threshold,
+    value,
+    threshold
+  };
+}
+
+// src/commands/subscriptions.ts
+import { paginateAll as paginateAll2 } from "@gpc-cli/api";
+async function listSubscriptions(client, packageName, options) {
+  if (options?.limit || options?.nextPage) {
+    const result = await paginateAll2(
+      async (pageToken) => {
+        const resp = await client.subscriptions.list(packageName, { pageToken, pageSize: options?.pageSize });
+        return { items: resp.subscriptions || [], nextPageToken: resp.nextPageToken };
+      },
+      { limit: options.limit, startPageToken: options.nextPage }
+    );
+    return { subscriptions: result.items, nextPageToken: result.nextPageToken };
+  }
+  return client.subscriptions.list(packageName, { pageToken: options?.pageToken, pageSize: options?.pageSize });
+}
+async function getSubscription(client, packageName, productId) {
+  return client.subscriptions.get(packageName, productId);
+}
+async function createSubscription(client, packageName, data) {
+  return client.subscriptions.create(packageName, data);
+}
+async function updateSubscription(client, packageName, productId, data, updateMask) {
+  return client.subscriptions.update(packageName, productId, data, updateMask);
+}
+async function deleteSubscription(client, packageName, productId) {
+  return client.subscriptions.delete(packageName, productId);
+}
+async function activateBasePlan(client, packageName, productId, basePlanId) {
+  return client.subscriptions.activateBasePlan(packageName, productId, basePlanId);
+}
+async function deactivateBasePlan(client, packageName, productId, basePlanId) {
+  return client.subscriptions.deactivateBasePlan(packageName, productId, basePlanId);
+}
+async function deleteBasePlan(client, packageName, productId, basePlanId) {
+  return client.subscriptions.deleteBasePlan(packageName, productId, basePlanId);
+}
+async function migratePrices(client, packageName, productId, basePlanId, data) {
+  return client.subscriptions.migratePrices(packageName, productId, basePlanId, data);
+}
+async function listOffers(client, packageName, productId, basePlanId) {
+  return client.subscriptions.listOffers(packageName, productId, basePlanId);
+}
+async function getOffer(client, packageName, productId, basePlanId, offerId) {
+  return client.subscriptions.getOffer(packageName, productId, basePlanId, offerId);
+}
+async function createOffer(client, packageName, productId, basePlanId, data) {
+  return client.subscriptions.createOffer(packageName, productId, basePlanId, data);
+}
+async function updateOffer(client, packageName, productId, basePlanId, offerId, data, updateMask) {
+  return client.subscriptions.updateOffer(packageName, productId, basePlanId, offerId, data, updateMask);
+}
+async function deleteOffer(client, packageName, productId, basePlanId, offerId) {
+  return client.subscriptions.deleteOffer(packageName, productId, basePlanId, offerId);
+}
+async function activateOffer(client, packageName, productId, basePlanId, offerId) {
+  return client.subscriptions.activateOffer(packageName, productId, basePlanId, offerId);
+}
+async function deactivateOffer(client, packageName, productId, basePlanId, offerId) {
+  return client.subscriptions.deactivateOffer(packageName, productId, basePlanId, offerId);
+}
+
+// src/commands/iap.ts
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
+import { join as join3 } from "path";
+import { paginateAll as paginateAll3 } from "@gpc-cli/api";
+async function listInAppProducts(client, packageName, options) {
+  if (options?.limit || options?.nextPage) {
+    const result = await paginateAll3(
+      async (pageToken) => {
+        const resp = await client.inappproducts.list(packageName, { token: pageToken, maxResults: options?.maxResults });
+        return { items: resp.inappproduct || [], nextPageToken: resp.tokenPagination?.nextPageToken };
+      },
+      { limit: options.limit, startPageToken: options.nextPage }
+    );
+    return { inappproduct: result.items, nextPageToken: result.nextPageToken };
+  }
+  return client.inappproducts.list(packageName, { token: options?.token, maxResults: options?.maxResults });
+}
+async function getInAppProduct(client, packageName, sku) {
+  return client.inappproducts.get(packageName, sku);
+}
+async function createInAppProduct(client, packageName, data) {
+  return client.inappproducts.create(packageName, data);
+}
+async function updateInAppProduct(client, packageName, sku, data) {
+  return client.inappproducts.update(packageName, sku, data);
+}
+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) {
+    return { created: 0, updated: 0, unchanged: 0, skus: [] };
+  }
+  const localProducts = [];
+  for (const file of jsonFiles) {
+    const content = await readFile4(join3(dir, file), "utf-8");
+    localProducts.push(JSON.parse(content));
+  }
+  const response = await client.inappproducts.list(packageName);
+  const remoteSkus = new Set((response.inappproduct || []).map((p) => p.sku));
+  let created = 0;
+  let updated = 0;
+  let unchanged = 0;
+  const skus = [];
+  for (const product of localProducts) {
+    skus.push(product.sku);
+    if (remoteSkus.has(product.sku)) {
+      if (!options?.dryRun) {
+        await client.inappproducts.update(packageName, product.sku, product);
+      }
+      updated++;
+    } else {
+      if (!options?.dryRun) {
+        await client.inappproducts.create(packageName, product);
+      }
+      created++;
+    }
+  }
+  return { created, updated, unchanged, skus };
+}
+
+// src/commands/purchases.ts
+import { paginateAll as paginateAll4 } from "@gpc-cli/api";
+async function getProductPurchase(client, packageName, productId, token) {
+  return client.purchases.getProduct(packageName, productId, token);
+}
+async function acknowledgeProductPurchase(client, packageName, productId, token, payload) {
+  const body = payload ? { developerPayload: payload } : void 0;
+  return client.purchases.acknowledgeProduct(packageName, productId, token, body);
+}
+async function consumeProductPurchase(client, packageName, productId, token) {
+  return client.purchases.consumeProduct(packageName, productId, token);
+}
+async function getSubscriptionPurchase(client, packageName, token) {
+  return client.purchases.getSubscriptionV2(packageName, token);
+}
+async function cancelSubscriptionPurchase(client, packageName, subscriptionId, token) {
+  return client.purchases.cancelSubscription(packageName, subscriptionId, token);
+}
+async function deferSubscriptionPurchase(client, packageName, subscriptionId, token, desiredExpiry) {
+  const sub = await client.purchases.getSubscriptionV1(packageName, subscriptionId, token);
+  return client.purchases.deferSubscription(packageName, subscriptionId, token, {
+    deferralInfo: {
+      expectedExpiryTimeMillis: sub.expiryTimeMillis,
+      desiredExpiryTimeMillis: String(new Date(desiredExpiry).getTime())
+    }
+  });
+}
+async function revokeSubscriptionPurchase(client, packageName, token) {
+  return client.purchases.revokeSubscriptionV2(packageName, token);
+}
+async function listVoidedPurchases(client, packageName, options) {
+  if (options?.limit || options?.nextPage) {
+    const result = await paginateAll4(
+      async (pageToken) => {
+        const resp = await client.purchases.listVoided(packageName, {
+          startTime: options?.startTime,
+          endTime: options?.endTime,
+          maxResults: options?.maxResults,
+          token: pageToken
+        });
+        return { items: resp.voidedPurchases || [], nextPageToken: resp.tokenPagination?.nextPageToken };
+      },
+      { limit: options.limit, startPageToken: options.nextPage }
+    );
+    return { voidedPurchases: result.items, nextPageToken: result.nextPageToken };
+  }
+  return client.purchases.listVoided(packageName, options);
+}
+async function refundOrder(client, packageName, orderId, options) {
+  return client.orders.refund(packageName, orderId, options);
+}
+
+// src/commands/pricing.ts
+async function convertRegionPrices(client, packageName, currencyCode, amount) {
+  const units = amount.split(".")[0] || "0";
+  const fractional = amount.split(".")[1] || "0";
+  const nanos = Number(fractional.padEnd(9, "0").slice(0, 9));
+  return client.monetization.convertRegionPrices(packageName, {
+    price: {
+      currencyCode,
+      units,
+      nanos
+    }
+  });
+}
+
+// src/commands/reports.ts
+var FINANCIAL_REPORT_TYPES = /* @__PURE__ */ new Set([
+  "earnings",
+  "sales",
+  "estimated_sales",
+  "play_balance"
+]);
+var STATS_REPORT_TYPES = /* @__PURE__ */ new Set([
+  "installs",
+  "crashes",
+  "ratings",
+  "reviews",
+  "store_performance",
+  "subscriptions"
+]);
+var VALID_DIMENSIONS = /* @__PURE__ */ new Set([
+  "country",
+  "language",
+  "os_version",
+  "device",
+  "app_version",
+  "carrier",
+  "overview"
+]);
+function isFinancialReportType(type) {
+  return FINANCIAL_REPORT_TYPES.has(type);
+}
+function isStatsReportType(type) {
+  return STATS_REPORT_TYPES.has(type);
+}
+function isValidReportType(type) {
+  return FINANCIAL_REPORT_TYPES.has(type) || STATS_REPORT_TYPES.has(type);
+}
+function isValidStatsDimension(dim) {
+  return VALID_DIMENSIONS.has(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).`
+    );
+  }
+  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.`);
+  }
+  return { year, month };
+}
+async function listReports(client, packageName, reportType, year, month) {
+  const response = await client.reports.list(packageName, reportType, year, month);
+  return response.reports || [];
+}
+async function downloadReport(client, packageName, reportType, year, month) {
+  const reports = await listReports(client, packageName, reportType, year, month);
+  if (reports.length === 0) {
+    throw new Error(
+      `No ${reportType} reports found for ${year}-${String(month).padStart(2, "0")}.`
+    );
+  }
+  const bucket = reports[0];
+  if (!bucket) {
+    throw new Error(
+      `No ${reportType} reports found for ${year}-${String(month).padStart(2, "0")}.`
+    );
+  }
+  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}`
+    );
+  }
+  return response.text();
+}
+
+// src/commands/users.ts
+import { paginateAll as paginateAll5 } from "@gpc-cli/api";
+var PERMISSION_PROPAGATION_WARNING = "Note: Permission changes may take up to 48 hours to propagate.";
+async function listUsers(client, developerId, options) {
+  if (options?.limit || options?.nextPage) {
+    const result = await paginateAll5(
+      async (pageToken) => {
+        const resp = await client.list(developerId, { pageToken, pageSize: options?.pageSize });
+        return { items: resp.users || [], nextPageToken: resp.nextPageToken };
+      },
+      { limit: options.limit, startPageToken: options.nextPage }
+    );
+    return { users: result.items, nextPageToken: result.nextPageToken };
+  }
+  const response = await client.list(developerId, options);
+  return { users: response.users || [], nextPageToken: response.nextPageToken };
+}
+async function getUser(client, developerId, userId) {
+  return client.get(developerId, userId);
+}
+async function inviteUser(client, developerId, email, permissions, grants) {
+  const user = { email };
+  if (permissions) user.developerAccountPermission = permissions;
+  if (grants) user.grants = grants;
+  return client.create(developerId, user);
+}
+async function updateUser(client, developerId, userId, permissions, grants) {
+  const updates = {};
+  const masks = [];
+  if (permissions) {
+    updates.developerAccountPermission = permissions;
+    masks.push("developerAccountPermission");
+  }
+  if (grants) {
+    updates.grants = grants;
+    masks.push("grants");
+  }
+  const updateMask = masks.length > 0 ? masks.join(",") : void 0;
+  return client.update(developerId, userId, updates, updateMask);
+}
+async function removeUser(client, developerId, userId) {
+  return client.delete(developerId, userId);
+}
+function parseGrantArg(grantStr) {
+  const colonIdx = grantStr.indexOf(":");
+  if (colonIdx === -1) {
+    throw new Error(
+      `Invalid grant format "${grantStr}". Expected <packageName>:<PERMISSION>[,<PERMISSION>...]`
+    );
+  }
+  const packageName = grantStr.slice(0, colonIdx);
+  const perms = grantStr.slice(colonIdx + 1).split(",");
+  return { packageName, appLevelPermissions: perms };
+}
+
+// src/commands/testers.ts
+import { readFile as readFile5 } from "fs/promises";
+async function listTesters(client, packageName, track) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const testers = await client.testers.get(packageName, edit.id, track);
+    return testers;
+  } finally {
+    await client.edits.delete(packageName, edit.id);
+  }
+}
+async function addTesters(client, packageName, track, groupEmails) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const current = await client.testers.get(packageName, edit.id, track);
+    const existing = new Set(current.googleGroups || []);
+    for (const email of groupEmails) {
+      existing.add(email.trim());
+    }
+    const updated = await client.testers.update(packageName, edit.id, track, {
+      googleGroups: [...existing]
+    });
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return updated;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+async function removeTesters(client, packageName, track, groupEmails) {
+  const edit = await client.edits.insert(packageName);
+  try {
+    const current = await client.testers.get(packageName, edit.id, track);
+    const toRemove = new Set(groupEmails.map((e) => e.trim()));
+    const filtered = (current.googleGroups || []).filter(
+      (g) => !toRemove.has(g)
+    );
+    const updated = await client.testers.update(packageName, edit.id, track, {
+      googleGroups: filtered
+    });
+    await client.edits.validate(packageName, edit.id);
+    await client.edits.commit(packageName, edit.id);
+    return updated;
+  } catch (error) {
+    await client.edits.delete(packageName, edit.id).catch(() => {
+    });
+    throw error;
+  }
+}
+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}.`);
+  }
+  const testers = await addTesters(client, packageName, track, emails);
+  return { added: emails.length, testers };
+}
+
+// src/utils/safe-path.ts
+import { resolve, normalize } from "path";
+function safePath(userPath) {
+  return resolve(normalize(userPath));
+}
+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}"`
+    );
+  }
+  return resolved;
+}
+
+// src/commands/plugin-scaffold.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } 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 files = [];
+  const pkg = {
+    name: pluginName,
+    version: "0.1.0",
+    description,
+    type: "module",
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    exports: {
+      ".": {
+        import: "./dist/index.js",
+        types: "./dist/index.d.ts"
+      }
+    },
+    files: ["dist"],
+    scripts: {
+      build: "tsup src/index.ts --format esm --dts",
+      dev: "tsup src/index.ts --format esm --dts --watch",
+      test: "vitest run",
+      "test:watch": "vitest"
+    },
+    keywords: ["gpc", "gpc-plugin", "google-play"],
+    license: "MIT",
+    peerDependencies: {
+      "@gpc-cli/plugin-sdk": ">=0.8.0"
+    },
+    devDependencies: {
+      "@gpc-cli/plugin-sdk": "^0.8.0",
+      tsup: "^8.0.0",
+      typescript: "^5.0.0",
+      vitest: "^3.0.0"
+    }
+  };
+  await writeFile2(join4(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+  files.push("package.json");
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      declaration: true,
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "./dist",
+      rootDir: "./src"
+    },
+    include: ["src"]
+  };
+  await writeFile2(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";
+
+export const plugin = definePlugin({
+  name: "${pluginName}",
+  version: "0.1.0",
+
+  register(hooks) {
+    hooks.beforeCommand(async (event: CommandEvent) => {
+      // Called before every gpc command
+      // Example: log command usage, validate prerequisites, etc.
+    });
+
+    hooks.afterCommand(async (event: CommandEvent, result: CommandResult) => {
+      // Called after every successful gpc command
+      // Example: send notifications, update dashboards, etc.
+    });
+
+    // Uncomment to add custom commands:
+    // hooks.registerCommands((registry) => {
+    //   registry.add({
+    //     name: "${shortName}",
+    //     description: "${description}",
+    //     action: async (args, opts) => {
+    //       console.log("Hello from ${pluginName}!");
+    //     },
+    //   });
+    // });
+  },
+});
+`;
+  await writeFile2(join4(srcDir, "index.ts"), srcContent);
+  files.push("src/index.ts");
+  const testContent = `import { describe, it, expect, vi } from "vitest";
+import { plugin } from "../src/index";
+
+describe("${pluginName}", () => {
+  it("has correct name and version", () => {
+    expect(plugin.name).toBe("${pluginName}");
+    expect(plugin.version).toBe("0.1.0");
+  });
+
+  it("registers without errors", () => {
+    const hooks = {
+      beforeCommand: vi.fn(),
+      afterCommand: vi.fn(),
+      onError: vi.fn(),
+      beforeRequest: vi.fn(),
+      afterResponse: vi.fn(),
+      registerCommands: vi.fn(),
+    };
+
+    expect(() => plugin.register(hooks)).not.toThrow();
+  });
+});
+`;
+  await writeFile2(join4(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";
+var auditDir = null;
+function initAudit(configDir) {
+  auditDir = configDir;
+}
+async function writeAuditLog(entry) {
+  if (!auditDir) return;
+  try {
+    await mkdir3(auditDir, { recursive: true, mode: 448 });
+    const logPath = join5(auditDir, "audit.log");
+    const redactedEntry = redactAuditArgs(entry);
+    const line = JSON.stringify(redactedEntry) + "\n";
+    await appendFile(logPath, line, { encoding: "utf-8", mode: 384 });
+    await chmod(logPath, 384).catch(() => {
+    });
+  } catch {
+  }
+}
+var SENSITIVE_ARG_KEYS = /* @__PURE__ */ new Set([
+  "key",
+  "keyFile",
+  "key-file",
+  "serviceAccount",
+  "service-account",
+  "token",
+  "password",
+  "secret",
+  "credentials",
+  "private_key",
+  "client_secret"
+]);
+function redactAuditArgs(entry) {
+  const redacted = {};
+  for (const [k, v] of Object.entries(entry.args)) {
+    redacted[k] = SENSITIVE_ARG_KEYS.has(k) ? "[REDACTED]" : v;
+  }
+  return { ...entry, args: redacted };
+}
+function createAuditEntry(command, args, app) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    command,
+    app,
+    args
+  };
+}
+export {
+  ApiError,
+  ConfigError,
+  GOOGLE_PLAY_LANGUAGES,
+  GpcError,
+  NetworkError,
+  PERMISSION_PROPAGATION_WARNING,
+  PluginManager,
+  acknowledgeProductPurchase,
+  activateBasePlan,
+  activateOffer,
+  addTesters,
+  cancelSubscriptionPurchase,
+  checkThreshold,
+  compareVitalsTrend,
+  consumeProductPurchase,
+  convertRegionPrices,
+  createAuditEntry,
+  createInAppProduct,
+  createOffer,
+  createSubscription,
+  deactivateBasePlan,
+  deactivateOffer,
+  deferSubscriptionPurchase,
+  deleteBasePlan,
+  deleteImage,
+  deleteInAppProduct,
+  deleteListing,
+  deleteOffer,
+  deleteSubscription,
+  detectOutputFormat,
+  diffListings,
+  discoverPlugins,
+  downloadReport,
+  exportReviews,
+  formatOutput,
+  getAppInfo,
+  getCountryAvailability,
+  getInAppProduct,
+  getListings,
+  getOffer,
+  getProductPurchase,
+  getReleasesStatus,
+  getReview,
+  getSubscription,
+  getSubscriptionPurchase,
+  getUser,
+  getVitalsAnomalies,
+  getVitalsAnr,
+  getVitalsBattery,
+  getVitalsCrashes,
+  getVitalsMemory,
+  getVitalsOverview,
+  getVitalsRendering,
+  getVitalsStartup,
+  importTestersFromCsv,
+  initAudit,
+  inviteUser,
+  isFinancialReportType,
+  isStatsReportType,
+  isValidBcp47,
+  isValidReportType,
+  isValidStatsDimension,
+  listImages,
+  listInAppProducts,
+  listOffers,
+  listReports,
+  listReviews,
+  listSubscriptions,
+  listTesters,
+  listTracks,
+  listUsers,
+  listVoidedPurchases,
+  migratePrices,
+  parseGrantArg,
+  parseMonth,
+  promoteRelease,
+  publish,
+  pullListings,
+  pushListings,
+  readListingsFromDir,
+  readReleaseNotesFromDir,
+  redactSensitive,
+  refundOrder,
+  removeTesters,
+  removeUser,
+  replyToReview,
+  revokeSubscriptionPurchase,
+  safePath,
+  safePathWithin,
+  scaffoldPlugin,
+  searchVitalsErrors,
+  syncInAppProducts,
+  updateAppDetails,
+  updateInAppProduct,
+  updateListing,
+  updateOffer,
+  updateRollout,
+  updateSubscription,
+  updateUser,
+  uploadImage,
+  uploadRelease,
+  validateImage,
+  validatePreSubmission,
+  validateReleaseNotes,
+  validateUploadFile,
+  writeAuditLog,
+  writeListingsToDir
+};
+//# sourceMappingURL=index.js.map