shipthis 0.0.1

package/dist/commands/game/wizard.js

@@ -0,0 +1,124 @@
+import { Flags } from '@oclif/core';
+import { B as BaseAuthenticatedCommand, i as isCWDGodotGame, g as getUserCredentials, P as Platform, C as CredentialsType, n as getProjectCredentials } from '../../baseGameCommand-xrD2WDDN.js';
+import 'path';
+import 'fs';
+import '@expo/apple-utils/build/index.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 'ini';
+import 'deepmerge';
+
+class GameWizard extends BaseAuthenticatedCommand {
+  static args = {};
+  static description = "Runs all the steps for the specific platform";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    forceStep: Flags.string({
+      char: "f",
+      description: "Force a specific step to run. You can repeat this flag to force multiple steps."
+    }),
+    platform: Flags.string({
+      char: "p",
+      description: "The platform to run the wizard for",
+      options: [
+        "ios"
+        /* TODO - android */
+      ],
+      required: true
+    })
+  };
+  async run() {
+    const { flags } = this;
+    if (!isCWDGodotGame()) {
+      this.error("No Godot project detected. Please run this from a godot project directory.", { exit: 1 });
+    }
+    const projectConfig = await this.getProjectConfigSafe();
+    const game = projectConfig.project;
+    const isStepForced = (commandName) => flags.forceStep?.includes(commandName);
+    const steps = [
+      {
+        command: "game:create",
+        args: ["--quiet"],
+        shouldRun: async () => !game
+      },
+      {
+        command: "apple:login",
+        args: ["--quiet"],
+        shouldRun: async () => {
+          const isLoggedIn = await this.hasValidAppleAuthState();
+          return !isLoggedIn;
+        }
+      },
+      {
+        command: "apple:apiKey:create",
+        args: ["--quiet"],
+        shouldRun: async () => {
+          const userCredentials = await getUserCredentials();
+          const userAppleApiKeyCredentials = userCredentials.filter(
+            (cred) => cred.platform == Platform.IOS && cred.type == CredentialsType.KEY
+          );
+          return userAppleApiKeyCredentials.length === 0;
+        }
+      },
+      {
+        command: "apple:certificate:create",
+        args: ["--quiet"],
+        shouldRun: async () => {
+          const userCredentials = await getUserCredentials();
+          const userAppleDistCredentials = userCredentials.filter(
+            (cred) => cred.platform == Platform.IOS && cred.type == CredentialsType.CERTIFICATE
+          );
+          return userAppleDistCredentials.length === 0;
+        }
+      },
+      {
+        command: "game:ios:app:create",
+        args: ["--quiet"],
+        shouldRun: async () => {
+          if (!game) return true;
+          const hasBundleIdSet = !!game.details?.iosBundleId;
+          return !hasBundleIdSet;
+        }
+      },
+      {
+        command: "game:ios:app:sync",
+        args: ["--quiet"],
+        // Can always run this
+        shouldRun: async () => true
+      },
+      {
+        command: "game:ios:profile:create",
+        args: ["--quiet"],
+        shouldRun: async () => {
+          if (!game) return true;
+          const projectCredentials = await getProjectCredentials(game.id);
+          const projectAppleProfileCredentials = projectCredentials.filter(
+            (cred) => cred.platform == Platform.IOS && cred.type == CredentialsType.CERTIFICATE
+          );
+          return projectAppleProfileCredentials.length === 0;
+        }
+      }
+    ];
+    for (const step of steps) {
+      const command = step.command;
+      const willRun = isStepForced(command) || await step.shouldRun();
+      if (!willRun) {
+        this.debug(`Skipping step: ${command}`);
+        continue;
+      }
+      const args = [...step.args, ...isStepForced(command) ? ["--force"] : []];
+      this.debug(`Running step: ${command} with args: ${args.join(" ")}`);
+      await this.config.runCommand(command, args);
+    }
+    await this.config.runCommand("game:status");
+  }
+}
+
+export { GameWizard as default };

