obsidian-launcher 2.0.2 → 2.1.0

package/dist/{chunk-EVX5ML6K.js → chunk-OUPK2DAJ.js}

@@ -116,57 +116,19 @@ import fsAsync2 from "fs/promises";
 import readlineSync from "readline-sync";
 import dotenv from "dotenv";
 import path2 from "path";
+import { Octokit } from "octokit";
 import { env } from "process";
-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 = _2.pickBy(params, (x) => x !== void 0);
+  const cleanParams = _2(params).pickBy((x) => x !== void 0).mapValues((v) => String(v)).value();
   const urlObj = new URL(url, base);
-  const searchParams = new URLSearchParams({ ...Object.fromEntries(urlObj.searchParams), ...params });
+  const searchParams = new URLSearchParams({ ...Object.fromEntries(urlObj.searchParams), ...cleanParams });
   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 = 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 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;
+function getGithubClient() {
+  return new Octokit({ auth: env.GITHUB_TOKEN });
 }
 async function obsidianApiLogin(opts) {
   const { interactive = false, savePath } = opts;
@@ -180,7 +142,7 @@ async function obsidianApiLogin(opts) {
       password = password || readlineSync.question("Obsidian password: ", { hideEchoBack: true });
     } else {
       throw Error(
-        "Obsidian Insiders account is required to download Obsidian beta versions. Either set the OBSIDIAN_EMAIL and OBSIDIAN_PASSWORD env vars (.env file is supported) or pre-download the Obsidian beta with `npx obsidian-launcher download -v <version>`"
+        "Obsidian Insiders account is required to download Obsidian beta versions. Either set the OBSIDIAN_EMAIL and OBSIDIAN_PASSWORD env vars (.env file is supported) or pre-download the Obsidian beta with `npx obsidian-launcher download app -v <version>`"
       );
     }
   }
@@ -209,7 +171,7 @@ async function obsidianApiLogin(opts) {
       needsMfa = true;
       if (!interactive) {
         throw Error(
-          "Can't login with 2FA in a non-interactive session. To download Obsidian beta versions, either disable 2FA on your account or pre-download the Obsidian beta with `npx obsidian-launcher download -v <version>`"
+          "Can't login with 2FA in a non-interactive session. To download Obsidian beta versions, either disable 2FA on your account or pre-download the Obsidian beta with `npx obsidian-launcher download app -v <version>`"
         );
       }
     } else if (["please wait", "try again"].some((m) => error?.includes(m))) {
@@ -219,9 +181,9 @@ async function obsidianApiLogin(opts) {
       throw Error(`Obsidian login failed: ${signin.error ?? "unknown error"}`);
     }
   }
-  if (!signin.token) {
-    throw Error(`Obsidian login failed: ${signin.error ?? "unknown error"}`);
-  } else if (!signin.license) {
+  if (!signin?.token) {
+    throw Error(`Obsidian login failed: ${signin?.error ?? "unknown error"}`);
+  } else if (!signin?.license) {
     throw Error("Obsidian Insiders account is required to download Obsidian beta versions");
   }
   if (interactive && savePath && (!env.OBSIDIAN_EMAIL || !env.OBSIDIAN_PASSWORD)) {
@@ -233,8 +195,8 @@ async function obsidianApiLogin(opts) {
 OBSIDIAN_PASSWORD='${password}'
 `
       );
+      console.log(`Saved Obsidian credentials to ${path2.relative(process.cwd(), savePath)}`);
     }
-    console.log(`Saved Obsidian credentials to ${path2.relative(process.cwd(), savePath)}`);
   }
   return signin.token;
 }
@@ -411,6 +373,39 @@ async function extractObsidianDmg(dmg, dest) {
     }
   });
 }
+async function fetchObsidianDesktopReleases(sinceDate, sinceSha) {
+  const repo = "obsidianmd/obsidian-releases";
+  const github = getGithubClient();
+  let commitHistory = await github.paginate(github.rest.repos.listCommits, {
+    owner: "obsidianmd",
+    repo: "obsidian-releases",
+    path: "desktop-releases.json",
+    since: sinceDate,
+    per_page: 100
+  });
+  commitHistory.reverse();
+  if (sinceSha) {
+    commitHistory = _3.takeRightWhile(commitHistory, (c) => c.sha != sinceSha);
+  }
+  const fileHistory = await pool(
+    4,
+    commitHistory,
+    (commit) => fetch(`https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
+  );
+  const commitDate = commitHistory.at(-1)?.commit.committer?.date ?? sinceDate;
+  const commitSha = commitHistory.at(-1)?.sha ?? sinceSha;
+  return [fileHistory, { commitDate, commitSha }];
+}
+async function fetchObsidianGitHubReleases() {
+  const github = getGithubClient();
+  let gitHubReleases = await github.paginate(github.rest.repos.listReleases, {
+    owner: "obsidianmd",
+    repo: "obsidian-releases",
+    per_page: 100
+  });
+  gitHubReleases = gitHubReleases.reverse();
+  return gitHubReleases;
+}
 var BROKEN_ASSETS = [
   "https://releases.obsidian.md/release/obsidian-0.12.16.asar.gz",
   "https://github.com/obsidianmd/obsidian-releases/releases/download/v0.12.16/obsidian-0.12.16.asar.gz",
@@ -481,7 +476,59 @@ function parseObsidianGithubRelease(gitHubRelease) {
     }
   };
 }
