shipthis 0.1.10 → 0.1.11

package/dist/commands/game/wizard.js

@@ -1,35 +1,36 @@
 import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
 import { Args } from '@oclif/core';
-import { Text, Box, render } from 'ink';
+import { Text, Box, useInput, render } from 'ink';
 import { p as getAuthedHeaders, q as API_URL, K as castArrayObjectDates, $ as queryClient, a8 as updateProject, u as getGodotVersion, t as GameEngine, v as createProject, w as DEFAULT_IGNORED_FILES_GLOBS, x as DEFAULT_SHIPPED_FILES_GLOBS, P as Platform, J as JobStatus, X as WEB_URL, H as getProject, C as CredentialsType, Q as getGoogleStatus, B as BaseAuthenticatedCommand, j as isCWDGodotGame } from '../../index-BB7X1Pqp.js';
 import React, { useState, useContext, useEffect, useRef } from 'react';
-import { c as CommandContext, b as GameContext, d as useBuilds, M as Markdown, q as queryBuilds, G as GameProvider, e as CreateGooglePlayGame, C as Command } from '../../Command-D6rWEZRM.js';
+import { c as CommandContext, b as GameContext, M as Markdown, d as useBuilds, q as queryBuilds, G as GameProvider, e as CreateGooglePlayGame, C as Command } from '../../Command-BiB9MqbJ.js';
 import Spinner from 'ink-spinner';
 import { Alert, TextInput } from '@inkjs/ui';
 import axios from 'axios';
 import 'crypto-js';
 import 'uuid';
 import 'luxon';
-import 'fs';
+import fs__default from 'fs';
 import { useQuery, useMutation } from '@tanstack/react-query';
-import 'open';
+import 'yazl';
 import 'crypto';
 import 'readline-sync';
 import 'node:readline';
 import 'node:path';
 import 'node:url';
 import 'fast-glob';
-import 'yazl';
 import 'socket.io-client';
 import 'isomorphic-git';
+import 'open';
 import 'qrcode';
 import 'string-length';
 import 'strip-ansi';
-import { C as CreateKeystore } from '../../CreateKeystore-g1z6DsU5.js';
-import { C as ConnectGoogle } from '../../index-DgbQBx6x.js';
-import { C as CreateServiceAccountKey } from '../../index-m4HTrJ5J.js';
+import { C as CreateKeystore } from '../../Create-DIaSKUpl.js';
+import { I as ImportKeystore } from '../../Import-BIOsf8AA.js';
+import { C as ConnectGoogle } from '../../index-o9Y-84Rj.js';
+import { C as CreateServiceAccountKey } from '../../index-D6BH5UAM.js';
 import { c as cacheKeys, f as fetchKeyTestResult, K as KeyTestStatus, a as KeyTestError } from '../../useAndroidServiceAccountTestResult-Ce1x0Eh8.js';
-import { u as useShip, J as JobProgress } from '../../JobProgress-jmGAzvxS.js';
+import { u as useShip, J as JobProgress } from '../../JobProgress-W0QQR49T.js';
 import { a as getProjectCredentials } from '../../index-DOgF4dFK.js';
 import { T as Title } from '../../Title-BCQtayg6.js';
 import 'path';
@@ -40,11 +41,12 @@ import '../../index-Cz_KLwWf.js';
 import 'marked';
 import 'marked-terminal';
 import '../../RunWithSpinner-BVXNWGD3.js';
+import '../../import-v54PM_Qg.js';
 import '../../useWebSocket-CBqsjHbt.js';
 import '../../useProjectCredentials-vjedBbKl.js';
 import '../../ProgressSpinner-6pw1T8Iw.js';
 import '../../git-DREGq-jc.js';
-import '../../useJobWatching-D-YzSlK8.js';
+import '../../useJobWatching-I_A3b36f.js';
 
 async function queryJobs({ projectId, ...pageAndSortParams }) {
   try {
@@ -230,6 +232,103 @@ const FormTextInput = ({ label, labelProps, ...rest }) => /* @__PURE__ */ jsxs(B
   /* @__PURE__ */ jsx(TextInput, { ...rest })
 ] });
 