package/dist/commands/login.js

@@ -0,0 +1,63 @@
+import axios from 'axios';
+import { Flags } from '@oclif/core';
+import { V as BaseCommand, p as API_URL } from '../baseGameCommand-xrD2WDDN.js';
+import { a as getInput } from '../index-DKsVctbw.js';
+import 'path';
+import 'fs';
+import '@expo/apple-utils/build/index.js';
+import 'luxon';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'react';
+import '@tanstack/react-query';
+import 'socket.io-client';
+import 'ini';
+import 'deepmerge';
+import 'isomorphic-git';
+
+class Login extends BaseCommand {
+  static args = {};
+  static description = "Authenticate - will create a new account if one does not exist.";
+  static examples = [
+    "<%= config.bin %> <%= command.id %>",
+    "<%= config.bin %> <%= command.id %> --force --email me@email.nowhere"
+  ];
+  static flags = {
+    force: Flags.boolean({ char: "f" }),
+    email: Flags.string({
+      char: "e",
+      description: "Your email address"
+    })
+  };
+  async run() {
+    const { flags } = this;
+    const authConfig = await this.getAuthConfig();
+    if (authConfig.shipThisUser && !flags.force) {
+      throw new Error(
+        `You are already logged in as ${authConfig.shipThisUser.email} use --force to login as a different user or remove the auth file`
+      );
+    }
+    const getEmail = async () => {
+      if (flags.email) return flags.email;
+      const email2 = await getInput("Please enter your email address: ");
+      if (!email2) throw new Error("Email address is required");
+      return email2;
+    };
+    const email = await getEmail();
+    await axios.post(`${API_URL}/auth/email/send`, { email });
+    this.log("Please check your email for an email with an OTP.");
+    const getOTP = async () => {
+      const otp2 = await getInput("Please enter the OTP: ");
+      if (!otp2) throw new Error("OTP is required");
+      return otp2;
+    };
+    const otp = await getOTP();
+    const { data: shipThisUser } = await axios.post(`${API_URL}/auth/email/verify`, { email, otp });
+    await this.setAuthConfig({ shipThisUser });
+    this.log("You are now logged in as", shipThisUser.email);
+    await this.config.runCommand("status");
+  }
+}
+
+export { Login as default };

package/dist/commands/status.js

@@ -0,0 +1,80 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { X as BACKEND_NAME, p as API_URL, Y as WS_URL, Z as WEB_URL, V as BaseCommand, i as isCWDGodotGame } from '../baseGameCommand-xrD2WDDN.js';
+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 'luxon';
+import 'socket.io-client';
+import '@expo/apple-utils/build/index.js';
+import { i as isCWDGitRepo } from '../git-DREGq-jc.js';
+import { S as StatusTable } from '../StatusTable-CxuX_R1D.js';
+import 'string-length';
+import 'strip-ansi';
+import { N as NextSteps } from '../NextSteps-CK9zHOCt.js';
+import '@oclif/core';
+import 'path';
+import 'ini';
+import 'deepmerge';
+import 'isomorphic-git';
+import '../Title-BCQtayg6.js';
+
+const Environment = () => {
+  if (process.env.NODE_ENV === "production") return null;
+  return /* @__PURE__ */ jsx(
+    StatusTable,
+    {
+      marginTop: 1,
+      title: "Environment",
+      statuses: {
+        Backend: BACKEND_NAME,
+        API_URL,
+        WS_URL,
+        WEB_URL
+      }
+    }
+  );
+};
+
+class Status extends BaseCommand {
+  static args = {};
+  static description = "Displays the current overall status.";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {};
+  async run() {
+    const authConfig = await this.getAuthConfig();
+    const isLoggedIn = !!authConfig.shipThisUser;
+    const isGodotGame = isCWDGodotGame();
+    const isShipThisConfigured = await this.hasProjectConfig();
+    const isGitRepo = await isCWDGitRepo();
+    let steps = [];
+    if (!isLoggedIn) steps.push("$ shipthis login --email my.email@address.nowhere");
+    if (!isGodotGame) steps.push("Run this command in a Godot project directory");
+    if (!isShipThisConfigured) steps.push('$ shipthis game create --name "My Awesome Game"');
+    if (steps.length === 0) steps = ["$ shipthis game status"];
+    const statusProps = {
+      title: "Status",
+      statuses: {
+        "Logged in": isLoggedIn,
+        "Godot project detected": isGodotGame,
+        "ShipThis project configured": isShipThisConfigured,
+        "Git repository detected (not required)": isGitRepo
+      }
+    };
+    render(
+      /* @__PURE__ */ jsxs(App, { children: [
+        /* @__PURE__ */ jsx(StatusTable, { ...statusProps }),
+        /* @__PURE__ */ jsx(Environment, {}),
+        /* @__PURE__ */ jsx(NextSteps, { steps })
+      ] })
+    );
+  }
+}
+
+export { Status as default };

