obsidian-launcher 0.0.1

package/dist/chunk-64XS3NWI.cjs

@@ -0,0 +1,1115 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/launcher.ts
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _zlib = require('zlib'); var _zlib2 = _interopRequireDefault(_zlib);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _nodefetch = require('node-fetch'); var _nodefetch2 = _interopRequireDefault(_nodefetch);
+var _extractzip = require('extract-zip'); var _extractzip2 = _interopRequireDefault(_extractzip);
+var _promises3 = require('stream/promises');
+var _get = require('@electron/get');
+var _child_process = require('child_process'); var _child_process2 = _interopRequireDefault(_child_process);
+var _semver = require('semver'); var _semver2 = _interopRequireDefault(_semver);
+var _chromeremoteinterface = require('chrome-remote-interface'); var _chromeremoteinterface2 = _interopRequireDefault(_chromeremoteinterface);
+
+// src/utils.ts
+
+
+var _promisepool = require('@supercharge/promise-pool');
+async function fileExists(path5) {
+  try {
+    await _promises2.default.access(path5);
+    return true;
+  } catch (e2) {
+    return false;
+  }
+}
+async function withTmpDir(dest, func) {
+  dest = _path2.default.resolve(dest);
+  const tmpDir = await _promises2.default.mkdtemp(_path2.default.join(_path2.default.dirname(dest), `.${_path2.default.basename(dest)}.tmp.`));
+  try {
+    let result = await _asyncNullishCoalesce(await func(tmpDir), async () => ( tmpDir));
+    if (!_path2.default.isAbsolute(result)) {
+      result = _path2.default.join(tmpDir, result);
+    } else if (!_path2.default.resolve(result).startsWith(tmpDir)) {
+      throw new Error(`Returned path ${result} not under tmpDir`);
+    }
+    if (await fileExists(dest) && (await _promises2.default.stat(dest)).isDirectory()) {
+      await _promises2.default.rename(dest, tmpDir + ".old");
+    }
+    await _promises2.default.rename(result, dest);
+    await _promises2.default.rm(tmpDir + ".old", { recursive: true, force: true });
+  } finally {
+    await _promises2.default.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+async function linkOrCp(src, dest) {
+  try {
+    await _promises2.default.link(src, dest);
+  } catch (e3) {
+    await _promises2.default.copyFile(src, dest);
+  }
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withTimeout(promise, timeout) {
+  let timer;
+  const result = Promise.race([
+    promise,
+    new Promise((resolve, reject) => timer = setTimeout(() => reject(Error("Promise timed out")), timeout))
+  ]);
+  return result.finally(() => clearTimeout(timer));
+}
+async function pool(size, items, func) {
+  const { results } = await _promisepool.PromisePool.for(items).withConcurrency(size).handleError(async (error) => {
+    throw error;
+  }).useCorrespondingResults().process(func);
+  return results;
+}
+async function maybe(promise) {
+  return promise.then((r) => ({ success: true, result: r, error: void 0 })).catch((e) => ({ success: false, result: void 0, error: e }));
+}
+
+// src/apis.ts
+var _lodash = require('lodash'); var _lodash2 = _interopRequireDefault(_lodash);
+
+
+var _url = require('url');
+function parseLinkHeader(linkHeader) {
+  function parseLinkData(linkData) {
+    return Object.fromEntries(
+      linkData.split(";").flatMap((x) => {
+        const partMatch = x.trim().match(/^([^=]+?)\s*=\s*"?([^"]+)"?$/);
+        return partMatch ? [[partMatch[1], partMatch[2]]] : [];
+      })
+    );
+  }
+  const linkDatas = linkHeader.split(/,\s*(?=<)/).flatMap((link) => {
+    const linkMatch = link.trim().match(/^<([^>]*)>(.*)$/);
+    if (linkMatch) {
+      return [{
+        url: linkMatch[1],
+        ...parseLinkData(linkMatch[2])
+      }];
+    } else {
+      return [];
+    }
+  }).filter((l) => l.rel);
+  return Object.fromEntries(linkDatas.map((l) => [l.rel, l]));
+}
+function createURL(url, base, params = {}) {
+  params = _lodash2.default.pickBy(params, (x) => x !== void 0);
+  const urlObj = new URL(url, base);
+  const searchParams = new URLSearchParams({ ...Object.fromEntries(urlObj.searchParams), ...params });
+  if ([...searchParams].length > 0) {
+    urlObj.search = "?" + searchParams;
+  }
+  return urlObj.toString();
+}
+async function fetchGitHubAPI(url, params = {}) {
+  url = createURL(url, "https://api.github.com", params);
+  const token = process.env.GITHUB_TOKEN;
+  const headers = token ? { Authorization: "Bearer " + token } : {};
+  const response = await _nodefetch2.default.call(void 0, url, { headers });
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${await response.text()}`);
+  }
+  return await response;
+}
+async function fetchGitHubAPIPaginated(url, params = {}) {
+  const results = [];
+  let next = createURL(url, "https://api.github.com", { per_page: 100, ...params });
+  while (next) {
+    const response = await fetchGitHubAPI(next);
+    results.push(...await response.json());
+    next = _optionalChain([parseLinkHeader, 'call', _4 => _4(_nullishCoalesce(response.headers.get("link"), () => ( ""))), 'access', _5 => _5.next, 'optionalAccess', _6 => _6.url]);
+  }
+  return results;
+}
+async function fetchObsidianAPI(url) {
+  url = createURL(url, "https://releases.obsidian.md");
+  const username = process.env.OBSIDIAN_USERNAME;
+  const password = process.env.OBSIDIAN_PASSWORD;
+  if (!username || !password) {
+    throw Error("OBSIDIAN_USERNAME or OBSIDIAN_PASSWORD environment variables are required to access the Obsidian API for beta versions.");
+  }
+  const response = await _nodefetch2.default.call(void 0, url, {
+    headers: {
+      // For some reason you have to set the User-Agent or it won't let you download
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36",
+      "Origin": "app://obsidian.md",
+      "Authorization": "Basic " + btoa(username + ":" + password)
+    }
+  });
+  return response;
+}
+async function fetchWithFileUrl(url) {
+  if (url.startsWith("file:")) {
+    return await _promises2.default.readFile(_url.fileURLToPath.call(void 0, url), "utf-8");
+  } else {
+    const response = await _nodefetch2.default.call(void 0, url);
+    if (response.ok) {
+      return response.text();
+    } else {
+      throw Error(`Request failed with ${response.status}: ${response.text()}`);
+    }
+  }
+}
+
+// src/chromeLocalStorage.ts
+
+var _classiclevel = require('classic-level');
+var ChromeLocalStorage = class {
+  /** Pass the path to the user data dir for Chrome/Electron. If it doesn't exist it will be created. */
+  constructor(userDataDir) {
+    this.userDataDir = userDataDir;
+    this.encodeKey = (domain, key) => `_${domain}\0
${key}`;
+    this.decodeKey = (key) => key.slice(1).split("\0
");
+    this.encodeValue = (value) => `
${value}`;
+    this.decodeValue = (value) => value.slice(1);
+    this.db = new (0, _classiclevel.ClassicLevel)(_path2.default.join(userDataDir, "Local Storage/leveldb/"));
+  }
+  /**
+   * Get a value from localStorage
+   * @param domain Domain the value is under, e.g. "https://example.com" or "app://obsidian.md"
+   * @param key Key to retreive
+   */
+  async getItem(domain, key) {
+    const value = await this.db.get(this.encodeKey(domain, key));
+    return value === void 0 ? null : this.decodeValue(value);
+  }
+  /**
+   * Set a value in localStorage
+   * @param domain Domain the value is under, e.g. "https://example.com" or "app://obsidian.md"
+   * @param key Key to set
+   * @param value Value to set
+   */
+  async setItem(domain, key, value) {
+    await this.db.put(this.encodeKey(domain, key), this.encodeValue(value));
+  }
+  /**
+   * Removes a key from localStorage
+   * @param domain Domain the values is under, e.g. "https://example.com" or "app://obsidian.md"
+   * @param key key to remove.
+   */
+  async removeItem(domain, key) {
+    await this.db.del(this.encodeKey(domain, key));
+  }
+  /** Get all items in localStorage as [domain, key, value] tuples */
+  async getAllItems() {
+    const result = [];
+    for await (const pair of this.db.iterator()) {
+      if (pair[0].startsWith("_")) {
+        const [domain, key] = this.decodeKey(pair[0]);
+        const value = this.decodeValue(pair[1]);
+        result.push([domain, key, value]);
+      }
+    }
+    return result;
+  }
+  /**
+   * Write multiple values to localStorage in batch
+   * @param domain Domain the values are under, e.g. "https://example.com" or "app://obsidian.md"
+   * @param data key/value mapping to write
+   */
+  async setItems(domain, data) {
+    await this.db.batch(
+      Object.entries(data).map(([key, value]) => ({
+        type: "put",
+        key: this.encodeKey(domain, key),
+        value: this.encodeValue(value)
+      }))
+    );
+  }
+  /**
+   * Close the localStorage database.
+   */
+  async close() {
+    await this.db.close();
+  }
+};
+
+// src/launcherUtils.ts
+
+
+var _util = require('util');
+
+var _which = require('which'); var _which2 = _interopRequireDefault(_which);
+
+
+var execFile = _util.promisify.call(void 0, _child_process2.default.execFile);
+function normalizeGitHubRepo(repo) {
+  return repo.replace(/^(https?:\/\/)?(github.com\/)/, "");
+}
+async function extractObsidianAppImage(appImage, dest) {
+  await withTmpDir(dest, async (tmpDir) => {
+    await _promises2.default.chmod(appImage, 493);
+    await execFile(appImage, ["--appimage-extract"], { cwd: tmpDir });
+    return _path2.default.join(tmpDir, "squashfs-root");
+  });
+}
+async function extractObsidianExe(exe, appArch, dest) {
+  const path7z = await _which2.default.call(void 0, "7z", { nothrow: true });
+  if (!path7z) {
+    throw new Error(
+      "Downloading Obsidian for Windows requires 7zip to be installed and available on the PATH. You install it from https://www.7-zip.org and then add the install location to the PATH."
+    );
+  }
+  exe = _path2.default.resolve(exe);
+  const subArchive = _path2.default.join("$PLUGINSDIR", appArch + ".7z");
+  dest = _path2.default.resolve(dest);
+  await withTmpDir(dest, async (tmpDir) => {
+    const extractedInstaller = _path2.default.join(tmpDir, "installer");
+    await execFile(path7z, ["x", "-o" + extractedInstaller, exe, subArchive]);
+    const extractedObsidian = _path2.default.join(tmpDir, "obsidian");
+    await execFile(path7z, ["x", "-o" + extractedObsidian, _path2.default.join(extractedInstaller, subArchive)]);
+    return extractedObsidian;
+  });
+}
+async function extractObsidianDmg(dmg, dest) {
+  dest = _path2.default.resolve(dest);
+  await withTmpDir(dest, async (tmpDir) => {
+    const proc = await execFile("hdiutil", ["attach", "-nobrowse", "-readonly", dmg]);
+    const volume = proc.stdout.match(/\/Volumes\/.*$/m)[0];
+    const obsidianApp = _path2.default.join(volume, "Obsidian.app");
+    try {
+      await _promises2.default.cp(obsidianApp, tmpDir, { recursive: true, verbatimSymlinks: true });
+    } finally {
+      await execFile("hdiutil", ["detach", volume]);
+    }
+    return tmpDir;
+  });
+}
+function parseObsidianDesktopRelease(fileRelease, isBeta) {
+  return {
+    version: fileRelease.latestVersion,
+    minInstallerVersion: fileRelease.minimumVersion,
+    maxInstallerVersion: "",
+    // Will be set later
+    isBeta,
+    downloads: {
+      asar: fileRelease.downloadUrl
+    }
+  };
+}
+function parseObsidianGithubRelease(gitHubRelease) {
+  const version = gitHubRelease.name;
+  const assets = gitHubRelease.assets.map((a) => a.browser_download_url);
+  const downloads = {
+    appImage: assets.find((u) => u.match(`${version}.AppImage$`)),
+    appImageArm: assets.find((u) => u.match(`${version}-arm64.AppImage$`)),
+    apk: assets.find((u) => u.match(`${version}.apk$`)),
+    asar: assets.find((u) => u.match(`${version}.asar.gz$`)),
+    dmg: assets.find((u) => u.match(`${version}(-universal)?.dmg$`)),
+    exe: assets.find((u) => u.match(`${version}.exe$`))
+  };
+  return {
+    version,
+    gitHubRelease: gitHubRelease.html_url,
+    downloads: _lodash2.default.pickBy(downloads, (x) => x !== void 0)
+  };
+}
+function correctObsidianVersionInfo(versionInfo) {
+  const corrections = {};
+  if (_semver2.default.gte(versionInfo.version, "1.5.3") && _semver2.default.lt(versionInfo.minInstallerVersion, "1.1.9")) {
+    corrections.minInstallerVersion = "1.1.9";
+  }
+  return corrections;
+}
+
+// src/launcher.ts
+
+var ObsidianLauncher = class {
+  /**
+   * Construct an ObsidianLauncher.
+   * @param cacheDir Path to the cache directory. Defaults to "OBSIDIAN_CACHE" env var or ".obsidian-cache".
+   * @param versionsUrl Custom `obsidian-versions.json` url. Can be a file URL.
+   * @param communityPluginsUrl Custom `community-plugins.json` url. Can be a file URL.
+   * @param communityThemes Custom `community-css-themes.json` url. Can be a file URL.
+   */
+  constructor(options = {}) {
+    this.cacheDir = _path2.default.resolve(_nullishCoalesce(_nullishCoalesce(options.cacheDir, () => ( process.env.OBSIDIAN_CACHE)), () => ( "./.obsidian-cache")));
+    const defaultVersionsUrl = "https://raw.githubusercontent.com/jesse-r-s-hines/wdio-obsidian-service/HEAD/obsidian-versions.json";
+    this.versionsUrl = _nullishCoalesce(options.versionsUrl, () => ( defaultVersionsUrl));
+    const defaultCommunityPluginsUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
+    this.communityPluginsUrl = _nullishCoalesce(options.communityPluginsUrl, () => ( defaultCommunityPluginsUrl));
+    const defaultCommunityThemesUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-css-themes.json";
+    this.communityThemesUrl = _nullishCoalesce(options.communityThemesUrl, () => ( defaultCommunityThemesUrl));
+    this.metadataCache = {};
+  }
+  /**
+   * Returns file content fetched from url as JSON. Caches content to dest and uses that cache if its more recent than
+   * cacheDuration ms or if there are network errors.
+   */
+  async cachedFetch(url, dest, { cacheDuration = 30 * 60 * 1e3 } = {}) {
+    dest = _path2.default.resolve(dest);
+    if (!(dest in this.metadataCache)) {
+      let fileContent;
+      const mtime = await fileExists(dest) ? (await _promises2.default.stat(dest)).mtime : void 0;
+      if (mtime && (/* @__PURE__ */ new Date()).getTime() - mtime.getTime() < cacheDuration) {
+        fileContent = await _promises2.default.readFile(dest, "utf-8");
+      } else {
+        const request = await maybe(fetchWithFileUrl(url));
+        if (request.success) {
+          await _promises2.default.mkdir(_path2.default.dirname(dest), { recursive: true });
+          await withTmpDir(dest, async (tmpDir) => {
+            await _promises2.default.writeFile(_path2.default.join(tmpDir, "download.json"), request.result);
+            return _path2.default.join(tmpDir, "download.json");
+          });
+          fileContent = request.result;
+        } else if (await fileExists(dest)) {
+          console.warn(request.error);
+          console.warn(`Unable to download ${dest}, using cached file.`);
+          fileContent = await _promises2.default.readFile(dest, "utf-8");
+        } else {
+          throw request.error;
+        }
+      }
+      this.metadataCache[dest] = JSON.parse(fileContent);
+    }
+    return this.metadataCache[dest];
+  }
+  /** Get information about all available Obsidian versions. */
+  async getVersions() {
+    const dest = _path2.default.join(this.cacheDir, "obsidian-versions.json");
+    return (await this.cachedFetch(this.versionsUrl, dest)).versions;
+  }
+  /** Get information about all available community plugins. */
+  async getCommunityPlugins() {
+    const dest = _path2.default.join(this.cacheDir, "obsidian-community-plugins.json");
+    return await this.cachedFetch(this.communityPluginsUrl, dest);
+  }
+  /** Get information about all available community themes. */
+  async getCommunityThemes() {
+    const dest = _path2.default.join(this.cacheDir, "obsidian-community-css-themes.json");
+    return await this.cachedFetch(this.communityThemesUrl, dest);
+  }
+  /**
+   * Resolves Obsidian version strings to absolute obsidian versions.
+   * @param appVersion Obsidian version string or "latest" or "latest-beta"
+   * @param installerVersion Obsidian version string or "latest" or "earliest"
+   * @returns [appVersion, installerVersion] with any "latest" etc. resolved to specific versions.
+   */
+  async resolveVersions(appVersion, installerVersion = "latest") {
+    const versions = await this.getVersions();
+    if (appVersion == "latest") {
+      appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
+    } else if (appVersion == "latest-beta") {
+      appVersion = versions.at(-1).version;
+    } else {
+      appVersion = _nullishCoalesce(_semver2.default.valid(appVersion), () => ( appVersion));
+    }
+    const appVersionInfo = versions.find((v) => v.version == appVersion);
+    if (!appVersionInfo) {
+      throw Error(`No Obsidian version ${appVersion} found`);
+    }
+    if (installerVersion == "latest") {
+      installerVersion = appVersionInfo.maxInstallerVersion;
+    } else if (installerVersion == "earliest") {
+      installerVersion = appVersionInfo.minInstallerVersion;
+    } else {
+      installerVersion = _nullishCoalesce(_semver2.default.valid(installerVersion), () => ( installerVersion));
+    }
+    const installerVersionInfo = versions.find((v) => v.version == installerVersion);
+    if (!installerVersionInfo || !installerVersionInfo.chromeVersion) {
+      throw Error(`No Obsidian installer for version ${installerVersion} found`);
+    }
+    if (_semver2.default.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion)) {
+      throw Error(
+        `Installer and app versions incompatible: minInstallerVersion of v${appVersionInfo.version} is ${appVersionInfo.minInstallerVersion}, but v${installerVersionInfo.version} specified`
+      );
+    }
+    return [appVersionInfo.version, installerVersionInfo.version];
+  }
+  /** Gets details about an Obsidian version */
+  async getVersionInfo(version) {
+    version = (await this.resolveVersions(version))[0];
+    const result = (await this.getVersions()).find((v) => v.version == version);
+    if (!result) {
+      throw Error(`No Obsidian version ${version} found`);
+    }
+    return result;
+  }
+  /**
+   * Downloads the Obsidian installer for the given version and platform. Returns the file path.
+   * @param installerVersion Version to download.
+   */
+  async downloadInstaller(installerVersion) {
+    const installerVersionInfo = await this.getVersionInfo(installerVersion);
+    return await this.downloadInstallerFromVersionInfo(installerVersionInfo);
+  }
+  /**
+   * Helper for downloadInstaller that doesn't require the obsidian-versions.json file so it can be used in
+   * updateObsidianVersionInfos
+   */
+  async downloadInstallerFromVersionInfo(versionInfo) {
+    const installerVersion = versionInfo.version;
+    const { platform, arch } = process;
+    const cacheDir = _path2.default.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
+    let installerPath;
+    let downloader;
+    if (platform == "linux") {
+      installerPath = _path2.default.join(cacheDir, "obsidian");
+      let installerUrl;
+      if (arch.startsWith("arm")) {
+        installerUrl = versionInfo.downloads.appImageArm;
+      } else {
+        installerUrl = versionInfo.downloads.appImage;
+      }
+      if (installerUrl) {
+        downloader = async (tmpDir) => {
+          const appImage = _path2.default.join(tmpDir, "Obsidian.AppImage");
+          await _promises2.default.writeFile(appImage, (await _nodefetch2.default.call(void 0, installerUrl)).body);
+          const obsidianFolder = _path2.default.join(tmpDir, "Obsidian");
+          await extractObsidianAppImage(appImage, obsidianFolder);
+          return obsidianFolder;
+        };
+      }
+    } else if (platform == "win32") {
+      installerPath = _path2.default.join(cacheDir, "Obsidian.exe");
+      const installerUrl = versionInfo.downloads.exe;
+      let appArch;
+      if (arch == "x64") {
+        appArch = "app-64";
+      } else if (arch == "ia32") {
+        appArch = "app-32";
+      } else if (arch.startsWith("arm")) {
+        appArch = "app-arm64";
+      }
+      if (installerUrl && appArch) {
+        downloader = async (tmpDir) => {
+          const installerExecutable = _path2.default.join(tmpDir, "Obsidian.exe");
+          await _promises2.default.writeFile(installerExecutable, (await _nodefetch2.default.call(void 0, installerUrl)).body);
+          const obsidianFolder = _path2.default.join(tmpDir, "Obsidian");
+          await extractObsidianExe(installerExecutable, appArch, obsidianFolder);
+          return obsidianFolder;
+        };
+      }
+    } else if (platform == "darwin") {
+      installerPath = _path2.default.join(cacheDir, "Contents/MacOS/Obsidian");
+      const installerUrl = versionInfo.downloads.dmg;
+      if (installerUrl) {
+        downloader = async (tmpDir) => {
+          const dmg = _path2.default.join(tmpDir, "Obsidian.dmg");
+          await _promises2.default.writeFile(dmg, (await _nodefetch2.default.call(void 0, installerUrl)).body);
+          const obsidianFolder = _path2.default.join(tmpDir, "Obsidian");
+          await extractObsidianDmg(dmg, obsidianFolder);
+          return obsidianFolder;
+        };
+      }
+    } else {
+      throw Error(`Unsupported platform ${platform}`);
+    }
+    if (!downloader) {
+      throw Error(`No Obsidian installer download available for v${installerVersion} ${platform} ${arch}`);
+    }
+    if (!await fileExists(installerPath)) {
+      console.log(`Downloading Obsidian installer v${installerVersion}...`);
+      await _promises2.default.mkdir(_path2.default.dirname(cacheDir), { recursive: true });
+      await withTmpDir(cacheDir, downloader);
+    }
+    return installerPath;
+  }
+  /**
+   * Downloads the Obsidian asar for the given version and platform. Returns the file path.
+   * @param appVersion Version to download.
+   */
+  async downloadApp(appVersion) {
+    const appVersionInfo = await this.getVersionInfo(appVersion);
+    const appUrl = appVersionInfo.downloads.asar;
+    if (!appUrl) {
+      throw Error(`No asar found for Obsidian version ${appVersion}`);
+    }
+    const appPath = _path2.default.join(this.cacheDir, "obsidian-app", `obsidian-${appVersionInfo.version}.asar`);
+    if (!await fileExists(appPath)) {
+      console.log(`Downloading Obsidian app v${appVersion} ...`);
+      await _promises2.default.mkdir(_path2.default.dirname(appPath), { recursive: true });
+      await withTmpDir(appPath, async (tmpDir) => {
+        const isInsidersBuild = new URL(appUrl).hostname.endsWith(".obsidian.md");
+        const response = isInsidersBuild ? await fetchObsidianAPI(appUrl) : await _nodefetch2.default.call(void 0, appUrl);
+        const archive = _path2.default.join(tmpDir, "app.asar.gz");
+        const asar = _path2.default.join(tmpDir, "app.asar");
+        await _promises2.default.writeFile(archive, response.body);
+        await _promises3.pipeline.call(void 0, _fs2.default.createReadStream(archive), _zlib2.default.createGunzip(), _fs2.default.createWriteStream(asar));
+        return asar;
+      });
+    }
+    return appPath;
+  }
+  /**
+   * Downloads chromedriver for the given Obsidian version.
+   * 
+   * wdio will download chromedriver from the Chrome for Testing API automatically (see
+   * https://github.com/GoogleChromeLabs/chrome-for-testing#json-api-endpoints). However, Google has only put
+   * chromedriver since v115.0.5763.0 in that API, so wdio can't download older versions of chromedriver. As of
+   * Obsidian v1.7.7, minInstallerVersion is v0.14.5 which runs on chromium v100.0.4896.75. Here we download
+   * chromedriver for older versions ourselves using the @electron/get package which fetches it from
+   * https://github.com/electron/electron/releases.
+   */
+  async downloadChromedriver(installerVersion) {
+    const versionInfo = await this.getVersionInfo(installerVersion);
+    const electronVersion = versionInfo.electronVersion;
+    if (!electronVersion) {
+      throw Error(`${installerVersion} is not an Obsidian installer version.`);
+    }
+    const chromedriverZipPath = await _get.downloadArtifact.call(void 0, {
+      version: electronVersion,
+      artifactName: "chromedriver",
+      cacheRoot: _path2.default.join(this.cacheDir, "chromedriver-legacy"),
+      unsafelyDisableChecksums: true
+      // the checksums are slow and run even on cache hit.
+    });
+    let chromedriverPath;
+    if (process.platform == "win32") {
+      chromedriverPath = _path2.default.join(_path2.default.dirname(chromedriverZipPath), "chromedriver.exe");
+    } else {
+      chromedriverPath = _path2.default.join(_path2.default.dirname(chromedriverZipPath), "chromedriver");
+    }
+    if (!await fileExists(chromedriverPath)) {
+      console.log(`Downloading legacy chromedriver for electron ${electronVersion} ...`);
+      await withTmpDir(chromedriverPath, async (tmpDir) => {
+        await _extractzip2.default.call(void 0, chromedriverZipPath, { dir: tmpDir });
+        return _path2.default.join(tmpDir, _path2.default.basename(chromedriverPath));
+      });
+    }
+    return chromedriverPath;
+  }
+  /** Gets the latest version of a plugin. */
+  async getLatestPluginVersion(repo) {
+    repo = normalizeGitHubRepo(repo);
+    const manifestUrl = `https://raw.githubusercontent.com/${repo}/HEAD/manifest.json`;
+    const cacheDest = _path2.default.join(this.cacheDir, "obsidian-plugins", repo, "latest.json");
+    const manifest = await this.cachedFetch(manifestUrl, cacheDest);
+    return manifest.version;
+  }
+  /**
+   * Downloads a plugin from a GitHub repo to the cache.
+   * @param repo Repo
+   * @param version Version of the plugin to install or "latest"
+   * @returns path to the downloaded plugin
+   */
+  async downloadGitHubPlugin(repo, version = "latest") {
+    repo = normalizeGitHubRepo(repo);
+    if (version == "latest") {
+      version = await this.getLatestPluginVersion(repo);
+    }
+    if (!_semver2.default.valid(version)) {
+      throw Error(`Invalid version "${version}"`);
+    }
+    version = _semver2.default.valid(version);
+    const pluginDir = _path2.default.join(this.cacheDir, "obsidian-plugins", repo, version);
+    if (!await fileExists(pluginDir)) {
+      await _promises2.default.mkdir(_path2.default.dirname(pluginDir), { recursive: true });
+      await withTmpDir(pluginDir, async (tmpDir) => {
+        const assetsToDownload = { "manifest.json": true, "main.js": true, "styles.css": false };
+        await Promise.all(
+          Object.entries(assetsToDownload).map(async ([file, required]) => {
+            const url = `https://github.com/${repo}/releases/download/${version}/${file}`;
+            const response = await _nodefetch2.default.call(void 0, url);
+            if (response.ok) {
+              await _promises2.default.writeFile(_path2.default.join(tmpDir, file), response.body);
+            } else if (required) {
+              throw Error(`No ${file} found for ${repo} version ${version}`);
+            }
+          })
+        );
+        return tmpDir;
+      });
+    }
+    return pluginDir;
+  }
+  /**
+   * Downloads a community plugin to the cache.
+   * @param id Id of the plugin
+   * @param version Version of the plugin to install, or "latest"
+   * @returns path to the downloaded plugin
+   */
+  async downloadCommunityPlugin(id, version = "latest") {
+    const communityPlugins = await this.getCommunityPlugins();
+    const pluginInfo = communityPlugins.find((p) => p.id == id);
+    if (!pluginInfo) {
+      throw Error(`No plugin with id ${id} found.`);
+    }
+    return await this.downloadGitHubPlugin(pluginInfo.repo, version);
+  }
+  /**
+   * Downloads a list of plugins to the cache and returns a list of LocalPluginEntry with the downloaded paths.
+   * Also adds the `id` property to the plugins based on the manifest.
+   * 
+   * You can download plugins from GitHub using `{repo: "org/repo"}` and community plugins using `{id: 'plugin-id'}`.
+   * Local plugins will just be passed through.
+   */
+  async downloadPlugins(plugins) {
+    return await Promise.all(
+      plugins.map(async (plugin) => {
+        let pluginPath;
+        if (typeof plugin == "string") {
+          pluginPath = plugin;
+        } else if ("path" in plugin) {
+          ;
+          pluginPath = plugin.path;
+        } else if ("repo" in plugin) {
+          pluginPath = await this.downloadGitHubPlugin(plugin.repo, plugin.version);
+        } else if ("id" in plugin) {
+          pluginPath = await this.downloadCommunityPlugin(plugin.id, plugin.version);
+        } else {
+          throw Error("You must specify one of plugin path, repo, or id");
+        }
+        let pluginId = typeof plugin == "object" && "id" in plugin ? plugin.id : void 0;
+        if (!pluginId) {
+          const manifestPath = _path2.default.join(pluginPath, "manifest.json");
+          pluginId = JSON.parse(await _promises2.default.readFile(manifestPath, "utf8").catch(() => "{}")).id;
+          if (!pluginId) {
+            throw Error(`${pluginPath}/manifest.json missing or malformed.`);
+          }
+        }
+        const enabled = typeof plugin == "string" ? true : plugin.enabled;
+        return { path: pluginPath, id: pluginId, enabled };
+      })
+    );
+  }
+  /** Gets the latest version of a theme. */
+  async getLatestThemeVersion(repo) {
+    repo = normalizeGitHubRepo(repo);
+    const manifestUrl = `https://raw.githubusercontent.com/${repo}/HEAD/manifest.json`;
+    const cacheDest = _path2.default.join(this.cacheDir, "obsidian-themes", repo, "latest.json");
+    const manifest = await this.cachedFetch(manifestUrl, cacheDest);
+    return manifest.version;
+  }
+  /**
+   * Downloads a theme from a GitHub repo to the cache.
+   * @param repo Repo
+   * @returns path to the downloaded theme
+   */
+  async downloadGitHubTheme(repo) {
+    repo = normalizeGitHubRepo(repo);
+    const version = await this.getLatestThemeVersion(repo);
+    const themeDir = _path2.default.join(this.cacheDir, "obsidian-themes", repo, version);
+    if (!await fileExists(themeDir)) {
+      await _promises2.default.mkdir(_path2.default.dirname(themeDir), { recursive: true });
+      await withTmpDir(themeDir, async (tmpDir) => {
+        const assetsToDownload = ["manifest.json", "theme.css"];
+        await Promise.all(
+          assetsToDownload.map(async (file) => {
+            const url = `https://raw.githubusercontent.com/${repo}/HEAD/${file}`;
+            const response = await _nodefetch2.default.call(void 0, url);
+            if (response.ok) {
+              await _promises2.default.writeFile(_path2.default.join(tmpDir, file), response.body);
+            } else {
+              throw Error(`No ${file} found for ${repo}`);
+            }
+          })
+        );
+        return tmpDir;
+      });
+    }
+    return themeDir;
+  }
+  /**
+   * Downloads a community theme to the cache.
+   * @param name name of the theme
+   * @returns path to the downloaded theme
+   */
+  async downloadCommunityTheme(name) {
+    const communityThemes = await this.getCommunityThemes();
+    const themeInfo = communityThemes.find((p) => p.name == name);
+    if (!themeInfo) {
+      throw Error(`No theme with name ${name} found.`);
+    }
+    return await this.downloadGitHubTheme(themeInfo.repo);
+  }
+  /**
+   * Downloads a list of themes to the cache and returns a list of LocalThemeEntry with the downloaded paths.
+   * Also adds the `name` property to the plugins based on the manifest.
+   * 
+   * You can download themes from GitHub using `{repo: "org/repo"}` and community themes using `{name: 'theme-name'}`.
+   * Local themes will just be passed through.
+   */
+  async downloadThemes(themes) {
+    return await Promise.all(
+      themes.map(async (theme) => {
+        let themePath;
+        if (typeof theme == "string") {
+          themePath = theme;
+        } else if ("path" in theme) {
+          ;
+          themePath = theme.path;
+        } else if ("repo" in theme) {
+          themePath = await this.downloadGitHubTheme(theme.repo);
+        } else if ("name" in theme) {
+          themePath = await this.downloadCommunityTheme(theme.name);
+        } else {
+          throw Error("You must specify one of theme path, repo, or name");
+        }
+        let themeName = typeof theme == "object" && "name" in theme ? theme.name : void 0;
+        if (!themeName) {
+          const manifestPath = _path2.default.join(themePath, "manifest.json");
+          themeName = JSON.parse(await _promises2.default.readFile(manifestPath, "utf8").catch(() => "{}")).name;
+          if (!themeName) {
+            throw Error(`${themePath}/manifest.json missing or malformed.`);
+          }
+        }
+        const enabled = typeof theme == "string" ? true : theme.enabled;
+        return { path: themePath, name: themeName, enabled };
+      })
+    );
+  }
+  /**
+   * Installs plugins into an Obsidian vault.
+   * @param vault Path to the vault to install the plugin in.
+   * @param plugins List plugins paths to install.
+   */
+  async installPlugins(vault, plugins) {
+    const downloadedPlugins = await this.downloadPlugins(plugins);
+    const obsidianDir = _path2.default.join(vault, ".obsidian");
+    await _promises2.default.mkdir(obsidianDir, { recursive: true });
+    const enabledPluginsPath = _path2.default.join(obsidianDir, "community-plugins.json");
+    let originalEnabledPlugins = [];
+    if (await fileExists(enabledPluginsPath)) {
+      originalEnabledPlugins = JSON.parse(await _promises2.default.readFile(enabledPluginsPath, "utf-8"));
+    }
+    let enabledPlugins = [...originalEnabledPlugins];
+    for (const { path: pluginPath, enabled = true } of downloadedPlugins) {
+      const manifestPath = _path2.default.join(pluginPath, "manifest.json");
+      const pluginId = JSON.parse(await _promises2.default.readFile(manifestPath, "utf8").catch(() => "{}")).id;
+      if (!pluginId) {
+        throw Error(`${manifestPath} missing or malformed.`);
+      }
+      const pluginDest = _path2.default.join(obsidianDir, "plugins", pluginId);
+      await _promises2.default.rm(pluginDest, { recursive: true, force: true });
+      await _promises2.default.mkdir(pluginDest, { recursive: true });
+      const files = {
+        "manifest.json": true,
+        "main.js": true,
+        "styles.css": false,
+        "data.json": false
+      };
+      for (const [file, required] of Object.entries(files)) {
+        if (await fileExists(_path2.default.join(pluginPath, file))) {
+          await linkOrCp(_path2.default.join(pluginPath, file), _path2.default.join(pluginDest, file));
+        } else if (required) {
+          throw Error(`${pluginPath}/${file} missing.`);
+        }
+      }
+      const pluginAlreadyListed = enabledPlugins.includes(pluginId);
+      if (enabled && !pluginAlreadyListed) {
+        enabledPlugins.push(pluginId);
+      } else if (!enabled && pluginAlreadyListed) {
+        enabledPlugins = enabledPlugins.filter((p) => p != pluginId);
+      }
+    }
+    if (!_lodash2.default.isEqual(enabledPlugins, originalEnabledPlugins)) {
+      await _promises2.default.writeFile(enabledPluginsPath, JSON.stringify(enabledPlugins, void 0, 2));
+    }
+  }
+  /** 
+   * Installs themes into an obsidian vault.
+   * @param vault Path to the theme to install the plugin in.
+   * @param themes: List of themes to install.
+   */
+  async installThemes(vault, themes) {
+    const downloadedThemes = await this.downloadThemes(themes);
+    const obsidianDir = _path2.default.join(vault, ".obsidian");
+    await _promises2.default.mkdir(obsidianDir, { recursive: true });
+    let enabledTheme = void 0;
+    for (const { path: themePath, enabled = true } of downloadedThemes) {
+      const manifestPath = _path2.default.join(themePath, "manifest.json");
+      const cssPath = _path2.default.join(themePath, "theme.css");
+      const themeName = JSON.parse(await _promises2.default.readFile(manifestPath, "utf8").catch(() => "{}")).name;
+      if (!themeName) {
+        throw Error(`${manifestPath} missing or malformed.`);
+      }
+      if (!await fileExists(cssPath)) {
+        throw Error(`${cssPath} missing.`);
+      }
+      const themeDest = _path2.default.join(obsidianDir, "themes", themeName);
+      await _promises2.default.rm(themeDest, { recursive: true, force: true });
+      await _promises2.default.mkdir(themeDest, { recursive: true });
+      await linkOrCp(manifestPath, _path2.default.join(themeDest, "manifest.json"));
+      await linkOrCp(cssPath, _path2.default.join(themeDest, "theme.css"));
+      if (enabledTheme && enabled) {
+        throw Error("You can only have one enabled theme.");
+      } else if (enabled) {
+        enabledTheme = themeName;
+      }
+    }
+    if (themes.length > 0) {
+      const appearancePath = _path2.default.join(obsidianDir, "appearance.json");
+      let appearance = {};
+      if (await fileExists(appearancePath)) {
+        appearance = JSON.parse(await _promises2.default.readFile(appearancePath, "utf-8"));
+      }
+      appearance.cssTheme = _nullishCoalesce(enabledTheme, () => ( ""));
+      await _promises2.default.writeFile(appearancePath, JSON.stringify(appearance, void 0, 2));
+    }
+  }
+  /**
+   * Sets up the config dir to use for the --user-data-dir in obsidian. Returns the path to the created config dir.
+   *
+   * @param appVersion Obsidian version string.
+   * @param installerVersion Obsidian version string.
+   * @param appPath Path to the asar file to install.
+   * @param vault Path to the vault to open in Obsidian.
+   * @param plugins List of plugins to install in the vault.
+   * @param themes List of themes to install in the vault.
+   * @param dest Destination path for the config dir. If omitted it will create it under `/tmp`.
+   */
+  async setupConfigDir(params) {
+    const [appVersion, installerVersion] = await this.resolveVersions(params.appVersion, params.installerVersion);
+    const configDir = await _asyncNullishCoalesce(params.dest, async () => ( await _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), "obs-launcher-config-"))));
+    let obsidianJson = {
+      updateDisabled: true
+      // Prevents Obsidian trying to auto-update on boot.
+    };
+    let localStorageData = {
+      "most-recently-installed-version": appVersion
+      // prevents the changelog page on boot
+    };
+    if (params.vault !== void 0) {
+      await this.installPlugins(params.vault, _nullishCoalesce(params.plugins, () => ( [])));
+      await this.installThemes(params.vault, _nullishCoalesce(params.themes, () => ( [])));
+      const vaultId = "1234567890abcdef";
+      obsidianJson = {
+        ...obsidianJson,
+        vaults: {
+          [vaultId]: {
+            path: _path2.default.resolve(params.vault),
+            ts: (/* @__PURE__ */ new Date()).getTime(),
+            open: true
+          }
+        }
+      };
+      localStorageData = {
+        ...localStorageData,
+        [`enable-plugin-${vaultId}`]: "true"
+        // Disable "safe mode" and enable plugins
+      };
+    }
+    await _promises2.default.writeFile(_path2.default.join(configDir, "obsidian.json"), JSON.stringify(obsidianJson));
+    if (params.appPath) {
+      await linkOrCp(params.appPath, _path2.default.join(configDir, _path2.default.basename(params.appPath)));
+    } else if (appVersion != installerVersion) {
+      throw Error("You must specify app path if appVersion != installerVersion");
+    }
+    const localStorage = new ChromeLocalStorage(configDir);
+    await localStorage.setItems("app://obsidian.md", localStorageData);
+    await localStorage.close();
+    return configDir;
+  }
+  /**
+   * Copies a vault to a temporary directory.
+   * @returns Path to the created tmpDir.
+   */
+  async copyVault(src) {
+    const dest = await _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), "obs-launcher-vault-"));
+    await _promises2.default.cp(src, dest, { recursive: true });
+    return dest;
+  }
+  /**
+   * Downloads and launches Obsidian with a sandboxed config dir. Optionally open a specific vault and install plugins
+   * and themes first.
+   *
+   * @param appVersion Obsidian version string.
+   * @param installerVersion Obsidian version string.
+   * @param vault Path to the vault to open in Obsidian.
+   * @param plugins List of plugins to install in the vault.
+   * @param themes List of themes to install in the vault.
+   * @param dest Destination path for the config dir. If omitted it will create it under `/tmp`.
+   * @param args CLI args to pass to Obsidian
+   * @param spawnOptions Options to pass to `spawn`.
+   * @returns The launched child process and the created config dir.
+   */
+  async launch(params) {
+    const [appVersion, installerVersion] = await this.resolveVersions(params.appVersion, params.installerVersion);
+    const appPath = await this.downloadApp(appVersion);
+    const installerPath = await this.downloadInstaller(installerVersion);
+    const configDir = await this.setupConfigDir({
+      appVersion,
+      installerVersion,
+      appPath,
+      vault: params.vault,
+      plugins: params.plugins,
+      themes: params.themes
+    });
+    const proc = _child_process2.default.spawn(installerPath, [
+      `--user-data-dir=${configDir}`,
+      ..._nullishCoalesce(params.args, () => ( []))
+    ], {
+      ...params.spawnOptions
+    });
+    return [proc, configDir];
+  }
+  /**
+   * Extract electron and chrome versions for an Obsidian version.
+   */
+  async getDependencyVersions(versionInfo) {
+    const binary = await this.downloadInstallerFromVersionInfo(versionInfo);
+    console.log(`${versionInfo.version}: Extracting electron & chrome versions...`);
+    const configDir = await _promises2.default.mkdtemp(_path2.default.join(_os2.default.tmpdir(), `fetch-obsidian-versions-`));
+    const proc = _child_process2.default.spawn(binary, [
+      `--remote-debugging-port=0`,
+      // 0 will make it choose a random available port
+      "--test-type=webdriver",
+      `--user-data-dir=${configDir}`,
+      "--no-sandbox",
+      // Workaround for SUID issue, see https://github.com/electron/electron/issues/42510
+      "--headless"
+    ]);
+    const procExit = new Promise((resolve) => proc.on("exit", (code) => resolve(_nullishCoalesce(code, () => ( -1)))));
+    let dependencyVersions;
+    try {
+      const portPromise = new Promise((resolve, reject) => {
+        procExit.then(() => reject("Processed ended without opening a port"));
+        proc.stderr.on("data", (data) => {
+          const port2 = _optionalChain([data, 'access', _7 => _7.toString, 'call', _8 => _8(), 'access', _9 => _9.match, 'call', _10 => _10(/ws:\/\/[\w.]+?:(\d+)/), 'optionalAccess', _11 => _11[1]]);
+          if (port2) {
+            resolve(Number(port2));
+          }
+        });
+      });
+      const port = await maybe(withTimeout(portPromise, 10 * 1e3));
+      if (!port.success) {
+        throw new Error("Timed out waiting for Chrome DevTools protocol port");
+      }
+      const client = await _chromeremoteinterface2.default.call(void 0, { port: port.result });
+      const response = await client.Runtime.evaluate({ expression: "JSON.stringify(process.versions)" });
+      dependencyVersions = JSON.parse(response.result.value);
+      await client.close();
+    } finally {
+      proc.kill("SIGTERM");
+      const timeout = await maybe(withTimeout(procExit, 4 * 1e3));
+      if (!timeout.success) {
+        console.log(`${versionInfo.version}: Stuck process ${proc.pid}, using SIGKILL`);
+        proc.kill("SIGKILL");
+      }
+      await procExit;
+      await sleep(1e3);
+      await _promises2.default.rm(configDir, { recursive: true, force: true });
+    }
+    if (!_optionalChain([dependencyVersions, 'optionalAccess', _12 => _12.electron]) || !_optionalChain([dependencyVersions, 'optionalAccess', _13 => _13.chrome])) {
+      throw Error(`Failed to extract electron and chrome versions for ${versionInfo.version}`);
+    }
+    return {
+      ...versionInfo,
+      electronVersion: dependencyVersions.electron,
+      chromeVersion: dependencyVersions.chrome,
+      nodeVersion: dependencyVersions.node
+    };
+  }
+  /** 
+   * Updates the info obsidian-versions.json. The obsidian-versions.json file is used in other launcher commands
+   * and in wdio-obsidian-service to get metadata about Obsidian versions in one place such as minInstallerVersion and
+   * the internal electron version.
+   */
+  async updateObsidianVersionInfos(original, { maxInstances = 1 } = {}) {
+    const repo = "obsidianmd/obsidian-releases";
+    let commitHistory = await fetchGitHubAPIPaginated(`repos/${repo}/commits`, {
+      path: "desktop-releases.json",
+      since: _optionalChain([original, 'optionalAccess', _14 => _14.metadata, 'access', _15 => _15.commit_date])
+    });
+    commitHistory.reverse();
+    if (original) {
+      commitHistory = _lodash2.default.takeRightWhile(commitHistory, (c) => c.sha != original.metadata.commit_sha);
+    }
+    const fileHistory = await pool(
+      8,
+      commitHistory,
+      (commit) => _nodefetch2.default.call(void 0, `https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
+    );
+    const githubReleases = await fetchGitHubAPIPaginated(`repos/${repo}/releases`);
+    const versionMap = _lodash2.default.keyBy(
+      _nullishCoalesce(_optionalChain([original, 'optionalAccess', _16 => _16.versions]), () => ( [])),
+      (v) => v.version
+    );
+    for (const { beta, ...current } of fileHistory) {
+      if (beta && (!versionMap[beta.latestVersion] || versionMap[beta.latestVersion].isBeta)) {
+        versionMap[beta.latestVersion] = _lodash2.default.merge(
+          {},
+          versionMap[beta.latestVersion],
+          parseObsidianDesktopRelease(beta, true)
+        );
+      }
+      versionMap[current.latestVersion] = _lodash2.default.merge(
+        {},
+        versionMap[current.latestVersion],
+        parseObsidianDesktopRelease(current, false)
+      );
+    }
+    for (const release of githubReleases) {
+      if (versionMap.hasOwnProperty(release.name)) {
+        versionMap[release.name] = _lodash2.default.merge({}, versionMap[release.name], parseObsidianGithubRelease(release));
+      }
+    }
+    const dependencyVersions = await pool(
+      maxInstances,
+      Object.values(versionMap).filter((v) => _optionalChain([v, 'access', _17 => _17.downloads, 'optionalAccess', _18 => _18.appImage]) && !v.chromeVersion),
+      (v) => this.getDependencyVersions(v)
+    );
+    for (const deps of dependencyVersions) {
+      versionMap[deps.version] = _lodash2.default.merge({}, versionMap[deps.version], deps);
+    }
+    let maxInstallerVersion = "0.0.0";
+    for (const version of Object.keys(versionMap).sort(_semver2.default.compare)) {
+      if (versionMap[version].downloads.appImage) {
+        maxInstallerVersion = version;
+      }
+      versionMap[version] = _lodash2.default.merge(
+        {},
+        versionMap[version],
+        correctObsidianVersionInfo(versionMap[version]),
+        { maxInstallerVersion }
+      );
+    }
+    const versionInfos = Object.values(versionMap);
+    versionInfos.sort((a, b) => _semver2.default.compare(a.version, b.version));
+    const result = {
+      metadata: {
+        commit_date: _nullishCoalesce(_optionalChain([commitHistory, 'access', _19 => _19.at, 'call', _20 => _20(-1), 'optionalAccess', _21 => _21.commit, 'access', _22 => _22.committer, 'access', _23 => _23.date]), () => ( _optionalChain([original, 'optionalAccess', _24 => _24.metadata, 'access', _25 => _25.commit_date]))),
+        commit_sha: _nullishCoalesce(_optionalChain([commitHistory, 'access', _26 => _26.at, 'call', _27 => _27(-1), 'optionalAccess', _28 => _28.sha]), () => ( _optionalChain([original, 'optionalAccess', _29 => _29.metadata, 'access', _30 => _30.commit_sha]))),
+        timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _31 => _31.metadata, 'access', _32 => _32.timestamp]), () => ( ""))
+        // set down below
+      },
+      versions: versionInfos
+    };
+    const dayMs = 24 * 60 * 60 * 1e3;
+    const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _33 => _33.metadata, 'access', _34 => _34.timestamp]), () => ( 0))).getTime();
+    if (!_lodash2.default.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
+      result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return result;
+  }
+  /**
+   * Returns true if the Obsidian version is already in the cache.
+   */
+  async isInCache(type, version) {
+    version = (await this.resolveVersions(version))[0];
+    let dest;
+    if (type == "app") {
+      dest = `obsidian-app/obsidian-${version}.asar`;
+    } else {
+      const { platform, arch } = process;
+      dest = `obsidian-installer/${platform}-${arch}/Obsidian-${version}`;
+    }
+    return await fileExists(_path2.default.join(this.cacheDir, dest));
+  }
+  /**
+   * Returns true if we either have the credentails to download the version or it's already in cache.
+   * This is only relevant for Obsidian beta versions, as they require Obsidian insider credentials to download.
+   */
+  async isAvailable(version) {
+    const versionInfo = await this.getVersionInfo(version);
+    if (versionInfo.isBeta) {
+      const hasCreds = !!(process.env["OBSIDIAN_USERNAME"] && process.env["OBSIDIAN_PASSWORD"]);
+      const inCache = await this.isInCache("app", versionInfo.version);
+      return hasCreds || inCache;
+    } else {
+      return !!versionInfo.downloads.asar;
+    }
+  }
+};
+
+
+
+exports.ObsidianLauncher = ObsidianLauncher;
+//# sourceMappingURL=chunk-64XS3NWI.cjs.map