-async function getInstallerInfo(installerKey, url) {
+var INSTALLER_KEYS = [
+  "appImage",
+  "appImageArm",
+  "tar",
+  "tarArm",
+  "dmg",
+  "exe"
+];
+function updateObsidianVersionList(args) {
+  const { original = [], destkopReleases = [], gitHubReleases = [], installerInfos = [] } = args;
+  const oldVersions = _3.keyBy(original, (v) => v.version);
+  const newVersions = _3.cloneDeep(oldVersions);
+  for (const destkopRelease of destkopReleases) {
+    const { current, beta } = parseObsidianDesktopRelease(destkopRelease);
+    if (beta) {
+      newVersions[beta.version] = _3.merge(newVersions[beta.version] ?? {}, beta);
+    }
+    newVersions[current.version] = _3.merge(newVersions[current.version] ?? {}, current);
+  }
+  for (const githubRelease of gitHubReleases) {
+    if (semver.valid(githubRelease.name) && !semver.prerelease(githubRelease.name)) {
+      const parsed = parseObsidianGithubRelease(githubRelease);
+      const newVersion = _3.merge(newVersions[parsed.version] ?? {}, parsed);
+      for (const installerKey of INSTALLER_KEYS) {
+        const oldDigest = oldVersions[parsed.version]?.installers[installerKey]?.digest;
+        const newDigest = newVersion.installers?.[installerKey]?.digest;
+        if (oldDigest && oldDigest != newDigest) {
+          newVersion.installers[installerKey] = { digest: newDigest };
+        }
+      }
+      newVersions[parsed.version] = newVersion;
+    }
+  }
+  let minInstallerVersion = void 0;
+  let maxInstallerVersion = void 0;
+  for (const version of Object.keys(newVersions).sort(semver.compare)) {
+    if (newVersions[version].downloads.appImage) {
+      maxInstallerVersion = version;
+      if (!minInstallerVersion) {
+        minInstallerVersion = version;
+      }
+    }
+    newVersions[version] = _3.merge({ minInstallerVersion, maxInstallerVersion }, newVersions[version]);
+  }
+  for (const installerInfo of installerInfos) {
+    newVersions[installerInfo.version] = _3.merge(newVersions[installerInfo.version] ?? {}, {
+      version: installerInfo.version,
+      installers: { [installerInfo.key]: installerInfo.installerInfo }
+    });
+  }
+  return Object.values(newVersions).map(normalizeObsidianVersionInfo).sort((a, b) => semver.compare(a.version, b.version));
+}
+async function extractInstallerInfo(installerKey, url) {
   const installerName = url.split("/").at(-1);
   console.log(`Extrating installer info for ${installerName}...`);
   const tmpDir = await makeTmpDir("obsidian-launcher-");
@@ -757,10 +804,11 @@ var ObsidianLauncher = class {
     } else if (appVersion == "latest") {
       appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
     } else if (appVersion == "earliest") {
-      appVersion = (await this.getRootManifest())?.minAppVersion;
-      if (!appVersion) {
+      const manifest = await this.getRootManifest();
+      if (!manifest?.minAppVersion) {
         throw Error('Unable to resolve Obsidian appVersion "earliest", no manifest.json or minAppVersion found.');
       }
+      appVersion = manifest.minAppVersion;
     } else {
       appVersion = semver2.valid(appVersion) ?? appVersion;
     }
@@ -798,7 +846,7 @@ var ObsidianLauncher = class {
     return _4.uniqBy(resolvedVersions, (v) => v.join("/"));
   }
   getInstallerKey(installerVersionInfo, opts = {}) {
-    const { platform, arch } = _4.merge({}, opts, currentPlatform);
+    const { platform, arch } = _4.defaults({}, opts, currentPlatform);
     const platformName = `${platform}-${arch}`;
     const key = _4.findKey(installerVersionInfo.installers, (v) => v && v.platforms.includes(platformName));
     return key;
@@ -810,7 +858,7 @@ var ObsidianLauncher = class {
    * @param opts.arch Architecture (defaults to host architecture)
    */
   async getInstallerInfo(installerVersion, opts = {}) {
-    const { platform, arch } = _4.merge({}, opts, currentPlatform);
+    const { platform, arch } = _4.defaults({}, opts, currentPlatform);
     const versionInfo = await this.getVersionInfo(installerVersion);
     const key = this.getInstallerKey(versionInfo, { platform, arch });
     if (key) {
@@ -829,7 +877,7 @@ var ObsidianLauncher = class {
    * @param opts.arch Architecture of the installer to download (defaults to host architecture)
    */
   async downloadInstaller(installerVersion, opts = {}) {
-    const { platform, arch } = _4.merge({}, opts, currentPlatform);
+    const { platform, arch } = _4.defaults({}, opts, currentPlatform);
     const versionInfo = await this.getVersionInfo(installerVersion);
     installerVersion = versionInfo.version;
     const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
@@ -865,7 +913,7 @@ var ObsidianLauncher = class {
    * 
    * To download Obsidian beta versions you'll need to have an Obsidian Insiders account and either set the 
    * `OBSIDIAN_EMAIL` and `OBSIDIAN_PASSWORD` env vars (`.env` file is supported) or pre-download the Obsidian beta
-   * with `npx obsidian-launcher download -v latest-beta`
+   * with `npx obsidian-launcher download app -v latest-beta`
    * 
    * @param appVersion Obsidian version to download
    */
@@ -913,7 +961,7 @@ var ObsidianLauncher = class {
    * @param installerVersion Obsidian installer version
    */
   async downloadChromedriver(installerVersion, opts = {}) {
-    const { platform, arch } = _4.merge({}, opts, currentPlatform);
+    const { platform, arch } = _4.defaults({}, opts, currentPlatform);
     const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
     const cacheDir = path5.join(this.cacheDir, `electron-chromedriver/${platform}-${arch}/${installerInfo.electron}`);
     let chromedriverPath;
@@ -1073,6 +1121,60 @@ var ObsidianLauncher = class {
       })
     );
   }
+  /**
+   * Installs plugins into an Obsidian vault
+   * @param vault Path to the vault to install the plugins in
+   * @param plugins List plugins to install
+   */
+  async installPlugins(vault, plugins) {
+    const downloadedPlugins = await this.downloadPlugins(plugins);
+    const obsidianDir = path5.join(vault, ".obsidian");
+    await fsAsync4.mkdir(obsidianDir, { recursive: true });
+    const enabledPluginsPath = path5.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 = path5.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 = path5.join(obsidianDir, "plugins", pluginId);
+      await fsAsync4.mkdir(pluginDest, { recursive: true });
+      const files = {
+        "manifest.json": true,
+        "main.js": true,
+        "styles.css": false
+      };
+      for (const [file, required] of Object.entries(files)) {
+        if (await fileExists(path5.join(pluginPath, file))) {
+          await linkOrCp(path5.join(pluginPath, file), path5.join(pluginDest, file));
+        } else if (required) {
+          throw Error(`${pluginPath}/${file} missing.`);
+        } else {
+          await fsAsync4.rm(path5.join(pluginDest, file), { force: true });
+        }
+      }
+      if (await fileExists(path5.join(pluginPath, "data.json"))) {
+        await fsAsync4.cp(path5.join(pluginPath, "data.json"), path5.join(pluginDest, "data.json"));
+      }
+      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(path5.join(pluginDest, ".hotreload"), "");
+      }
+    }
+    if (!_4.isEqual(enabledPlugins, originalEnabledPlugins)) {
+      await fsAsync4.writeFile(enabledPluginsPath, JSON.stringify(enabledPlugins, void 0, 2));
+    }
+  }
   /** Gets the latest version of a theme. */
   async getLatestThemeVersion(repo) {
     repo = normalizeGitHubRepo(repo);
@@ -1086,25 +1188,40 @@ var ObsidianLauncher = class {
    * @param repo Repo
    * @returns path to the downloaded theme
    */
-  async downloadGitHubTheme(repo) {
+  async downloadGitHubTheme(repo, version = "latest") {
     repo = normalizeGitHubRepo(repo);
-    const version = await this.getLatestThemeVersion(repo);
+    const latest = await this.getLatestThemeVersion(repo);
+    if (version == "latest") {
+      version = latest;
+    }
+    if (!semver2.valid(version)) {
+      throw Error(`Invalid version "${version}"`);
+    }
+    version = semver2.valid(version);
     const themeDir = path5.join(this.cacheDir, "obsidian-themes", repo, version);
     if (!await fileExists(themeDir)) {
       await atomicCreate(themeDir, async (tmpDir) => {
         const assetsToDownload = ["manifest.json", "theme.css"];
+        let baseUrl = `https://github.com/${repo}/releases/download/${version}`;
+        if (!(await fetch(`${baseUrl}/manifest.json`)).ok) {
+          if (version != latest) {
+            throw Error(`No theme version "${version}" found`);
+          }
+          baseUrl = `https://raw.githubusercontent.com/${repo}/HEAD`;
+        }
         await Promise.all(
-          assetsToDownload.map(async (file) => {
-            const url = `https://raw.githubusercontent.com/${repo}/HEAD/${file}`;
-            const response = await fetch(url);
-            if (response.ok) {
-              await downloadResponse(response, path5.join(tmpDir, file));
-            } else {
-              throw Error(`No ${file} found for ${repo}`);
+          assetsToDownload.map(
+            async (file) => {
+              const url = `${baseUrl}/${file}`;
+              const response = await fetch(url);
+              if (response.ok) {
+                await downloadResponse(response, path5.join(tmpDir, file));
+              } else {
+                throw Error(`No ${file} found for ${repo}`);
+              }
             }
-          })
+          )
         );
-        return tmpDir;
       });
     }
     return themeDir;
@@ -1114,13 +1231,13 @@ var ObsidianLauncher = class {
    * @param name name of the theme
    * @returns path to the downloaded theme
    */
-  async downloadCommunityTheme(name) {
+  async downloadCommunityTheme(name, version = "latest") {
     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);
+    return await this.downloadGitHubTheme(themeInfo.repo, version);
   }
   /**
    * Downloads a list of themes to the cache and returns a list of {@link DownloadedThemeEntry} with the downloaded
@@ -1147,10 +1264,10 @@ var ObsidianLauncher = class {
           themePath = path5.resolve(theme.path);
           originalType = "local";
         } else if ("repo" in theme) {
-          themePath = await this.downloadGitHubTheme(theme.repo);
+          themePath = await this.downloadGitHubTheme(theme.repo, theme.version);
           originalType = "github";
         } else if ("name" in theme) {
-          themePath = await this.downloadCommunityTheme(theme.name);
+          themePath = await this.downloadCommunityTheme(theme.name, theme.version);
           originalType = "community";
         } else {
           throw Error("You must specify one of theme path, repo, or name");
@@ -1181,58 +1298,6 @@ var ObsidianLauncher = class {
     );
   }
   /**
-   * Installs plugins into an Obsidian vault
-   * @param vault Path to the vault to install the plugins in
-   * @param plugins List plugins to install
-   */
-  async installPlugins(vault, plugins) {
-    const downloadedPlugins = await this.downloadPlugins(plugins);
-    const obsidianDir = path5.join(vault, ".obsidian");
-    await fsAsync4.mkdir(obsidianDir, { recursive: true });
-    const enabledPluginsPath = path5.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 = path5.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 = path5.join(obsidianDir, "plugins", pluginId);
-      await fsAsync4.mkdir(pluginDest, { recursive: true });
-      const files = {
-        "manifest.json": [true, true],
-        "main.js": [true, true],
-        "styles.css": [false, true],
-        "data.json": [false, false]
-      };
-      for (const [file, [required, deleteIfMissing]] of Object.entries(files)) {
-        if (await fileExists(path5.join(pluginPath, file))) {
-          await linkOrCp(path5.join(pluginPath, file), path5.join(pluginDest, file));
-        } else if (required) {
-          throw Error(`${pluginPath}/${file} missing.`);
-        } else if (deleteIfMissing) {
-          await fsAsync4.rm(path5.join(pluginDest, file), { force: true });
-        }
-      }
-      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(path5.join(pluginDest, ".hotreload"), "");
-      }
-    }
-    if (!_4.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 themes in
    * @param themes List of themes to install
@@ -1403,71 +1468,31 @@ var ObsidianLauncher = class {
    */
   async updateVersionList(original, opts = {}) {
     const { maxInstances = 1 } = opts;
-    const repo = "obsidianmd/obsidian-releases";
-    const originalVersions = _4.keyBy(original?.versions ?? [], (v) => v.version);
-    const versions = _4.cloneDeep(originalVersions);
-    let commitHistory = await fetchGitHubAPIPaginated(`repos/${repo}/commits`, {
-      path: "desktop-releases.json",
-      since: original?.metadata?.commitDate
-    });
-    commitHistory.reverse();
-    if (original?.metadata?.commitSha) {
-      commitHistory = _4.takeRightWhile(commitHistory, (c) => c.sha != original.metadata.commitSha);
-    }
-    const fileHistory = await pool(
-      maxInstances,
-      commitHistory,
-      (commit) => fetch(`https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
+    const [destkopReleases, commitInfo] = await fetchObsidianDesktopReleases(
+      original?.metadata.commitDate,
+      original?.metadata.commitSha
     );
-    for (const fileVersion of fileHistory) {
-      const { current, beta } = parseObsidianDesktopRelease(fileVersion);
-      if (beta) {
-        versions[beta.version] = _4.merge(versions[beta.version] ?? {}, beta);
-      }
-      versions[current.version] = _4.merge(versions[current.version] ?? {}, current);
-    }
-    const githubReleases = (await fetchGitHubAPIPaginated(`repos/${repo}/releases`)).reverse();
-    for (const release of githubReleases) {
-      if (semver2.valid(release.name)) {
-        const parsed = parseObsidianGithubRelease(release);
-        versions[parsed.version] = _4.merge(versions[parsed.version] ?? {}, parsed);
-      }
-    }
-    const installerKeys = ["appImage", "appImageArm", "tar", "tarArm", "dmg", "exe"];
-    const newInstallers = Object.values(versions).flatMap((v) => installerKeys.map((k) => [v, k]));
+    const gitHubReleases = await fetchObsidianGitHubReleases();
+    let newVersions = updateObsidianVersionList({
+      original: original?.versions,
+      destkopReleases,
+      gitHubReleases
+    });
+    const newInstallers = newVersions.flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => v.downloads?.[key] && !v.installers?.[key]?.chrome);
     const installerInfos = await pool(maxInstances, newInstallers, async ([v, key]) => {
-      let installerInfo;
-      const hasAsset = !!v.downloads?.[key];
-      const alreadyExtracted = !!v.installers?.[key]?.chrome;
-      const changed = v.installers?.[key]?.digest != originalVersions[v.version]?.installers[key]?.digest;
-      if (hasAsset && (!alreadyExtracted || changed)) {
-        installerInfo = await getInstallerInfo(key, v.downloads[key]);
-      }
-      return { version: v.version, installerInfo: { [key]: installerInfo } };
+      const installerInfo = await extractInstallerInfo(key, v.downloads[key]);
+      return { version: v.version, key, installerInfo };
     });
-    for (const installerInfo of installerInfos) {
-      versions[installerInfo.version] = _4.merge(versions[installerInfo.version] ?? {}, installerInfo);
-    }
-    let minInstallerVersion = void 0;
-    let maxInstallerVersion = void 0;
-    for (const version of Object.keys(versions).sort(semver2.compare)) {
-      if (!minInstallerVersion && versions[version].downloads.appImage) {
-        minInstallerVersion = version;
-      }
-      if (versions[version].downloads.appImage) {
-        maxInstallerVersion = version;
-      }
-      versions[version] = _4.merge({ minInstallerVersion, maxInstallerVersion }, versions[version]);
-    }
+    newVersions = updateObsidianVersionList({ original: newVersions, installerInfos });
     const result = {
       metadata: {
         schemaVersion: obsidianVersionsSchemaVersion,
-        commitDate: commitHistory.at(-1)?.commit.committer.date ?? original?.metadata.commitDate,
-        commitSha: commitHistory.at(-1)?.sha ?? original?.metadata.commitSha,
+        commitDate: commitInfo.commitDate,
+        commitSha: commitInfo.commitSha,
         timestamp: original?.metadata.timestamp ?? ""
         // set down below
       },
-      versions: Object.values(versions).map(normalizeObsidianVersionInfo).sort((a, b) => semver2.compare(a.version, b.version))
+      versions: newVersions
     };
     const dayMs = 24 * 60 * 60 * 1e3;
     const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(original?.metadata.timestamp ?? 0).getTime();
@@ -1516,4 +1541,4 @@ export {
   watchFiles,
   ObsidianLauncher
 };
-//# sourceMappingURL=chunk-EVX5ML6K.js.map
+//# sourceMappingURL=chunk-OUPK2DAJ.js.map