package/dist/export-CujqsTR_.js

@@ -0,0 +1,36 @@
+import axios from 'axios';
+import * as fs from 'fs';
+import { o as getAuthedHeaders, p as API_URL } from './baseGameCommand-xrD2WDDN.js';
+
+async function exportCredential({ zipPath, credentialId, projectId }) {
+  const headers = getAuthedHeaders();
+  const url = projectId ? `${API_URL}/projects/${projectId}/credentials/${credentialId}/export` : `${API_URL}/credentials/${credentialId}/export`;
+  const { data } = await axios.post(
+    url,
+    {},
+    // no-body
+    { headers }
+  );
+  const downloadUrl = data.url;
+  return await downloadFile(downloadUrl, zipPath);
+}
+async function downloadFile(url, destination) {
+  const response = await axios({
+    url,
+    method: "GET",
+    responseType: "stream"
+  });
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destination);
+    response.data.pipe(file);
+    file.on("finish", () => {
+      file.close();
+      resolve();
+    });
+    file.on("error", (err) => {
+      fs.unlink(destination, () => reject(err));
+    });
+  });
+}
+
+export { exportCredential as e };

package/dist/git-DREGq-jc.js

@@ -0,0 +1,32 @@
+import git from 'isomorphic-git';
+import { promises } from 'fs';
+
+async function isCWDGitRepo() {
+  const dir = process.cwd();
+  try {
+    await git.log({ fs: promises, dir, depth: 1 });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function getCWDGitInfo() {
+  const dir = process.cwd();
+  const empty = {};
+  try {
+    const commits = await git.log({ fs: promises, dir, depth: 1 });
+    const branch = await git.currentBranch({
+      fs: promises,
+      dir,
+      fullname: false
+    });
+    return {
+      gitCommitHash: commits[0].oid,
+      gitBranch: branch
+    };
+  } catch (e) {
+    return empty;
+  }
+}
+
+export { getCWDGitInfo as g, isCWDGitRepo as i };

package/dist/import-Q-KO61ll.js

@@ -0,0 +1,38 @@
+import axios from 'axios';
+import { promises } from 'fs';
+import { o as getAuthedHeaders, p as API_URL } from './baseGameCommand-xrD2WDDN.js';
+
+async function getNewImportTicket(projectId) {
+  const url = projectId ? `${API_URL}/projects/${projectId}/credentials/import/url` : `${API_URL}/credentials/import/url`;
+  const headers = getAuthedHeaders();
+  const { data: importInfo } = await axios({
+    method: "post",
+    url,
+    headers
+  });
+  return importInfo;
+}
+async function importCredential({ projectId, zipPath, type, platform }) {
+  const importTicket = await getNewImportTicket(projectId);
+  const zipBuffer = await promises.readFile(zipPath);
+  await axios.put(importTicket.url, zipBuffer, {
+    headers: {
+      "Content-length": zipBuffer.length,
+      "Content-Type": "application/zip"
+    }
+  });
+  const headers = getAuthedHeaders();
+  const url = projectId ? `${API_URL}/projects/${projectId}/credentials/import` : `${API_URL}/credentials/import`;
+  return await axios({
+    method: "post",
+    url,
+    headers,
+    data: {
+      uuid: importTicket.uuid,
+      type,
+      platform
+    }
+  });
+}
+
+export { importCredential as i };

package/dist/index-DKsVctbw.js

@@ -0,0 +1,125 @@
+import crypto from 'crypto';
+import fs__default from 'fs';
+import readlineSync from 'readline-sync';
+import { promises } from 'node:readline';
+import { K as JobStatus, P as Platform, R as JobStage, S as LogLevel } from './baseGameCommand-xrD2WDDN.js';
+import 'react';
+import 'axios';
+import '@tanstack/react-query';
+import 'luxon';
+import '@expo/apple-utils/build/index.js';
+import 'isomorphic-git';
+import 'socket.io-client';
+
+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-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
+  ) ?? [];
+  return !!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.replace(/[\s\-_]+/g, ".");
+  normalizedGameName = normalizedGameName.replace(/[^a-z0-9\.]/g, "");
+  normalizedGameName = normalizedGameName.replace(/\.+/g, ".");
+  normalizedGameName = normalizedGameName.replace(/^\./, "").replace(/\.$/, "");
+  if (/^[0-9]/.test(normalizedGameName)) {
+    normalizedGameName = "app." + normalizedGameName;
+  }
+  const prefix = "com.";
+  if (normalizedGameName === "") {
+    return null;
+  }
+  return prefix + normalizedGameName;
+}
+
+export { getInput as a, generatePackageName as b, getPlatformName as c, getJobStatusColor as d, getFileHash as e, getMaskedInput as f, getShortUUID as g, getStageColor as h, isValidSemVer as i, getMessageColor as j, makeHumanReadable as m };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/run.js

