shipthis 0.1.35 → 0.1.37

package/dist/index-CmuXyPed.js

@@ -0,0 +1,1905 @@
+import * as fs from 'node:fs';
+import fs__default from 'node:fs';
+import axios from 'axios';
+import CryptoJS from 'crypto-js';
+import { v4 } from 'uuid';
+import { DateTime } from 'luxon';
+import path from 'node:path';
+import chalk from 'chalk';
+import { Command, Flags } from '@oclif/core';
+import * as expo from '@expo/apple-utils/build/index.js';
+import crypto from 'node:crypto';
+import { promises } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import readlineSync from 'readline-sync';
+import 'isomorphic-git';
+import merge from 'deepmerge';
+import { parse } from 'ini';
+import { QueryClient, useQuery } from '@tanstack/react-query';
+import React, { useState, useEffect, useContext, useRef } from 'react';
+import 'fast-glob';
+import 'yazl';
+import 'socket.io-client';
+import 'fullscreen-ink';
+import { useStdin, useInput, Text, Box } from 'ink';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import Spinner from 'ink-spinner';
+import 'string-length';
+import 'strip-ansi';
+import open from 'open';
+import '@inkjs/ui';
+import require$$0 from 'fs';
+import require$$1 from 'path';
+import { setOptions, parse as parse$1 } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+import 'qrcode';
+
+const cacheKeys = {
+  androidKeyTestResult: (props) => ["androidKeyTestResult", ...Object.values(props)],
+  androidSetupStatus: (props) => ["androidSetupStatus", ...Object.values(props)],
+  builds: (props) => ["builds", ...Object.values(props)],
+  googleStatus: () => ["googleStatus"],
+  job: (props) => ["job", ...Object.values(props)],
+  jobLogs: (props) => ["jobLogs", ...Object.values(props)],
+  jobs: (props) => ["jobs", ...Object.values(props)],
+  projectCredentials: (props) => ["projectCredentials", ...Object.values(props)],
+  userCredentials: (props) => ["userCredentials", ...Object.values(props)]
+};
+
+const AUTH_ENV_VAR_NAME = "SHIPTHIS_TOKEN";
+const DOMAIN_ENV_VAR_NAME = "SHIPTHIS_DOMAIN";
+const DEFAULT_SHIPPED_FILES_GLOBS = ["**/*"];
+const DEFAULT_IGNORED_FILES_GLOBS = [
+  ".git",
+  ".gitignore",
+  "shipthis.json",
+  "shipthis-*.zip",
+  ".godot/**",
+  ".nomedia",
+  ".import/**",
+  "export.cfg",
+  "export_credentials.cfg",
+  "*.translation",
+  ".mono/**",
+  "data_*/**",
+  "mono_crash.*.json"
+];
+const PRIMARY_DOMAIN = "shipth.is";
+function getUrlsForDomain(domain) {
+  const isPublic = domain.includes(PRIMARY_DOMAIN);
+  const apiDomain = (isPublic ? `api.` : "") + domain;
+  const wsDomain = (isPublic ? `ws.` : "") + domain;
+  return {
+    api: `https://${apiDomain}/api/1.0.0`,
+    web: `https://${domain}/`,
+    ws: `wss://${wsDomain}`
+  };
+}
+const DOMAIN = process.env[DOMAIN_ENV_VAR_NAME] || PRIMARY_DOMAIN;
+const BACKEND_URLS = getUrlsForDomain(DOMAIN);
+const API_URL = BACKEND_URLS.api;
+const WS_URL = BACKEND_URLS.ws;
+const WEB_URL = BACKEND_URLS.web;
+
+const DEFAULT_LOCALE = "en-US";
+function castObjectDates(apiObject, keys = ["createdAt", "updatedAt"]) {
+  if (!apiObject) return apiObject;
+  const datesOnly = Object.keys(apiObject).filter((k) => keys.includes(k)).reduce((a, c) => {
+    if (!apiObject[c]) return a;
+    a[c] = DateTime.fromISO(apiObject[c]);
+    return a;
+  }, {});
+  return {
+    ...apiObject,
+    ...datesOnly
+  };
+}
+function castArrayObjectDates(apiArray, keys = ["createdAt", "updatedAt"]) {
+  return apiArray.map((apiObject) => castObjectDates(apiObject, keys));
+}
+function castJobDates(jobObject) {
+  if (jobObject.build) return castObjectDates({ ...jobObject, build: castObjectDates(jobObject.build) });
+  return castObjectDates(jobObject);
+}
+function getDateLocale() {
+  const fallback = Intl.DateTimeFormat().resolvedOptions().locale.replaceAll("_", "-") || DEFAULT_LOCALE;
+  try {
+    const { env } = process;
+    const fullLocale = env.LC_TIME || env.LANG || env.LANGUAGE || env.LC_ALL || env.LC_MESSAGES;
+    const shortLocale = fullLocale?.split(".")[0].replaceAll("_", "-");
+    const finalLocal = shortLocale || fallback;
+    const _ = DateTime.now().toLocaleString(DateTime.DATE_SHORT, { locale: finalLocal });
+    return finalLocal;
+  } catch {
+    return fallback;
+  }
+}
+function getShortDate(inputDate) {
+  const locale = getDateLocale();
+  return inputDate.toLocaleString(DateTime.DATE_SHORT, { locale });
+}
+function getShortDateTime(inputDate, extraFormatOpts = {}) {
+  const locale = getDateLocale();
+  const formatOpts = { ...DateTime.DATETIME_SHORT, ...extraFormatOpts };
+  return inputDate.toLocaleString(formatOpts, { locale });
+}
+function getShortTime(inputDate, extraFormatOpts = { fractionalSecondDigits: 3 }) {
+  const locale = getDateLocale();
+  const formatOpts = { ...DateTime.TIME_24_WITH_SECONDS, ...extraFormatOpts };
+  return inputDate.toLocaleString(formatOpts, { locale });
+}
+function getShortTimeDelta(start, end) {
+  return end.diff(start).rescale().set({ milliseconds: 0 }).shiftTo("minutes", "seconds").toHuman({
+    listStyle: "short",
+    unitDisplay: "short"
+  });
+}
+
+let currentAuthToken;
+function setAuthToken(token) {
+  currentAuthToken = token;
+}
+function getAuthToken() {
+  return currentAuthToken;
+}
+function getAuthedHeaders() {
+  return {
+    Authorization: `Bearer ${currentAuthToken}`
+  };
+}
+async function createProject(props) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.post(`${API_URL}/projects`, props, opt);
+  return castObjectDates(data);
+}
+async function getProject(projectId) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.get(`${API_URL}/projects/${projectId}`, opt);
+  return castObjectDates(data);
+}
+async function getProjects(params) {
+  const headers = getAuthedHeaders();
+  const opt = { headers, params };
+  const { data: rawData } = await axios.get(`${API_URL}/projects`, opt);
+  const data = castArrayObjectDates(rawData.data);
+  return {
+    data,
+    pageCount: rawData.pageCount
+  };
+}
+async function updateProject(projectId, edits) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.put(`${API_URL}/projects/${projectId}`, edits, opt);
+  return castObjectDates(data);
+}
+async function getProjectPlatformProgress(projectId, platform) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.get(`${API_URL}/projects/${projectId}/${platform}/progress`, opt);
+  return data;
+}
+async function getNewUploadTicket(projectId) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.post(`${API_URL}/upload/${projectId}/url`, {}, opt);
+  return data;
+}
+async function startJobsFromUpload(uploadTicketId, startOptions) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.post(`${API_URL}/upload/start/${uploadTicketId}`, startOptions, opt);
+  return castArrayObjectDates(data);
+}
+async function getProjectJobs(projectId, params) {
+  const headers = getAuthedHeaders();
+  const opt = { headers, params };
+  const { data: rawData } = await axios.get(`${API_URL}/projects/${projectId}/jobs`, opt);
+  const data = castArrayObjectDates(rawData.data);
+  return {
+    data,
+    pageCount: rawData.pageCount
+  };
+}
+async function getJob(jobId, projectId) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.get(`${API_URL}/projects/${projectId}/jobs/${jobId}`, opt);
+  return castJobDates(data);
+}
+async function getSingleUseUrl(destination) {
+  const headers = await getAuthedHeaders();
+  const { data } = await axios.post(`${API_URL}/me/otp`, {}, { headers });
+  const queryString = Object.entries({ ...data, destination }).map(([key, value]) => `${key}=${encodeURIComponent(`${value}`)}`).join("&");
+  const url = `${WEB_URL}exchange/?${queryString}`;
+  return url;
+}
+async function getShortAuthRequiredUrl(destination) {
+  const { email } = await getSelf();
+  const key = v4();
+  const salt = "Na (s) + 1/2 Cl\u2082 (g) \u2192 NaCl (s)";
+  const fullKey = `${key}${salt}`;
+  const token = CryptoJS.AES.encrypt(email, fullKey).toString();
+  const params = {
+    destination,
+    key,
+    token
+  };
+  const queryString = Object.entries(params).map(([key2, value]) => `${key2}=${encodeURIComponent(`${value}`)}`).join("&");
+  const url = `${WEB_URL}login/?${queryString}`;
+  const headers = await getAuthedHeaders();
+  const { data } = await axios.post(
+    `${API_URL}/me/shorten`,
+    {
+      url
+    },
+    { headers }
+  );
+  return data.url;
+}
+async function getBuild(projectId, buildId) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.get(`${API_URL}/projects/${projectId}/builds/${buildId}`, opt);
+  return castObjectDates(data);
+}
+async function getSelf() {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.get(`${API_URL}/me`, opt);
+  return castObjectDates(data);
+}
+async function getTerms() {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.get(`${API_URL}/me/terms`, opt);
+  return {
+    // Any agreements which have changed since the user last accepted terms
+    changes: castArrayObjectDates(data.changes),
+    // Current versions of any agreements
+    current: castArrayObjectDates(data.current)
+  };
+}
+async function acceptTerms() {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.post(`${API_URL}/me/terms`, {}, opt);
+  return castObjectDates(data);
+}
+async function getGoogleAuthUrl(projectId) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const web = encodeURIComponent(new URL("/google/redirect/", WEB_URL).href);
+  const url = `${API_URL}/projects/${projectId}/credentials/android/key/connect`;
+  const { data } = await axios.get(`${url}?redirectUri=${web}`, opt);
+  const response = data;
+  return await getShortAuthRequiredUrl(response.url);
+}
+async function disconnectGoogle() {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  await axios.delete(`${API_URL}/me/google/connect`, opt);
+}
+async function getGoogleStatus() {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.get(`${API_URL}/me/google/status`, opt);
+  return castObjectDates(data, ["orgCreatedAt"]);
+}
+async function enforcePolicy() {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.post(`${API_URL}/me/google/policy`, null, opt);
+  return castObjectDates(data, ["orgCreatedAt"]);
+}
+async function revokePolicy() {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.delete(`${API_URL}/me/google/policy`, opt);
+  return castObjectDates(data, ["orgCreatedAt"]);
+}
+async function inviteServiceAccount(projectId, developerId) {
+  try {
+    const headers = getAuthedHeaders();
+    const { data } = await axios.post(
+      `${API_URL}/projects/${projectId}/credentials/android/key/invite/`,
+      { developerId },
+      {
+        headers
+      }
+    );
+    return data;
+  } catch (error) {
+    console.error("inviteServiceAccount Error", error);
+    throw error;
+  }
+}
+async function downloadBuildById(projectId, buildId, fileName) {
+  const build = await getBuild(projectId, buildId);
+  const { url } = build;
+  const writer = fs.createWriteStream(fileName);
+  const response = await axios({
+    method: "GET",
+    responseType: "stream",
+    url
+  });
+  response.data.pipe(writer);
+  return new Promise((resolve, reject) => {
+    writer.on("finish", resolve);
+    writer.on("error", reject);
+  });
+}
+const APIKEYS_DATE_FIELDS = ["createdAt", "updatedAt", "expiresAt", "lastUsedAt", "revokedAt"];
+async function getAPIKeys(params) {
+  const headers = getAuthedHeaders();
+  const opt = { headers, params };
+  const { data: rawData } = await axios.get(`${API_URL}/me/keys`, opt);
+  const data = castArrayObjectDates(rawData.data, APIKEYS_DATE_FIELDS);
+  return {
+    data,
+    pageCount: rawData.pageCount
+  };
+}
+async function createAPIKey(createProps) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.post(`${API_URL}/me/keys`, createProps, opt);
+  return castObjectDates(data, APIKEYS_DATE_FIELDS);
+}
+async function revokeAPIKey(apiKeyId) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  await axios.delete(`${API_URL}/me/keys/${apiKeyId}`, opt);
+}
+
+const defaultExport = expo.default;
+const {
+  ApiKey,
+  ApiKeyType,
+  App,
+  Auth,
+  BetaGroup,
+  BundleId,
+  CapabilityType,
+  CapabilityTypeOption,
+  Certificate,
+  CertificateType,
+  Profile,
+  ProfileType,
+  Session,
+  UserRole
+} = defaultExport;
+
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["ANDROID"] = "ANDROID";
+  Platform2["IOS"] = "IOS";
+  return Platform2;
+})(Platform || {});
+var GameEngine = /* @__PURE__ */ ((GameEngine2) => {
+  GameEngine2["GODOT"] = "godot";
+  return GameEngine2;
+})(GameEngine || {});
+var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
+  JobStatus2["COMPLETED"] = "COMPLETED";
+  JobStatus2["FAILED"] = "FAILED";
+  JobStatus2["PENDING"] = "PENDING";
+  JobStatus2["PROCESSING"] = "PROCESSING";
+  return JobStatus2;
+})(JobStatus || {});
+var JobStage = /* @__PURE__ */ ((JobStage2) => {
+  JobStage2["BUILD"] = "BUILD";
+  JobStage2["CONFIGURE"] = "CONFIGURE";
+  JobStage2["EXPORT"] = "EXPORT";
+  JobStage2["PUBLISH"] = "PUBLISH";
+  JobStage2["SETUP"] = "SETUP";
+  return JobStage2;
+})(JobStage || {});
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["ERROR"] = "ERROR";
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARN"] = "WARN";
+  return LogLevel2;
+})(LogLevel || {});
+var CredentialsType = /* @__PURE__ */ ((CredentialsType2) => {
+  CredentialsType2["CERTIFICATE"] = "CERTIFICATE";
+  CredentialsType2["KEY"] = "KEY";
+  return CredentialsType2;
+})(CredentialsType || {});
+var BuildType = /* @__PURE__ */ ((BuildType2) => {
+  BuildType2["AAB"] = "AAB";
+  BuildType2["APK"] = "APK";
+  BuildType2["IPA"] = "IPA";
+  return BuildType2;
+})(BuildType || {});
+
+function isCWDGodotGame() {
+  const cwd = process.cwd();
+  const godotProject = path.join(cwd, "project.godot");
+  return fs__default.existsSync(godotProject);
+}
+const GODOT_CAPABILITIES = [
+  // TODO: how about capabilities from godot extensions
+  { key: "capabilities/access_wifi", name: "Access WiFi", type: CapabilityType.ACCESS_WIFI },
+  { key: "capabilities/push_notifications", name: "Push Notifications", type: CapabilityType.PUSH_NOTIFICATIONS }
+];
+function getGodotProjectCapabilities(platform) {
+  const exportPresets = getGodotExportPresets(platform);
+  const { options } = exportPresets;
+  const capabilities = [];
+  for (const capability of GODOT_CAPABILITIES) {
+    if (!(capability.key in options)) continue;
+    if (`${options[capability.key]}`.toLocaleLowerCase() === "true") capabilities.push(capability.type);
+  }
+  return capabilities;
+}
+function getGodotProjectConfig() {
+  const cwd = process.cwd();
+  const projectGodotPath = path.join(cwd, "project.godot");
+  const projectGodotContent = fs__default.readFileSync(projectGodotPath, "utf8");
+  return parse(projectGodotContent);
+}
+function getGodotProjectName() {
+  try {
+    const projectGodotConfig = getGodotProjectConfig();
+    return projectGodotConfig.application["config/name"];
+  } catch {
+    return null;
+  }
+}
+function getGodotAppleBundleIdentifier() {
+  try {
+    const preset = getGodotExportPresets(Platform.IOS);
+    return preset.options["application/bundle_identifier"];
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+}
+function getGodotAndroidPackageName() {
+  try {
+    const preset = getGodotExportPresets(Platform.ANDROID);
+    return preset.options["package/unique_name"];
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+}
+function getGodotVersion() {
+  const projectGodotConfig = getGodotProjectConfig();
+  if ("config/features" in projectGodotConfig.application) {
+    const features = projectGodotConfig.application["config/features"];
+    const match = features.match(/"(\d+\.\d+)"/);
+    if (!match) throw new Error("Couldn't find Godot version in project.godot");
+    return match[1];
+  }
+  return "3.6";
+}
+function getGodotExportPresets(platform) {
+  const { warn } = console;
+  let presetConfig = platform === Platform.IOS ? getBaseExportPresets_iOS() : getBaseExportPresets_Android();
+  const cwd = process.cwd();
+  const filename = "export_presets.cfg";
+  const exportPresetsPath = path.join(cwd, filename);
+  const isFound = fs__default.existsSync(exportPresetsPath);
+  if (isFound) {
+    const exportPresetsContent = fs__default.readFileSync(exportPresetsPath, "utf8");
+    const exportPresetsIni = parse(exportPresetsContent);
+    const presetIndexes = Object.keys(exportPresetsIni.preset || {});
+    const presetIndex = presetIndexes.find((index) => {
+      const current = exportPresetsIni.preset[index];
+      return `${current.name}`.toUpperCase() === platform;
+    });
+    if (presetIndex) {
+      presetConfig = merge(presetConfig, exportPresetsIni.preset[presetIndex]);
+    } else {
+      warn(`Preset ${platform} not found in ${filename} - will use defaults`);
+    }
+  } else {
+    warn(`${filename} not found at ${exportPresetsPath}`);
+  }
+  return presetConfig;
+}
+function getBaseExportPresets_iOS() {
+  return {
+    custom_features: "",
+    dedicated_server: false,
+    encrypt_directory: false,
+    encrypt_pck: false,
+    encryption_exclude_filters: "",
+    encryption_include_filters: "",
+    exclude_filter: "",
+    export_filter: "all_resources",
+    export_path: "output",
+    include_filter: "",
+    name: "iOS",
+    options: {
+      "application/export_project_only": true,
+      "application/icon_interpolation": "4",
+      "application/launch_screens_interpolation": "4",
+      "application/short_version": "1.0.0",
+      // default version number
+      "application/signature": "",
+      "architectures/arm64": true,
+      "capabilities/access_wifi": false,
+      "capabilities/push_notifications": false,
+      "custom_template/debug": "",
+      "custom_template/release": "",
+      "icons/app_store_1024x1024": "",
+      "icons/ipad_76x76": "",
+      "icons/ipad_152x152": "",
+      "icons/ipad_167x167": "",
+      "icons/iphone_120x120": "",
+      "icons/iphone_180x180": "",
+      "icons/notification_40x40": "",
+      "icons/notification_60x60": "",
+      "icons/settings_58x58": "",
+      "icons/settings_87x87": "",
+      "icons/spotlight_40x40": "",
+      "icons/spotlight_80x80": "",
+      "landscape_launch_screens/ipad_1024x768": "",
+      "landscape_launch_screens/ipad_2048x1536": "",
+      "landscape_launch_screens/iphone_2208x1242": "",
+      "landscape_launch_screens/iphone_2436x1125": "",
+      "portrait_launch_screens/ipad_768x1024": "",
+      "portrait_launch_screens/ipad_1536x2048": "",
+      "portrait_launch_screens/iphone_640x960": "",
+      "portrait_launch_screens/iphone_640x1136": "",
+      "portrait_launch_screens/iphone_750x1334": "",
+      "portrait_launch_screens/iphone_1125x2436": "",
+      "portrait_launch_screens/iphone_1242x2208": "",
+      "privacy/camera_usage_description": "",
+      "privacy/camera_usage_description_localized": "{}",
+      "privacy/microphone_usage_description": "",
+      "privacy/microphone_usage_description_localized": "{}",
+      "privacy/photolibrary_usage_description": "",
+      "privacy/photolibrary_usage_description_localized": "{}",
+      "storyboard/custom_bg_color": "Color(0, 0, 0, 1)",
+      "storyboard/custom_image@2x": "",
+      "storyboard/custom_image@3x": "",
+      "storyboard/image_scale_mode": "0",
+      "storyboard/use_custom_bg_color": false,
+      "storyboard/use_launch_screen_storyboard": true,
+      "user_data/accessible_from_files_app": false,
+      "user_data/accessible_from_itunes_sharing": false
+    },
+    platform: "iOS",
+    runnable: true
+  };
+}
+function getBaseExportPresets_Android() {
+  return {
+    name: "Android",
+    // TODO
+    options: {
+      // TODO
+    },
+    platform: "Android"
+  };
+}
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 50
+    }
+  }
+});
+
+var KeyTestStatus = /* @__PURE__ */ ((KeyTestStatus2) => {
+  KeyTestStatus2["ERROR"] = "error";
+  KeyTestStatus2["SUCCESS"] = "success";
+  return KeyTestStatus2;
+})(KeyTestStatus || {});
+var KeyTestError = /* @__PURE__ */ ((KeyTestError2) => {
+  KeyTestError2["APP_NOT_FOUND"] = "app_not_found";
+  KeyTestError2["NO_PACKAGE_NAME"] = "no_package_name";
+  KeyTestError2["NO_SERVICE_ACCOUNT_KEY"] = "no_service_account_key";
+  KeyTestError2["NOT_INVITED"] = "not_invited";
+  return KeyTestError2;
+})(KeyTestError || {});
+const KeyTestErrorMessage = {
+  ["app_not_found" /* APP_NOT_FOUND */]: "Application not found in Google Play Console",
+  ["no_package_name" /* NO_PACKAGE_NAME */]: "Android Package Name has not been set",
+  ["no_service_account_key" /* NO_SERVICE_ACCOUNT_KEY */]: "Service Account API Key not found in your account",
+  ["not_invited" /* NOT_INVITED */]: "Service Account has not been invited to Google Play"
+};
+function niceError(keyError) {
+  return keyError ? KeyTestErrorMessage[keyError] : void 0;
+}
+const fetchKeyTestResult = async ({ projectId }, config) => {
+  if (!projectId) throw new Error("projectId is required");
+  const url = `${API_URL}/projects/${projectId}/credentials/android/key/test`;
+  const headers = getAuthedHeaders();
+  const { data } = await axios.post(url, {}, { headers, ...config });
+  return data;
+};
+const useAndroidServiceAccountTestResult = (props) => useQuery({
+  queryFn: () => fetchKeyTestResult(props),
+  queryKey: cacheKeys.androidKeyTestResult(props)
+});
+
+async function queryBuilds({ projectId, ...pageAndSortParams }) {
+  try {
+    const headers = getAuthedHeaders();
+    const url = `${API_URL}/projects/${projectId}/builds`;
+    const response = await axios.get(url, { headers, params: pageAndSortParams });
+    return {
+      ...response.data,
+      data: castArrayObjectDates(response.data.data)
+    };
+  } catch (error) {
+    console.warn("queryBuilds Error", error);
+    throw error;
+  }
+}
+function getBuildSummary(build) {
+  const ext = build.buildType || (build.platform === Platform.IOS ? "IPA" : "AAB");
+  const filename = `game.${ext.toLowerCase()}`;
+  const details = getJobDetailsSummary(build.jobDetails);
+  const summary = {};
+  summary.id = getShortUUID(build.id);
+  summary.version = details.version;
+  summary.gitInfo = details.gitInfo;
+  summary.platform = getPlatformName(build.platform);
+  summary.jobId = getShortUUID(build.jobId);
+  summary.createdAt = getShortDateTime(build.createdAt);
+  summary.cmd = `shipthis game build download ${getShortUUID(build.id)} ${filename}`;
+  return summary;
+}
+const useBuilds = (props) => {
+  const queryResult = useQuery({
+    queryFn: async () => queryBuilds(props),
+    queryKey: cacheKeys.builds(props)
+  });
+  return queryResult;
+};
+
+function getJobDetailsSummary(jobDetails) {
+  const semanticVersion = jobDetails?.semanticVersion || "N/A";
+  const buildNumber = jobDetails?.buildNumber || "N/A";
+  const gitCommit = jobDetails?.gitCommitHash ? getShortUUID(jobDetails.gitCommitHash) : "";
+  const gitBranch = jobDetails?.gitBranch || "";
+  const details = {};
+  details.version = `${semanticVersion} (${buildNumber})`;
+  details.gitInfo = gitCommit ? `${gitCommit} (${gitBranch})` : "";
+  return details;
+}
+function getJobSummary(job, timeNow) {
+  const inProgress = ![JobStatus.COMPLETED, JobStatus.FAILED].includes(job.status);
+  const details = getJobDetailsSummary(job.details);
+  const summary = {};
+  summary.id = getShortUUID(job.id);
+  summary.version = details.version;
+  summary.gitInfo = details.gitInfo;
+  summary.platform = getPlatformName(job.type);
+  summary.status = job.status;
+  summary.createdAt = getShortDateTime(job.createdAt);
+  summary.runtime = getShortTimeDelta(job.createdAt, inProgress ? timeNow : job.updatedAt);
+  return summary;
+}
+const useJob = (props) => useQuery({
+  queryFn: () => getJob(props.jobId, props.projectId),
+  queryKey: cacheKeys.job(props)
+});
+
+const useSafeInput = (handler, options = { isActive: true }) => {
+  const { isRawModeSupported } = useStdin();
+  const isActive = isRawModeSupported === true && options.isActive !== false;
+  useInput(
+    (input, key) => {
+      const lowerInput = input.toLowerCase();
+      return handler(lowerInput, key);
+    },
+    { isActive }
+  );
+};
+
+function getShortUUID(originalUuid) {
+  return originalUuid.slice(0, 8);
+}
+function getStageColor(stage) {
+  switch (stage) {
+    case JobStage.SETUP: {
+      return "#FFB3B3";
+    }
+    // pastel red
+    case JobStage.CONFIGURE: {
+      return "#FFD9B3";
+    }
+    // pastel orange
+    case JobStage.EXPORT: {
+      return "#FFFACD";
+    }
+    // pastel yellow
+    case JobStage.BUILD: {
+      return "#B3FFB3";
+    }
+    // pastel green
+    case JobStage.PUBLISH: {
+      return "#B3D9FF";
+    }
+  }
+}
+function getMessageColor(level) {
+  switch (level) {
+    case LogLevel.INFO: {
+      return "white";
+    }
+    case LogLevel.WARN: {
+      return "yellow";
+    }
+    case LogLevel.ERROR: {
+      return "red";
+    }
+  }
+}
+function getJobStatusColor(status) {
+  switch (status) {
+    case JobStatus.PENDING: {
+      return "yellow";
+    }
+    case JobStatus.PROCESSING: {
+      return "blue";
+    }
+    case JobStatus.COMPLETED: {
+      return "green";
+    }
+    case JobStatus.FAILED: {
+      return "red";
+    }
+  }
+}
+async function getFileHash(filename) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const rs = fs__default.createReadStream(filename);
+    rs.on("error", reject);
+    rs.on("data", (chunk) => hash.update(chunk));
+    rs.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+function isValidSemVer(versionString) {
+  const [semVer, major, minor, patch, prerelease, buildmetadata] = versionString.match(
+    /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][\dA-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][\dA-Za-z-]*))*))?(?:\+([\dA-Za-z-]+(?:\.[\dA-Za-z-]+)*))?$/
+  ) ?? [];
+  return Boolean(semVer);
+}
+function makeHumanReadable(rawObject) {
+  const getLabel = (key) => {
+    const words = key.split(/(?=[A-Z])/);
+    return words.map((word) => word[0].toUpperCase() + word.slice(1)).join(" ").replaceAll("  ", " ");
+  };
+  const withLabels = Object.entries(rawObject).reduce((acc, [key, value]) => {
+    acc[getLabel(key)] = value;
+    return acc;
+  }, {});
+  return withLabels;
+}
+function getPlatformName(platform) {
+  switch (platform) {
+    case Platform.IOS: {
+      return "iOS";
+    }
+    case Platform.ANDROID: {
+      return "Android";
+    }
+    default: {
+      throw new Error(`Unknown platform: ${platform}`);
+    }
+  }
+}
+async function getMaskedInput(message) {
+  const password = readlineSync.question(message, {
+    hideEchoBack: true
+    // This will hide the input as the user types
+  });
+  return password;
+}
+async function getInput(message) {
+  const rl = promises.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await rl.question(message);
+  rl.close();
+  return answer;
+}
+function generatePackageName(gameName) {
+  let normalizedGameName = gameName.trim().toLowerCase();
+  normalizedGameName = normalizedGameName.replaceAll(/[\s_\-]+/g, ".");
+  normalizedGameName = normalizedGameName.replaceAll(/[^\d.a-z]/g, "");
+  normalizedGameName = normalizedGameName.replaceAll(/\.+/g, ".");
+  normalizedGameName = normalizedGameName.replace(/^\./, "").replace(/\.$/, "");
+  if (/^\d/.test(normalizedGameName)) {
+    normalizedGameName = "app." + normalizedGameName;
+  }
+  const prefix = "com.";
+  if (normalizedGameName === "") {
+    return null;
+  }
+  return prefix + normalizedGameName;
+}
+function scriptDir(importMeta) {
+  const filename = fileURLToPath(importMeta.url);
+  const dirname = path.dirname(filename);
+  return dirname;
+}
+
+class BaseCommand extends Command {
+  // define flags that can be inherited by any command that extends BaseCommand
+  static baseFlags = {};
+  // add the --json flag
+  static enableJsonFlag = false;
+  args;
+  flags;
+  async catch(err) {
+    return super.catch(err);
+  }
+  // Used in baseGameCommand and the other commands that need to ensure that the CWD is a Godot project
+  ensureWeAreInAProjectDir() {
+    if (!isCWDGodotGame()) {
+      this.error("No Godot project detected. Please run this from a godot project directory.", { exit: 1 });
+    }
+    if (!this.hasProjectConfig()) {
+      this.error(
+        'No ShipThis config found. Please run `shipthis game create --name "Space Invaders"` to create a game.',
+        { exit: 1 }
+      );
+    }
+  }
+  ensureWeHaveAppleCookies() {
+    if (!this.hasAuthConfigFile()) {
+      this.error("You must be authenticated with Apple in to use this command. Please run shipthis apple login", {
+        exit: 1
+      });
+    }
+  }
+  async finally(_) {
+    return super.finally(_);
+  }
+  // Used in the apple commands to get the cookies from the auth file
+  async getAppleCookies() {
+    const authConfig = await this.getAuthConfig();
+    if (!authConfig.appleCookies) return null;
+    return authConfig.appleCookies;
+  }
+  // Returns the current auth config - prefers to use the env var
+  async getAuthConfig() {
+    const envVarValue = process.env[AUTH_ENV_VAR_NAME];
+    if (!envVarValue) return await this.getAuthConfigFromFile();
+    setAuthToken(envVarValue);
+    const self = await getSelf();
+    const selfWithJwt = {
+      ...self,
+      jwt: envVarValue
+    };
+    return {
+      shipThisUser: selfWithJwt
+    };
+  }
+  // Loads the auth config from the file system
+  async getAuthConfigFromFile() {
+    const baseConfig = {};
+    const configPath = this.getAuthConfigPath();
+    if (!fs__default.existsSync(configPath)) return baseConfig;
+    const raw = await fs__default.promises.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.shipThisUser) {
+      setAuthToken(parsed.shipThisUser.jwt);
+    }
+    return {
+      ...baseConfig,
+      ...parsed
+    };
+  }
+  // This is used to expose the flags to the Android Wizard
+  getDetailsFlagsValues() {
+    const keys = Object.keys(DetailsFlags);
+    const values = {};
+    for (const key of keys) {
+      if (this.flags[key]) values[key] = this.flags[key];
+    }
+    return values;
+  }
+  // Exposing it to the react components using the CommandContext
+  getFlags() {
+    return this.flags;
+  }
+  getGameId() {
+    const { flags } = this;
+    if (flags.gameId) return flags.gameId;
+    const { project } = this.getProjectConfigSafe();
+    if (!project) return null;
+    return project.id;
+  }
+  async getProjectConfig() {
+    if (!this.hasProjectConfig()) throw new Error("No project config found");
+    return this.getProjectConfigSafe();
+  }
+  getProjectConfigSafe() {
+    if (!this.hasProjectConfig()) return {};
+    const configPath = this.getProjectConfigPath();
+    const raw = fs__default.readFileSync(configPath, "utf8");
+    return JSON.parse(raw);
+  }
+  hasAuthConfigFile() {
+    const configPath = this.getAuthConfigPath();
+    return fs__default.existsSync(configPath);
+  }
+  hasProjectConfig() {
+    const configPath = this.getProjectConfigPath();
+    return fs__default.existsSync(configPath);
+  }
+  // Tests the apple cookies
+  async hasValidAppleAuthState() {
+    try {
+      await this.refreshAppleAuthState();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async init() {
+    process.on("SIGINT", () => process.exit(0));
+    process.on("SIGTERM", () => process.exit(0));
+    await super.init();
+    const { args, flags } = await this.parse({
+      args: this.ctor.args,
+      baseFlags: super.ctor.baseFlags,
+      enableJsonFlag: this.ctor.enableJsonFlag,
+      flags: this.ctor.flags,
+      strict: this.ctor.strict
+    });
+    this.flags = flags;
+    this.args = args;
+    await this.getAuthConfig();
+  }
+  async isAuthenticated() {
+    const authConfig = await this.getAuthConfig();
+    return Boolean(authConfig.shipThisUser?.jwt);
+  }
+  async refreshAppleAuthState() {
+    const cookies = await this.getAppleCookies();
+    const rerunMessage = `Please run ${chalk.bold("shipthis apple login")} to authenticate with Apple.`;
+    if (!cookies) throw new Error(`No Apple cookies found. ${rerunMessage}`);
+    const authState = await Auth.loginWithCookiesAsync(
+      {
+        cookies
+      },
+      {}
+    );
+    if (!authState) throw new Error(`Failed to refresh Apple auth state. ${rerunMessage}`);
+    return authState;
+  }
+  // Pass undefined to logout
+  async setAppleCookies(cookies) {
+    const authConfig = await this.getAuthConfig();
+    await this.setAuthConfig({ ...authConfig, appleCookies: cookies });
+  }
+  // This is called after login to persist the JWT and user details
+  async setAuthConfig(config) {
+    const configPath = this.getAuthConfigPath();
+    await fs__default.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+  }
+  async setProjectConfig(config) {
+    const configPath = this.getProjectConfigPath();
+    await fs__default.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+  }
+  async updateProjectConfig(update) {
+    const config = await this.getProjectConfig();
+    await this.setProjectConfig({ ...config, ...update });
+  }
+  // Returns the values of the flags in DetailsFlags
+  getAuthConfigPath() {
+    return path.join(this.config.home, ".shipthis.auth.json");
+  }
+  getProjectConfigPath() {
+    return path.join(process.cwd(), "shipthis.json");
+  }
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var ejs$1 = {};
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	(function (exports) {
+		var regExpChars = /[|\\{}()[\]^$+*?.]/g;
+		var hasOwnProperty = Object.prototype.hasOwnProperty;
+		var hasOwn = function(obj, key) {
+		  return hasOwnProperty.apply(obj, [key]);
+		};
+		exports.escapeRegExpChars = function(string) {
+		  if (!string) {
+		    return "";
+		  }
+		  return String(string).replace(regExpChars, "\\$&");
+		};
+		var _ENCODE_HTML_RULES = {
+		  "&": "&",
+		  "<": "&lt;",
+		  ">": "&gt;",
+		  '"': "&#34;",
+		  "'": "&#39;"
+		};
+		var _MATCH_HTML = /[&<>'"]/g;
+		function encode_char(c) {
+		  return _ENCODE_HTML_RULES[c] || c;
+		}
+		var escapeFuncStr = `var _ENCODE_HTML_RULES = {
+      "&": "&amp;"
+    , "<": "&lt;"
+    , ">": "&gt;"
+    , '"': "&#34;"
+    , "'": "&#39;"
+    }
+  , _MATCH_HTML = /[&<>'"]/g;
+function encode_char(c) {
+  return _ENCODE_HTML_RULES[c] || c;
+};
+`;
+		exports.escapeXML = function(markup) {
+		  return markup == void 0 ? "" : String(markup).replace(_MATCH_HTML, encode_char);
+		};
+		function escapeXMLToString() {
+		  return Function.prototype.toString.call(this) + ";\n" + escapeFuncStr;
+		}
+		try {
+		  if (typeof Object.defineProperty === "function") {
+		    Object.defineProperty(exports.escapeXML, "toString", { value: escapeXMLToString });
+		  } else {
+		    exports.escapeXML.toString = escapeXMLToString;
+		  }
+		} catch (err) {
+		  console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
+		}
+		exports.shallowCopy = function(to, from) {
+		  from = from || {};
+		  if (to !== null && to !== void 0) {
+		    for (var p in from) {
+		      if (!hasOwn(from, p)) {
+		        continue;
+		      }
+		      if (p === "__proto__" || p === "constructor") {
+		        continue;
+		      }
+		      to[p] = from[p];
+		    }
+		  }
+		  return to;
+		};
+		exports.shallowCopyFromList = function(to, from, list) {
+		  list = list || [];
+		  from = from || {};
+		  if (to !== null && to !== void 0) {
+		    for (var i = 0; i < list.length; i++) {
+		      var p = list[i];
+		      if (typeof from[p] != "undefined") {
+		        if (!hasOwn(from, p)) {
+		          continue;
+		        }
+		        if (p === "__proto__" || p === "constructor") {
+		          continue;
+		        }
+		        to[p] = from[p];
+		      }
+		    }
+		  }
+		  return to;
+		};
+		exports.cache = {
+		  _data: {},
+		  set: function(key, val) {
+		    this._data[key] = val;
+		  },
+		  get: function(key) {
+		    return this._data[key];
+		  },
+		  remove: function(key) {
+		    delete this._data[key];
+		  },
+		  reset: function() {
+		    this._data = {};
+		  }
+		};
+		exports.hyphenToCamel = function(str) {
+		  return str.replace(/-[a-z]/g, function(match) {
+		    return match[1].toUpperCase();
+		  });
+		};
+		exports.createNullProtoObjWherePossible = function() {
+		  if (typeof Object.create == "function") {
+		    return function() {
+		      return /* @__PURE__ */ Object.create(null);
+		    };
+		  }
+		  if (!({ __proto__: null } instanceof Object)) {
+		    return function() {
+		      return { __proto__: null };
+		    };
+		  }
+		  return function() {
+		    return {};
+		  };
+		}();
+		exports.hasOwnOnlyObject = function(obj) {
+		  var o = exports.createNullProtoObjWherePossible();
+		  for (var p in obj) {
+		    if (hasOwn(obj, p)) {
+		      o[p] = obj[p];
+		    }
+		  }
+		  return o;
+		}; 
+	} (utils));
+	return utils;
+}
+
+var version = "3.1.10";
+var require$$3 = {
+	version: version};
+
+var hasRequiredEjs;
+
+function requireEjs () {
+	if (hasRequiredEjs) return ejs$1;
+	hasRequiredEjs = 1;
+	(function (exports) {
+		/**
+		 * @file Embedded JavaScript templating engine. {@link http://ejs.co}
+		 * @author Matthew Eernisse <mde@fleegix.org>
+		 * @author Tiancheng "Timothy" Gu <timothygu99@gmail.com>
+		 * @project EJS
+		 * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
+		 */
+		var fs = require$$0;
+		var path = require$$1;
+		var utils = requireUtils();
+		var scopeOptionWarned = false;
+		var _VERSION_STRING = require$$3.version;
+		var _DEFAULT_OPEN_DELIMITER = "<";
+		var _DEFAULT_CLOSE_DELIMITER = ">";
+		var _DEFAULT_DELIMITER = "%";
+		var _DEFAULT_LOCALS_NAME = "locals";
+		var _NAME = "ejs";
+		var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
+		var _OPTS_PASSABLE_WITH_DATA = [
+		  "delimiter",
+		  "scope",
+		  "context",
+		  "debug",
+		  "compileDebug",
+		  "client",
+		  "_with",
+		  "rmWhitespace",
+		  "strict",
+		  "filename",
+		  "async"
+		];
+		var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
+		var _BOM = /^\uFEFF/;
+		var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+		exports.cache = utils.cache;
+		exports.fileLoader = fs.readFileSync;
+		exports.localsName = _DEFAULT_LOCALS_NAME;
+		exports.promiseImpl = new Function("return this;")().Promise;
+		exports.resolveInclude = function(name, filename, isDir) {
+		  var dirname = path.dirname;
+		  var extname = path.extname;
+		  var resolve = path.resolve;
+		  var includePath = resolve(isDir ? filename : dirname(filename), name);
+		  var ext = extname(name);
+		  if (!ext) {
+		    includePath += ".ejs";
+		  }
+		  return includePath;
+		};
+		function resolvePaths(name, paths) {
+		  var filePath;
+		  if (paths.some(function(v) {
+		    filePath = exports.resolveInclude(name, v, true);
+		    return fs.existsSync(filePath);
+		  })) {
+		    return filePath;
+		  }
+		}
+		function getIncludePath(path2, options) {
+		  var includePath;
+		  var filePath;
+		  var views = options.views;
+		  var match = /^[A-Za-z]+:\\|^\//.exec(path2);
+		  if (match && match.length) {
+		    path2 = path2.replace(/^\/*/, "");
+		    if (Array.isArray(options.root)) {
+		      includePath = resolvePaths(path2, options.root);
+		    } else {
+		      includePath = exports.resolveInclude(path2, options.root || "/", true);
+		    }
+		  } else {
+		    if (options.filename) {
+		      filePath = exports.resolveInclude(path2, options.filename);
+		      if (fs.existsSync(filePath)) {
+		        includePath = filePath;
+		      }
+		    }
+		    if (!includePath && Array.isArray(views)) {
+		      includePath = resolvePaths(path2, views);
+		    }
+		    if (!includePath && typeof options.includer !== "function") {
+		      throw new Error('Could not find the include file "' + options.escapeFunction(path2) + '"');
+		    }
+		  }
+		  return includePath;
+		}
+		function handleCache(options, template) {
+		  var func;
+		  var filename = options.filename;
+		  var hasTemplate = arguments.length > 1;
+		  if (options.cache) {
+		    if (!filename) {
+		      throw new Error("cache option requires a filename");
+		    }
+		    func = exports.cache.get(filename);
+		    if (func) {
+		      return func;
+		    }
+		    if (!hasTemplate) {
+		      template = fileLoader(filename).toString().replace(_BOM, "");
+		    }
+		  } else if (!hasTemplate) {
+		    if (!filename) {
+		      throw new Error("Internal EJS error: no file name or template provided");
+		    }
+		    template = fileLoader(filename).toString().replace(_BOM, "");
+		  }
+		  func = exports.compile(template, options);
+		  if (options.cache) {
+		    exports.cache.set(filename, func);
+		  }
+		  return func;
+		}
+		function tryHandleCache(options, data, cb) {
+		  var result;
+		  if (!cb) {
+		    if (typeof exports.promiseImpl == "function") {
+		      return new exports.promiseImpl(function(resolve, reject) {
+		        try {
+		          result = handleCache(options)(data);
+		          resolve(result);
+		        } catch (err) {
+		          reject(err);
+		        }
+		      });
+		    } else {
+		      throw new Error("Please provide a callback function");
+		    }
+		  } else {
+		    try {
+		      result = handleCache(options)(data);
+		    } catch (err) {
+		      return cb(err);
+		    }
+		    cb(null, result);
+		  }
+		}
+		function fileLoader(filePath) {
+		  return exports.fileLoader(filePath);
+		}
+		function includeFile(path2, options) {
+		  var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);
+		  opts.filename = getIncludePath(path2, opts);
+		  if (typeof options.includer === "function") {
+		    var includerResult = options.includer(path2, opts.filename);
+		    if (includerResult) {
+		      if (includerResult.filename) {
+		        opts.filename = includerResult.filename;
+		      }
+		      if (includerResult.template) {
+		        return handleCache(opts, includerResult.template);
+		      }
+		    }
+		  }
+		  return handleCache(opts);
+		}
+		function rethrow(err, str, flnm, lineno, esc) {
+		  var lines = str.split("\n");
+		  var start = Math.max(lineno - 3, 0);
+		  var end = Math.min(lines.length, lineno + 3);
+		  var filename = esc(flnm);
+		  var context = lines.slice(start, end).map(function(line, i) {
+		    var curr = i + start + 1;
+		    return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
+		  }).join("\n");
+		  err.path = filename;
+		  err.message = (filename || "ejs") + ":" + lineno + "\n" + context + "\n\n" + err.message;
+		  throw err;
+		}
+		function stripSemi(str) {
+		  return str.replace(/;(\s*$)/, "$1");
+		}
+		exports.compile = function compile(template, opts) {
+		  var templ;
+		  if (opts && opts.scope) {
+		    if (!scopeOptionWarned) {
+		      console.warn("`scope` option is deprecated and will be removed in EJS 3");
+		      scopeOptionWarned = true;
+		    }
+		    if (!opts.context) {
+		      opts.context = opts.scope;
+		    }
+		    delete opts.scope;
+		  }
+		  templ = new Template(template, opts);
+		  return templ.compile();
+		};
+		exports.render = function(template, d, o) {
+		  var data = d || utils.createNullProtoObjWherePossible();
+		  var opts = o || utils.createNullProtoObjWherePossible();
+		  if (arguments.length == 2) {
+		    utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
+		  }
+		  return handleCache(opts, template)(data);
+		};
+		exports.renderFile = function() {
+		  var args = Array.prototype.slice.call(arguments);
+		  var filename = args.shift();
+		  var cb;
+		  var opts = { filename };
+		  var data;
+		  var viewOpts;
+		  if (typeof arguments[arguments.length - 1] == "function") {
+		    cb = args.pop();
+		  }
+		  if (args.length) {
+		    data = args.shift();
+		    if (args.length) {
+		      utils.shallowCopy(opts, args.pop());
+		    } else {
+		      if (data.settings) {
+		        if (data.settings.views) {
+		          opts.views = data.settings.views;
+		        }
+		        if (data.settings["view cache"]) {
+		          opts.cache = true;
+		        }
+		        viewOpts = data.settings["view options"];
+		        if (viewOpts) {
+		          utils.shallowCopy(opts, viewOpts);
+		        }
+		      }
+		      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
+		    }
+		    opts.filename = filename;
+		  } else {
+		    data = utils.createNullProtoObjWherePossible();
+		  }
+		  return tryHandleCache(opts, data, cb);
+		};
+		exports.Template = Template;
+		exports.clearCache = function() {
+		  exports.cache.reset();
+		};
+		function Template(text, optsParam) {
+		  var opts = utils.hasOwnOnlyObject(optsParam);
+		  var options = utils.createNullProtoObjWherePossible();
+		  this.templateText = text;
+		  this.mode = null;
+		  this.truncate = false;
+		  this.currentLine = 1;
+		  this.source = "";
+		  options.client = opts.client || false;
+		  options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
+		  options.compileDebug = opts.compileDebug !== false;
+		  options.debug = !!opts.debug;
+		  options.filename = opts.filename;
+		  options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
+		  options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
+		  options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
+		  options.strict = opts.strict || false;
+		  options.context = opts.context;
+		  options.cache = opts.cache || false;
+		  options.rmWhitespace = opts.rmWhitespace;
+		  options.root = opts.root;
+		  options.includer = opts.includer;
+		  options.outputFunctionName = opts.outputFunctionName;
+		  options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
+		  options.views = opts.views;
+		  options.async = opts.async;
+		  options.destructuredLocals = opts.destructuredLocals;
+		  options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
+		  if (options.strict) {
+		    options._with = false;
+		  } else {
+		    options._with = typeof opts._with != "undefined" ? opts._with : true;
+		  }
+		  this.opts = options;
+		  this.regex = this.createRegex();
+		}
+		Template.modes = {
+		  EVAL: "eval",
+		  ESCAPED: "escaped",
+		  RAW: "raw",
+		  COMMENT: "comment",
+		  LITERAL: "literal"
+		};
+		Template.prototype = {
+		  createRegex: function() {
+		    var str = _REGEX_STRING;
+		    var delim = utils.escapeRegExpChars(this.opts.delimiter);
+		    var open = utils.escapeRegExpChars(this.opts.openDelimiter);
+		    var close = utils.escapeRegExpChars(this.opts.closeDelimiter);
+		    str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
+		    return new RegExp(str);
+		  },
+		  compile: function() {
+		    var src;
+		    var fn;
+		    var opts = this.opts;
+		    var prepended = "";
+		    var appended = "";
+		    var escapeFn = opts.escapeFunction;
+		    var ctor;
+		    var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
+		    if (!this.source) {
+		      this.generateSource();
+		      prepended += '  var __output = "";\n  function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
+		      if (opts.outputFunctionName) {
+		        if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
+		          throw new Error("outputFunctionName is not a valid JS identifier.");
+		        }
+		        prepended += "  var " + opts.outputFunctionName + " = __append;\n";
+		      }
+		      if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
+		        throw new Error("localsName is not a valid JS identifier.");
+		      }
+		      if (opts.destructuredLocals && opts.destructuredLocals.length) {
+		        var destructuring = "  var __locals = (" + opts.localsName + " || {}),\n";
+		        for (var i = 0; i < opts.destructuredLocals.length; i++) {
+		          var name = opts.destructuredLocals[i];
+		          if (!_JS_IDENTIFIER.test(name)) {
+		            throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
+		          }
+		          if (i > 0) {
+		            destructuring += ",\n  ";
+		          }
+		          destructuring += name + " = __locals." + name;
+		        }
+		        prepended += destructuring + ";\n";
+		      }
+		      if (opts._with !== false) {
+		        prepended += "  with (" + opts.localsName + " || {}) {\n";
+		        appended += "  }\n";
+		      }
+		      appended += "  return __output;\n";
+		      this.source = prepended + this.source + appended;
+		    }
+		    if (opts.compileDebug) {
+		      src = "var __line = 1\n  , __lines = " + JSON.stringify(this.templateText) + "\n  , __filename = " + sanitizedFilename + ";\ntry {\n" + this.source + "} catch (e) {\n  rethrow(e, __lines, __filename, __line, escapeFn);\n}\n";
+		    } else {
+		      src = this.source;
+		    }
+		    if (opts.client) {
+		      src = "escapeFn = escapeFn || " + escapeFn.toString() + ";\n" + src;
+		      if (opts.compileDebug) {
+		        src = "rethrow = rethrow || " + rethrow.toString() + ";\n" + src;
+		      }
+		    }
+		    if (opts.strict) {
+		      src = '"use strict";\n' + src;
+		    }
+		    if (opts.debug) {
+		      console.log(src);
+		    }
+		    if (opts.compileDebug && opts.filename) {
+		      src = src + "\n//# sourceURL=" + sanitizedFilename + "\n";
+		    }
+		    try {
+		      if (opts.async) {
+		        try {
+		          ctor = new Function("return (async function(){}).constructor;")();
+		        } catch (e) {
+		          if (e instanceof SyntaxError) {
+		            throw new Error("This environment does not support async/await");
+		          } else {
+		            throw e;
+		          }
+		        }
+		      } else {
+		        ctor = Function;
+		      }
+		      fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
+		    } catch (e) {
+		      if (e instanceof SyntaxError) {
+		        if (opts.filename) {
+		          e.message += " in " + opts.filename;
+		        }
+		        e.message += " while compiling ejs\n\n";
+		        e.message += "If the above error is not helpful, you may want to try EJS-Lint:\n";
+		        e.message += "https://github.com/RyanZim/EJS-Lint";
+		        if (!opts.async) {
+		          e.message += "\n";
+		          e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
+		        }
+		      }
+		      throw e;
+		    }
+		    var returnedFn = opts.client ? fn : function anonymous(data) {
+		      var include = function(path2, includeData) {
+		        var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);
+		        if (includeData) {
+		          d = utils.shallowCopy(d, includeData);
+		        }
+		        return includeFile(path2, opts)(d);
+		      };
+		      return fn.apply(
+		        opts.context,
+		        [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]
+		      );
+		    };
+		    if (opts.filename && typeof Object.defineProperty === "function") {
+		      var filename = opts.filename;
+		      var basename = path.basename(filename, path.extname(filename));
+		      try {
+		        Object.defineProperty(returnedFn, "name", {
+		          value: basename,
+		          writable: false,
+		          enumerable: false,
+		          configurable: true
+		        });
+		      } catch (e) {
+		      }
+		    }
+		    return returnedFn;
+		  },
+		  generateSource: function() {
+		    var opts = this.opts;
+		    if (opts.rmWhitespace) {
+		      this.templateText = this.templateText.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
+		    }
+		    this.templateText = this.templateText.replace(/[ \t]*<%_/gm, "<%_").replace(/_%>[ \t]*/gm, "_%>");
+		    var self = this;
+		    var matches = this.parseTemplateText();
+		    var d = this.opts.delimiter;
+		    var o = this.opts.openDelimiter;
+		    var c = this.opts.closeDelimiter;
+		    if (matches && matches.length) {
+		      matches.forEach(function(line, index) {
+		        var closing;
+		        if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
+		          closing = matches[index + 2];
+		          if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
+		            throw new Error('Could not find matching close tag for "' + line + '".');
+		          }
+		        }
+		        self.scanLine(line);
+		      });
+		    }
+		  },
+		  parseTemplateText: function() {
+		    var str = this.templateText;
+		    var pat = this.regex;
+		    var result = pat.exec(str);
+		    var arr = [];
+		    var firstPos;
+		    while (result) {
+		      firstPos = result.index;
+		      if (firstPos !== 0) {
+		        arr.push(str.substring(0, firstPos));
+		        str = str.slice(firstPos);
+		      }
+		      arr.push(result[0]);
+		      str = str.slice(result[0].length);
+		      result = pat.exec(str);
+		    }
+		    if (str) {
+		      arr.push(str);
+		    }
+		    return arr;
+		  },
+		  _addOutput: function(line) {
+		    if (this.truncate) {
+		      line = line.replace(/^(?:\r\n|\r|\n)/, "");
+		      this.truncate = false;
+		    }
+		    if (!line) {
+		      return line;
+		    }
+		    line = line.replace(/\\/g, "\\\\");
+		    line = line.replace(/\n/g, "\\n");
+		    line = line.replace(/\r/g, "\\r");
+		    line = line.replace(/"/g, '\\"');
+		    this.source += '    ; __append("' + line + '")\n';
+		  },
+		  scanLine: function(line) {
+		    var self = this;
+		    var d = this.opts.delimiter;
+		    var o = this.opts.openDelimiter;
+		    var c = this.opts.closeDelimiter;
+		    var newLineCount = 0;
+		    newLineCount = line.split("\n").length - 1;
+		    switch (line) {
+		      case o + d:
+		      case o + d + "_":
+		        this.mode = Template.modes.EVAL;
+		        break;
+		      case o + d + "=":
+		        this.mode = Template.modes.ESCAPED;
+		        break;
+		      case o + d + "-":
+		        this.mode = Template.modes.RAW;
+		        break;
+		      case o + d + "#":
+		        this.mode = Template.modes.COMMENT;
+		        break;
+		      case o + d + d:
+		        this.mode = Template.modes.LITERAL;
+		        this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")\n';
+		        break;
+		      case d + d + c:
+		        this.mode = Template.modes.LITERAL;
+		        this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")\n';
+		        break;
+		      case d + c:
+		      case "-" + d + c:
+		      case "_" + d + c:
+		        if (this.mode == Template.modes.LITERAL) {
+		          this._addOutput(line);
+		        }
+		        this.mode = null;
+		        this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
+		        break;
+		      default:
+		        if (this.mode) {
+		          switch (this.mode) {
+		            case Template.modes.EVAL:
+		            case Template.modes.ESCAPED:
+		            case Template.modes.RAW:
+		              if (line.lastIndexOf("//") > line.lastIndexOf("\n")) {
+		                line += "\n";
+		              }
+		          }
+		          switch (this.mode) {
+		            // Just executing code
+		            case Template.modes.EVAL:
+		              this.source += "    ; " + line + "\n";
+		              break;
+		            // Exec, esc, and output
+		            case Template.modes.ESCAPED:
+		              this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))\n";
+		              break;
+		            // Exec and output
+		            case Template.modes.RAW:
+		              this.source += "    ; __append(" + stripSemi(line) + ")\n";
+		              break;
+		            case Template.modes.COMMENT:
+		              break;
+		            // Literal <%% mode, append as raw output
+		            case Template.modes.LITERAL:
+		              this._addOutput(line);
+		              break;
+		          }
+		        } else {
+		          this._addOutput(line);
+		        }
+		    }
+		    if (self.opts.compileDebug && newLineCount) {
+		      this.currentLine += newLineCount;
+		      this.source += "    ; __line = " + this.currentLine + "\n";
+		    }
+		  }
+		};
+		exports.escapeXML = utils.escapeXML;
+		exports.__express = exports.renderFile;
+		exports.VERSION = _VERSION_STRING;
+		exports.name = _NAME;
+		if (typeof window != "undefined") {
+		  window.ejs = exports;
+		} 
+	} (ejs$1));
+	return ejs$1;
+}
+
+var ejsExports = requireEjs();
+var ejs = /*@__PURE__*/getDefaultExportFromCjs(ejsExports);
+
+const cleanHyperlinks = (input) => (
+  // When we run in a <ScrollArea> the links break
+  // Remove OSC 8 hyperlink wrappers but preserve the styled content inside
+  input.replaceAll(/\u001B]8;;[^\u0007]*\u0007/g, "").replaceAll("\x1B]8;;\x07", "")
+);
+const getRenderedMarkdown = ({ filename, templateVars, ...options }) => {
+  setOptions({
+    renderer: new TerminalRenderer({
+      ...options
+    })
+  });
+  const entrypointPath = fs__default.realpathSync(process.argv[1]);
+  const root = path.dirname(entrypointPath);
+  const mdPath = path.join(root, "..", "assets", "markdown", filename);
+  const mdTemplate = fs__default.readFileSync(mdPath, "utf8").trim();
+  const markdown = ejs.render(mdTemplate, templateVars ?? {}, {
+    filename: mdPath
+  });
+  const rendered = parse$1(markdown).trim();
+  const cleaned = cleanHyperlinks(rendered);
+  return cleaned;
+};
+const Markdown = ({ filename, templateVars, ...options }) => {
+  const [text, setText] = useState("");
+  useEffect(() => {
+    const cleaned = getRenderedMarkdown({ filename, templateVars, ...options });
+    setText(cleaned);
+  }, [filename, templateVars, options]);
+  return /* @__PURE__ */ jsx(Text, { children: text });
+};
+
+const CommandContext = React.createContext({
+  command: null,
+  setCommand(command) {
+  }
+});
+const CommandProvider = (props) => {
+  const [command, setCommand] = useState(props.command || null);
+  return /* @__PURE__ */ jsx(CommandContext.Provider, { value: { command, setCommand }, children: props.children });
+};
+
+const GameContext = React.createContext({
+  game: null,
+  gameId: null,
+  setGameId(gameId) {
+  }
+});
+const GameProvider = ({ children }) => {
+  const { command } = React.useContext(CommandContext);
+  const [gameId, setGameId] = useState(command?.getGameId() || null);
+  const [game, setGame] = useState(null);
+  const handleGameIdChange = async () => {
+    if (!gameId) {
+      setGame(null);
+      return;
+    }
+    const game2 = await getProject(gameId);
+    setGame(game2);
+  };
+  useEffect(() => {
+    handleGameIdChange();
+  }, [gameId]);
+  return /* @__PURE__ */ jsx(GameContext.Provider, { value: { game, gameId, setGameId }, children });
+};
+
+scriptDir(import.meta);
+const getIsAppFound = (result) => {
+  const isFound = result?.status === KeyTestStatus.SUCCESS || result?.status === KeyTestStatus.ERROR && result?.error === KeyTestError.NOT_INVITED;
+  return isFound;
+};
+const CreateGooglePlayGame = (props) => {
+  const { gameId } = useContext(GameContext);
+  return /* @__PURE__ */ jsx(Fragment, { children: gameId && /* @__PURE__ */ jsx(Create, { gameId, ...props }) });
+};
+const Create = ({ gameId, onComplete, onError, ...boxProps }) => {
+  const { data: result, isFetching } = useAndroidServiceAccountTestResult({ projectId: gameId });
+  const { data: builds } = useBuilds({ pageNumber: 0, projectId: gameId });
+  const previousIsFound = useRef(false);
+  useEffect(() => {
+    const isFound = getIsAppFound(result);
+    if (previousIsFound.current === false && isFound) {
+      onComplete();
+    }
+    previousIsFound.current = isFound;
+  }, [result]);
+  useSafeInput(async (input) => {
+    if (!gameId) return;
+    switch (input) {
+      case "r": {
+        queryClient.invalidateQueries({
+          queryKey: cacheKeys.androidKeyTestResult({ projectId: gameId })
+        });
+        break;
+      }
+      case "d": {
+        const dashUrl = await getShortAuthRequiredUrl(`/games/${getShortUUID(gameId)}/builds`);
+        await open(dashUrl);
+        break;
+      }
+    }
+  });
+  const initialBuild = builds?.data.find(
+    (build) => build.platform === Platform.ANDROID && build.buildType === BuildType.AAB
+  );
+  const downloadCmd = initialBuild ? `${getBuildSummary(initialBuild).cmd}` : "Initial AAB build not found!";
+  const templateVars = {
+    dashboardURL: new URL(`/games/${getShortUUID(gameId)}/builds`, WEB_URL).toString(),
+    downloadCmd
+  };
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, ...boxProps, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: isFetching ? "Checking..." : "ShipThis has not detected your game in Google Play. Press R to test again." }),
+      isFetching && /* @__PURE__ */ jsx(Spinner, { type: "dots" })
+    ] }),
+    /* @__PURE__ */ jsx(Markdown, { filename: "create-google-play-game.md.ejs", templateVars })
+  ] }) });
+};
+
+class BaseAuthenticatedCommand extends BaseCommand {
+  static flags = {};
+  async init() {
+    await super.init();
+    if (!this.isAuthenticated()) {
+      this.error("No auth config found. Please run `shipthis login` to authenticate.", { exit: 1 });
+    }
+    const self = await getSelf();
+    const accepted = Boolean(self.details?.hasAcceptedTerms);
+    if (!accepted) {
+      this.error("You must accept the agreements first. Please run `shipthis login --acceptAgreements` to do this.", {
+        exit: 1
+      });
+    }
+    const terms = await getTerms();
+    if (terms.changes.length > 0) {
+      const warningMD = getRenderedMarkdown({
+        filename: "agreement-update.md.ejs",
+        templateVars: {
+          changes: terms.changes.map((a) => {
+            return {
+              ...a,
+              url: new URL(a.path, WEB_URL).toString()
+            };
+          })
+        }
+      });
+      console.log(warningMD);
+    }
+  }
+}
+
+class BaseGameCommand extends BaseAuthenticatedCommand {
+  static flags = {
+    ...BaseAuthenticatedCommand.flags,
+    gameId: Flags.string({ char: "g", description: "The ID of the game" })
+  };
+  async getGame() {
+    try {
+      const gameId = await this.getGameId();
+      if (!gameId) this.error("No game ID found.");
+      return await getProject(gameId);
+    } catch (error) {
+      if (error?.response?.status === 404) {
+        this.error("Game not found - please check you have access");
+      } else throw error;
+    }
+  }
+  async updateGame(update) {
+    const project = await this.getGame();
+    const projectUpdate = {
+      ...project,
+      ...update
+    };
+    const updatedProject = await updateProject(project.id, projectUpdate);
+    await this.updateProjectConfig({ project: updatedProject });
+    return updatedProject;
+  }
+}
+
+const DetailsFlags = {
+  androidPackageName: Flags.string({ char: "a", description: "Set the Android package name" }),
+  buildNumber: Flags.integer({ char: "b", description: "Set the build number" }),
+  gameEngine: Flags.string({ char: "e", description: "Set the game engine" }),
+  gameEngineVersion: Flags.string({ char: "v", description: "Set the game engine version" }),
+  gcpProjectId: Flags.string({ char: "g", description: "Set the GCP project ID" }),
+  gcpServiceAccountId: Flags.string({ char: "c", description: "Set the GCP service account ID" }),
+  iosBundleId: Flags.string({ char: "i", description: "Set the iOS bundle ID" }),
+  name: Flags.string({ char: "n", description: "The name of the game" }),
+  semanticVersion: Flags.string({ char: "s", description: "Set the semantic version" })
+};
+
+export { getAuthToken as $, ApiKey as A, BaseAuthenticatedCommand as B, CredentialsType as C, DetailsFlags as D, DEFAULT_IGNORED_FILES_GLOBS as E, getGodotProjectName as F, GODOT_CAPABILITIES as G, getProjectJobs as H, getJobSummary as I, getJobStatusColor as J, getJob as K, JobStatus as L, getStageColor as M, makeHumanReadable as N, getProject as O, Platform as P, getProjectPlatformProgress as Q, GameContext as R, CommandContext as S, isValidSemVer as T, UserRole as U, castArrayObjectDates as V, WEB_URL as W, queryClient as X, CommandProvider as Y, GameProvider as Z, WS_URL as _, ApiKeyType as a, cacheKeys as a0, downloadBuildById as a1, getGoogleStatus as a2, getGodotAndroidPackageName as a3, enforcePolicy as a4, revokePolicy as a5, fetchKeyTestResult as a6, niceError as a7, KeyTestStatus as a8, KeyTestError as a9, getMessageColor as aA, getShortTime as aB, updateProject as aC, queryBuilds as aD, CreateGooglePlayGame as aE, inviteServiceAccount as aa, disconnectGoogle as ab, BaseCommand as ac, ejs as ad, getAPIKeys as ae, createAPIKey as af, revokeAPIKey as ag, getSingleUseUrl as ah, acceptTerms as ai, setAuthToken as aj, Auth as ak, getMaskedInput as al, getNewUploadTicket as am, getFileHash as an, startJobsFromUpload as ao, getPlatformName as ap, useBuilds as aq, getBuildSummary as ar, LogLevel as as, useSafeInput as at, Markdown as au, getShortAuthRequiredUrl as av, castObjectDates as aw, getGoogleAuthUrl as ax, useJob as ay, castJobDates as az, getRenderedMarkdown as b, getInput as c, Certificate as d, getProjects as e, getShortDate as f, getShortUUID as g, BaseGameCommand as h, generatePackageName as i, getGodotAppleBundleIdentifier as j, BundleId as k, App as l, CapabilityTypeOption as m, BetaGroup as n, isCWDGodotGame as o, CertificateType as p, Profile as q, ProfileType as r, API_URL as s, getAuthedHeaders as t, getGodotProjectCapabilities as u, CapabilityType as v, GameEngine as w, getGodotVersion as x, createProject as y, DEFAULT_SHIPPED_FILES_GLOBS as z };