obsidian-launcher 0.1.8 → 0.2.1

package/dist/{chunk-CNMICOMM.js → chunk-GYFCGBK2.js}

@@ -3,7 +3,7 @@ import fsAsync4 from "fs/promises";
 import fs from "fs";
 import zlib from "zlib";
 import path4 from "path";
-import os from "os";
+import os2 from "os";
 import crypto from "crypto";
 import fetch2 from "node-fetch";
 import extractZip from "extract-zip";
@@ -11,12 +11,12 @@ 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";
+import _ from "lodash";
 async function fileExists(path5) {
   try {
     await fsAsync.access(path5);
@@ -71,9 +71,20 @@ async function pool(size, items, func) {
 async function maybe(promise) {
   return promise.then((r) => ({ success: true, result: r, error: void 0 })).catch((e) => ({ success: false, result: void 0, error: e }));
 }
+function mergeKeepUndefined(object, ...sources) {
+  return _.mergeWith(
+    object,
+    ...sources,
+    (objValue, srcValue, key, obj) => {
+      if (_.isPlainObject(obj) && objValue !== srcValue && srcValue === void 0) {
+        obj[key] = srcValue;
+      }
+    }
+  );
+}
 
 // src/apis.ts
-import _ from "lodash";
+import _2 from "lodash";
 import fetch from "node-fetch";
 import fsAsync2 from "fs/promises";
 import { fileURLToPath } from "url";
@@ -100,7 +111,7 @@ function parseLinkHeader(linkHeader) {
   return Object.fromEntries(linkDatas.map((l) => [l.rel, l]));
 }
 function createURL(url, base, params = {}) {
-  params = _.pickBy(params, (x) => x !== void 0);
+  params = _2.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) {
@@ -234,11 +245,13 @@ var ChromeLocalStorage = class {
 // src/launcherUtils.ts
 import fsAsync3 from "fs/promises";
 import path3 from "path";
+import os from "os";
 import { promisify } from "util";
 import child_process from "child_process";
 import which from "which";
 import semver from "semver";
-import _2 from "lodash";
+import _3 from "lodash";
+import CDP from "chrome-remote-interface";
 var execFile = promisify(child_process.execFile);
 function normalizeGitHubRepo(repo) {
   return repo.replace(/^(https?:\/\/)?(github.com\/)/, "");
@@ -285,9 +298,7 @@ async function extractObsidianDmg(dmg, dest) {
 function parseObsidianDesktopRelease(fileRelease, isBeta) {
   return {
     version: fileRelease.latestVersion,
-    minInstallerVersion: fileRelease.minimumVersion,
-    maxInstallerVersion: "",
-    // Will be set later
+    minInstallerVersion: fileRelease.minimumVersion != "0.0.0" ? fileRelease.minimumVersion : void 0,
     isBeta,
     downloads: {
       asar: fileRelease.downloadUrl
@@ -308,19 +319,105 @@ function parseObsidianGithubRelease(gitHubRelease) {
   return {
     version,
     gitHubRelease: gitHubRelease.html_url,
-    downloads: _2.pickBy(downloads, (x) => x !== void 0)
+    downloads: _3.pickBy(downloads, (x) => x !== void 0)
+  };
+}
+async function getElectronVersionInfo(version, binaryPath) {
+  console.log(`${version}: Retrieving electron & chrome versions...`);
+  const configDir = await fsAsync3.mkdtemp(path3.join(os.tmpdir(), `fetch-obsidian-versions-`));
+  const proc = child_process.spawn(binaryPath, [
+    `--remote-debugging-port=0`,
+    // 0 will make it choose a random available port
+    "--test-type=webdriver",
+    `--user-data-dir=${configDir}`,
+    "--no-sandbox"
+    // Workaround for SUID issue, see https://github.com/electron/electron/issues/42510
+  ]);
+  const procExit = new Promise((resolve) => proc.on("exit", (code) => resolve(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(`${version}: Stuck process ${proc.pid}, using SIGKILL`);
+      proc.kill("SIGKILL");
+    }
+    await procExit;
+    await sleep(1e3);
+    await fsAsync3.rm(configDir, { recursive: true, force: true });
+  }
+  if (!dependencyVersions?.electron || !dependencyVersions?.chrome) {
+    throw Error(`Failed to extract electron and chrome versions for ${version}`);
+  }
+  return {
+    electronVersion: dependencyVersions.electron,
+    chromeVersion: dependencyVersions.chrome,
+    nodeVersion: dependencyVersions.node
   };
 }
 function correctObsidianVersionInfo(versionInfo) {
-  const corrections = {};
+  const corrections = [
+    // These version's downloads are missing or broken.
+    { version: "0.12.16", downloads: { asar: void 0 } },
+    { version: "1.4.7", downloads: { asar: void 0 } },
+    { version: "1.4.8", downloads: { asar: void 0 } },
+    // The minInstallerVersion here is incorrect
+    { version: "1.3.4", minInstallerVersion: "0.14.5" },
+    { version: "1.3.3", minInstallerVersion: "0.14.5" },
+    { version: "1.3.2", minInstallerVersion: "0.14.5" },
+    { version: "1.3.1", minInstallerVersion: "0.14.5" },
+    { version: "1.3.0", minInstallerVersion: "0.14.5" }
+  ];
+  const result = corrections.find((v) => v.version == versionInfo.version) ?? {};
   if (semver.gte(versionInfo.version, "1.5.3") && semver.lt(versionInfo.minInstallerVersion, "1.1.9")) {
-    corrections.minInstallerVersion = "1.1.9";
+    result.minInstallerVersion = "1.1.9";
   }
-  return corrections;
+  return result;
+}
+function normalizeObsidianVersionInfo(versionInfo) {
+  versionInfo = {
+    version: versionInfo.version,
+    minInstallerVersion: versionInfo.minInstallerVersion,
+    maxInstallerVersion: versionInfo.maxInstallerVersion,
+    isBeta: versionInfo.isBeta,
+    gitHubRelease: versionInfo.gitHubRelease,
+    downloads: {
+      asar: versionInfo.downloads?.asar,
+      appImage: versionInfo.downloads?.appImage,
+      appImageArm: versionInfo.downloads?.appImageArm,
+      apk: versionInfo.downloads?.apk,
+      dmg: versionInfo.downloads?.dmg,
+      exe: versionInfo.downloads?.exe
+    },
+    electronVersion: versionInfo.electronVersion,
+    chromeVersion: versionInfo.chromeVersion,
+    nodeVersion: versionInfo.nodeVersion
+  };
+  versionInfo.downloads = _3.omitBy(versionInfo.downloads, _3.isUndefined);
+  versionInfo = _3.omitBy(versionInfo, _3.isUndefined);
+  return versionInfo;
 }
 
 // src/launcher.ts
-import _3 from "lodash";
+import _4 from "lodash";
 var ObsidianLauncher = class {
   /**
    * Construct an ObsidianLauncher.
@@ -403,8 +500,8 @@ var ObsidianLauncher = class {
     return await this.cachedFetch(this.communityThemesUrl, dest);
   }
   /**
-   * Resolves Obsidian version strings to absolute obsidian versions.
-   * @param appVersion Obsidian version string or "latest", "earliest", or "latest-beta". "earliest" will use the 
+   * Resolves Obsidian app and installer version strings to absolute versions.
+   * @param appVersion Obsidian version string or "latest", "latest-beta" or "earliest". "earliest" will use the 
    *     minAppVersion set in your manifest.json.
    * @param installerVersion Obsidian version string or "latest" or "earliest". "earliest" will use the minimum
    *     installer version compatible with the appVersion.
@@ -412,21 +509,9 @@ var ObsidianLauncher = class {
    */
   async resolveVersions(appVersion, installerVersion = "latest") {
     const versions = await this.getVersions();
-    if (appVersion == "latest-beta") {
-      appVersion = versions.at(-1).version;
-    } else if (appVersion == "latest") {
-      appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
-    } else if (appVersion == "earliest") {
-      appVersion = (await this.getRootManifest())?.minAppVersion;
-      if (!appVersion) {
-        throw Error('Unable to resolve Obsidian app version "earliest", no manifest.json or minAppVersion found.');
-      }
-    } else {
-      appVersion = semver2.valid(appVersion) ?? appVersion;
-    }
-    const appVersionInfo = versions.find((v) => v.version == appVersion);
-    if (!appVersionInfo) {
-      throw Error(`No Obsidian app version ${appVersion} found`);
+    const appVersionInfo = await this.getVersionInfo(appVersion);
+    if (!appVersionInfo.minInstallerVersion || !appVersionInfo.maxInstallerVersion) {
+      throw Error(`No compatible installers available for app version ${appVersion}`);
     }
     if (installerVersion == "latest") {
       installerVersion = appVersionInfo.maxInstallerVersion;
@@ -439,21 +524,37 @@ var ObsidianLauncher = class {
     if (!installerVersionInfo || !installerVersionInfo.chromeVersion) {
       throw Error(`No Obsidian installer for version ${installerVersion} found`);
     }
-    if (semver2.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion)) {
+    if (semver2.lt(installerVersionInfo.version, appVersionInfo.minInstallerVersion) || semver2.gt(installerVersionInfo.version, appVersionInfo.maxInstallerVersion)) {
       throw Error(
-        `Installer and app versions incompatible: minInstallerVersion of v${appVersionInfo.version} is ${appVersionInfo.minInstallerVersion}, but v${installerVersionInfo.version} specified`
+        `App and installer versions incompatible: app ${appVersionInfo.version} is compatible with installer >=${appVersionInfo.minInstallerVersion} <=${appVersionInfo.maxInstallerVersion} but ${installerVersionInfo.version} specified`
       );
     }
     return [appVersionInfo.version, installerVersionInfo.version];
   }
-  /** Gets details about an Obsidian version */
+  /**
+   * Gets details about an Obsidian version.
+   * @param version Obsidian version string or "latest", "earliest", or "latest-beta". "earliest" will use the 
+   *     minAppVersion set in your manifest.json.
+   */
   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`);
+    const versions = await this.getVersions();
+    if (version == "latest-beta") {
+      version = versions.at(-1).version;
+    } else if (version == "latest") {
+      version = versions.filter((v) => !v.isBeta).at(-1).version;
+    } else if (version == "earliest") {
+      version = (await this.getRootManifest())?.minAppVersion;
+      if (!version) {
+        throw Error('Unable to resolve Obsidian app version "earliest", no manifest.json or minAppVersion found.');
+      }
+    } else {
+      version = semver2.valid(version) ?? version;
     }
-    return result;
+    const versionInfo = versions.find((v) => v.version == version);
+    if (!versionInfo) {
+      throw Error(`No Obsidian app version ${version} found`);
+    }
+    return versionInfo;
   }
   /**
    * Downloads the Obsidian installer for the given version and platform. Returns the file path.
@@ -850,7 +951,7 @@ var ObsidianLauncher = class {
         await fsAsync4.writeFile(path4.join(pluginDest, ".hotreload"), "");
       }
     }
-    if (!_3.isEqual(enabledPlugins, originalEnabledPlugins)) {
+    if (!_4.isEqual(enabledPlugins, originalEnabledPlugins)) {
       await fsAsync4.writeFile(enabledPluginsPath, JSON.stringify(enabledPlugins, void 0, 2));
     }
   }
@@ -899,13 +1000,13 @@ var ObsidianLauncher = class {
    *
    * @param appVersion Obsidian version string.
    * @param installerVersion Obsidian version string.
-   * @param appPath Path to the asar file to install.
+   * @param appPath Path to the asar file to install. Will download if omitted.
    * @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-"));
+    const configDir = params.dest ?? await fsAsync4.mkdtemp(path4.join(os2.tmpdir(), "obs-launcher-config-"));
     let obsidianJson = {
       updateDisabled: true
       // Prevents Obsidian trying to auto-update on boot.
@@ -933,11 +1034,11 @@ var ObsidianLauncher = class {
       };
     }
     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");
+    let appPath = params.appPath;
+    if (!appPath) {
+      appPath = await this.downloadApp(appVersion);
     }
+    await linkOrCp(appPath, path4.join(configDir, path4.basename(appPath)));
     const localStorage = new ChromeLocalStorage(configDir);
     await localStorage.setItems("app://obsidian.md", localStorageData);
     await localStorage.close();
@@ -955,7 +1056,7 @@ var ObsidianLauncher = class {
   async setupVault(params) {
     let vault = params.vault;
     if (params.copy) {
-      const dest = await fsAsync4.mkdtemp(path4.join(os.tmpdir(), "obs-launcher-vault-"));
+      const dest = await fsAsync4.mkdtemp(path4.join(os2.tmpdir(), "obs-launcher-vault-"));
       await fsAsync4.cp(vault, dest, { recursive: true });
       vault = dest;
     }
@@ -1001,63 +1102,6 @@ var ObsidianLauncher = class {
     });
     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
@@ -1071,7 +1115,7 @@ var ObsidianLauncher = class {
     });
     commitHistory.reverse();
     if (original) {
-      commitHistory = _3.takeRightWhile(commitHistory, (c) => c.sha != original.metadata.commit_sha);
+      commitHistory = _4.takeRightWhile(commitHistory, (c) => c.sha != original.metadata.commit_sha);
     }
     const fileHistory = await pool(
       8,
@@ -1079,19 +1123,19 @@ var ObsidianLauncher = class {
       (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(
+    const versionMap = _4.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] = _4.merge(
           {},
           versionMap[beta.latestVersion],
           parseObsidianDesktopRelease(beta, true)
         );
       }
-      versionMap[current.latestVersion] = _3.merge(
+      versionMap[current.latestVersion] = _4.merge(
         {},
         versionMap[current.latestVersion],
         parseObsidianDesktopRelease(current, false)
@@ -1099,31 +1143,40 @@ var ObsidianLauncher = class {
     }
     for (const release of githubReleases) {
       if (versionMap.hasOwnProperty(release.name)) {
-        versionMap[release.name] = _3.merge({}, versionMap[release.name], parseObsidianGithubRelease(release));
+        versionMap[release.name] = _4.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)
+      async (v) => {
+        const binaryPath = await this.downloadInstallerFromVersionInfo(v);
+        const electronVersionInfo = await getElectronVersionInfo(v.version, binaryPath);
+        return { ...v, ...electronVersionInfo };
+      }
     );
     for (const deps of dependencyVersions) {
-      versionMap[deps.version] = _3.merge({}, versionMap[deps.version], deps);
+      versionMap[deps.version] = _4.merge({}, versionMap[deps.version], deps);
     }
-    let maxInstallerVersion = "0.0.0";
+    let minInstallerVersion = void 0;
+    let maxInstallerVersion = void 0;
     for (const version of Object.keys(versionMap).sort(semver2.compare)) {
+      if (!minInstallerVersion && versionMap[version].chromeVersion) {
+        minInstallerVersion = version;
+      }
       if (versionMap[version].downloads.appImage) {
         maxInstallerVersion = version;
       }
-      versionMap[version] = _3.merge(
+      versionMap[version] = mergeKeepUndefined(
         {},
         versionMap[version],
-        correctObsidianVersionInfo(versionMap[version]),
-        { maxInstallerVersion }
+        {
+          minInstallerVersion: versionMap[version].minInstallerVersion ?? minInstallerVersion,
+          maxInstallerVersion
+        },
+        correctObsidianVersionInfo(versionMap[version])
       );
     }
-    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,
@@ -1131,11 +1184,11 @@ var ObsidianLauncher = class {
         timestamp: original?.metadata.timestamp ?? ""
         // set down below
       },
-      versions: versionInfos
+      versions: Object.values(versionMap).map(normalizeObsidianVersionInfo).sort((a, b) => semver2.compare(a.version, b.version))
     };
     const dayMs = 24 * 60 * 60 * 1e3;
     const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(original?.metadata.timestamp ?? 0).getTime();
-    if (!_3.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
+    if (!_4.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
       result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
     }
     return result;
@@ -1144,7 +1197,7 @@ var ObsidianLauncher = class {
    * Returns true if the Obsidian version is already in the cache.
    */
   async isInCache(type, version) {
-    version = (await this.resolveVersions(version))[0];
+    version = (await this.getVersionInfo(version)).version;
     let dest;
     if (type == "app") {
       dest = `obsidian-app/obsidian-${version}.asar`;
@@ -1160,12 +1213,13 @@ var ObsidianLauncher = class {
    */
   async isAvailable(version) {
     const versionInfo = await this.getVersionInfo(version);
+    const versionExists = !!(versionInfo.downloads.asar && versionInfo.minInstallerVersion);
     if (versionInfo.isBeta) {
       const hasCreds = !!(process.env["OBSIDIAN_USERNAME"] && process.env["OBSIDIAN_PASSWORD"]);
       const inCache = await this.isInCache("app", versionInfo.version);
-      return hasCreds || inCache;
+      return versionExists && (hasCreds || inCache);
     } else {
-      return !!versionInfo.downloads.asar;
+      return versionExists;
     }
   }
 };
@@ -1173,4 +1227,4 @@ var ObsidianLauncher = class {
 export {
   ObsidianLauncher
 };
-//# sourceMappingURL=chunk-CNMICOMM.js.map
+//# sourceMappingURL=chunk-GYFCGBK2.js.map