@@ -0,0 +1,3 @@
+import { execute } from '@oclif/core';
+
+await execute({dir: import.meta.url});

package/dist/upload-CUlWmNbS.js

@@ -0,0 +1,60 @@
+import axios from 'axios';
+import { o as getAuthedHeaders, p as API_URL } from './baseGameCommand-xrD2WDDN.js';
+
+async function getNewUploadTicket(projectId = null) {
+  const url = projectId ? `${API_URL}/projects/${projectId}/credentials/url` : `${API_URL}/credentials/url`;
+  const headers = getAuthedHeaders();
+  const { data: uploadInfo } = await axios({
+    method: "post",
+    url,
+    headers
+  });
+  return uploadInfo;
+}
+async function uploadUserCredentials({ contents, platform, type, serialNumber }) {
+  const uploadInfo = await getNewUploadTicket();
+  const jsonBuffer = Buffer.from(JSON.stringify(contents));
+  await axios.put(uploadInfo.url, jsonBuffer, {
+    headers: {
+      "Content-length": jsonBuffer.length,
+      "Content-Type": "application/json"
+    }
+  });
+  const headers = getAuthedHeaders();
+  return await axios({
+    method: "post",
+    url: `${API_URL}/credentials`,
+    headers,
+    data: {
+      platform,
+      type,
+      uuid: uploadInfo.uuid,
+      serialNumber
+    }
+  });
+}
+async function uploadProjectCredentials(projectId, { contents, platform, type, serialNumber, identifier }) {
+  const uploadInfo = await getNewUploadTicket(projectId);
+  const jsonBuffer = Buffer.from(JSON.stringify(contents));
+  await axios.put(uploadInfo.url, jsonBuffer, {
+    headers: {
+      "Content-length": jsonBuffer.length,
+      "Content-Type": "application/json"
+    }
+  });
+  const headers = getAuthedHeaders();
+  return await axios({
+    method: "post",
+    url: `${API_URL}/projects/${projectId}/credentials`,
+    headers,
+    data: {
+      platform,
+      type,
+      uuid: uploadInfo.uuid,
+      identifier,
+      serialNumber
+    }
+  });
+}
+
+export { uploadProjectCredentials as a, uploadUserCredentials as u };

