obsidian-launcher 0.1.0 → 0.1.2

package/dist/chunk-HKIRRZUO.js

@@ -0,0 +1,1146 @@
+// src/launcher.ts
+import fsAsync4 from "fs/promises";
+import fs from "fs";
+import zlib from "zlib";
+import path4 from "path";
+import os from "os";
+import crypto from "crypto";
+import fetch2 from "node-fetch";
+import extractZip from "extract-zip";
+import { pipeline } from "stream/promises";
+import { downloadArtifact } from "@electron/get";
+import child_process2 from "child_process";
+import semver2 from "semver";
+import CDP from "chrome-remote-interface";
+
+// src/utils.ts
+import fsAsync from "fs/promises";
+import path from "path";
+import { PromisePool } from "@supercharge/promise-pool";
+async function fileExists(path5) {
+  try {
+    await fsAsync.access(path5);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withTmpDir(dest, func) {
+  dest = path.resolve(dest);
+  const tmpDir = await fsAsync.mkdtemp(path.join(path.dirname(dest), `.${path.basename(dest)}.tmp.`));
+  try {
+    let result = await func(tmpDir) ?? tmpDir;
+    if (!path.isAbsolute(result)) {
+      result = path.join(tmpDir, result);
+    } else if (!path.resolve(result).startsWith(tmpDir)) {
+      throw new Error(`Returned path ${result} not under tmpDir`);
+    }
+    if (await fileExists(dest) && (await fsAsync.stat(dest)).isDirectory()) {
+      await fsAsync.rename(dest, tmpDir + ".old");
+    }
+    await fsAsync.rename(result, dest);
+    await fsAsync.rm(tmpDir + ".old", { recursive: true, force: true });
+  } finally {
+    await fsAsync.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+async function linkOrCp(src, dest) {
+  try {
+    await fsAsync.link(src, dest);
+  } catch {
+    await fsAsync.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.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
+import _ from "lodash";
+import fetch from "node-fetch";
+import fsAsync2 from "fs/promises";
+import { fileURLToPath } from "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 = _.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 fetch(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 = parseLinkHeader(response.headers.get("link") ?? "").next?.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 fetch(url, {
+    headers: {
+      // For some reason you have to set the User-Agent or it won't let you download
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36",
+      "Origin": "app://obsidian.md",
+      "Authorization": "Basic " + btoa(username + ":" + password)
+    }
+  });
+  return response;
+}
+async function fetchWithFileUrl(url) {
+  if (url.startsWith("file:")) {
+    return await fsAsync2.readFile(fileURLToPath(url), "utf-8");
+  } else {
+    const response = await fetch(url);
+    if (response.ok) {
+      return response.text();
+    } else {
+      throw Error(`Request failed with ${response.status}: ${response.text()}`);
+    }
+  }
+}
+
+// src/chromeLocalStorage.ts
+import path2 from "path";
+import { ClassicLevel } from "classic-level";
+var ChromeLocalStorage = class {
+  /** Pass the path to the user data dir for Chrome/Electron. If it doesn't exist it will be created. */
+  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 ClassicLevel(path2.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
+import fsAsync3 from "fs/promises";
+import path3 from "path";
+import { promisify } from "util";
+import child_process from "child_process";
+import which from "which";
+import semver from "semver";
+import _2 from "lodash";
+var execFile = promisify(child_process.execFile);
+function normalizeGitHubRepo(repo) {
+  return repo.replace(/^(https?:\/\/)?(github.com\/)/, "");
+}
+async function extractObsidianAppImage(appImage, dest) {
+  await withTmpDir(dest, async (tmpDir) => {
+    await fsAsync3.chmod(appImage, 493);
+    await execFile(appImage, ["--appimage-extract"], { cwd: tmpDir });
+    return path3.join(tmpDir, "squashfs-root");
+  });
+}
+async function extractObsidianExe(exe, appArch, dest) {
+  const path7z = await which("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 = path3.resolve(exe);
+  const subArchive = path3.join("$PLUGINSDIR", appArch + ".7z");
+  dest = path3.resolve(dest);
+  await withTmpDir(dest, async (tmpDir) => {
+    const extractedInstaller = path3.join(tmpDir, "installer");
+    await execFile(path7z, ["x", "-o" + extractedInstaller, exe, subArchive]);
+    const extractedObsidian = path3.join(tmpDir, "obsidian");
+    await execFile(path7z, ["x", "-o" + extractedObsidian, path3.join(extractedInstaller, subArchive)]);
+    return extractedObsidian;
+  });
+}
+async function extractObsidianDmg(dmg, dest) {
+  dest = path3.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 = path3.join(volume, "Obsidian.app");
+    try {
+      await fsAsync3.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: _2.pickBy(downloads, (x) => x !== void 0)
+  };
+}
+function correctObsidianVersionInfo(versionInfo) {
+  const corrections = {};
+  if (semver.gte(versionInfo.version, "1.5.3") && semver.lt(versionInfo.minInstallerVersion, "1.1.9")) {
+    corrections.minInstallerVersion = "1.1.9";
+  }
+  return corrections;
+}
+
+// src/launcher.ts
+import _3 from "lodash";
+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 = path4.resolve(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 = options.versionsUrl ?? defaultVersionsUrl;
+    const defaultCommunityPluginsUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
+    this.communityPluginsUrl = options.communityPluginsUrl ?? defaultCommunityPluginsUrl;
+    const defaultCommunityThemesUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-css-themes.json";
+    this.communityThemesUrl = 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 = path4.resolve(dest);
+    if (!(dest in this.metadataCache)) {
+      let fileContent;
+      const mtime = await fileExists(dest) ? (await fsAsync4.stat(dest)).mtime : void 0;
+      if (mtime && (/* @__PURE__ */ new Date()).getTime() - mtime.getTime() < cacheDuration) {
+        fileContent = await fsAsync4.readFile(dest, "utf-8");
+      } else {
+        const request = await maybe(fetchWithFileUrl(url));
+        if (request.success) {
+          await fsAsync4.mkdir(path4.dirname(dest), { recursive: true });
+          await withTmpDir(dest, async (tmpDir) => {
+            await fsAsync4.writeFile(path4.join(tmpDir, "download.json"), request.result);
+            return path4.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 fsAsync4.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 = path4.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 = path4.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 = path4.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 = semver2.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 = semver2.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.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 = path4.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
+    let installerPath;
+    let downloader;
+    if (platform == "linux") {
+      installerPath = path4.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 = path4.join(tmpDir, "Obsidian.AppImage");
+          await fsAsync4.writeFile(appImage, (await fetch2(installerUrl)).body);
+          const obsidianFolder = path4.join(tmpDir, "Obsidian");
+          await extractObsidianAppImage(appImage, obsidianFolder);
+          return obsidianFolder;
+        };
+      }
+    } else if (platform == "win32") {
+      installerPath = path4.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 = path4.join(tmpDir, "Obsidian.exe");
+          await fsAsync4.writeFile(installerExecutable, (await fetch2(installerUrl)).body);
+          const obsidianFolder = path4.join(tmpDir, "Obsidian");
+          await extractObsidianExe(installerExecutable, appArch, obsidianFolder);
+          return obsidianFolder;
+        };
+      }
+    } else if (platform == "darwin") {
+      installerPath = path4.join(cacheDir, "Contents/MacOS/Obsidian");
+      const installerUrl = versionInfo.downloads.dmg;
+      if (installerUrl) {
+        downloader = async (tmpDir) => {
+          const dmg = path4.join(tmpDir, "Obsidian.dmg");
+          await fsAsync4.writeFile(dmg, (await fetch2(installerUrl)).body);
+          const obsidianFolder = path4.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 fsAsync4.mkdir(path4.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 = path4.join(this.cacheDir, "obsidian-app", `obsidian-${appVersionInfo.version}.asar`);
+    if (!await fileExists(appPath)) {
+      console.log(`Downloading Obsidian app v${appVersion} ...`);
+      await fsAsync4.mkdir(path4.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 fetch2(appUrl);
+        const archive = path4.join(tmpDir, "app.asar.gz");
+        const asar = path4.join(tmpDir, "app.asar");
+        await fsAsync4.writeFile(archive, response.body);
+        await pipeline(fs.createReadStream(archive), zlib.createGunzip(), fs.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 downloadArtifact({
+      version: electronVersion,
+      artifactName: "chromedriver",
+      cacheRoot: path4.join(this.cacheDir, "chromedriver-legacy"),
+      unsafelyDisableChecksums: true
+      // the checksums are slow and run even on cache hit.
+    });
+    let chromedriverPath;
+    if (process.platform == "win32") {
+      chromedriverPath = path4.join(path4.dirname(chromedriverZipPath), "chromedriver.exe");
+    } else {
+      chromedriverPath = path4.join(path4.dirname(chromedriverZipPath), "chromedriver");
+    }
+    if (!await fileExists(chromedriverPath)) {
+      console.log(`Downloading legacy chromedriver for electron ${electronVersion} ...`);
+      await withTmpDir(chromedriverPath, async (tmpDir) => {
+        await extractZip(chromedriverZipPath, { dir: tmpDir });
+        return path4.join(tmpDir, path4.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 = path4.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.valid(version)) {
+      throw Error(`Invalid version "${version}"`);
+    }
+    version = semver2.valid(version);
+    const pluginDir = path4.join(this.cacheDir, "obsidian-plugins", repo, version);
+    if (!await fileExists(pluginDir)) {
+      await fsAsync4.mkdir(path4.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 fetch2(url);
+            if (response.ok) {
+              await fsAsync4.writeFile(path4.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) => {
+        if (typeof plugin == "object" && "originalType" in plugin) {
+          return { ...plugin };
+        }
+        let pluginPath;
+        let originalType;
+        if (typeof plugin == "string") {
+          pluginPath = plugin;
+          originalType = "local";
+        } else if ("path" in plugin) {
+          ;
+          pluginPath = plugin.path;
+          originalType = "local";
+        } else if ("repo" in plugin) {
+          pluginPath = await this.downloadGitHubPlugin(plugin.repo, plugin.version);
+          originalType = "github";
+        } else if ("id" in plugin) {
+          pluginPath = await this.downloadCommunityPlugin(plugin.id, plugin.version);
+          originalType = "community";
+        } 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 = path4.join(pluginPath, "manifest.json");
+          pluginId = JSON.parse(await fsAsync4.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, originalType };
+      })
+    );
+  }
+  /** 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 = path4.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 = path4.join(this.cacheDir, "obsidian-themes", repo, version);
+    if (!await fileExists(themeDir)) {
+      await fsAsync4.mkdir(path4.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 fetch2(url);
+            if (response.ok) {
+              await fsAsync4.writeFile(path4.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) => {
+        if (typeof theme == "object" && "originalType" in theme) {
+          return { ...theme };
+        }
+        let themePath;
+        let originalType;
+        if (typeof theme == "string") {
+          themePath = theme;
+          originalType = "local";
+        } else if ("path" in theme) {
+          ;
+          themePath = theme.path;
+          originalType = "local";
+        } else if ("repo" in theme) {
+          themePath = await this.downloadGitHubTheme(theme.repo);
+          originalType = "github";
+        } else if ("name" in theme) {
+          themePath = await this.downloadCommunityTheme(theme.name);
+          originalType = "community";
+        } 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 = path4.join(themePath, "manifest.json");
+          themeName = JSON.parse(await fsAsync4.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, originalType };
+      })
+    );
+  }
+  /**
+   * 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 = path4.join(vault, ".obsidian");
+    await fsAsync4.mkdir(obsidianDir, { recursive: true });
+    const enabledPluginsPath = path4.join(obsidianDir, "community-plugins.json");
+    let originalEnabledPlugins = [];
+    if (await fileExists(enabledPluginsPath)) {
+      originalEnabledPlugins = JSON.parse(await fsAsync4.readFile(enabledPluginsPath, "utf-8"));
+    }
+    let enabledPlugins = [...originalEnabledPlugins];
+    for (const { path: pluginPath, enabled = true, originalType } of downloadedPlugins) {
+      const manifestPath = path4.join(pluginPath, "manifest.json");
+      const pluginId = JSON.parse(await fsAsync4.readFile(manifestPath, "utf8").catch(() => "{}")).id;
+      if (!pluginId) {
+        throw Error(`${manifestPath} missing or malformed.`);
+      }
+      const pluginDest = path4.join(obsidianDir, "plugins", pluginId);
+      await fsAsync4.rm(pluginDest, { recursive: true, force: true });
+      await fsAsync4.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(path4.join(pluginPath, file))) {
+          await linkOrCp(path4.join(pluginPath, file), path4.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 (originalType == "local") {
+        await fsAsync4.writeFile(path4.join(pluginDest, ".hotreload"), "");
+      }
+    }
+    if (!_3.isEqual(enabledPlugins, originalEnabledPlugins)) {
+      await fsAsync4.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 = path4.join(vault, ".obsidian");
+    await fsAsync4.mkdir(obsidianDir, { recursive: true });
+    let enabledTheme = void 0;
+    for (const { path: themePath, enabled = true } of downloadedThemes) {
+      const manifestPath = path4.join(themePath, "manifest.json");
+      const cssPath = path4.join(themePath, "theme.css");
+      const themeName = JSON.parse(await fsAsync4.readFile(manifestPath, "utf8").catch(() => "{}")).name;
+      if (!themeName) {
+        throw Error(`${manifestPath} missing or malformed.`);
+      }
+      if (!await fileExists(cssPath)) {
+        throw Error(`${cssPath} missing.`);
+      }
+      const themeDest = path4.join(obsidianDir, "themes", themeName);
+      await fsAsync4.rm(themeDest, { recursive: true, force: true });
+      await fsAsync4.mkdir(themeDest, { recursive: true });
+      await linkOrCp(manifestPath, path4.join(themeDest, "manifest.json"));
+      await linkOrCp(cssPath, path4.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 = path4.join(obsidianDir, "appearance.json");
+      let appearance = {};
+      if (await fileExists(appearancePath)) {
+        appearance = JSON.parse(await fsAsync4.readFile(appearancePath, "utf-8"));
+      }
+      appearance.cssTheme = enabledTheme ?? "";
+      await fsAsync4.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 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 = params.dest ?? await fsAsync4.mkdtemp(path4.join(os.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) {
+      const vaultId = crypto.randomBytes(8).toString("hex");
+      obsidianJson = {
+        ...obsidianJson,
+        vaults: {
+          [vaultId]: {
+            path: path4.resolve(params.vault),
+            ts: (/* @__PURE__ */ new Date()).getTime(),
+            open: true
+          }
+        }
+      };
+      localStorageData = {
+        ...localStorageData,
+        [`enable-plugin-${vaultId}`]: "true"
+        // Disable "safe mode" and enable plugins
+      };
+    }
+    await fsAsync4.writeFile(path4.join(configDir, "obsidian.json"), JSON.stringify(obsidianJson));
+    if (params.appPath) {
+      await linkOrCp(params.appPath, path4.join(configDir, path4.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;
+  }
+  /**
+   * Sets up a vault for Obsidian, installing plugins and themes and optionally copying the vault to a temporary
+   * directory first.
+   * @param vault Path to the vault to open in Obsidian.
+   * @param copy Whether to copy the vault to a tmpdir first. Default false.
+   * @param plugins List of plugins to install in the vault.
+   * @param themes List of themes to install in the vault.
+   * @returns Path to the copied vault (or just the path to the vault if copy is false)
+   */
+  async setupVault(params) {
+    let vault = params.vault;
+    if (params.copy) {
+      const dest = await fsAsync4.mkdtemp(path4.join(os.tmpdir(), "obs-launcher-vault-"));
+      await fsAsync4.cp(vault, dest, { recursive: true });
+      vault = dest;
+    }
+    await this.installPlugins(vault, params.plugins ?? []);
+    await this.installThemes(vault, params.themes ?? []);
+    return vault;
+  }
+  /**
+   * Downloads and launches Obsidian with a sandboxed config dir and a specifc vault open. Optionally install plugins
+   * and themes first.
+   * 
+   * This is just a shortcut for calling downloadApp, downloadInstaller, setupVault and setupConfDir.
+   *
+   * @param appVersion Obsidian version string.
+   * @param installerVersion Obsidian version string.
+   * @param vault Path to the vault to open in Obsidian.
+   * @param copy Whether to copy the vault to a tmpdir first. Default false.
+   * @param plugins List of plugins to install in the vault.
+   * @param themes List of themes to install in the vault.
+   * @param args CLI args to pass to Obsidian
+   * @param spawnOptions Options to pass to `spawn`.
+   * @returns The launched child process and the created tmpdirs.
+   */
+  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);
+    let vault = params.vault;
+    if (vault) {
+      vault = await this.setupVault({
+        vault,
+        copy: params.copy ?? false,
+        plugins: params.plugins,
+        themes: params.themes
+      });
+    }
+    const configDir = await this.setupConfigDir({ appVersion, installerVersion, appPath, vault });
+    const proc = child_process2.spawn(installerPath, [
+      `--user-data-dir=${configDir}`,
+      ...params.args ?? []
+    ], {
+      ...params.spawnOptions
+    });
+    return { proc, configDir, vault };
+  }
+  /**
+   * 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 fsAsync4.mkdtemp(path4.join(os.tmpdir(), `fetch-obsidian-versions-`));
+    const proc = child_process2.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(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 = data.toString().match(/ws:\/\/[\w.]+?:(\d+)/)?.[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 CDP({ 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 fsAsync4.rm(configDir, { recursive: true, force: true });
+    }
+    if (!dependencyVersions?.electron || !dependencyVersions?.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: original?.metadata.commit_date
+    });
+    commitHistory.reverse();
+    if (original) {
+      commitHistory = _3.takeRightWhile(commitHistory, (c) => c.sha != original.metadata.commit_sha);
+    }
+    const fileHistory = await pool(
+      8,
+      commitHistory,
+      (commit) => fetch2(`https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
+    );
+    const githubReleases = await fetchGitHubAPIPaginated(`repos/${repo}/releases`);
+    const versionMap = _3.keyBy(
+      original?.versions ?? [],
+      (v) => v.version
+    );
+    for (const { beta, ...current } of fileHistory) {
+      if (beta && (!versionMap[beta.latestVersion] || versionMap[beta.latestVersion].isBeta)) {
+        versionMap[beta.latestVersion] = _3.merge(
+          {},
+          versionMap[beta.latestVersion],
+          parseObsidianDesktopRelease(beta, true)
+        );
+      }
+      versionMap[current.latestVersion] = _3.merge(
+        {},
+        versionMap[current.latestVersion],
+        parseObsidianDesktopRelease(current, false)
+      );
+    }
+    for (const release of githubReleases) {
+      if (versionMap.hasOwnProperty(release.name)) {
+        versionMap[release.name] = _3.merge({}, versionMap[release.name], parseObsidianGithubRelease(release));
+      }
+    }
+    const dependencyVersions = await pool(
+      maxInstances,
+      Object.values(versionMap).filter((v) => v.downloads?.appImage && !v.chromeVersion),
+      (v) => this.getDependencyVersions(v)
+    );
+    for (const deps of dependencyVersions) {
+      versionMap[deps.version] = _3.merge({}, versionMap[deps.version], deps);
+    }
+    let maxInstallerVersion = "0.0.0";
+    for (const version of Object.keys(versionMap).sort(semver2.compare)) {
+      if (versionMap[version].downloads.appImage) {
+        maxInstallerVersion = version;
+      }
+      versionMap[version] = _3.merge(
+        {},
+        versionMap[version],
+        correctObsidianVersionInfo(versionMap[version]),
+        { maxInstallerVersion }
+      );
+    }
+    const versionInfos = Object.values(versionMap);
+    versionInfos.sort((a, b) => semver2.compare(a.version, b.version));
+    const result = {
+      metadata: {
+        commit_date: commitHistory.at(-1)?.commit.committer.date ?? original?.metadata.commit_date,
+        commit_sha: commitHistory.at(-1)?.sha ?? original?.metadata.commit_sha,
+        timestamp: original?.metadata.timestamp ?? ""
+        // set down below
+      },
+      versions: versionInfos
+    };
+    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;
+  }
+  /**
+   * 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(path4.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;
+    }
+  }
+};
+
+export {
+  ObsidianLauncher
+};
+//# sourceMappingURL=chunk-HKIRRZUO.js.map