obsidian-launcher 1.3.2 → 2.0.0

package/dist/{chunk-CUFVRSMT.cjs → chunk-KQZZMJOZ.cjs}

@@ -1,19 +1,11 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/launcher.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } async function _asyncOptionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkQQJCBP4Ncjs = require('./chunk-QQJCBP4N.cjs');
+
+// src/utils.ts
 var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
 var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
-var _zlib = require('zlib'); var _zlib2 = _interopRequireDefault(_zlib);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
-var _extractzip = require('extract-zip'); var _extractzip2 = _interopRequireDefault(_extractzip);
-var _promises3 = require('stream/promises');
-var _get = require('@electron/get');
-var _child_process = require('child_process'); var _child_process2 = _interopRequireDefault(_child_process);
-var _semver = require('semver'); var _semver2 = _interopRequireDefault(_semver);
-var _url = require('url');
-
-// src/utils.ts
-
-
 var _os = require('os'); var _os2 = _interopRequireDefault(_os);
 var _promisepool = require('@supercharge/promise-pool');
 var _lodash = require('lodash'); var _lodash2 = _interopRequireDefault(_lodash);
@@ -28,14 +20,14 @@ async function fileExists(path5) {
 async function makeTmpDir(prefix) {
   return _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), _nullishCoalesce(prefix, () => ( "tmp-"))));
 }
-async function withTmpDir(dest, func) {
+async function atomicCreate(dest, func, options = {}) {
   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.`));
   try {
     let result = await _asyncNullishCoalesce(await func(tmpDir), async () => ( tmpDir));
-    if (!_path2.default.isAbsolute(result)) {
-      result = _path2.default.join(tmpDir, result);
-    } else if (!_path2.default.resolve(result).startsWith(tmpDir)) {
+    result = _path2.default.resolve(tmpDir, result);
+    if (!result.startsWith(tmpDir)) {
       throw new Error(`Returned path ${result} not under tmpDir`);
     }
     if (await fileExists(dest) && (await _promises2.default.stat(dest)).isDirectory()) {
@@ -43,28 +35,22 @@ async function withTmpDir(dest, func) {
     }
     await _promises2.default.rename(result, dest);
     await _promises2.default.rm(tmpDir + ".old", { recursive: true, force: true });
-  } finally {
     await _promises2.default.rm(tmpDir, { recursive: true, force: true });
+  } catch (e) {
+    if (!options.preserveTmpDir) {
+      await _promises2.default.rm(_nullishCoalesce(createdParentDir, () => ( tmpDir)), { 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) {
     await _promises2.default.copyFile(src, dest);
   }
 }
-async function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withTimeout(promise, timeout) {
-  let timer;
-  const result = Promise.race([
-    promise,
-    new Promise((resolve, reject) => timer = setTimeout(() => reject(Error("Promise timed out")), timeout))
-  ]);
-  return result.finally(() => clearTimeout(timer));
-}
 async function pool(size, items, func) {
   const { results } = await _promisepool.PromisePool.for(items).withConcurrency(size).handleError(async (error) => {
     throw error;
@@ -74,23 +60,58 @@ async function pool(size, items, func) {
 async function maybe(promise) {
   return promise.then((r) => ({ success: true, result: r, error: void 0 })).catch((e) => ({ success: false, result: void 0, error: e }));
 }
-function mergeKeepUndefined(object, ...sources) {
-  return _lodash2.default.mergeWith(
-    object,
-    ...sources,
-    (objValue, srcValue, key, obj) => {
-      if (_lodash2.default.isPlainObject(obj) && objValue !== srcValue && srcValue === void 0) {
-        obj[key] = srcValue;
+function watchFiles(files, func, options) {
+  const debouncedFunc = _lodash2.default.debounce((curr, prev) => {
+    if (curr.mtimeMs > prev.mtimeMs || curr.mtimeMs == 0 && prev.mtimeMs != 0) {
+      func(curr, prev);
+    }
+  }, options.debounce);
+  for (const file of files) {
+    _fs2.default.watchFile(file, { interval: options.interval, persistent: options.persistent }, debouncedFunc);
+  }
+}
+function normalizeObject(canonical, obj) {
+  const rootCanonical = canonical, rootObj = obj;
+  function helper(canonical2, obj2) {
+    if (_lodash2.default.isPlainObject(canonical2)) {
+      if (_lodash2.default.isPlainObject(obj2)) {
+        obj2 = _lodash2.default.pick(obj2, Object.keys(canonical2));
+        obj2 = _lodash2.default.mapValues(obj2, (v, k) => helper(canonical2[k], v));
+        obj2 = _lodash2.default.omitBy(obj2, (v) => v === void 0);
+        return obj2;
+      } else {
+        return obj2;
       }
+    } else if (canonical2 === null) {
+      return obj2;
+    } else {
+      throw Error(`Invalid canonical form ${JSON.stringify(rootCanonical)}`);
     }
-  );
+  }
+  return helper(rootCanonical, rootObj);
 }
 
-// src/apis.ts
+// src/launcher.ts
+
+
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var _extractzip = require('extract-zip'); var _extractzip2 = _interopRequireDefault(_extractzip);
+var _get = require('@electron/get');
+var _child_process = require('child_process'); var _child_process2 = _interopRequireDefault(_child_process);
+var _semver = require('semver'); var _semver2 = _interopRequireDefault(_semver);
+var _url = require('url');
+var _dotenv = require('dotenv'); var _dotenv2 = _interopRequireDefault(_dotenv);
+
+// src/types.ts
+var obsidianVersionsSchemaVersion = "2.0.0";
 
+// src/apis.ts
 
 
+var _promises3 = require('stream/promises');
 var _stream = require('stream');
+
+var _readlinesync = require('readline-sync'); var _readlinesync2 = _interopRequireDefault(_readlinesync);
 function parseLinkHeader(linkHeader) {
   function parseLinkData(linkData) {
     return Object.fromEntries(
@@ -130,7 +151,7 @@ async function fetchGitHubAPI(url, params = {}) {
   if (!response.ok) {
     throw new Error(`GitHub API error: ${await response.text()}`);
   }
-  return await response;
+  return response;
 }
 async function fetchGitHubAPIPaginated(url, params = {}) {
   const results = [];
@@ -142,24 +163,87 @@ async function fetchGitHubAPIPaginated(url, params = {}) {
   }
   return results;
 }
-async function fetchObsidianAPI(url) {
-  url = createURL(url, "https://releases.obsidian.md");
-  const username = process.env.OBSIDIAN_USERNAME;
-  const password = process.env.OBSIDIAN_PASSWORD;
-  if (!username || !password) {
-    throw Error("OBSIDIAN_USERNAME or OBSIDIAN_PASSWORD environment variables are required to access the Obsidian API for beta versions.");
+async function obsidianApiLogin(opts) {
+  const { interactive = false, savePath } = opts;
+  let email = process.env.OBSIDIAN_EMAIL;
+  let password = process.env.OBSIDIAN_PASSWORD;
+  let mfa;
+  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 });
+    } 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>`"
+      );
+    }
   }
