obsidian-launcher 2.1.1 → 2.1.2

package/dist/{chunk-BLHP5CDO.cjs → chunk-Z5EOC6TG.cjs}

@@ -11,45 +11,57 @@ var _promisepool = require('@supercharge/promise-pool');
 var _lodash = require('lodash'); var _lodash2 = _interopRequireDefault(_lodash);
 async function fileExists(path6) {
   try {
-    await _promises2.default.access(path6);
+    await _promises2.default.stat(path6);
     return true;
-  } catch (e2) {
-    return false;
+  } catch (e) {
+    if (_optionalChain([e, 'optionalAccess', _5 => _5.code]) == "ENOENT") {
+      return false;
+    }
+    throw e;
   }
 }
 async function makeTmpDir(prefix) {
   return _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), _nullishCoalesce(prefix, () => ( "tmp-"))));
 }
 async function atomicCreate(dest, func, opts = {}) {
+  const { replace = true, preserveTmpDir = false } = opts;
   dest = _path2.default.resolve(dest);
-  const createdParentDir = await _promises2.default.mkdir(_path2.default.dirname(dest), { recursive: true });
-  const tmpDir = await _promises2.default.mkdtemp(_path2.default.join(_path2.default.dirname(dest), `.${_path2.default.basename(dest)}.tmp.`));
-  let success = false;
+  const parentDir = _path2.default.dirname(dest);
+  if (!replace && await fileExists(dest)) return;
+  await _promises2.default.mkdir(parentDir, { recursive: true });
+  const scratch = await _promises2.default.mkdtemp(_path2.default.join(parentDir, `.${_path2.default.basename(dest)}.tmp.`));
   try {
-    let result = await _asyncNullishCoalesce(await func(tmpDir), async () => ( tmpDir));
-    result = _path2.default.resolve(tmpDir, result);
-    if (!result.startsWith(tmpDir)) {
-      throw new Error(`Returned path ${result} not under tmpDir`);
+    let result = await _asyncNullishCoalesce(await func(scratch), async () => ( scratch));
+    result = _path2.default.resolve(scratch, result);
+    if (!result.startsWith(scratch)) {
+      throw new Error(`Returned path ${result} not under scratch`);
     }
-    if (await fileExists(dest) && (await _promises2.default.stat(dest)).isDirectory()) {
-      await _promises2.default.rename(dest, tmpDir + ".old");
+    if (replace) {
+      if (await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => null)), 'optionalAccess', async _6 => _6.isDirectory, 'call', async _7 => _7()])) {
+        await _promises2.default.rename(dest, `${scratch}.old`);
+      }
+      await _promises2.default.rename(result, dest);
+    } else {
+      if (!await fileExists(dest)) {
+        await _promises2.default.rename(result, dest).catch((e) => {
+          if (_optionalChain([e, 'optionalAccess', _8 => _8.code]) != "ENOTEMPTY") throw e;
+        });
+      }
     }
-    await _promises2.default.rename(result, dest);
-    success = true;
-  } finally {
-    if (success) {
-      await _promises2.default.rm(tmpDir + ".old", { recursive: true, force: true });
-      await _promises2.default.rm(tmpDir, { recursive: true, force: true });
-    } else if (!opts.preserveTmpDir) {
-      await _promises2.default.rm(_nullishCoalesce(createdParentDir, () => ( tmpDir)), { recursive: true, force: true });
+    await _promises2.default.rm(scratch, { recursive: true, force: true });
+    await _promises2.default.rm(`${scratch}.old`, { recursive: true, force: true });
+  } catch (e) {
+    if (!preserveTmpDir) {
+      await _promises2.default.rm(scratch, { recursive: true, force: true });
     }
+    throw e;
   }
 }
 async function linkOrCp(src, dest) {
   await _promises2.default.rm(dest, { recursive: true, force: true });
   try {
     await _promises2.default.link(src, dest);
-  } catch (e3) {
+  } catch (e2) {
     await _promises2.default.copyFile(src, dest);
   }
 }
