obsidian-launcher 2.1.6 → 2.2.0

package/dist/{chunk-EPJSKILH.cjs → chunk-GVT27UTK.cjs}

@@ -7,8 +7,16 @@ var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(
 var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _consola = require('consola');
 var _promisepool = require('@supercharge/promise-pool');
 var _lodash = require('lodash'); var _lodash2 = _interopRequireDefault(_lodash);
+var consola = _consola.createConsola.call(void 0, {
+  throttle: -1,
+  // disable throttle
+  formatOptions: {
+    date: false
+  }
+});
 async function fileExists(path6) {
   try {
     await _promises2.default.stat(path6);
@@ -23,6 +31,14 @@ async function fileExists(path6) {
 async function makeTmpDir(prefix) {
   return _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), _nullishCoalesce(prefix, () => ( "tmp-"))));
 }
+var logged = /* @__PURE__ */ new Map();
+function warnOnce(key, message) {
+  const times = _nullishCoalesce(logged.get(key), () => ( 0));
+  if (times <= 0) {
+    consola.warn({ message });
+  }
+  logged.set(key, times + 1);
+}
 async function atomicCreate(dest, func, opts = {}) {
   const { replace = true, preserveTmpDir = false } = opts;
   dest = _path2.default.resolve(dest);
@@ -68,6 +84,14 @@ async function linkOrCp(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;
@@ -77,6 +101,47 @@ 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 }));
 }