+  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 _readlinesync2.default.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 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 _promises2.default.rm(savePath, { force: true });
+    }
+    throw error;
+  }
+  if (interactive && savePath && (!process.env.OBSIDIAN_EMAIL || !process.env.OBSIDIAN_PASSWORD)) {
+    const save = _readlinesync2.default.question("Save credentails to disk? [y/n]: ");
+    if (["y", "yes"].includes(save.toLocaleLowerCase())) {
+      await _promises2.default.writeFile(
+        savePath,
+        `OBSIDIAN_EMAIL='${email}'
+OBSIDIAN_PASSWORD='${password}'
+`
+      );
+    }
+  }
+  return signin.token;
+}
+async function fetchObsidianApi(url, opts) {
+  url = createURL(url, "https://releases.obsidian.md");
   const response = await fetch(url, {
     headers: {
-      // For some reason you have to set the User-Agent or it won't let you download
       "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",
-      "Authorization": "Basic " + btoa(username + ":" + password)
+      "Authorization": "Bearer " + opts.token
     }
   });
   return response;
 }
 async function downloadResponse(response, dest) {
+  if (!response.ok) {
+    throw Error(`${response.url} failed with ${response.status}`);
+  }
   const fileStream = _fs2.default.createWriteStream(dest, { flags: "w" });
   const fetchStream = _stream.Readable.fromWeb(response.body);
   await _promises3.finished.call(void 0, fetchStream.pipe(fileStream));
@@ -173,7 +257,10 @@ var ChromeLocalStorage = class {
   constructor(userDataDir) {
     this.userDataDir = userDataDir;
     this.encodeKey = (domain, key) => `_${domain}\0
${key}`;
-    this.decodeKey = (key) => key.slice(1).split("\0
");
+    this.decodeKey = (key) => {
+      const parts = key.slice(1).split("\0
");
+      return [parts[0], parts.slice(1).join("\0
")];
+    };
     this.encodeValue = (value) => `
${value}`;
     this.decodeValue = (value) => value.slice(1);
     this.db = new (0, _classiclevel.ClassicLevel)(_path2.default.join(userDataDir, "Local Storage/leveldb/"));
@@ -241,231 +328,325 @@ var ChromeLocalStorage = class {
 // src/launcherUtils.ts
 
 
-var _util = require('util');
 
-var _which = require('which'); var _which2 = _interopRequireDefault(_which);
 
 
-var _chromeremoteinterface = require('chrome-remote-interface'); var _chromeremoteinterface2 = _interopRequireDefault(_chromeremoteinterface);
-var execFile = _util.promisify.call(void 0, _child_process2.default.execFile);
+
+
+var _zlib = require('zlib'); var _zlib2 = _interopRequireDefault(_zlib);
+
 function normalizeGitHubRepo(repo) {
-  return repo.replace(/^(https?:\/\/)?(github.com\/)/, "");
+  return _nullishCoalesce(_optionalChain([repo, 'access', _8 => _8.match, 'call', _9 => _9(/^(https?:\/\/)?(github.com\/)?(.*?)\/?$/), 'optionalAccess', _10 => _10[3]]), () => ( repo));
+}
+async function extractGz(archive, dest) {
+  await _promises3.pipeline.call(void 0, _fs2.default.createReadStream(archive), _zlib2.default.createGunzip(), _fs2.default.createWriteStream(dest));
+}
+async function sevenZ(args, options) {
+  const sevenZipScript = _path2.default.resolve(_url.fileURLToPath.call(void 0, _chunkQQJCBP4Ncjs.importMetaUrl), "../7z.js");
+  const proc = _child_process2.default.spawn(process.execPath, [sevenZipScript, ...args], {
+    stdio: "pipe",
+    ...options
+  });
+  let stdout = "", stderr = "";
+  proc.stdout.on("data", (data) => stdout += data);
+  proc.stderr.on("data", (data) => stderr += data);
+  const procExit = new Promise((resolve) => proc.on("close", (code) => resolve(_nullishCoalesce(code, () => ( -1)))));
+  const exitCode = await procExit;
+  const result = { stdout, stderr };
+  if (exitCode != 0) {
+    throw Error(`"7z ${args.join(" ")}" failed with ${exitCode}:
+${stdout}
+${stderr}`);
+  }
+  return result;
 }
 async function extractObsidianAppImage(appImage, dest) {
-  await withTmpDir(dest, async (tmpDir) => {
-    await _promises2.default.chmod(appImage, 493);
-    await execFile(appImage, ["--appimage-extract"], { cwd: tmpDir });
-    return _path2.default.join(tmpDir, "squashfs-root");
+  await atomicCreate(dest, async (tmpDir) => {
+    await sevenZ(["x", "-o.", _path2.default.relative(tmpDir, appImage)], { cwd: tmpDir });
+    return tmpDir;
   });
 }
-async function extractObsidianExe(exe, appArch, dest) {
-  const path7z = await _which2.default.call(void 0, "7z", { nothrow: true });
-  if (!path7z) {
-    throw new Error(
-      "Downloading Obsidian for Windows requires 7zip to be installed and available on the PATH. You install it from https://www.7-zip.org and then add the install location to the PATH."
-    );
+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-"));
+  });
+}
+async function extractObsidianExe(exe, arch, dest) {
+  let subArchive;
+  if (arch == "x64") {
+    subArchive = `$PLUGINSDIR/app-64.7z`;
+  } else if (arch == "ia32") {
+    subArchive = `$PLUGINSDIR/app-32.7z`;
+  } else if (arch == "arm64") {
+    subArchive = `$PLUGINSDIR/app-arm64.7z`;
+  } else {
+    throw Error(`No Obsidian installer found for ${process.platform} ${process.arch}`);
   }
-  exe = _path2.default.resolve(exe);
-  const subArchive = _path2.default.join("$PLUGINSDIR", appArch + ".7z");
-  dest = _path2.default.resolve(dest);
-  await withTmpDir(dest, async (tmpDir) => {
-    const extractedInstaller = _path2.default.join(tmpDir, "installer");
-    await execFile(path7z, ["x", "-o" + extractedInstaller, exe, subArchive]);
-    const extractedObsidian = _path2.default.join(tmpDir, "obsidian");
-    await execFile(path7z, ["x", "-o" + extractedObsidian, _path2.default.join(extractedInstaller, subArchive)]);
-    return extractedObsidian;
+  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 });
+    return "obsidian";
   });
 }
 async function extractObsidianDmg(dmg, dest) {
   dest = _path2.default.resolve(dest);
-  await withTmpDir(dest, async (tmpDir) => {
-    const proc = await execFile("hdiutil", ["attach", "-nobrowse", "-readonly", dmg]);
-    const volume = proc.stdout.match(/\/Volumes\/.*$/m)[0];
-    const obsidianApp = _path2.default.join(volume, "Obsidian.app");
-    try {
-      await _promises2.default.cp(obsidianApp, tmpDir, { recursive: true, verbatimSymlinks: true });
-    } finally {
-      await execFile("hdiutil", ["detach", volume]);
+  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);
+    if (files.includes("Obsidian.app")) {
+      return "Obsidian.app";
+    } else {
+      return _path2.default.join(files[0], "Obsidian.app");
     }
-    return tmpDir;
   });
 }
-function parseObsidianDesktopRelease(fileRelease, isBeta) {
-  return {
-    version: fileRelease.latestVersion,
-    minInstallerVersion: fileRelease.minimumVersion != "0.0.0" ? fileRelease.minimumVersion : void 0,
-    isBeta,
-    downloads: {
-      asar: fileRelease.downloadUrl
+var BROKEN_ASSETS = [
+  "https://releases.obsidian.md/release/obsidian-0.12.16.asar.gz",
+  "https://github.com/obsidianmd/obsidian-releases/releases/download/v0.12.16/obsidian-0.12.16.asar.gz",
+  "https://releases.obsidian.md/release/obsidian-1.4.7.asar.gz",
+  "https://releases.obsidian.md/release/obsidian-1.4.8.asar.gz"
+];
+function parseObsidianDesktopRelease(fileRelease) {
+  const parse = (r, isBeta) => {
+    const version = r.latestVersion;
+    let minInstallerVersion = r.minimumVersion;
+    if (minInstallerVersion == "0.0.0") {
+      minInstallerVersion = void 0;
+    } else if (_semver2.default.satisfies(version, ">=1.3.0 <=1.3.4")) {
+      minInstallerVersion = "0.14.5";
+    } else if (_semver2.default.gte(version, "1.5.3") && _semver2.default.lt(minInstallerVersion, "1.1.9")) {
+      minInstallerVersion = "1.1.9";
     }
+    return {
+      version: r.latestVersion,
+      minInstallerVersion,
+      isBeta,
+      downloads: {
+        asar: BROKEN_ASSETS.includes(r.downloadUrl) ? void 0 : r.downloadUrl
+      }
+    };
   };
+  const result = { current: parse(fileRelease, false) };
+  if (fileRelease.beta && fileRelease.beta.latestVersion !== fileRelease.latestVersion) {
+    result.beta = parse(fileRelease.beta, true);
+  }
+  return result;
 }
 function parseObsidianGithubRelease(gitHubRelease) {
   const version = gitHubRelease.name;
-  const assets = gitHubRelease.assets.map((a) => a.browser_download_url);
-  const downloads = {
-    appImage: assets.find((u) => u.match(`${version}.AppImage$`)),
-    appImageArm: assets.find((u) => u.match(`${version}-arm64.AppImage$`)),
-    apk: assets.find((u) => u.match(`${version}.apk$`)),
-    asar: assets.find((u) => u.match(`${version}.asar.gz$`)),
-    dmg: assets.find((u) => u.match(`${version}(-universal)?.dmg$`)),
-    exe: assets.find((u) => u.match(`${version}.exe$`))
-  };
+  let assets = gitHubRelease.assets.map((a) => ({
+    url: a.browser_download_url,
+    digest: _nullishCoalesce(a.digest, () => ( `id:${a.id}`))
+  }));
+  assets = assets.filter((a) => !BROKEN_ASSETS.includes(a.url));
+  const asar = assets.find((a) => a.url.match(`${version}.asar.gz$`));
+  const appImage = assets.find((a) => a.url.match(`${version}.AppImage$`));
+  const appImageArm = assets.find((a) => a.url.match(`${version}-arm64.AppImage$`));
+  const tar = assets.find((a) => a.url.match(`${version}.tar.gz$`));
+  const tarArm = assets.find((a) => a.url.match(`${version}-arm64.tar.gz$`));
+  const dmg = assets.find((a) => a.url.match(`${version}(-universal)?.dmg$`));
+  const exe = assets.find((a) => a.url.match(`${version}.exe$`));
+  const apk = assets.find((a) => a.url.match(`${version}.apk$`));
   return {
     version,
     gitHubRelease: gitHubRelease.html_url,
-    downloads
+    downloads: {
+      asar: _optionalChain([asar, 'optionalAccess', _11 => _11.url]),
+      appImage: _optionalChain([appImage, 'optionalAccess', _12 => _12.url]),
+      appImageArm: _optionalChain([appImageArm, 'optionalAccess', _13 => _13.url]),
+      tar: _optionalChain([tar, 'optionalAccess', _14 => _14.url]),
+      tarArm: _optionalChain([tarArm, 'optionalAccess', _15 => _15.url]),
+      dmg: _optionalChain([dmg, 'optionalAccess', _16 => _16.url]),
+      exe: _optionalChain([exe, 'optionalAccess', _17 => _17.url]),
+      apk: _optionalChain([apk, 'optionalAccess', _18 => _18.url])
+    },
+    installers: {
+      appImage: appImage ? { digest: appImage.digest } : void 0,
+      appImageArm: appImageArm ? { digest: appImageArm.digest } : void 0,
+      tar: tar ? { digest: tar.digest } : void 0,
+      tarArm: tarArm ? { digest: tarArm.digest } : void 0,
+      dmg: dmg ? { digest: dmg.digest } : void 0,
+      exe: exe ? { digest: exe.digest } : void 0
+    }
   };
 }
-async function getElectronVersionInfo(version, binaryPath) {
-  console.log(`${version}: Retrieving electron & chrome versions...`);
-  const configDir = await makeTmpDir("fetch-obsidian-versions-");
-  const proc = _child_process2.default.spawn(binaryPath, [
-    `--remote-debugging-port=0`,
-    // 0 will make it choose a random available port
-    "--test-type=webdriver",
-    `--user-data-dir=${configDir}`,
-    "--no-sandbox"
-    // Workaround for SUID issue, see https://github.com/electron/electron/issues/42510
-  ]);
-  const procExit = new Promise((resolve) => proc.on("exit", (code) => resolve(_nullishCoalesce(code, () => ( -1)))));
-  let dependencyVersions;
+async function getInstallerInfo(installerKey, url) {
+  const installerName = url.split("/").at(-1);
+  console.log(`Extrating installer info for ${installerName}...`);
+  const tmpDir = await makeTmpDir("obsidian-launcher-");
   try {
-    const portPromise = new Promise((resolve, reject) => {
-      procExit.then(() => reject("Processed ended without opening a port"));
-      proc.stderr.on("data", (data) => {
-        const port2 = _optionalChain([data, 'access', _8 => _8.toString, 'call', _9 => _9(), 'access', _10 => _10.match, 'call', _11 => _11(/ws:\/\/[\w.]+?:(\d+)/), 'optionalAccess', _12 => _12[1]]);
-        if (port2) {
-          resolve(Number(port2));
+    const installerPath = _path2.default.join(tmpDir, url.split("/").at(-1));
+    await downloadResponse(await fetch(url), installerPath);
+    const exractedPath = _path2.default.join(tmpDir, "Obsidian");
+    let platforms = [];
+    if (installerKey == "appImage" || installerKey == "appImageArm") {
+      await extractObsidianAppImage(installerPath, exractedPath);
+      platforms = ["linux-" + (installerKey == "appImage" ? "x64" : "arm64")];
+    } else if (installerKey == "tar" || installerKey == "tarArm") {
+      await extractObsidianTar(installerPath, exractedPath);
+      platforms = ["linux-" + (installerKey == "tar" ? "x64" : "arm64")];
+    } else if (installerKey == "exe") {
+      await extractObsidianExe(installerPath, "x64", exractedPath);
+      const { stdout } = await sevenZ(["l", "-ba", _path2.default.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");
+      if (files.includes("$PLUGINSDIR/app-32.7z")) platforms.push("win32-ia32");
+      if (files.includes("$PLUGINSDIR/app-64.7z")) platforms.push("win32-x64");
+    } else if (installerKey == "dmg") {
+      await extractObsidianDmg(installerPath, exractedPath);
+      platforms = ["darwin-arm64", "darwin-x64"];
+    } else {
+      throw new Error(`Unknown installer key ${installerKey}`);
+    }
+    const matches = [];
+    const installerFiles = await _promises2.default.readdir(exractedPath, { recursive: true, withFileTypes: true });
+    for (const file of installerFiles) {
+      if (file.isFile() && !file.name.endsWith(".asar")) {
+        const stream = _fs2.default.createReadStream(_path2.default.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;
+          chunk = prev + chunk;
+          matches.push(...[...(prev + chunk).matchAll(regex)].map((m) => m[0]));
+          prev = chunk.slice(-64);
         }
-      });
-    });
-    const port = await maybe(withTimeout(portPromise, 10 * 1e3));
-    if (!port.success) {
-      throw new Error("Timed out waiting for Chrome DevTools protocol port");
+      }
     }
-    const client = await _chromeremoteinterface2.default.call(void 0, { port: port.result });
-    const response = await client.Runtime.evaluate({ expression: "JSON.stringify(process.versions)" });
-    dependencyVersions = JSON.parse(response.result.value);
-    await client.close();
-  } finally {
-    proc.kill("SIGTERM");
-    const timeout = await maybe(withTimeout(procExit, 4 * 1e3));
-    if (!timeout.success) {
-      console.log(`${version}: Stuck process ${proc.pid}, using SIGKILL`);
-      proc.kill("SIGKILL");
+    const versionSortKey = (v) => v.split(".").map((s) => s.padStart(9, "0")).join(".");
+    const versions = _lodash2.default.call(void 0, matches).map((m) => m.split("/")).groupBy(0).mapValues((ms) => ms.map((m) => m[1])).mapValues((ms) => _lodash2.default.sortBy(ms, versionSortKey).at(-1)).value();
+    const electron = versions["Electron"];
+    const chrome = versions["Chrome"];
+    if (!electron || !chrome) {
+      throw new Error(`Failed to extract Electron and Chrome versions from binary ${installerPath}`);
     }
-    await procExit;
-    await sleep(1e3);
-    await _promises2.default.rm(configDir, { recursive: true, force: true });
-  }
-  if (!_optionalChain([dependencyVersions, 'optionalAccess', _13 => _13.electron]) || !_optionalChain([dependencyVersions, 'optionalAccess', _14 => _14.chrome])) {
-    throw Error(`Failed to extract electron and chrome versions for ${version}`);
-  }
-  return {
-    electronVersion: dependencyVersions.electron,
-    chromeVersion: dependencyVersions.chrome,
-    nodeVersion: dependencyVersions.node
-  };
-}
-function correctObsidianVersionInfo(versionInfo) {
-  const corrections = [
-    // These version's downloads are missing or broken.
-    { version: "0.12.16", downloads: { asar: void 0 } },
-    { version: "1.4.7", downloads: { asar: void 0 } },
-    { version: "1.4.8", downloads: { asar: void 0 } },
-    // The minInstallerVersion here is incorrect
-    { version: "1.3.4", minInstallerVersion: "0.14.5" },
-    { version: "1.3.3", minInstallerVersion: "0.14.5" },
-    { version: "1.3.2", minInstallerVersion: "0.14.5" },
-    { version: "1.3.1", minInstallerVersion: "0.14.5" },
-    { version: "1.3.0", minInstallerVersion: "0.14.5" }
-  ];
-  const result = _nullishCoalesce(corrections.find((v) => v.version == versionInfo.version), () => ( {}));
-  if (_semver2.default.gte(versionInfo.version, "1.5.3") && _semver2.default.lt(versionInfo.minInstallerVersion, "1.1.9")) {
-    result.minInstallerVersion = "1.1.9";
+    console.log(`Extracted installer info for ${installerName}`);
+    return { electron, chrome, platforms };
+  } finally {
+    await _promises2.default.rm(tmpDir, { recursive: true, force: true });
   }
-  return result;
 }
 function normalizeObsidianVersionInfo(versionInfo) {
   versionInfo = {
-    version: versionInfo.version,
-    minInstallerVersion: versionInfo.minInstallerVersion,
-    maxInstallerVersion: versionInfo.maxInstallerVersion,
-    isBeta: versionInfo.isBeta,
-    gitHubRelease: versionInfo.gitHubRelease,
+    ...versionInfo,
+    // kept for backwards compatibility
+    electronVersion: _optionalChain([versionInfo, 'access', _19 => _19.installers, 'optionalAccess', _20 => _20.appImage, 'optionalAccess', _21 => _21.electron]),
+    chromeVersion: _optionalChain([versionInfo, 'access', _22 => _22.installers, 'optionalAccess', _23 => _23.appImage, 'optionalAccess', _24 => _24.chrome])
+  };
+  const canonicalForm = {
+    version: null,
+    minInstallerVersion: null,
+    maxInstallerVersion: null,
+    isBeta: null,
+    gitHubRelease: null,
     downloads: {
-      asar: _optionalChain([versionInfo, 'access', _15 => _15.downloads, 'optionalAccess', _16 => _16.asar]),
-      appImage: _optionalChain([versionInfo, 'access', _17 => _17.downloads, 'optionalAccess', _18 => _18.appImage]),
-      appImageArm: _optionalChain([versionInfo, 'access', _19 => _19.downloads, 'optionalAccess', _20 => _20.appImageArm]),
-      apk: _optionalChain([versionInfo, 'access', _21 => _21.downloads, 'optionalAccess', _22 => _22.apk]),
-      dmg: _optionalChain([versionInfo, 'access', _23 => _23.downloads, 'optionalAccess', _24 => _24.dmg]),
-      exe: _optionalChain([versionInfo, 'access', _25 => _25.downloads, 'optionalAccess', _26 => _26.exe])
+      asar: null,
+      appImage: null,
+      appImageArm: null,
+      tar: null,
+      tarArm: null,
+      dmg: null,
+      exe: null,
+      apk: null
+    },
+    installers: {
+      appImage: { digest: null, electron: null, chrome: null, platforms: null },
+      appImageArm: { digest: null, electron: null, chrome: null, platforms: null },
+      tar: { digest: null, electron: null, chrome: null, platforms: null },
+      tarArm: { digest: null, electron: null, chrome: null, platforms: null },
+      dmg: { digest: null, electron: null, chrome: null, platforms: null },
+      exe: { digest: null, electron: null, chrome: null, platforms: null }
     },
-    electronVersion: versionInfo.electronVersion,
-    chromeVersion: versionInfo.chromeVersion,
-    nodeVersion: versionInfo.nodeVersion
+    electronVersion: null,
+    chromeVersion: null
   };
-  versionInfo.downloads = _lodash2.default.omitBy(versionInfo.downloads, _lodash2.default.isUndefined);
-  versionInfo = _lodash2.default.omitBy(versionInfo, _lodash2.default.isUndefined);
-  return versionInfo;
+  return normalizeObject(canonicalForm, versionInfo);
 }
 
 // src/launcher.ts
 
+var currentPlatform = {
+  platform: process.platform,
+  arch: process.arch
+};
 var ObsidianLauncher = class {
   /**
    * Construct an ObsidianLauncher.
-   * @param options.cacheDir Path to the cache directory. Defaults to "OBSIDIAN_CACHE" env var or ".obsidian-cache".
-   * @param options.versionsUrl Custom `obsidian-versions.json` url. Can be a file URL.
-   * @param options.communityPluginsUrl Custom `community-plugins.json` url. Can be a file URL.
-   * @param options.communityThemesUrl Custom `community-css-themes.json` url. Can be a file URL.
-   * @param options.cacheDuration If the cached version list is older than this (in ms), refetch it. Defaults to 30 minutes.
+   * @param opts.cacheDir Path to the cache directory. Defaults to "OBSIDIAN_CACHE" env var or ".obsidian-cache".
+   * @param opts.versionsUrl Custom `obsidian-versions.json` url. Can be a file URL.
+   * @param opts.communityPluginsUrl Custom `community-plugins.json` url. Can be a file URL.
+   * @param opts.communityThemesUrl Custom `community-css-themes.json` url. Can be a file URL.
+   * @param opts.cacheDuration If the cached version list is older than this (in ms), refetch it. Defaults to 30 minutes.
+   * @param opts.interactive If it can prompt the user for input (e.g. for Obsidian credentials). Default false.
    */
-  constructor(options = {}) {
-    this.cacheDir = _path2.default.resolve(_nullishCoalesce(_nullishCoalesce(options.cacheDir, () => ( process.env.OBSIDIAN_CACHE)), () => ( "./.obsidian-cache")));
+  constructor(opts = {}) {
+    this.interactive = false;
+    this.cacheDir = _path2.default.resolve(_nullishCoalesce(_nullishCoalesce(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 = _nullishCoalesce(options.versionsUrl, () => ( defaultVersionsUrl));
+    this.versionsUrl = _nullishCoalesce(opts.versionsUrl, () => ( defaultVersionsUrl));
     const defaultCommunityPluginsUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
-    this.communityPluginsUrl = _nullishCoalesce(options.communityPluginsUrl, () => ( defaultCommunityPluginsUrl));
+    this.communityPluginsUrl = _nullishCoalesce(opts.communityPluginsUrl, () => ( defaultCommunityPluginsUrl));
     const defaultCommunityThemesUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-css-themes.json";
-    this.communityThemesUrl = _nullishCoalesce(options.communityThemesUrl, () => ( defaultCommunityThemesUrl));
-    this.cacheDuration = _nullishCoalesce(options.cacheDuration, () => ( 30 * 60 * 1e3));
+    this.communityThemesUrl = _nullishCoalesce(opts.communityThemesUrl, () => ( defaultCommunityThemesUrl));
+    this.cacheDuration = _nullishCoalesce(opts.cacheDuration, () => ( 30 * 60 * 1e3));
+    this.interactive = _nullishCoalesce(opts.interactive, () => ( false));
     this.metadataCache = {};
+    _dotenv2.default.config({
+      path: [".env", _path2.default.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
    * cacheDuration ms or if there are network errors.
    */
-  async cachedFetch(url, dest) {
+  async cachedFetch(url, dest, cacheValid) {
+    cacheValid = _nullishCoalesce(cacheValid, () => ( (() => true)));
     dest = _path2.default.join(this.cacheDir, dest);
     if (!(dest in this.metadataCache)) {
-      let fileContent;
+      let data;
+      let error;
+      const cacheMtime = await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => void 0)), 'optionalAccess', async _25 => _25.mtime]);
       if (url.startsWith("file:")) {
-        fileContent = await _promises2.default.readFile(_url.fileURLToPath.call(void 0, url), "utf-8");
-      } else {
-        const mtime = await fileExists(dest) ? (await _promises2.default.stat(dest)).mtime : void 0;
-        if (mtime && (/* @__PURE__ */ new Date()).getTime() - mtime.getTime() < this.cacheDuration) {
-          fileContent = await _promises2.default.readFile(dest, "utf-8");
+        data = JSON.parse(await _promises2.default.readFile(_url.fileURLToPath.call(void 0, url), "utf-8"));
+      }
+      if (!data && cacheMtime && (/* @__PURE__ */ new Date()).getTime() - cacheMtime.getTime() < this.cacheDuration) {
+        const parsed = JSON.parse(await _promises2.default.readFile(dest, "utf-8"));
+        if (cacheValid(parsed)) {
+          data = parsed;
+        }
+      }
+      if (!data) {
+        const response = await maybe(fetch(url).then(async (r) => {
+          if (!r.ok) throw Error(`Fetch ${url} failed with status ${r.status}`);
+          const d = await r.text();
+          if (_lodash2.default.isError(_lodash2.default.attempt(JSON.parse, d))) throw Error(`Failed to parse response from ${url}`);
+          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");
+          });
+          data = JSON.parse(response.result);
         } else {
-          const request = await maybe(fetch(url).then((r) => r.text()));
-          if (request.success) {
-            await _promises2.default.mkdir(_path2.default.dirname(dest), { recursive: true });
-            await withTmpDir(dest, async (tmpDir) => {
-              await _promises2.default.writeFile(_path2.default.join(tmpDir, "download.json"), request.result);
-              return _path2.default.join(tmpDir, "download.json");
-            });
-            fileContent = request.result;
-          } else if (await fileExists(dest)) {
-            console.warn(request.error);
-            console.warn(`Unable to download ${dest}, using cached file.`);
-            fileContent = await _promises2.default.readFile(dest, "utf-8");
-          } else {
-            throw request.error;
-          }
+          error = response.error;
+        }
+      }
+      if (!data && await fileExists(dest)) {
+        const parsed = JSON.parse(await _promises2.default.readFile(dest, "utf-8"));
+        if (cacheValid(parsed)) {
+          console.warn(error);
+          console.warn(`Unable to download ${url}, using cached file.`);
+          data = parsed;
         }
       }
-      this.metadataCache[dest] = JSON.parse(fileContent);
+      if (!data) {
+        throw error;
+      }
+      this.metadataCache[dest] = data;
     }
     return this.metadataCache[dest];
   }
@@ -492,7 +673,12 @@ var ObsidianLauncher = class {
    * Get information about all available Obsidian versions.
    */
   async getVersions() {
-    return (await this.cachedFetch(this.versionsUrl, "obsidian-versions.json")).versions;
+    const isValid = (d) => _semver2.default.satisfies(_nullishCoalesce(d.metadata.schemaVersion, () => ( "1.0.0")), `^${obsidianVersionsSchemaVersion}`);
+    const versions = await this.cachedFetch(this.versionsUrl, "obsidian-versions.json", isValid);
+    if (!isValid(versions)) {
+      throw new Error(`${this.versionsUrl} format has changed, please update obsidian-launcher and wdio-obsidian-service`);
+    }
+    return versions.versions;
   }
   /**
    * Get information about all available community plugins.
@@ -508,11 +694,11 @@ var ObsidianLauncher = class {
   }
   /**
    * Resolves Obsidian app and installer version strings to absolute versions.
-   * @param appVersion Obsidian version string or one of 
+   * @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)
    *   - "earliest": Get the `minAppVersion` set in your `manifest.json`
-   * @param installerVersion Obsidian version string or one of 
+   * @param installerVersion specific version or one of
    *   - "latest": Get the latest Obsidian installer compatible with `appVersion`
    *   - "earliest": Get the oldest Obsidian installer compatible with `appVersion`
    * 
@@ -520,22 +706,34 @@ var ObsidianLauncher = class {
    *
    * @returns [appVersion, installerVersion] with any "latest" etc. resolved to specific versions.
    */
-  async resolveVersions(appVersion, installerVersion = "latest") {
+  async resolveVersion(appVersion, installerVersion = "latest") {
     const versions = await this.getVersions();
     const appVersionInfo = await this.getVersionInfo(appVersion);
+    appVersion = appVersionInfo.version;
+    let installerVersionInfo;
+    const { platform, arch } = process;
     if (!appVersionInfo.minInstallerVersion || !appVersionInfo.maxInstallerVersion) {
-      throw Error(`No compatible installers available for app version ${appVersion}`);
+      throw Error(`No installers available for Obsidian ${appVersion}`);
     }
     if (installerVersion == "latest") {
-      installerVersion = appVersionInfo.maxInstallerVersion;
+      installerVersionInfo = _lodash2.default.findLast(
+        versions,
+        (v) => _semver2.default.lte(v.version, appVersionInfo.version) && !!this.getInstallerKey(v, { platform, arch })
+      );
     } else if (installerVersion == "earliest") {
-      installerVersion = appVersionInfo.minInstallerVersion;
+      installerVersionInfo = versions.find(
+        (v) => _semver2.default.gte(v.version, appVersionInfo.minInstallerVersion) && !!this.getInstallerKey(v, { platform, arch })
+      );
     } else {
       installerVersion = _nullishCoalesce(_semver2.default.valid(installerVersion), () => ( installerVersion));
+      installerVersionInfo = versions.find((v) => v.version == installerVersion);
     }
-    const installerVersionInfo = versions.find((v) => v.version == installerVersion);
-    if (!installerVersionInfo || !installerVersionInfo.chromeVersion) {
-      throw Error(`No Obsidian installer for version ${installerVersion} found`);
+    if (!installerVersionInfo) {
+      if (["earliest", "latest"].includes(installerVersion)) {
+        throw Error(`No compatible installers available for Obsidian ${appVersion}`);
+      } else {
+        throw Error(`No Obsidian installer ${installerVersion} found`);
+      }
     }
     if (_semver2.default.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion) || _semver2.default.gt(installerVersionInfo.version, appVersionInfo.maxInstallerVersion)) {
       throw Error(
@@ -555,124 +753,145 @@ var ObsidianLauncher = class {
     } else if (appVersion == "latest") {
       appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
     } else if (appVersion == "earliest") {
-      appVersion = await _asyncOptionalChain([(await this.getRootManifest()), 'optionalAccess', async _27 => _27.minAppVersion]);
+      appVersion = await _asyncOptionalChain([(await this.getRootManifest()), 'optionalAccess', async _26 => _26.minAppVersion]);
       if (!appVersion) {
-        throw Error('Unable to resolve Obsidian app appVersion "earliest", no manifest.json or minAppVersion found.');
+        throw Error('Unable to resolve Obsidian appVersion "earliest", no manifest.json or minAppVersion found.');
       }
     } else {
       appVersion = _nullishCoalesce(_semver2.default.valid(appVersion), () => ( appVersion));
     }
     const versionInfo = versions.find((v) => v.version == appVersion);
     if (!versionInfo) {
-      throw Error(`No Obsidian app version ${appVersion} found`);
+      throw Error(`No Obsidian app version "${appVersion}" found`);
     }
     return versionInfo;
   }
   /**
-   * Downloads the Obsidian installer for the given version and current platform. Returns the file path.
-   * @param installerVersion Obsidian installer version to download
+   * Parses a string of Obsidian versions into [appVersion, installerVersion] tuples.
+   * 
+   * `versions` should be a space separated list of Obsidian app versions. You can optionally specify the installer
+   * version by using "appVersion/installerVersion" e.g. `"1.7.7/1.8.10"`.
+   * 
+   * Example: 
+   * ```js
+   * launcher.parseVersions("1.8.10/1.7.7 latest latest-beta/earliest")
+   * ```
+   * 
+   * See also: [Obsidian App vs Installer Versions](../README.md#obsidian-app-vs-installer-versions)
+   * 
+   * @param versions string to parse
+   * @returns [appVersion, installerVersion][] resolved to specific versions.
+   */
+  async parseVersions(versions) {
+    let 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) {
+      resolvedVersions.push(await this.resolveVersion(appVersion, installerVersion));
+    }
+    return _lodash2.default.uniqBy(resolvedVersions, (v) => v.join("/"));
+  }
+  getInstallerKey(installerVersionInfo, opts = {}) {
+    const { platform, arch } = _lodash2.default.merge({}, opts, currentPlatform);
+    const platformName = `${platform}-${arch}`;
+    const key = _lodash2.default.findKey(installerVersionInfo.installers, (v) => v && v.platforms.includes(platformName));
+    return key;
+  }
+  /**
+   * Gets details about the Obsidian installer for the given platform.
+   * @param installerVersion Obsidian installer version
+   * @param opts.platform Platform/os (defaults to host platform)
+   * @param opts.arch Architecture (defaults to host architecture)
    */
-  async downloadInstaller(installerVersion) {
-    const installerVersionInfo = await this.getVersionInfo(installerVersion);
-    return await this.downloadInstallerFromVersionInfo(installerVersionInfo);
+  async getInstallerInfo(installerVersion, opts = {}) {
+    const { platform, arch } = _lodash2.default.merge({}, opts, currentPlatform);
+    const versionInfo = await this.getVersionInfo(installerVersion);
+    const key = this.getInstallerKey(versionInfo, { platform, arch });
+    if (key) {
+      return { ...versionInfo.installers[key], url: versionInfo.downloads[key] };
+    } else {
+      throw Error(
+        `No Obsidian installer for ${installerVersion} ${platform}-${arch}` + (versionInfo.isBeta ? ` (${installerVersion} is a beta version)` : "")
+      );
+    }
   }
   /**
-   * Helper for downloadInstaller that doesn't require the obsidian-versions.json file so it can be used in
-   * updateObsidianVersionInfos
+   * Downloads the Obsidian installer for the given version and platform/arch (defaults to host platform/arch).
+   * Returns the file path.
+   * @param installerVersion Obsidian installer version to download
+   * @param opts.platform Platform/os of the installer to download (defaults to host platform)
+   * @param opts.arch Architecture of the installer to download (defaults to host architecture)
    */
-  async downloadInstallerFromVersionInfo(versionInfo) {
-    const installerVersion = versionInfo.version;
-    const { platform, arch } = process;
+  async downloadInstaller(installerVersion, opts = {}) {
+    const { platform, arch } = _lodash2.default.merge({}, opts, currentPlatform);
+    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}`);
-    let installerPath;
-    let downloader;
+    let binaryPath;
+    let extractor;
     if (platform == "linux") {
-      installerPath = _path2.default.join(cacheDir, "obsidian");
-      let installerUrl;
-      if (arch.startsWith("arm")) {
-        installerUrl = versionInfo.downloads.appImageArm;
-      } else {
-        installerUrl = versionInfo.downloads.appImage;
-      }
-      if (installerUrl) {
-        downloader = async (tmpDir) => {
-          const appImage = _path2.default.join(tmpDir, "Obsidian.AppImage");
-          await downloadResponse(await fetch(installerUrl), appImage);
-          const obsidianFolder = _path2.default.join(tmpDir, "Obsidian");
-          await extractObsidianAppImage(appImage, obsidianFolder);
-          return obsidianFolder;
-        };
-      }
+      binaryPath = _path2.default.join(cacheDir, "obsidian");
+      extractor = (installer, dest) => extractObsidianAppImage(installer, dest);
     } else if (platform == "win32") {
-      installerPath = _path2.default.join(cacheDir, "Obsidian.exe");
-      const installerUrl = versionInfo.downloads.exe;
-      let appArch;
-      if (arch == "x64") {
-        appArch = "app-64";
-      } else if (arch == "ia32") {
-        appArch = "app-32";
-      } else if (arch.startsWith("arm")) {
-        appArch = "app-arm64";
-      }
-      if (installerUrl && appArch) {
-        downloader = async (tmpDir) => {
-          const installerExecutable = _path2.default.join(tmpDir, "Obsidian.exe");
-          await downloadResponse(await fetch(installerUrl), installerExecutable);
-          const obsidianFolder = _path2.default.join(tmpDir, "Obsidian");
-          await extractObsidianExe(installerExecutable, appArch, obsidianFolder);
-          return obsidianFolder;
-        };
-      }
+      binaryPath = _path2.default.join(cacheDir, "Obsidian.exe");
+      extractor = (installer, dest) => extractObsidianExe(installer, arch, dest);
     } else if (platform == "darwin") {
-      installerPath = _path2.default.join(cacheDir, "Contents/MacOS/Obsidian");
-      const installerUrl = versionInfo.downloads.dmg;
-      if (installerUrl) {
-        downloader = async (tmpDir) => {
-          const dmg = _path2.default.join(tmpDir, "Obsidian.dmg");
-          await downloadResponse(await fetch(installerUrl), dmg);
-          const obsidianFolder = _path2.default.join(tmpDir, "Obsidian");
-          await extractObsidianDmg(dmg, obsidianFolder);
-          return obsidianFolder;
-        };
-      }
+      binaryPath = _path2.default.join(cacheDir, "Contents/MacOS/Obsidian");
+      extractor = (installer, dest) => extractObsidianDmg(installer, dest);
     } else {
       throw Error(`Unsupported platform ${platform}`);
     }
-    if (!downloader) {
-      throw Error(`No Obsidian installer download available for v${installerVersion} ${platform} ${arch}`);
-    }
-    if (!await fileExists(installerPath)) {
+    if (!await fileExists(binaryPath)) {
       console.log(`Downloading Obsidian installer v${installerVersion}...`);
-      await _promises2.default.mkdir(_path2.default.dirname(cacheDir), { recursive: true });
-      await withTmpDir(cacheDir, downloader);
+      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;
+      });
     }
-    return installerPath;
+    return binaryPath;
   }
   /**
    * Downloads the Obsidian asar for the given version. Returns the file path.
    * 
-   * To download beta versions you'll need to have an Obsidian account with Catalyst and set the `OBSIDIAN_USERNAME`
-   * and `OBSIDIAN_PASSWORD` environment variables. 2FA needs to be disabled.
+   * 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`
    * 
    * @param appVersion Obsidian version to download
    */
   async downloadApp(appVersion) {
-    const appVersionInfo = await this.getVersionInfo(appVersion);
-    const appUrl = appVersionInfo.downloads.asar;
+    const versionInfo = await this.getVersionInfo(appVersion);
+    const appUrl = versionInfo.downloads.asar;
     if (!appUrl) {
       throw Error(`No asar found for Obsidian version ${appVersion}`);
     }
-    const appPath = _path2.default.join(this.cacheDir, "obsidian-app", `obsidian-${appVersionInfo.version}.asar`);
+    const appPath = _path2.default.join(this.cacheDir, "obsidian-app", `obsidian-${versionInfo.version}.asar`);
     if (!await fileExists(appPath)) {
-      console.log(`Downloading Obsidian app v${appVersion} ...`);
-      await _promises2.default.mkdir(_path2.default.dirname(appPath), { recursive: true });
-      await withTmpDir(appPath, async (tmpDir) => {
-        const isInsidersBuild = new URL(appUrl).hostname.endsWith(".obsidian.md");
-        const response = isInsidersBuild ? await fetchObsidianAPI(appUrl) : await fetch(appUrl);
+      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 _promises3.pipeline.call(void 0, _fs2.default.createReadStream(archive), _zlib2.default.createGunzip(), _fs2.default.createWriteStream(asar));
+        await extractGz(archive, asar);
         return asar;
       });
     }
@@ -689,34 +908,53 @@ var ObsidianLauncher = class {
    * 
    * @param installerVersion Obsidian installer version
    */
-  async downloadChromedriver(installerVersion) {
-    const versionInfo = await this.getVersionInfo(installerVersion);
-    const electronVersion = versionInfo.electronVersion;
-    if (!electronVersion) {
-      throw Error(`${installerVersion} is not an Obsidian installer version.`);
-    }
-    const chromedriverZipPath = await _get.downloadArtifact.call(void 0, {
-      version: electronVersion,
-      artifactName: "chromedriver",
-      cacheRoot: _path2.default.join(this.cacheDir, "chromedriver-legacy"),
-      unsafelyDisableChecksums: true
-      // the checksums are slow and run even on cache hit.
-    });
+  async downloadChromedriver(installerVersion, opts = {}) {
+    const { platform, arch } = _lodash2.default.merge({}, opts, currentPlatform);
+    const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
+    const cacheDir = _path2.default.join(this.cacheDir, `electron-chromedriver/${platform}-${arch}/${installerInfo.electron}`);
     let chromedriverPath;
     if (process.platform == "win32") {
-      chromedriverPath = _path2.default.join(_path2.default.dirname(chromedriverZipPath), "chromedriver.exe");
+      chromedriverPath = _path2.default.join(cacheDir, `chromedriver.exe`);
     } else {
-      chromedriverPath = _path2.default.join(_path2.default.dirname(chromedriverZipPath), "chromedriver");
+      chromedriverPath = _path2.default.join(cacheDir, `chromedriver`);
     }
     if (!await fileExists(chromedriverPath)) {
-      console.log(`Downloading legacy chromedriver for electron ${electronVersion} ...`);
-      await withTmpDir(chromedriverPath, async (tmpDir) => {
-        await _extractzip2.default.call(void 0, chromedriverZipPath, { dir: tmpDir });
-        return _path2.default.join(tmpDir, _path2.default.basename(chromedriverPath));
+      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;
       });
     }
     return chromedriverPath;
   }
+  /**
+   * Downloads the Obsidian apk.
+   */
+  async downloadAndroid(version) {
+    const versionInfo = await this.getVersionInfo(version);
+    const apkUrl = versionInfo.downloads.apk;
+    if (!apkUrl) {
+      throw Error(
+        `No apk found for Obsidian version ${version}` + (versionInfo.isBeta ? ` (${version} is a beta version)` : "")
+      );
+    }
+    const apkPath = _path2.default.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 = _path2.default.join(tmpDir, "obsidian.apk");
+        await downloadResponse(await fetch(apkUrl), dest);
+        return dest;
+      });
+    }
+    return apkPath;
+  }
   /** Gets the latest version of a plugin. */
   async getLatestPluginVersion(repo) {
     repo = normalizeGitHubRepo(repo);
@@ -742,8 +980,7 @@ var ObsidianLauncher = class {
     version = _semver2.default.valid(version);
     const pluginDir = _path2.default.join(this.cacheDir, "obsidian-plugins", repo, version);
     if (!await fileExists(pluginDir)) {
-      await _promises2.default.mkdir(_path2.default.dirname(pluginDir), { recursive: true });
-      await withTmpDir(pluginDir, async (tmpDir) => {
+      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]) => {
@@ -776,8 +1013,8 @@ var ObsidianLauncher = class {
     return await this.downloadGitHubPlugin(pluginInfo.repo, version);
   }
   /**
-   * Downloads a list of plugins to the cache and returns a list of `DownloadedPluginEntry` with the downloaded paths.
-   * Also adds the `id` property to the plugins based on the manifest.
+   * Downloads a list of plugins to the cache and returns a list of {@link DownloadedPluginEntry} with the downloaded
+   * paths. Also adds the `id` property to the plugins based on the manifest.
    * 
    * You can download plugins from GitHub using `{repo: "org/repo"}` and community plugins using `{id: 'plugin-id'}`.
    * Local plugins will just be passed through.
@@ -850,8 +1087,7 @@ var ObsidianLauncher = class {
     const version = await this.getLatestThemeVersion(repo);
     const themeDir = _path2.default.join(this.cacheDir, "obsidian-themes", repo, version);
     if (!await fileExists(themeDir)) {
-      await _promises2.default.mkdir(_path2.default.dirname(themeDir), { recursive: true });
-      await withTmpDir(themeDir, async (tmpDir) => {
+      await atomicCreate(themeDir, async (tmpDir) => {
         const assetsToDownload = ["manifest.json", "theme.css"];
         await Promise.all(
           assetsToDownload.map(async (file) => {
@@ -883,8 +1119,8 @@ var ObsidianLauncher = class {
     return await this.downloadGitHubTheme(themeInfo.repo);
   }
   /**
-   * Downloads a list of themes to the cache and returns a list of `DownloadedThemeEntry` with the downloaded paths.
-   * Also adds the `name` property to the plugins based on the manifest.
+   * Downloads a list of themes to the cache and returns a list of {@link DownloadedThemeEntry} with the downloaded
+   * paths. Also adds the `name` property to the plugins based on the manifest.
    * 
    * You can download themes from GitHub using `{repo: "org/repo"}` and community themes using `{name: 'theme-name'}`.
    * Local themes will just be passed through.
@@ -1038,27 +1274,35 @@ var ObsidianLauncher = class {
    * @param params.appVersion Obsidian app version
    * @param params.installerVersion Obsidian version string.
    * @param params.appPath Path to the asar file to install. Will download if omitted.
-   * @param params.vault Path to the vault to open in Obsidian.
-   * @param params.dest Destination path for the config dir. If omitted it will create a temporary directory.
+   * @param params.vault Path to the vault to open in Obsidian
+   * @param params.localStorage items to add to localStorage. `$vaultId` in the keys will be replaced with the vaultId
+   * @param params.chromePreferences Chrome preferences to add to the Preferences file
    */
   async setupConfigDir(params) {
-    const [appVersion, installerVersion] = await this.resolveVersions(params.appVersion, params.installerVersion);
-    const configDir = await _asyncNullishCoalesce(params.dest, async () => ( await makeTmpDir("obs-launcher-config-")));
-    let obsidianJson = {
-      updateDisabled: true
-      // Prevents Obsidian trying to auto-update on boot.
-    };
-    let localStorageData = {
-      "most-recently-installed-version": appVersion
+    const [appVersion, installerVersion] = await this.resolveVersion(params.appVersion, params.installerVersion);
+    const configDir = await makeTmpDir("obsidian-launcher-config-");
+    const vaultId = _crypto2.default.randomBytes(8).toString("hex");
+    const localStorageData = {
+      "most-recently-installed-version": appVersion,
       // prevents the changelog page on boot
+      [`enable-plugin-${vaultId}`]: "true",
+      // Disable "safe mode" and enable plugins
+      ..._lodash2.default.mapKeys(_nullishCoalesce(params.localStorage, () => ( {})), (v, k) => k.replace("$vaultId", _nullishCoalesce(vaultId, () => ( ""))))
+    };
+    const chromePreferences = _lodash2.default.merge(
+      // disables the "allow pasting" bit in the dev tools console
+      { "electron": { "devtools": { "preferences": { "disable-self-xss-warning": "true" } } } },
+      _nullishCoalesce(params.chromePreferences, () => ( {}))
+    );
+    const obsidianJson = {
+      updateDisabled: true
+      // prevents Obsidian trying to auto-update on boot.
     };
     if (params.vault !== void 0) {
       if (!await fileExists(params.vault)) {
         throw Error(`Vault path ${params.vault} doesn't exist.`);
       }
-      const vaultId = _crypto2.default.randomBytes(8).toString("hex");
-      obsidianJson = {
-        ...obsidianJson,
+      Object.assign(obsidianJson, {
         vaults: {
           [vaultId]: {
             path: _path2.default.resolve(params.vault),
@@ -1066,14 +1310,10 @@ var ObsidianLauncher = class {
             open: true
           }
         }
-      };
-      localStorageData = {
-        ...localStorageData,
-        [`enable-plugin-${vaultId}`]: "true"
-        // Disable "safe mode" and enable plugins
-      };
+      });
     }
     await _promises2.default.writeFile(_path2.default.join(configDir, "obsidian.json"), JSON.stringify(obsidianJson));
+    await _promises2.default.writeFile(_path2.default.join(configDir, "Preferences"), JSON.stringify(chromePreferences));
     let appPath = params.appPath;
     if (!appPath) {
       appPath = await this.downloadApp(appVersion);
@@ -1108,8 +1348,6 @@ var ObsidianLauncher = class {
    * Downloads and launches Obsidian with a sandboxed config dir and a specifc vault open. Optionally install plugins
    * and themes first.
    * 
-   * This is just a shortcut for calling `downloadApp`, `downloadInstaller`, `setupVault` and `setupConfDir`.
-   *
    * @param params.appVersion Obsidian app version. Default "latest"
    * @param params.installerVersion Obsidian installer version. Default "latest"
    * @param params.vault Path to the vault to open in Obsidian
@@ -1117,11 +1355,12 @@ var ObsidianLauncher = class {
    * @param params.plugins List of plugins to install in the vault
    * @param params.themes List of themes to install in the vault
    * @param params.args CLI args to pass to Obsidian
+   * @param params.localStorage items to add to localStorage. `$vaultId` in the keys will be replaced with the vaultId
    * @param params.spawnOptions Options to pass to `spawn`
    * @returns The launched child process and the created tmpdirs
    */
   async launch(params) {
-    const [appVersion, installerVersion] = await this.resolveVersions(
+    const [appVersion, installerVersion] = await this.resolveVersion(
       _nullishCoalesce(params.appVersion, () => ( "latest")),
       _nullishCoalesce(params.installerVersion, () => ( "latest"))
     );
@@ -1136,10 +1375,16 @@ var ObsidianLauncher = class {
         themes: params.themes
       });
     }
-    const configDir = await this.setupConfigDir({ appVersion, installerVersion, appPath, vault });
+    const configDir = await this.setupConfigDir({
+      appVersion,
+      installerVersion,
+      appPath,
+      vault,
+      localStorage: params.localStorage
+    });
     const proc = _child_process2.default.spawn(installerPath, [
       `--user-data-dir=${configDir}`,
-      // Workaround for SUID issue on AppImages. See https://github.com/electron/electron/issues/42510
+      // Workaround for SUID issue on linux. See https://github.com/electron/electron/issues/42510
       ...process.platform == "linux" ? ["--no-sandbox"] : [],
       ..._nullishCoalesce(params.args, () => ( []))
     ], {
@@ -1148,91 +1393,80 @@ var ObsidianLauncher = class {
     return { proc, configDir, vault };
   }
   /** 
-   * Updates the info obsidian-versions.json. The obsidian-versions.json file is used in other launcher commands
+   * Updates the info in obsidian-versions.json. The obsidian-versions.json file is used in other launcher commands
    * and in wdio-obsidian-service to get metadata about Obsidian versions in one place such as minInstallerVersion and
-   * the internal electron version.
+   * the internal Electron version.
    */
-  async updateObsidianVersionInfos(original, { maxInstances = 1 } = {}) {
+  async updateVersionList(original, opts = {}) {
+    const { maxInstances = 1 } = opts;
     const repo = "obsidianmd/obsidian-releases";
+    const originalVersions = _lodash2.default.keyBy(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _27 => _27.versions]), () => ( [])), (v) => v.version);
+    const versions = _lodash2.default.cloneDeep(originalVersions);
     let commitHistory = await fetchGitHubAPIPaginated(`repos/${repo}/commits`, {
       path: "desktop-releases.json",
-      since: _optionalChain([original, 'optionalAccess', _28 => _28.metadata, 'access', _29 => _29.commitDate])
+      since: _optionalChain([original, 'optionalAccess', _28 => _28.metadata, 'optionalAccess', _29 => _29.commitDate])
     });
     commitHistory.reverse();
-    if (original) {
+    if (_optionalChain([original, 'optionalAccess', _30 => _30.metadata, 'optionalAccess', _31 => _31.commitSha])) {
       commitHistory = _lodash2.default.takeRightWhile(commitHistory, (c) => c.sha != original.metadata.commitSha);
     }
     const fileHistory = await pool(
-      8,
+      maxInstances,
       commitHistory,
       (commit) => fetch(`https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
     );
-    const githubReleases = await fetchGitHubAPIPaginated(`repos/${repo}/releases`);
-    const versionMap = _lodash2.default.keyBy(
-      _nullishCoalesce(_optionalChain([original, 'optionalAccess', _30 => _30.versions]), () => ( [])),
-      (v) => v.version
-    );
-    for (const { beta, ...current } of fileHistory) {
-      if (beta && (!versionMap[beta.latestVersion] || versionMap[beta.latestVersion].isBeta)) {
-        versionMap[beta.latestVersion] = _lodash2.default.merge(
-          {},
-          versionMap[beta.latestVersion],
-          parseObsidianDesktopRelease(beta, true)
-        );
+    for (const fileVersion of fileHistory) {
+      const { current, beta } = parseObsidianDesktopRelease(fileVersion);
+      if (beta) {
+        versions[beta.version] = _lodash2.default.merge(_nullishCoalesce(versions[beta.version], () => ( {})), beta);
       }
-      versionMap[current.latestVersion] = _lodash2.default.merge(
-        {},
-        versionMap[current.latestVersion],
-        parseObsidianDesktopRelease(current, false)
-      );
+      versions[current.version] = _lodash2.default.merge(_nullishCoalesce(versions[current.version], () => ( {})), current);
     }
+    const githubReleases = (await fetchGitHubAPIPaginated(`repos/${repo}/releases`)).reverse();
     for (const release of githubReleases) {
-      if (versionMap.hasOwnProperty(release.name)) {
-        versionMap[release.name] = _lodash2.default.merge({}, versionMap[release.name], parseObsidianGithubRelease(release));
+      if (_semver2.default.valid(release.name)) {
+        const parsed = parseObsidianGithubRelease(release);
+        versions[parsed.version] = _lodash2.default.merge(_nullishCoalesce(versions[parsed.version], () => ( {})), parsed);
       }
     }
-    const dependencyVersions = await pool(
-      maxInstances,
-      Object.values(versionMap).filter((v) => _optionalChain([v, 'access', _31 => _31.downloads, 'optionalAccess', _32 => _32.appImage]) && !v.chromeVersion),
-      async (v) => {
-        const binaryPath = await this.downloadInstallerFromVersionInfo(v);
-        const electronVersionInfo = await getElectronVersionInfo(v.version, binaryPath);
-        return { ...v, ...electronVersionInfo };
+    const installerKeys = ["appImage", "appImageArm", "tar", "tarArm", "dmg", "exe"];
+    const newInstallers = Object.values(versions).flatMap((v) => installerKeys.map((k) => [v, k]));
+    const installerInfos = await pool(maxInstances, newInstallers, async ([v, key]) => {
+      let installerInfo;
+      const hasAsset = !!_optionalChain([v, 'access', _32 => _32.downloads, 'optionalAccess', _33 => _33[key]]);
+      const alreadyExtracted = !!_optionalChain([v, 'access', _34 => _34.installers, 'optionalAccess', _35 => _35[key], 'optionalAccess', _36 => _36.chrome]);
+      const changed = _optionalChain([v, 'access', _37 => _37.installers, 'optionalAccess', _38 => _38[key], 'optionalAccess', _39 => _39.digest]) != _optionalChain([originalVersions, 'access', _40 => _40[v.version], 'optionalAccess', _41 => _41.installers, 'access', _42 => _42[key], 'optionalAccess', _43 => _43.digest]);
+      if (hasAsset && (!alreadyExtracted || changed)) {
+        installerInfo = await getInstallerInfo(key, v.downloads[key]);
       }
-    );
-    for (const deps of dependencyVersions) {
-      versionMap[deps.version] = _lodash2.default.merge({}, versionMap[deps.version], deps);
+      return { version: v.version, installerInfo: { [key]: installerInfo } };
+    });
+    for (const installerInfo of installerInfos) {
+      versions[installerInfo.version] = _lodash2.default.merge(_nullishCoalesce(versions[installerInfo.version], () => ( {})), installerInfo);
     }
     let minInstallerVersion = void 0;
     let maxInstallerVersion = void 0;
-    for (const version of Object.keys(versionMap).sort(_semver2.default.compare)) {
-      if (!minInstallerVersion && versionMap[version].chromeVersion) {
+    for (const version of Object.keys(versions).sort(_semver2.default.compare)) {
+      if (!minInstallerVersion && versions[version].downloads.appImage) {
         minInstallerVersion = version;
       }
-      if (versionMap[version].downloads.appImage) {
+      if (versions[version].downloads.appImage) {
         maxInstallerVersion = version;
       }
-      versionMap[version] = mergeKeepUndefined(
-        {},
-        versionMap[version],
-        {
-          minInstallerVersion: _nullishCoalesce(versionMap[version].minInstallerVersion, () => ( minInstallerVersion)),
-          maxInstallerVersion
-        },
-        correctObsidianVersionInfo(versionMap[version])
-      );
+      versions[version] = _lodash2.default.merge({ minInstallerVersion, maxInstallerVersion }, versions[version]);
     }
     const result = {
       metadata: {
-        commitDate: _nullishCoalesce(_optionalChain([commitHistory, 'access', _33 => _33.at, 'call', _34 => _34(-1), 'optionalAccess', _35 => _35.commit, 'access', _36 => _36.committer, 'access', _37 => _37.date]), () => ( _optionalChain([original, 'optionalAccess', _38 => _38.metadata, 'access', _39 => _39.commitDate]))),
-        commitSha: _nullishCoalesce(_optionalChain([commitHistory, 'access', _40 => _40.at, 'call', _41 => _41(-1), 'optionalAccess', _42 => _42.sha]), () => ( _optionalChain([original, 'optionalAccess', _43 => _43.metadata, 'access', _44 => _44.commitSha]))),
-        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _45 => _45.metadata, 'access', _46 => _46.timestamp]), () => ( ""))
+        schemaVersion: obsidianVersionsSchemaVersion,
+        commitDate: _nullishCoalesce(_optionalChain([commitHistory, 'access', _44 => _44.at, 'call', _45 => _45(-1), 'optionalAccess', _46 => _46.commit, 'access', _47 => _47.committer, 'access', _48 => _48.date]), () => ( _optionalChain([original, 'optionalAccess', _49 => _49.metadata, 'access', _50 => _50.commitDate]))),
+        commitSha: _nullishCoalesce(_optionalChain([commitHistory, 'access', _51 => _51.at, 'call', _52 => _52(-1), 'optionalAccess', _53 => _53.sha]), () => ( _optionalChain([original, 'optionalAccess', _54 => _54.metadata, 'access', _55 => _55.commitSha]))),
+        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _56 => _56.metadata, 'access', _57 => _57.timestamp]), () => ( ""))
         // set down below
       },
-      versions: Object.values(versionMap).map(normalizeObsidianVersionInfo).sort((a, b) => _semver2.default.compare(a.version, b.version))
+      versions: Object.values(versions).map(normalizeObsidianVersionInfo).sort((a, b) => _semver2.default.compare(a.version, b.version))
     };
     const dayMs = 24 * 60 * 60 * 1e3;
-    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _47 => _47.metadata, 'access', _48 => _48.timestamp]), () => ( 0))).getTime();
+    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _58 => _58.metadata, 'access', _59 => _59.timestamp]), () => ( 0))).getTime();
     if (!_lodash2.default.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
       result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
     }
@@ -1261,18 +1495,21 @@ var ObsidianLauncher = class {
    */
   async isAvailable(appVersion) {
     const versionInfo = await this.getVersionInfo(appVersion);
-    const versionExists = !!(versionInfo.downloads.asar && versionInfo.minInstallerVersion);
-    if (versionInfo.isBeta) {
-      const hasCreds = !!(process.env["OBSIDIAN_USERNAME"] && process.env["OBSIDIAN_PASSWORD"]);
+    if (!versionInfo.downloads.asar || !versionInfo.minInstallerVersion) {
+      return false;
+    }
+    if (new URL(versionInfo.downloads.asar).hostname.endsWith(".obsidian.md")) {
+      const hasCreds = !!(process.env["OBSIDIAN_EMAIL"] && process.env["OBSIDIAN_PASSWORD"]);
       const inCache = await this.isInCache("app", versionInfo.version);
-      return versionExists && (hasCreds || inCache);
+      return hasCreds || inCache;
     } else {
-      return versionExists;
+      return true;
     }
   }
 };
 
 
 
-exports.ObsidianLauncher = ObsidianLauncher;
-//# sourceMappingURL=chunk-CUFVRSMT.cjs.map
+
+exports.watchFiles = watchFiles; exports.ObsidianLauncher = ObsidianLauncher;
+//# sourceMappingURL=chunk-KQZZMJOZ.cjs.map