@todesktop/cli 1.15.1 → 1.17.0

package/dist/cli.js

@@ -192,12 +192,14 @@ var firebaseApp = (0, import_app.initializeApp)({
 });
 var auth = (0, import_auth.getAuth)(firebaseApp);
 var db = (0, import_firestore.getFirestore)(firebaseApp);
-var currentUser = () => auth.currentUser;
+var currentUser = () => {
+  return auth.currentUser;
+};
 var signInWithCustomToken = async (token) => {
   return (0, import_auth.signInWithCustomToken)(auth, token);
 };
 var onUserAuth = (handler) => (0, import_auth.onAuthStateChanged)(auth, (user) => {
-  handler(user || {});
+  handler(user != null ? user : {});
 });
 var firestore_default = db;
 
@@ -322,7 +324,7 @@ var track = (event, properties = {}, callback = () => {
     analytics.track(
       {
         event,
-        userId: user ? user.uid : void 0,
+        userId: user == null ? void 0 : user.uid,
         anonymousId,
         properties: {
           ...properties,
@@ -1062,8 +1064,8 @@ function loadTypeScriptConfig(configPath) {
         );
       }
     }
-    const fs6 = require("fs");
-    const sourceCode = fs6.readFileSync(configPath, "utf8");
+    const fs7 = require("fs");
+    const sourceCode = fs7.readFileSync(configPath, "utf8");
     const result = typescript.transpile(sourceCode, {
       target: typescript.ScriptTarget.ES2018,
       module: typescript.ModuleKind.CommonJS,
@@ -1643,6 +1645,20 @@ var schema_default = {
     appFiles: { $ref: "#/definitions/appFilesProperty" },
     appProtocolScheme: { $ref: "#/definitions/appProtocolSchemeProperty" },
     appPath: { $ref: "#/definitions/appPathProperty" },
+    bundleWorkspacePackages: {
+      type: "object",
+      additionalProperties: false,
+      description: "Useful when your application is a monorepo (e.g. pnpm workspaces). You can configure whether the CLI bundles workspace packages alongside the app upload. When enabled, workspace dependencies referenced via `workspace:` or local `file:` specifiers are bundled with your application upload and dependency ranges are rewritten to `file:` paths so they install deterministically on the build servers.",
+      examples: ['{"enabled":true}'],
+      default: { enabled: false },
+      properties: {
+        enabled: {
+          type: "boolean",
+          default: false,
+          description: "Enable automatic bundling of workspace packages for this project."
+        }
+      }
+    },
     asar: { $ref: "#/definitions/asarProperty" },
     asarUnpack: { $ref: "#/definitions/asarUnpackProperty" },
     buildVersion: { $ref: "#/definitions/buildVersionProperty" },
@@ -2705,6 +2721,19 @@ var getVersionControlInfo_default = async (directory) => {
 // src/commands/build/utilities/spyBuild.ts
 var import_events = __toESM(require("events"));
 var import_firestore3 = require("firebase/firestore");
+
+// src/utilities/firestoreData.ts
+var readQueryDocument = (doc9) => {
+  return doc9.data();
+};
+var readDocumentSnapshot = (snapshot) => {
+  return snapshot.exists() ? snapshot.data() : void 0;
+};
+var readQuerySnapshot = (snapshot) => {
+  return snapshot.docs.map((doc9) => readQueryDocument(doc9));
+};
+
+// src/commands/build/utilities/spyBuild.ts
 function spyBuild() {
   const emitter = new import_events.default();
   let unsubscribeSnapshot;
@@ -2734,7 +2763,7 @@ function spyBuild() {
       unsubscribeSnapshot = (0, import_firestore3.onSnapshot)(
         (0, import_firestore3.doc)(firestore_default, buildPath),
         (snapshot) => {
-          latestBuildDoc = snapshot.exists() ? snapshot.data() : void 0;
+          latestBuildDoc = readDocumentSnapshot(snapshot);
           emitter.emit("update", {
             build: latestBuildDoc,
             snapshot
@@ -2771,9 +2800,9 @@ function buildHasSettled(build) {
 }
 
 // src/commands/build/utilities/uploadApplicationSource.ts
-var import_fast_glob = __toESM(require("fast-glob"));
-var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var import_fast_glob2 = __toESM(require("fast-glob"));
+var fs6 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 
 // src/commands/build/utilities/generateS3Key.ts
 var generateS3Key_default = ({ appId, buildId, filenameSuffix }) => `${appId}/sourceArchives/${buildId}--${filenameSuffix}`;
@@ -2859,13 +2888,29 @@ async function zip_default({
   });
   const processedFiles = await Promise.all(
     files.map(async (file) => {
+      if (file.content !== void 0 && file.content !== null) {
+        const buffer = Buffer.isBuffer(file.content) ? file.content : Buffer.from(file.content);
+        return {
+          ...file,
+          contentBuffer: buffer,
+          isDirectory: false,
+          size: buffer.length,
+          virtual: true
+        };
+      }
+      if (!file.from) {
+        throw new Error(
+          `Zip entry for ${file.to} must provide either a source path or in-memory content.`
+        );
+      }
       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
+        size: isDirectory ? await (0, import_du.default)(file.from) : stats.size,
+        virtual: false
       };
     })
   );
@@ -2888,15 +2933,21 @@ Your app is larger than ${fileSizeLimit}MB. Your app is ${import_chalk.default.b
     );
     return stream;
   }
-  processedFiles.forEach(({ from, isDirectory, stats, to }) => {
-    if (isDirectory) {
+  processedFiles.forEach((entry) => {
+    const { from, isDirectory, stats, to, virtual, contentBuffer, mode } = entry;
+    if (virtual) {
+      stream.append(contentBuffer, {
+        name: to,
+        mode: mode != null ? mode : 420
+      });
+    } else if (isDirectory) {
       stream.directory(from, to);
     } else if (appPkgJson && to === import_path7.default.join("app", "package.json")) {
       stream.append(JSON.stringify(appPkgJson), {
         name: to
       });
     } else {
-      stream.file(from, { name: to, mode: stats.mode });
+      stream.file(from, { name: to, mode: mode != null ? mode : stats.mode });
     }
   });
   stream.finalize();
@@ -2910,6 +2961,533 @@ Your app is larger than ${fileSizeLimit}MB. Your app is ${import_chalk.default.b
   return stream;
 }
 
+// src/commands/build/utilities/workspace/index.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_fs3 = __toESM(require("fs"));
+var import_path8 = __toESM(require("path"));
+var import_js_yaml = __toESM(require("js-yaml"));
+var BUNDLED_ROOT = "bundledPackages";
+var DEFAULT_IGNORE_GLOBS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/.hg/**",
+  "**/.svn/**",
+  "**/.DS_Store",
+  "**/npm-debug.log",
+  "**/yarn-error.log"
+];
+async function prepareWorkspaceBundle(input) {
+  var _a;
+  const { config: config2, appPkgJson, appPath } = input;
+  if (!((_a = config2.bundleWorkspacePackages) == null ? void 0 : _a.enabled)) {
+    return {
+      appPackageJson: appPkgJson,
+      entries: [],
+      shouldBundle: false
+    };
+  }
+  const workspace = findWorkspaceDefinition(appPath, appPkgJson);
+  if (!workspace) {
+    throw new Error(
+      "Bundle workspace packages is enabled but no workspace root could be found."
+    );
+  }
+  if (workspace.warning) {
+    logger_default.warn(workspace.warning);
+  }
+  const workspacePackages = collectWorkspacePackages(workspace);
+  const bundledPackageNames = determineBundleClosure({
+    appPath,
+    appPkgJson,
+    workspace,
+    workspacePackages
+  });
+  if (!bundledPackageNames.size) {
+    logger_default.info("No workspace packages matched bundle criteria.");
+    return {
+      appPackageJson: appPkgJson,
+      entries: [],
+      shouldBundle: false
+    };
+  }
+  const bundleEntries = [];
+  const appRewriteMap = {};
+  const bundledPackageContexts = /* @__PURE__ */ new Map();
+  const sortedPackageNames = Array.from(bundledPackageNames).sort();
+  for (const packageName of sortedPackageNames) {
+    const pkg = workspacePackages.get(packageName);
+    if (!pkg) {
+      throw new Error(
+        `Workspace package "${packageName}" referenced for bundling but not found in workspace map.`
+      );
+    }
+    const bundlePath = getBundlePath(packageName);
+    bundledPackageContexts.set(packageName, { bundlePath, packageName });
+    appRewriteMap[packageName] = `file:../${import_path8.default.posix.join(
+      BUNDLED_ROOT,
+      bundlePath
+    )}`;
+    const packageEntries = await buildPackageEntries({
+      bundlePath,
+      workspacePackage: pkg,
+      bundledNames: bundledPackageNames,
+      contexts: bundledPackageContexts
+    });
+    bundleEntries.push(...packageEntries.files);
+    bundleEntries.push(packageEntries.packageJsonEntry);
+  }
+  const rewrittenAppPkgJson = applyRewriteMap(appPkgJson, appRewriteMap);
+  logger_default.info(
+    `Bundling ${sortedPackageNames.length} workspace package(s) from ${workspace.type} workspace at ${workspace.rootDir}`
+  );
+  logger_default.info(`Bundled packages: ${sortedPackageNames.join(", ")}`);
+  return {
+    appPackageJson: rewrittenAppPkgJson,
+    entries: bundleEntries,
+    shouldBundle: true
+  };
+}
+function findWorkspaceDefinition(appPath, appPkgJson) {
+  const appDir = import_path8.default.resolve(appPath);
+  let currentDir = appDir;
+  let previousDir = "";
+  const pnpmPreference = detectPnpmPreference(appPkgJson);
+  while (currentDir !== previousDir) {
+    const pnpmFile = import_path8.default.join(currentDir, "pnpm-workspace.yaml");
+    const packageJsonPath = import_path8.default.join(currentDir, "package.json");
+    const hasPnpm = import_fs3.default.existsSync(pnpmFile);
+    const packageJson2 = readPackageJsonIfExists(packageJsonPath);
+    const npmWorkspaces = getNpmWorkspaces(packageJson2);
+    if (hasPnpm || npmWorkspaces.length) {
+      const pnpmDefinition = hasPnpm ? createPnpmDefinition({ pnpmFile, rootDir: currentDir }) : void 0;
+      const npmDefinition = npmWorkspaces.length ? createNpmDefinition({ globs: npmWorkspaces, rootDir: currentDir }) : void 0;
+      const chosen = chooseWorkspaceDefinition({
+        pnpmPreference,
+        pnpmDefinition,
+        npmDefinition
+      });
+      if (chosen) {
+        const includesApp = workspaceIncludesPath({
+          appDir,
+          globs: chosen.globs,
+          rootDir: chosen.rootDir
+        });
+        if (includesApp) {
+          return chosen;
+        }
+      }
+    }
+    previousDir = currentDir;
+    currentDir = import_path8.default.dirname(currentDir);
+  }
+  return void 0;
+}
+function detectPnpmPreference(appPkgJson) {
+  const pkgManager = appPkgJson.packageManager;
+  if (typeof pkgManager !== "string") {
+    return false;
+  }
+  return pkgManager.startsWith("pnpm@");
+}
+function readPackageJsonIfExists(filePath) {
+  if (!import_fs3.default.existsSync(filePath)) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(import_fs3.default.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`Unable to parse package.json at ${filePath}: ${error}`);
+  }
+}
+function getNpmWorkspaces(packageJson2) {
+  if (!packageJson2) {
+    return [];
+  }
+  const { workspaces } = packageJson2;
+  if (!workspaces) {
+    return [];
+  }
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter(
+      (value) => typeof value === "string"
+    );
+  }
+  if (typeof workspaces === "object" && Array.isArray(workspaces.packages)) {
+    return workspaces.packages.filter(
+      (value) => typeof value === "string"
+    );
+  }
+  return [];
+}
+function createPnpmDefinition({
+  pnpmFile,
+  rootDir
+}) {
+  const packages = parsePnpmWorkspaceFile(pnpmFile);
+  if (!packages.length) {
+    throw new Error(
+      `pnpm workspace file at ${pnpmFile} does not define any packages.`
+    );
+  }
+  return {
+    globs: packages,
+    rootDir,
+    realRootDir: import_fs3.default.realpathSync(rootDir),
+    type: "pnpm"
+  };
+}
+function createNpmDefinition({
+  globs,
+  rootDir
+}) {
+  return {
+    globs,
+    rootDir,
+    realRootDir: import_fs3.default.realpathSync(rootDir),
+    type: "npm"
+  };
+}
+function chooseWorkspaceDefinition({
+  pnpmPreference,
+  pnpmDefinition,
+  npmDefinition
+}) {
+  if (pnpmDefinition && npmDefinition) {
+    const warning = "Both pnpm-workspace.yaml and package.json workspaces detected; defaulting to pnpm.";
+    if (pnpmPreference) {
+      return pnpmDefinition;
+    }
+    return { ...pnpmDefinition, warning };
+  }
+  return pnpmDefinition || npmDefinition;
+}
+function parsePnpmWorkspaceFile(filePath) {
+  const content = import_fs3.default.readFileSync(filePath, "utf8");
+  const parsed = import_js_yaml.default.load(content);
+  let packagesField;
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    packagesField = parsed.packages;
+  } else {
+    packagesField = parsed;
+  }
+  if (!Array.isArray(packagesField)) {
+    throw new Error(
+      `pnpm workspace file at ${filePath} does not define any packages.`
+    );
+  }
+  const packages = packagesField.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => Boolean(value));
+  if (!packages.length) {
+    throw new Error(
+      `pnpm workspace file at ${filePath} does not define any packages.`
+    );
+  }
+  return packages;
+}
+function workspaceIncludesPath({
+  appDir,
+  globs,
+  rootDir
+}) {
+  const target = import_path8.default.resolve(appDir);
+  const matches = import_fast_glob.default.sync(globs, {
+    absolute: true,
+    cwd: rootDir,
+    onlyDirectories: true,
+    followSymbolicLinks: false,
+    ignore: ["**/node_modules/**"]
+  });
+  return matches.some((dir) => import_path8.default.resolve(dir) === target);
+}
+function collectWorkspacePackages(definition) {
+  const { globs, rootDir } = definition;
+  const directories = import_fast_glob.default.sync(globs, {
+    absolute: true,
+    cwd: rootDir,
+    onlyDirectories: true,
+    followSymbolicLinks: false,
+    ignore: ["**/node_modules/**"]
+  });
+  const packages = /* @__PURE__ */ new Map();
+  for (const dir of directories) {
+    const packageJsonPath = import_path8.default.join(dir, "package.json");
+    if (!import_fs3.default.existsSync(packageJsonPath)) {
+      continue;
+    }
+    const manifest = readPackageJsonIfExists(packageJsonPath);
+    if (!manifest || !manifest.name) {
+      continue;
+    }
+    const name = manifest.name;
+    if (packages.has(name)) {
+      const existing = packages.get(name);
+      throw new Error(
+        `Duplicate workspace package name "${name}" found at ${existing == null ? void 0 : existing.dir} and ${dir}`
+      );
+    }
+    const absoluteDir = import_path8.default.resolve(dir);
+    const pkg = {
+      dir: absoluteDir,
+      manifest,
+      name,
+      realDir: import_fs3.default.realpathSync(absoluteDir)
+    };
+    packages.set(name, pkg);
+  }
+  return packages;
+}
+function determineBundleClosure({
+  appPath,
+  appPkgJson,
+  workspace,
+  workspacePackages
+}) {
+  const bundled = /* @__PURE__ */ new Set();
+  const queue = [];
+  collectDependencyReferences({
+    manifest: appPkgJson,
+    packageDir: appPath,
+    queue,
+    workspace,
+    workspacePackages,
+    sourceName: "app"
+  });
+  while (queue.length) {
+    const ref = queue.shift();
+    if (!ref) {
+      continue;
+    }
+    const targetPackage = workspacePackages.get(ref.name);
+    if (!targetPackage) {
+      throw new Error(
+        `Dependency "${ref.name}" referenced via ${ref.section} is not part of the workspace.`
+      );
+    }
+    if (bundled.has(targetPackage.name)) {
+      continue;
+    }
+    bundled.add(targetPackage.name);
+    collectDependencyReferences({
+      manifest: targetPackage.manifest,
+      packageDir: targetPackage.dir,
+      queue,
+      workspace,
+      workspacePackages,
+      sourceName: targetPackage.name
+    });
+  }
+  return bundled;
+}
+function collectDependencyReferences({
+  manifest,
+  packageDir,
+  queue,
+  workspace,
+  workspacePackages,
+  sourceName
+}) {
+  const sections = [
+    "dependencies",
+    "optionalDependencies",
+    "devDependencies"
+  ];
+  for (const section of sections) {
+    const deps = manifest[section];
+    if (!deps)
+      continue;
+    for (const [depName, spec] of Object.entries(deps)) {
+      if (typeof spec !== "string")
+        continue;
+      const target = resolveWorkspaceTarget({
+        depName,
+        packageDir,
+        spec,
+        workspace,
+        workspacePackages,
+        sourceName
+      });
+      if (target) {
+        queue.push({ name: target, spec, section });
+      }
+    }
+  }
+}
+function resolveWorkspaceTarget({
+  depName,
+  packageDir,
+  spec,
+  workspace,
+  workspacePackages,
+  sourceName
+}) {
+  if (spec.startsWith("workspace:")) {
+    if (!workspacePackages.has(depName)) {
+      throw new Error(
+        `Workspace dependency "${depName}" referenced by ${sourceName} is not declared in workspace globs.`
+      );
+    }
+    return depName;
+  }
+  if (spec.startsWith("file:")) {
+    const targetPath = spec.slice("file:".length);
+    const resolved = import_path8.default.resolve(packageDir, targetPath);
+    const targetRealPath = import_fs3.default.realpathSync(resolved);
+    const relativeToRoot = import_path8.default.relative(workspace.realRootDir, targetRealPath);
+    if (relativeToRoot.startsWith("..") || import_path8.default.isAbsolute(relativeToRoot)) {
+      throw new Error(
+        `Dependency "${depName}" from ${sourceName} resolves outside of workspace root via spec ${spec}.`
+      );
+    }
+    for (const pkg of workspacePackages.values()) {
+      if (pkg.realDir === targetRealPath) {
+        return pkg.name;
+      }
+    }
+    throw new Error(
+      `Dependency "${depName}" from ${sourceName} points to ${resolved}, which is not a known workspace package.`
+    );
+  }
+  return void 0;
+}
+function getBundlePath(packageName) {
+  if (packageName.startsWith("@")) {
+    const [scope, ...rest] = packageName.split("/");
+    return [scope, rest.join("/")].filter(Boolean).join("/");
+  }
+  return packageName;
+}
+function applyRewriteMap(manifest, rewriteMap) {
+  const clone = JSON.parse(JSON.stringify(manifest));
+  const sections = [
+    "dependencies",
+    "optionalDependencies",
+    "devDependencies"
+  ];
+  for (const section of sections) {
+    const sectionDeps = clone[section];
+    if (!sectionDeps)
+      continue;
+    for (const [depName, rewrite] of Object.entries(rewriteMap)) {
+      if (sectionDeps[depName]) {
+        sectionDeps[depName] = rewrite;
+      }
+    }
+  }
+  return clone;
+}
+async function buildPackageEntries({
+  bundlePath,
+  workspacePackage,
+  bundledNames,
+  contexts
+}) {
+  const packageDir = workspacePackage.dir;
+  const manifest = workspacePackage.manifest;
+  const filesToInclude = await gatherPackageFiles({ packageDir, manifest });
+  const files = filesToInclude.map((absolutePath) => {
+    const relative3 = import_path8.default.relative(packageDir, absolutePath);
+    const posixRelative = toPosix(import_path8.default.join(bundlePath, relative3));
+    return {
+      from: absolutePath,
+      to: import_path8.default.posix.join(BUNDLED_ROOT, posixRelative)
+    };
+  });
+  const rewrites = buildRewriteMapForPackage({
+    bundlePath,
+    manifest,
+    bundledNames,
+    contexts
+  });
+  const packageJsonEntry = {
+    content: Buffer.from(
+      `${JSON.stringify(applyRewriteMap(manifest, rewrites), null, 2)}
+`
+    ),
+    to: import_path8.default.posix.join(BUNDLED_ROOT, bundlePath, "package.json")
+  };
+  return { files, packageJsonEntry };
+}
+async function gatherPackageFiles({
+  packageDir,
+  manifest
+}) {
+  const declaredPatterns = Array.isArray(manifest.files) ? manifest.files : ["**/*"];
+  const normalizedPatterns = declaredPatterns.flatMap((pattern) => {
+    if (pattern.includes("*")) {
+      return [pattern];
+    }
+    const absoluteCandidate = import_path8.default.join(packageDir, pattern);
+    try {
+      const stats = import_fs3.default.statSync(absoluteCandidate);
+      if (stats.isDirectory()) {
+        const posixPattern = pattern.replace(/\\/g, "/");
+        return [pattern, `${posixPattern}/**/*`];
+      }
+    } catch (error) {
+    }
+    return [pattern];
+  });
+  const matchedFiles = await (0, import_fast_glob.default)(normalizedPatterns, {
+    absolute: true,
+    cwd: packageDir,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: DEFAULT_IGNORE_GLOBS
+  });
+  const extras = [
+    "README",
+    "README.md",
+    "README.txt",
+    "LICENSE",
+    "LICENCE",
+    "NOTICE",
+    "CHANGELOG",
+    "CHANGELOG.md"
+  ];
+  for (const extra of extras) {
+    const extraPath = import_path8.default.join(packageDir, extra);
+    if (import_fs3.default.existsSync(extraPath) && import_fs3.default.statSync(extraPath).isFile()) {
+      matchedFiles.push(extraPath);
+    }
+  }
+  const uniqueFiles = Array.from(new Set(matchedFiles));
+  return uniqueFiles.filter((filePath) => !filePath.endsWith("package.json"));
+}
+function buildRewriteMapForPackage({
+  bundlePath,
+  manifest,
+  bundledNames,
+  contexts
+}) {
+  var _a, _b;
+  const rewriteMap = {};
+  const sections = [
+    "dependencies",
+    "optionalDependencies",
+    "devDependencies"
+  ];
+  for (const section of sections) {
+    const deps = manifest[section];
+    if (!deps)
+      continue;
+    for (const [depName, spec] of Object.entries(deps)) {
+      if (typeof spec !== "string")
+        continue;
+      if (bundledNames.has(depName)) {
+        const targetBundlePath = (_b = (_a = contexts.get(depName)) == null ? void 0 : _a.bundlePath) != null ? _b : getBundlePath(depName);
+        const fromPath = import_path8.default.posix.join(BUNDLED_ROOT, bundlePath);
+        const toPath = import_path8.default.posix.join(BUNDLED_ROOT, targetBundlePath);
+        const relative3 = import_path8.default.posix.relative(fromPath, toPath) || ".";
+        rewriteMap[depName] = `file:${relative3}`;
+      }
+    }
+  }
+  return rewriteMap;
+}
+function toPosix(targetPath) {
+  return targetPath.split(import_path8.default.sep).join(import_path8.default.posix.sep);
+}
+
 // src/commands/build/utilities/uploadApplicationSource.ts
 var getAppFiles = async (globsInput, appPath, appPkgJson) => {
   const globs = [
@@ -2923,11 +3501,11 @@ var getAppFiles = async (globsInput, appPath, appPkgJson) => {
   if (globsInput && globsInput.length) {
     globs.push(
       ...globsInput,
-      path7.join(appPath, "package.json"),
-      path7.join(appPath, "package-lock.json"),
-      path7.join(appPath, "yarn.lock"),
-      path7.join(appPath, "pnpm-lock.yaml"),
-      path7.join(appPath, "shrinkwrap.yaml")
+      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("**");
@@ -2938,14 +3516,14 @@ var getAppFiles = async (globsInput, appPath, appPkgJson) => {
     "todesktop:afterPack"
   ]) {
     if (appPkgJson.scripts && appPkgJson.scripts[hookName]) {
-      globs.push(path7.join(appPath, appPkgJson.scripts[hookName]));
+      globs.push(path8.join(appPath, appPkgJson.scripts[hookName]));
     }
   }
   const normalizedGlobs = globs.map((glob) => {
-    const globToUse = path7.isAbsolute(glob) ? path7.relative(appPath, glob) : 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, {
+  let absolutePaths = await (0, import_fast_glob2.default)(normalizedGlobs, {
     absolute: true,
     cwd: appPath,
     dot: true,
@@ -2957,7 +3535,7 @@ var getAppFiles = async (globsInput, appPath, appPkgJson) => {
   });
   if (process.platform === "win32") {
     absolutePaths = absolutePaths.map(
-      (absolutePath) => absolutePath.replace(/\//g, path7.sep)
+      (absolutePath) => absolutePath.replace(/\//g, path8.sep)
     );
   }
   if (!absolutePaths || !absolutePaths.length) {
@@ -2971,21 +3549,21 @@ var getAppFiles = async (globsInput, appPath, appPkgJson) => {
   } else {
     let mainFilePath = appPath;
     if (appPkgJson.main) {
-      mainFilePath = path7.join(mainFilePath, appPkgJson.main);
+      mainFilePath = path8.join(mainFilePath, appPkgJson.main);
     }
-    if (fs5.statSync(mainFilePath).isDirectory()) {
-      mainFilePath = path7.join(mainFilePath, "index.js");
+    if (fs6.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 ? path7.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.`
+        `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: path7.join("app", path7.relative(appPath, absolutePath))
+      to: path8.join("app", path8.relative(appPath, absolutePath))
     };
   });
 };
@@ -3010,11 +3588,29 @@ async function uploadApplicationSource({
     "uploadApplicationSource"
   );
   let totalBytes = 0;
+  let effectiveAppPkgJson = appPkgJson;
+  let workspaceEntries = [];
+  try {
+    const workspaceBundle = await prepareWorkspaceBundle({
+      appPath: config2.appPath,
+      appPkgJson,
+      config: config2
+    });
+    effectiveAppPkgJson = workspaceBundle.appPackageJson;
+    workspaceEntries = workspaceBundle.entries;
+  } catch (error) {
+    logger_default.error({ err: error }, "Failed to prepare workspace bundle");
+    throw error;
+  }
   const files = [
     /*
       App files (stored in app/ in the ZIP)
     */
-    ...await getAppFiles(config2.appFiles, config2.appPath, appPkgJson),
+    ...await getAppFiles(
+      config2.appFiles,
+      config2.appPath,
+      effectiveAppPkgJson
+    ),
     /*
       Optional extra content files (stored in extraContentFiles/ in the ZIP). Their
       paths within is the their relative path from the project root so
@@ -3025,7 +3621,7 @@ async function uploadApplicationSource({
     ...(config2.extraContentFiles || []).map(({ from, to = "." }) => {
       return {
         from,
-        to: path7.join("extraContentFiles", to, path7.basename(from))
+        to: path8.join("extraContentFiles", to, path8.basename(from))
       };
     }),
     /*
@@ -3035,7 +3631,7 @@ async function uploadApplicationSource({
     ...(config2.extraResources || []).map(({ from, to = "." }) => {
       return {
         from,
-        to: path7.join("extraResources", to, path7.basename(from))
+        to: path8.join("extraResources", to, path8.basename(from))
       };
     }),
     /*
@@ -3043,16 +3639,16 @@ async function uploadApplicationSource({
     */
     {
       from: config2.icon,
-      to: path7.join("icons", "appIcon" + path7.extname(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: path7.join(
+        to: path8.join(
           "icons",
-          "appIcon-linux" + path7.extname(config2.linux.icon)
+          "appIcon-linux" + path8.extname(config2.linux.icon)
         )
       });
     }
@@ -3061,10 +3657,10 @@ async function uploadApplicationSource({
     const possibleIcons = [];
     for (const fa of config2.fileAssociations) {
       if (fa.icon) {
-        const icon = path7.parse(fa.icon);
+        const icon = path8.parse(fa.icon);
         possibleIcons.push(
-          { ext: fa.ext, icon: path7.join(icon.dir, icon.name) + ".ico" },
-          { ext: fa.ext, icon: path7.join(icon.dir, icon.name) + ".icns" }
+          { ext: fa.ext, icon: path8.join(icon.dir, icon.name) + ".ico" },
+          { ext: fa.ext, icon: path8.join(icon.dir, icon.name) + ".icns" }
         );
       }
     }
@@ -3073,7 +3669,7 @@ async function uploadApplicationSource({
         if (await exists(icon)) {
           files.push({
             from: icon,
-            to: path7.join("icons", "association-" + ext + path7.extname(icon))
+            to: path8.join("icons", "association-" + ext + path8.extname(icon))
           });
         }
       })
@@ -3083,25 +3679,25 @@ async function uploadApplicationSource({
     if (config2.mac.entitlements) {
       files.push({
         from: config2.mac.entitlements,
-        to: path7.join("other", "mac", "entitlements.mac.plist")
+        to: path8.join("other", "mac", "entitlements.mac.plist")
       });
     }
     if (config2.mac.entitlementsInherit) {
       files.push({
         from: config2.mac.entitlementsInherit,
-        to: path7.join("other", "mac", "entitlementsInherit.mac.plist")
+        to: path8.join("other", "mac", "entitlementsInherit.mac.plist")
       });
     }
     if (config2.mac.icon) {
       files.push({
         from: config2.mac.icon,
-        to: path7.join("icons", "appIcon-mac" + path7.extname(config2.mac.icon))
+        to: path8.join("icons", "appIcon-mac" + path8.extname(config2.mac.icon))
       });
     }
     if (config2.mac.requirements) {
       files.push({
         from: config2.mac.requirements,
-        to: path7.join("other", "mac", "requirements.txt")
+        to: path8.join("other", "mac", "requirements.txt")
       });
     }
   }
@@ -3109,19 +3705,19 @@ async function uploadApplicationSource({
     if (config2.mas.entitlements) {
       files.push({
         from: config2.mas.entitlements,
-        to: path7.join("other", "mac", "entitlements.mas.plist")
+        to: path8.join("other", "mac", "entitlements.mas.plist")
       });
     }
     if (config2.mas.entitlementsInherit) {
       files.push({
         from: config2.mas.entitlementsInherit,
-        to: path7.join("other", "mac", "entitlementsInherit.mas.plist")
+        to: path8.join("other", "mac", "entitlementsInherit.mas.plist")
       });
     }
     if (config2.mas.provisioningProfile) {
       files.push({
         from: config2.mas.provisioningProfile,
-        to: path7.join("other", "mac", "mas.provisionprofile")
+        to: path8.join("other", "mac", "mas.provisionprofile")
       });
     }
   }
@@ -3129,7 +3725,7 @@ async function uploadApplicationSource({
     if (config2.dmg.background) {
       files.push({
         from: config2.dmg.background,
-        to: path7.join("other", "mac", "dmg-background.tiff")
+        to: path8.join("other", "mac", "dmg-background.tiff")
       });
     }
   }
@@ -3137,19 +3733,22 @@ async function uploadApplicationSource({
     if (config2.windows.icon) {
       files.push({
         from: config2.windows.icon,
-        to: path7.join(
+        to: path8.join(
           "icons",
-          "appIcon-windows" + path7.extname(config2.windows.icon)
+          "appIcon-windows" + path8.extname(config2.windows.icon)
         )
       });
     }
     if (config2.windows.nsisInclude) {
       files.push({
         from: config2.windows.nsisInclude,
-        to: path7.join("other", "installer.nsh")
+        to: path8.join("other", "installer.nsh")
       });
     }
   }
+  if (workspaceEntries.length) {
+    files.push(...workspaceEntries);
+  }
   return uploadToS3_default({
     bucket: config2.bucket || void 0,
     inputStream: await zip_default({
@@ -3158,15 +3757,15 @@ async function uploadApplicationSource({
       onError: (e) => {
         throw e;
       },
-      onProgress({ fs: fs6 }) {
-        totalBytes = fs6.totalBytes;
+      onProgress({ fs: fs7 }) {
+        totalBytes = fs7.totalBytes;
       },
-      appPkgJson
+      appPkgJson: effectiveAppPkgJson
     }),
     key: generateS3Key_default({
       appId,
       buildId,
-      filenameSuffix: `${(_a = appPkgJson.name) == null ? void 0 : _a.replaceAll("/", "")}.zip`
+      filenameSuffix: `${(_a = effectiveAppPkgJson.name) == null ? void 0 : _a.replaceAll("/", "")}.zip`
     }),
     onProgress({ loaded, total }) {
       onProgress(loaded / total * 100, loaded);
@@ -3175,7 +3774,7 @@ async function uploadApplicationSource({
 }
 async function exists(filePath) {
   try {
-    await fs5.promises.access(filePath);
+    await fs6.promises.access(filePath);
     return true;
   } catch (e) {
     return false;
@@ -3714,7 +4313,7 @@ async function subscribeToFirebaseDoc(key, receiver) {
       (snapshot) => {
         receiver({
           snapshot,
-          data: snapshot.exists() ? snapshot.data() : void 0
+          data: readDocumentSnapshot(snapshot)
         });
         resolve5(unsubscribe);
       },
@@ -3744,15 +4343,22 @@ var subscribeToBuild_default = async ({ appId, buildId, onDataReceived, userId }
 var import_firestore12 = require("firebase/firestore");
 var getCollection = async (collectionRef) => {
   const resp = await (0, import_firestore12.getDocs)(collectionRef);
-  const result = [];
-  resp.forEach((doc9) => result.push(doc9.data()));
-  return result;
+  return readQuerySnapshot(resp);
 };
 var acceptedUsersCollection = (id) => (0, import_firestore12.collection)(firestore_default, `users/${id}/acceptedUsers`);
 var findAppUserId = async (appId) => {
-  const { uid, email } = currentUser();
-  const acceptedUsers = await getCollection(acceptedUsersCollection(uid));
-  const primaryUser = { id: uid, label: email };
+  var _a;
+  const authUser = currentUser();
+  if (!(authUser == null ? void 0 : authUser.uid)) {
+    throw new Error("A signed-in Firebase user is required");
+  }
+  const acceptedUsers = await getCollection(
+    acceptedUsersCollection(authUser.uid)
+  );
+  const primaryUser = {
+    id: authUser.uid,
+    label: (_a = authUser.email) != null ? _a : authUser.uid
+  };
   const users = [
     primaryUser,
     ...acceptedUsers.map((user) => ({ id: user.id, label: user.email }))
@@ -3978,13 +4584,13 @@ var OngoingBuildGuard = ({
           builds: []
         };
         if (!buildsResult.empty) {
-          const latestBuild = buildsResult.docs[0].data();
+          const latestBuild = readQueryDocument(buildsResult.docs[0]);
           const isRunning = isBuildRunning(latestBuild) && latestBuild.status !== "preparation";
           logger_default.debug(
             { isRunning },
             "OngoingBuildGuard component: got latest build"
           );
-          stateUpdates.builds = buildsResult.docs.map((doc9) => doc9.data()).filter((build) => {
+          stateUpdates.builds = buildsResult.docs.map((doc9) => readQueryDocument(doc9)).filter((build) => {
             if (isBuildRunning(build) && build.status !== "preparation") {
               return true;
             }
@@ -4372,7 +4978,7 @@ async function getBuilds({
   if (buildsResult.empty) {
     return [];
   }
-  return buildsResult.docs.map((doc9) => doc9.data());
+  return readQuerySnapshot(buildsResult);
 }
 
 // src/utilities/getRelativeDateFromDateString.ts
@@ -4752,6 +5358,7 @@ async function getBuildById({
   buildId,
   userId
 }) {
+  var _a;
   logger_default.debug({ appId, buildId }, "getBuildById");
   const snapshot = await (0, import_firestore19.getDoc)(
     (0, import_firestore19.doc)(firestore_default, `users/${userId}/applications/${appId}/builds/${buildId}`)
@@ -4759,7 +5366,7 @@ async function getBuildById({
   if (!snapshot.exists()) {
     return null;
   }
-  return snapshot.data();
+  return (_a = readDocumentSnapshot(snapshot)) != null ? _a : null;
 }
 
 // src/utilities/getLatestReleasedBuild.ts
@@ -4770,7 +5377,7 @@ async function getLatestReleasedBuild({
   var _a, _b;
   const appRef = (0, import_firestore21.doc)(firestore_default, `users/${userId}/applications/${appId}`);
   const appSnapshot = await (0, import_firestore21.getDoc)(appRef);
-  const app2 = appSnapshot.exists() ? appSnapshot.data() : void 0;
+  const app2 = readDocumentSnapshot(appSnapshot);
   if (!app2) {
     throw new Error(`Application with ID of ${appId} doesn't exist.`);
   }
@@ -4787,7 +5394,7 @@ async function getLatestReleasedBuild({
     (0, import_firestore21.limit)(1)
   );
   const buildsResult = await (0, import_firestore21.getDocs)(buildsQuery);
-  return buildsResult.empty ? void 0 : buildsResult.docs[0].data();
+  return buildsResult.empty ? void 0 : readQueryDocument(buildsResult.docs[0]);
 }
 
 // src/components/BuildPicker.tsx
@@ -4931,6 +5538,7 @@ async function getBuildAttributes({
   buildId,
   configPath
 }) {
+  var _a;
   const {
     id: appId,
     nodeVersion,
@@ -4938,7 +5546,7 @@ async function getBuildAttributes({
     pnpmVersion
   } = getProjectConfig(configPath).config;
   const { id: userId } = await findAppUserId_default(appId);
-  const { uid: contextUserId } = currentUser();
+  const contextUserId = (_a = currentUser()) == null ? void 0 : _a.uid;
   const build = await fetchBuild({ appId, buildId, userId });
   return {
     appId,
@@ -4971,8 +5579,9 @@ async function releaseBuild({
   try {
     await getCallableFirebaseFunction_default("releaseBuild")({ appId, buildId });
   } catch (e) {
-    if (isFirebaseFunctionError(e) && (e.code === "failed-precondition" || e.code === "not-found")) {
-      throw CliError.from(e, "build-error");
+    if (isFirebaseFunctionError(e)) {
+      const errorType = e.code === "failed-precondition" || e.code === "not-found" ? "build-error" : "error";
+      throw CliError.from(e, errorType);
     } else {
       throw new CliError("Unexpected internal error while releasing build");
     }
@@ -5820,7 +6429,10 @@ async function waitUntilFinished({
     const unsubscribe = (0, import_firestore27.onSnapshot)(
       (0, import_firestore27.doc)(firestore_default, docPath),
       (snapshot) => {
-        const data = snapshot.exists() ? snapshot.data() : void 0;
+        const data = readDocumentSnapshot(snapshot);
+        if (!data) {
+          return;
+        }
         const progress = makeProgress(data);
         onProgress(progress);
         if (progress.isFinished) {
@@ -6000,7 +6612,7 @@ var exitIfCLIOutOfDate_default = () => {
   (0, import_latest_version.default)(pkg.name).then((latest) => {
     if (import_semver3.default.gt(latest, pkg.version)) {
       const commandToUpdate = import_chalk3.default.greenBright(
-        `npm install ${import_is_installed_globally.default ? "--location=global" : "--save-dev"} @todesktop/cli`
+        `npm install ${import_is_installed_globally.default ? "-g" : "--save-dev"} @todesktop/cli`
       );
       console.log(
         `Your version of @todesktop/cli is out of date.
@@ -6025,7 +6637,7 @@ var package_default = {
     access: "public"
   },
   name: "@todesktop/cli",
-  version: "1.15.0",
+  version: "1.15.2",
   license: "MIT",
   author: "Dave Jeffery <dave@todesktop.com> (http://www.todesktop.com/)",
   homepage: "https://todesktop.com/cli",
@@ -6093,6 +6705,7 @@ var package_default = {
     "ink-text-input": "^4.0.1",
     "is-ci": "^3.0.1",
     "is-installed-globally": "^0.3.2",
+    "js-yaml": "^4.1.0",
     "latest-version": "^5.1.0",
     "lodash.merge": "^4.6.2",
     "lodash.throttle": "^4.1.1",
@@ -6155,7 +6768,8 @@ var package_default = {
       "**/*.test.tsx",
       "!build/**/*",
       "!test/fixtures/**/*",
-      "!test/utilities/**/*"
+      "!test/utilities/**/*",
+      "!worktrees/**/*"
     ],
     require: [
       "esbuild-register",