+async function until(func, opts) {
+  const { timeout, poll = 100 } = opts;
+  let time = 0;
+  let result;
+  let error;
+  while (!result && time < timeout) {
+    try {
+      result = await func();
+      error = void 0;
+    } catch (e) {
+      error = e;
+    }
+    if (!result) {
+      await sleep(poll);
+    }
+    time += poll;
+  }
+  if (!result) {
+    throw new Error("Timed out waiting for condition" + (error ? `: ${error}` : ""));
+  }
+  return result;
+}
+async function retry(func, opts = {}) {
+  const { retries = 4, backoff = 1e3, retryIf = () => true } = opts;
+  let attempt = 0;
+  let error;
+  while (attempt < retries) {
+    try {
+      return await func(attempt);
+    } catch (e) {
+      error = e;
+    }
+    const delay = backoff * Math.random() + backoff * Math.pow(2, attempt);
+    attempt += 1;
+    if (!retryIf(error) || attempt >= retries) {
+      throw error;
+    }
+    await sleep(delay);
+  }
+  throw error;
+}
 function watchFiles(files, func, options) {
   const debouncedFunc = _lodash2.default.debounce((curr, prev) => {
     if (curr.mtimeMs > prev.mtimeMs || curr.mtimeMs == 0 && prev.mtimeMs != 0) {
@@ -190,15 +255,17 @@ async function obsidianApiLogin(opts) {
   let email = _nullishCoalesce(_process.env.OBSIDIAN_EMAIL, () => ( cached.OBSIDIAN_EMAIL));
   let password = _nullishCoalesce(_process.env.OBSIDIAN_PASSWORD, () => ( cached.OBSIDIAN_PASSWORD));
   let promptedCredentials = false;
+  const predownloadMessage = "pre-download the Obsidian beta with:\n    npx obsidian-launcher download app -v <version>";
   if (!email || !password) {
     if (interactive) {
-      console.log("Obsidian Insiders account is required to download Obsidian beta versions.");
+      consola.log("Obsidian Insiders account is required to download Obsidian beta versions.");
+      consola.log("You can set OBSIDIAN_EMAIL and OBSIDIAN_PASSWORD environment variables (.env file is supported) to avoid this prompt.");
       email = email || _readlinesync2.default.question("Obsidian email: ");
       password = password || _readlinesync2.default.question("Obsidian password: ", { hideEchoBack: true });
       promptedCredentials = true;
     } else {
       throw Error(
-        "Obsidian Insiders account is required to download Obsidian beta versions. Either set the OBSIDIAN_EMAIL and OBSIDIAN_PASSWORD env vars (.env file is supported) or pre-download the Obsidian beta with `npx obsidian-launcher download app -v <version>`"
+        "Obsidian Insiders account is required to download Obsidian beta versions. Set the OBSIDIAN_EMAIL and OBSIDIAN_PASSWORD environment variables (.env file is supported)" + (_process.env.CI ? "." : ` or ${predownloadMessage}`)
       );
     }
   }
@@ -231,12 +298,12 @@ async function obsidianApiLogin(opts) {
       needsMfa = true;
       if (!interactive) {
         throw Error(
-          "Can't login with 2FA in a non-interactive session. To download Obsidian beta versions, either disable 2FA on your account or pre-download the Obsidian beta with `npx obsidian-launcher download app -v <version>`"
+          "Can't login with 2FA in a non-interactive session. To download Obsidian beta versions disable 2FA on your account" + (_process.env.CI ? "." : ` or ${predownloadMessage}`)
         );
       }
     } else if (["please wait", "try again"].some((m) => _optionalChain([error, 'optionalAccess', _21 => _21.includes, 'call', _22 => _22(m)]))) {
-      console.warn(`Obsidian login failed: ${signin.error}`);
-      console.warn("Retrying obsidian login...");
+      consola.warn(`Obsidian login failed: ${signin.error}`);
+      consola.warn("Retrying obsidian login...");
       retries++;
     } else if (!signin.token) {
       throw Error(`Obsidian login failed: ${_nullishCoalesce(signin.error, () => ( "unknown error"))}`);
@@ -256,7 +323,7 @@ async function obsidianApiLogin(opts) {
 OBSIDIAN_PASSWORD='${password}'
 `
       );
-      console.log(`Saved Obsidian credentials to ${_path2.default.relative(process.cwd(), savePath)}`);
+      consola.log(`Saved Obsidian credentials to ${_path2.default.relative(process.cwd(), savePath)}`);
     }
   }
   return signin.token;
@@ -275,13 +342,21 @@ async function fetchObsidianApi(url, opts) {
   });
   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));
+async function downloadResponse(func, dest, opts = {}) {
+  await retry(async () => {
+    const response = await func();
+    if (!response.ok) {
+      const error = Error(`${response.url} failed with ${response.status}`);
+      error.status = response.status;
+      throw error;
+    }
+    const fileStream = _fs2.default.createWriteStream(dest, { flags: "w" });
+    const fetchStream = _stream.Readable.fromWeb(response.body);
+    await _promises3.finished.call(void 0, fetchStream.pipe(fileStream));
+  }, {
+    retryIf: (e) => !e.status || ![401, 403, 404].includes(e.status),
+    ...opts
+  });
 }
 
 // src/chromeLocalStorage.ts
@@ -371,6 +446,7 @@ var _util = require('util');
 
 var _zlib = require('zlib'); var _zlib2 = _interopRequireDefault(_zlib);
 
+var _chromeremoteinterface = require('chrome-remote-interface'); var _chromeremoteinterface2 = _interopRequireDefault(_chromeremoteinterface);
 var execFile = _util.promisify.call(void 0, _child_process2.default.execFile);
 function normalizeGitHubRepo(repo) {
   return _nullishCoalesce(_optionalChain([repo, 'access', _26 => _26.match, 'call', _27 => _27(/^(https?:\/\/)?(github.com\/)?(.*?)\/?$/), 'optionalAccess', _28 => _28[3]]), () => ( repo));
@@ -451,61 +527,96 @@ async function extractObsidianDmg(dmg, dest) {
     }
   });
 }
-async function extractInstallerInfo(installerKey, url) {
-  const installerName = url.split("/").at(-1);
-  console.log(`Extrating installer info for ${installerName}...`);
-  const tmpDir = await makeTmpDir("obsidian-launcher-");
-  try {
-    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}`);
+async function getCdpSession(launcher, appVersion, installerVersion) {
+  [appVersion, installerVersion] = await launcher.resolveVersion(appVersion, installerVersion);
+  const cleanup = [];
+  const doCleanup = async () => {
+    for (const func of [...cleanup].reverse()) {
+      await func();
     }
-    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 vault = await makeTmpDir("obsidian-vault-");
+  cleanup.push(() => _promises2.default.rm(vault, { recursive: true, force: true }));
+  const pluginDir = _path2.default.join(vault, ".obsidian", "plugins", "obsidian-launcher");
+  await _promises2.default.mkdir(pluginDir, { recursive: true });
+  await _promises2.default.writeFile(_path2.default.join(pluginDir, "manifest.json"), JSON.stringify({
+    id: "obsidian-launcher",
+    name: "Obsidian Launcher",
+    version: "1.0.0",
+    minAppVersion: "0.0.1",
+    description: "",
+    author: "obsidian-launcher",
+    isDesktopOnly: false
+  }));
+  await _promises2.default.writeFile(_path2.default.join(pluginDir, "main.js"), `
+        const obsidian = require('obsidian');
+        class ObsidianLauncherPlugin extends obsidian.Plugin {
+            async onload() { window.obsidianLauncher = {app: this.app, obsidian: obsidian}; };
         }
+        module.exports = ObsidianLauncherPlugin;
+    `);
+  await _promises2.default.writeFile(_path2.default.join(vault, ".obsidian", "community-plugins.json"), JSON.stringify([
+    "obsidian-launcher"
+  ]));
+  try {
+    const { proc, configDir } = await launcher.launch({
+      appVersion,
+      installerVersion,
+      vault,
+      copy: false,
+      args: [`--remote-debugging-port=0`, "--test-type=webdriver"]
+      // will choose a random available port
+    });
+    cleanup.push(() => _promises2.default.rm(configDir, { recursive: true, force: true }));
+    const procExit = new Promise((resolve) => proc.on("close", (code) => resolve(_nullishCoalesce(code, () => ( -1)))));
+    cleanup.push(async () => {
+      proc.kill("SIGTERM");
+      const timeout = await maybe(withTimeout(procExit, 5 * 1e3));
+      if (!timeout.success) {
+        consola.warn(`Stuck process ${proc.pid}, using SIGKILL`);
+        proc.kill("SIGKILL");
       }
+      await procExit;
+    });
+    const portPromise = new Promise((resolve, reject) => {
+      void procExit.then(() => reject(Error("Processed ended without opening a port")));
+      proc.stderr.on("data", (data) => {
+        const port2 = _optionalChain([data, 'access', _29 => _29.toString, 'call', _30 => _30(), 'access', _31 => _31.match, 'call', _32 => _32(/ws:\/\/[\w.]+?:(\d+)/), 'optionalAccess', _33 => _33[1]]);
+        if (port2) {
+          resolve(Number(port2));
+        }
+      });
+    });
+    const port = await maybe(withTimeout(portPromise, 20 * 1e3));
+    if (!port.success) {
+      throw new Error("Timed out waiting for Chrome DevTools protocol port");
     }
-    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}`);
-    }
-    console.log(`Extracted installer info for ${installerName}`);
-    return { electron, chrome, platforms };
-  } finally {
-    await _promises2.default.rm(tmpDir, { recursive: true, force: true });
+    const client = await _chromeremoteinterface2.default.call(void 0, { port: port.result });
+    cleanup.push(() => client.close());
+    const expr = _semver2.default.gte(appVersion, "0.12.8") ? "!!window.obsidianLauncher" : "!!window.app.workspace";
+    await until(
+      () => client.Runtime.evaluate({ expression: expr }).then((r) => r.result.value),
+      { timeout: 5e3 }
+    );
+    return {
+      client,
+      cleanup: doCleanup,
+      proc
+    };
+  } catch (e) {
+    await doCleanup();
+    throw e;
+  }
+}
+async function cdpEvaluate(client, expression) {
+  const response = await client.Runtime.evaluate({ expression, returnByValue: true });
+  if (response.exceptionDetails) {
+    throw Error(response.exceptionDetails.text);
   }
+  return response.result.value;
+}
+async function cdpEvaluateUntil(client, expression, opts) {
+  return await until(() => cdpEvaluate(client, expression), opts);
 }
 async function fetchObsidianDesktopReleases(sinceDate, sinceSha) {
   const repo = "obsidianmd/obsidian-releases";
@@ -522,37 +633,31 @@ async function fetchObsidianDesktopReleases(sinceDate, sinceSha) {
     commitHistory,
     (commit) => fetch(`https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
   );
-  const commitDate = _nullishCoalesce(_optionalChain([commitHistory, 'access', _29 => _29.at, 'call', _30 => _30(-1), 'optionalAccess', _31 => _31.commit, 'access', _32 => _32.committer, 'access', _33 => _33.date]), () => ( sinceDate));
-  const commitSha = _nullishCoalesce(_optionalChain([commitHistory, 'access', _34 => _34.at, 'call', _35 => _35(-1), 'optionalAccess', _36 => _36.sha]), () => ( sinceSha));
+  const commitDate = _nullishCoalesce(_optionalChain([commitHistory, 'access', _34 => _34.at, 'call', _35 => _35(-1), 'optionalAccess', _36 => _36.commit, 'access', _37 => _37.committer, 'access', _38 => _38.date]), () => ( sinceDate));
+  const commitSha = _nullishCoalesce(_optionalChain([commitHistory, 'access', _39 => _39.at, 'call', _40 => _40(-1), 'optionalAccess', _41 => _41.sha]), () => ( sinceSha));
   return [fileHistory, { commitDate, commitSha }];
 }
 async function fetchObsidianGitHubReleases() {
-  const gitHubReleases = await fetchGitHubAPIPaginated(`repos/obsidianmd/obsidian-releases/releases`);
-  return gitHubReleases.reverse();
+  const releases = await fetchGitHubAPIPaginated(`repos/obsidianmd/obsidian-releases/releases`);
+  return releases.reverse();
 }
-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"
+var BROKEN_VERSIONS = [
+  "0.12.16",
+  // broken download link
+  "1.4.7",
+  // broken download link
+  "1.4.8",
+  // broken download link
+  "1.0.1"
+  // won't launch
 ];
 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
+        asar: r.downloadUrl
       }
     };
   };
@@ -564,11 +669,10 @@ function parseObsidianDesktopRelease(fileRelease) {
 }
 function parseObsidianGithubRelease(gitHubRelease) {
   const version = gitHubRelease.name;
-  let assets = gitHubRelease.assets.map((a) => ({
+  const 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$`));
@@ -581,14 +685,14 @@ function parseObsidianGithubRelease(gitHubRelease) {
     version,
     gitHubRelease: gitHubRelease.html_url,
     downloads: {
-      asar: _optionalChain([asar, 'optionalAccess', _37 => _37.url]),
-      appImage: _optionalChain([appImage, 'optionalAccess', _38 => _38.url]),
-      appImageArm: _optionalChain([appImageArm, 'optionalAccess', _39 => _39.url]),
-      tar: _optionalChain([tar, 'optionalAccess', _40 => _40.url]),
-      tarArm: _optionalChain([tarArm, 'optionalAccess', _41 => _41.url]),
-      dmg: _optionalChain([dmg, 'optionalAccess', _42 => _42.url]),
-      exe: _optionalChain([exe, 'optionalAccess', _43 => _43.url]),
-      apk: _optionalChain([apk, 'optionalAccess', _44 => _44.url])
+      asar: _optionalChain([asar, 'optionalAccess', _42 => _42.url]),
+      appImage: _optionalChain([appImage, 'optionalAccess', _43 => _43.url]),
+      appImageArm: _optionalChain([appImageArm, 'optionalAccess', _44 => _44.url]),
+      tar: _optionalChain([tar, 'optionalAccess', _45 => _45.url]),
+      tarArm: _optionalChain([tarArm, 'optionalAccess', _46 => _46.url]),
+      dmg: _optionalChain([dmg, 'optionalAccess', _47 => _47.url]),
+      exe: _optionalChain([exe, 'optionalAccess', _48 => _48.url]),
+      apk: _optionalChain([apk, 'optionalAccess', _49 => _49.url])
     },
     installers: {
       appImage: appImage ? { digest: appImage.digest } : void 0,
@@ -608,58 +712,184 @@ var INSTALLER_KEYS = [
   "dmg",
   "exe"
 ];
-function updateObsidianVersionList(args) {
-  const { original = [], destkopReleases = [], gitHubReleases = [], installerInfos = [] } = args;
-  const oldVersions = _lodash2.default.keyBy(original, (v) => v.version);
-  const newVersions = _lodash2.default.cloneDeep(oldVersions);
-  for (const destkopRelease of destkopReleases) {
-    const { current, beta } = parseObsidianDesktopRelease(destkopRelease);
-    if (beta) {
-      newVersions[beta.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[beta.version], () => ( {})), beta);
+async function extractInstallerInfo(version, installerKey, url) {
+  const installerName = url.split("/").at(-1);
+  consola.log(`Extrating installer info for ${installerName}...`);
+  const tmpDir = await makeTmpDir("obsidian-launcher-");
+  try {
+    const installerPath = _path2.default.join(tmpDir, url.split("/").at(-1));
+    await downloadResponse(() => 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}`);
     }
-    newVersions[current.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[current.version], () => ( {})), current);
-  }
-  for (const githubRelease of gitHubReleases) {
-    if (_semver2.default.valid(githubRelease.name) && !_semver2.default.prerelease(githubRelease.name)) {
-      const parsed = parseObsidianGithubRelease(githubRelease);
-      const newVersion = _lodash2.default.merge(_nullishCoalesce(newVersions[parsed.version], () => ( {})), parsed);
-      for (const installerKey of INSTALLER_KEYS) {
-        const oldDigest = _optionalChain([oldVersions, 'access', _45 => _45[parsed.version], 'optionalAccess', _46 => _46.installers, 'access', _47 => _47[installerKey], 'optionalAccess', _48 => _48.digest]);
-        const newDigest = _optionalChain([newVersion, 'access', _49 => _49.installers, 'optionalAccess', _50 => _50[installerKey], 'optionalAccess', _51 => _51.digest]);
-        if (oldDigest && oldDigest != newDigest) {
-          newVersion.installers[installerKey] = { digest: newDigest };
+    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);
         }
       }
-      newVersions[parsed.version] = newVersion;
     }
+    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}`);
+    }
+    consola.log(`Extracted installer info for ${installerName}`);
+    return { electron, chrome, platforms };
+  } finally {
+    await _promises2.default.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+async function checkCompatibility(launcher, appVersion, installerVersion) {
+  [appVersion, installerVersion] = await launcher.resolveVersion(appVersion, installerVersion);
+  consola.log(`Checking if app ${appVersion} and installer ${installerVersion} are compatible...`);
+  await launcher.downloadApp(appVersion);
+  await launcher.downloadInstaller(installerVersion);
+  const cdpResult = await maybe(retry(
+    () => getCdpSession(launcher, appVersion, installerVersion),
+    { retries: 3, backoff: 4e3 }
+  ));
+  if (!cdpResult.success) {
+    consola.log(`app ${appVersion} with installer ${installerVersion} failed to launch: ${cdpResult.error}`);
+    return false;
   }
-  let minInstallerVersion = void 0;
-  let maxInstallerVersion = void 0;
-  for (const version of Object.keys(newVersions).sort(_semver2.default.compare)) {
-    if (newVersions[version].downloads.appImage) {
-      maxInstallerVersion = version;
-      if (!minInstallerVersion) {
-        minInstallerVersion = version;
+  const { client, cleanup } = cdpResult.result;
+  let result = true;
+  try {
+    if (_semver2.default.lt(appVersion, "0.7.4")) {
+      result = _semver2.default.gte(installerVersion, "0.6.4");
+    } else if (_semver2.default.lt(appVersion, "0.13.4")) {
+      await cdpEvaluate(client, `window.app.commands.executeCommandById('app:open-settings')`);
+      await until(() => cdpEvaluate(client, `
+                document.evaluate(
+                    "//*[contains(@class, 'vertical-tab-nav-item') and contains(text(),'About')]",
+                    document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null
+                ).singleNodeValue.click() ?? true;
+            `), { timeout: 5e3 });
+      const aboutText = await until(() => cdpEvaluate(client, `
+                document.evaluate(
+                    "//*[contains(@class, 'setting-item-name') and contains(text(),'Current version:')]",
+                    document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null
+                ).singleNodeValue.parentNode.innerText;
+            `), { timeout: 5e3 });
+      if (["manual installation", "manually install"].some((t) => aboutText.includes(t))) {
+        result = false;
+      }
+    } else {
+      await cdpEvaluate(client, `window.obsidianLauncher.app.commands.executeCommandById('app:show-debug-info')`);
+      const debugInfo = await cdpEvaluateUntil(
+        client,
+        `document.querySelector(".debug-textarea").value.trim()`,
+        { timeout: 5e3 }
+      );
+      if (debugInfo.toLowerCase().match(/installer version too low/)) {
+        result = false;
       }
     }
-    newVersions[version] = _lodash2.default.merge(newVersions[version], {
-      minInstallerVersion: _nullishCoalesce(_optionalChain([newVersions, 'access', _52 => _52[version], 'optionalAccess', _53 => _53.minInstallerVersion]), () => ( minInstallerVersion)),
-      maxInstallerVersion
-      // override maxInstallerVersion if it was already set
-    });
+  } finally {
+    await cleanup();
   }
-  for (const installerInfo of installerInfos) {
-    newVersions[installerInfo.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[installerInfo.version], () => ( {})), {
-      version: installerInfo.version,
-      installers: { [installerInfo.key]: installerInfo.installerInfo }
+  consola.log(`app ${appVersion} and installer ${installerVersion} are ${!result ? "in" : ""}compatible`);
+  return result;
+}
+async function getCompatibilityInfos(versions, { _checkCompatibility = checkCompatibility } = {}) {
+  const tmp = await makeTmpDir("obsidian-installer-compat-");
+  try {
+    const versionsFile = {
+      metadata: {
+        schemaVersion: obsidianVersionsSchemaVersion,
+        commitDate: "1970-01-01T00:00:00Z",
+        commitSha: "0000000000000000000000000000000000000000",
+        timestamp: "1970-01-01T00:00:00Z"
+      },
+      versions: versions.map((v) => ({
+        ...v,
+        minInstallerVersion: _nullishCoalesce(v.minInstallerVersion, () => ( "0.0.0")),
+        maxInstallerVersion: _nullishCoalesce(v.maxInstallerVersion, () => ( "999.9.9"))
+      }))
+    };
+    await _promises2.default.writeFile(_path2.default.join(tmp, "obsidian-versions.json"), JSON.stringify(versionsFile));
+    const launcher = new ObsidianLauncher({
+      cacheDir: _path2.default.join(tmp, "cache"),
+      versionsUrl: _url.pathToFileURL.call(void 0, _path2.default.join(tmp, "obsidian-versions.json")).toString()
     });
+    const versionArr = _lodash2.default.call(void 0, _lodash2.default.cloneDeep(versions)).sort((a, b) => _semver2.default.compare(a.version, b.version)).dropWhile((v) => !v.downloads.appImage).filter((v) => !!v.downloads.asar).value();
+    let maxInstallerVersion = void 0;
+    for (const version of versionArr) {
+      if (version.downloads.appImage) {
+        maxInstallerVersion = version.version;
+      }
+      version.maxInstallerVersion = maxInstallerVersion;
+    }
+    const installerArr = versionArr.filter((v) => !!v.downloads.appImage);
+    const installerIndexMap = _lodash2.default.fromPairs(installerArr.map((v, i) => [v.version, i]));
+    for (const [i, version] of versionArr.entries()) {
+      if (version.minInstallerVersion) {
+        continue;
+      }
+      const prev = i > 0 ? versionArr[i - 1] : void 0;
+      let start = prev ? installerIndexMap[prev.minInstallerVersion] : 0;
+      let end = installerIndexMap[version.maxInstallerVersion];
+      while (start <= end) {
+        const mid = Math.floor((start + end) / 2);
+        const compatible = await _checkCompatibility(
+          launcher,
+          version.version,
+          installerArr[mid].version
+        );
+        if (!compatible) {
+          start = mid + 1;
+        } else {
+          end = mid - 1;
+        }
+      }
+      if (start > installerIndexMap[version.maxInstallerVersion]) {
+        throw Error(`${version.version} failed to launch for all installers`);
+      }
+      version.minInstallerVersion = installerArr[start].version;
+    }
+    const origVersions = _lodash2.default.call(void 0, versions).map((v) => _lodash2.default.pick(v, ["version", "minInstallerVersion", "maxInstallerVersion"])).keyBy((v) => v.version).value();
+    return versionArr.map((v) => ({
+      version: v.version,
+      minInstallerVersion: v.minInstallerVersion,
+      maxInstallerVersion: v.maxInstallerVersion
+    })).filter((v) => !_lodash2.default.isEqual(v, origVersions[v.version]));
+  } finally {
+    await _promises2.default.rm(tmp, { recursive: true, force: true });
   }
-  return Object.values(newVersions).map(normalizeObsidianVersionInfo).sort((a, b) => _semver2.default.compare(a.version, b.version));
 }
 function normalizeObsidianVersionInfo(versionInfo) {
   versionInfo = _lodash2.default.cloneDeep(versionInfo);
-  versionInfo.electronVersion = _optionalChain([versionInfo, 'access', _54 => _54.installers, 'optionalAccess', _55 => _55.appImage, 'optionalAccess', _56 => _56.electron]);
-  versionInfo.chromeVersion = _optionalChain([versionInfo, 'access', _57 => _57.installers, 'optionalAccess', _58 => _58.appImage, 'optionalAccess', _59 => _59.chrome]);
+  versionInfo.electronVersion = _optionalChain([versionInfo, 'access', _50 => _50.installers, 'optionalAccess', _51 => _51.appImage, 'optionalAccess', _52 => _52.electron]);
+  versionInfo.chromeVersion = _optionalChain([versionInfo, 'access', _53 => _53.installers, 'optionalAccess', _54 => _54.appImage, 'optionalAccess', _55 => _55.chrome]);
   versionInfo.downloads = _nullishCoalesce(versionInfo.downloads, () => ( {}));
   versionInfo.installers = _nullishCoalesce(versionInfo.installers, () => ( {}));
   const canonicalForm = {
@@ -691,6 +921,74 @@ function normalizeObsidianVersionInfo(versionInfo) {
   };
   return normalizeObject(canonicalForm, versionInfo);
 }
+async function updateObsidianVersionList(original, {
+  maxInstances = 1,
+  _fetchObsidianDesktopReleases = fetchObsidianDesktopReleases,
+  _fetchObsidianGitHubReleases = fetchObsidianGitHubReleases,
+  _extractInstallerInfo = extractInstallerInfo,
+  _checkCompatibility = checkCompatibility
+} = {}) {
+  const oldVersions = _lodash2.default.keyBy(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _56 => _56.versions]), () => ( [])), (v) => v.version);
+  let newVersions = _lodash2.default.cloneDeep(oldVersions);
+  const [destkopReleases, commitInfo] = await _fetchObsidianDesktopReleases(
+    _optionalChain([original, 'optionalAccess', _57 => _57.metadata, 'access', _58 => _58.commitDate]),
+    _optionalChain([original, 'optionalAccess', _59 => _59.metadata, 'access', _60 => _60.commitSha])
+  );
+  for (const destkopRelease of destkopReleases) {
+    const { current, beta } = parseObsidianDesktopRelease(destkopRelease);
+    if (beta) {
+      newVersions[beta.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[beta.version], () => ( {})), beta);
+    }
+    newVersions[current.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[current.version], () => ( {})), current);
+  }
+  const gitHubReleases = await _fetchObsidianGitHubReleases();
+  for (const githubRelease of gitHubReleases) {
+    if (_semver2.default.valid(githubRelease.name) && !_semver2.default.prerelease(githubRelease.name)) {
+      const parsed = parseObsidianGithubRelease(githubRelease);
+      const newVersion = _lodash2.default.merge(_nullishCoalesce(newVersions[parsed.version], () => ( {})), parsed);
+      for (const installerKey of INSTALLER_KEYS) {
+        const oldDigest = _optionalChain([oldVersions, 'access', _61 => _61[parsed.version], 'optionalAccess', _62 => _62.installers, 'access', _63 => _63[installerKey], 'optionalAccess', _64 => _64.digest]);
+        const newDigest = _optionalChain([newVersion, 'access', _65 => _65.installers, 'optionalAccess', _66 => _66[installerKey], 'optionalAccess', _67 => _67.digest]);
+        if (oldDigest && oldDigest != newDigest) {
+          newVersion.installers[installerKey] = { digest: newDigest };
+        }
+      }
+      newVersions[parsed.version] = newVersion;
+    }
+  }
+  newVersions = _lodash2.default.omitBy(newVersions, (v) => BROKEN_VERSIONS.includes(v.version));
+  const newInstallers = Object.values(newVersions).flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => _optionalChain([v, 'access', _68 => _68.downloads, 'optionalAccess', _69 => _69[key]]) && !_optionalChain([v, 'access', _70 => _70.installers, 'optionalAccess', _71 => _71[key], 'optionalAccess', _72 => _72.chrome]));
+  const installerInfos = await pool(maxInstances, newInstallers, async ([v, key]) => {
+    const installerInfo = await _extractInstallerInfo(v.version, key, v.downloads[key]);
+    return { version: v.version, installers: { [key]: installerInfo } };
+  });
+  for (const installerInfo of installerInfos) {
+    newVersions[installerInfo.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[installerInfo.version], () => ( {})), installerInfo);
+  }
+  const compatInfos = await getCompatibilityInfos(
+    Object.values(newVersions),
+    { _checkCompatibility }
+  );
+  for (const compatInfo of compatInfos) {
+    newVersions[compatInfo.version] = _lodash2.default.merge(_nullishCoalesce(newVersions[compatInfo.version], () => ( {})), compatInfo);
+  }
+  const result = {
+    metadata: {
+      schemaVersion: obsidianVersionsSchemaVersion,
+      commitDate: commitInfo.commitDate,
+      commitSha: commitInfo.commitSha,
+      timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _73 => _73.metadata, 'access', _74 => _74.timestamp]), () => ( ""))
+      // set down below
+    },
+    versions: Object.values(newVersions).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', _75 => _75.metadata, 'access', _76 => _76.timestamp]), () => ( 0))).getTime();
+  if (!_lodash2.default.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
+    result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return result;
+}
 
 // src/launcher.ts
 var currentPlatform = {
@@ -698,6 +996,7 @@ var currentPlatform = {
   arch: process.arch
 };
 _dotenv2.default.config({ path: [".env"], quiet: true });
+var minSupportedObsidianVersion = "0.12.8";
 var ObsidianLauncher = class {
   /**
    * Construct an ObsidianLauncher.
@@ -731,7 +1030,7 @@ var ObsidianLauncher = class {
     if (!(dest in this.metadataCache)) {
       let data;
       let error;
-      const cacheMtime = await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => void 0)), 'optionalAccess', async _60 => _60.mtime]);
+      const cacheMtime = await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => void 0)), 'optionalAccess', async _77 => _77.mtime]);
       if (url.startsWith("file:")) {
         data = JSON.parse(await _promises2.default.readFile(_url.fileURLToPath.call(void 0, url), "utf-8"));
       }
@@ -761,8 +1060,8 @@ var ObsidianLauncher = class {
       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.`);
+          consola.warn(error);
+          consola.warn(`Unable to download ${url}, using cached file.`);
           data = parsed;
         }
       }
