obsidian-launcher 2.1.6 → 2.2.0

package/dist/{chunk-O3OTELNK.js → chunk-LBBOWJGG.js}

@@ -3,8 +3,16 @@ import fsAsync from "fs/promises";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { createConsola } from "consola";
 import { PromisePool } from "@supercharge/promise-pool";
 import _ from "lodash";
+var consola = createConsola({
+  throttle: -1,
+  // disable throttle
+  formatOptions: {
+    date: false
+  }
+});
 async function fileExists(path6) {
   try {
     await fsAsync.stat(path6);
@@ -19,6 +27,14 @@ async function fileExists(path6) {
 async function makeTmpDir(prefix) {
   return fsAsync.mkdtemp(path.join(os.tmpdir(), prefix ?? "tmp-"));
 }
+var logged = /* @__PURE__ */ new Map();
+function warnOnce(key, message) {
+  const times = 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 = path.resolve(dest);
@@ -64,6 +80,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.for(items).withConcurrency(size).handleError(async (error) => {
     throw error;
@@ -73,6 +97,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 = _.debounce((curr, prev) => {
     if (curr.mtimeMs > prev.mtimeMs || curr.mtimeMs == 0 && prev.mtimeMs != 0) {
@@ -186,15 +251,17 @@ async function obsidianApiLogin(opts) {
   let email = env.OBSIDIAN_EMAIL ?? cached.OBSIDIAN_EMAIL;
   let password = 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 || readlineSync.question("Obsidian email: ");
       password = password || readlineSync.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)" + (env.CI ? "." : ` or ${predownloadMessage}`)
       );
     }
   }
@@ -227,12 +294,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" + (env.CI ? "." : ` or ${predownloadMessage}`)
         );
       }
     } else if (["please wait", "try again"].some((m) => error?.includes(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: ${signin.error ?? "unknown error"}`);
@@ -252,7 +319,7 @@ async function obsidianApiLogin(opts) {
 OBSIDIAN_PASSWORD='${password}'
 `
       );
-      console.log(`Saved Obsidian credentials to ${path2.relative(process.cwd(), savePath)}`);
+      consola.log(`Saved Obsidian credentials to ${path2.relative(process.cwd(), savePath)}`);
     }
   }
   return signin.token;
@@ -271,13 +338,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.createWriteStream(dest, { flags: "w" });
-  const fetchStream = Readable.fromWeb(response.body);
-  await finished(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.createWriteStream(dest, { flags: "w" });
+    const fetchStream = Readable.fromWeb(response.body);
+    await finished(fetchStream.pipe(fileStream));
+  }, {
+    retryIf: (e) => !e.status || ![401, 403, 404].includes(e.status),
+    ...opts
+  });
 }
 
 // src/chromeLocalStorage.ts
@@ -366,7 +441,8 @@ import semver from "semver";
 import _3 from "lodash";
 import { pipeline } from "stream/promises";
 import zlib from "zlib";
-import { fileURLToPath } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
+import CDP from "chrome-remote-interface";
 var execFile = promisify(child_process.execFile);
 function normalizeGitHubRepo(repo) {
   return repo.match(/^(https?:\/\/)?(github.com\/)?(.*?)\/?$/)?.[3] ?? repo;
@@ -447,61 +523,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 = path4.join(tmpDir, url.split("/").at(-1));
-    await downloadResponse(await fetch(url), installerPath);
-    const exractedPath = path4.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", path4.relative(tmpDir, installerPath)], { cwd: tmpDir });
-      const lines = stdout.trim().split("\n").map((l) => l.trim());
-      const files = lines.map((l) => l.split(/\s+/).at(-1).replace(/\\/g, "/"));
-      if (files.includes("$PLUGINSDIR/app-arm64.7z")) platforms.push("win32-arm64");
-      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 fsAsync3.readdir(exractedPath, { recursive: true, withFileTypes: true });
-    for (const file of installerFiles) {
-      if (file.isFile() && !file.name.endsWith(".asar")) {
-        const stream = fs3.createReadStream(path4.join(file.parentPath, file.name), { encoding: "utf-8" });
-        let prev = "";
-        for await (let chunk of stream) {
-          const regex = /Chrome\/\d+\.\d+\.\d+\.\d+|Electron\/\d+\.\d+\.\d+/g;
-          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(() => fsAsync3.rm(vault, { recursive: true, force: true }));
+  const pluginDir = path4.join(vault, ".obsidian", "plugins", "obsidian-launcher");
+  await fsAsync3.mkdir(pluginDir, { recursive: true });
+  await fsAsync3.writeFile(path4.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 fsAsync3.writeFile(path4.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 fsAsync3.writeFile(path4.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(() => fsAsync3.rm(configDir, { recursive: true, force: true }));
+    const procExit = new Promise((resolve) => proc.on("close", (code) => resolve(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 = data.toString().match(/ws:\/\/[\w.]+?:(\d+)/)?.[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 = _3(matches).map((m) => m.split("/")).groupBy(0).mapValues((ms) => ms.map((m) => m[1])).mapValues((ms) => _3.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 fsAsync3.rm(tmpDir, { recursive: true, force: true });
+    const client = await CDP({ port: port.result });
+    cleanup.push(() => client.close());
+    const expr = semver.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";
@@ -523,32 +634,26 @@ async function fetchObsidianDesktopReleases(sinceDate, 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 (semver.satisfies(version, ">=1.3.0 <=1.3.4")) {
-      minInstallerVersion = "0.14.5";
-    } else if (semver.gte(version, "1.5.3") && semver.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
       }
     };
   };
@@ -560,11 +665,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: 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$`));
@@ -604,53 +708,179 @@ var INSTALLER_KEYS = [
   "dmg",
   "exe"
 ];
-function updateObsidianVersionList(args) {
-  const { original = [], destkopReleases = [], gitHubReleases = [], installerInfos = [] } = args;
-  const oldVersions = _3.keyBy(original, (v) => v.version);
-  const newVersions = _3.cloneDeep(oldVersions);
-  for (const destkopRelease of destkopReleases) {
-    const { current, beta } = parseObsidianDesktopRelease(destkopRelease);
-    if (beta) {
-      newVersions[beta.version] = _3.merge(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 = path4.join(tmpDir, url.split("/").at(-1));
+    await downloadResponse(() => fetch(url), installerPath);
+    const exractedPath = path4.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", path4.relative(tmpDir, installerPath)], { cwd: tmpDir });
+      const lines = stdout.trim().split("\n").map((l) => l.trim());
+      const files = lines.map((l) => l.split(/\s+/).at(-1).replace(/\\/g, "/"));
+      if (files.includes("$PLUGINSDIR/app-arm64.7z")) platforms.push("win32-arm64");
+      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] = _3.merge(newVersions[current.version] ?? {}, current);
-  }
-  for (const githubRelease of gitHubReleases) {
-    if (semver.valid(githubRelease.name) && !semver.prerelease(githubRelease.name)) {
-      const parsed = parseObsidianGithubRelease(githubRelease);
-      const newVersion = _3.merge(newVersions[parsed.version] ?? {}, parsed);
-      for (const installerKey of INSTALLER_KEYS) {
-        const oldDigest = oldVersions[parsed.version]?.installers[installerKey]?.digest;
-        const newDigest = newVersion.installers?.[installerKey]?.digest;
-        if (oldDigest && oldDigest != newDigest) {
-          newVersion.installers[installerKey] = { digest: newDigest };
+    const matches = [];
+    const installerFiles = await fsAsync3.readdir(exractedPath, { recursive: true, withFileTypes: true });
+    for (const file of installerFiles) {
+      if (file.isFile() && !file.name.endsWith(".asar")) {
+        const stream = fs3.createReadStream(path4.join(file.parentPath, file.name), { encoding: "utf-8" });
+        let prev = "";
+        for await (let chunk of stream) {
+          const regex = /Chrome\/\d+\.\d+\.\d+\.\d+|Electron\/\d+\.\d+\.\d+/g;
+          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 = _3(matches).map((m) => m.split("/")).groupBy(0).mapValues((ms) => ms.map((m) => m[1])).mapValues((ms) => _3.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 fsAsync3.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(semver.compare)) {
-    if (newVersions[version].downloads.appImage) {
-      maxInstallerVersion = version;
-      if (!minInstallerVersion) {
-        minInstallerVersion = version;
+  const { client, cleanup } = cdpResult.result;
+  let result = true;
+  try {
+    if (semver.lt(appVersion, "0.7.4")) {
+      result = semver.gte(installerVersion, "0.6.4");
+    } else if (semver.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] = _3.merge(newVersions[version], {
-      minInstallerVersion: newVersions[version]?.minInstallerVersion ?? minInstallerVersion,
-      maxInstallerVersion
-      // override maxInstallerVersion if it was already set
-    });
+  } finally {
+    await cleanup();
   }
-  for (const installerInfo of installerInfos) {
-    newVersions[installerInfo.version] = _3.merge(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: v.minInstallerVersion ?? "0.0.0",
+        maxInstallerVersion: v.maxInstallerVersion ?? "999.9.9"
+      }))
+    };
+    await fsAsync3.writeFile(path4.join(tmp, "obsidian-versions.json"), JSON.stringify(versionsFile));
+    const launcher = new ObsidianLauncher({
+      cacheDir: path4.join(tmp, "cache"),
+      versionsUrl: pathToFileURL(path4.join(tmp, "obsidian-versions.json")).toString()
     });
+    const versionArr = _3(_3.cloneDeep(versions)).sort((a, b) => semver.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 = _3.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 = _3(versions).map((v) => _3.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) => !_3.isEqual(v, origVersions[v.version]));
+  } finally {
+    await fsAsync3.rm(tmp, { recursive: true, force: true });
   }
-  return Object.values(newVersions).map(normalizeObsidianVersionInfo).sort((a, b) => semver.compare(a.version, b.version));
 }
 function normalizeObsidianVersionInfo(versionInfo) {
   versionInfo = _3.cloneDeep(versionInfo);
@@ -687,6 +917,74 @@ function normalizeObsidianVersionInfo(versionInfo) {
   };
   return normalizeObject(canonicalForm, versionInfo);
 }
+async function updateObsidianVersionList(original, {
+  maxInstances = 1,
+  _fetchObsidianDesktopReleases = fetchObsidianDesktopReleases,
+  _fetchObsidianGitHubReleases = fetchObsidianGitHubReleases,
+  _extractInstallerInfo = extractInstallerInfo,
+  _checkCompatibility = checkCompatibility
+} = {}) {
+  const oldVersions = _3.keyBy(original?.versions ?? [], (v) => v.version);
+  let newVersions = _3.cloneDeep(oldVersions);
+  const [destkopReleases, commitInfo] = await _fetchObsidianDesktopReleases(
+    original?.metadata.commitDate,
+    original?.metadata.commitSha
+  );
+  for (const destkopRelease of destkopReleases) {
+    const { current, beta } = parseObsidianDesktopRelease(destkopRelease);
+    if (beta) {
+      newVersions[beta.version] = _3.merge(newVersions[beta.version] ?? {}, beta);
+    }
+    newVersions[current.version] = _3.merge(newVersions[current.version] ?? {}, current);
+  }
+  const gitHubReleases = await _fetchObsidianGitHubReleases();
+  for (const githubRelease of gitHubReleases) {
+    if (semver.valid(githubRelease.name) && !semver.prerelease(githubRelease.name)) {
+      const parsed = parseObsidianGithubRelease(githubRelease);
+      const newVersion = _3.merge(newVersions[parsed.version] ?? {}, parsed);
+      for (const installerKey of INSTALLER_KEYS) {
+        const oldDigest = oldVersions[parsed.version]?.installers[installerKey]?.digest;
+        const newDigest = newVersion.installers?.[installerKey]?.digest;
+        if (oldDigest && oldDigest != newDigest) {
+          newVersion.installers[installerKey] = { digest: newDigest };
+        }
+      }
+      newVersions[parsed.version] = newVersion;
+    }
+  }
+  newVersions = _3.omitBy(newVersions, (v) => BROKEN_VERSIONS.includes(v.version));
+  const newInstallers = Object.values(newVersions).flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => v.downloads?.[key] && !v.installers?.[key]?.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] = _3.merge(newVersions[installerInfo.version] ?? {}, installerInfo);
+  }
+  const compatInfos = await getCompatibilityInfos(
+    Object.values(newVersions),
+    { _checkCompatibility }
+  );
+  for (const compatInfo of compatInfos) {
+    newVersions[compatInfo.version] = _3.merge(newVersions[compatInfo.version] ?? {}, compatInfo);
+  }
+  const result = {
+    metadata: {
+      schemaVersion: obsidianVersionsSchemaVersion,
+      commitDate: commitInfo.commitDate,
+      commitSha: commitInfo.commitSha,
+      timestamp: original?.metadata.timestamp ?? ""
+      // set down below
+    },
+    versions: Object.values(newVersions).map(normalizeObsidianVersionInfo).sort((a, b) => semver.compare(a.version, b.version))
+  };
+  const dayMs = 24 * 60 * 60 * 1e3;
+  const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(original?.metadata.timestamp ?? 0).getTime();
+  if (!_3.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
+    result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return result;
+}
 
 // src/launcher.ts
 var currentPlatform = {
@@ -694,6 +992,7 @@ var currentPlatform = {
   arch: process.arch
 };
 dotenv2.config({ path: [".env"], quiet: true });
+var minSupportedObsidianVersion = "0.12.8";
 var ObsidianLauncher = class {
   /**
    * Construct an ObsidianLauncher.
@@ -757,8 +1056,8 @@ var ObsidianLauncher = class {
       if (!data && await fileExists(dest)) {
         const parsed = JSON.parse(await fsAsync4.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;
         }
       }
@@ -831,8 +1130,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.lt(appVersion, minSupportedObsidianVersion)) {
+      warnOnce(
+        "unsupported-version",
+        `Obsidian versions before ${minSupportedObsidianVersion} are unsupported, some obsidian-launcher features will not work.`
+      );
     }
     if (installerVersion == "latest") {
       installerVersionInfo = _4.findLast(
@@ -841,7 +1143,7 @@ var ObsidianLauncher = class {
       );
     } else if (installerVersion == "earliest") {
       installerVersionInfo = versions.find(
-        (v) => semver2.gte(v.version, appVersionInfo.minInstallerVersion) && !!this.getInstallerKey(v, { platform, arch })
+        (v) => appVersionInfo.minInstallerVersion && semver2.gte(v.version, appVersionInfo.minInstallerVersion) && semver2.lte(v.version, appVersionInfo.version) && !!this.getInstallerKey(v, { platform, arch })
       );
     } else {
       installerVersion = semver2.valid(installerVersion) ?? installerVersion;
@@ -849,14 +1151,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.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion) || semver2.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.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion) || semver2.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];
@@ -937,6 +1240,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: path5.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.
@@ -965,9 +1282,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 = path5.join(scratch, "installer");
-      await downloadResponse(await fetch(installerInfo.url), installer);
+      await downloadResponse(() => fetch(installerInfo.url), installer);
       const extracted = path5.join(scratch, "extracted");
       await extractor(installer, extracted);
       return extracted;
@@ -978,8 +1295,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
    */
@@ -991,23 +1308,18 @@ var ObsidianLauncher = class {
     }
     const appPath = path5.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: path5.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 = path5.join(scratch, "app.asar.gz");
+      const asar = path5.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 = path5.join(scratch, "app.asar.gz");
-      const asar = path5.join(scratch, "app.asar");
-      await downloadResponse(response, archive);
       await extractGz(archive, asar);
       return asar;
     }, { replace: false });
@@ -1035,7 +1347,7 @@ var ObsidianLauncher = class {
       chromedriverPath = path5.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 downloadArtifact({
         version: installerInfo.electron,
         artifactName: "chromedriver",
@@ -1060,9 +1372,9 @@ var ObsidianLauncher = class {
     }
     const apkPath = path5.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 = path5.join(scratch, "obsidian.apk");
-      await downloadResponse(await fetch(apkUrl), dest);
+      await downloadResponse(() => fetch(apkUrl), dest);
       return dest;
     }, { replace: false });
     return apkPath;
@@ -1096,11 +1408,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, path5.join(scratch, file));
-          } else if (required) {
-            throw Error(`No ${file} found for ${repo} version ${version}`);
+          try {
+            await downloadResponse(() => fetch(url), path5.join(scratch, file));
+          } catch {
+            if (required) {
+              throw Error(`No ${file} found for ${repo} version ${version}`);
+            }
           }
         })
       );
@@ -1270,10 +1583,9 @@ var ObsidianLauncher = class {
         assetsToDownload.map(
           async (file) => {
             const url = `${baseUrl}/${file}`;
-            const response = await fetch(url);
-            if (response.ok) {
-              await downloadResponse(response, path5.join(scratch, file));
-            } else {
+            try {
+              await downloadResponse(() => fetch(url), path5.join(scratch, file));
+            } catch {
               throw Error(`No ${file} found for ${repo}`);
             }
           }
@@ -1436,6 +1748,9 @@ var ObsidianLauncher = class {
           }
         }
       });
+      if (semver2.lt(appVersion, "0.10.0")) {
+        obsidianJson.last_open = vaultId;
+      }
     }
     await fsAsync4.writeFile(path5.join(configDir, "obsidian.json"), JSON.stringify(obsidianJson));
     await fsAsync4.writeFile(path5.join(configDir, "Preferences"), JSON.stringify(chromePreferences));
@@ -1523,39 +1838,7 @@ var ObsidianLauncher = class {
    * the internal Electron version.
    */
   async updateVersionList(original, opts = {}) {
-    const { maxInstances = 1 } = opts;
-    const [destkopReleases, commitInfo] = await fetchObsidianDesktopReleases(
-      original?.metadata.commitDate,
-      original?.metadata.commitSha
-    );
-    const gitHubReleases = await fetchObsidianGitHubReleases();
-    let newVersions = updateObsidianVersionList({
-      original: original?.versions,
-      destkopReleases,
-      gitHubReleases
-    });
-    const newInstallers = newVersions.flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => v.downloads?.[key] && !v.installers?.[key]?.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: original?.metadata.timestamp ?? ""
-        // set down below
-      },
-      versions: newVersions
-    };
-    const dayMs = 24 * 60 * 60 * 1e3;
-    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(original?.metadata.timestamp ?? 0).getTime();
-    if (!_4.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.
@@ -1584,7 +1867,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(path5.join(this.cacheDir, "obsidian-credentials.env"));
       const inCache = await this.isInCache("app", versionInfo.version);
       return hasCreds || inCache;
     } else {
@@ -1594,7 +1877,9 @@ var ObsidianLauncher = class {
 };
 
 export {
+  consola,
   watchFiles,
+  minSupportedObsidianVersion,
   ObsidianLauncher
 };
-//# sourceMappingURL=chunk-O3OTELNK.js.map
+//# sourceMappingURL=chunk-LBBOWJGG.js.map