shipthis 0.1.5 → 0.1.6

package/dist/index-wyPoxiTc.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 { J as JobStatus, P as Platform, I as JobStage, L as LogLevel } from './index-DdABTtYO.js';
+import 'react';
+import 'axios';
+import '@tanstack/react-query';
+import 'luxon';
+import 'isomorphic-git';
+import '@oclif/core';
+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, getStageColor as d, getMaskedInput as e, getFileHash as f, getShortUUID as g, getPlatformName as h, isValidSemVer as i, getMessageColor as j, makeHumanReadable as m, scriptDir as s };

package/dist/upload-LXRr4pMa.js

@@ -0,0 +1,60 @@
+import axios from 'axios';
+import { p as getAuthedHeaders, q as API_URL } from './index-DdABTtYO.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/useAndroidServiceAccountTestResult-InDf5WSl.js

@@ -0,0 +1,52 @@
+import { p as getAuthedHeaders, q as API_URL } from './index-DdABTtYO.js';
+import axios from 'axios';
+import { useQuery } from '@tanstack/react-query';
+
+const cacheKeys = {
+  androidKeyTestResult: (props) => ["androidKeyTestResult", ...Object.values(props)],
+  androidSetupStatus: (props) => ["androidSetupStatus", ...Object.values(props)],
+  builds: (props) => ["builds", ...Object.values(props)],
+  googleStatus: () => ["googleStatus"],
+  job: (props) => ["job", ...Object.values(props)],
+  jobLogs: (props) => ["jobLogs", ...Object.values(props)],
+  jobs: (props) => ["jobs", ...Object.values(props)],
+  projectCredentials: (props) => ["projectCredentials", ...Object.values(props)],
+  userCredentials: (props) => ["userCredentials", ...Object.values(props)]
+};
+
+var KeyTestStatus = /* @__PURE__ */ ((KeyTestStatus2) => {
+  KeyTestStatus2["SUCCESS"] = "success";
+  KeyTestStatus2["ERROR"] = "error";
+  return KeyTestStatus2;
+})(KeyTestStatus || {});
+var KeyTestError = /* @__PURE__ */ ((KeyTestError2) => {
+  KeyTestError2["NO_SERVICE_ACCOUNT_KEY"] = "no_service_account_key";
+  KeyTestError2["NO_PACKAGE_NAME"] = "no_package_name";
+  KeyTestError2["APP_NOT_FOUND"] = "app_not_found";
+  KeyTestError2["NOT_INVITED"] = "not_invited";
+  return KeyTestError2;
+})(KeyTestError || {});
+const KeyTestErrorMessage = {
+  ["no_service_account_key" /* NO_SERVICE_ACCOUNT_KEY */]: "Service Account API Key not found in your account",
+  ["no_package_name" /* NO_PACKAGE_NAME */]: "Android Package Name has not been set",
+  ["app_not_found" /* APP_NOT_FOUND */]: "Application not found in Google Play Console",
+  ["not_invited" /* NOT_INVITED */]: "Service Account has not been invited to Google Play"
+};
+function niceError(keyError) {
+  return keyError ? KeyTestErrorMessage[keyError] : undefined;
+}
+const fetchKeyTestResult = async ({ projectId }, config) => {
+  if (!projectId) throw new Error("projectId is required");
+  const url = `${API_URL}/projects/${projectId}/credentials/android/key/test`;
+  const headers = getAuthedHeaders();
+  const { data } = await axios.post(url, {}, { headers, ...config });
+  return data;
+};
+const useAndroidServiceAccountTestResult = (props) => {
+  return useQuery({
+    queryKey: cacheKeys.androidKeyTestResult(props),
+    queryFn: () => fetchKeyTestResult(props)
+  });
+};
+
+export { KeyTestStatus as K, KeyTestError as a, cacheKeys as c, fetchKeyTestResult as f, niceError as n, useAndroidServiceAccountTestResult as u };

package/dist/useAppleApp-DgE0wEaq.js

@@ -0,0 +1,32 @@
+import { useQuery } from '@tanstack/react-query';
+import { f as App } from './index-DdABTtYO.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-DtLODy3p.js

@@ -0,0 +1,64 @@
+import { useQuery } from '@tanstack/react-query';
+import { e as BundleId, r as getGodotProjectCapabilities, P as Platform, G as GODOT_CAPABILITIES, s as CapabilityType } from './index-DdABTtYO.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 };