@@ -835,8 +1134,11 @@ var ObsidianLauncher = class {
     appVersion = appVersionInfo.version;
     let installerVersionInfo;
     const { platform, arch } = process;
-    if (!appVersionInfo.minInstallerVersion || !appVersionInfo.maxInstallerVersion) {
-      throw Error(`No installers available for Obsidian ${appVersion}`);
+    if (_semver2.default.lt(appVersion, minSupportedObsidianVersion)) {
+      warnOnce(
+        "unsupported-version",
+        `Obsidian versions before ${minSupportedObsidianVersion} are unsupported, some obsidian-launcher features will not work.`
+      );
     }
     if (installerVersion == "latest") {
       installerVersionInfo = _lodash2.default.findLast(
@@ -845,7 +1147,7 @@ var ObsidianLauncher = class {
       );
     } else if (installerVersion == "earliest") {
       installerVersionInfo = versions.find(
-        (v) => _semver2.default.gte(v.version, appVersionInfo.minInstallerVersion) && !!this.getInstallerKey(v, { platform, arch })
+        (v) => appVersionInfo.minInstallerVersion && _semver2.default.gte(v.version, appVersionInfo.minInstallerVersion) && _semver2.default.lte(v.version, appVersionInfo.version) && !!this.getInstallerKey(v, { platform, arch })
       );
     } else {
       installerVersion = _nullishCoalesce(_semver2.default.valid(installerVersion), () => ( installerVersion));
@@ -853,14 +1155,15 @@ var ObsidianLauncher = class {
     }
     if (!installerVersionInfo) {
       if (["earliest", "latest"].includes(installerVersion)) {
-        throw Error(`No compatible installers available for Obsidian ${appVersion}`);
+        throw Error(`No compatible installers available for Obsidian ${appVersion} for ${platform}-${arch}`);
       } 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(
-        `App and installer versions incompatible: app ${appVersionInfo.version} is compatible with installer >=${appVersionInfo.minInstallerVersion} <=${appVersionInfo.maxInstallerVersion} but ${installerVersionInfo.version} specified`
+    if (!appVersionInfo.minInstallerVersion || !appVersionInfo.maxInstallerVersion || _semver2.default.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion) || _semver2.default.gt(installerVersionInfo.version, appVersionInfo.maxInstallerVersion)) {
+      warnOnce(
+        `incompatible-versions-${appVersionInfo.version}-${installerVersionInfo.version}`,
+        `App and installer versions are incompatible: app ${appVersionInfo.version} is compatible with installer >=${appVersionInfo.minInstallerVersion} <=${appVersionInfo.maxInstallerVersion} but ${installerVersionInfo.version} specified.`
       );
     }
     return [appVersionInfo.version, installerVersionInfo.version];
@@ -877,7 +1180,7 @@ var ObsidianLauncher = class {
       appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
     } else if (appVersion == "earliest") {
       const manifest = await this.getRootManifest();
-      if (!_optionalChain([manifest, 'optionalAccess', _61 => _61.minAppVersion])) {
+      if (!_optionalChain([manifest, 'optionalAccess', _78 => _78.minAppVersion])) {
         throw Error('Unable to resolve Obsidian appVersion "earliest", no manifest.json or minAppVersion found.');
       }
       appVersion = manifest.minAppVersion;
@@ -941,6 +1244,20 @@ var ObsidianLauncher = class {
       );
     }
   }
+  /**
+   * Log into the Obsidian api using your Insider's account so you can download beta versions.
+   *
+   * login will be called automatically when using downloadApp on an Obsidian beta version so you usually won't need
+   * to call this directly.
+   */
+  async login() {
+    if (!this.obsidianApiToken) {
+      this.obsidianApiToken = await obsidianApiLogin({
+        interactive: this.interactive,
+        savePath: _path2.default.join(this.cacheDir, "obsidian-credentials.env")
+      });
+    }
+  }
   /**
    * Downloads the Obsidian installer for the given version and platform/arch (defaults to host platform/arch).
    * Returns the file path.
@@ -969,9 +1286,9 @@ var ObsidianLauncher = class {
       throw Error(`Unsupported platform ${platform}`);
     }
     await atomicCreate(installerDir, async (scratch) => {
-      console.log(`Downloading Obsidian installer v${installerVersion}...`);
+      consola.log(`Downloading Obsidian installer v${installerVersion}...`);
       const installer = _path2.default.join(scratch, "installer");
-      await downloadResponse(await fetch(installerInfo.url), installer);
+      await downloadResponse(() => fetch(installerInfo.url), installer);
       const extracted = _path2.default.join(scratch, "extracted");
       await extractor(installer, extracted);
       return extracted;
@@ -982,8 +1299,8 @@ var ObsidianLauncher = class {
    * Downloads the Obsidian asar for the given version. Returns the file path.
    * 
    * 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 app -v latest-beta`
+   * `OBSIDIAN_EMAIL` and `OBSIDIAN_PASSWORD` environment variables (`.env` file is supported) or pre-download the
+   * Obsidian beta with `npx obsidian-launcher download app -v latest-beta`
    * 
    * @param appVersion Obsidian version to download
    */
@@ -995,23 +1312,18 @@ var ObsidianLauncher = class {
     }
     const appPath = _path2.default.join(this.cacheDir, "obsidian-app", `obsidian-${versionInfo.version}.asar`);
     const isInsiders = new URL(appUrl).hostname.endsWith(".obsidian.md");
-    if (isInsiders && !this.obsidianApiToken && !await fileExists(appPath)) {
-      this.obsidianApiToken = await obsidianApiLogin({
-        interactive: this.interactive,
-        savePath: _path2.default.join(this.cacheDir, "obsidian-credentials.env")
-      });
+    if (isInsiders && !await fileExists(appPath)) {
+      await this.login();
     }
     await atomicCreate(appPath, async (scratch) => {
-      console.log(`Downloading Obsidian app v${versionInfo.version} ...`);
-      let response;
+      consola.log(`Downloading Obsidian app v${versionInfo.version} ...`);
+      const archive = _path2.default.join(scratch, "app.asar.gz");
+      const asar = _path2.default.join(scratch, "app.asar");
       if (isInsiders) {
-        response = await fetchObsidianApi(appUrl, { token: this.obsidianApiToken });
+        await downloadResponse(() => fetchObsidianApi(appUrl, { token: this.obsidianApiToken }), archive);
       } else {
-        response = await fetch(appUrl);
+        await downloadResponse(() => fetch(appUrl), archive);
       }
-      const archive = _path2.default.join(scratch, "app.asar.gz");
-      const asar = _path2.default.join(scratch, "app.asar");
-      await downloadResponse(response, archive);
       await extractGz(archive, asar);
       return asar;
     }, { replace: false });
@@ -1039,7 +1351,7 @@ var ObsidianLauncher = class {
       chromedriverPath = _path2.default.join(chromedriverDir, `chromedriver`);
     }
     await atomicCreate(chromedriverDir, async (scratch) => {
-      console.log(`Downloading chromedriver for electron ${installerInfo.electron} ...`);
+      consola.log(`Downloading chromedriver for electron ${installerInfo.electron} ...`);
       const chromedriverZipPath = await _get.downloadArtifact.call(void 0, {
         version: installerInfo.electron,
         artifactName: "chromedriver",
@@ -1064,9 +1376,9 @@ var ObsidianLauncher = class {
     }
     const apkPath = _path2.default.join(this.cacheDir, "obsidian-apk", `obsidian-${versionInfo.version}.apk`);
     await atomicCreate(apkPath, async (scratch) => {
-      console.log(`Downloading Obsidian apk v${versionInfo.version} ...`);
+      consola.log(`Downloading Obsidian apk v${versionInfo.version} ...`);
       const dest = _path2.default.join(scratch, "obsidian.apk");
-      await downloadResponse(await fetch(apkUrl), dest);
+      await downloadResponse(() => fetch(apkUrl), dest);
       return dest;
     }, { replace: false });
     return apkPath;
@@ -1100,11 +1412,12 @@ var ObsidianLauncher = class {
       await Promise.all(
         Object.entries(assetsToDownload).map(async ([file, required]) => {
           const url = `https://github.com/${repo}/releases/download/${version}/${file}`;
-          const response = await fetch(url);
-          if (response.ok) {
-            await downloadResponse(response, _path2.default.join(scratch, file));
-          } else if (required) {
-            throw Error(`No ${file} found for ${repo} version ${version}`);
+          try {
+            await downloadResponse(() => fetch(url), _path2.default.join(scratch, file));
+          } catch (e3) {
+            if (required) {
+              throw Error(`No ${file} found for ${repo} version ${version}`);
+            }
           }
         })
       );
@@ -1274,10 +1587,9 @@ var ObsidianLauncher = class {
         assetsToDownload.map(
           async (file) => {
             const url = `${baseUrl}/${file}`;
-            const response = await fetch(url);
-            if (response.ok) {
-              await downloadResponse(response, _path2.default.join(scratch, file));
-            } else {
+            try {
+              await downloadResponse(() => fetch(url), _path2.default.join(scratch, file));
+            } catch (e4) {
               throw Error(`No ${file} found for ${repo}`);
             }
           }
@@ -1440,6 +1752,9 @@ var ObsidianLauncher = class {
           }
         }
       });
+      if (_semver2.default.lt(appVersion, "0.10.0")) {
+        obsidianJson.last_open = vaultId;
+      }
     }
     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));
@@ -1527,39 +1842,7 @@ var ObsidianLauncher = class {
    * the internal Electron version.
    */
   async updateVersionList(original, opts = {}) {
-    const { maxInstances = 1 } = opts;
-    const [destkopReleases, commitInfo] = await fetchObsidianDesktopReleases(
-      _optionalChain([original, 'optionalAccess', _62 => _62.metadata, 'access', _63 => _63.commitDate]),
-      _optionalChain([original, 'optionalAccess', _64 => _64.metadata, 'access', _65 => _65.commitSha])
-    );
-    const gitHubReleases = await fetchObsidianGitHubReleases();
-    let newVersions = updateObsidianVersionList({
-      original: _optionalChain([original, 'optionalAccess', _66 => _66.versions]),
-      destkopReleases,
-      gitHubReleases
-    });
-    const newInstallers = newVersions.flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => _optionalChain([v, 'access', _67 => _67.downloads, 'optionalAccess', _68 => _68[key]]) && !_optionalChain([v, 'access', _69 => _69.installers, 'optionalAccess', _70 => _70[key], 'optionalAccess', _71 => _71.chrome]));
-    const installerInfos = await pool(maxInstances, newInstallers, async ([v, key]) => {
-      const installerInfo = await extractInstallerInfo(key, v.downloads[key]);
-      return { version: v.version, key, installerInfo };
-    });
-    newVersions = updateObsidianVersionList({ original: newVersions, installerInfos });
-    const result = {
-      metadata: {
-        schemaVersion: obsidianVersionsSchemaVersion,
-        commitDate: commitInfo.commitDate,
-        commitSha: commitInfo.commitSha,
-        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _72 => _72.metadata, 'access', _73 => _73.timestamp]), () => ( ""))
-        // set down below
-      },
-      versions: newVersions
-    };
-    const dayMs = 24 * 60 * 60 * 1e3;
-    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _74 => _74.metadata, 'access', _75 => _75.timestamp]), () => ( 0))).getTime();
-    if (!_lodash2.default.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
-      result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    return result;
+    return updateObsidianVersionList(original, { maxInstances: opts.maxInstances });
   }
   /**
    * Returns true if the Obsidian version is already in the cache.
@@ -1588,7 +1871,7 @@ var ObsidianLauncher = class {
       return false;
     }
     if (new URL(versionInfo.downloads.asar).hostname.endsWith(".obsidian.md")) {
-      const hasCreds = !!(process.env["OBSIDIAN_EMAIL"] && process.env["OBSIDIAN_PASSWORD"]);
+      const hasCreds = !!(process.env["OBSIDIAN_EMAIL"] && process.env["OBSIDIAN_PASSWORD"]) || await fileExists(_path2.default.join(this.cacheDir, "obsidian-credentials.env"));
       const inCache = await this.isInCache("app", versionInfo.version);
       return hasCreds || inCache;
     } else {
@@ -1600,5 +1883,7 @@ var ObsidianLauncher = class {
 
 
 
-exports.watchFiles = watchFiles; exports.ObsidianLauncher = ObsidianLauncher;
-//# sourceMappingURL=chunk-EPJSKILH.cjs.map
+
+
+exports.consola = consola; exports.watchFiles = watchFiles; exports.minSupportedObsidianVersion = minSupportedObsidianVersion; exports.ObsidianLauncher = ObsidianLauncher;
+//# sourceMappingURL=chunk-GVT27UTK.cjs.map