shipthis 0.0.1

package/dist/commands/game/ios/app/create.js

@@ -0,0 +1,104 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import { A as App } from '../../../../App-DFPMSEZF.js';
+import 'ink-spinner';
+import { a as getInput, b as generatePackageName } from '../../../../index-DKsVctbw.js';
+import 'react';
+import { d as BaseGameCommand, l as getGodotAppleBundleIdentifier, m as BundleId, k as App$1 } from '../../../../baseGameCommand-xrD2WDDN.js';
+import 'luxon';
+import '@tanstack/react-query';
+import 'axios';
+import 'fs';
+import 'socket.io-client';
+import 'string-length';
+import 'strip-ansi';
+import { R as RunWithSpinner } from '../../../../RunWithSpinner-BVXNWGD3.js';
+import 'path';
+import '@expo/apple-utils/build/index.js';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'isomorphic-git';
+import 'ini';
+import 'deepmerge';
+
+class GameIosAppCreate extends BaseGameCommand {
+  static args = {};
+  static description = "Creates an App and BundleId in the Apple Developer Portal. If --gameId is not provided it will look in the current directory.";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    quiet: Flags.boolean({ char: "q", description: "Avoid output except for interactions and errors" }),
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    appName: Flags.string({ char: "n", description: "The name of the App in the Apple Developer Portal" }),
+    bundleId: Flags.string({ char: "b", description: "The BundleId in the Apple Developer Portal" }),
+    force: Flags.boolean({ char: "f" })
+    // not used but don't remove or the wizard breaks
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    const { flags } = this;
+    const { appName, bundleId } = flags;
+    const getAppName = async () => {
+      if (appName) return appName;
+      const suggestedName = game.name;
+      const question = `Please enter the name of the App in the Apple Developer Portal, or press enter to use ${suggestedName}: `;
+      const enteredName = await getInput(question);
+      return enteredName || suggestedName;
+    };
+    const getBundleIdentifier = async () => {
+      if (bundleId) return bundleId;
+      const generatedBundleId = generatePackageName(game.name);
+      const suggestedBundleId = game.details?.iosBundleId || getGodotAppleBundleIdentifier() || generatedBundleId || "com.example.game";
+      const question = `Please enter the BundleId in the Apple Developer Portal, or press enter to use ${suggestedBundleId}: `;
+      const enteredBundleId = await getInput(question);
+      return enteredBundleId || suggestedBundleId;
+    };
+    const name = await getAppName();
+    const iosBundleId = await getBundleIdentifier();
+    const createApp = async () => {
+      this.log(`Checking for ${iosBundleId} in apple portal...`);
+      let bundleId2 = await BundleId.findAsync(ctx, { identifier: iosBundleId });
+      if (!bundleId2) {
+        this.log(`Creating BundleId ${iosBundleId} in apple portal...`);
+        bundleId2 = await BundleId.createAsync(ctx, {
+          identifier: iosBundleId,
+          name
+        });
+      }
+      let app = await App$1.findAsync(ctx, {
+        bundleId: iosBundleId
+      });
+      if (!app) {
+        this.log(`Creating App ${iosBundleId} in apple portal...`);
+        app = await App$1.createAsync(ctx, {
+          bundleId: iosBundleId,
+          name,
+          primaryLocale: "en-US"
+          // TODO
+        });
+      }
+      await this.updateGame({ details: { ...game.details, iosBundleId } });
+    };
+    const handleComplete = async () => {
+      await this.config.runCommand("game:ios:app:sync", ["--gameId", game.id]);
+      process.exit(0);
+    };
+    if (this.flags.quiet) return await createApp();
+    render(
+      /* @__PURE__ */ jsx(App, { children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: "Creating App and BundleId in the Apple Developer Portal",
+          msgComplete: "App and BundleId created",
+          executeMethod: createApp,
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosAppCreate as default };

package/dist/commands/game/ios/app/status.js

@@ -0,0 +1,52 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import { A as App } from '../../../../App-DFPMSEZF.js';
+import 'ink-spinner';
+import 'crypto';
+import 'fs';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import 'axios';
+import '@tanstack/react-query';
+import { d as BaseGameCommand } from '../../../../baseGameCommand-xrD2WDDN.js';
+import 'luxon';
+import 'socket.io-client';
+import '@expo/apple-utils/build/index.js';
+import 'isomorphic-git';
+import { A as AppleAppDetails, a as AppleBundleIdDetails } from '../../../../AppleBundleIdDetails-CuhAbVEp.js';
+import 'string-length';
+import 'strip-ansi';
+import { N as NextSteps } from '../../../../NextSteps-CK9zHOCt.js';
+import 'path';
+import 'ini';
+import 'deepmerge';
+import '../../../../useAppleApp-BmwYu7qG.js';
+import '../../../../Title-BCQtayg6.js';
+import '../../../../Table-CvM6pccN.js';
+import '../../../../useAppleBundleId-DCJnfNWr.js';
+
+class GameIosAppStatus extends BaseGameCommand {
+  static args = {};
+  static description = "Shows the Game iOS App status. If --gameId is not provided it will look in the current directory.";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    gameId: Flags.string({ char: "g", description: "The ID of the game" })
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    const steps = [];
+    render(
+      /* @__PURE__ */ jsxs(App, { children: [
+        /* @__PURE__ */ jsx(AppleAppDetails, { iosBundleId: game.details?.iosBundleId, ctx }),
+        /* @__PURE__ */ jsx(AppleBundleIdDetails, { iosBundleId: game.details?.iosBundleId, ctx }),
+        /* @__PURE__ */ jsx(NextSteps, { steps })
+      ] })
+    );
+  }
+}
+
+export { GameIosAppStatus as default };

package/dist/commands/game/ios/app/sync.js

@@ -0,0 +1,81 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import { A as App } from '../../../../App-DFPMSEZF.js';
+import 'ink-spinner';
+import 'crypto';
+import 'fs';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import 'axios';
+import '@tanstack/react-query';
+import { d as BaseGameCommand, h as CapabilityTypeOption } from '../../../../baseGameCommand-xrD2WDDN.js';
+import 'luxon';
+import 'socket.io-client';
+import { f as fetchBundleId } from '../../../../useAppleBundleId-DCJnfNWr.js';
+import 'isomorphic-git';
+import 'string-length';
+import 'strip-ansi';
+import { R as RunWithSpinner } from '../../../../RunWithSpinner-BVXNWGD3.js';
+import 'path';
+import '@expo/apple-utils/build/index.js';
+import 'ini';
+import 'deepmerge';
+
+class GameIosAppSync extends BaseGameCommand {
+  static args = {};
+  static description = 'Synchronies the Apple App "BundleId" with the capabilities from the local project. If --gameId is not provided it will look in the current directory.';
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    quiet: Flags.boolean({ char: "q", description: "Avoid output except for interactions and errors" }),
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    force: Flags.boolean({ char: "f" })
+    // not used but don't remove or the wizard breaks
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    if (!game.details?.iosBundleId) return this.error("Please run `shipthis game ios app create` first");
+    const { iosBundleId } = game.details;
+    const syncCapabilities = async () => {
+      const bundleQueryResponse = await fetchBundleId({ ctx, iosBundleId });
+      const { bundleId, capabilities: existing, projectCapabilities } = bundleQueryResponse;
+      if (!bundleId) return this.error("BundleId not found");
+      if (!projectCapabilities) return this.error("Project capabilities not loaded");
+      const unRemovable = ["IN_APP_PURCHASE"];
+      const toRemove = existing.filter((c) => !projectCapabilities.includes(c) && !unRemovable.includes(c));
+      const toAdd = projectCapabilities.filter((c) => !existing.includes(c));
+      for (const capability of toRemove) {
+        await bundleId.updateBundleIdCapabilityAsync({
+          capabilityType: capability,
+          option: CapabilityTypeOption.OFF
+        });
+      }
+      for (const capability of toAdd) {
+        await bundleId.updateBundleIdCapabilityAsync({
+          capabilityType: capability,
+          option: CapabilityTypeOption.ON
+        });
+      }
+    };
+    const handleComplete = async () => {
+      await this.config.runCommand("game:ios:app:status", ["--gameId", game.id]);
+    };
+    if (this.flags.quiet) return await syncCapabilities();
+    render(
+      /* @__PURE__ */ jsx(App, { children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: "Syncing App Store BundleId capabilities",
+          msgComplete: "App Store BundleId capabilities synced",
+          executeMethod: syncCapabilities,
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosAppSync as default };

package/dist/commands/game/ios/profile/create.js

@@ -0,0 +1,110 @@
+import { jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Flags } from '@oclif/core';
+import axios from 'axios';
+import { A as App } from '../../../../App-DFPMSEZF.js';
+import 'ink-spinner';
+import { d as BaseGameCommand, n as getProjectCredentials, P as Platform, C as CredentialsType, q as Certificate, r as CertificateType, g as getUserCredentials, s as Profile, t as ProfileType } from '../../../../baseGameCommand-xrD2WDDN.js';
+import 'crypto';
+import 'fs';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import '@tanstack/react-query';
+import 'luxon';
+import 'socket.io-client';
+import { f as fetchBundleId } from '../../../../useAppleBundleId-DCJnfNWr.js';
+import 'isomorphic-git';
+import 'string-length';
+import 'strip-ansi';
+import { R as RunWithSpinner } from '../../../../RunWithSpinner-BVXNWGD3.js';
+import 'path';
+import { a as uploadProjectCredentials } from '../../../../upload-CUlWmNbS.js';
+import '@expo/apple-utils/build/index.js';
+import 'ini';
+import 'deepmerge';
+
+class GameIosProfileCreate extends BaseGameCommand {
+  static args = {};
+  static description = "Creates a Mobile Provisioning Profile in the Apple Developer Portal. If --gameId is not provided it will look in the current directory.";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    quiet: Flags.boolean({ char: "q", description: "Avoid output except for interactions and errors" }),
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    force: Flags.boolean({ char: "f" })
+  };
+  async run() {
+    const game = await this.getGame();
+    const authState = await this.refreshAppleAuthState();
+    const ctx = authState.context;
+    const { flags } = this;
+    const { force } = flags;
+    const projectCredentials = await getProjectCredentials(game.id);
+    const projectAppleProfileCredentials = projectCredentials.filter(
+      (cred) => cred.platform == Platform.IOS && cred.type == CredentialsType.CERTIFICATE
+    );
+    if (projectAppleProfileCredentials.length !== 0 && !force) {
+      this.error("A Mobile Provisioning Profile already exists. Use --force to overwrite it.");
+    }
+    const createProfile = async () => {
+      if (!game.details?.iosBundleId) throw new Error("iosBundleId not found in game details");
+      const { iosBundleId } = game.details;
+      const { bundleId } = await fetchBundleId({ ctx, iosBundleId });
+      if (!bundleId) throw new Error("BundleId not found");
+      const appleCerts = await Certificate.getAsync(ctx, {
+        query: {
+          filter: {
+            certificateType: [CertificateType.DISTRIBUTION, CertificateType.IOS_DISTRIBUTION]
+          }
+        }
+      });
+      const userCerts = await getUserCredentials();
+      const validCert = userCerts.find(
+        (cred) => cred.platform === Platform.IOS && cred.type === CredentialsType.CERTIFICATE && cred.isActive == true
+      );
+      if (!validCert) throw new Error("No valid user certificates found");
+      const validAppleCert = appleCerts.find((cert) => cert.attributes.serialNumber === validCert.serialNumber);
+      if (!validAppleCert) throw new Error("No valid apple certificates found");
+      const profile = await Profile.createAsync(ctx, {
+        bundleId: bundleId.id,
+        certificates: [validAppleCert.id],
+        devices: [],
+        name: `ShipThis Profile for ${iosBundleId}`,
+        profileType: ProfileType.IOS_APP_STORE
+      });
+      const { data: contents } = await axios({
+        method: "get",
+        url: validCert.url
+      });
+      const userCertContent = contents;
+      const projectCertContent = {
+        ...userCertContent,
+        mobileProvisionBase64: `${profile.attributes.profileContent}`
+      };
+      await uploadProjectCredentials(game.id, {
+        contents: projectCertContent,
+        platform: Platform.IOS,
+        type: CredentialsType.CERTIFICATE,
+        serialNumber: validCert.serialNumber,
+        identifier: iosBundleId
+      });
+    };
+    const handleComplete = async () => {
+      await this.config.runCommand("game:ios:profile:status", ["--gameId", game.id]);
+    };
+    if (this.flags.quiet) return await createProfile();
+    render(
+      /* @__PURE__ */ jsx(App, { children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: "Creating Mobile Provisioning Profile in the Apple Developer Portal",
+          msgComplete: "Mobile Provisioning Profile created",
+          executeMethod: createProfile,
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosProfileCreate as default };

package/dist/commands/game/ios/profile/export.js

@@ -0,0 +1,68 @@
+import { jsx } from 'react/jsx-runtime';
+import { Args, Flags } from '@oclif/core';
+import { render } from 'ink';
+import * as fs from 'fs';
+import 'path';
+import '@expo/apple-utils/build/index.js';
+import 'axios';
+import { d as BaseGameCommand, n as getProjectCredentials, P as Platform, C as CredentialsType } from '../../../../baseGameCommand-xrD2WDDN.js';
+import 'luxon';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import '@tanstack/react-query';
+import 'socket.io-client';
+import 'isomorphic-git';
+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 { e as exportCredential } from '../../../../export-CujqsTR_.js';
+import 'ini';
+import 'deepmerge';
+
+class GameIosProfileExport extends BaseGameCommand {
+  static args = {
+    file: Args.string({ description: "Name of the ZIP file to create", required: true })
+  };
+  static description = "Saves the current Mobile Provisioning Profile to a ZIP file";
+  static examples = ["<%= config.bin %> <%= command.id %> userProfile.zip"];
+  static flags = {
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    force: Flags.boolean({ char: "f", description: "Overwrite the file if it already exists" })
+  };
+  async run() {
+    const { args, flags } = this;
+    const { file } = args;
+    const { force } = flags;
+    const game = await this.getGame();
+    const zipAlreadyExists = fs.existsSync(file);
+    if (zipAlreadyExists && !force) {
+      this.error(`The file ${file} already exists. Use --force to overwrite it.`);
+    }
+    const projectCredentials = await getProjectCredentials(game.id);
+    const userAppleProfileCredentials = projectCredentials.filter(
+      (cred) => cred.platform == Platform.IOS && cred.type == CredentialsType.CERTIFICATE
+    );
+    if (userAppleProfileCredentials.length === 0) {
+      this.error("No Mobile Provisioning Profile found which can be exported.");
+    }
+    const [profile] = userAppleProfileCredentials;
+    const handleComplete = async () => process.exit(0);
+    render(
+      /* @__PURE__ */ jsx(App, { children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: `Exporting Mobile Provisioning Profile to ${file}...`,
+          msgComplete: `Mobile Provisioning Profile exported to ${file}`,
+          executeMethod: () => exportCredential({ zipPath: file, credentialId: profile.id, projectId: game.id }),
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosProfileExport as default };

package/dist/commands/game/ios/profile/import.js

@@ -0,0 +1,77 @@
+import { jsx } from 'react/jsx-runtime';
+import { Args, Flags } from '@oclif/core';
+import { render } from 'ink';
+import * as fs from 'fs';
+import 'path';
+import '@expo/apple-utils/build/index.js';
+import 'axios';
+import { d as BaseGameCommand, n as getProjectCredentials, P as Platform, C as CredentialsType } from '../../../../baseGameCommand-xrD2WDDN.js';
+import 'luxon';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import '@tanstack/react-query';
+import 'socket.io-client';
+import 'isomorphic-git';
+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 { i as importCredential } from '../../../../import-Q-KO61ll.js';
+import 'ini';
+import 'deepmerge';
+
+class GameIosProfileImport extends BaseGameCommand {
+  static args = {
+    file: Args.string({
+      description: "Name of the ZIP file to import (must be in the same format as the export)",
+      required: true
+    })
+  };
+  static description = "Imports an Mobile Provisioning Profile to your ShipThis account";
+  static examples = ["<%= config.bin %> <%= command.id %> profile.zip"];
+  static flags = {
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    force: Flags.boolean({ char: "f" })
+  };
+  async run() {
+    const { args, flags } = this;
+    const { file } = args;
+    const { force } = flags;
+    const game = await this.getGame();
+    const zipFound = fs.existsSync(file);
+    if (!zipFound) {
+      this.error(`The file ${file} does not exist.`);
+    }
+    const projectCredentials = await getProjectCredentials(game.id);
+    const projectAppleProfileCredentials = projectCredentials.filter(
+      (cred) => cred.platform == Platform.IOS && cred.type == CredentialsType.CERTIFICATE
+    );
+    if (projectAppleProfileCredentials.length !== 0 && !force) {
+      this.error("A Mobile Provisioning Profile already exists. Use --force to overwrite it.");
+    }
+    const handleComplete = async () => {
+      await this.config.runCommand(`game:ios:profile:status`, ["--noAppleAuth", "--gameId", game.id]);
+    };
+    render(
+      /* @__PURE__ */ jsx(App, { children: /* @__PURE__ */ jsx(
+        RunWithSpinner,
+        {
+          msgInProgress: `Importing Mobile Provisioning Profile from ${file}...`,
+          msgComplete: `Mobile Provisioning Profile imported from ${file}`,
+          executeMethod: () => importCredential({
+            zipPath: file,
+            type: CredentialsType.CERTIFICATE,
+            platform: Platform.IOS,
+            projectId: game.id
+          }),
+          onComplete: handleComplete
+        }
+      ) })
+    );
+  }
+}
+
+export { GameIosProfileImport as default };

package/dist/commands/game/ios/profile/status.js

@@ -0,0 +1,183 @@
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { Box, Text, render } from 'ink';
+import { Flags } from '@oclif/core';
+import { A as App } from '../../../../App-DFPMSEZF.js';
+import Spinner from 'ink-spinner';
+import { f as getShortDate, s as Profile, t as ProfileType, o as getAuthedHeaders, p as API_URL, I as castArrayObjectDates, P as Platform, C as CredentialsType, d as BaseGameCommand } from '../../../../baseGameCommand-xrD2WDDN.js';
+import 'crypto';
+import 'fs';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import axios from 'axios';
+import { useQuery } from '@tanstack/react-query';
+import { DateTime } from 'luxon';
+import 'socket.io-client';
+import '@expo/apple-utils/build/index.js';
+import 'isomorphic-git';
+import { c as cacheKeys } from '../../../../cacheKeys-CShA-ZjE.js';
+import { g as getShortUUID } from '../../../../index-DKsVctbw.js';
+import { T as Title } from '../../../../Title-BCQtayg6.js';
+import { T as Table } from '../../../../Table-CvM6pccN.js';
+import 'string-length';
+import 'strip-ansi';
+import { N as NextSteps } from '../../../../NextSteps-CK9zHOCt.js';
+import 'path';
+import 'ini';
+import 'deepmerge';
+
+async function queryAppleProfiles({ ctx }) {
+  const appleProfiles = await Profile.getAsync(ctx, {
+    query: {
+      filter: {
+        profileType: [ProfileType.IOS_APP_STORE]
+      }
+    }
+  });
+  return appleProfiles;
+}
+const canAppleProfileBeUsed = (appleProfile, project, projectCredentials) => {
+  try {
+    if (!appleProfile.isValid) return false;
+    const profileBundleId = appleProfile.attributes.bundleId?.attributes.identifier;
+    const profileCertificateSerialNumber = appleProfile.attributes.certificates?.[0]?.attributes.serialNumber;
+    if (profileBundleId !== project.details?.iosBundleId) return false;
+    return projectCredentials.some(
+      (credential) => credential.isActive && credential.serialNumber === profileCertificateSerialNumber
+    );
+  } catch (e) {
+    console.log(e);
+    return false;
+  }
+};
+function getAppleProfileSummary(appleProfile, project, projectCredentials) {
+  return {
+    id: appleProfile.id,
+    name: appleProfile.attributes.name,
+    platform: appleProfile.attributes.platform,
+    expires: getShortDate(DateTime.fromISO(appleProfile.attributes.expirationDate)),
+    canBeUsed: canAppleProfileBeUsed(appleProfile, project, projectCredentials)
+  };
+}
+const useAppleProfiles = (props) => {
+  const queryResult = useQuery({
+    queryKey: ["appleProfiles"],
+    queryFn: () => queryAppleProfiles(props)
+  });
+  return queryResult;
+};
+
+async function queryProjectCredentials({
+  projectId,
+  ...pageAndSortParams
+}) {
+  try {
+    const headers = getAuthedHeaders();
+    const url = `${API_URL}/projects/${projectId}/credentials`;
+    const response = await axios.get(url, { headers, params: pageAndSortParams });
+    return {
+      ...response.data,
+      data: castArrayObjectDates(response.data.data)
+    };
+  } catch (error) {
+    console.warn("queryProjectCredentials Error", error);
+    throw error;
+  }
+}
+function getProjectCredentialSummary(credential) {
+  return {
+    id: getShortUUID(credential.id),
+    type: credential.type,
+    serial: credential.serialNumber,
+    isActive: credential.isActive,
+    createdAt: getShortDate(credential.createdAt)
+  };
+}
+const useProjectCredentials = ({
+  platform,
+  type,
+  ...fetchProps
+}) => {
+  const queryResult = useQuery({
+    queryKey: cacheKeys.projectCredentials(fetchProps),
+    queryFn: async () => queryProjectCredentials(fetchProps),
+    select: (data) => {
+      if (!(platform || type)) return data;
+      return {
+        ...data,
+        data: data.data.filter((credential) => {
+          return (!platform || credential.platform === platform) && (!type || credential.type === type);
+        })
+      };
+    }
+  });
+  return queryResult;
+};
+
+const AppleProfilesTable = ({ ctx, project, ...boxProps }) => {
+  const { data: credentialsResponse } = useProjectCredentials({
+    projectId: project.id,
+    platform: Platform.IOS,
+    type: CredentialsType.CERTIFICATE
+  });
+  const { data: certs, isLoading } = useAppleProfiles({ ctx });
+  const hasUsable = certs && credentialsResponse && certs.some((cert) => canAppleProfileBeUsed(cert, project, credentialsResponse.data));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, ...boxProps, children: [
+    /* @__PURE__ */ jsx(Title, { children: "Mobile Provisioning Profiles in your Apple account" }),
+    isLoading && /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+    certs && credentialsResponse && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsxs(Box, { marginLeft: 2, marginBottom: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(Text, { children: `You have ${certs.length} Mobile Provisioning Profiles in your Apple account` }),
+        /* @__PURE__ */ jsx(Text, { children: `${hasUsable ? "One" : "None"} of these can be used by ShipThis` })
+      ] }),
+      /* @__PURE__ */ jsx(Table, { data: certs.map((cert) => getAppleProfileSummary(cert, project, credentialsResponse.data)) }),
+      !hasUsable && /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, children: "You do not have a usable Mobile Provisioning Profile. To ship an iOS game, you will need a usable Mobile Provisioning Profile." }) })
+    ] })
+  ] });
+};
+
+const ProjectCredentialsTable = ({ credentialTypeName, queryProps, ...boxProps }) => {
+  const { isLoading, data } = useProjectCredentials(queryProps);
+  const hasActive = data?.data.some((credential) => credential.isActive);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, ...boxProps, children: [
+    /* @__PURE__ */ jsx(Title, { children: `${credentialTypeName}s in your ShipThis account` }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: 2, marginBottom: 1, flexDirection: "column", children: /* @__PURE__ */ jsx(Text, { children: hasActive ? `You have an active ${credentialTypeName} in your ShipThis account.` : `You DO NOT have an active ${credentialTypeName} which ShipThis can use.` }) }),
+    isLoading && /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+    data && /* @__PURE__ */ jsx(Table, { data: data.data.map(getProjectCredentialSummary) })
+  ] });
+};
+
+class GameIosProfileStatus extends BaseGameCommand {
+  static args = {};
+  static description = "Shows the Game iOS Mobile Provisioning Profile Status. If --gameId is not provided it will look in the current directory.";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    gameId: Flags.string({ char: "g", description: "The ID of the game" }),
+    noAppleAuth: Flags.boolean({ char: "f" })
+  };
+  async run() {
+    const { flags } = this;
+    const showApple = !flags.noAppleAuth;
+    const game = await this.getGame();
+    let ctx = null;
+    if (showApple) {
+      const authState = await this.refreshAppleAuthState();
+      ctx = authState.context;
+    }
+    render(
+      /* @__PURE__ */ jsxs(App, { children: [
+        /* @__PURE__ */ jsx(
+          ProjectCredentialsTable,
+          {
+            credentialTypeName: "Mobile Provisioning Profile",
+            queryProps: { platform: Platform.IOS, type: CredentialsType.CERTIFICATE, projectId: game.id }
+          }
+        ),
+        showApple && /* @__PURE__ */ jsx(AppleProfilesTable, { ctx, project: game }),
+        /* @__PURE__ */ jsx(NextSteps, { steps: [] })
+      ] })
+    );
+  }
+}
+
+export { GameIosProfileStatus as default };