package/dist/useJobWatching-P5oC7mNB.js

@@ -0,0 +1,45 @@
+import { u as useJob } from './Command-DxmQn3XT.js';
+import { useState, useEffect } from 'react';
+import { u as useWebSocket } from './useWebSocket-D8PojLtx.js';
+import { K as castJobDates, M as castObjectDates } from './index-DdABTtYO.js';
+
+function useJobWatching({ projectId, jobId, isWatching, onJobUpdate }) {
+  const [websocketJob, setWebsocketJob] = useState(null);
+  const [mostRecentLog, setMostRecentLog] = useState(null);
+  const jobStatusListener = {
+    getPattern: () => [`project.${projectId}:job:created`, `project.${projectId}:job:updated`],
+    eventHandler: async (pattern, rawJob) => {
+      if (rawJob.id !== jobId) return;
+      const job2 = castJobDates(rawJob);
+      setWebsocketJob(job2);
+      if (onJobUpdate) onJobUpdate(job2);
+    }
+  };
+  const jobProgressListener = {
+    getPattern: () => `project.${projectId}:job.${jobId}:log`,
+    eventHandler: async (pattern, rawLogEntry) => {
+      const logEntry = castObjectDates(rawLogEntry, ["sentAt", "createdAt"]);
+      setMostRecentLog(logEntry);
+    }
+  };
+  useWebSocket(isWatching ? [jobStatusListener, jobProgressListener] : []);
+  const { isLoading, data: job } = useJob({
+    projectId,
+    jobId
+  });
+  useEffect(() => {
+    setWebsocketJob(null);
+  }, [jobId, projectId, isWatching, job]);
+  const fetchedJob = job ? job : null;
+  const data = websocketJob ? websocketJob : fetchedJob;
+  const progress = mostRecentLog?.progress || null;
+  const stage = mostRecentLog?.stage || null;
+  return {
+    isLoading,
+    data,
+    progress,
+    stage
+  };
+}
+
+export { useJobWatching as u };

package/dist/useProjectCredentials-BRffcsO3.js

@@ -0,0 +1,54 @@
+import axios from 'axios';
+import { useQuery } from '@tanstack/react-query';
+import { c as cacheKeys } from './useAndroidServiceAccountTestResult-InDf5WSl.js';
+import { b as getShortDate, p as getAuthedHeaders, q as API_URL, H as castArrayObjectDates } from './index-DdABTtYO.js';
+import { g as getShortUUID } from './index-wyPoxiTc.js';
+
+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.substring(0, 30) + (credential.serialNumber.length > 30 ? "\u2026" : ""),
+    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;
+};
+
+export { getProjectCredentialSummary as g, useProjectCredentials as u };

package/dist/useWebSocket-D8PojLtx.js

@@ -0,0 +1,36 @@
+import { useEffect } from 'react';
+import { io } from 'socket.io-client';
+import { N as getAuthToken, W as WS_URL } from './index-DdABTtYO.js';
+
+function useWebSocket(listeners = []) {
+  const log = () => {
+  };
+  useEffect(() => {
+    if (listeners.length === 0) {
+      return;
+    }
+    const token = getAuthToken();
+    const socket = io(WS_URL, {
+      auth: { token },
+      forceNew: true
+    });
+    socket.on("connect", () => log());
+    for (const listener of listeners) {
+      const pattern = listener.getPattern();
+      const bindSocket = (pattern2) => {
+        const boundListener = listener.eventHandler.bind(listener, pattern2);
+        socket.on(pattern2, boundListener);
+      };
+      if (Array.isArray(pattern)) {
+        pattern.forEach(bindSocket);
+        continue;
+      }
+      bindSocket(pattern);
+    }
+    return () => {
+      socket.disconnect();
+    };
+  }, []);
+}
+
+export { useWebSocket as u };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "shipthis",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "shipthis",
-      "version": "0.1.5",
+      "version": "0.1.6",
       "license": "MIT",
       "dependencies": {
         "@expo/apple-utils": "2.0.3",

package/oclif.manifest.json

@@ -2261,5 +2261,5 @@
       ]
     }
   },
-  "version": "0.1.5"
+  "version": "0.1.6"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shipthis",
   "description": "ShipThis manages building and uploading your Godot games to the App Store and Google Play.",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "author": "Hello Invent Ltd",
   "bin": {
     "shipthis": "./bin/run.js"