+const ImportForm = ({ importKeystoreProps, onSubmit }) => {
+  const [activeInput, setActiveInput] = useState("jksFilePath" /* jksFilePath */);
+  const [error, setError] = useState(null);
+  const [jksFilePath, setJksFilePath] = useState(importKeystoreProps.jksFilePath);
+  const [password, setPassword] = useState(importKeystoreProps.keyPassword);
+  const handleSubmitJksFilePath = () => {
+    setError(null);
+    if (!jksFilePath || jksFilePath.length === 0) {
+      setError("Please enter a path to your jks file");
+      return;
+    }
+    if (!fs__default.existsSync(jksFilePath)) {
+      setError("The file does not exist");
+      return;
+    }
+    setActiveInput("password" /* password */);
+  };
+  const handleSubmitPassword = () => {
+    setError(null);
+    if (!password || password.length === 0) {
+      setError("Please enter a password");
+      return;
+    }
+    onSubmit({
+      ...importKeystoreProps,
+      jksFilePath,
+      keyPassword: password,
+      keystorePassword: password
+    });
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    error && /* @__PURE__ */ jsx(Alert, { variant: "error", children: error }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [
+      /* @__PURE__ */ jsx(
+        FormTextInput,
+        {
+          label: "Path to your jks file:",
+          isDisabled: activeInput !== "jksFilePath" /* jksFilePath */,
+          defaultValue: jksFilePath,
+          placeholder: "Enter the path to your jks file...",
+          onChange: setJksFilePath,
+          onSubmit: handleSubmitJksFilePath
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        FormTextInput,
+        {
+          label: "Password:",
+          isDisabled: activeInput !== "password" /* password */,
+          defaultValue: password,
+          placeholder: "Enter the password for your jks file...",
+          onChange: setPassword,
+          onSubmit: handleSubmitPassword
+        }
+      )
+    ] })
+  ] });
+};
+
+const CreateOrImport = ({ onComplete, onError, ...boxProps }) => {
+  const [stage, setStage] = useState(0 /* Choose */);
+  const [importKeystoreProps, setImportKeystoreProps] = useState({
+    jksFilePath: "",
+    keyPassword: "",
+    keystorePassword: ""
+  });
+  useInput(async (input) => {
+    if (stage !== 0 /* Choose */) return;
+    if (input === "c") return setStage(1 /* Create */);
+    if (input === "i") return setStage(2 /* ImportForm */);
+  });
+  const handleImportFormSubmit = (newImportProps) => {
+    setImportKeystoreProps(newImportProps);
+    setStage(3 /* ImportKeystore */);
+  };
+  const renderStage = () => {
+    switch (stage) {
+      case 0 /* Choose */:
+        return /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Text, { children: "Would you like to create a new keystore or import an existing one?" }),
+          /* @__PURE__ */ jsx(Text, { bold: true, children: "Press C to create a new keystore" }),
+          /* @__PURE__ */ jsx(Text, { bold: true, children: "Press I to import an existing keystore" })
+        ] });
+      case 1 /* Create */:
+        return /* @__PURE__ */ jsx(CreateKeystore, { onComplete, onError });
+      case 2 /* ImportForm */:
+        return /* @__PURE__ */ jsx(ImportForm, { onSubmit: handleImportFormSubmit, importKeystoreProps });
+      case 3 /* ImportKeystore */:
+        return /* @__PURE__ */ jsx(ImportKeystore, { onComplete, onError, importKeystoreProps });
+    }
+  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, ...boxProps, children: [
+    /* @__PURE__ */ jsx(Markdown, { filename: "create-or-import-keystore.md", templateVars: {} }),
+    renderStage()
+  ] });
+};
+
 const CreateInitialBuild = (props) => {
   const { gameId } = useContext(GameContext);
   return /* @__PURE__ */ jsx(Fragment, { children: gameId && /* @__PURE__ */ jsx(CreateForGame, { gameId, ...props }) });
@@ -252,8 +351,10 @@ const CreateForGame = ({ onComplete, onError, gameId, ...boxProps }) => {
     const hasAndroidBuild = buildData.data.some((build) => build.platform === Platform.ANDROID);
     if (!prevHasBuild.current && hasAndroidBuild) return onComplete();
     prevHasBuild.current = hasAndroidBuild;
-    const hasAndroidJob = jobData.data.some((job) => job.type === Platform.ANDROID);
-    const shouldRun = !hasAndroidBuild && !hasAndroidJob;
+    const hasRunningAndroidJob = jobData.data.some(
+      (job) => job.type === Platform.ANDROID && [JobStatus.PENDING, JobStatus.PROCESSING].includes(job.status)
+    );
+    const shouldRun = !hasAndroidBuild && !hasRunningAndroidJob;
     if (shouldRun)
       shipMutation.mutateAsync({
         command,
@@ -357,9 +458,7 @@ const getStepInitialStatus = (step, statusFlags) => {
     createKeystore: statusFlags.hasAndroidKeystore,
     createServiceAccount: statusFlags.hasServiceAccountKey,
     createGooglePlayGame: statusFlags.hasGooglePlayGame,
-    inviteServiceAccount: statusFlags.hasInvitedServiceAccount,
-    connectGoogle: false,
-    createInitialBuild: false
+    inviteServiceAccount: statusFlags.hasInvitedServiceAccount
   };
   return base[step] ? "SUCCESS" /* SUCCESS */ : "PENDING" /* PENDING */;
 };
@@ -399,7 +498,7 @@ const getStatusFlags = async (cmd) => {
 
 const StepLabels = {
   createGame: "Create game in ShipThis",
-  createKeystore: "Create an Android Keystore",
+  createKeystore: "Create or import an Android Keystore",
   connectGoogle: "Connect ShipThis with Google",
   createServiceAccount: "Create a Service Account & API Key",
   createInitialBuild: "Create an initial build",
@@ -438,7 +537,7 @@ const StepStatusTable = ({ stepStatuses }) => {
 
 const stepComponentMap = {
   createGame: CreateGame,
-  createKeystore: CreateKeystore,
+  createKeystore: CreateOrImport,
   connectGoogle: ConnectGoogle,
   createServiceAccount: CreateServiceAccountKey,
   createInitialBuild: CreateInitialBuild,

package/dist/commands/status.js

@@ -2,7 +2,7 @@ import { jsxs, jsx } from 'react/jsx-runtime';
 import { render } from 'ink';
 import { T as BaseCommand, j as isCWDGodotGame } from '../index-BB7X1Pqp.js';
 import 'react';
-import { C as Command } from '../Command-D6rWEZRM.js';
+import { C as Command } from '../Command-BiB9MqbJ.js';
 import 'ink-spinner';
 import 'axios';
 import 'crypto-js';
@@ -11,17 +11,17 @@ import 'luxon';
 import 'fs';
 import '@inkjs/ui';
 import '@tanstack/react-query';
-import 'open';
+import 'yazl';
 import 'crypto';
 import 'readline-sync';
 import 'node:readline';
 import 'node:path';
 import 'node:url';
 import 'fast-glob';
-import 'yazl';
 import 'socket.io-client';
 import { i as isCWDGitRepo } from '../git-DREGq-jc.js';
 import '@oclif/core';
+import 'open';
 import { N as NextSteps } from '../NextSteps-CK9zHOCt.js';
 import 'qrcode';
 import { S as StatusTable } from '../StatusTable-Dm5St4g-.js';

package/dist/import-v54PM_Qg.js

@@ -0,0 +1,47 @@
+import axios from 'axios';
+import { promises } from 'fs';
+import { p as getAuthedHeaders, q as API_URL } from './index-BB7X1Pqp.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-D6BH5UAM.js

@@ -0,0 +1,135 @@
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { Box, Text } from 'ink';
+import { useState, useRef, useEffect, useContext } from 'react';
+import Spinner from 'ink-spinner';
+import { b as GameContext } from './Command-BiB9MqbJ.js';
+import { p as getAuthedHeaders, q as API_URL, F as castObjectDates, P as Platform, C as CredentialsType, Q as getGoogleStatus } from './index-BB7X1Pqp.js';
+import axios from 'axios';
+import 'crypto-js';
+import 'uuid';
+import 'luxon';
+import 'fs';
+import '@inkjs/ui';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import 'yazl';
+import 'crypto';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import { c as cacheKeys } from './useAndroidServiceAccountTestResult-Ce1x0Eh8.js';
+import 'fast-glob';
+import 'socket.io-client';
+import 'isomorphic-git';
+import '@oclif/core';
+import { u as useWebSocket } from './useWebSocket-CBqsjHbt.js';
+import { u as useProjectCredentials } from './useProjectCredentials-vjedBbKl.js';
+import 'open';
+import { P as ProgressSpinner } from './ProgressSpinner-6pw1T8Iw.js';
+import 'qrcode';
+import 'string-length';
+import 'strip-ansi';
+
+async function fetchStatus({ projectId }) {
+  try {
+    if (!projectId) throw new Error("projectId is required");
+    const headers = getAuthedHeaders();
+    const url = `${API_URL}/projects/${projectId}/credentials/android/key/status/`;
+    const response = await axios.get(url, { headers });
+    return castObjectDates(response.data);
+  } catch (error) {
+    console.warn("fetchStatus Error", error);
+    throw error;
+  }
+}
+const useAndroidServiceAccountSetupStatus = (props) => {
+  return useQuery({
+    queryKey: cacheKeys.androidSetupStatus(props),
+    queryFn: () => fetchStatus(props),
+    // Status changes frequently, so we want to keep it fresh
+    refetchInterval: 1e3 * 5,
+    staleTime: 1e3 * 5
+  });
+};
+
+const ERR_NOT_AUTHENTICATED = "You must be connected to Google to create a Service Account Key";
+const useHasServiceAccountKey = (projectId) => {
+  const { data, isSuccess } = useProjectCredentials({ projectId, platform: Platform.ANDROID });
+  return isSuccess && data.data.some((cred) => cred.isActive && cred.platform === Platform.ANDROID && cred.type == CredentialsType.KEY);
+};
+const useAndroidServiceAccount = ({ projectId, onError, onComplete }) => {
+  const queryClient = useQueryClient();
+  const [isStarting, setIsStarting] = useState(false);
+  const hasServiceAccountKey = useHasServiceAccountKey(projectId);
+  const listener = {
+    getPattern: () => `project.${projectId}:android-setup-status`,
+    eventHandler: async (pattern, data) => {
+      const key = cacheKeys.androidSetupStatus({ projectId });
+      queryClient.setQueryData(key, () => data);
+    }
+  };
+  useWebSocket([listener]);
+  const { data: setupStatus } = useAndroidServiceAccountSetupStatus({ projectId });
+  const prevSetupStatusRef = useRef("unknown");
+  useEffect(() => {
+    if (["running", "queued"].includes(prevSetupStatusRef.current)) {
+      if (setupStatus?.status === "complete") onComplete();
+      if (setupStatus?.status === "error") onError(new Error(setupStatus.errorMessage));
+    }
+    prevSetupStatusRef.current = setupStatus?.status || "unknown";
+  }, [setupStatus]);
+  const handleStart = async () => {
+    try {
+      setIsStarting(true);
+      const currentStatus = await getGoogleStatus();
+      if (!currentStatus.isAuthenticated) throw new Error(ERR_NOT_AUTHENTICATED);
+      const headers = getAuthedHeaders();
+      const androidKeyApiBase = `${API_URL}/projects/${projectId}/credentials/android/key`;
+      const startUrl = `${androidKeyApiBase}/setup/`;
+      const { data: updatedStatus } = await axios.post(startUrl, {}, { headers });
+      queryClient.invalidateQueries({
+        queryKey: cacheKeys.projectCredentials({ projectId, pageNumber: 0 })
+      });
+      await queryClient.setQueryData(cacheKeys.androidSetupStatus({ projectId }), (_) => updatedStatus);
+      setIsStarting(false);
+      return true;
+    } catch (error) {
+      setIsStarting(false);
+      console.warn("useAndroidServiceAccount.handleStart Error", error);
+      onError(error);
+      return false;
+    }
+  };
+  const isCreating = isStarting || setupStatus?.status === "queued" || setupStatus?.status === "running";
+  return {
+    handleStart,
+    setupStatus,
+    isCreating,
+    hasServiceAccountKey
+  };
+};
+
+const CreateServiceAccountKey = (props) => {
+  const { gameId } = useContext(GameContext);
+  return /* @__PURE__ */ jsx(Fragment, { children: gameId && /* @__PURE__ */ jsx(CreateForGame, { gameId, ...props }) });
+};
+const CreateForGame = ({ onComplete, onError, gameId, ...boxProps }) => {
+  const [didStart, setDidStart] = useState(false);
+  const { handleStart, setupStatus, isCreating } = useAndroidServiceAccount({
+    projectId: gameId,
+    onError,
+    onComplete
+  });
+  useEffect(() => {
+    handleStart().then(() => setDidStart(true));
+  }, [gameId]);
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, ...boxProps, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, children: [
+      /* @__PURE__ */ jsx(Text, { children: "Creating a Service Account and API Key..." }),
+      isCreating && /* @__PURE__ */ jsx(Spinner, { type: "dots" })
+    ] }),
+    didStart && /* @__PURE__ */ jsx(ProgressSpinner, { progress: (setupStatus?.progress || 0) * 100, spinnerType: "dots" })
+  ] }) });
+};
+
+export { CreateServiceAccountKey as C };

