@todesktop/cli 1.5.1 → 1.6.1

package/dist/cli.js

@@ -0,0 +1,4430 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+var import_ink33 = require("ink");
+var import_react21 = require("react");
+var import_register = require("source-map-support/register");
+
+// src/components/Build.tsx
+var import_react6 = require("react");
+var import_prop_types9 = __toESM(require("prop-types"));
+
+// src/components/BuildProgress.tsx
+var import_ink4 = require("ink");
+var import_prop_types3 = __toESM(require("prop-types"));
+var import_react2 = require("react");
+var import_lodash = __toESM(require("lodash.throttle"));
+
+// src/components/BuildCompleteMessage.tsx
+var import_ink2 = require("ink");
+var import_ink_link = __toESM(require("ink-link"));
+var import_prop_types = __toESM(require("prop-types"));
+var import_react = require("react");
+
+// src/utilities/logForCI.ts
+var import_is_ci = __toESM(require("is-ci"));
+
+// src/utilities/logger.ts
+var import_bunyan = __toESM(require("bunyan"));
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var Sentry = __toESM(require("@sentry/node"));
+var logger;
+try {
+  const name = "todesktop-cli";
+  let parentDirectory;
+  const homePath = os.homedir();
+  if (process.platform === "darwin") {
+    parentDirectory = path.join(homePath, "Library", "Logs", name);
+  } else if (process.platform === "win32") {
+    parentDirectory = path.join(
+      process.env.APPDATA || path.join(homePath, "AppData", "Roaming"),
+      name,
+      "logs"
+    );
+  } else {
+    parentDirectory = path.join(
+      process.env.XDG_CONFIG_HOME || path.join(homePath, ".config"),
+      name,
+      "logs"
+    );
+  }
+  fs.mkdirSync(parentDirectory, { recursive: true });
+  logger = import_bunyan.default.createLogger({
+    name,
+    src: true,
+    streams: [
+      {
+        level: "debug",
+        path: path.join(parentDirectory, "main.log")
+      }
+    ]
+  });
+} catch (e) {
+  const noOp = () => {
+  };
+  logger = {
+    debug: noOp,
+    error: noOp,
+    fatal: noOp,
+    info: noOp,
+    trace: noOp,
+    warn: noOp
+  };
+  try {
+    Sentry.captureException(e);
+  } catch (err) {
+  }
+}
+var logger_default = logger;
+
+// src/utilities/logForCI.ts
+var logForCI_default = (...args2) => {
+  logger_default.info({ args: args2 }, "logForCI");
+  if (import_is_ci.default || !process.stdin.isTTY) {
+    console.log(...args2);
+  }
+};
+
+// src/utilities/useExit.ts
+var import_ink = require("ink");
+
+// src/utilities/analytics.ts
+var import_os = __toESM(require("os"));
+var import_uuid = require("uuid");
+var import_analytics_node = __toESM(require("analytics-node"));
+
+// src/utilities/getEnvironmentVariables.ts
+var import_dotenv = __toESM(require("dotenv"));
+var import_path = __toESM(require("path"));
+var hasInitialized = false;
+var init = () => {
+  if (hasInitialized) {
+    return;
+  }
+  import_dotenv.default.config({
+    path: import_path.default.resolve(__dirname, "../.env")
+  });
+  hasInitialized = true;
+};
+var getEnvironmentVariables_default = () => {
+  init();
+  return process.env;
+};
+
+// src/utilities/firestore.ts
+var import_app = __toESM(require("firebase/app"));
+var import_firestore = require("firebase/firestore");
+var import_auth = require("firebase/auth");
+var environmentVariables = getEnvironmentVariables_default();
+var firebaseDB = import_app.default.initializeApp({
+  apiKey: environmentVariables.TODESKTOP_CLI_FIREBASE_API_KEY,
+  authDomain: environmentVariables.TODESKTOP_CLI_FIREBASE_AUTH_DOMAIN,
+  databaseURL: environmentVariables.TODESKTOP_CLI_FIREBASE_DATABASE_URL,
+  projectId: environmentVariables.TODESKTOP_CLI_FIREBASE_PROJECT_ID,
+  storageBucket: environmentVariables.TODESKTOP_CLI_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: environmentVariables.TODESKTOP_CLI_FIREBASE_MESSAGING_SENDER_ID,
+  appId: environmentVariables.TODESKTOP_CLI_FIREBASE_ID
+});
+var currentUser = () => import_app.default.auth().currentUser;
+var signInWithCustomToken = async (token) => {
+  return import_app.default.auth().signInWithCustomToken(token);
+};
+var onUserAuth = (handler) => import_app.default.auth().onAuthStateChanged((user) => {
+  handler(user || {});
+});
+var firestore_default = firebaseDB.firestore();
+
+// src/utilities/configStore.ts
+var fs2 = __toESM(require("fs"));
+var import_del = __toESM(require("del"));
+var import_conf = __toESM(require("conf"));
+var import_xdg_basedir = __toESM(require("xdg-basedir"));
+var config = new import_conf.default({ configName: "todesktop-cli" });
+var accessTokenConfigKey = "accessToken";
+var emailConfigKey = "email";
+var jwtTokenConfigKey = "jwtToken";
+var setConfig = (key, value) => config.set(key, value);
+var getConfig = (key) => config.get(key);
+var setAuthConfig = (email, accessToken, jwtToken) => {
+  setConfig(emailConfigKey, email);
+  setConfig(accessTokenConfigKey, accessToken);
+  setConfig(jwtTokenConfigKey, jwtToken);
+};
+var getAuthConfig = () => {
+  const accessToken = getConfig(accessTokenConfigKey);
+  const jwtToken = getConfig(jwtTokenConfigKey);
+  const email = getConfig(emailConfigKey);
+  return { accessToken, jwtToken, email };
+};
+var deleteAuthConfig = () => {
+  config.delete(emailConfigKey);
+  config.delete(accessTokenConfigKey);
+  config.delete(jwtTokenConfigKey);
+};
+var oldConfigPath = `${import_xdg_basedir.default.config}/configstore/config.json.json`;
+if (fs2.existsSync(oldConfigPath)) {
+  try {
+    const { email, accessToken, jwtToken } = require(oldConfigPath);
+    setAuthConfig(email, accessToken, jwtToken);
+    (0, import_del.default)(oldConfigPath, { force: true });
+  } catch (err) {
+    (0, import_del.default)(oldConfigPath, { force: true });
+  }
+}
+
+// src/utilities/getToDesktopPackageJson.ts
+var import_pkg_up = __toESM(require("pkg-up"));
+
+// src/utilities/readJson.ts
+function readJson(filePath) {
+  return require(filePath);
+}
+
+// src/utilities/getToDesktopPackageJson.ts
+var packageJson = readJson(
+  import_pkg_up.default.sync({ cwd: __dirname })
+);
+function getToDesktopPackageJson() {
+  return packageJson;
+}
+
+// src/utilities/getCliVersion.ts
+var cliVersion = getToDesktopPackageJson().version;
+var getCliVersion_default = () => cliVersion;
+
+// src/utilities/analytics.ts
+var environmentVariables2 = getEnvironmentVariables_default();
+var analytics = new import_analytics_node.default(environmentVariables2.SEGMENT_WRITE_KEY, {
+  flushAt: 1,
+  flushInterval: 1
+});
+var ANALYTICS_EVENT = {
+  CLI_COMMAND: "CLI Command"
+};
+function getAnalyticsBaseProperties() {
+  const baseProps = {
+    app: {
+      cliVersion: ""
+    },
+    client: "cli",
+    user: {
+      email: ""
+    },
+    os: {
+      name: "",
+      version: ""
+    },
+    runtime: {
+      name: "Node.js",
+      version: ""
+    }
+  };
+  try {
+    baseProps.os = {
+      name: import_os.default.platform(),
+      version: import_os.default.release()
+    };
+  } catch (err) {
+  }
+  try {
+    baseProps.user = {
+      email: getAuthConfig().email
+    };
+  } catch (err) {
+  }
+  try {
+    baseProps.app = {
+      cliVersion: getCliVersion_default()
+    };
+  } catch (err) {
+  }
+  try {
+    baseProps.runtime = {
+      name: "Node.js",
+      version: process.version
+    };
+  } catch (err) {
+  }
+  return baseProps;
+}
+var anonymousId = (0, import_uuid.v4)();
+var track = (event, properties = {}, callback = () => {
+}) => {
+  try {
+    const user = currentUser();
+    analytics.track(
+      {
+        event,
+        userId: user ? user.uid : void 0,
+        anonymousId,
+        properties: {
+          ...properties,
+          ...getAnalyticsBaseProperties()
+        }
+      },
+      callback
+    );
+  } catch (err) {
+  }
+};
+var identify = (id, traits = {}, callback = () => {
+}) => {
+  try {
+    analytics.identify({ userId: id, anonymousId, traits }, callback);
+  } catch (err) {
+  }
+};
+var flush = (callback = () => {
+}) => analytics.flush(callback);
+
+// src/utilities/useExit.ts
+var useExit_default = () => {
+  const { exit } = (0, import_ink.useApp)();
+  return (error = void 0) => {
+    logger_default.debug({ error }, "Exit called");
+    firestore_default.terminate().catch(
+      (e) => logger_default.error(e)
+    );
+    let timeoutId;
+    Promise.race([
+      new Promise((resolve4) => flush(() => resolve4())),
+      new Promise(
+        (resolve4) => timeoutId = setTimeout(() => resolve4(), 1e3)
+      )
+    ]).catch(() => {
+    }).finally(() => {
+      clearTimeout(timeoutId);
+      try {
+        exit();
+      } catch (e) {
+        logger_default.error(e);
+      }
+      setTimeout(() => process.exit(error ? 1 : 0), 10);
+    });
+  };
+};
+
+// src/components/BuildCompleteMessage.tsx
+var import_path2 = __toESM(require("path"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var addTrailingSlash = (url) => {
+  return url.endsWith("/") ? url : `${url}/`;
+};
+var BuildCompleteMessage = ({ build }) => {
+  const exit = useExit_default();
+  let url = build.standardUniversalDownloadUrl;
+  if (process.platform === "darwin") {
+    url = new URL(
+      import_path2.default.posix.join("mac", "zip", process.arch),
+      addTrailingSlash(url)
+    ).href;
+  }
+  logForCI_default(`Build complete! ${url}`);
+  (0, import_react.useEffect)(() => {
+    if (url) {
+      setTimeout(exit, 10);
+    }
+  }, [exit, url]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink2.Box, { marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink2.Text, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink2.Text, { bold: true, children: "Build complete!" }),
+    " ",
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink_link.default, { fallback: false, url, children: url || "" })
+  ] }) });
+};
+BuildCompleteMessage.propTypes = {
+  build: import_prop_types.default.object.isRequired
+};
+var BuildCompleteMessage_default = BuildCompleteMessage;
+
+// src/components/PlatformProgress.tsx
+var import_prop_types2 = __toESM(require("prop-types"));
+var import_ink3 = require("ink");
+var import_ink_link2 = __toESM(require("ink-link"));
+var import_path3 = __toESM(require("path"));
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var preLabelMaxWidth = "More info: ".length;
+var getProgressPercentageLabel = (percentage, activityType) => {
+  let backgroundColor = "white";
+  let color = "black";
+  if (activityType === "error") {
+    backgroundColor = "red";
+  } else if (percentage === 100) {
+    backgroundColor = "green";
+    color = "black";
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { backgroundColor, color, children: [
+      " ",
+      Math.round(percentage).toString().padStart(2, "0"),
+      "%",
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: " " })
+  ] });
+};
+var PlatformProgress = ({
+  activityName,
+  activityType,
+  downloadUrl,
+  percent,
+  platform,
+  shouldShowReadyPrefix
+}) => {
+  let progressIndicator;
+  if (activityType === "done") {
+    if (process.platform === "darwin") {
+      downloadUrl = import_path3.default.posix.join(downloadUrl, "mac", "zip", process.arch);
+    }
+    progressIndicator = /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { children: [
+        getProgressPercentageLabel(100),
+        shouldShowReadyPrefix ? "Ready!" : ""
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink_link2.default, { fallback: false, url: downloadUrl, children: downloadUrl })
+    ] });
+  } else {
+    let activityNameToDisplay = activityName.replace(
+      /(?:\r\n|\r|\n)\s*/g,
+      "\u21B5 "
+    );
+    if (activityNameToDisplay.length > 64) {
+      activityNameToDisplay = `${activityNameToDisplay.substr(0, 61)}...`;
+    }
+    progressIndicator = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { children: [
+      ["preparation", "queue"].includes(activityType) ? void 0 : getProgressPercentageLabel(percent, activityType),
+      activityNameToDisplay,
+      activityType === "error" ? "" : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Text, { children: "..." })
+    ] }) }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Box, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink3.Box, { width: preLabelMaxWidth, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink3.Text, { children: [
+      platform[0].toUpperCase() + platform.substr(1),
+      ": "
+    ] }) }),
+    progressIndicator
+  ] });
+};
+PlatformProgress.propTypes = {
+  activityName: import_prop_types2.default.string.isRequired,
+  activityType: import_prop_types2.default.string.isRequired,
+  downloadUrl: import_prop_types2.default.string,
+  percent: import_prop_types2.default.number.isRequired,
+  platform: import_prop_types2.default.string.isRequired,
+  shouldShowReadyPrefix: import_prop_types2.default.bool
+};
+var PlatformProgress_default = PlatformProgress;
+
+// src/utilities/buildStatus.ts
+var hasBuildKickedOff = (build) => {
+  if (!build) {
+    return false;
+  }
+  return build.status && build.status !== "preparation";
+};
+var isBuildCancellable = (build) => hasBuildKickedOff(build) && isBuildRunning(build);
+var isBuildRunning = (build) => {
+  if (!build) {
+    return false;
+  }
+  return !["cancelled", "succeeded"].includes(build.status) && ["linux", "mac", "windows"].some(
+    (platform) => isPlatformBuildRunning(build[platform])
+  );
+};
+var isPlatformBuildRunning = (platformBuild) => {
+  if (!platformBuild) {
+    return false;
+  }
+  return !platformBuild.shouldSkip && !["cancelled", "succeeded"].includes(platformBuild.status) && ("failed" !== platformBuild.status || platformBuild.numberOfAttemptedBuilds < 2);
+};
+
+// src/components/BuildProgress.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var logForCIThrottled = (0, import_lodash.default)(logForCI_default, 60 * 1e3, { trailing: true });
+var BuildProgress = ({ build, onBuildFailure }) => {
+  logger_default.debug("BuildProgress component: render");
+  const exit = useExit_default();
+  const [{ hasKickedOff }, setState] = (0, import_react2.useState)({
+    hasKickedOff: false
+  });
+  const platformsNotSkipped = ["windows", "mac", "linux"].filter(
+    (platform) => !build[platform].shouldSkip
+  );
+  (0, import_react2.useEffect)(() => {
+    setState((previousState) => ({
+      ...previousState,
+      hasKickedOff: hasBuildKickedOff(build)
+    }));
+  }, [build]);
+  (0, import_react2.useEffect)(() => {
+    if (build.status === "failed") {
+      onBuildFailure(build.errorMessage);
+    } else if (build.status === "cancelled") {
+      setTimeout(exit, 10);
+    } else {
+      const ciPlatformProgress = platformsNotSkipped.map(
+        (platform) => `${platform.charAt(0).toUpperCase() + platform.slice(1)}: ${build[platform].progressActivityName} (${build[platform].progressPercentage}%)`
+      );
+      logForCIThrottled(ciPlatformProgress.join(", "));
+    }
+  }, [build, exit, onBuildFailure, platformsNotSkipped]);
+  if (build.status === "succeeded") {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(BuildCompleteMessage_default, { build });
+  }
+  if (build.status === "cancelled") {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Text, { children: "Build cancelled" }) });
+  }
+  if (!hasKickedOff) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Box, { flexDirection: "column", children: platformsNotSkipped.map((platform) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink4.Box, { flexDirection: "column", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    PlatformProgress_default,
+    {
+      activityName: build[platform].status === "failed" ? build[platform].errorMessage : build[platform].progressActivityName,
+      activityType: build[platform].status === "failed" ? "error" : build[platform].progressActivityType,
+      downloadUrl: build[platform].standardDownloadUrl,
+      percent: build[platform].progressPercentage,
+      platform,
+      shouldShowReadyPrefix: !(build && ["failed", "succeeded"].includes(build.status))
+    }
+  ) }, platform)) }) });
+};
+BuildProgress.propTypes = {
+  build: import_prop_types3.default.object.isRequired,
+  onBuildFailure: import_prop_types3.default.func.isRequired
+};
+var BuildProgress_default = BuildProgress;
+
+// src/components/ErrorDisplay.tsx
+var import_ink5 = require("ink");
+var import_prop_types4 = __toESM(require("prop-types"));
+var import_react3 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var ErrorDisplay = ({ commandUsed, error }) => {
+  const exit = useExit_default();
+  logger_default.error({ error });
+  (0, import_react3.useEffect)(() => {
+    if (!error) {
+      return;
+    }
+    setTimeout(() => exit(error), 10);
+  }, [exit, error]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { backgroundColor: "red", color: "white", children: [
+      " ",
+      "ERROR",
+      " "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink5.Text, { children: error.message || error.stack || error.toString() }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Box, { flexDirection: "column", marginTop: 1, children: [
+      commandUsed ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { dimColor: true, color: "gray", children: [
+        "Command: ",
+        commandUsed
+      ] }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { dimColor: true, color: "gray", children: [
+        "@todesktop/cli: ",
+        getCliVersion_default()
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { dimColor: true, color: "gray", children: [
+        "Node: ",
+        process.version
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_ink5.Text, { dimColor: true, color: "gray", children: [
+        "cwd: ",
+        process.cwd()
+      ] })
+    ] })
+  ] });
+};
+ErrorDisplay.propTypes = {
+  commandUsed: import_prop_types4.default.string,
+  error: import_prop_types4.default.object.isRequired
+};
+var ErrorDisplay_default = ErrorDisplay;
+
+// src/components/Preparation.tsx
+var import_ink7 = require("ink");
+
+// src/components/ProgressBar.tsx
+var import_prop_types5 = __toESM(require("prop-types"));
+var import_ink_gradient = __toESM(require("ink-gradient"));
+
+// src/libs/ink-progress-bar/index.tsx
+var import_ink6 = require("ink");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var Bar = ({
+  percent = 1,
+  columns = 0,
+  left = 0,
+  right = 0,
+  character = "\u2588",
+  rightPad = false,
+  ...rest
+}) => {
+  const getString = () => {
+    const screen = columns || process.stdout.columns || 80;
+    const space = screen - right - left;
+    const max = Math.min(Math.floor(space * percent), space);
+    const chars = character.repeat(max);
+    if (!rightPad) {
+      return chars;
+    }
+    return chars + " ".repeat(space - max);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink6.Text, { ...rest, children: getString() });
+};
+var ink_progress_bar_default = Bar;
+
+// src/components/ProgressBar.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var ProgressBar = ({ left, right, percent }) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink_gradient.default, { colors: ["gray", "white"], children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(ink_progress_bar_default, { left, right, percent }) });
+ProgressBar.propTypes = {
+  left: import_prop_types5.default.number,
+  right: import_prop_types5.default.number,
+  percent: import_prop_types5.default.number.isRequired
+};
+var ProgressBar_default = ProgressBar;
+
+// src/components/Preparation.tsx
+var import_prop_types6 = __toESM(require("prop-types"));
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var Preparation = ({ progressPercentage, stageLabel, uploadedSize }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Box, { marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Text, { children: [
+      stageLabel,
+      ": "
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(ProgressBar_default, { left: 11, percent: progressPercentage }),
+      uploadedSize ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { children: uploadedSize }) : void 0
+    ] })
+  ] });
+};
+Preparation.propTypes = {
+  progressPercentage: import_prop_types6.default.number.isRequired,
+  stageLabel: import_prop_types6.default.string.isRequired,
+  uploadedSize: import_prop_types6.default.string
+};
+var Preparation_default = Preparation;
+
+// src/components/InitialLoadingState.tsx
+var import_ink8 = require("ink");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var InitialLoadingState = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { children: "Getting app info..." });
+};
+var InitialLoadingState_default = InitialLoadingState;
+
+// src/components/MainLayout.tsx
+var import_ink13 = require("ink");
+var import_is_ci3 = __toESM(require("is-ci"));
+var import_react5 = require("react");
+
+// src/components/CancelBuild.tsx
+var import_ink9 = require("ink");
+var import_react4 = require("react");
+
+// src/utilities/getCallableFirebaseFunction.ts
+var import_firebase = __toESM(require("firebase"));
+var import_functions = require("firebase/functions");
+if (getEnvironmentVariables_default().TODESKTOP_CLI_ENV === "development") {
+  import_firebase.default.functions().useFunctionsEmulator("http://localhost:5000");
+}
+var getCallableFirebaseFunction_default = (functionName) => import_firebase.default.functions().httpsCallable(functionName);
+
+// src/components/CancelBuild.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var cancelBuild = getCallableFirebaseFunction_default("cancelBuild");
+var CancelBuild = ({
+  appId,
+  children: postCancelContents,
+  commandUsed,
+  id
+}) => {
+  logger_default.debug({ appId, buildId: id }, "CancelBuild component: render");
+  const exit = useExit_default();
+  const [
+    { arbitraryMessageComponent, error, hasCompleted, hasStarted },
+    setState
+  ] = (0, import_react4.useState)({
+    arbitraryMessageComponent: null,
+    error: null,
+    hasCompleted: false,
+    hasStarted: false
+  });
+  (0, import_react4.useEffect)(() => {
+    if (hasCompleted || hasStarted) {
+      return;
+    }
+    setState((previousState) => ({ ...previousState, hasStarted: true }));
+    logForCI_default("Cancelling build...");
+    cancelBuild({ appId, buildId: id }).then((result) => {
+      logger_default.debug(
+        { appId, buildId: id, result },
+        "CancelBuild component: cancellation request complete"
+      );
+      setState((previousState) => ({ ...previousState, hasCompleted: true }));
+    }).catch((e) => {
+      logger_default.debug(
+        { appId, buildId: id, code: e.code },
+        "CancelBuild component: cancellation request failed"
+      );
+      logger_default.error(e);
+      const stateUpdates = {
+        arbitraryMessageComponent: void 0,
+        error: void 0,
+        hasCompleted: true
+      };
+      if (e.code === "internal") {
+        stateUpdates.error = e;
+      } else {
+        stateUpdates.arbitraryMessageComponent = /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Text, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Text, { color: "red", children: [
+            "Cannot cancel build (",
+            id,
+            ")."
+          ] }),
+          " ",
+          e.message
+        ] });
+      }
+      setState((prevState) => ({
+        ...prevState,
+        ...stateUpdates
+      }));
+    });
+  }, [appId, id, hasStarted, hasCompleted]);
+  (0, import_react4.useEffect)(() => {
+    if (hasCompleted && !postCancelContents) {
+      logger_default.debug(
+        "CancelBuild component: exiting now that build is cancelled"
+      );
+      exit();
+    }
+  }, [postCancelContents, exit, hasCompleted]);
+  if (error) {
+    error.message = `Failed to cancel build (${id}). ${error.message}`;
+    return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(ErrorDisplay_default, { commandUsed, error });
+  }
+  if (arbitraryMessageComponent) {
+    return arbitraryMessageComponent;
+  }
+  if (hasCompleted) {
+    return postCancelContents ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_jsx_runtime9.Fragment, { children: postCancelContents }) : /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Text, { children: "Build cancelled" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Text, { children: [
+    "Cancelling build (",
+    id,
+    ")..."
+  ] });
+};
+var CancelBuild_default = CancelBuild;
+
+// src/components/Footer.tsx
+var import_ink10 = require("ink");
+var import_ink_link3 = __toESM(require("ink-link"));
+var import_prop_types7 = __toESM(require("prop-types"));
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var Footer = ({
+  hasBuildEverFailed,
+  shouldShowCancelBuildInstructions,
+  uiUrl
+}) => {
+  if (!uiUrl) {
+    return null;
+  }
+  let buildFailedMessage;
+  if (hasBuildEverFailed) {
+    buildFailedMessage = /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { color: "red", children: "An error has occurred. " });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Text, { bold: true, children: [
+        buildFailedMessage,
+        "See web UI for more information: "
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink_link3.default, { fallback: false, url: uiUrl, children: uiUrl }) })
+    ] }),
+    shouldShowCancelBuildInstructions ? /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Text, { color: "gray", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { bold: true, children: "[esc]:" }),
+      " cancel build"
+    ] }) : null
+  ] });
+};
+Footer.propTypes = {
+  hasBuildEverFailed: import_prop_types7.default.bool,
+  shouldShowCancelBuildInstructions: import_prop_types7.default.bool,
+  uiUrl: import_prop_types7.default.string
+};
+var Footer_default = Footer;
+
+// src/components/Header.tsx
+var import_ink11 = require("ink");
+var import_prop_types8 = __toESM(require("prop-types"));
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var getText = (build, name, version) => {
+  const suffix = name + (version ? ` v${version}` : "");
+  if (build && ["cancelled", "succeeded", "failed"].includes(build.status)) {
+    if (build.status === "succeeded") {
+      return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { children: [
+        "\u2705 ",
+        suffix
+      ] });
+    } else if (build.status === "failed") {
+      return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { children: [
+        "\u274C ",
+        suffix
+      ] });
+    } else if (build.status === "cancelled") {
+      return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { bold: true, color: "gray", children: "X" }),
+        " ",
+        suffix
+      ] });
+    }
+  } else {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { children: suffix });
+  }
+};
+var Header = ({ build, name, version }) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginBottom: 1, children: getText(build, name, version) });
+Header.propTypes = {
+  build: import_prop_types8.default.object,
+  name: import_prop_types8.default.string.isRequired,
+  version: import_prop_types8.default.string
+};
+var Header_default = Header;
+
+// src/utilities/useInput.ts
+var import_is_ci2 = __toESM(require("is-ci"));
+var import_ink12 = require("ink");
+var hasSubscribed = false;
+var ctrlCSubscriptions = [];
+var onStdin = (data, exit) => {
+  let input = String(data);
+  let wasCtrlPressed = false;
+  if (input <= "" && input !== "\r") {
+    input = String.fromCharCode(input.charCodeAt(0) + "a".charCodeAt(0) - 1);
+    wasCtrlPressed = true;
+  }
+  if (wasCtrlPressed && input === "c") {
+    ctrlCSubscriptions.forEach((subscription) => subscription());
+    setTimeout(exit, 10);
+  }
+};
+var useInput_default = () => {
+  const exit = useExit_default();
+  const { stdin, isRawModeSupported } = (0, import_ink12.useStdin)();
+  if (import_is_ci2.default || !isRawModeSupported) {
+    return () => () => {
+    };
+  }
+  return (callback, useInputOptions = {}, { onCtrlCPressed = null } = {}) => {
+    const onStdinData = (data) => onStdin(data, exit);
+    if (onCtrlCPressed) {
+      ctrlCSubscriptions.push(onCtrlCPressed);
+    }
+    if (!hasSubscribed) {
+      hasSubscribed = true;
+      stdin.on("data", onStdinData);
+    }
+    const cleanUpInputHook = (0, import_ink12.useInput)(callback, useInputOptions);
+    return () => {
+      if (hasSubscribed) {
+        stdin.off("data", onStdinData);
+      }
+      cleanUpInputHook == null ? void 0 : cleanUpInputHook();
+    };
+  };
+};
+
+// src/components/MainLayout.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var MainLayout = ({
+  appId,
+  appName,
+  appVersion,
+  build,
+  children,
+  commandUsed,
+  hasBuildEverFailed
+}) => {
+  logger_default.debug("MainLayout component: render");
+  const onInput = useInput_default();
+  const { isRawModeSupported } = (0, import_ink13.useStdin)();
+  const [
+    { canCancelBuild, hasKickedOff, isCancellingBuild, wasCtrlCPressed },
+    setState
+  ] = (0, import_react5.useState)({
+    canCancelBuild: null,
+    hasKickedOff: false,
+    isCancellingBuild: false,
+    wasCtrlCPressed: false
+  });
+  (0, import_react5.useEffect)(() => {
+    setState((previousState) => ({
+      ...previousState,
+      hasKickedOff: hasBuildKickedOff(build)
+    }));
+  }, [build]);
+  (0, import_react5.useEffect)(() => {
+    setState((previousState) => ({
+      ...previousState,
+      canCancelBuild: !import_is_ci3.default && isRawModeSupported && !isCancellingBuild && isBuildCancellable(build)
+    }));
+  }, [build, isCancellingBuild]);
+  onInput(
+    async (input, key) => {
+      if (key.escape && canCancelBuild) {
+        logger_default.debug("MainLayout component: esc pressed, cancelling build");
+        setState((previousState) => ({
+          ...previousState,
+          isCancellingBuild: true
+        }));
+      }
+    },
+    {},
+    {
+      onCtrlCPressed: () => {
+        setState((previousState) => ({
+          ...previousState,
+          wasCtrlCPressed: true
+        }));
+      }
+    }
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_jsx_runtime12.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Header_default, { build, name: appName, version: appVersion }),
+    isCancellingBuild ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CancelBuild_default, { appId, commandUsed, id: build.id }) }) : children,
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+      Footer_default,
+      {
+        hasBuildEverFailed,
+        shouldShowCancelBuildInstructions: canCancelBuild && !wasCtrlCPressed,
+        uiUrl: build ? build.url : null
+      }
+    ),
+    wasCtrlCPressed && hasKickedOff ? /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_jsx_runtime12.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Box, { flexDirection: "column", marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Text, { color: "gray", children: "The build will continue in the background. To view it, run:" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink13.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink13.Text, { bold: true, color: "gray", children: [
+        "todesktop builds ",
+        build.id
+      ] }) })
+    ] }) : null
+  ] });
+};
+var MainLayout_default = MainLayout;
+
+// src/utilities/runBuild.ts
+var import_pretty_bytes = __toESM(require("pretty-bytes"));
+
+// src/utilities/getVersionControlInfo.ts
+var gitRevSync = __toESM(require("git-rev-sync"));
+var getVersionControlInfo_default = async (directory) => {
+  let result = {};
+  try {
+    const gitCommitHash = gitRevSync.long(directory);
+    if (gitCommitHash) {
+      result = {
+        branchName: gitRevSync.branch(directory),
+        commitDate: gitRevSync.date().toISOString(),
+        commitId: gitCommitHash,
+        commitMessage: gitRevSync.message(),
+        hasUncommittedChanges: gitRevSync.isDirty(),
+        repositoryRemoteUrl: gitRevSync.remoteUrl(),
+        versionControlSystemName: "git"
+      };
+    }
+  } catch (e) {
+  }
+  return result;
+};
+
+// src/utilities/projectConfig/getProjectConfig.ts
+var import_path5 = require("path");
+var import_fs = require("fs");
+var import_find_up = __toESM(require("find-up"));
+
+// src/utilities/projectConfig/loadConfig.ts
+function loadConfig(configPath) {
+  return require(configPath);
+}
+
+// src/utilities/projectConfig/resolveConfigPaths.ts
+var path5 = __toESM(require("path"));
+function resolveConfigPaths({
+  config: config2,
+  projectRoot
+}) {
+  const appRoot = config2.appPath ? path5.isAbsolute(config2.appPath) ? config2.appPath : path5.join(projectRoot, config2.appPath) : projectRoot;
+  const transformIfExists = (value, transformer) => value ? transformer(value) : void 0;
+  const resolvePath = (filePath) => path5.isAbsolute(filePath) ? filePath : path5.join(projectRoot, filePath);
+  const result = {
+    ...config2,
+    appPath: appRoot,
+    icon: resolvePath(config2.icon)
+  };
+  if (config2.extraContentFiles) {
+    result.extraContentFiles = transformIfExists(
+      config2.extraContentFiles,
+      (extraContentFiles) => extraContentFiles.map((extraContentFile) => ({
+        ...extraContentFile,
+        from: resolvePath(extraContentFile.from)
+      }))
+    );
+  }
+  if (config2.extraResources) {
+    result.extraResources = transformIfExists(
+      config2.extraResources,
+      (extraResources) => extraResources.map((extraResource) => ({
+        ...extraResource,
+        from: resolvePath(extraResource.from)
+      }))
+    );
+  }
+  if (config2.linux) {
+    result.linux = { ...config2.linux };
+    if (config2.linux.icon) {
+      result.linux.icon = resolvePath(config2.linux.icon);
+    }
+  }
+  if (config2.mac) {
+    result.mac = { ...config2.mac };
+    if (config2.mac.entitlements) {
+      result.mac.entitlements = resolvePath(config2.mac.entitlements);
+    }
+    if (config2.mac.icon) {
+      result.mac.icon = resolvePath(config2.mac.icon);
+    }
+  }
+  if (config2.dmg) {
+    if (config2.dmg.background) {
+      result.dmg.background = resolvePath(config2.dmg.background);
+    }
+  }
+  if (config2.windows) {
+    result.windows = { ...config2.windows };
+    if (config2.windows.icon) {
+      result.windows.icon = resolvePath(config2.windows.icon);
+    }
+  }
+  return result;
+}
+
+// src/utilities/projectConfig/validateConfig.ts
+var import_ajv3 = __toESM(require("ajv"));
+var import_ajv_formats2 = __toESM(require("ajv-formats"));
+var import_better_ajv_errors2 = __toESM(require("better-ajv-errors"));
+
+// src/utilities/projectConfig/addCustomKeywords.ts
+var import_ajv2 = require("ajv");
+var import_email_regex = __toESM(require("email-regex"));
+var fs3 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var import_parse_author = __toESM(require("parse-author"));
+var semver = __toESM(require("semver"));
+
+// src/utilities/projectConfig/validatePackageJSON.ts
+var import_ajv = __toESM(require("ajv"));
+var import_ajv_formats = __toESM(require("ajv-formats"));
+var import_better_ajv_errors = __toESM(require("better-ajv-errors"));
+
+// src/utilities/projectConfig/schema/packageJSON.ts
+var packageJSON_default = (context) => {
+  return {
+    type: "object",
+    required: [
+      "author",
+      "dependencies",
+      "devDependencies",
+      "homepage",
+      "name",
+      "version"
+    ],
+    properties: {
+      author: {
+        npmAuthor: {}
+      },
+      dependencies: {
+        type: "object",
+        required: ["@todesktop/runtime"],
+        excludedDependencies: {
+          dependencyKey: "dependencies",
+          blacklist: ["@todesktop/cli"]
+        },
+        properties: {
+          "@todesktop/runtime": {
+            type: "string"
+          }
+        }
+      },
+      devDependencies: {
+        type: "object",
+        required: ["electron"],
+        properties: {
+          electron: {
+            type: "string",
+            semanticVersion: {
+              packageName: "electron",
+              mustBeExact: true
+            }
+          }
+        }
+      },
+      name: {
+        type: "string",
+        minLength: 1
+      },
+      scripts: {
+        type: "object",
+        properties: {
+          "todesktop:beforeInstall": {
+            type: "string",
+            file: {
+              from: context.projectRoot,
+              mustBeFile: true
+            }
+          },
+          "todesktop:afterPack": {
+            type: "string",
+            file: {
+              from: context.projectRoot,
+              mustBeFile: true
+            }
+          }
+        }
+      },
+      version: {
+        type: "string",
+        semanticVersion: {}
+      }
+    }
+  };
+};
+
+// src/utilities/projectConfig/validatePackageJSON.ts
+var validatePackageJSON_default = (pkg, pkgPath, context) => {
+  const ajv = new import_ajv.default({ allErrors: true });
+  (0, import_ajv_formats.default)(ajv);
+  addCustomKeywords_default(ajv, context);
+  const schema = packageJSON_default(context);
+  const validate = ajv.compile(schema);
+  if (!validate(pkg)) {
+    const output = (0, import_better_ajv_errors.default)(schema, pkg, validate.errors, {
+      indent: 2
+    });
+    const error = new Error(`package.json invalid (${pkgPath}); 
+${output}`);
+    error.isValidationError = true;
+    throw error;
+  }
+};
+
+// src/utilities/projectConfig/addCustomKeywords.ts
+var addCustomKeywords_default = (ajv, context) => {
+  const addKeyword = (def) => {
+    const validate = (schema, data) => {
+      try {
+        return def.validate(schema, data);
+      } catch (e) {
+        if (e instanceof import_ajv2.ValidationError) {
+          validate.errors = e.errors;
+          return false;
+        }
+        throw e;
+      }
+    };
+    ajv.addKeyword({ ...def, validate });
+  };
+  addKeyword({
+    keyword: "excludedDependencies",
+    validate: (schema, data) => {
+      const matchingPackages = schema.blacklist.filter(
+        (packageName) => data[packageName]
+      );
+      if (matchingPackages.length) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: "Dependency",
+            message: `${matchingPackages.join(", ")} should not be in ${schema.dependencyKey}`,
+            instancePath: `/${schema.dependencyKey}`
+          }
+        ]);
+      }
+      return true;
+    }
+  });
+  addKeyword({
+    keyword: "email",
+    type: "string",
+    validate: (schema, data) => {
+      if (!(0, import_email_regex.default)({ exact: true }).test(data)) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: "email",
+            message: "invalid"
+          }
+        ]);
+      }
+      return true;
+    }
+  });
+  addKeyword({
+    keyword: "file",
+    type: "string",
+    validate: (schema, data) => {
+      const mustBeDirectory = schema.mustBeDirectory || schema.mustBeElectronApp;
+      if (!data.trim().length) {
+        if (schema.isOptional) {
+          return true;
+        }
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: schema.mustBeDirectory ? "Directory" : "File",
+            message: "is empty"
+          }
+        ]);
+      }
+      const filePath = path6.isAbsolute(data) ? data : path6.join(schema.from, data);
+      if (path6.relative(schema.from, filePath).startsWith("..")) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: mustBeDirectory ? "Directory" : "File",
+            message: `is not in project (${filePath})`
+          }
+        ]);
+      }
+      if (schema.extensions && !schema.extensions.includes(path6.extname(filePath).substr(1))) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: "File extension",
+            message: `invalid. ${path6.extname(data)} Must be${schema.extensions > 1 ? "one of the following:" : ""} "${schema.extensions.join('", "')}"`
+          }
+        ]);
+      }
+      if (!fs3.existsSync(filePath)) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: mustBeDirectory ? "Directory" : "File",
+            message: `does not exist (${filePath})`
+          }
+        ]);
+      }
+      const stats = fs3.statSync(filePath);
+      if (mustBeDirectory && stats.isFile()) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: "Directory",
+            message: `must be a directory, not a file (${filePath})`
+          }
+        ]);
+      } else if (schema.mustBeFile && stats.isDirectory()) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: "File",
+            message: `must be a file, not a directory (${filePath})`
+          }
+        ]);
+      }
+      if (schema.mustBeElectronApp) {
+        const appRoot = path6.resolve(filePath);
+        const pkgPath = path6.join(appRoot, "package.json");
+        if (!fs3.existsSync(pkgPath)) {
+          throw new import_ajv2.ValidationError([
+            {
+              keyword: "App",
+              message: `invalid. There is no package.json at ${pkgPath}`
+            }
+          ]);
+        }
+        let pkg;
+        try {
+          pkg = require(pkgPath);
+        } catch (e) {
+          throw new import_ajv2.ValidationError([
+            {
+              keyword: "App",
+              message: `invalid. Invalid JSON in package.json (${pkgPath})`
+            }
+          ]);
+        }
+        context.projectRoot = appRoot;
+        validatePackageJSON_default(pkg, pkgPath, context);
+        const mainFilePath = pkg.main;
+        if (mainFilePath) {
+          const resolvedMainFilePath = path6.join(appRoot, mainFilePath);
+          if (!fs3.existsSync(resolvedMainFilePath)) {
+            throw new import_ajv2.ValidationError([
+              {
+                keyword: "App",
+                message: `invalid. The "main" file specified in your package.json (${mainFilePath}) does not exist (${resolvedMainFilePath})`
+              }
+            ]);
+          }
+        } else {
+          if (!fs3.existsSync(path6.join(appRoot, "index.js"))) {
+            throw new import_ajv2.ValidationError([
+              {
+                keyword: "App",
+                message: 'invalid. There is neither a "main" property in your package.json nor an index.js at the root of your app'
+              }
+            ]);
+          }
+        }
+      }
+      return true;
+    },
+    errors: true
+  });
+  addKeyword({
+    keyword: "npmAuthor",
+    validate: (schema, data) => {
+      const dataType = typeof data;
+      if (dataType === "undefined") {
+        return true;
+      } else if (dataType === "string") {
+        const parsedAuthor = (0, import_parse_author.default)(data);
+        if (!parsedAuthor || !parsedAuthor.email) {
+          throw new import_ajv2.ValidationError([
+            {
+              keyword: "author",
+              message: `invalid. If you're using a string, it must look something like "Barney Rubble <b@rubble.com>", see https://docs.npmjs.com/files/package.json#people-fields-author-contributors`
+            }
+          ]);
+        }
+      } else if (dataType === "object") {
+        if (typeof data.name === "undefined") {
+          throw new import_ajv2.ValidationError([
+            {
+              keyword: "author",
+              message: `invalid. "name" property is missing.`
+            }
+          ]);
+        } else {
+          if (typeof data.name !== "string") {
+            throw new import_ajv2.ValidationError([
+              {
+                keyword: "author",
+                message: `.name invalid. It must be a string`
+              }
+            ]);
+          }
+          if (typeof data.email === "undefined") {
+            throw new import_ajv2.ValidationError([
+              {
+                keyword: "author",
+                message: `invalid. "email" property is missing.`
+              }
+            ]);
+          } else {
+            if (typeof data.email === "string") {
+              if (!(0, import_email_regex.default)({ exact: true }).test(data.email)) {
+                throw new import_ajv2.ValidationError([
+                  {
+                    keyword: "author",
+                    message: `.email invalid. It does not look like an email.`
+                  }
+                ]);
+              }
+            } else {
+              throw new import_ajv2.ValidationError([
+                {
+                  keyword: "author",
+                  message: `.email invalid. It must be a string.`
+                }
+              ]);
+            }
+          }
+        }
+      } else {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword: "author",
+            message: "invalid. It must either be an object or string. See https://docs.npmjs.com/files/package.json#people-fields-author-contributors"
+          }
+        ]);
+      }
+      return true;
+    },
+    errors: true
+  });
+  addKeyword({
+    keyword: "semanticVersion",
+    type: "string",
+    validate: (schema, data) => {
+      const keyword = (schema.packageName ? `${schema.packageName} ` : "") + "version";
+      if (!(semver.valid(data) || semver.validRange(data))) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword,
+            message: "invalid. It must be a semantic version (see https://semver.org/)"
+          }
+        ]);
+      }
+      if (schema.mustBeExact && (data.startsWith("~") || data.startsWith("^"))) {
+        throw new import_ajv2.ValidationError([
+          {
+            keyword,
+            message: "invalid. It must be an exact version. Good: 9.0.0. Bad: ^9.0.0"
+          }
+        ]);
+      }
+      return true;
+    }
+  });
+};
+
+// src/utilities/projectConfig/schema/full.ts
+var getItemOrArrayOfItemsSchema = (itemSchema) => {
+  return {
+    oneOf: [
+      itemSchema,
+      {
+        type: "array",
+        items: itemSchema
+      }
+    ]
+  };
+};
+var full_default = (context) => {
+  const getIconSchema = (additionalAllowedExtensions = []) => {
+    return {
+      type: "string",
+      file: {
+        from: context.projectRoot,
+        extensions: ["icns", "png", ...additionalAllowedExtensions],
+        mustBeFile: true
+      },
+      minLength: 3
+    };
+  };
+  return {
+    type: "object",
+    required: ["id", "icon", "schemaVersion"],
+    properties: {
+      appId: { type: "string", minLength: 1 },
+      appFiles: {
+        type: "array",
+        items: {
+          type: "string",
+          minLength: 1
+        },
+        minItems: 1
+      },
+      appProtocolScheme: { type: "string", minLength: 1 },
+      appPath: {
+        type: "string",
+        file: {
+          from: context.projectRoot,
+          isOptional: true,
+          mustBeElectronApp: true
+        }
+      },
+      asarUnpack: {
+        oneOf: [
+          { type: "boolean" },
+          {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            },
+            minItems: 1
+          }
+        ]
+      },
+      copyright: { type: "string", minLength: 1 },
+      electronMirror: {
+        type: "string",
+        format: "uri"
+      },
+      electronVersion: {
+        type: "string",
+        minLength: 1
+      },
+      extraContentFiles: {
+        type: "array",
+        items: {
+          type: "object",
+          required: ["from"],
+          properties: {
+            from: {
+              type: "string",
+              file: { from: context.projectRoot }
+            },
+            to: { type: "string" }
+          }
+        }
+      },
+      extraResources: {
+        type: "array",
+        items: {
+          type: "object",
+          required: ["from"],
+          properties: {
+            from: {
+              type: "string",
+              file: { from: context.projectRoot }
+            },
+            to: { type: "string" }
+          }
+        }
+      },
+      fileAssociations: {
+        type: "array",
+        items: {
+          type: "object",
+          required: ["ext"],
+          properties: {
+            ext: getItemOrArrayOfItemsSchema({
+              type: "string",
+              minLength: 1
+            }),
+            description: {
+              type: "string",
+              minLength: 1
+            },
+            name: {
+              type: "string",
+              minLength: 1
+            },
+            mimeType: {
+              type: "string",
+              minLength: 1
+            },
+            icon: {
+              type: "string",
+              minLength: 1
+            },
+            role: {
+              type: "string",
+              minLength: 1
+            },
+            isPackage: {
+              type: "boolean"
+            },
+            rank: {
+              type: "string",
+              minLength: 1
+            }
+          }
+        },
+        minItems: 1
+      },
+      filesForDistribution: {
+        type: "array",
+        items: {
+          type: "string",
+          minLength: 1
+        },
+        minItems: 1
+      },
+      icon: getIconSchema(),
+      linux: {
+        type: "object",
+        properties: {
+          category: { type: "string", minLength: 1 },
+          icon: getIconSchema(),
+          noSandbox: { type: "boolean" }
+        }
+      },
+      id: { type: "string", minLength: 1 },
+      mac: {
+        type: "object",
+        properties: {
+          category: { type: "string", minLength: 1 },
+          additionalBinariesToSign: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          },
+          entitlements: {
+            type: "string",
+            file: {
+              from: context.projectRoot,
+              extensions: ["plist"],
+              mustBeFile: true
+            },
+            minLength: 1
+          },
+          extendInfo: {
+            type: "object"
+          },
+          icon: getIconSchema()
+        }
+      },
+      dmg: {
+        type: "object",
+        properties: {
+          background: {
+            type: "string",
+            file: {
+              from: context.projectRoot,
+              extensions: ["tiff"],
+              mustBeFile: true
+            },
+            minLength: 1
+          },
+          artifactName: { type: "string", minLength: 1 },
+          backgroundColor: { type: "string", minLength: 1 },
+          iconSize: { type: "number" },
+          iconTextSize: { type: "number" },
+          title: { type: "string", minLength: 1 },
+          contents: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                x: { type: "number" },
+                y: { type: "number" }
+              }
+            }
+          },
+          window: {
+            type: "object",
+            properties: {
+              x: { type: "number" },
+              y: { type: "number" },
+              width: { type: "number" },
+              height: { type: "number" }
+            }
+          }
+        }
+      },
+      schemaVersion: { type: "number", minimum: 1, maximum: 1 },
+      snap: {
+        type: "object",
+        properties: {
+          after: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          },
+          appPartStage: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          },
+          assumes: getItemOrArrayOfItemsSchema({
+            type: "string",
+            minLength: 1
+          }),
+          autoStart: {
+            type: "boolean"
+          },
+          buildPackages: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          },
+          confinement: {
+            type: "string",
+            enum: ["classic", "devmode", "strict"]
+          },
+          environment: {
+            type: "object"
+          },
+          grade: {
+            type: "string",
+            enum: ["devel", "stable"]
+          },
+          layout: {
+            type: "object"
+          },
+          plugs: {
+            type: "array",
+            items: {
+              anyOf: [
+                {
+                  type: "string",
+                  minLength: 1
+                },
+                {
+                  type: "object"
+                }
+              ]
+            }
+          },
+          stagePackages: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            }
+          },
+          summary: {
+            type: "string",
+            maxLength: 78
+          },
+          useTemplateApp: {
+            type: "boolean"
+          }
+        }
+      },
+      uploadSizeLimit: {
+        type: "number"
+      },
+      windows: {
+        type: "object",
+        properties: {
+          icon: getIconSchema(["ico"])
+        }
+      }
+    }
+  };
+};
+
+// src/utilities/projectConfig/validateConfig.ts
+function validateConfig({
+  config: config2,
+  projectRoot
+}) {
+  const context = { projectRoot };
+  const schema = full_default(context);
+  const ajv = new import_ajv3.default({ allErrors: true });
+  (0, import_ajv_formats2.default)(ajv);
+  addCustomKeywords_default(ajv, context);
+  const validate = ajv.compile(schema);
+  if (!validate(config2)) {
+    const output = (0, import_better_ajv_errors2.default)(schema, config2, validate.errors, {
+      indent: 2
+    });
+    throw new Error(
+      `todesktop.json invalid. 
+Learn more here: https://www.npmjs.com/package/@todesktop/cli#project-configuration-todesktopjson 
+
+${output}`
+    );
+  }
+  if (config2.productName) {
+    throw new Error(
+      `todesktop.json invalid.
+
+The "productName" property is no longer supported in todesktop.json. Please remove it and add it to your app's package.json instead.
+
+We made this change because Electron also uses the "productName" if it exists in your app's package.json. If you do not add it to your package.json, your app name will default to the value of the "name" property in your package.json.`
+    );
+  }
+}
+
+// src/utilities/projectConfig/computeFullProjectConfig.ts
+var import_path4 = require("path");
+var import_lodash2 = __toESM(require("lodash.merge"));
+function computeFullProjectConfig(partialConfig, projectRoot) {
+  if (!partialConfig.extends) {
+    logger_default.debug("No extends field, returning partial config");
+    return partialConfig;
+  } else {
+    logger_default.debug("Extends field found, resolving");
+    const parentConfigPath = (0, import_path4.resolve)(projectRoot, partialConfig.extends);
+    const parentConfig = loadConfig(parentConfigPath);
+    const parentFullConfig = computeFullProjectConfig(
+      parentConfig,
+      projectRoot
+    );
+    const result = (0, import_lodash2.default)({}, parentFullConfig, partialConfig);
+    delete result.extends;
+    return result;
+  }
+}
+
+// src/utilities/projectConfig/getProjectConfig.ts
+function getProjectConfig(configPath = null) {
+  if (configPath === null) {
+    logger_default.debug("No config path provided, searching for one");
+    configPath = import_find_up.default.sync("todesktop.json");
+    if (!configPath) {
+      throw new Error(
+        "Can not find todesktop.json in this folder or any parent folders"
+      );
+    }
+  } else {
+    if (typeof configPath === "undefined" || configPath === "") {
+      logger_default.error("Provided config path is empty");
+      throw new Error("No config path provided");
+    }
+    configPath = (0, import_path5.resolve)(process.cwd(), configPath);
+    if (!(0, import_fs.existsSync)(configPath)) {
+      logger_default.error("Provided config path does not exist");
+      throw new Error(`Config file not found at ${configPath}`);
+    }
+  }
+  const projectRoot = (0, import_path5.dirname)(configPath);
+  const partialConfig = loadConfig(configPath);
+  partialConfig.appPath = partialConfig.appPath || ".";
+  const config2 = computeFullProjectConfig(partialConfig, projectRoot);
+  validateConfig({ config: config2, projectRoot });
+  const result = resolveConfigPaths({ config: config2, projectRoot });
+  return { config: result, unprocessedConfig: config2, projectRoot };
+}
+
+// src/utilities/postToFirebaseFunction.ts
+var import_axios = __toESM(require("axios"));
+var { TODESKTOP_CLI_FIREBASE_FUNCTIONS_BASE } = getEnvironmentVariables_default();
+async function postToFirebaseFunction_default(functionName, body = {}, config2 = {}) {
+  logger_default.debug({ functionName, body, config: config2 }, "postToFirebaseFunction");
+  try {
+    const response = await import_axios.default.post(
+      `${TODESKTOP_CLI_FIREBASE_FUNCTIONS_BASE}${functionName}`,
+      body,
+      config2
+    );
+    logger_default.debug(
+      { responseData: response.data },
+      "postToFirebaseFunction: success"
+    );
+    return response.data;
+  } catch (e) {
+    logger_default.error({ error: e }, "postToFirebaseFunction: error");
+    throw e;
+  }
+}
+
+// src/utilities/subscribeToFirebaseDoc.ts
+var subscribeToFirebaseDoc_default = async (key, receiver) => {
+  const hasResolved = false;
+  return new Promise((resolve4, reject) => {
+    logger_default.debug({ key }, "subscribeToFirebaseDoc");
+    firestore_default.doc(key).onSnapshot(
+      (snapshot) => {
+        receiver({
+          snapshot,
+          data: snapshot.exists ? snapshot.data() : void 0
+        });
+        if (!hasResolved) {
+          resolve4();
+        }
+      },
+      (err) => {
+        reject(err);
+      }
+    );
+  });
+};
+
+// src/utilities/subscribeToBuild.ts
+var subscribeToBuild_default = async ({ appId, buildId, onDataReceived, userId }) => {
+  try {
+    return await subscribeToFirebaseDoc_default(
+      `users/${userId}/applications/${appId}/builds/${buildId}`,
+      async ({ data }) => {
+        onDataReceived(data);
+      }
+    );
+  } catch (e) {
+    e.message = `Failed while subscribing to build; ${e.message}`;
+    throw e;
+  }
+};
+
+// src/utilities/uploadApplicationSource.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+var fs5 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+
+// src/utilities/generateS3Key.ts
+var generateS3Key_default = ({ appId, buildId, filenameSuffix }) => `${appId}/sourceArchives/${buildId}--${filenameSuffix}`;
+
+// src/utilities/uploadToS3.ts
+var import_superagent = __toESM(require("superagent"));
+var import_util = __toESM(require("util"));
+var import_stream_to_array = __toESM(require("stream-to-array"));
+var { TODESKTOP_CLI_S3_BUCKET } = getEnvironmentVariables_default();
+var uploadToS3_default = async ({
+  bucket = TODESKTOP_CLI_S3_BUCKET,
+  inputStream,
+  key,
+  onProgress = () => {
+  }
+}) => {
+  const { data } = await getCallableFirebaseFunction_default("getSignedURL")({
+    key
+  });
+  const body = await new Promise((resolve4) => {
+    (0, import_stream_to_array.default)(inputStream).then(function(parts) {
+      const buffers = parts.map(
+        (part) => import_util.default.isBuffer(part) ? part : Buffer.from(part)
+      );
+      return resolve4(Buffer.concat(buffers));
+    });
+  });
+  return new Promise((resolve4) => {
+    import_superagent.default.put(data.signedURL).send(body).set("content-type", "application/zip").on("progress", (event) => onProgress(event)).end(() => {
+      logger_default.debug({ bucket, key, url: data.uploadURL }, "uploadToS3");
+      resolve4({ bucket, key, url: data.uploadURL });
+    });
+    return { bucket, key, url: data.uploadURL };
+  });
+};
+
+// src/utilities/zip.ts
+var import_archiver = __toESM(require("archiver"));
+var import_du = __toESM(require("du"));
+var import_fs2 = __toESM(require("fs"));
+var import_chalk = __toESM(require("chalk"));
+var import_path6 = __toESM(require("path"));
+async function zip_default({
+  files,
+  fileSizeLimit = 20,
+  onError,
+  onProgress,
+  appPkgJson
+}) {
+  logger_default.debug({ files }, "zip");
+  const stream = (0, import_archiver.default)("zip");
+  stream.on("warning", function(err) {
+    if (err.code === "ENOENT") {
+      console.warn(err);
+      logger_default.warn({ err }, "zip: stream warning ENOENT");
+    } else {
+      onError(err);
+    }
+  });
+  stream.on("error", function(err) {
+    onError(err);
+  });
+  const processedFiles = await Promise.all(
+    files.map(async (file) => {
+      const stats = import_fs2.default.lstatSync(file.from);
+      const isDirectory = stats.isDirectory();
+      return {
+        ...file,
+        isDirectory,
+        stats,
+        size: isDirectory ? await (0, import_du.default)(file.from) : stats.size
+      };
+    })
+  );
+  const totalFileSize = processedFiles.reduce((sum, b) => sum + b.size, 0);
+  if (totalFileSize > fileSizeLimit * 1e6) {
+    onError(
+      new Error(
+        [
+          `
+
+Your app is larger than ${fileSizeLimit}MB. Your app is ${import_chalk.default.bold.red.underline(
+            (totalFileSize / 1e6).toFixed(1) + "MB"
+          )}.
+`,
+          `You may be including unnecessary files in your app(see the \`appPath\` and \`appFiles\` options).`,
+          `If not, this limit can be raised by setting the \`uploadSizeLimit\` option.`,
+          `Learn more at https://www.npmjs.com/package/@todesktop/cli#uploadsizelimit---optional-number`
+        ].join("\n")
+      )
+    );
+    return stream;
+  }
+  processedFiles.forEach(({ from, isDirectory, stats, to }) => {
+    if (isDirectory) {
+      stream.directory(from, to);
+    } else if (appPkgJson && to === import_path6.default.join("app", "package.json")) {
+      stream.append(JSON.stringify(appPkgJson), {
+        name: to
+      });
+    } else {
+      stream.file(from, { name: to, mode: stats.mode });
+    }
+  });
+  stream.finalize();
+  stream.on(
+    "progress",
+    (progress) => onProgress({
+      ...progress,
+      percentage: progress.entries.processed / progress.entries.total * 100
+    })
+  );
+  return stream;
+}
+
+// src/utilities/uploadApplicationSource.ts
+var getAppFiles = async (globsInput, appPath, appPkgJson) => {
+  const globs = ["!node_modules", "!**/node_modules", "!.git", "!**/.git"];
+  if (globsInput && globsInput.length) {
+    globs.push(
+      ...globsInput,
+      path8.join(appPath, "package.json"),
+      path8.join(appPath, "package-lock.json"),
+      path8.join(appPath, "yarn.lock"),
+      path8.join(appPath, "pnpm-lock.yaml"),
+      path8.join(appPath, "shrinkwrap.yaml")
+    );
+  } else {
+    globs.push("**");
+  }
+  for (const hookName of ["todesktop:beforeInstall", "todesktop:afterPack"]) {
+    if (appPkgJson.scripts && appPkgJson.scripts[hookName]) {
+      globs.push(path8.join(appPath, appPkgJson.scripts[hookName]));
+    }
+  }
+  const normalizedGlobs = globs.map((glob) => {
+    const globToUse = path8.isAbsolute(glob) ? path8.relative(appPath, glob) : glob;
+    return globToUse.replace(/\\/g, "/").replace(/\/+$/, "");
+  }).filter((glob) => !glob.startsWith("..") && !glob.startsWith("!.."));
+  let absolutePaths = await (0, import_fast_glob.default)(normalizedGlobs, {
+    absolute: true,
+    cwd: appPath,
+    dot: true,
+    followSymbolicLinks: false,
+    onlyDirectories: false,
+    onlyFiles: true,
+    globstar: true,
+    unique: true
+  });
+  if (process.platform === "win32") {
+    absolutePaths = absolutePaths.map(
+      (absolutePath) => absolutePath.replace(/\//g, path8.sep)
+    );
+  }
+  if (!absolutePaths || !absolutePaths.length) {
+    throw new Error("No files found to upload");
+  } else if (!absolutePaths.filter((absolutePath) => absolutePath.endsWith(".js")).length) {
+    throw new Error(
+      `No .js files found to upload (${absolutePaths[0]}). There's likely an issue with the appFiles option. Learn more at https://www.npmjs.com/package/@todesktop/cli#appfiles----optional-array-of-glob-patterns. If this is not the case, please contact us.`
+    );
+  } else {
+    let mainFilePath = appPath;
+    if (appPkgJson.main) {
+      mainFilePath = path8.join(mainFilePath, appPkgJson.main);
+    }
+    if (fs5.statSync(mainFilePath).isDirectory()) {
+      mainFilePath = path8.join(mainFilePath, "index.js");
+    }
+    if (!absolutePaths.includes(mainFilePath)) {
+      throw new Error(
+        `The "main" file specified in your package.json (${appPkgJson.main ? path8.relative(appPath, mainFilePath) : "defaults to index.js"}) is not set to be uploaded to our servers. This is likely due to how you have configured the \`appFiles\` option. Learn more at https://www.npmjs.com/package/@todesktop/cli#appfiles----optional-array-of-glob-patterns. If this is not the case, please contact us.`
+      );
+    }
+  }
+  return absolutePaths.map((absolutePath) => {
+    return {
+      from: absolutePath,
+      to: path8.join("app", path8.relative(appPath, absolutePath))
+    };
+  });
+};
+var uploadApplicationSource_default = async ({ appId, appPkgJson, buildId, config: config2, onProgress }) => {
+  logger_default.debug(
+    {
+      appId,
+      appPkgJson,
+      buildId,
+      config: config2,
+      onProgress
+    },
+    "uploadApplicationSource"
+  );
+  let totalBytes = 0;
+  const files = [
+    ...await getAppFiles(config2.appFiles, config2.appPath, appPkgJson),
+    ...(config2.extraContentFiles || []).map(({ from, to = "." }) => {
+      return {
+        from,
+        to: path8.join("extraContentFiles", to, path8.basename(from))
+      };
+    }),
+    ...(config2.extraResources || []).map(({ from, to = "." }) => {
+      return {
+        from,
+        to: path8.join("extraResources", to, path8.basename(from))
+      };
+    }),
+    {
+      from: config2.icon,
+      to: path8.join("icons", "appIcon" + path8.extname(config2.icon))
+    }
+  ];
+  if (config2.linux) {
+    if (config2.linux.icon) {
+      files.push({
+        from: config2.linux.icon,
+        to: path8.join(
+          "icons",
+          "appIcon-linux" + path8.extname(config2.linux.icon)
+        )
+      });
+    }
+  }
+  if (config2.mac) {
+    if (config2.mac.entitlements) {
+      files.push({
+        from: config2.mac.entitlements,
+        to: path8.join("other", "mac", "entitlements.mac.plist")
+      });
+    }
+    if (config2.mac.icon) {
+      files.push({
+        from: config2.mac.icon,
+        to: path8.join("icons", "appIcon-mac" + path8.extname(config2.mac.icon))
+      });
+    }
+  }
+  if (config2.dmg) {
+    if (config2.dmg.background) {
+      files.push({
+        from: config2.dmg.background,
+        to: path8.join("other", "mac", "dmg-background.tiff")
+      });
+    }
+  }
+  if (config2.windows) {
+    if (config2.windows.icon) {
+      files.push({
+        from: config2.windows.icon,
+        to: path8.join(
+          "icons",
+          "appIcon-windows" + path8.extname(config2.windows.icon)
+        )
+      });
+    }
+  }
+  return uploadToS3_default({
+    bucket: config2.bucket || void 0,
+    inputStream: await zip_default({
+      files,
+      fileSizeLimit: config2.uploadSizeLimit,
+      onError: (e) => {
+        throw e;
+      },
+      onProgress({ fs: fs6 }) {
+        totalBytes = fs6.totalBytes;
+      },
+      appPkgJson
+    }),
+    key: generateS3Key_default({
+      appId,
+      buildId,
+      filenameSuffix: `${appPkgJson.name}.zip`
+    }),
+    onProgress({ loaded, total }) {
+      onProgress(loaded / total * 100, loaded);
+    }
+  });
+};
+
+// src/utilities/getPackageJson.ts
+var import_lodash3 = __toESM(require("lodash.merge"));
+var import_path7 = __toESM(require("path"));
+function deleteNullDeps(dep) {
+  Object.keys(dep).forEach((key) => {
+    if (dep[key] === null) {
+      delete dep[key];
+    }
+  });
+  return dep;
+}
+function removeNullDependencies(pkgJson) {
+  const { dependencies, devDependencies } = pkgJson;
+  if (dependencies) {
+    pkgJson.dependencies = deleteNullDeps(dependencies);
+  }
+  if (devDependencies) {
+    pkgJson.devDependencies = deleteNullDeps(devDependencies);
+  }
+  return pkgJson;
+}
+function getAppPkgJson({ config: config2 }) {
+  const packageJsonFromConfig = config2.packageJson || {};
+  const extendsFrom = packageJsonFromConfig.extends || "package.json";
+  const packageJsonFromFile = readJson(import_path7.default.join(config2.appPath, extendsFrom));
+  return removeNullDependencies(
+    (0, import_lodash3.default)({}, packageJsonFromFile, packageJsonFromConfig)
+  );
+}
+var getPackageJson_default = getAppPkgJson;
+
+// src/utilities/runBuild.ts
+var runBuild_default = async ({ onEvent, shouldCodeSign = true, configPath }) => {
+  logForCI_default("Getting application information...");
+  const primaryUserId = currentUser().uid;
+  const { config: config2, unprocessedConfig } = getProjectConfig(configPath);
+  const appId = config2.id;
+  const appPkgJson = getPackageJson_default({ config: config2 });
+  onEvent("progress", {
+    appId,
+    appPkg: appPkgJson,
+    preparationProgress: 0.02
+  });
+  logForCI_default("Preparing...");
+  let buildId;
+  try {
+    const prepareResult = await postToFirebaseFunction_default("prepareNewBuild", {
+      appPkgName: appPkgJson.name,
+      appPkgProductName: appPkgJson.productName,
+      appVersion: appPkgJson.version,
+      id: config2.id,
+      projectConfig: unprocessedConfig,
+      shouldCodeSign: shouldCodeSign !== false,
+      shouldRelease: false,
+      userId: primaryUserId,
+      versionControlInfo: await getVersionControlInfo_default(config2.appPath)
+    });
+    buildId = prepareResult.appData.meta.currentBuildProgress.id;
+    const firebaseUnsubscribe = await subscribeToBuild_default({
+      appId,
+      buildId,
+      onDataReceived: (data) => onEvent("progress", { build: data }),
+      userId: prepareResult.userId
+    });
+    onEvent("firebase-subscribed", { firebaseUnsubscribe });
+  } catch (e) {
+    e.message = `Failed while preparing new build; ${e.message}`;
+    throw e;
+  }
+  onEvent("progress", {
+    preparationProgress: 0.05,
+    preparationStageLabel: "Uploading"
+  });
+  logForCI_default("Uploading...");
+  let sourceArchiveDetails;
+  try {
+    const uploadAppSourceResult = await uploadApplicationSource_default({
+      appId,
+      appPkgJson,
+      buildId,
+      config: config2,
+      onProgress(progress, uploadedSize) {
+        const dataToEmit = {
+          preparationProgress: 0.05 + progress / 100 * 0.95,
+          preparationUploadedSize: ""
+        };
+        if (uploadedSize) {
+          dataToEmit.preparationUploadedSize = (0, import_pretty_bytes.default)(uploadedSize);
+        }
+        onEvent("progress", dataToEmit);
+      }
+    });
+    sourceArchiveDetails = uploadAppSourceResult;
+  } catch (e) {
+    e.message = `Failed while uploading application source; ${e.message}`;
+    throw e;
+  }
+  onEvent("progress", { isPreparationComplete: true });
+  logForCI_default("Kicking off build...");
+  try {
+    await postToFirebaseFunction_default("kickOffBuild", {
+      appId,
+      appPkgName: appPkgJson.name,
+      appVersion: appPkgJson.version,
+      buildId,
+      userId: primaryUserId,
+      sourceArchiveDetails
+    });
+  } catch (e) {
+    e.message = `Failed while kicking off build; ${e.message}`;
+    throw e;
+  }
+};
+
+// src/utilities/shouldExitOnBuildFailure.ts
+var shouldExitOnBuildFailure_default = (build) => {
+  const hasBuildSettled = ["linux", "mac", "windows"].every(
+    (platform) => build[platform].shouldSkip || "succeeded" === build[platform].status || "failed" === build[platform].status && build[platform].numberOfAttemptedBuilds === 2
+  );
+  const hasSettledWithError = ["linux", "mac", "windows"].some(
+    (platform) => "failed" === build[platform].status
+  );
+  return hasBuildSettled && hasSettledWithError;
+};
+
+// src/components/Build.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var initalState = {
+  appId: null,
+  appPkg: null,
+  build: null,
+  error: null,
+  hasBuildEverFailed: false,
+  isPreparationComplete: false,
+  preparationStageLabel: "Preparing",
+  preparationProgress: 0,
+  preparationUploadedSize: null
+};
+var Build = ({ commandUsed, shouldCodeSign = true, configPath }) => {
+  const exit = useExit_default();
+  const [
+    {
+      appId,
+      appPkg,
+      build,
+      error,
+      hasBuildEverFailed,
+      isPreparationComplete,
+      preparationStageLabel,
+      preparationProgress,
+      preparationUploadedSize
+    },
+    setState
+  ] = (0, import_react6.useState)(initalState);
+  const onError = (e) => {
+    const error2 = e.response ? e.response.data : e;
+    logForCI_default(error2);
+    setState((prevState) => ({
+      ...prevState,
+      error: error2
+    }));
+  };
+  (0, import_react6.useEffect)(() => {
+    let firebaseUnsubscribe;
+    runBuild_default({
+      onEvent: (eventName, data) => {
+        logger_default.debug({ eventName, data }, "Build component: runBuild.onEvent");
+        if (eventName === "firebase-subscribed") {
+          firebaseUnsubscribe = data.firebaseUnsubscribe;
+        } else if (eventName === "progress") {
+          setState((prevState) => ({ ...prevState, ...data }));
+        }
+      },
+      shouldCodeSign,
+      configPath
+    }).catch(onError);
+    return () => {
+      if (firebaseUnsubscribe) {
+        firebaseUnsubscribe();
+      }
+    };
+  }, [commandUsed, shouldCodeSign, configPath]);
+  (0, import_react6.useEffect)(() => {
+    if (hasBuildEverFailed && shouldExitOnBuildFailure_default(build)) {
+      setTimeout(() => exit(new Error("Build has failed")), 10);
+    }
+  }, [build, exit, hasBuildEverFailed]);
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ErrorDisplay_default, { commandUsed, error });
+  }
+  if (!appPkg) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(InitialLoadingState_default, {});
+  }
+  const onBuildFailure = () => {
+    if (hasBuildEverFailed) {
+      return;
+    }
+    setState((prevState) => ({
+      ...prevState,
+      hasBuildEverFailed: true
+    }));
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    MainLayout_default,
+    {
+      appId,
+      appName: build && build.appName || appPkg.name,
+      appVersion: build && build.appVersion || appPkg.version,
+      build,
+      commandUsed,
+      hasBuildEverFailed,
+      children: isPreparationComplete ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(BuildProgress_default, { build, onBuildFailure }) : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        Preparation_default,
+        {
+          progressPercentage: preparationProgress,
+          stageLabel: preparationStageLabel,
+          uploadedSize: preparationUploadedSize
+        }
+      )
+    }
+  );
+};
+Build.propTypes = {
+  commandUsed: import_prop_types9.default.string.isRequired,
+  shouldCodeSign: import_prop_types9.default.bool,
+  configPath: import_prop_types9.default.string
+};
+var Build_default = Build;
+
+// src/utilities/checkIfReactIsUsable.ts
+var import_react7 = require("react");
+var checkIfReactIsUsable_default = ({ cons = console, proc = process } = {}) => {
+  try {
+    (0, import_react7.useState)(null);
+  } catch (e) {
+    cons.error(e);
+    proc.exit(1);
+  }
+};
+
+// src/components/LoginHOC.tsx
+var import_ink16 = require("ink");
+var import_react10 = require("react");
+var import_prop_types11 = __toESM(require("prop-types"));
+var import_is_ci4 = __toESM(require("is-ci"));
+
+// src/components/Login.tsx
+var import_ink14 = require("ink");
+var import_prop_types10 = __toESM(require("prop-types"));
+var import_react9 = require("react");
+var import_react_final_form = require("react-final-form");
+
+// src/components/TextInput.tsx
+var import_ink_text_input = __toESM(require("ink-text-input"));
+var import_react8 = __toESM(require("react"));
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var TextInput = ({ onBlur, onFocus, ...props }) => {
+  import_react8.default.useEffect(() => {
+    onFocus();
+    return onBlur;
+  }, [onFocus, onBlur]);
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink_text_input.default, { ...props, showCursor: true });
+};
+var TextInput_default = TextInput;
+
+// src/components/Login.tsx
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var loginFields = [
+  {
+    name: "email",
+    label: "Your email",
+    placeholder: "name@email.com",
+    Input: TextInput_default,
+    validate: (value) => {
+      if (!value)
+        return "Required";
+    }
+  },
+  {
+    name: "accessToken",
+    label: "Your access token",
+    placeholder: "********",
+    Input: TextInput_default,
+    validate: (value) => {
+      if (!value)
+        return "Required";
+    },
+    mask: "*"
+  }
+];
+var Login = ({ setIsLoggedIn }) => {
+  const [activeField, setActiveField] = (0, import_react9.useState)(0);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const [failureMessage, setFailureMessage] = (0, import_react9.useState)(null);
+  const [isSubmittingForm, setIsSubmittingForm] = (0, import_react9.useState)(false);
+  const onFailure = (message2) => {
+    setIsSubmittingForm(false);
+    setFailureMessage(message2);
+    setActiveField(0);
+  };
+  const onSubmitLogin = async ({ email, accessToken }) => {
+    setFailureMessage(null);
+    setIsSubmittingForm(true);
+    try {
+      const jwtToken = await postToFirebaseFunction_default("loginWithAccessToken", {
+        email,
+        accessToken
+      });
+      if (jwtToken) {
+        await signInWithCustomToken(jwtToken);
+        setAuthConfig(email, accessToken, jwtToken);
+        setIsLoggedIn(true);
+      } else {
+        onFailure("Incorrrect credentials. Try again");
+      }
+    } catch (err) {
+      if (err.code === 500) {
+        setError(err);
+      } else {
+        onFailure(`Login unsuccessful: ${err.message}`);
+      }
+    }
+  };
+  if (error)
+    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(ErrorDisplay_default, { error });
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_jsx_runtime15.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { children: "You are not currently logged in." }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { children: "Log in below:" }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { marginBottom: 1 }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_react_final_form.Form, { onSubmit: onSubmitLogin, children: ({ handleSubmit, validating }) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { flexDirection: "column", children: loginFields.map(
+      ({ name, label, placeholder, validate, Input, mask }, index) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_react_final_form.Field, { name, validate, children: ({ input, meta }) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { flexDirection: "column", children: activeField >= index ? /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Box, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { bold: activeField === index, children: [
+          label,
+          ": "
+        ] }),
+        activeField === index ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          Input,
+          {
+            ...input,
+            mask,
+            placeholder,
+            onSubmit: () => {
+              if (meta.valid && !validating) {
+                setActiveField((value) => value + 1);
+                if (activeField === loginFields.length - 1) {
+                  handleSubmit();
+                }
+              } else {
+                input.onBlur();
+              }
+            }
+          }
+        ) : input.value && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { children: name === "accessToken" ? input.value.replace(/./gi, "*") : input.value }) || placeholder && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { color: "gray", children: placeholder }),
+        meta.invalid && meta.touched && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { marginLeft: 2, marginRight: 1, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { color: "red", children: "\u2716" }) }),
+        meta.error && meta.touched && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(Error2, { errorMessage: meta.error })
+      ] }) : null }) }, name)
+    ) }) }),
+    isSubmittingForm && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { children: "Logging in..." }) }),
+    failureMessage && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(Error2, { errorMessage: failureMessage, marginTop: true })
+  ] });
+};
+var Error2 = ({ errorMessage, marginTop }) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { marginTop: marginTop ? 1 : 0, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { color: "red", children: errorMessage }) });
+Error2.propTypes = {
+  errorMessage: import_prop_types10.default.string.isRequired,
+  marginTop: import_prop_types10.default.bool
+};
+Login.propTypes = {
+  setIsLoggedIn: import_prop_types10.default.func.isRequired
+};
+var Login_default = Login;
+
+// src/components/LoadingText.tsx
+var import_ink15 = require("ink");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+var LoadingText = () => {
+  const { stdout } = (0, import_ink15.useStdout)();
+  const stdOutRedirected = !stdout.isTTY;
+  if (stdOutRedirected) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_ink15.Text, { children: "Loading..." });
+};
+var LoadingText_default = LoadingText;
+
+// src/components/LoginHOC.tsx
+var import_jsx_runtime17 = require("react/jsx-runtime");
+var LoginHOC = ({ children, isInteractive = true }) => {
+  const [isLoggedIn, setIsLoggedIn] = (0, import_react10.useState)(false);
+  const [isEffectDone, setEffectDone] = (0, import_react10.useState)(false);
+  const [error, setError] = (0, import_react10.useState)(null);
+  const { isRawModeSupported } = (0, import_ink16.useStdin)();
+  const { stdout } = (0, import_ink16.useStdout)();
+  const stdOutRedirected = !stdout.isTTY;
+  const onFailure = (message2, err = {}) => {
+    setError({
+      ...err,
+      message: message2
+    });
+  };
+  (0, import_react10.useEffect)(() => {
+    async function isAccessTokenValid() {
+      const { accessToken, email, jwtToken } = getAuthConfig();
+      let userCreds = null;
+      const { TODESKTOP_ACCESS_TOKEN, TODESKTOP_EMAIL } = getEnvironmentVariables_default();
+      try {
+        if (TODESKTOP_ACCESS_TOKEN && TODESKTOP_EMAIL) {
+          const newJwtToken = await postToFirebaseFunction_default(
+            "loginWithAccessToken",
+            {
+              email: TODESKTOP_EMAIL,
+              accessToken: TODESKTOP_ACCESS_TOKEN
+            }
+          );
+          if (newJwtToken) {
+            userCreds = await signInWithCustomToken(newJwtToken);
+            if (userCreds.user)
+              setIsLoggedIn(true);
+          }
+        } else if (!isRawModeSupported || import_is_ci4.default) {
+          onFailure(
+            "ToDesktop environment variables not found. When automating builds with your CI provider, you need to specify environment variables for TODESKTOP_EMAIL and TODESKTOP_ACCESS_TOKEN."
+          );
+        }
+      } catch (err) {
+        onFailure("Log in with environment variables failed.", err);
+      }
+      try {
+        if (!userCreds && jwtToken) {
+          userCreds = await signInWithCustomToken(jwtToken);
+          if (userCreds.user)
+            setIsLoggedIn(true);
+        }
+      } catch (err) {
+      }
+      try {
+        if (!userCreds && accessToken && email) {
+          const newJwtToken = await postToFirebaseFunction_default(
+            "loginWithAccessToken",
+            { email, accessToken }
+          );
+          if (newJwtToken) {
+            userCreds = await signInWithCustomToken(newJwtToken);
+            setAuthConfig(email, accessToken, newJwtToken);
+            if (userCreds.user)
+              setIsLoggedIn(true);
+          }
+        }
+      } catch (err) {
+      }
+      setEffectDone(true);
+    }
+    isAccessTokenValid();
+  }, []);
+  if (error && isInteractive) {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(ErrorDisplay_default, { error });
+  }
+  if (!isEffectDone) {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(LoadingText_default, {});
+  }
+  if (!isLoggedIn && isInteractive) {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Login_default, { setIsLoggedIn });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_jsx_runtime17.Fragment, { children });
+};
+LoginHOC.propTypes = {
+  children: import_prop_types11.default.object,
+  isInteractive: import_prop_types11.default.bool
+};
+var LoginHOC_default = LoginHOC;
+
+// src/components/ErrorBoundary.tsx
+var import_react11 = __toESM(require("react"));
+var Sentry2 = __toESM(require("@sentry/node"));
+var ErrorBoundary = class extends import_react11.default.Component {
+  constructor(props) {
+    super(props);
+    this.state = { eventId: null, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, errorInfo) {
+    Sentry2.withScope((scope) => {
+      scope.setExtras(errorInfo);
+      const eventId = Sentry2.captureException(error);
+      this.setState({ eventId });
+    });
+  }
+  render() {
+    if (this.state.error) {
+      throw this.state.error;
+    }
+    return this.props.children;
+  }
+};
+var ErrorBoundary_default = ErrorBoundary;
+
+// src/components/OngoingBuildGuard.tsx
+var import_ink20 = require("ink");
+var import_ink_select_input = __toESM(require("ink-select-input"));
+var import_prop_types15 = __toESM(require("prop-types"));
+var import_react13 = require("react");
+
+// src/components/CustomSelectInputIndicator.tsx
+var import_ink17 = require("ink");
+var import_prop_types12 = __toESM(require("prop-types"));
+var import_jsx_runtime18 = require("react/jsx-runtime");
+var CustomSelectInputIndicator = ({ isSelected, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Box, { marginRight: 1, ...props, children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_ink17.Text, { children: isSelected ? process.platform === "win32" ? ">" : "\u276F" : " " }) });
+CustomSelectInputIndicator.propTypes = {
+  isSelected: import_prop_types12.default.bool.isRequired
+};
+var CustomSelectInputIndicator_default = CustomSelectInputIndicator;
+
+// src/components/CustomSelectInputItem.tsx
+var import_ink18 = require("ink");
+var import_prop_types13 = __toESM(require("prop-types"));
+var import_jsx_runtime19 = require("react/jsx-runtime");
+var CustomSelectInputItem = ({ isSelected, label, ...props }) => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(import_ink18.Text, { bold: isSelected, color: isSelected ? void 0 : "gray", ...props, children: label });
+CustomSelectInputItem.propTypes = {
+  isSelected: import_prop_types13.default.bool.isRequired,
+  label: import_prop_types13.default.string.isRequired
+};
+var CustomSelectInputItem_default = CustomSelectInputItem;
+
+// src/components/ViewBuild.tsx
+var import_ink19 = require("ink");
+var import_prop_types14 = __toESM(require("prop-types"));
+var import_react12 = require("react");
+
+// src/utilities/getLatestBuildId.ts
+var getLatestBuildId_default = async ({ appId, userId }) => {
+  logger_default.debug({ appId }, "getLatestBuildId");
+  const appRef = firestore_default.doc(`users/${userId}/applications/${appId}`);
+  const appSnapshot = await appRef.get();
+  if (!appSnapshot.exists) {
+    throw new Error(`Application with ID of ${appId} doesn't exist.`);
+  }
+  const buildsResult = await appRef.collection("builds").orderBy("createdAt", "desc").limit(1).get();
+  if (buildsResult.empty) {
+    return null;
+  } else {
+    return buildsResult.docs[0].id;
+  }
+};
+
+// src/utilities/findAppUserId.ts
+var getCollection = (collectionRef) => {
+  return collectionRef.get().then((resp) => {
+    const result = [];
+    resp.forEach((doc) => result.push(doc.data()));
+    return result;
+  });
+};
+var acceptedUsersCollection = (id) => firestore_default.collection(`users/${id}/acceptedUsers`);
+var findAppUserId = async (appId) => {
+  const { uid, email } = currentUser();
+  const acceptedUsers = await getCollection(acceptedUsersCollection(uid));
+  const primaryUser = { id: uid, label: email };
+  const users = [
+    primaryUser,
+    ...acceptedUsers.map((user) => ({ id: user.id, label: user.email }))
+  ];
+  for (const user of users) {
+    try {
+      const doc = await firestore_default.doc(`users/${user.id}/applications/${appId}`).get();
+      if (doc.exists)
+        return user;
+    } catch (err) {
+    }
+  }
+  return primaryUser;
+};
+var findAppUserId_default = findAppUserId;
+
+// src/components/ViewBuild.tsx
+var import_jsx_runtime20 = require("react/jsx-runtime");
+var ViewBuild = ({ commandUsed, id, configPath }) => {
+  const exit = useExit_default();
+  const [
+    {
+      appId,
+      arbitraryMessageComponent,
+      build,
+      error,
+      hasBuildEverFailed,
+      isLoading
+    },
+    setState
+  ] = (0, import_react12.useState)({
+    appId: null,
+    arbitraryMessageComponent: null,
+    build: null,
+    error: null,
+    hasBuildEverFailed: false,
+    isLoading: true
+  });
+  const onError = (e) => {
+    const error2 = e.response ? e.response.data : e;
+    logForCI_default(error2);
+    setState((prevState) => ({
+      ...prevState,
+      error: error2
+    }));
+  };
+  (0, import_react12.useEffect)(() => {
+    let firebaseUnsubscribe;
+    async function viewBuild() {
+      let config2;
+      try {
+        config2 = getProjectConfig(configPath).config;
+      } catch (e) {
+        setState((previousState) => ({ ...previousState, error: e }));
+        return;
+      }
+      const { id: userId } = await findAppUserId_default(config2.id);
+      const subscribe = (buildId) => {
+        subscribeToBuild_default({
+          appId: config2.id,
+          buildId,
+          onDataReceived: (data) => {
+            if (!data) {
+              onError(
+                new Error(
+                  `No such build exists (${buildId}). Please contact us if this is an error`
+                )
+              );
+            }
+            setState((prevState) => ({
+              ...prevState,
+              appId: config2.id,
+              build: data,
+              isLoading: false
+            }));
+          },
+          userId
+        }).then((firebaseUnsubscribeResult) => {
+          firebaseUnsubscribe = firebaseUnsubscribeResult;
+        }).catch(onError);
+      };
+      if (id) {
+        subscribe(id);
+      } else {
+        getLatestBuildId_default({ appId: config2.id, userId }).catch(onError).then((latestBuildId) => {
+          if (!latestBuildId) {
+            setState((previousState) => ({
+              ...previousState,
+              arbitraryMessageComponent: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(import_ink19.Text, { children: "There are no builds yet" })
+            }));
+            return;
+          }
+          return subscribe(latestBuildId);
+        });
+      }
+    }
+    viewBuild();
+    return () => {
+      if (firebaseUnsubscribe) {
+        firebaseUnsubscribe();
+      }
+    };
+  }, [id]);
+  (0, import_react12.useEffect)(() => {
+    if (hasBuildEverFailed && shouldExitOnBuildFailure_default(build)) {
+      setTimeout(() => exit(new Error("Build has failed")), 10);
+    }
+  }, [build, exit, hasBuildEverFailed]);
+  (0, import_react12.useEffect)(() => {
+    if (arbitraryMessageComponent) {
+      setTimeout(() => exit(new Error("Validation failed")), 10);
+    }
+  }, [arbitraryMessageComponent, exit]);
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(ErrorDisplay_default, { commandUsed, error });
+  }
+  if (arbitraryMessageComponent) {
+    return arbitraryMessageComponent;
+  }
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(LoadingText_default, {});
+  }
+  const onBuildFailure = () => {
+    if (hasBuildEverFailed) {
+      return;
+    }
+    setState((prevState) => ({
+      ...prevState,
+      hasBuildEverFailed: true
+    }));
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+    MainLayout_default,
+    {
+      appId,
+      appName: build.appName,
+      appVersion: build.appVersion,
+      build,
+      commandUsed,
+      hasBuildEverFailed,
+      children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(BuildProgress_default, { build, onBuildFailure })
+    }
+  );
+};
+ViewBuild.propTypes = {
+  id: (props, propName, componentName) => {
+    if ([props.id, props.shouldViewLatest].filter(Boolean).length !== 1) {
+      return new Error(
+        `Exactly one of 'id' and 'shouldViewLatest' must be specified in '${componentName}'`
+      );
+    }
+    const type = typeof props.id;
+    if (!["string", "undefined"].includes(type)) {
+      return new Error(
+        `'id' is a '${type}', not a string, in '${componentName}'.`
+      );
+    }
+  },
+  commandUsed: import_prop_types14.default.string.isRequired,
+  shouldViewLatest: (props, propName, componentName) => {
+    if ([props.id, props.shouldViewLatest].filter(Boolean).length !== 1) {
+      return new Error(
+        `Exactly one of 'id' and 'shouldViewLatest' must be specified in '${componentName}'`
+      );
+    }
+    const type = typeof props.shouldViewLatest;
+    if (!["boolean", "undefined"].includes(type)) {
+      return new Error(
+        `'shouldViewLatest' is a '${type}', not a boolean, in '${componentName}'.`
+      );
+    }
+  },
+  configPath: import_prop_types14.default.string
+};
+var ViewBuild_default = ViewBuild;
+
+// src/components/OngoingBuildGuard.tsx
+var import_is_ci5 = __toESM(require("is-ci"));
+var import_jsx_runtime21 = require("react/jsx-runtime");
+var OngoingBuildGuard = ({ children, commandUsed, configPath }) => {
+  const { isRawModeSupported } = (0, import_ink20.useStdin)();
+  const onInput = useInput_default();
+  const exit = useExit_default();
+  const [{ appId, builds, error, isLoading, itemChosen }, setState] = (0, import_react13.useState)({
+    appId: null,
+    builds: [],
+    error: null,
+    isLoading: true,
+    itemChosen: null
+  });
+  (0, import_react13.useEffect)(() => {
+    if (!isLoading) {
+      return;
+    }
+    (async () => {
+      try {
+        const applicationId = getProjectConfig(configPath).config.id;
+        const { id } = await findAppUserId_default(applicationId);
+        const buildsResult = await firestore_default.doc(`users/${id}/applications/${applicationId}`).collection("builds").orderBy("createdAt", "desc").limit(10).get();
+        const stateUpdates = {
+          appId: applicationId,
+          isLoading: false,
+          builds: []
+        };
+        if (!buildsResult.empty) {
+          const latestBuild = buildsResult.docs[0].data();
+          const isRunning = isBuildRunning(latestBuild) && latestBuild.status !== "preparation";
+          logger_default.debug(
+            { isRunning },
+            "OngoingBuildGuard component: got latest build"
+          );
+          stateUpdates.builds = buildsResult.docs.map((doc) => doc.data()).filter((build) => {
+            if (isBuildRunning(build) && build.status !== "preparation") {
+              return true;
+            }
+            return false;
+          });
+        }
+        setState((previousState) => ({
+          ...previousState,
+          ...stateUpdates
+        }));
+      } catch (e) {
+        setState((previousState) => ({
+          ...previousState,
+          error: e
+        }));
+      }
+    })();
+  }, [builds, itemChosen, isLoading, isRawModeSupported]);
+  if (isRawModeSupported) {
+    onInput(() => {
+    });
+  }
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(ErrorDisplay_default, { commandUsed, error });
+  }
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { children: "..." });
+  }
+  if (itemChosen) {
+    logger_default.debug({ itemChosen }, "OngoingBuildGuard component: item chosen");
+    const build = builds.find(Boolean);
+    if (itemChosen.value === "view") {
+      return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(ViewBuild_default, { commandUsed, id: build.id });
+    } else if (itemChosen.value === "cancel") {
+      return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(CancelBuild_default, { appId, commandUsed, id: build.id, children });
+    } else if (itemChosen.value === "concurrent") {
+      return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_jsx_runtime21.Fragment, { children });
+    } else {
+      setTimeout(exit, 10);
+    }
+  }
+  if (builds.length && import_is_ci5.default === false && isRawModeSupported) {
+    const latestBuild = builds.find(Boolean);
+    const multiple = builds.length > 1;
+    const items = [
+      {
+        label: `View ${multiple ? "latest" : "it"}`,
+        value: "view"
+      }
+    ];
+    if (builds.some((build) => isBuildCancellable(build))) {
+      items.push({
+        label: `Cancel ${multiple ? "latest" : "it"} and start a new build`,
+        value: "cancel"
+      });
+      items.push({
+        label: "Start a concurrent build",
+        value: "concurrent"
+      });
+    }
+    items.push({
+      label: "Exit",
+      value: "exit"
+    });
+    const handleSelect = (itemChosen2) => setState((previousState) => ({ ...previousState, itemChosen: itemChosen2 }));
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_ink20.Box, { marginBottom: 1, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_ink20.Text, { bold: true, children: multiple ? "There are ongoing builds " : "There is an ongoing build " }),
+        /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_ink20.Text, { children: [
+          "(",
+          latestBuild.appName,
+          latestBuild.appVersion ? ` v${latestBuild.appVersion}` : "",
+          ")"
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+        import_ink_select_input.default,
+        {
+          indicatorComponent: CustomSelectInputIndicator_default,
+          itemComponent: CustomSelectInputItem_default,
+          items,
+          onSelect: handleSelect
+        }
+      )
+    ] });
+  } else {
+    return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_jsx_runtime21.Fragment, { children });
+  }
+};
+OngoingBuildGuard.propTypes = {
+  commandUsed: import_prop_types15.default.string.isRequired,
+  children: import_prop_types15.default.oneOfType([import_prop_types15.default.array, import_prop_types15.default.object]),
+  configPath: import_prop_types15.default.string
+};
+var OngoingBuildGuard_default = OngoingBuildGuard;
+
+// src/utilities/useAnalytics.ts
+var import_react14 = require("react");
+var useAnalyticsCommand = (command, flags = {}, properties = {}) => {
+  const [hasAttemptedTracking, setTrackingAttempt] = (0, import_react14.useState)(false);
+  logger_default.info({ command, flags, properties }, "useAnalyticsCommand");
+  try {
+    if (flags.projectPath) {
+      properties = {
+        ...properties,
+        ...getProjectConfig()
+      };
+    }
+  } catch (err) {
+  }
+  (0, import_react14.useEffect)(() => {
+    const authUnsubscribe = onUserAuth(async (user) => {
+      if (user.uid) {
+        identify(
+          user.uid,
+          {
+            email: user.email,
+            displayName: user.displayName
+          },
+          () => {
+            track(
+              ANALYTICS_EVENT.CLI_COMMAND,
+              {
+                ...properties,
+                flags,
+                command
+              },
+              () => setTrackingAttempt(true)
+            );
+            authUnsubscribe && authUnsubscribe();
+          }
+        );
+      }
+    });
+    setTimeout(() => setTrackingAttempt(true), 5e3);
+  }, []);
+  return { hasAttemptedTracking };
+};
+
+// src/commands/BuildCommand.tsx
+var import_jsx_runtime22 = require("react/jsx-runtime");
+var BuildCommand = ({
+  shouldCodeSign = true,
+  configPath = null
+}) => {
+  checkIfReactIsUsable_default();
+  useAnalyticsCommand("build", {
+    codeSign: shouldCodeSign,
+    config: configPath
+  });
+  const commandUsed = "todesktop build";
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(ErrorBoundary_default, { children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(LoginHOC_default, { children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(OngoingBuildGuard_default, { configPath, commandUsed, children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+    Build_default,
+    {
+      commandUsed,
+      shouldCodeSign,
+      configPath
+    }
+  ) }) }) });
+};
+var BuildCommand_default = BuildCommand;
+
+// src/components/ViewBuilds.tsx
+var import_ink26 = require("ink");
+var import_prop_types21 = __toESM(require("prop-types"));
+var import_react16 = require("react");
+
+// src/components/Table.tsx
+var import_ink24 = require("ink");
+var import_prop_types20 = __toESM(require("prop-types"));
+
+// src/components/TableEnd.tsx
+var import_ink21 = require("ink");
+var import_prop_types16 = __toESM(require("prop-types"));
+var import_jsx_runtime23 = require("react/jsx-runtime");
+var TableEnd = ({ keyDetails, ...props }) => {
+  let content = "\u2514";
+  content += Object.values(keyDetails).map(({ width }) => "\u2500".repeat(width + 2)).join("\u2534");
+  content += "\u2518";
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_ink21.Box, { ...props, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_ink21.Text, { children: content }) });
+};
+TableEnd.propTypes = {
+  keyDetails: import_prop_types16.default.object.isRequired
+};
+var TableEnd_default = TableEnd;
+
+// src/components/TableHead.tsx
+var import_ink22 = require("ink");
+var import_prop_types17 = __toESM(require("prop-types"));
+var import_react15 = require("react");
+var import_jsx_runtime24 = require("react/jsx-runtime");
+var TableHead = ({ keyDetails, ...props }) => {
+  let topLine = "\u250C";
+  topLine += Object.values(keyDetails).map(({ width }) => "\u2500".repeat(width + 2)).join("\u252C");
+  topLine += "\u2510";
+  const contentLineElements = Object.values(keyDetails).map(
+    ({ key, width }, index) => {
+      return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_react15.Fragment, { children: [
+        index > 0 ? /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Text, { children: " \u2502 " }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Box, { width, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Text, { bold: true, children: key }) })
+      ] }, key);
+    }
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_ink22.Box, { flexDirection: "column", ...props, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Text, { children: topLine }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_ink22.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Text, { children: "\u2502 " }),
+      contentLineElements,
+      /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_ink22.Text, { children: " \u2502" })
+    ] }) })
+  ] });
+};
+TableHead.propTypes = {
+  bottomLinePrefix: import_prop_types17.default.string,
+  keyDetails: import_prop_types17.default.object.isRequired
+};
+var TableHead_default = TableHead;
+
+// src/components/TableBody.tsx
+var import_prop_types19 = __toESM(require("prop-types"));
+
+// src/components/TableRow.tsx
+var import_ink23 = require("ink");
+var import_prop_types18 = __toESM(require("prop-types"));
+var import_jsx_runtime25 = require("react/jsx-runtime");
+var TableRow = ({
+  data,
+  getCellTextProps = ({ props }) => props,
+  keyDetails,
+  textProps = {}
+}) => {
+  let topLine = "\u251C";
+  topLine += Object.values(keyDetails).map(({ width }) => "\u2500".repeat(width + 2)).join("\u253C");
+  topLine += "\u2524";
+  const content = /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_jsx_runtime25.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_ink23.Text, { children: "\u2502 " }),
+    Object.entries(data).map(([key, value], index) => {
+      return /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_ink23.Box, { children: [
+        index > 0 ? /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_ink23.Text, { children: " \u2502 " }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_ink23.Box, { width: keyDetails[key].width, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+          import_ink23.Text,
+          {
+            ...getCellTextProps({
+              key,
+              props: textProps,
+              rowData: data,
+              value
+            }),
+            children: value
+          }
+        ) })
+      ] }, key);
+    }),
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_ink23.Text, { children: " \u2502" })
+  ] });
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_jsx_runtime25.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(import_ink23.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_ink23.Text, { children: topLine }),
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(import_ink23.Box, { children: content })
+  ] }) });
+};
+TableRow.propTypes = {
+  data: import_prop_types18.default.object.isRequired,
+  getCellTextProps: import_prop_types18.default.func,
+  keyDetails: import_prop_types18.default.object.isRequired,
+  textProps: import_prop_types18.default.object
+};
+var TableRow_default = TableRow;
+
+// src/components/TableBody.tsx
+var import_jsx_runtime26 = require("react/jsx-runtime");
+var TableBody = ({ data, getCellTextProps, keyDetails }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(import_jsx_runtime26.Fragment, { children: data.map((rowData, index) => /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+    TableRow_default,
+    {
+      data: rowData,
+      getCellTextProps,
+      keyDetails
+    },
+    index
+  )) });
+};
+TableBody.propTypes = {
+  data: (props, propName, componentName) => {
+    const type = typeof props.data;
+    if (Array.isArray("array")) {
+      return new Error(
+        `'data' prop must be an array ('${type}' given) in ${componentName} component`
+      );
+    }
+    if (props.data.length === 0) {
+      return new Error(
+        `'data' prop must not be empty, in ${componentName} component`
+      );
+    }
+  },
+  getCellTextProps: import_prop_types19.default.func,
+  keyDetails: import_prop_types19.default.object.isRequired
+};
+var TableBody_default = TableBody;
+
+// src/utilities/getKeyDetails.ts
+var getKeyDetails_default = (data) => {
+  const result = {};
+  Object.keys(data[0]).forEach((key) => {
+    result[key] = {
+      key,
+      width: Math.max(
+        key.length,
+        data.map((item) => item[key].toString().length).sort((a, b) => b - a)[0]
+      )
+    };
+  });
+  return result;
+};
+
+// src/components/Table.tsx
+var import_jsx_runtime27 = require("react/jsx-runtime");
+var Table = ({ data, getCellTextProps }) => {
+  const keyDetails = getKeyDetails_default(data);
+  return /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(import_ink24.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(TableHead_default, { keyDetails }),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+      TableBody_default,
+      {
+        data,
+        getCellTextProps,
+        keyDetails
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(TableEnd_default, { keyDetails })
+  ] });
+};
+Table.propTypes = {
+  data: (props, propName, componentName) => {
+    const type = typeof props.data;
+    if (Array.isArray("array")) {
+      return new Error(
+        `'data' prop must be an array ('${type}' given) in ${componentName} component`
+      );
+    }
+    if (props.data.length === 0) {
+      return new Error(
+        `'data' prop must not be empty, in ${componentName} component`
+      );
+    }
+  },
+  getCellTextProps: import_prop_types20.default.func
+};
+var Table_default = Table;
+
+// src/utilities/capitalize.ts
+var capitalize_default = (input) => {
+  if (typeof input !== "string") {
+    return "";
+  }
+  return input.charAt(0).toUpperCase() + input.slice(1);
+};
+
+// src/utilities/getBuilds.ts
+var getBuilds_default = async ({
+  addWhereClauses = (query) => query,
+  userId,
+  appId,
+  limit = 5,
+  startAfter = null
+}) => {
+  logger_default.debug({ appId, limit, startAfter }, "getBuilds");
+  const appRef = firestore_default.doc(`users/${userId}/applications/${appId}`);
+  const appSnapshot = await appRef.get();
+  if (!appSnapshot.exists) {
+    throw new Error(`Application with ID of ${appId} doesn't exist.`);
+  }
+  let query = addWhereClauses(appRef.collection("builds")).orderBy(
+    "createdAt",
+    "desc"
+  );
+  if (startAfter) {
+    query = query.startAfter(startAfter);
+  }
+  const buildsResult = await query.limit(limit).get();
+  if (buildsResult.empty) {
+    return [];
+  }
+  return buildsResult.docs.map((doc) => doc.data());
+};
+
+// src/utilities/getRelativeDateFromDateString.ts
+var dateFns = __toESM(require("date-fns"));
+var getRelativeDateFromDateString_default = (input) => dateFns.formatDistance(new Date(input), new Date()) + " ago";
+
+// src/components/SyntaxHighlight.tsx
+var import_chalk2 = __toESM(require("chalk"));
+var React3 = __toESM(require("react"));
+var import_ink25 = require("ink");
+var import_util2 = __toESM(require("util"));
+var import_jsx_runtime28 = require("react/jsx-runtime");
+var supportsColor = import_chalk2.default.stderr.supportsColor;
+var SyntaxHighlight = ({
+  object,
+  colors = supportsColor == null ? void 0 : supportsColor.hasBasic
+}) => {
+  const { stdout } = (0, import_ink25.useStdout)();
+  const highlightedCode = React3.useMemo(() => {
+    return stdout.isTTY ? import_util2.default.inspect(object, { colors, depth: 6 }) : JSON.stringify(object, null, 2);
+  }, [colors, object, stdout.isTTY]);
+  return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(import_ink25.Text, { wrap: "end", children: highlightedCode });
+};
+var SyntaxHighlight_default = SyntaxHighlight;
+
+// src/components/ViewBuilds.tsx
+var import_jsx_runtime29 = require("react/jsx-runtime");
+var ViewBuilds = ({
+  commandUsed,
+  configPath,
+  count,
+  format,
+  exit: shouldExitAfterViewingBuilds = false
+}) => {
+  const exit = useExit_default();
+  const [
+    {
+      builds,
+      error,
+      hasMoreToLoad,
+      isInitialLoadComplete,
+      isLoading,
+      projectConfig,
+      startAfter,
+      user
+    },
+    setState
+  ] = (0, import_react16.useState)({
+    builds: [],
+    error: null,
+    hasMoreToLoad: true,
+    isInitialLoadComplete: false,
+    isLoading: false,
+    projectConfig: null,
+    startAfter: null,
+    user: null
+  });
+  const onInput = useInput_default();
+  onInput((input, key) => {
+    if (key.escape) {
+      exit();
+    }
+    if (input === " " || key.downArrow || key.pageDown || key.return) {
+      if (!isInitialLoadComplete || !hasMoreToLoad) {
+        return;
+      }
+      setState((previousState) => ({
+        ...previousState,
+        startAfter: builds[builds.length - 1].createdAt
+      }));
+    }
+  });
+  (0, import_react16.useEffect)(() => {
+    async function viewBuilds() {
+      if (error || isLoading || isInitialLoadComplete && (!hasMoreToLoad || !startAfter)) {
+        return;
+      }
+      if (!["table", "json"].includes(format)) {
+        setState((previousState) => ({
+          ...previousState,
+          error: new Error(
+            `Invalid output format "${format}". Valid formats are "table" and "json".`
+          )
+        }));
+        return;
+      }
+      setState((previousState) => ({
+        ...previousState,
+        isLoading: true
+      }));
+      let config2;
+      try {
+        config2 = projectConfig || getProjectConfig(configPath).config;
+      } catch (e) {
+        setState((previousState) => ({ ...previousState, error: e }));
+        return;
+      }
+      const pageSize = count || 5;
+      const user2 = await findAppUserId_default(config2.id);
+      getBuilds_default({
+        appId: config2.id,
+        limit: pageSize + 1,
+        startAfter,
+        userId: user2.id
+      }).then((buildsResult) => {
+        setState((previousState) => {
+          const stateUpdates = {
+            builds: [],
+            hasMoreToLoad: buildsResult.length > pageSize,
+            isInitialLoadComplete: true,
+            isLoading: false,
+            projectConfig: config2,
+            startAfter: null,
+            user: user2
+          };
+          if (buildsResult.length) {
+            stateUpdates.builds = [
+              ...previousState.builds,
+              ...buildsResult.slice(0, pageSize)
+            ];
+          }
+          return {
+            ...previousState,
+            ...stateUpdates
+          };
+        });
+      }).catch((e) => {
+        logForCI_default(e);
+        setState((previousState) => ({
+          ...previousState,
+          error: e,
+          isLoading: false
+        }));
+      });
+    }
+    viewBuilds();
+  }, [
+    error,
+    hasMoreToLoad,
+    isInitialLoadComplete,
+    isLoading,
+    projectConfig,
+    startAfter
+  ]);
+  (0, import_react16.useEffect)(() => {
+    if (!hasMoreToLoad) {
+      setTimeout(exit, 10);
+    }
+  }, [exit, hasMoreToLoad]);
+  (0, import_react16.useEffect)(() => {
+    if (!isLoading && isInitialLoadComplete && shouldExitAfterViewingBuilds) {
+      setTimeout(exit, 10);
+    }
+  }, [exit, isLoading, shouldExitAfterViewingBuilds, isInitialLoadComplete]);
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(ErrorDisplay_default, { commandUsed, error });
+  }
+  if (!isInitialLoadComplete) {
+    return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(LoadingText_default, {});
+  }
+  if (builds.length) {
+    const formatData = (builds2) => builds2.map((build) => ({
+      ID: build.id,
+      Version: build.appVersion || "n/a",
+      "Creation date": getRelativeDateFromDateString_default(build.createdAt),
+      Status: capitalize_default(build.status),
+      "Release date": build.releasedAt ? getRelativeDateFromDateString_default(build.releasedAt) : "Unreleased",
+      Owner: user ? user.label : "unknown"
+    }));
+    const getCellTextProps = ({ key, props, value }) => {
+      const result = { ...props };
+      if (key === "Status") {
+        const status = value.toLowerCase();
+        if (status === "succeeded") {
+          result.color = "green";
+        } else if (status === "failed") {
+          result.color = "red";
+        } else if (status === "cancelled") {
+          result.dimColor = true;
+        }
+      } else if (key === "Version" && value.toLowerCase() === "n/a") {
+        result.dimColor = true;
+      } else if (key === "Release date" && value.toLowerCase() === "unreleased") {
+        result.dimColor = true;
+      }
+      return result;
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)(import_jsx_runtime29.Fragment, { children: [
+      format === "table" ? /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(
+        Table_default,
+        {
+          getCellTextProps,
+          data: formatData(builds)
+        }
+      ) : null,
+      format === "json" ? /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(SyntaxHighlight_default, { object: removeAppBuilderLibConfig(builds) }) : null,
+      !shouldExitAfterViewingBuilds && builds.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_ink26.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_ink26.Text, { color: "gray", dimColor: true, children: isLoading ? "Loading more..." : hasMoreToLoad ? `Showing the latest ${builds.length} builds. Press space/down to load more.` : `Showing all (${builds.length}) builds` }) }) : null
+    ] });
+  } else {
+    return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(import_ink26.Text, { children: "There are no builds yet" });
+  }
+};
+var removeAppBuilderLibConfig = (builds) => {
+  return builds.map((build) => {
+    if (build.mac && build.mac.appBuilderLibConfig) {
+      delete build.mac.appBuilderLibConfig;
+    }
+    if (build.windows && build.windows.appBuilderLibConfig) {
+      delete build.windows.appBuilderLibConfig;
+    }
+    if (build.linux && build.linux.appBuilderLibConfig) {
+      delete build.linux.appBuilderLibConfig;
+    }
+    return build;
+  });
+};
+ViewBuilds.propTypes = {
+  commandUsed: import_prop_types21.default.string.isRequired,
+  configPath: import_prop_types21.default.string,
+  count: import_prop_types21.default.number,
+  format: import_prop_types21.default.string,
+  exit: import_prop_types21.default.bool
+};
+var ViewBuilds_default = ViewBuilds;
+
+// src/commands/BuildsCommand.tsx
+var import_jsx_runtime30 = require("react/jsx-runtime");
+var BuildsCommand = ({
+  id,
+  shouldViewLatest,
+  configPath = null,
+  count,
+  format = "table",
+  exit
+}) => {
+  checkIfReactIsUsable_default();
+  useAnalyticsCommand("builds", {
+    id,
+    shouldViewLatest,
+    configPath,
+    count,
+    format,
+    exit
+  });
+  const getContents = () => {
+    let commandUsed = "todesktop builds";
+    if (id) {
+      commandUsed += " <id>";
+      return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(ViewBuild_default, { commandUsed, id, configPath });
+    } else if (shouldViewLatest) {
+      commandUsed += " --latest";
+      return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+        ViewBuild_default,
+        {
+          commandUsed,
+          shouldViewLatest: true,
+          configPath
+        }
+      );
+    } else {
+      return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+        ViewBuilds_default,
+        {
+          commandUsed,
+          configPath,
+          count,
+          format,
+          exit
+        }
+      );
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(ErrorBoundary_default, { children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(LoginHOC_default, { children: getContents() }) });
+};
+var BuildsCommand_default = BuildsCommand;
+
+// src/commands/LogoutCommand.tsx
+var import_react17 = require("react");
+var import_ink27 = require("ink");
+var import_jsx_runtime31 = require("react/jsx-runtime");
+var Logout = () => {
+  const exit = useExit_default();
+  const { hasAttemptedTracking } = useAnalyticsCommand("logout");
+  checkIfReactIsUsable_default();
+  deleteAuthConfig();
+  (0, import_react17.useEffect)(() => {
+    if (hasAttemptedTracking) {
+      exit();
+    }
+  }, [exit, hasAttemptedTracking]);
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(import_ink27.Text, { children: "Log out successful" });
+};
+var LogoutWrapper = () => {
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(ErrorBoundary_default, { children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(LoginHOC_default, { isInteractive: false, children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(Logout, {}) }) });
+};
+var LogoutCommand_default = LogoutWrapper;
+
+// src/commands/ReleaseCommand.tsx
+var import_ink31 = require("ink");
+
+// src/components/ReleaseBuild.tsx
+var import_ink28 = require("ink");
+var import_ink_link4 = __toESM(require("ink-link"));
+var import_ink_select_input2 = __toESM(require("ink-select-input"));
+var import_prop_types22 = __toESM(require("prop-types"));
+var import_react18 = require("react");
+
+// src/utilities/getBuildById.ts
+var getBuildById_default = async ({ appId, buildId, userId }) => {
+  logger_default.debug({ appId, buildId }, "getBuildById");
+  const snapshot = await firestore_default.doc(`users/${userId}/applications/${appId}/builds/${buildId}`).get();
+  if (!snapshot.exists) {
+    return null;
+  }
+  return snapshot.data();
+};
+
+// src/components/ReleaseBuild.tsx
+var import_jsx_runtime32 = require("react/jsx-runtime");
+var getValidationErrorMessageDisplay = (build, validationMessage) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_ink28.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_ink28.Text, { bold: true, color: "red", children: [
+      "Can't release ",
+      build.appName,
+      " v",
+      build.appVersion
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Box, { marginBottom: 1, marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { children: validationMessage }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { bold: true, children: "See web UI for more information: " }),
+    /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink_link4.default, { fallback: false, url: build.url, children: build.url }) })
+  ] });
+};
+var ReleaseBuild = ({ commandUsed, id, shouldConfirm, configPath }) => {
+  const exit = useExit_default();
+  const [
+    {
+      appId,
+      arbitraryMessageComponent,
+      build,
+      error,
+      hasConfirmed,
+      hasBeenValidatedSuccesfully,
+      isComplete,
+      isReleasing
+    },
+    setState
+  ] = (0, import_react18.useState)({
+    appId: null,
+    build: null,
+    error: null,
+    hasConfirmed: false,
+    hasBeenValidatedSuccesfully: false,
+    isComplete: false,
+    isReleasing: false,
+    arbitraryMessageComponent: null
+  });
+  const onError = (e) => {
+    const error2 = e.response ? e.response.data : e;
+    logForCI_default(error2);
+    setState((prevState) => ({
+      ...prevState,
+      error: error2
+    }));
+  };
+  (0, import_react18.useEffect)(() => {
+    async function releaseBuild() {
+      if (build) {
+        return;
+      }
+      const config2 = getProjectConfig(configPath).config;
+      const appId2 = config2.id;
+      const { id: userId } = await findAppUserId_default(appId2);
+      const loadBuild = (buildId) => {
+        getBuildById_default({ appId: appId2, buildId, userId }).then((buildResult) => {
+          if (!buildResult) {
+            throw new Error(
+              `No such build ${buildId} for application ${appId2}`
+            );
+          }
+          setState((previousState) => ({
+            ...previousState,
+            appId: appId2,
+            build: buildResult
+          }));
+        }).catch(onError);
+      };
+      if (id) {
+        loadBuild(id);
+      } else {
+        getLatestBuildId_default({ appId: appId2, userId }).catch(onError).then((buildId) => {
+          if (!buildId) {
+            setState((previousState) => ({
+              ...previousState,
+              arbitraryMessageComponent: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { children: "There are no builds yet" })
+            }));
+            return;
+          }
+          return loadBuild(buildId);
+        });
+      }
+    }
+    releaseBuild();
+  }, [build, id]);
+  (0, import_react18.useEffect)(() => {
+    if (!build || hasBeenValidatedSuccesfully || arbitraryMessageComponent) {
+      return;
+    }
+    let validationMessage;
+    if (build.releasedAt) {
+      validationMessage = `It has already been released.`;
+    } else if (build.status !== "succeeded") {
+      validationMessage = `The build must have completed successfully. Actual build status: ${build.status}`;
+    }
+    if (validationMessage) {
+      setState((previousState) => ({
+        ...previousState,
+        arbitraryMessageComponent: getValidationErrorMessageDisplay(
+          build,
+          validationMessage
+        ),
+        hasBeenValidatedSuccesfully: false
+      }));
+    } else {
+      setState((previousState) => ({
+        ...previousState,
+        hasBeenValidatedSuccesfully: true
+      }));
+    }
+  }, [arbitraryMessageComponent, build, hasBeenValidatedSuccesfully]);
+  (0, import_react18.useEffect)(() => {
+    if (!hasBeenValidatedSuccesfully || shouldConfirm && !hasConfirmed || isReleasing || isComplete) {
+      return;
+    }
+    setState((previousState) => ({
+      ...previousState,
+      isReleasing: true
+    }));
+    getCallableFirebaseFunction_default("releaseBuild")({
+      appId,
+      buildId: build.id
+    }).then(() => {
+      logForCI_default("Released!");
+      setState((previousState) => ({
+        ...previousState,
+        isReleasing: false,
+        isComplete: true
+      }));
+    }).catch((e) => {
+      if (["failed-precondition", "not-found"].includes(e.code)) {
+        setState((previousState) => ({
+          ...previousState,
+          arbitraryMessageComponent: getValidationErrorMessageDisplay(
+            build,
+            e.message
+          ),
+          isReleasing: false
+        }));
+      } else {
+        onError(new Error("Unexpected internal error while releasing build"));
+      }
+    });
+  }, [
+    appId,
+    build,
+    hasConfirmed,
+    hasBeenValidatedSuccesfully,
+    id,
+    isComplete,
+    isReleasing,
+    shouldConfirm
+  ]);
+  (0, import_react18.useEffect)(() => {
+    if (isComplete) {
+      setTimeout(exit, 10);
+      return;
+    }
+    if (arbitraryMessageComponent) {
+      setTimeout(() => exit(new Error("Validation failed")), 10);
+    }
+  }, [arbitraryMessageComponent, exit, isComplete]);
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(ErrorDisplay_default, { commandUsed, error });
+  }
+  if (arbitraryMessageComponent) {
+    return arbitraryMessageComponent;
+  }
+  if (hasBeenValidatedSuccesfully && shouldConfirm && !hasConfirmed) {
+    const items = [
+      {
+        label: "Yes",
+        value: "yes"
+      },
+      {
+        label: "No",
+        value: "no"
+      }
+    ];
+    const onSubmit = (item) => {
+      if (item.value === "no") {
+        setTimeout(exit, 10);
+        return;
+      }
+      setState((previousState) => ({
+        ...previousState,
+        hasConfirmed: true
+      }));
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_ink28.Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_ink28.Box, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_ink28.Text, { children: [
+          "This will release build ",
+          build.id,
+          " as "
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_ink28.Text, { bold: true, children: [
+          build.appName,
+          " v",
+          build.appVersion
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { children: ", are you sure?" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Box, { marginBottom: 1, marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
+        import_ink_select_input2.default,
+        {
+          indicatorComponent: CustomSelectInputIndicator_default,
+          initialIndex: 1,
+          itemComponent: CustomSelectInputItem_default,
+          items,
+          onSelect: onSubmit
+        }
+      ) }),
+      /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { dimColor: true, children: "Your users will be auto-updated to this version. You can use --force to bypass this confirmation in future" })
+    ] });
+  }
+  if (isReleasing) {
+    return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { children: "Releasing..." });
+  }
+  if (isComplete) {
+    return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { bold: true, color: "greenBright", children: "Released!" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(import_ink28.Text, { children: "..." });
+};
+ReleaseBuild.propTypes = {
+  id: (props, propName, componentName) => {
+    if ([props.id, props.shouldReleaseLatest].filter(Boolean).length !== 1) {
+      return new Error(
+        `Exactly one of 'id' and 'shouldReleaseLatest' must be specified in '${componentName}'`
+      );
+    }
+    const type = typeof props.id;
+    if (!["string", "undefined"].includes(type)) {
+      return new Error(
+        `'id' is a '${type}', not a string, in '${componentName}'.`
+      );
+    }
+  },
+  commandUsed: import_prop_types22.default.string.isRequired,
+  shouldReleaseLatest: (props, propName, componentName) => {
+    if ([props.id, props.shouldReleaseLatest].filter(Boolean).length !== 1) {
+      return new Error(
+        `Exactly one of 'id' and 'shouldReleaseLatest' must be specified in '${componentName}'`
+      );
+    }
+    const type = typeof props.shouldReleaseLatest;
+    if (!["boolean", "undefined"].includes(type)) {
+      return new Error(
+        `'shouldReleaseLatest' is a '${type}', not a boolean, in '${componentName}'.`
+      );
+    }
+  },
+  shouldConfirm: import_prop_types22.default.bool.isRequired,
+  configPath: import_prop_types22.default.string
+};
+var ReleaseBuild_default = ReleaseBuild;
+
+// src/components/PickBuildForRelease.tsx
+var import_ink30 = require("ink");
+var import_prop_types24 = __toESM(require("prop-types"));
+var import_react19 = require("react");
+
+// src/components/SelectTable.tsx
+var import_ink29 = require("ink");
+var import_ink_select_input3 = __toESM(require("ink-select-input"));
+var import_prop_types23 = __toESM(require("prop-types"));
+var import_jsx_runtime33 = require("react/jsx-runtime");
+var CustomIndicator = (props) => /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(CustomSelectInputIndicator_default, { marginTop: 1, ...props });
+var SelectTable = ({ data, onSelect }) => {
+  const keyDetails = getKeyDetails_default(data);
+  const getSelectItems = () => {
+    return data.map((rowData, index) => {
+      return {
+        index,
+        key: index,
+        value: rowData
+      };
+    });
+  };
+  const ItemComponent = ({
+    label,
+    index,
+    isSelected
+  }) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
+      TableRow_default,
+      {
+        data: data[index],
+        keyDetails,
+        textProps: { bold: isSelected, color: isSelected ? void 0 : "gray" }
+      },
+      index
+    );
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime33.jsxs)(import_ink29.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(TableHead_default, { keyDetails, marginLeft: 2 }),
+    /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
+      import_ink_select_input3.default,
+      {
+        indicatorComponent: CustomIndicator,
+        itemComponent: ItemComponent,
+        items: getSelectItems(),
+        onSelect
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(TableEnd_default, { keyDetails, marginLeft: 2 })
+  ] });
+};
+SelectTable.propTypes = {
+  data: (props, propName, componentName) => {
+    const type = typeof props.data;
+    if (Array.isArray("array")) {
+      return new Error(
+        `'data' prop must be an array ('${type}' given) in ${componentName} component`
+      );
+    }
+    if (props.data.length === 0) {
+      return new Error(
+        `'data' prop must not be empty, in ${componentName} component`
+      );
+    }
+  },
+  onSelect: import_prop_types23.default.func
+};
+var SelectTable_default = SelectTable;
+
+// src/components/PickBuildForRelease.tsx
+var import_jsx_runtime34 = require("react/jsx-runtime");
+var PickBuildForRelease = ({ commandUsed, shouldConfirm, configPath }) => {
+  const exit = useExit_default();
+  const [{ error, builds, chosenBuildId, isLoading, user }, setState] = (0, import_react19.useState)({
+    error: null,
+    builds: null,
+    chosenBuildId: null,
+    isLoading: true,
+    user: null
+  });
+  const onInput = useInput_default();
+  (0, import_react19.useEffect)(() => {
+    async function pickBuildForRelease() {
+      if (builds) {
+        return;
+      }
+      let config2;
+      try {
+        config2 = getProjectConfig(configPath).config;
+      } catch (e) {
+        setState((previousState) => ({ ...previousState, error: e }));
+        return;
+      }
+      const user2 = await findAppUserId_default(config2.id);
+      getBuilds_default({
+        addWhereClauses: (query) => query.where("status", "==", "succeeded"),
+        appId: config2.id,
+        limit: 50,
+        userId: user2.id
+      }).then((buildsResult) => {
+        setState((previousState) => ({
+          ...previousState,
+          user: user2,
+          builds: buildsResult.filter((buildResult) => !buildResult.releasedAt).slice(0, 5),
+          isLoading: false
+        }));
+      }).catch((e) => {
+        logForCI_default(e);
+        setState((previousState) => ({
+          ...previousState,
+          error: e,
+          isLoading: false
+        }));
+      });
+    }
+    pickBuildForRelease();
+  }, [builds]);
+  onInput((input, key) => {
+    if (!builds || !builds.length || chosenBuildId) {
+      return;
+    }
+    if (key.escape) {
+      exit();
+    }
+  });
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(ErrorDisplay_default, { commandUsed, error });
+  }
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(LoadingText_default, {});
+  }
+  if (chosenBuildId) {
+    return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
+      ReleaseBuild_default,
+      {
+        commandUsed,
+        id: chosenBuildId,
+        shouldConfirm
+      }
+    );
+  }
+  if (builds.length) {
+    const data = builds.map((build) => ({
+      ID: build.id,
+      Version: build.appVersion || "unknown",
+      "Creation date": getRelativeDateFromDateString_default(build.createdAt),
+      Owner: user ? user.label : "unknown"
+    }));
+    const onSelect = (item) => setState((previousState) => ({
+      ...previousState,
+      chosenBuildId: item.value.ID
+    }));
+    return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(import_jsx_runtime34.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(import_ink30.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(import_ink30.Text, { children: "Which build would you like to release?" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(SelectTable_default, { data, onSelect }),
+      /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(import_ink30.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(import_ink30.Text, { dimColor: true, children: [
+        "Showing the latest ",
+        builds.length,
+        " unreleased successful builds"
+      ] }) })
+    ] });
+  } else {
+    return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(import_ink30.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(import_ink30.Text, { children: "No elligible builds found " }),
+      /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(import_ink30.Text, { dimColor: true, children: "(i.e. unreleased and successful)" })
+    ] });
+  }
+};
+PickBuildForRelease.propTypes = {
+  commandUsed: import_prop_types24.default.string.isRequired,
+  shouldConfirm: import_prop_types24.default.bool.isRequired,
+  configPath: import_prop_types24.default.string
+};
+var PickBuildForRelease_default = PickBuildForRelease;
+
+// src/commands/ReleaseCommand.tsx
+var import_jsx_runtime35 = require("react/jsx-runtime");
+var ReleaseCommand = ({
+  id,
+  force,
+  shouldReleaseLatest,
+  configPath
+}) => {
+  checkIfReactIsUsable_default();
+  useAnalyticsCommand("release", {
+    id,
+    force,
+    shouldReleaseLatest,
+    config: configPath
+  });
+  if (id && id.startsWith(".")) {
+    return /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(import_jsx_runtime35.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime35.jsxs)(import_ink31.Box, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_ink31.Text, { bold: true, color: "red", children: "todesktop release <project-path>" }),
+        /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_ink31.Text, { children: " is no longer supported. Run this instead:" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(import_ink31.Text, { bold: true, color: "greenBright", children: "todesktop build && todesktop release --latest --force" })
+    ] });
+  }
+  const getContents = () => {
+    if (id) {
+      return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+        ReleaseBuild_default,
+        {
+          configPath,
+          commandUsed: "todesktop release <id>",
+          id,
+          shouldConfirm: !force
+        }
+      );
+    } else if (shouldReleaseLatest) {
+      return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+        ReleaseBuild_default,
+        {
+          configPath,
+          commandUsed: "todesktop release --latest",
+          shouldReleaseLatest: true,
+          shouldConfirm: !force
+        }
+      );
+    } else {
+      return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
+        PickBuildForRelease_default,
+        {
+          configPath,
+          commandUsed: "todesktop builds",
+          shouldConfirm: !force
+        }
+      );
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(ErrorBoundary_default, { children: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(LoginHOC_default, { children: getContents() }) });
+};
+var ReleaseCommand_default = ReleaseCommand;
+
+// src/commands/WhoamiCommand.tsx
+var import_react20 = require("react");
+var import_ink32 = require("ink");
+var import_jsx_runtime36 = require("react/jsx-runtime");
+var WhoAmI = () => {
+  const exit = useExit_default();
+  checkIfReactIsUsable_default();
+  const auth = getAuthConfig();
+  const { hasAttemptedTracking } = useAnalyticsCommand("whoami", {}, {});
+  (0, import_react20.useEffect)(() => {
+    if (hasAttemptedTracking) {
+      exit();
+    }
+  }, [exit, hasAttemptedTracking]);
+  if (!auth || !auth.email) {
+    return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(import_ink32.Text, { children: "You're not signed in" });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(import_ink32.Text, { children: auth.email });
+};
+var WhoAmIWrapper = () => /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ErrorBoundary_default, { children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(LoginHOC_default, { isInteractive: false, children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(WhoAmI, {}) }) });
+var WhoamiCommand_default = WhoAmIWrapper;
+
+// src/utilities/exitIfCLIOutOfDate.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_is_installed_globally = __toESM(require("is-installed-globally"));
+var import_latest_version = __toESM(require("latest-version"));
+var import_semver = __toESM(require("semver"));
+var exitIfCLIOutOfDate_default = () => {
+  if (process.env.AVA_PATH) {
+    return;
+  }
+  const pkg = getToDesktopPackageJson();
+  (0, import_latest_version.default)(pkg.name).then((latest) => {
+    if (import_semver.default.gt(latest, pkg.version)) {
+      const commandToUpdate = import_chalk3.default.greenBright(
+        `npm install ${import_is_installed_globally.default ? "--location=global" : "--save-dev"} @todesktop/cli`
+      );
+      console.log(
+        `Your version of @todesktop/cli is out of date.
+Run ${commandToUpdate} to update to v${latest}.`
+      );
+      if (!import_semver.default.satisfies(latest, `^${pkg.version}`)) {
+        console.log(`CLI is exiting because it is out out of date.`);
+        process.exit(1);
+      }
+    }
+  });
+};
+
+// src/utilities/initSentry.ts
+var Sentry3 = __toESM(require("@sentry/node"));
+var import_os2 = __toESM(require("os"));
+
+// package.json
+var package_default = {
+  private: false,
+  publishConfig: {
+    access: "public"
+  },
+  name: "@todesktop/cli",
+  version: "1.6.0",
+  license: "MIT",
+  author: "Dave Jeffery <dave@todesktop.com> (http://www.todesktop.com/)",
+  homepage: "https://todesktop.com/cli",
+  bugs: {
+    email: "dave@todesktop.com"
+  },
+  bin: {
+    todesktop: "./dist/cli.js"
+  },
+  engines: {
+    node: ">=12"
+  },
+  scripts: {
+    dev: "cp-cli dev.env .env && npm run build:dev && npm link",
+    "dev:prod": "cp-cli prod.env .env && npm run build && npm link",
+    build: "esbuild src/index.ts --packages=external --bundle --sourcemap --platform=node --outfile=dist/cli.js && cp-cli prod.env .env",
+    "build:dev": "esbuild src/index.ts --packages=external --bundle --sourcemap --platform=node --outfile=dist/cli.js && cp-cli prod.env .env",
+    lint: "npm run lint:types && npm run lint:styles",
+    "lint:styles": "eslint src test .eslintrc.js",
+    "lint:types": "tsc",
+    "lint--fix": "eslint src test --fix",
+    release: "npm run build && npx np --tag=latest",
+    "release-beta": "npm run build && npx np --any-branch --no-tests --tag=beta",
+    test: "ava",
+    "test--watch": "npm test -- --watch"
+  },
+  files: [
+    "dist",
+    "docs",
+    ".env",
+    "LICENSE",
+    "README.md"
+  ],
+  dependencies: {
+    "@sentry/node": "^5.27.2",
+    ajv: "^8.11.2",
+    "ajv-formats": "^2.1.1",
+    "analytics-node": "^4.0.1",
+    archiver: "^5.2.0",
+    axios: "^0.21.1",
+    "better-ajv-errors": "^1.2.0",
+    bunyan: "^1.8.14",
+    chalk: "^4.1.0",
+    commander: "^9.4.1",
+    conf: "^7.1.2",
+    "date-fns": "^2.28.0",
+    del: "^6.0.0",
+    dotenv: "^8.2.0",
+    du: "^1.0.0",
+    "email-regex": "^4.0.0",
+    "fast-glob": "^3.2.4",
+    "final-form": "^4.20.1",
+    "find-up": "^5.0.0",
+    firebase: "^7.24.0",
+    "git-rev-sync": "^3.0.2",
+    ink: "^3.2.0",
+    "ink-gradient": "^2.0.0",
+    "ink-link": "^2.0.0",
+    "ink-select-input": "^4.2.1",
+    "ink-text-input": "^4.0.1",
+    "is-ci": "^3.0.1",
+    "is-installed-globally": "^0.3.2",
+    "latest-version": "^5.1.0",
+    "lodash.merge": "^4.6.2",
+    "lodash.throttle": "^4.1.1",
+    "parse-author": "^2.0.0",
+    "pkg-up": "^3.1.0",
+    "pretty-bytes": "^5.4.1",
+    "prop-types": "^15.7.2",
+    react: "^17.0.2",
+    "react-final-form": "^6.5.1",
+    semver: "^7.3.2",
+    "source-map-support": "^0.5.21",
+    "stream-to-array": "^2.3.0",
+    superagent: "^7.1.3",
+    uuid: "^8.3.1",
+    "xdg-basedir": "^4.0.0"
+  },
+  devDependencies: {
+    "@todesktop/shared": "^7.147.0",
+    "@types/bunyan": "^1.8.6",
+    "@types/react": "^18.0.26",
+    "@typescript-eslint/eslint-plugin": "^5.46.1",
+    "@typescript-eslint/parser": "^5.46.1",
+    ava: "^4.3.1",
+    "cp-cli": "^2.0.0",
+    esbuild: "^0.16.5",
+    "esbuild-register": "^3.4.1",
+    eslint: "^8.29.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-react": "^7.31.11",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-standard": "^4.1.0",
+    execa: "^4.0.3",
+    "extract-zip": "^2.0.1",
+    "fs-extra": "^9.0.1",
+    husky: "^4.3.0",
+    "lint-staged": "^10.2.11",
+    prettier: "^2.8.1",
+    proxyquire: "^2.1.3",
+    sinon: "^9.0.3",
+    typescript: "^4.9.4"
+  },
+  ava: {
+    extensions: [
+      "ts"
+    ],
+    files: [
+      "test/**/*.ts",
+      "!test/fixtures/**/*",
+      "!test/utilities/**/*"
+    ],
+    require: [
+      "esbuild-register"
+    ],
+    timeout: "10m"
+  },
+  "lint-staged": {
+    "**/*.{js,ts,tsx}": [
+      "eslint src --fix",
+      "git add"
+    ]
+  },
+  husky: {
+    hooks: {
+      "pre-commit": "lint-staged"
+    }
+  },
+  overrides: {
+    pastel: {
+      "parcel-bundler": {
+        deasync: "0.1.27"
+      }
+    }
+  },
+  resolutions: {
+    "pastel/parcel-bundler/deasync": "0.1.24",
+    ink: "3.2.0",
+    react: "17.0.2"
+  },
+  packageExtensions: {
+    "ink-progress-bar@*": {
+      dependencies: {
+        react: "*",
+        ink: "*"
+      }
+    }
+  }
+};
+
+// src/utilities/initSentry.ts
+var initSentry_default = () => {
+  const { TODESKTOP_CLI_SENTRY_DSN } = getEnvironmentVariables_default();
+  if (!TODESKTOP_CLI_SENTRY_DSN) {
+    return;
+  }
+  Sentry3.init({
+    dsn: TODESKTOP_CLI_SENTRY_DSN
+  });
+  Sentry3.configureScope((scope) => {
+    try {
+      scope.setUser({ email: getAuthConfig().email });
+    } catch (err) {
+    }
+    try {
+      scope.setContext("os", {
+        name: import_os2.default.platform(),
+        version: import_os2.default.release()
+      });
+    } catch (err) {
+    }
+    try {
+      scope.setContext("runtime", {
+        name: "Node.js",
+        version: process.version
+      });
+    } catch (err) {
+    }
+    try {
+      scope.setContext("app", {
+        app_name: package_default.name,
+        app_version: package_default.version
+      });
+    } catch (err) {
+    }
+    try {
+      const configResult = getProjectConfig();
+      scope.setExtra("config", configResult);
+    } catch (err) {
+    }
+  });
+};
+
+// src/utilities/onCommand.ts
+var onCommand_default = ({ sentry = true, exitIfOutOfDate = true } = {}) => {
+  if (sentry) {
+    initSentry_default();
+  }
+  if (exitIfOutOfDate) {
+    exitIfCLIOutOfDate_default();
+  }
+};
+
+// src/index.ts
+var parseCount = (value) => {
+  const parsedValue = Number.parseInt(value, 10);
+  if (parsedValue > 0) {
+    return parsedValue;
+  }
+  throw new import_commander.InvalidArgumentError("Should be a positive number");
+};
+import_commander.program.name("todekstop").version(getCliVersion_default());
+import_commander.program.command("build").description(
+  "Build an Electron app with native installers, code signing baked-in, etc. but without releasing it (existing users won't get an auto-update). For quicker builds, you can append `--code-sign=false` to disablecode-signing and notarization."
+).option(
+  "--code-sign [bool]",
+  "Whether or not code-signing and notarization should be performed. Disable this for quicker builds"
+).option(
+  "--config [string]",
+  "Path to a different configuration file. If not specified, `todesktop.json` in the project root will be used"
+).action(({ codeSign, config: config2 }) => {
+  runCommand(BuildCommand_default, {
+    shouldCodeSign: codeSign,
+    configPath: config2
+  });
+});
+import_commander.program.command("builds").description("View your builds").argument("[id]", "View a specific build by ID").option("--latest", "View the latest build").option(
+  "--config [string]",
+  "Path to a different configuration file. If not specified, `todesktop.json` in the project root will be used"
+).option("--count [number]", "Number of builds to show per page", parseCount).addOption(
+  new import_commander.Option("--format <type>", "Format to output the build details in").choices(["json", "table"]).default("table")
+).option("--exit", "View the latest build").action((id, { config: config2, count, exit, format, latest }) => {
+  runCommand(BuildsCommand_default, {
+    configPath: config2,
+    count,
+    exit,
+    format,
+    id,
+    shouldViewLatest: latest
+  });
+});
+import_commander.program.command("logout").description("Logs you out").action(() => {
+  runCommand(LogoutCommand_default, null, { exitIfOutOfDate: false });
+});
+import_commander.program.command("release").description("Release a build").argument("[id]", "A specific build ID to release").option("--force", "Skips interactive confirmation step").option("--latest", "Release the latest build").option(
+  "--config [string]",
+  "Path to a different configuration file. If not specified, `todesktop.json` in the project root will be used"
+).action((id, { config: config2, force, latest }) => {
+  runCommand(ReleaseCommand_default, {
+    configPath: config2,
+    force,
+    id,
+    shouldReleaseLatest: latest
+  });
+});
+import_commander.program.command("whoami").description("Prints the email of the account you're signed into").action(() => {
+  runCommand(WhoamiCommand_default);
+});
+var runCommand = (component, props = null, { exitIfOutOfDate = true } = {}) => {
+  onCommand_default({ exitIfOutOfDate });
+  const { waitUntilExit } = (0, import_ink33.render)((0, import_react21.createElement)(component, props));
+  waitUntilExit().catch((error) => {
+    console.error(error.stack);
+  });
+};
+var args = [...process.argv];
+if (args.length === 2) {
+  args.push("help");
+}
+import_commander.program.parse(args);
+//# sourceMappingURL=cli.js.map