package/dist/useAppleApp-BmwYu7qG.js

@@ -0,0 +1,32 @@
+import { useQuery } from '@tanstack/react-query';
+import { k as App } from './baseGameCommand-xrD2WDDN.js';
+
+const queryAppleApp = async ({ ctx, iosBundleId }) => {
+  if (!iosBundleId) {
+    return { app: null, summary: null };
+  }
+  const app = await App.findAsync(ctx, {
+    bundleId: iosBundleId
+  });
+  if (!app) {
+    return { app: null, summary: null };
+  }
+  return {
+    app,
+    summary: {
+      id: app.id,
+      name: app.attributes.name,
+      bundleId: app.attributes.bundleId,
+      primaryLocale: app.attributes.primaryLocale
+    }
+  };
+};
+const useAppleApp = (props) => {
+  const queryResult = useQuery({
+    queryKey: ["appleApp", props.iosBundleId],
+    queryFn: () => queryAppleApp(props)
+  });
+  return queryResult;
+};
+
+export { queryAppleApp as q, useAppleApp as u };

package/dist/useAppleBundleId-DCJnfNWr.js

@@ -0,0 +1,64 @@
+import { useQuery } from '@tanstack/react-query';
+import { m as BundleId, u as getGodotProjectCapabilities, P as Platform, G as GODOT_CAPABILITIES, v as CapabilityType } from './baseGameCommand-xrD2WDDN.js';
+
+async function getBundleIdCapabilities(bundleId) {
+  const current = await bundleId.getBundleIdCapabilitiesAsync();
+  let existing = [];
+  for (const capability of current) {
+    const capabilityType = Object.values(CapabilityType).find((c) => capability.isType(c));
+    if (capabilityType) {
+      existing.push(capabilityType);
+    }
+  }
+  return existing;
+}
+const fetchBundleId = async ({ ctx, iosBundleId }) => {
+  const empty = {
+    bundleId: null,
+    bundleIdSummary: null,
+    capabilities: null,
+    capabilitiesTable: null,
+    projectCapabilities: null,
+    shouldSyncCapabilities: null
+  };
+  if (!iosBundleId) return empty;
+  const bundleId = await BundleId.findAsync(ctx, {
+    identifier: iosBundleId
+  });
+  if (!bundleId) return empty;
+  const bundleIdCapabilities = await getBundleIdCapabilities(bundleId);
+  const projectCapabilities = getGodotProjectCapabilities(Platform.IOS);
+  const capabilitiesTable = GODOT_CAPABILITIES.map((gc) => {
+    const isEnabledInBundle = bundleIdCapabilities.includes(gc.type);
+    const isEnabledInProject = projectCapabilities.includes(gc.type);
+    const isCorrectlyConfigured = isEnabledInBundle === isEnabledInProject;
+    return {
+      name: gc.name,
+      isEnabledInBundle,
+      isEnabledInProject,
+      isCorrectlyConfigured
+    };
+  });
+  return {
+    bundleId,
+    bundleIdSummary: {
+      id: bundleId.id,
+      identifier: bundleId.attributes.identifier,
+      name: bundleId.attributes.name,
+      platform: bundleId.attributes.platform
+    },
+    capabilities: bundleIdCapabilities,
+    capabilitiesTable,
+    projectCapabilities,
+    shouldSyncCapabilities: !capabilitiesTable.every((c) => c.isCorrectlyConfigured)
+  };
+};
+const useAppleBundleId = (props) => {
+  const queryResult = useQuery({
+    queryKey: ["appleBundleId", props.iosBundleId],
+    queryFn: () => fetchBundleId(props)
+  });
+  return queryResult;
+};
+
+export { fetchBundleId as f, useAppleBundleId as u };