package/dist/index-o9Y-84Rj.js

@@ -0,0 +1,122 @@
+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 { Q as getGoogleStatus, a2 as getShortAuthRequiredUrl, a3 as getGoogleAuthUrl, X as WEB_URL } from './index-BB7X1Pqp.js';
+import 'crypto';
+import 'fs';
+import 'readline-sync';
+import 'node:readline';
+import 'node:path';
+import 'node:url';
+import 'axios';
+import { useQuery } from '@tanstack/react-query';
+import 'crypto-js';
+import 'uuid';
+import 'luxon';
+import 'fast-glob';
+import 'yazl';
+import 'socket.io-client';
+import { u as useWebSocket } from './useWebSocket-CBqsjHbt.js';
+import { c as cacheKeys } from './useAndroidServiceAccountTestResult-Ce1x0Eh8.js';
+import 'isomorphic-git';
+import '@oclif/core';
+import { b as GameContext, M as Markdown } from './Command-BiB9MqbJ.js';
+import 'ink-spinner';
+import '@inkjs/ui';
+import 'string-length';
+import 'strip-ansi';
+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/useJobWatching-I_A3b36f.js

@@ -0,0 +1,45 @@
+import { u as useJob } from './Command-BiB9MqbJ.js';
+import { useState, useEffect } from 'react';
+import { u as useWebSocket } from './useWebSocket-CBqsjHbt.js';
+import { E as castJobDates, F as castObjectDates } from './index-BB7X1Pqp.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/npm-shrinkwrap.json

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

