shipthis 0.0.1

package/dist/baseGameCommand-xrD2WDDN.js

@@ -0,0 +1,599 @@
+import { Command, Flags } from '@oclif/core';
+import path from 'path';
+import fs__default from 'fs';
+import * as expo from '@expo/apple-utils/build/index.js';
+import axios from 'axios';
+import { DateTime } from 'luxon';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import { QueryClient } from '@tanstack/react-query';
+import 'socket.io-client';
+import { parse } from 'ini';
+import merge from 'deepmerge';
+import 'isomorphic-git';
+
+const defaultExport = expo.default;
+const {
+  ApiKey,
+  ApiKeyType,
+  App,
+  Auth,
+  BundleId,
+  CapabilityType,
+  CapabilityTypeOption,
+  Certificate,
+  CertificateType,
+  Profile,
+  ProfileType,
+  Session,
+  UserRole,
+  BetaGroup
+} = defaultExport;
+
+const DEFAULT_SHIPPED_FILES_GLOBS = ["**/*"];
+const DEFAULT_IGNORED_FILES_GLOBS = [".git", ".gitignore", "shipthis.json", "shipthis-*.zip"];
+const BACKENDS = {
+  dev: {
+    apiUrl: "https://api.develop.shipthis.cc/api/1.0.0",
+    wsUrl: "wss://ws.develop.shipthis.cc",
+    webUrl: "https://develop.shipthis.cc/"
+  },
+  local: {
+    apiUrl: "https://easy-reliably-gull.ngrok-free.app/api/1.0.0",
+    wsUrl: "wss://easy-reliably-gull.ngrok-free.app",
+    webUrl: "https://easy-reliably-gull.ngrok-free.app/"
+  }
+};
+const BACKEND_ENV_VAR_NAME = "SHIPTHIS_BACKEND";
+const BACKEND_NAME = process.env[BACKEND_ENV_VAR_NAME] || "dev";
+const API_URL = BACKENDS[BACKEND_NAME].apiUrl;
+const WS_URL = BACKENDS[BACKEND_NAME].wsUrl;
+const WEB_URL = BACKENDS[BACKEND_NAME].webUrl;
+
+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) => {
+    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.replace(/_/g, "-") || DEFAULT_LOCALE;
+  try {
+    const env = process.env;
+    const fullLocale = env.LC_TIME || env.LANG || env.LANGUAGE || env.LC_ALL || env.LC_MESSAGES;
+    const shortLocale = fullLocale?.split(".")[0].replace(/_/g, "-");
+    const finalLocal = shortLocale || fallback;
+    const _ = DateTime.now().toLocaleString(DateTime.DATE_SHORT, { locale: finalLocal });
+    return finalLocal;
+  } catch (e) {
+    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"
+  });
+}
+
+async function getUserCredentials(pageSize = 100) {
+  const headers = getAuthedHeaders();
+  const { data } = await axios({
+    method: "get",
+    url: `${API_URL}/credentials?pageSize=${pageSize}`,
+    headers
+  });
+  return castArrayObjectDates(data.data);
+}
+async function getProjectCredentials(projectId, pageSize = 100) {
+  const headers = getAuthedHeaders();
+  const { data } = await axios({
+    method: "get",
+    url: `${API_URL}/projects/${projectId}/credentials?pageSize=${pageSize}`,
+    headers
+  });
+  return castArrayObjectDates(data.data);
+}
+
+const AUTH_ENV_VAR_NAME = "SHIPTHIS_TOKEN";
+function setAuthToken(token) {
+  process.env[AUTH_ENV_VAR_NAME] = token;
+}
+function getAuthToken() {
+  return process.env[AUTH_ENV_VAR_NAME];
+}
+function getAuthedHeaders() {
+  return {
+    Authorization: `Bearer ${process.env[AUTH_ENV_VAR_NAME]}`
+  };
+}
+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, uploadDetails) {
+  const headers = getAuthedHeaders();
+  const opt = { headers };
+  const { data } = await axios.post(`${API_URL}/upload/start/${uploadTicketId}`, uploadDetails, 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}=${value}`).join("&");
+  const url = `${WEB_URL}exchange/?${queryString}`;
+  return 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);
+}
+
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["IOS"] = "IOS";
+  Platform2["ANDROID"] = "ANDROID";
+  return Platform2;
+})(Platform || {});
+var GameEngine = /* @__PURE__ */ ((GameEngine2) => {
+  GameEngine2["GODOT"] = "godot";
+  return GameEngine2;
+})(GameEngine || {});
+var JobStatus = /* @__PURE__ */ ((JobStatus2) => {
+  JobStatus2["PENDING"] = "PENDING";
+  JobStatus2["PROCESSING"] = "PROCESSING";
+  JobStatus2["COMPLETED"] = "COMPLETED";
+  JobStatus2["FAILED"] = "FAILED";
+  return JobStatus2;
+})(JobStatus || {});
+var JobStage = /* @__PURE__ */ ((JobStage2) => {
+  JobStage2["SETUP"] = "SETUP";
+  JobStage2["EXPORT"] = "EXPORT";
+  JobStage2["CONFIGURE"] = "CONFIGURE";
+  JobStage2["BUILD"] = "BUILD";
+  JobStage2["PUBLISH"] = "PUBLISH";
+  return JobStage2;
+})(JobStage || {});
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARN"] = "WARN";
+  LogLevel2["ERROR"] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+var CredentialsType = /* @__PURE__ */ ((CredentialsType2) => {
+  CredentialsType2["CERTIFICATE"] = "CERTIFICATE";
+  CredentialsType2["KEY"] = "KEY";
+  return CredentialsType2;
+})(CredentialsType || {});
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 50
+    }
+  }
+});
+
+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
+  { name: "Access WiFi", key: "capabilities/access_wifi", type: CapabilityType.ACCESS_WIFI },
+  { name: "Push Notifications", key: "capabilities/push_notifications", type: CapabilityType.PUSH_NOTIFICATIONS }
+];
+function getGodotProjectCapabilities(platform) {
+  const exportPresets = getGodotExportPresets(platform);
+  const options = exportPresets.options;
+  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 (e) {
+    return null;
+  }
+}
+function getGodotAppleBundleIdentifier() {
+  try {
+    const preset = getGodotExportPresets(Platform.IOS);
+    return preset.options["application/bundle_identifier"];
+  } catch (e) {
+    console.log(e);
+    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.X";
+}
+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) {
+    warn(`${filename} not found at ${exportPresetsPath}`);
+  } else {
+    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) {
+      warn(`Preset ${platform} not found in ${filename} - will use defaults`);
+    } else {
+      presetConfig = merge(presetConfig, exportPresetsIni.preset[presetIndex]);
+    }
+  }
+  return presetConfig;
+}
+function getBaseExportPresets_iOS() {
+  return {
+    name: "iOS",
+    platform: "iOS",
+    runnable: true,
+    dedicated_server: false,
+    custom_features: "",
+    export_filter: "all_resources",
+    include_filter: "",
+    exclude_filter: "",
+    export_path: "output",
+    encryption_include_filters: "",
+    encryption_exclude_filters: "",
+    encrypt_pck: false,
+    encrypt_directory: false,
+    options: {
+      "custom_template/debug": "",
+      "custom_template/release": "",
+      "architectures/arm64": true,
+      "application/signature": "",
+      "application/icon_interpolation": "4",
+      "application/launch_screens_interpolation": "4",
+      "application/export_project_only": true,
+      "capabilities/access_wifi": false,
+      "capabilities/push_notifications": false,
+      "user_data/accessible_from_files_app": false,
+      "user_data/accessible_from_itunes_sharing": false,
+      "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": "{}",
+      "icons/iphone_120x120": "",
+      "icons/iphone_180x180": "",
+      "icons/ipad_76x76": "",
+      "icons/ipad_152x152": "",
+      "icons/ipad_167x167": "",
+      "icons/app_store_1024x1024": "",
+      "icons/spotlight_40x40": "",
+      "icons/spotlight_80x80": "",
+      "icons/settings_58x58": "",
+      "icons/settings_87x87": "",
+      "icons/notification_40x40": "",
+      "icons/notification_60x60": "",
+      "storyboard/use_launch_screen_storyboard": true,
+      "storyboard/image_scale_mode": "0",
+      "storyboard/custom_image@2x": "",
+      "storyboard/custom_image@3x": "",
+      "storyboard/use_custom_bg_color": false,
+      "storyboard/custom_bg_color": "Color(0, 0, 0, 1)",
+      "landscape_launch_screens/iphone_2436x1125": "",
+      "landscape_launch_screens/iphone_2208x1242": "",
+      "landscape_launch_screens/ipad_1024x768": "",
+      "landscape_launch_screens/ipad_2048x1536": "",
+      "portrait_launch_screens/iphone_640x960": "",
+      "portrait_launch_screens/iphone_640x1136": "",
+      "portrait_launch_screens/iphone_750x1334": "",
+      "portrait_launch_screens/iphone_1125x2436": "",
+      "portrait_launch_screens/ipad_768x1024": "",
+      "portrait_launch_screens/ipad_1536x2048": "",
+      "portrait_launch_screens/iphone_1242x2208": "",
+      "application/short_version": "1.0.0"
+      // default version number
+    }
+  };
+}
+function getBaseExportPresets_Android() {
+  return {
+    name: "Android",
+    platform: "Android",
+    // TODO
+    options: {
+      // TODO
+    }
+  };
+}
+
+class BaseCommand extends Command {
+  // add the --json flag
+  static enableJsonFlag = false;
+  // define flags that can be inherited by any command that extends BaseCommand
+  static baseFlags = {};
+  flags;
+  args;
+  async init() {
+    process.on("SIGINT", () => process.exit(0));
+    process.on("SIGTERM", () => process.exit(0));
+    await super.init();
+    const { args, flags } = await this.parse({
+      flags: this.ctor.flags,
+      baseFlags: super.ctor.baseFlags,
+      enableJsonFlag: this.ctor.enableJsonFlag,
+      args: this.ctor.args,
+      strict: this.ctor.strict
+    });
+    this.flags = flags;
+    this.args = args;
+    if (this.hasAuthConfig()) await this.loadAuthConfig();
+  }
+  async catch(err) {
+    return super.catch(err);
+  }
+  async finally(_) {
+    return super.finally(_);
+  }
+  getAuthConfigPath() {
+    return path.join(this.config.home, ".shipthis.auth.json");
+  }
+  hasAuthConfig() {
+    const configPath = this.getAuthConfigPath();
+    return fs__default.existsSync(configPath);
+  }
+  async getAuthConfig() {
+    const baseConfig = {};
+    const configPath = this.getAuthConfigPath();
+    if (!fs__default.existsSync(configPath)) return baseConfig;
+    const raw = await fs__default.promises.readFile(configPath, "utf8");
+    const typesConfig = JSON.parse(raw);
+    return {
+      ...baseConfig,
+      ...typesConfig
+    };
+  }
+  async setAuthConfig(config) {
+    const configPath = this.getAuthConfigPath();
+    await fs__default.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+  }
+  async loadAuthConfig() {
+    const authConfig = await this.getAuthConfig();
+    if (!authConfig.shipThisUser) {
+      throw new Error("You must be logged in to use this command");
+    }
+    setAuthToken(authConfig.shipThisUser.jwt);
+  }
+  getProjectConfigPath() {
+    return path.join(process.cwd(), "shipthis.json");
+  }
+  hasProjectConfig() {
+    const configPath = this.getProjectConfigPath();
+    return fs__default.existsSync(configPath);
+  }
+  async getProjectConfig() {
+    if (!this.hasProjectConfig()) throw new Error("No project config found");
+    return this.getProjectConfigSafe();
+  }
+  async getProjectConfigSafe() {
+    if (!this.hasProjectConfig()) return {};
+    const configPath = this.getProjectConfigPath();
+    const raw = await fs__default.promises.readFile(configPath, "utf8");
+    return JSON.parse(raw);
+  }
+  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 });
+  }
+  // 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 }
+      );
+    }
+  }
+  async refreshAppleAuthState() {
+    const cookies = await this.getAppleCookies();
+    const rerunMessage = "Please run 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;
+  }
+  // Tests the apple cookies
+  async hasValidAppleAuthState() {
+    try {
+      await this.refreshAppleAuthState();
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  // 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;
+  }
+  async setAppleCookies(cookies) {
+    const authConfig = await this.getAuthConfig();
+    await this.setAuthConfig({ ...authConfig, appleCookies: cookies });
+  }
+  ensureWeHaveAppleCookies() {
+    if (!this.hasAuthConfig()) {
+      this.error("You must be authenticated with Apple in to use this command. Please run shipthis apple login", {
+        exit: 1
+      });
+    }
+  }
+}
+
+class BaseAuthenticatedCommand extends BaseCommand {
+  static flags = {};
+  async init() {
+    await super.init();
+    if (!this.hasAuthConfig()) {
+      this.error("No auth config found. Please run `shipthis login` to authenticate.", { exit: 1 });
+    }
+  }
+}
+
+class BaseGameCommand extends BaseAuthenticatedCommand {
+  static flags = {
+    ...BaseAuthenticatedCommand.flags,
+    gameId: Flags.string({ char: "g", description: "The ID of the game" })
+  };
+  async getGame() {
+    try {
+      const { flags } = this;
+      if (flags.gameId) {
+        return await getProject(flags.gameId);
+      }
+      this.ensureWeAreInAProjectDir();
+      const { project } = await this.getProjectConfig();
+      if (!project) throw new Error("No project");
+      return await getProject(project.id);
+    } catch (e) {
+      if (e?.response?.status === 404) {
+        this.error("Game not found - please check you have access");
+      } else throw e;
+    }
+  }
+  async getGameCredentials() {
+    const { project } = await this.getProjectConfig();
+    if (!project) throw new Error("No project");
+    const projectCredentials = await getProjectCredentials(project.id);
+    return projectCredentials;
+  }
+  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;
+  }
+}
+
+export { castObjectDates as $, ApiKey as A, BaseAuthenticatedCommand as B, CredentialsType as C, DEFAULT_SHIPPED_FILES_GLOBS as D, getGodotProjectName as E, getBuild as F, GODOT_CAPABILITIES as G, getShortDateTime as H, castArrayObjectDates as I, getProjectJobs as J, JobStatus as K, getShortTimeDelta as L, getJob as M, getNewUploadTicket as N, startJobsFromUpload as O, Platform as P, queryClient as Q, JobStage as R, LogLevel as S, getSingleUseUrl as T, UserRole as U, BaseCommand as V, Auth as W, BACKEND_NAME as X, WS_URL as Y, WEB_URL as Z, getAuthToken as _, ApiKeyType as a, castJobDates as a0, getShortTime as a1, getProject as b, DEFAULT_IGNORED_FILES_GLOBS as c, BaseGameCommand as d, getProjectPlatformProgress as e, getShortDate as f, getUserCredentials as g, CapabilityTypeOption as h, isCWDGodotGame as i, BetaGroup as j, App as k, getGodotAppleBundleIdentifier as l, BundleId as m, getProjectCredentials as n, getAuthedHeaders as o, API_URL as p, Certificate as q, CertificateType as r, Profile as s, ProfileType as t, getGodotProjectCapabilities as u, CapabilityType as v, getProjects as w, GameEngine as x, getGodotVersion as y, createProject as z };

package/dist/cacheKeys-CShA-ZjE.js

@@ -0,0 +1,9 @@
+const cacheKeys = {
+  job: (props) => ["job", ...Object.values(props)],
+  jobLogs: (props) => ["jobLogs", ...Object.values(props)],
+  userCredentials: (props) => ["userCredentials", ...Object.values(props)],
+  projectCredentials: (props) => ["projectCredentials", ...Object.values(props)],
+  builds: (props) => ["builds", ...Object.values(props)]
+};
+
+export { cacheKeys as c };

package/dist/commands/apple/apiKey/create.js

@@ -0,0 +1,88 @@
+import { jsx } from 'react/jsx-runtime';
+import { Flags } from '@oclif/core';
+import { render } from 'ink';
+import 'path';
+import 'fs';
+import { g as getUserCredentials, P as Platform, C as CredentialsType, A as ApiKey, U as UserRole, a as ApiKeyType } from '../../../baseGameCommand-xrD2WDDN.js';
+import 'axios';
+import 'luxon';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import '@tanstack/react-query';
+import 'socket.io-client';
+import 'isomorphic-git';
+import { B as BaseAppleCommand } from '../../../baseAppleCommand-BXUu-026.js';
+import { A as App } from '../../../App-DFPMSEZF.js';
+import 'ink-spinner';
+import 'string-length';
+import 'strip-ansi';
+import { R as RunWithSpinner } from '../../../RunWithSpinner-BVXNWGD3.js';
+import { u as uploadUserCredentials } from '../../../upload-CUlWmNbS.js';
+import '@expo/apple-utils/build/index.js';
+import 'ini';
+import 'deepmerge';
+
+class AppleApiKeyCreate extends BaseAppleCommand {
+  static args = {};
+  static description = "Creates an App Store Connect API Key in your Apple Developer account and saves the private key in your ShipThis account";
+  static examples = ["<%= config.bin %> <%= command.id %>", "<%= config.bin %> <%= command.id %> --force"];
+  static flags = {
+    force: Flags.boolean({ char: "f" }),
+    quiet: Flags.boolean({ char: "q", description: "Avoid output except for interactions and errors" })
+  };
+  async run() {
+    const { flags } = this;
+    const { force } = flags;
+    const userCredentials = await getUserCredentials();
+    const userAppleApiKeyCredentials = userCredentials.filter(
+      (cred) => cred.platform == Platform.IOS && cred.type == CredentialsType.KEY
+    );
+    if (userAppleApiKeyCredentials.length !== 0 && !force) {
+      this.error("An App Store Connect API already exists. Use --force to overwrite it.");
+    }
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    const createApiKey = async () => {
+      const userKey = await ApiKey.createAsync(ctx, {
+        nickname: `ShipThis ${Math.floor((/* @__PURE__ */ new Date()).valueOf() / 1e3)}`,
+        allAppsVisible: true,
+        roles: [UserRole.ADMIN],
+        keyType: ApiKeyType.PUBLIC_API
+      });
+      const keyContent = await userKey.downloadAsync();
+      if (!keyContent) throw new Error("Failed to download key content");
+      const reloadedKey = await ApiKey.infoAsync(ctx, { id: userKey.id });
+      const key = {
+        keyId: userKey.id,
+        issuer: `${reloadedKey.attributes.provider?.id}`,
+        p8Content: keyContent,
+        serialNumber: userKey.id
+      };
+      await uploadUserCredentials({
+        platform: Platform.IOS,
+        type: CredentialsType.KEY,
+        contents: key,
+        serialNumber: key.serialNumber
+      });
+    };
+    const handleComplete = async () => {
+      await this.config.runCommand(`apple:apiKey:status`);
+    };
+    if (this.flags.quiet) return await createApiKey();
+    render(
+      /* @__PURE__ */ jsx(App, { children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: `Creating App Store Connect API in the Apple Developer Portal...`,
+          msgComplete: `App Store Connect API created and saved to ShipThis`,
+          executeMethod: createApiKey,
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { AppleApiKeyCreate as default };