@@ -168,38 +180,43 @@ async function fetchGitHubAPIPaginated(url, params = {}) {
   while (next) {
     const response = await fetchGitHubAPI(next);
     results.push(...await response.json());
-    next = _optionalChain([parseLinkHeader, 'call', _5 => _5(_nullishCoalesce(response.headers.get("link"), () => ( ""))), 'access', _6 => _6.next, 'optionalAccess', _7 => _7.url]);
+    next = _optionalChain([parseLinkHeader, 'call', _9 => _9(_nullishCoalesce(response.headers.get("link"), () => ( ""))), 'access', _10 => _10.next, 'optionalAccess', _11 => _11.url]);
   }
   return results;
 }
 async function obsidianApiLogin(opts) {
   const { interactive = false, savePath } = opts;
-  if (savePath) _dotenv2.default.config({ path: [savePath], quiet: true });
-  let email = _process.env.OBSIDIAN_EMAIL;
-  let password = _process.env.OBSIDIAN_PASSWORD;
+  const cached = savePath ? _dotenv2.default.parse(await _promises2.default.readFile(savePath).catch(() => "")) : {};
+  let email = _nullishCoalesce(_process.env.OBSIDIAN_EMAIL, () => ( cached.OBSIDIAN_EMAIL));
+  let password = _nullishCoalesce(_process.env.OBSIDIAN_PASSWORD, () => ( cached.OBSIDIAN_PASSWORD));
+  let promptedCredentials = false;
   if (!email || !password) {
     if (interactive) {
       console.log("Obsidian Insiders account is required to download Obsidian beta versions.");
       email = email || _readlinesync2.default.question("Obsidian email: ");
       password = password || _readlinesync2.default.question("Obsidian password: ", { hideEchoBack: true });
+      promptedCredentials = true;
     } else {
       throw Error(
         "Obsidian Insiders account is required to download Obsidian beta versions. Either set the OBSIDIAN_EMAIL and OBSIDIAN_PASSWORD env vars (.env file is supported) or pre-download the Obsidian beta with `npx obsidian-launcher download app -v <version>`"
       );
     }
   }
+  function parseSignin(r) {
+    return { token: r.token ? "token" : void 0, error: _optionalChain([r, 'access', _12 => _12.error, 'optionalAccess', _13 => _13.toString, 'call', _14 => _14()]), license: r.license };
+  }
   let needsMfa = false;
   let retries = 0;
   let signin = void 0;
-  while (!_optionalChain([signin, 'optionalAccess', _8 => _8.token]) && retries < 3) {
+  while (!_optionalChain([signin, 'optionalAccess', _15 => _15.token]) && retries < 3) {
     if (retries > 0 || _process.env.CI) {
-      await sleep(2 * Math.random() + retries * retries * 2);
+      await sleep(2 * Math.random() + retries * retries * 3);
     }
     let mfa = "";
     if (needsMfa && interactive) {
       mfa = _readlinesync2.default.question("Obsidian 2FA: ");
     }
-    signin = await fetch("https://api.obsidian.md/user/signin", {
+    const response = await fetch("https://api.obsidian.md/user/signin", {
       method: "post",
       headers: {
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36",
@@ -208,27 +225,29 @@ async function obsidianApiLogin(opts) {
       },
       body: JSON.stringify({ email, password, mfa })
     }).then((r) => r.json());
-    const error = _optionalChain([signin, 'access', _9 => _9.error, 'optionalAccess', _10 => _10.toLowerCase, 'call', _11 => _11()]);
-    if (_optionalChain([error, 'optionalAccess', _12 => _12.includes, 'call', _13 => _13("2fa")]) && !needsMfa) {
+    signin = parseSignin(response);
+    const error = _optionalChain([signin, 'access', _16 => _16.error, 'optionalAccess', _17 => _17.toLowerCase, 'call', _18 => _18()]);
+    if (_optionalChain([error, 'optionalAccess', _19 => _19.includes, 'call', _20 => _20("2fa")]) && !needsMfa) {
       needsMfa = true;
       if (!interactive) {
         throw Error(
           "Can't login with 2FA in a non-interactive session. To download Obsidian beta versions, either disable 2FA on your account or pre-download the Obsidian beta with `npx obsidian-launcher download app -v <version>`"
         );
       }
-    } else if (["please wait", "try again"].some((m) => _optionalChain([error, 'optionalAccess', _14 => _14.includes, 'call', _15 => _15(m)]))) {
+    } else if (["please wait", "try again"].some((m) => _optionalChain([error, 'optionalAccess', _21 => _21.includes, 'call', _22 => _22(m)]))) {
       console.warn(`Obsidian login failed: ${signin.error}`);
+      console.warn("Retrying obsidian login...");
       retries++;
     } else if (!signin.token) {
       throw Error(`Obsidian login failed: ${_nullishCoalesce(signin.error, () => ( "unknown error"))}`);
     }
   }
-  if (!_optionalChain([signin, 'optionalAccess', _16 => _16.token])) {
-    throw Error(`Obsidian login failed: ${_nullishCoalesce(_optionalChain([signin, 'optionalAccess', _17 => _17.error]), () => ( "unknown error"))}`);
-  } else if (!_optionalChain([signin, 'optionalAccess', _18 => _18.license])) {
+  if (!_optionalChain([signin, 'optionalAccess', _23 => _23.token])) {
+    throw Error(`Obsidian login failed: ${_nullishCoalesce(_optionalChain([signin, 'optionalAccess', _24 => _24.error]), () => ( "unknown error"))}`);
+  } else if (!_optionalChain([signin, 'optionalAccess', _25 => _25.license])) {
     throw Error("Obsidian Insiders account is required to download Obsidian beta versions");
   }
-  if (interactive && savePath && (!_process.env.OBSIDIAN_EMAIL || !_process.env.OBSIDIAN_PASSWORD)) {
+  if (savePath && promptedCredentials) {
     const save = _readlinesync2.default.question("Cache credentails to disk? [y/n]: ");
     if (["y", "yes"].includes(save.toLowerCase())) {
       await _promises2.default.writeFile(
@@ -243,6 +262,9 @@ OBSIDIAN_PASSWORD='${password}'
   return signin.token;
 }
 async function fetchObsidianApi(url, opts) {
+  if (!opts.token) {
+    throw Error("Obsidian credentials required to download Obsidian beta release");
+  }
   url = createURL(url, "https://releases.obsidian.md");
   const response = await fetch(url, {
     headers: {
@@ -349,7 +371,7 @@ var ChromeLocalStorage = class {
 var _zlib = require('zlib'); var _zlib2 = _interopRequireDefault(_zlib);
 
 function normalizeGitHubRepo(repo) {
-  return _nullishCoalesce(_optionalChain([repo, 'access', _19 => _19.match, 'call', _20 => _20(/^(https?:\/\/)?(github.com\/)?(.*?)\/?$/), 'optionalAccess', _21 => _21[3]]), () => ( repo));
+  return _nullishCoalesce(_optionalChain([repo, 'access', _26 => _26.match, 'call', _27 => _27(/^(https?:\/\/)?(github.com\/)?(.*?)\/?$/), 'optionalAccess', _28 => _28[3]]), () => ( repo));
 }
 async function extractGz(archive, dest) {
   await _promises3.pipeline.call(void 0, _fs2.default.createReadStream(archive), _zlib2.default.createGunzip(), _fs2.default.createWriteStream(dest));
@@ -374,16 +396,16 @@ ${stderr}`);
   return result;
 }
 async function extractObsidianAppImage(appImage, dest) {
-  await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-o.", _path2.default.relative(tmpDir, appImage)], { cwd: tmpDir });
-    return tmpDir;
+  await atomicCreate(dest, async (scratch) => {
+    await sevenZ(["x", "-o.", _path2.default.relative(scratch, appImage)], { cwd: scratch });
+    return scratch;
   });
 }
 async function extractObsidianTar(tar, dest) {
-  await atomicCreate(dest, async (tmpDir) => {
-    await extractGz(tar, _path2.default.join(tmpDir, "inflated.tar"));
-    await sevenZ(["x", "-o.", "inflated.tar"], { cwd: tmpDir });
-    return (await _promises2.default.readdir(tmpDir)).find((p) => p.match("obsidian-"));
+  await atomicCreate(dest, async (scratch) => {
+    await extractGz(tar, _path2.default.join(scratch, "inflated.tar"));
+    await sevenZ(["x", "-o.", "inflated.tar"], { cwd: scratch });
+    return (await _promises2.default.readdir(scratch)).find((p) => p.match("obsidian-"));
   });
 }
 async function extractObsidianExe(exe, arch, dest) {
@@ -397,17 +419,17 @@ async function extractObsidianExe(exe, arch, dest) {
   } else {
     throw Error(`No Obsidian installer found for ${process.platform} ${process.arch}`);
   }
-  await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-oinstaller", _path2.default.relative(tmpDir, exe), subArchive], { cwd: tmpDir });
-    await sevenZ(["x", "-oobsidian", _path2.default.join("installer", subArchive)], { cwd: tmpDir });
+  await atomicCreate(dest, async (scratch) => {
+    await sevenZ(["x", "-oinstaller", _path2.default.relative(scratch, exe), subArchive], { cwd: scratch });
+    await sevenZ(["x", "-oobsidian", _path2.default.join("installer", subArchive)], { cwd: scratch });
     return "obsidian";
   });
 }
 async function extractObsidianDmg(dmg, dest) {
   dest = _path2.default.resolve(dest);
-  await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-o.", _path2.default.relative(tmpDir, dmg), "*/Obsidian.app", "Obsidian.app"], { cwd: tmpDir });
-    const files = await _promises2.default.readdir(tmpDir);
+  await atomicCreate(dest, async (scratch) => {
+    await sevenZ(["x", "-o.", _path2.default.relative(scratch, dmg), "*/Obsidian.app", "Obsidian.app"], { cwd: scratch });
+    const files = await _promises2.default.readdir(scratch);
     if (files.includes("Obsidian.app")) {
       return "Obsidian.app";
     } else {
@@ -430,8 +452,8 @@ async function fetchObsidianDesktopReleases(sinceDate, sinceSha) {
     commitHistory,
     (commit) => fetch(`https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
   );
-  const commitDate = _nullishCoalesce(_optionalChain([commitHistory, 'access', _22 => _22.at, 'call', _23 => _23(-1), 'optionalAccess', _24 => _24.commit, 'access', _25 => _25.committer, 'access', _26 => _26.date]), () => ( sinceDate));
-  const commitSha = _nullishCoalesce(_optionalChain([commitHistory, 'access', _27 => _27.at, 'call', _28 => _28(-1), 'optionalAccess', _29 => _29.sha]), () => ( sinceSha));
+  const commitDate = _nullishCoalesce(_optionalChain([commitHistory, 'access', _29 => _29.at, 'call', _30 => _30(-1), 'optionalAccess', _31 => _31.commit, 'access', _32 => _32.committer, 'access', _33 => _33.date]), () => ( sinceDate));
+  const commitSha = _nullishCoalesce(_optionalChain([commitHistory, 'access', _34 => _34.at, 'call', _35 => _35(-1), 'optionalAccess', _36 => _36.sha]), () => ( sinceSha));
   return [fileHistory, { commitDate, commitSha }];
 }
 async function fetchObsidianGitHubReleases() {
@@ -489,14 +511,14 @@ function parseObsidianGithubRelease(gitHubRelease) {
     version,
     gitHubRelease: gitHubRelease.html_url,
     downloads: {
-      asar: _optionalChain([asar, 'optionalAccess', _30 => _30.url]),
-      appImage: _optionalChain([appImage, 'optionalAccess', _31 => _31.url]),
-      appImageArm: _optionalChain([appImageArm, 'optionalAccess', _32 => _32.url]),
-      tar: _optionalChain([tar, 'optionalAccess', _33 => _33.url]),
-      tarArm: _optionalChain([tarArm, 'optionalAccess', _34 => _34.url]),
-      dmg: _optionalChain([dmg, 'optionalAccess', _35 => _35.url]),
-      exe: _optionalChain([exe, 'optionalAccess', _36 => _36.url]),
-      apk: _optionalChain([apk, 'optionalAccess', _37 => _37.url])
+      asar: _optionalChain([asar, 'optionalAccess', _37 => _37.url]),
+      appImage: _optionalChain([appImage, 'optionalAccess', _38 => _38.url]),
+      appImageArm: _optionalChain([appImageArm, 'optionalAccess', _39 => _39.url]),
+      tar: _optionalChain([tar, 'optionalAccess', _40 => _40.url]),
+      tarArm: _optionalChain([tarArm, 'optionalAccess', _41 => _41.url]),
+      dmg: _optionalChain([dmg, 'optionalAccess', _42 => _42.url]),
+      exe: _optionalChain([exe, 'optionalAccess', _43 => _43.url]),
+      apk: _optionalChain([apk, 'optionalAccess', _44 => _44.url])
     },
     installers: {
       appImage: appImage ? { digest: appImage.digest } : void 0,
@@ -532,8 +554,8 @@ function updateObsidianVersionList(args) {
       const parsed = parseObsidianGithubRelease(githubRelease);
       const newVersion = _lodash2.default.merge(_nullishCoalesce(newVersions[parsed.version], () => ( {})), parsed);
       for (const installerKey of INSTALLER_KEYS) {
-        const oldDigest = _optionalChain([oldVersions, 'access', _38 => _38[parsed.version], 'optionalAccess', _39 => _39.installers, 'access', _40 => _40[installerKey], 'optionalAccess', _41 => _41.digest]);
-        const newDigest = _optionalChain([newVersion, 'access', _42 => _42.installers, 'optionalAccess', _43 => _43[installerKey], 'optionalAccess', _44 => _44.digest]);
+        const oldDigest = _optionalChain([oldVersions, 'access', _45 => _45[parsed.version], 'optionalAccess', _46 => _46.installers, 'access', _47 => _47[installerKey], 'optionalAccess', _48 => _48.digest]);
+        const newDigest = _optionalChain([newVersion, 'access', _49 => _49.installers, 'optionalAccess', _50 => _50[installerKey], 'optionalAccess', _51 => _51.digest]);
         if (oldDigest && oldDigest != newDigest) {
           newVersion.installers[installerKey] = { digest: newDigest };
         }
@@ -550,7 +572,11 @@ function updateObsidianVersionList(args) {
         minInstallerVersion = version;
       }
     }
-    newVersions[version] = _lodash2.default.merge({ minInstallerVersion, maxInstallerVersion }, newVersions[version]);
+    newVersions[version] = _lodash2.default.merge(newVersions[version], {
+      minInstallerVersion: _nullishCoalesce(_optionalChain([newVersions, 'access', _52 => _52[version], 'optionalAccess', _53 => _53.minInstallerVersion]), () => ( minInstallerVersion)),
+      maxInstallerVersion
+      // override maxInstallerVersion if it was already set
+    });
   }
   for (const installerInfo of installerInfos) {
     newVersions[installerInfo.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[installerInfo.version], () => ( {})), {
@@ -618,8 +644,8 @@ async function extractInstallerInfo(installerKey, url) {
 }
 function normalizeObsidianVersionInfo(versionInfo) {
   versionInfo = _lodash2.default.cloneDeep(versionInfo);
-  versionInfo.electronVersion = _optionalChain([versionInfo, 'access', _45 => _45.installers, 'optionalAccess', _46 => _46.appImage, 'optionalAccess', _47 => _47.electron]);
-  versionInfo.chromeVersion = _optionalChain([versionInfo, 'access', _48 => _48.installers, 'optionalAccess', _49 => _49.appImage, 'optionalAccess', _50 => _50.chrome]);
+  versionInfo.electronVersion = _optionalChain([versionInfo, 'access', _54 => _54.installers, 'optionalAccess', _55 => _55.appImage, 'optionalAccess', _56 => _56.electron]);
+  versionInfo.chromeVersion = _optionalChain([versionInfo, 'access', _57 => _57.installers, 'optionalAccess', _58 => _58.appImage, 'optionalAccess', _59 => _59.chrome]);
   versionInfo.downloads = _nullishCoalesce(versionInfo.downloads, () => ( {}));
   versionInfo.installers = _nullishCoalesce(versionInfo.installers, () => ( {}));
   const canonicalForm = {
@@ -691,7 +717,7 @@ var ObsidianLauncher = class {
     if (!(dest in this.metadataCache)) {
       let data;
       let error;
-      const cacheMtime = await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => void 0)), 'optionalAccess', async _51 => _51.mtime]);
+      const cacheMtime = await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => void 0)), 'optionalAccess', async _60 => _60.mtime]);
       if (url.startsWith("file:")) {
         data = JSON.parse(await _promises2.default.readFile(_url.fileURLToPath.call(void 0, url), "utf-8"));
       }
@@ -709,10 +735,10 @@ var ObsidianLauncher = class {
           return d;
         }));
         if (response.success) {
-          await atomicCreate(dest, async (tmpDir) => {
-            await _promises2.default.writeFile(_path2.default.join(tmpDir, "download.json"), response.result);
-            return _path2.default.join(tmpDir, "download.json");
-          });
+          await atomicCreate(dest, async (scratch) => {
+            await _promises2.default.writeFile(_path2.default.join(scratch, "download.json"), response.result);
+            return _path2.default.join(scratch, "download.json");
+          }, { replace: true });
           data = JSON.parse(response.result);
         } else {
           error = response.error;
@@ -779,7 +805,7 @@ var ObsidianLauncher = class {
    * Resolves Obsidian app and installer version strings to absolute versions.
    * @param appVersion specific version or one of
    *   - "latest": Get the current latest non-beta Obsidian version
-   *   - "latest-beta": Get the current latest beta Obsidian version (or latest is there is no current beta)
+   *   - "latest-beta": Get the current latest beta Obsidian version (or latest if there is no current beta)
    *   - "earliest": Get the `minAppVersion` set in your `manifest.json`
    * @param installerVersion specific version or one of
    *   - "latest": Get the latest Obsidian installer compatible with `appVersion`
@@ -837,7 +863,7 @@ var ObsidianLauncher = class {
       appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
     } else if (appVersion == "earliest") {
       const manifest = await this.getRootManifest();
-      if (!_optionalChain([manifest, 'optionalAccess', _52 => _52.minAppVersion])) {
+      if (!_optionalChain([manifest, 'optionalAccess', _61 => _61.minAppVersion])) {
         throw Error('Unable to resolve Obsidian appVersion "earliest", no manifest.json or minAppVersion found.');
       }
       appVersion = manifest.minAppVersion;
@@ -913,31 +939,29 @@ var ObsidianLauncher = class {
     const versionInfo = await this.getVersionInfo(installerVersion);
     installerVersion = versionInfo.version;
     const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
-    const cacheDir = _path2.default.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
+    const installerDir = _path2.default.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
     let binaryPath;
     let extractor;
     if (platform == "linux") {
-      binaryPath = _path2.default.join(cacheDir, "obsidian");
+      binaryPath = _path2.default.join(installerDir, "obsidian");
       extractor = (installer, dest) => extractObsidianAppImage(installer, dest);
     } else if (platform == "win32") {
-      binaryPath = _path2.default.join(cacheDir, "Obsidian.exe");
+      binaryPath = _path2.default.join(installerDir, "Obsidian.exe");
       extractor = (installer, dest) => extractObsidianExe(installer, arch, dest);
     } else if (platform == "darwin") {
-      binaryPath = _path2.default.join(cacheDir, "Contents/MacOS/Obsidian");
+      binaryPath = _path2.default.join(installerDir, "Contents/MacOS/Obsidian");
       extractor = (installer, dest) => extractObsidianDmg(installer, dest);
     } else {
       throw Error(`Unsupported platform ${platform}`);
     }
-    if (!await fileExists(binaryPath)) {
+    await atomicCreate(installerDir, async (scratch) => {
       console.log(`Downloading Obsidian installer v${installerVersion}...`);
-      await atomicCreate(cacheDir, async (tmpDir) => {
-        const installer = _path2.default.join(tmpDir, "installer");
-        await downloadResponse(await fetch(installerInfo.url), installer);
-        const extracted = _path2.default.join(tmpDir, "extracted");
-        await extractor(installer, extracted);
-        return extracted;
-      });
-    }
+      const installer = _path2.default.join(scratch, "installer");
+      await downloadResponse(await fetch(installerInfo.url), installer);
+      const extracted = _path2.default.join(scratch, "extracted");
+      await extractor(installer, extracted);
+      return extracted;
+    }, { replace: false });
     return binaryPath;
   }
   /**
@@ -956,29 +980,27 @@ var ObsidianLauncher = class {
       throw Error(`No asar found for Obsidian version ${appVersion}`);
     }
     const appPath = _path2.default.join(this.cacheDir, "obsidian-app", `obsidian-${versionInfo.version}.asar`);
-    if (!await fileExists(appPath)) {
-      console.log(`Downloading Obsidian app v${versionInfo.version} ...`);
-      await atomicCreate(appPath, async (tmpDir) => {
-        const isInsiders = new URL(appUrl).hostname.endsWith(".obsidian.md");
-        let response;
-        if (isInsiders) {
-          if (!this.obsidianApiToken) {
-            this.obsidianApiToken = await obsidianApiLogin({
-              interactive: this.interactive,
-              savePath: _path2.default.join(this.cacheDir, "obsidian-credentials.env")
-            });
-          }
-          response = await fetchObsidianApi(appUrl, { token: this.obsidianApiToken });
-        } else {
-          response = await fetch(appUrl);
-        }
-        const archive = _path2.default.join(tmpDir, "app.asar.gz");
-        const asar = _path2.default.join(tmpDir, "app.asar");
-        await downloadResponse(response, archive);
-        await extractGz(archive, asar);
-        return asar;
+    const isInsiders = new URL(appUrl).hostname.endsWith(".obsidian.md");
+    if (isInsiders && !this.obsidianApiToken && !await fileExists(appPath)) {
+      this.obsidianApiToken = await obsidianApiLogin({
+        interactive: this.interactive,
+        savePath: _path2.default.join(this.cacheDir, "obsidian-credentials.env")
       });
     }
+    await atomicCreate(appPath, async (scratch) => {
+      console.log(`Downloading Obsidian app v${versionInfo.version} ...`);
+      let response;
+      if (isInsiders) {
+        response = await fetchObsidianApi(appUrl, { token: this.obsidianApiToken });
+      } else {
+        response = await fetch(appUrl);
+      }
+      const archive = _path2.default.join(scratch, "app.asar.gz");
+      const asar = _path2.default.join(scratch, "app.asar");
+      await downloadResponse(response, archive);
+      await extractGz(archive, asar);
+      return asar;
+    }, { replace: false });
     return appPath;
   }
   /**
@@ -995,26 +1017,24 @@ var ObsidianLauncher = class {
   async downloadChromedriver(installerVersion, opts = {}) {
     const { platform, arch } = _lodash2.default.defaults({}, opts, currentPlatform);
     const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
-    const cacheDir = _path2.default.join(this.cacheDir, `electron-chromedriver/${platform}-${arch}/${installerInfo.electron}`);
+    const chromedriverDir = _path2.default.join(this.cacheDir, `electron-chromedriver/${platform}-${arch}/${installerInfo.electron}`);
     let chromedriverPath;
     if (process.platform == "win32") {
-      chromedriverPath = _path2.default.join(cacheDir, `chromedriver.exe`);
+      chromedriverPath = _path2.default.join(chromedriverDir, `chromedriver.exe`);
     } else {
-      chromedriverPath = _path2.default.join(cacheDir, `chromedriver`);
+      chromedriverPath = _path2.default.join(chromedriverDir, `chromedriver`);
     }
-    if (!await fileExists(chromedriverPath)) {
+    await atomicCreate(chromedriverDir, async (scratch) => {
       console.log(`Downloading chromedriver for electron ${installerInfo.electron} ...`);
-      await atomicCreate(cacheDir, async (tmpDir) => {
-        const chromedriverZipPath = await _get.downloadArtifact.call(void 0, {
-          version: installerInfo.electron,
-          artifactName: "chromedriver",
-          cacheRoot: _path2.default.join(tmpDir, "download")
-        });
-        const extracted = _path2.default.join(tmpDir, "extracted");
-        await _extractzip2.default.call(void 0, chromedriverZipPath, { dir: extracted });
-        return extracted;
+      const chromedriverZipPath = await _get.downloadArtifact.call(void 0, {
+        version: installerInfo.electron,
+        artifactName: "chromedriver",
+        cacheRoot: _path2.default.join(scratch, "download")
       });
-    }
+      const extracted = _path2.default.join(scratch, "extracted");
+      await _extractzip2.default.call(void 0, chromedriverZipPath, { dir: extracted });
+      return extracted;
+    }, { replace: false });
     return chromedriverPath;
   }
   /**
@@ -1029,14 +1049,12 @@ var ObsidianLauncher = class {
       );
     }
     const apkPath = _path2.default.join(this.cacheDir, "obsidian-apk", `obsidian-${versionInfo.version}.apk`);
-    if (!await fileExists(apkPath)) {
+    await atomicCreate(apkPath, async (scratch) => {
       console.log(`Downloading Obsidian apk v${versionInfo.version} ...`);
-      await atomicCreate(apkPath, async (tmpDir) => {
-        const dest = _path2.default.join(tmpDir, "obsidian.apk");
-        await downloadResponse(await fetch(apkUrl), dest);
-        return dest;
-      });
-    }
+      const dest = _path2.default.join(scratch, "obsidian.apk");
+      await downloadResponse(await fetch(apkUrl), dest);
+      return dest;
+    }, { replace: false });
     return apkPath;
   }
   /** Gets the latest version of a plugin. */
@@ -1063,23 +1081,21 @@ var ObsidianLauncher = class {
     }
     version = _semver2.default.valid(version);
     const pluginDir = _path2.default.join(this.cacheDir, "obsidian-plugins", repo, version);
-    if (!await fileExists(pluginDir)) {
-      await atomicCreate(pluginDir, async (tmpDir) => {
-        const assetsToDownload = { "manifest.json": true, "main.js": true, "styles.css": false };
-        await Promise.all(
-          Object.entries(assetsToDownload).map(async ([file, required]) => {
-            const url = `https://github.com/${repo}/releases/download/${version}/${file}`;
-            const response = await fetch(url);
-            if (response.ok) {
-              await downloadResponse(response, _path2.default.join(tmpDir, file));
-            } else if (required) {
-              throw Error(`No ${file} found for ${repo} version ${version}`);
-            }
-          })
-        );
-        return tmpDir;
-      });
-    }
+    await atomicCreate(pluginDir, async (scratch) => {
+      const assetsToDownload = { "manifest.json": true, "main.js": true, "styles.css": false };
+      await Promise.all(
+        Object.entries(assetsToDownload).map(async ([file, required]) => {
+          const url = `https://github.com/${repo}/releases/download/${version}/${file}`;
+          const response = await fetch(url);
+          if (response.ok) {
+            await downloadResponse(response, _path2.default.join(scratch, file));
+          } else if (required) {
+            throw Error(`No ${file} found for ${repo} version ${version}`);
+          }
+        })
+      );
+      return scratch;
+    }, { replace: false });
     return pluginDir;
   }
   /**
@@ -1231,31 +1247,29 @@ var ObsidianLauncher = class {
     }
     version = _semver2.default.valid(version);
     const themeDir = _path2.default.join(this.cacheDir, "obsidian-themes", repo, version);
-    if (!await fileExists(themeDir)) {
-      await atomicCreate(themeDir, async (tmpDir) => {
-        const assetsToDownload = ["manifest.json", "theme.css"];
-        let baseUrl = `https://github.com/${repo}/releases/download/${version}`;
-        if (!(await fetch(`${baseUrl}/manifest.json`)).ok) {
-          if (version != latest) {
-            throw Error(`No theme version "${version}" found`);
-          }
-          baseUrl = `https://raw.githubusercontent.com/${repo}/HEAD`;
+    await atomicCreate(themeDir, async (scratch) => {
+      const assetsToDownload = ["manifest.json", "theme.css"];
+      let baseUrl = `https://github.com/${repo}/releases/download/${version}`;
+      if (!(await fetch(`${baseUrl}/manifest.json`)).ok) {
+        if (version != latest) {
+          throw Error(`No theme version "${version}" found`);
         }
-        await Promise.all(
-          assetsToDownload.map(
-            async (file) => {
-              const url = `${baseUrl}/${file}`;
-              const response = await fetch(url);
-              if (response.ok) {
-                await downloadResponse(response, _path2.default.join(tmpDir, file));
-              } else {
-                throw Error(`No ${file} found for ${repo}`);
-              }
+        baseUrl = `https://raw.githubusercontent.com/${repo}/HEAD`;
+      }
+      await Promise.all(
+        assetsToDownload.map(
+          async (file) => {
+            const url = `${baseUrl}/${file}`;
+            const response = await fetch(url);
+            if (response.ok) {
+              await downloadResponse(response, _path2.default.join(scratch, file));
+            } else {
+              throw Error(`No ${file} found for ${repo}`);
             }
-          )
-        );
-      });
-    }
+          }
+        )
+      );
+    }, { replace: false });
     return themeDir;
   }
   /**
@@ -1501,16 +1515,16 @@ var ObsidianLauncher = class {
   async updateVersionList(original, opts = {}) {
     const { maxInstances = 1 } = opts;
     const [destkopReleases, commitInfo] = await fetchObsidianDesktopReleases(
-      _optionalChain([original, 'optionalAccess', _53 => _53.metadata, 'access', _54 => _54.commitDate]),
-      _optionalChain([original, 'optionalAccess', _55 => _55.metadata, 'access', _56 => _56.commitSha])
+      _optionalChain([original, 'optionalAccess', _62 => _62.metadata, 'access', _63 => _63.commitDate]),
+      _optionalChain([original, 'optionalAccess', _64 => _64.metadata, 'access', _65 => _65.commitSha])
     );
     const gitHubReleases = await fetchObsidianGitHubReleases();
     let newVersions = updateObsidianVersionList({
-      original: _optionalChain([original, 'optionalAccess', _57 => _57.versions]),
+      original: _optionalChain([original, 'optionalAccess', _66 => _66.versions]),
       destkopReleases,
       gitHubReleases
     });
-    const newInstallers = newVersions.flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => _optionalChain([v, 'access', _58 => _58.downloads, 'optionalAccess', _59 => _59[key]]) && !_optionalChain([v, 'access', _60 => _60.installers, 'optionalAccess', _61 => _61[key], 'optionalAccess', _62 => _62.chrome]));
+    const newInstallers = newVersions.flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => _optionalChain([v, 'access', _67 => _67.downloads, 'optionalAccess', _68 => _68[key]]) && !_optionalChain([v, 'access', _69 => _69.installers, 'optionalAccess', _70 => _70[key], 'optionalAccess', _71 => _71.chrome]));
     const installerInfos = await pool(maxInstances, newInstallers, async ([v, key]) => {
       const installerInfo = await extractInstallerInfo(key, v.downloads[key]);
       return { version: v.version, key, installerInfo };
@@ -1521,13 +1535,13 @@ var ObsidianLauncher = class {
         schemaVersion: obsidianVersionsSchemaVersion,
         commitDate: commitInfo.commitDate,
         commitSha: commitInfo.commitSha,
-        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _63 => _63.metadata, 'access', _64 => _64.timestamp]), () => ( ""))
+        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _72 => _72.metadata, 'access', _73 => _73.timestamp]), () => ( ""))
         // set down below
       },
       versions: newVersions
     };
     const dayMs = 24 * 60 * 60 * 1e3;
-    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _65 => _65.metadata, 'access', _66 => _66.timestamp]), () => ( 0))).getTime();
+    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _74 => _74.metadata, 'access', _75 => _75.timestamp]), () => ( 0))).getTime();
     if (!_lodash2.default.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
       result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
     }
@@ -1573,4 +1587,4 @@ var ObsidianLauncher = class {
 
 
 exports.watchFiles = watchFiles; exports.ObsidianLauncher = ObsidianLauncher;
-//# sourceMappingURL=chunk-BLHP5CDO.cjs.map
+//# sourceMappingURL=chunk-Z5EOC6TG.cjs.map