package/oclif.manifest.json

@@ -1827,14 +1827,15 @@
       "aliases": [],
       "args": {
         "file": {
-          "description": "Name of the ZIP file to import (must be in the same format as the export)",
+          "description": "Path to the ZIP file to import (must be in the same format as the export)",
           "name": "file",
-          "required": true
+          "required": false
         }
       },
       "description": "Imports an Android Keystore to your ShipThis account for the specified game.",
       "examples": [
-        "<%= config.bin %> <%= command.id %>"
+        "<%= config.bin %> <%= command.id %> path/to/import.zip -g abfd5b00",
+        "<%= config.bin %> <%= command.id %> --jksFile path/to/file.jks --keystorePassword yourpass --keyPassword yourkeypass"
       ],
       "flags": {
         "gameId": {
@@ -1845,8 +1846,30 @@
           "multiple": false,
           "type": "option"
         },
+        "jksFile": {
+          "description": "Path to the JKS file to import (requires passwords)",
+          "name": "jksFile",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "keystorePassword": {
+          "description": "Keystore password (required when using --jksFile)",
+          "name": "keystorePassword",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "keyPassword": {
+          "description": "Key alias password (required when using --jksFile)",
+          "name": "keyPassword",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "force": {
           "char": "f",
+          "description": "Overwrite any existing keystore without confirmation",
           "name": "force",
           "allowNo": false,
           "type": "boolean"
@@ -2297,5 +2320,5 @@
       ]
     }
   },
-  "version": "0.1.10"
+  "version": "0.1.11"
 }

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.10",
+  "version": "0.1.11",
   "author": "Hello Invent Ltd",
   "bin": {
     "shipthis": "./bin/run.js"