shipthis 0.1.25 → 0.1.26

package/dist/commands/login.js

@@ -0,0 +1,92 @@
+import axios from 'axios';
+import { Flags } from '@oclif/core';
+import { W as WEB_URL, Y as BaseCommand, q as API_URL, _ as setAuthToken, $ as acceptTerms } from '../index-DkNQs11R.js';
+import { a as getInput } from '../index-BB00V5oF.js';
+import 'path';
+import 'fs';
+import '@expo/apple-utils/build/index.js';
+import 'crypto-js';
+import 'uuid';
+import 'luxon';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'isomorphic-git';
+import 'ini';
+import 'deepmerge';
+import 'react';
+import '@tanstack/react-query';
+import 'fast-glob';
+import 'yazl';
+import 'socket.io-client';
+
+const TERMS_URL = new URL("/terms", WEB_URL).href;
+const PRIVACY_URL = new URL("/privacy", WEB_URL).href;
+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 source = `shipthis-cli-${this.config.version}`;
+    const { data: shipThisUser } = await axios.post(`${API_URL}/auth/email/verify`, { email, otp, source });
+    const getAcceptedTermsResponse = async () => {
+      console.log(
+        `Please review the following documents:
+
+${[
+          `- Privacy Policy: ${PRIVACY_URL}`,
+          `- Terms and Conditions: ${TERMS_URL}`
+        ].join("\n")}
+`
+      );
+      const accepted = await getInput("Do you accept the terms of these documents? (yes/no): ");
+      const answer = accepted.toLowerCase().trim().substring(0, 1);
+      return answer === "y";
+    };
+    await this.setAuthConfig({ shipThisUser });
+    setAuthToken(shipThisUser.jwt);
+    this.log("You are now logged in as", shipThisUser.email);
+    if (!shipThisUser.details?.hasAcceptedTerms) {
+      const didAccept = await getAcceptedTermsResponse();
+      if (!didAccept) throw new Error("You must accept the terms to continue");
+      await acceptTerms();
+    }
+    await this.config.runCommand("status");
+  }
+}
+
+export { Login as default };

package/dist/commands/status.js

@@ -0,0 +1,76 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { render } from 'ink';
+import { Y as BaseCommand, j as isCWDGodotGame } from '../index-DkNQs11R.js';
+import 'react';
+import '../index-nnzhQ3nY.js';
+import 'ink-spinner';
+import 'axios';
+import 'crypto-js';
+import 'uuid';
+import 'fs';
+import 'luxon';
+import '@inkjs/ui';
+import '@tanstack/react-query';
+import 'yazl';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import { i as isCWDGitRepo } from '../git-DREGq-jc.js';
+import '@oclif/core';
+import 'fast-glob';
+import 'socket.io-client';
+import 'open';
+import 'marked';
+import 'marked-terminal';
+import 'path';
+import { N as NextSteps } from '../NextSteps-CK9zHOCt.js';
+import 'qrcode';
+import { S as StatusTable } from '../StatusTable-Dm5St4g-.js';
+import 'string-length';
+import 'strip-ansi';
+import { C as Command } from '../Command-B3AmRt2w.js';
+import '@expo/apple-utils/build/index.js';
+import 'isomorphic-git';
+import 'ini';
+import 'deepmerge';
+import '../index-BB00V5oF.js';
+import '../useAndroidServiceAccountTestResult-DcYDam-p.js';
+import '../Title-BCQtayg6.js';
+
+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 wizard");
+    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(Command, { command: this, children: [
+        /* @__PURE__ */ jsx(StatusTable, { ...statusProps }),
+        /* @__PURE__ */ jsx(NextSteps, { steps })
+      ] })
+    );
+  }
+}
+
+export { Status as default };

package/dist/export-CVs_xoDN.js

@@ -0,0 +1,36 @@
+import axios from 'axios';
+import * as fs from 'fs';
+import { p as getAuthedHeaders, q as API_URL } from './index-DkNQs11R.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-Ch5O7xfN.js

@@ -0,0 +1,47 @@
+import axios from 'axios';
+import { promises } from 'fs';
+import { p as getAuthedHeaders, q as API_URL } from './index-DkNQs11R.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`;
+  const { data: publicCredential } = await axios({
+    method: "post",
+    url,
+    headers,
+    data: {
+      uuid: importTicket.uuid,
+      type,
+      platform
+    }
+  });
+  if (projectId) {
+    return publicCredential;
+  }
+  return publicCredential;
+}
+
+export { importCredential as i };

package/dist/index-BB00V5oF.js

@@ -0,0 +1,136 @@
+import crypto from 'crypto';
+import fs__default from 'fs';
+import readlineSync from 'readline-sync';
+import { promises } from 'node:readline';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { N as JobStage, P as Platform, O as LogLevel, J as JobStatus } from './index-DkNQs11R.js';
+import 'luxon';
+import 'axios';
+import 'isomorphic-git';
+import '@oclif/core';
+import 'react';
+import '@tanstack/react-query';
+import 'crypto-js';
+import 'uuid';
+import 'fast-glob';
+import 'yazl';
+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;
+}
+function scriptDir(importMeta) {
+  const filename = fileURLToPath(importMeta.url);
+  const dirname = path.dirname(filename);
+  return dirname;
+}
+
+export { getInput as a, generatePackageName as b, getJobStatusColor as c, getMaskedInput as d, getFileHash as e, getPlatformName as f, getShortUUID as g, getStageColor as h, isValidSemVer as i, getMessageColor as j, makeHumanReadable as m, scriptDir as s };

