obsidian-launcher 2.0.0 → 2.0.2

package/dist/{chunk-KPNJCYO4.js → chunk-EVX5ML6K.js}

@@ -5,9 +5,9 @@ import path from "path";
 import os from "os";
 import { PromisePool } from "@supercharge/promise-pool";
 import _ from "lodash";
-async function fileExists(path5) {
+async function fileExists(path6) {
   try {
-    await fsAsync.access(path5);
+    await fsAsync.access(path6);
     return true;
   } catch {
     return false;
@@ -16,10 +16,11 @@ async function fileExists(path5) {
 async function makeTmpDir(prefix) {
   return fsAsync.mkdtemp(path.join(os.tmpdir(), prefix ?? "tmp-"));
 }
-async function atomicCreate(dest, func, options = {}) {
+async function atomicCreate(dest, func, opts = {}) {
   dest = path.resolve(dest);
   const createdParentDir = await fsAsync.mkdir(path.dirname(dest), { recursive: true });
   const tmpDir = await fsAsync.mkdtemp(path.join(path.dirname(dest), `.${path.basename(dest)}.tmp.`));
+  let success = false;
   try {
     let result = await func(tmpDir) ?? tmpDir;
     result = path.resolve(tmpDir, result);
@@ -30,13 +31,14 @@ async function atomicCreate(dest, func, options = {}) {
       await fsAsync.rename(dest, tmpDir + ".old");
     }
     await fsAsync.rename(result, dest);
-    await fsAsync.rm(tmpDir + ".old", { recursive: true, force: true });
-    await fsAsync.rm(tmpDir, { recursive: true, force: true });
-  } catch (e) {
-    if (!options.preserveTmpDir) {
+    success = true;
+  } finally {
+    if (success) {
+      await fsAsync.rm(tmpDir + ".old", { recursive: true, force: true });
+      await fsAsync.rm(tmpDir, { recursive: true, force: true });
+    } else if (!opts.preserveTmpDir) {
       await fsAsync.rm(createdParentDir ?? tmpDir, { recursive: true, force: true });
     }
-    throw e;
   }
 }
 async function linkOrCp(src, dest) {
@@ -47,6 +49,9 @@ async function linkOrCp(src, dest) {
     await fsAsync.copyFile(src, dest);
   }
 }
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function pool(size, items, func) {
   const { results } = await PromisePool.for(items).withConcurrency(size).handleError(async (error) => {
     throw error;
@@ -89,14 +94,15 @@ function normalizeObject(canonical, obj) {
 
 // src/launcher.ts
 import fsAsync4 from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 import crypto from "crypto";
 import extractZip from "extract-zip";
 import { downloadArtifact } from "@electron/get";
 import child_process2 from "child_process";
 import semver2 from "semver";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import dotenv from "dotenv";
+import _4 from "lodash";
+import dotenv2 from "dotenv";
 
 // src/types.ts
 var obsidianVersionsSchemaVersion = "2.0.0";
@@ -108,6 +114,9 @@ import { finished } from "stream/promises";
 import { Readable } from "stream";
 import fsAsync2 from "fs/promises";
 import readlineSync from "readline-sync";
+import dotenv from "dotenv";
+import path2 from "path";
+import { env } from "process";
 function parseLinkHeader(linkHeader) {
   function parseLinkData(linkData) {
     return Object.fromEntries(
@@ -141,7 +150,7 @@ function createURL(url, base, params = {}) {
 }
 async function fetchGitHubAPI(url, params = {}) {
   url = createURL(url, "https://api.github.com", params);
-  const token = process.env.GITHUB_TOKEN;
+  const token = env.GITHUB_TOKEN;
   const headers = token ? { Authorization: "Bearer " + token } : {};
   const response = await fetch(url, { headers });
   if (!response.ok) {
@@ -161,9 +170,9 @@ async function fetchGitHubAPIPaginated(url, params = {}) {
 }
 async function obsidianApiLogin(opts) {
   const { interactive = false, savePath } = opts;
-  let email = process.env.OBSIDIAN_EMAIL;
-  let password = process.env.OBSIDIAN_PASSWORD;
-  let mfa;
+  if (savePath) dotenv.config({ path: [savePath], quiet: true });
+  let email = env.OBSIDIAN_EMAIL;
+  let password = env.OBSIDIAN_PASSWORD;
   if (!email || !password) {
     if (interactive) {
       console.log("Obsidian Insiders account is required to download Obsidian beta versions.");
@@ -171,50 +180,53 @@ async function obsidianApiLogin(opts) {
       password = password || readlineSync.question("Obsidian password: ", { hideEchoBack: 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 is supported) or pre-download the Obsidian beta with `npx obsidian-launcher download -v <version>`"
+        "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 -v <version>`"
       );
     }
   }
-  const 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",
-    "Origin": "app://obsidian.md",
-    "Content-Type": "application/json"
-  };
-  let signin = await fetch("https://api.obsidian.md/user/signin", {
-    method: "post",
-    headers,
-    body: JSON.stringify({ email, password, mfa: "" })
-  }).then((r) => r.json());
-  if (signin.error && signin.error.includes("2FA")) {
-    if (interactive) {
-      mfa = await readlineSync.question("Obsidian 2FA: ");
-      signin = await fetch("https://api.obsidian.md/user/signin", {
-        method: "post",
-        headers,
-        body: JSON.stringify({ email, password, mfa })
-      }).then((r) => r.json());
-    } else {
-      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 -v <version>`"
-      );
+  let needsMfa = false;
+  let retries = 0;
+  let signin = void 0;
+  while (!signin?.token && retries < 3) {
+    if (retries > 0 || env.CI) {
+      await sleep(2 * Math.random() + retries * retries * 2);
+    }
+    let mfa = "";
+    if (needsMfa && interactive) {
+      mfa = readlineSync.question("Obsidian 2FA: ");
+    }
+    signin = 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",
+        "Origin": "app://obsidian.md",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ email, password, mfa })
+    }).then((r) => r.json());
+    const error = signin.error?.toLowerCase();
+    if (error?.includes("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 -v <version>`"
+        );
+      }
+    } else if (["please wait", "try again"].some((m) => error?.includes(m))) {
+      console.warn(`Obsidian login failed: ${signin.error}`);
+      retries++;
+    } else if (!signin.token) {
+      throw Error(`Obsidian login failed: ${signin.error ?? "unknown error"}`);
     }
   }
-  let error = void 0;
   if (!signin.token) {
-    error = Error(`Obsidian login failed: ${signin.error}`);
-  }
-  if (!error && !signin.license) {
-    error = Error("Obsidian Insiders account is required to download Obsidian beta versions");
-  }
-  if (error) {
-    if (savePath) {
-      await fsAsync2.rm(savePath, { force: true });
-    }
-    throw error;
+    throw Error(`Obsidian login failed: ${signin.error ?? "unknown error"}`);
+  } else if (!signin.license) {
+    throw Error("Obsidian Insiders account is required to download Obsidian beta versions");
   }
-  if (interactive && savePath && (!process.env.OBSIDIAN_EMAIL || !process.env.OBSIDIAN_PASSWORD)) {
-    const save = readlineSync.question("Save credentails to disk? [y/n]: ");
-    if (["y", "yes"].includes(save.toLocaleLowerCase())) {
+  if (interactive && savePath && (!env.OBSIDIAN_EMAIL || !env.OBSIDIAN_PASSWORD)) {
+    const save = readlineSync.question("Cache credentails to disk? [y/n]: ");
+    if (["y", "yes"].includes(save.toLowerCase())) {
       await fsAsync2.writeFile(
         savePath,
         `OBSIDIAN_EMAIL='${email}'
@@ -222,6 +234,7 @@ OBSIDIAN_PASSWORD='${password}'
 `
       );
     }
+    console.log(`Saved Obsidian credentials to ${path2.relative(process.cwd(), savePath)}`);
   }
   return signin.token;
 }
@@ -246,7 +259,7 @@ async function downloadResponse(response, dest) {
 }
 
 // src/chromeLocalStorage.ts
-import path2 from "path";
+import path3 from "path";
 import { ClassicLevel } from "classic-level";
 var ChromeLocalStorage = class {
   /** Pass the path to the user data dir for Chrome/Electron. If it doesn't exist it will be created. */
@@ -259,7 +272,7 @@ var ChromeLocalStorage = class {
     };
     this.encodeValue = (value) => `
${value}`;
     this.decodeValue = (value) => value.slice(1);
-    this.db = new ClassicLevel(path2.join(userDataDir, "Local Storage/leveldb/"));
+    this.db = new ClassicLevel(path3.join(userDataDir, "Local Storage/leveldb/"));
   }
   /**
    * Get a value from localStorage
@@ -324,7 +337,7 @@ var ChromeLocalStorage = class {
 // src/launcherUtils.ts
 import fsAsync3 from "fs/promises";
 import fs3 from "fs";
-import path3 from "path";
+import path4 from "path";
 import child_process from "child_process";
 import semver from "semver";
 import _3 from "lodash";
@@ -338,7 +351,7 @@ async function extractGz(archive, dest) {
   await pipeline(fs3.createReadStream(archive), zlib.createGunzip(), fs3.createWriteStream(dest));
 }
 async function sevenZ(args, options) {
-  const sevenZipScript = path3.resolve(fileURLToPath(import.meta.url), "../7z.js");
+  const sevenZipScript = path4.resolve(fileURLToPath(import.meta.url), "../7z.js");
   const proc = child_process.spawn(process.execPath, [sevenZipScript, ...args], {
     stdio: "pipe",
     ...options
@@ -358,13 +371,13 @@ ${stderr}`);
 }
 async function extractObsidianAppImage(appImage, dest) {
   await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-o.", path3.relative(tmpDir, appImage)], { cwd: tmpDir });
+    await sevenZ(["x", "-o.", path4.relative(tmpDir, appImage)], { cwd: tmpDir });
     return tmpDir;
   });
 }
 async function extractObsidianTar(tar, dest) {
   await atomicCreate(dest, async (tmpDir) => {
-    await extractGz(tar, path3.join(tmpDir, "inflated.tar"));
+    await extractGz(tar, path4.join(tmpDir, "inflated.tar"));
     await sevenZ(["x", "-o.", "inflated.tar"], { cwd: tmpDir });
     return (await fsAsync3.readdir(tmpDir)).find((p) => p.match("obsidian-"));
   });
@@ -381,20 +394,20 @@ async function extractObsidianExe(exe, arch, dest) {
     throw Error(`No Obsidian installer found for ${process.platform} ${process.arch}`);
   }
   await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-oinstaller", path3.relative(tmpDir, exe), subArchive], { cwd: tmpDir });
-    await sevenZ(["x", "-oobsidian", path3.join("installer", subArchive)], { cwd: tmpDir });
+    await sevenZ(["x", "-oinstaller", path4.relative(tmpDir, exe), subArchive], { cwd: tmpDir });
+    await sevenZ(["x", "-oobsidian", path4.join("installer", subArchive)], { cwd: tmpDir });
     return "obsidian";
   });
 }
 async function extractObsidianDmg(dmg, dest) {
-  dest = path3.resolve(dest);
+  dest = path4.resolve(dest);
   await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-o.", path3.relative(tmpDir, dmg), "*/Obsidian.app", "Obsidian.app"], { cwd: tmpDir });
+    await sevenZ(["x", "-o.", path4.relative(tmpDir, dmg), "*/Obsidian.app", "Obsidian.app"], { cwd: tmpDir });
     const files = await fsAsync3.readdir(tmpDir);
     if (files.includes("Obsidian.app")) {
       return "Obsidian.app";
     } else {
-      return path3.join(files[0], "Obsidian.app");
+      return path4.join(files[0], "Obsidian.app");
     }
   });
 }
@@ -473,9 +486,9 @@ async function getInstallerInfo(installerKey, url) {
   console.log(`Extrating installer info for ${installerName}...`);
   const tmpDir = await makeTmpDir("obsidian-launcher-");
   try {
-    const installerPath = path3.join(tmpDir, url.split("/").at(-1));
+    const installerPath = path4.join(tmpDir, url.split("/").at(-1));
     await downloadResponse(await fetch(url), installerPath);
-    const exractedPath = path3.join(tmpDir, "Obsidian");
+    const exractedPath = path4.join(tmpDir, "Obsidian");
     let platforms = [];
     if (installerKey == "appImage" || installerKey == "appImageArm") {
       await extractObsidianAppImage(installerPath, exractedPath);
@@ -485,7 +498,7 @@ async function getInstallerInfo(installerKey, url) {
       platforms = ["linux-" + (installerKey == "tar" ? "x64" : "arm64")];
     } else if (installerKey == "exe") {
       await extractObsidianExe(installerPath, "x64", exractedPath);
-      const { stdout } = await sevenZ(["l", "-ba", path3.relative(tmpDir, installerPath)], { cwd: tmpDir });
+      const { stdout } = await sevenZ(["l", "-ba", path4.relative(tmpDir, installerPath)], { cwd: tmpDir });
       const lines = stdout.trim().split("\n").map((l) => l.trim());
       const files = lines.map((l) => l.split(/\s+/).at(-1).replace(/\\/g, "/"));
       if (files.includes("$PLUGINSDIR/app-arm64.7z")) platforms.push("win32-arm64");
@@ -501,7 +514,7 @@ async function getInstallerInfo(installerKey, url) {
     const installerFiles = await fsAsync3.readdir(exractedPath, { recursive: true, withFileTypes: true });
     for (const file of installerFiles) {
       if (file.isFile() && !file.name.endsWith(".asar")) {
-        const stream = fs3.createReadStream(path3.join(file.parentPath, file.name), { encoding: "utf-8" });
+        const stream = fs3.createReadStream(path4.join(file.parentPath, file.name), { encoding: "utf-8" });
         let prev = "";
         for await (let chunk of stream) {
           const regex = /Chrome\/\d+\.\d+\.\d+\.\d+|Electron\/\d+\.\d+\.\d+/g;
@@ -525,12 +538,11 @@ async function getInstallerInfo(installerKey, url) {
   }
 }
 function normalizeObsidianVersionInfo(versionInfo) {
-  versionInfo = {
-    ...versionInfo,
-    // kept for backwards compatibility
-    electronVersion: versionInfo.installers?.appImage?.electron,
-    chromeVersion: versionInfo.installers?.appImage?.chrome
-  };
+  versionInfo = _3.cloneDeep(versionInfo);
+  versionInfo.electronVersion = versionInfo.installers?.appImage?.electron;
+  versionInfo.chromeVersion = versionInfo.installers?.appImage?.chrome;
+  versionInfo.downloads = versionInfo.downloads ?? {};
+  versionInfo.installers = versionInfo.installers ?? {};
   const canonicalForm = {
     version: null,
     minInstallerVersion: null,
@@ -562,11 +574,11 @@ function normalizeObsidianVersionInfo(versionInfo) {
 }
 
 // src/launcher.ts
-import _4 from "lodash";
 var currentPlatform = {
   platform: process.platform,
   arch: process.arch
 };
+dotenv2.config({ path: [".env"], quiet: true });
 var ObsidianLauncher = class {
   /**
    * Construct an ObsidianLauncher.
@@ -579,7 +591,7 @@ var ObsidianLauncher = class {
    */
   constructor(opts = {}) {
     this.interactive = false;
-    this.cacheDir = path4.resolve(opts.cacheDir ?? process.env.OBSIDIAN_CACHE ?? "./.obsidian-cache");
+    this.cacheDir = path5.resolve(opts.cacheDir ?? process.env.OBSIDIAN_CACHE ?? "./.obsidian-cache");
     const defaultVersionsUrl = "https://raw.githubusercontent.com/jesse-r-s-hines/wdio-obsidian-service/HEAD/obsidian-versions.json";
     this.versionsUrl = opts.versionsUrl ?? defaultVersionsUrl;
     const defaultCommunityPluginsUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
@@ -589,10 +601,6 @@ var ObsidianLauncher = class {
     this.cacheDuration = opts.cacheDuration ?? 30 * 60 * 1e3;
     this.interactive = opts.interactive ?? false;
     this.metadataCache = {};
-    dotenv.config({
-      path: [".env", path4.join(this.cacheDir, "obsidian-credentials.env")],
-      quiet: true
-    });
   }
   /**
    * Returns file content fetched from url as JSON. Caches content to dest and uses that cache if its more recent than
@@ -600,7 +608,7 @@ var ObsidianLauncher = class {
    */
   async cachedFetch(url, dest, cacheValid) {
     cacheValid = cacheValid ?? (() => true);
-    dest = path4.join(this.cacheDir, dest);
+    dest = path5.join(this.cacheDir, dest);
     if (!(dest in this.metadataCache)) {
       let data;
       let error;
@@ -623,8 +631,8 @@ var ObsidianLauncher = class {
         }));
         if (response.success) {
           await atomicCreate(dest, async (tmpDir) => {
-            await fsAsync4.writeFile(path4.join(tmpDir, "download.json"), response.result);
-            return path4.join(tmpDir, "download.json");
+            await fsAsync4.writeFile(path5.join(tmpDir, "download.json"), response.result);
+            return path5.join(tmpDir, "download.json");
           });
           data = JSON.parse(response.result);
         } else {
@@ -651,12 +659,12 @@ var ObsidianLauncher = class {
    */
   async getRootManifest() {
     if (!("manifest.json" in this.metadataCache)) {
-      const root = path4.parse(process.cwd()).root;
+      const root = path5.parse(process.cwd()).root;
       let dir = process.cwd();
-      while (dir != root && !await fileExists(path4.join(dir, "manifest.json"))) {
-        dir = path4.dirname(dir);
+      while (dir != root && !await fileExists(path5.join(dir, "manifest.json"))) {
+        dir = path5.dirname(dir);
       }
-      const manifestPath = path4.join(dir, "manifest.json");
+      const manifestPath = path5.join(dir, "manifest.json");
       if (await fileExists(manifestPath)) {
         this.metadataCache["manifest.json"] = JSON.parse(await fsAsync4.readFile(manifestPath, "utf-8"));
       } else {
@@ -779,12 +787,12 @@ var ObsidianLauncher = class {
    * @returns [appVersion, installerVersion][] resolved to specific versions.
    */
   async parseVersions(versions) {
-    let parsedVersions = versions.split(/[ ,]/).filter((v) => v).map((v) => {
+    const parsedVersions = versions.split(/[ ,]/).filter((v) => v).map((v) => {
       const [appVersion, installerVersion = "earliest"] = v.split("/");
       return [appVersion, installerVersion];
     });
-    let resolvedVersions = [];
-    for (let [appVersion, installerVersion] of parsedVersions) {
+    const resolvedVersions = [];
+    for (const [appVersion, installerVersion] of parsedVersions) {
       resolvedVersions.push(await this.resolveVersion(appVersion, installerVersion));
     }
     return _4.uniqBy(resolvedVersions, (v) => v.join("/"));
@@ -825,17 +833,17 @@ var ObsidianLauncher = class {
     const versionInfo = await this.getVersionInfo(installerVersion);
     installerVersion = versionInfo.version;
     const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
-    const cacheDir = path4.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
+    const cacheDir = path5.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
     let binaryPath;
     let extractor;
     if (platform == "linux") {
-      binaryPath = path4.join(cacheDir, "obsidian");
+      binaryPath = path5.join(cacheDir, "obsidian");
       extractor = (installer, dest) => extractObsidianAppImage(installer, dest);
     } else if (platform == "win32") {
-      binaryPath = path4.join(cacheDir, "Obsidian.exe");
+      binaryPath = path5.join(cacheDir, "Obsidian.exe");
       extractor = (installer, dest) => extractObsidianExe(installer, arch, dest);
     } else if (platform == "darwin") {
-      binaryPath = path4.join(cacheDir, "Contents/MacOS/Obsidian");
+      binaryPath = path5.join(cacheDir, "Contents/MacOS/Obsidian");
       extractor = (installer, dest) => extractObsidianDmg(installer, dest);
     } else {
       throw Error(`Unsupported platform ${platform}`);
@@ -843,9 +851,9 @@ var ObsidianLauncher = class {
     if (!await fileExists(binaryPath)) {
       console.log(`Downloading Obsidian installer v${installerVersion}...`);
       await atomicCreate(cacheDir, async (tmpDir) => {
-        const installer = path4.join(tmpDir, "installer");
+        const installer = path5.join(tmpDir, "installer");
         await downloadResponse(await fetch(installerInfo.url), installer);
-        const extracted = path4.join(tmpDir, "extracted");
+        const extracted = path5.join(tmpDir, "extracted");
         await extractor(installer, extracted);
         return extracted;
       });
@@ -855,9 +863,9 @@ var ObsidianLauncher = class {
   /**
    * Downloads the Obsidian asar for the given version. Returns the file path.
    * 
-   * To download Obsidian beta versions you'll need have an Obsidian Insiders account and either set the 
-   * `OBSIDIAN_EMAIL` and `OBSIDIAN_PASSWORD` env vars (`.env` is supported) or pre-download the Obsidian beta with
-   * `npx obsidian-launcher download -v latest-beta`
+   * To download Obsidian beta versions you'll need to have an Obsidian Insiders account and 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 -v latest-beta`
    * 
    * @param appVersion Obsidian version to download
    */
@@ -867,7 +875,7 @@ var ObsidianLauncher = class {
     if (!appUrl) {
       throw Error(`No asar found for Obsidian version ${appVersion}`);
     }
-    const appPath = path4.join(this.cacheDir, "obsidian-app", `obsidian-${versionInfo.version}.asar`);
+    const appPath = path5.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) => {
@@ -877,15 +885,15 @@ var ObsidianLauncher = class {
           if (!this.obsidianApiToken) {
             this.obsidianApiToken = await obsidianApiLogin({
               interactive: this.interactive,
-              savePath: path4.join(this.cacheDir, "obsidian-credentials.env")
+              savePath: path5.join(this.cacheDir, "obsidian-credentials.env")
             });
           }
           response = await fetchObsidianApi(appUrl, { token: this.obsidianApiToken });
         } else {
           response = await fetch(appUrl);
         }
-        const archive = path4.join(tmpDir, "app.asar.gz");
-        const asar = path4.join(tmpDir, "app.asar");
+        const archive = path5.join(tmpDir, "app.asar.gz");
+        const asar = path5.join(tmpDir, "app.asar");
         await downloadResponse(response, archive);
         await extractGz(archive, asar);
         return asar;
@@ -907,12 +915,12 @@ var ObsidianLauncher = class {
   async downloadChromedriver(installerVersion, opts = {}) {
     const { platform, arch } = _4.merge({}, opts, currentPlatform);
     const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
-    const cacheDir = path4.join(this.cacheDir, `electron-chromedriver/${platform}-${arch}/${installerInfo.electron}`);
+    const cacheDir = path5.join(this.cacheDir, `electron-chromedriver/${platform}-${arch}/${installerInfo.electron}`);
     let chromedriverPath;
     if (process.platform == "win32") {
-      chromedriverPath = path4.join(cacheDir, `chromedriver.exe`);
+      chromedriverPath = path5.join(cacheDir, `chromedriver.exe`);
     } else {
-      chromedriverPath = path4.join(cacheDir, `chromedriver`);
+      chromedriverPath = path5.join(cacheDir, `chromedriver`);
     }
     if (!await fileExists(chromedriverPath)) {
       console.log(`Downloading chromedriver for electron ${installerInfo.electron} ...`);
@@ -920,9 +928,9 @@ var ObsidianLauncher = class {
         const chromedriverZipPath = await downloadArtifact({
           version: installerInfo.electron,
           artifactName: "chromedriver",
-          cacheRoot: path4.join(tmpDir, "download")
+          cacheRoot: path5.join(tmpDir, "download")
         });
-        const extracted = path4.join(tmpDir, "extracted");
+        const extracted = path5.join(tmpDir, "extracted");
         await extractZip(chromedriverZipPath, { dir: extracted });
         return extracted;
       });
@@ -940,11 +948,11 @@ var ObsidianLauncher = class {
         `No apk found for Obsidian version ${version}` + (versionInfo.isBeta ? ` (${version} is a beta version)` : "")
       );
     }
-    const apkPath = path4.join(this.cacheDir, "obsidian-apk", `obsidian-${versionInfo.version}.apk`);
+    const apkPath = path5.join(this.cacheDir, "obsidian-apk", `obsidian-${versionInfo.version}.apk`);
     if (!await fileExists(apkPath)) {
       console.log(`Downloading Obsidian apk v${versionInfo.version} ...`);
       await atomicCreate(apkPath, async (tmpDir) => {
-        const dest = path4.join(tmpDir, "obsidian.apk");
+        const dest = path5.join(tmpDir, "obsidian.apk");
         await downloadResponse(await fetch(apkUrl), dest);
         return dest;
       });
@@ -955,7 +963,7 @@ var ObsidianLauncher = class {
   async getLatestPluginVersion(repo) {
     repo = normalizeGitHubRepo(repo);
     const manifestUrl = `https://raw.githubusercontent.com/${repo}/HEAD/manifest.json`;
-    const cacheDest = path4.join("obsidian-plugins", repo, "latest.json");
+    const cacheDest = path5.join("obsidian-plugins", repo, "latest.json");
     const manifest = await this.cachedFetch(manifestUrl, cacheDest);
     return manifest.version;
   }
@@ -974,7 +982,7 @@ var ObsidianLauncher = class {
       throw Error(`Invalid version "${version}"`);
     }
     version = semver2.valid(version);
-    const pluginDir = path4.join(this.cacheDir, "obsidian-plugins", repo, version);
+    const pluginDir = path5.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 };
@@ -983,7 +991,7 @@ var ObsidianLauncher = class {
             const url = `https://github.com/${repo}/releases/download/${version}/${file}`;
             const response = await fetch(url);
             if (response.ok) {
-              await downloadResponse(response, path4.join(tmpDir, file));
+              await downloadResponse(response, path5.join(tmpDir, file));
             } else if (required) {
               throw Error(`No ${file} found for ${repo} version ${version}`);
             }
@@ -1026,11 +1034,11 @@ var ObsidianLauncher = class {
         let pluginPath;
         let originalType;
         if (typeof plugin == "string") {
-          pluginPath = path4.resolve(plugin);
+          pluginPath = path5.resolve(plugin);
           originalType = "local";
         } else if ("path" in plugin) {
           ;
-          pluginPath = path4.resolve(plugin.path);
+          pluginPath = path5.resolve(plugin.path);
           originalType = "local";
         } else if ("repo" in plugin) {
           pluginPath = await this.downloadGitHubPlugin(plugin.repo, plugin.version);
@@ -1041,7 +1049,7 @@ var ObsidianLauncher = class {
         } else {
           throw Error("You must specify one of plugin path, repo, or id");
         }
-        const manifestPath = path4.join(pluginPath, "manifest.json");
+        const manifestPath = path5.join(pluginPath, "manifest.json");
         if (!await fileExists(manifestPath)) {
           throw Error(`No plugin found at ${pluginPath}`);
         }
@@ -1052,7 +1060,7 @@ var ObsidianLauncher = class {
             throw Error(`${manifestPath} malformed.`);
           }
         }
-        if (!await fileExists(path4.join(pluginPath, "main.js"))) {
+        if (!await fileExists(path5.join(pluginPath, "main.js"))) {
           throw Error(`No main.js found under ${pluginPath}`);
         }
         let enabled;
@@ -1069,7 +1077,7 @@ var ObsidianLauncher = class {
   async getLatestThemeVersion(repo) {
     repo = normalizeGitHubRepo(repo);
     const manifestUrl = `https://raw.githubusercontent.com/${repo}/HEAD/manifest.json`;
-    const cacheDest = path4.join("obsidian-themes", repo, "latest.json");
+    const cacheDest = path5.join("obsidian-themes", repo, "latest.json");
     const manifest = await this.cachedFetch(manifestUrl, cacheDest);
     return manifest.version;
   }
@@ -1081,7 +1089,7 @@ var ObsidianLauncher = class {
   async downloadGitHubTheme(repo) {
     repo = normalizeGitHubRepo(repo);
     const version = await this.getLatestThemeVersion(repo);
-    const themeDir = path4.join(this.cacheDir, "obsidian-themes", repo, version);
+    const themeDir = path5.join(this.cacheDir, "obsidian-themes", repo, version);
     if (!await fileExists(themeDir)) {
       await atomicCreate(themeDir, async (tmpDir) => {
         const assetsToDownload = ["manifest.json", "theme.css"];
@@ -1090,7 +1098,7 @@ var ObsidianLauncher = class {
             const url = `https://raw.githubusercontent.com/${repo}/HEAD/${file}`;
             const response = await fetch(url);
             if (response.ok) {
-              await downloadResponse(response, path4.join(tmpDir, file));
+              await downloadResponse(response, path5.join(tmpDir, file));
             } else {
               throw Error(`No ${file} found for ${repo}`);
             }
@@ -1132,11 +1140,11 @@ var ObsidianLauncher = class {
         let themePath;
         let originalType;
         if (typeof theme == "string") {
-          themePath = path4.resolve(theme);
+          themePath = path5.resolve(theme);
           originalType = "local";
         } else if ("path" in theme) {
           ;
-          themePath = path4.resolve(theme.path);
+          themePath = path5.resolve(theme.path);
           originalType = "local";
         } else if ("repo" in theme) {
           themePath = await this.downloadGitHubTheme(theme.repo);
@@ -1147,19 +1155,19 @@ var ObsidianLauncher = class {
         } else {
           throw Error("You must specify one of theme path, repo, or name");
         }
-        const manifestPath = path4.join(themePath, "manifest.json");
+        const manifestPath = path5.join(themePath, "manifest.json");
         if (!await fileExists(manifestPath)) {
           throw Error(`No theme found at ${themePath}`);
         }
         let themeName = typeof theme == "object" && "name" in theme ? theme.name : void 0;
         if (!themeName) {
-          const manifestPath2 = path4.join(themePath, "manifest.json");
+          const manifestPath2 = path5.join(themePath, "manifest.json");
           themeName = JSON.parse(await fsAsync4.readFile(manifestPath2, "utf8").catch(() => "{}")).name;
           if (!themeName) {
             throw Error(`${themePath}/manifest.json malformed.`);
           }
         }
-        if (!await fileExists(path4.join(themePath, "theme.css"))) {
+        if (!await fileExists(path5.join(themePath, "theme.css"))) {
           throw Error(`No theme.css found under ${themePath}`);
         }
         let enabled;
@@ -1179,21 +1187,21 @@ var ObsidianLauncher = class {
    */
   async installPlugins(vault, plugins) {
     const downloadedPlugins = await this.downloadPlugins(plugins);
-    const obsidianDir = path4.join(vault, ".obsidian");
+    const obsidianDir = path5.join(vault, ".obsidian");
     await fsAsync4.mkdir(obsidianDir, { recursive: true });
-    const enabledPluginsPath = path4.join(obsidianDir, "community-plugins.json");
+    const enabledPluginsPath = path5.join(obsidianDir, "community-plugins.json");
     let originalEnabledPlugins = [];
     if (await fileExists(enabledPluginsPath)) {
       originalEnabledPlugins = JSON.parse(await fsAsync4.readFile(enabledPluginsPath, "utf-8"));
     }
     let enabledPlugins = [...originalEnabledPlugins];
     for (const { path: pluginPath, enabled = true, originalType } of downloadedPlugins) {
-      const manifestPath = path4.join(pluginPath, "manifest.json");
+      const manifestPath = path5.join(pluginPath, "manifest.json");
       const pluginId = JSON.parse(await fsAsync4.readFile(manifestPath, "utf8").catch(() => "{}")).id;
       if (!pluginId) {
         throw Error(`${manifestPath} missing or malformed.`);
       }
-      const pluginDest = path4.join(obsidianDir, "plugins", pluginId);
+      const pluginDest = path5.join(obsidianDir, "plugins", pluginId);
       await fsAsync4.mkdir(pluginDest, { recursive: true });
       const files = {
         "manifest.json": [true, true],
@@ -1202,12 +1210,12 @@ var ObsidianLauncher = class {
         "data.json": [false, false]
       };
       for (const [file, [required, deleteIfMissing]] of Object.entries(files)) {
-        if (await fileExists(path4.join(pluginPath, file))) {
-          await linkOrCp(path4.join(pluginPath, file), path4.join(pluginDest, file));
+        if (await fileExists(path5.join(pluginPath, file))) {
+          await linkOrCp(path5.join(pluginPath, file), path5.join(pluginDest, file));
         } else if (required) {
           throw Error(`${pluginPath}/${file} missing.`);
         } else if (deleteIfMissing) {
-          await fsAsync4.rm(path4.join(pluginDest, file), { force: true });
+          await fsAsync4.rm(path5.join(pluginDest, file), { force: true });
         }
       }
       const pluginAlreadyListed = enabledPlugins.includes(pluginId);
@@ -1217,7 +1225,7 @@ var ObsidianLauncher = class {
         enabledPlugins = enabledPlugins.filter((p) => p != pluginId);
       }
       if (originalType == "local") {
-        await fsAsync4.writeFile(path4.join(pluginDest, ".hotreload"), "");
+        await fsAsync4.writeFile(path5.join(pluginDest, ".hotreload"), "");
       }
     }
     if (!_4.isEqual(enabledPlugins, originalEnabledPlugins)) {
@@ -1231,12 +1239,12 @@ var ObsidianLauncher = class {
    */
   async installThemes(vault, themes) {
     const downloadedThemes = await this.downloadThemes(themes);
-    const obsidianDir = path4.join(vault, ".obsidian");
+    const obsidianDir = path5.join(vault, ".obsidian");
     await fsAsync4.mkdir(obsidianDir, { recursive: true });
     let enabledTheme = void 0;
     for (const { path: themePath, enabled = true } of downloadedThemes) {
-      const manifestPath = path4.join(themePath, "manifest.json");
-      const cssPath = path4.join(themePath, "theme.css");
+      const manifestPath = path5.join(themePath, "manifest.json");
+      const cssPath = path5.join(themePath, "theme.css");
       const themeName = JSON.parse(await fsAsync4.readFile(manifestPath, "utf8").catch(() => "{}")).name;
       if (!themeName) {
         throw Error(`${manifestPath} missing or malformed.`);
@@ -1244,10 +1252,10 @@ var ObsidianLauncher = class {
       if (!await fileExists(cssPath)) {
         throw Error(`${cssPath} missing.`);
       }
-      const themeDest = path4.join(obsidianDir, "themes", themeName);
+      const themeDest = path5.join(obsidianDir, "themes", themeName);
       await fsAsync4.mkdir(themeDest, { recursive: true });
-      await linkOrCp(manifestPath, path4.join(themeDest, "manifest.json"));
-      await linkOrCp(cssPath, path4.join(themeDest, "theme.css"));
+      await linkOrCp(manifestPath, path5.join(themeDest, "manifest.json"));
+      await linkOrCp(cssPath, path5.join(themeDest, "theme.css"));
       if (enabledTheme && enabled) {
         throw Error("You can only have one enabled theme.");
       } else if (enabled) {
@@ -1255,7 +1263,7 @@ var ObsidianLauncher = class {
       }
     }
     if (themes.length > 0) {
-      const appearancePath = path4.join(obsidianDir, "appearance.json");
+      const appearancePath = path5.join(obsidianDir, "appearance.json");
       let appearance = {};
       if (await fileExists(appearancePath)) {
         appearance = JSON.parse(await fsAsync4.readFile(appearancePath, "utf-8"));
@@ -1301,20 +1309,20 @@ var ObsidianLauncher = class {
       Object.assign(obsidianJson, {
         vaults: {
           [vaultId]: {
-            path: path4.resolve(params.vault),
+            path: path5.resolve(params.vault),
             ts: (/* @__PURE__ */ new Date()).getTime(),
             open: true
           }
         }
       });
     }
-    await fsAsync4.writeFile(path4.join(configDir, "obsidian.json"), JSON.stringify(obsidianJson));
-    await fsAsync4.writeFile(path4.join(configDir, "Preferences"), JSON.stringify(chromePreferences));
+    await fsAsync4.writeFile(path5.join(configDir, "obsidian.json"), JSON.stringify(obsidianJson));
+    await fsAsync4.writeFile(path5.join(configDir, "Preferences"), JSON.stringify(chromePreferences));
     let appPath = params.appPath;
     if (!appPath) {
       appPath = await this.downloadApp(appVersion);
     }
-    await linkOrCp(appPath, path4.join(configDir, path4.basename(appPath)));
+    await linkOrCp(appPath, path5.join(configDir, path5.basename(appPath)));
     const localStorage = new ChromeLocalStorage(configDir);
     await localStorage.setItems("app://obsidian.md", localStorageData);
     await localStorage.close();
@@ -1332,7 +1340,7 @@ var ObsidianLauncher = class {
   async setupVault(params) {
     let vault = params.vault;
     if (params.copy) {
-      const dest = await makeTmpDir(`${path4.basename(vault)}-`);
+      const dest = await makeTmpDir(`${path5.basename(vault)}-`);
       await fsAsync4.cp(vault, dest, { recursive: true, preserveTimestamps: true });
       vault = dest;
     }
@@ -1482,7 +1490,7 @@ var ObsidianLauncher = class {
       const { platform, arch } = process;
       dest = `obsidian-installer/${platform}-${arch}/Obsidian-${version}`;
     }
-    return await fileExists(path4.join(this.cacheDir, dest));
+    return await fileExists(path5.join(this.cacheDir, dest));
   }
   /**
    * Returns true if we either have the credentials to download the version or it's already in cache.
@@ -1508,4 +1516,4 @@ export {
   watchFiles,
   ObsidianLauncher
 };
-//# sourceMappingURL=chunk-KPNJCYO4.js.map
+//# sourceMappingURL=chunk-EVX5ML6K.js.map