package/dist/index-BD1WLuFJ.js

@@ -0,0 +1,125 @@
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { Text, useInput, Box } from 'ink';
+import open from 'open';
+import { useState, useEffect, useContext } from 'react';
+import { T as getGoogleStatus, a3 as getShortAuthRequiredUrl, a4 as getGoogleAuthUrl, W as WEB_URL } from './index-DkNQs11R.js';
+import 'crypto';
+import 'fs';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'luxon';
+import 'axios';
+import 'isomorphic-git';
+import '@oclif/core';
+import { useQuery } from '@tanstack/react-query';
+import 'crypto-js';
+import 'uuid';
+import 'fast-glob';
+import 'yazl';
+import 'socket.io-client';
+import { u as useWebSocket } from './useWebSocket-ByuNoqRw.js';
+import { c as cacheKeys } from './useAndroidServiceAccountTestResult-DcYDam-p.js';
+import { b as GameContext, M as Markdown } from './index-nnzhQ3nY.js';
+import 'ink-spinner';
+import '@inkjs/ui';
+import 'string-length';
+import 'strip-ansi';
+import 'marked';
+import 'marked-terminal';
+import 'path';
+import qrcode from 'qrcode';
+
+const useGoogleStatus = () => {
+  return useQuery({
+    queryKey: cacheKeys.googleStatus(),
+    queryFn: getGoogleStatus
+  });
+};
+
+function useGoogleStatusWatching({
+  projectId,
+  isWatching,
+  onGoogleStatusUpdate
+}) {
+  const [wsGoogleStatus, setWsGoogleStatus] = useState(null);
+  const listener = {
+    getPattern: () => `project.${projectId}:google-status`,
+    eventHandler: async (pattern, data2) => {
+      setWsGoogleStatus(data2);
+      if (onGoogleStatusUpdate) onGoogleStatusUpdate(data2);
+    }
+  };
+  useWebSocket([listener] );
+  const { isLoading, data: googleStatus } = useGoogleStatus();
+  useEffect(() => {
+    setWsGoogleStatus(null);
+  }, [projectId, isWatching, googleStatus]);
+  const fetchedGoogleStatus = googleStatus ? googleStatus : null;
+  const data = wsGoogleStatus ? wsGoogleStatus : fetchedGoogleStatus;
+  return {
+    isLoading,
+    data
+  };
+}
+
+const QRCodeTerminal = ({ url }) => {
+  const [code, setCode] = useState(null);
+  const handleLoad = async () => {
+    const codeString = await qrcode.toString(url, { type: "terminal", errorCorrectionLevel: "L", small: true });
+    setCode(codeString);
+  };
+  useEffect(() => {
+    handleLoad();
+  }, []);
+  return /* @__PURE__ */ jsx(Fragment, { children: code && /* @__PURE__ */ jsx(Text, { children: code }) });
+};
+
+async function getConnectUrl(gameId, helpPage) {
+  const helpPagePath = `/docs/android?gameId=${gameId}#2-connect-shipthis-with-google`;
+  const url = helpPage ? await getShortAuthRequiredUrl(helpPagePath) : await getGoogleAuthUrl(gameId);
+  return url;
+}
+const GoogleAuthQRCode = ({ gameId, helpPage }) => {
+  const [url, setUrl] = useState(null);
+  const handleLoad = async () => {
+    const url2 = await getConnectUrl(gameId, helpPage);
+    setUrl(url2);
+  };
+  useEffect(() => {
+    handleLoad();
+  }, []);
+  return /* @__PURE__ */ jsx(Fragment, { children: url && /* @__PURE__ */ jsx(QRCodeTerminal, { url }) });
+};
+
+const ConnectGoogle = (props) => {
+  const { gameId } = useContext(GameContext);
+  return /* @__PURE__ */ jsx(Fragment, { children: gameId && /* @__PURE__ */ jsx(ConnectForGame, { gameId, ...props }) });
+};
+const ConnectForGame = ({ onComplete, onError, helpPage, gameId, ...boxProps }) => {
+  useGoogleStatusWatching({
+    projectId: gameId,
+    isWatching: true,
+    onGoogleStatusUpdate: (status) => {
+      if (status.isAuthenticated) return onComplete();
+    }
+  });
+  useInput(async (input) => {
+    if (!gameId) return;
+    if (input !== "d") return;
+    const url = await getConnectUrl(gameId, true);
+    await open(url);
+  });
+  const templateVars = {
+    privacyURL: new URL("/privacy", WEB_URL).toString()
+  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, ...boxProps, children: [
+    /* @__PURE__ */ jsx(Markdown, { filename: "privacy-notification.md", templateVars }),
+    /* @__PURE__ */ jsx(Text, { children: "Scan the QR code below to connect your Google account to ShipThis:" }),
+    gameId && /* @__PURE__ */ jsx(GoogleAuthQRCode, { gameId, helpPage: !!helpPage }),
+    /* @__PURE__ */ jsx(Text, { children: "Or press D to sign-in using your browser" })
+  ] });
+};
+
+export { ConnectGoogle as C };

package/dist/index-CIa2EDQ6.js

@@ -0,0 +1,24 @@
+import axios from 'axios';
+import { p as getAuthedHeaders, q as API_URL, L as castArrayObjectDates } from './index-DkNQs11R.js';
+import 'fs';
+
+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);
+}
+
+export { getProjectCredentials as a, getUserCredentials as g };