obsidian-launcher 2.1.1 → 2.1.2

package/README.md

@@ -7,7 +7,7 @@ The primary use case for this package is to allow [wdio-obsidian-service](../wdi
 ## Example Usage
 You can run the CLI via `npx`, e.g.:
 ```bash
-npx obsidian-launcher watch --version 1.8.10 --copy -p . test/vault
+npx obsidian-launcher watch --version 1.8.10 --copy --plugin . test/vault
 ```
 This will download and launch Obsidian 1.8.10 with a sandboxed configuration directory so you don't need to worry about it interfering with your system Obsidian installation. You can even launch multiple different versions of Obsidian side-by-side. See [below](#cli) for CLI docs.
 
@@ -32,7 +32,7 @@ Obsidian Desktop is distributed in two parts, the "installer" which is the execu
 `appVersion` can be set to one of:
 - a specific version string like "1.7.7"
 - "latest": run the latest non-beta Obsidian version
-- "latest-beta": run the latest beta Obsidian version (or latest is there is no current beta)
+- "latest-beta": run the latest beta Obsidian version (or latest if there is no current beta)
     - To download Obsidian beta versions you'll need to have an Obsidian Insiders account
 - "earliest": run the `minAppVersion` set in your plugin's `manifest.json`
 
@@ -61,7 +61,7 @@ Several commands can take a list of plugins and themes to install. You can speci
 - `id:<community-id>`: For plugins, id of a community plugin, e.g. `id:templater-obsidian`
 - `name:<community-name>`: For themes, name of a community theme, e.g. `name:Minimal`
 
-You can install a specific version of a plugin or theme with `-p id:myplugin=1.2.3`.
+You can install a specific version of a plugin or theme with `-p id:myplugin@1.2.3`.
 
 ### launch
 Download and launch Obsidian, opening the specified vault.

package/dist/{chunk-RDGKX2LW.js → chunk-HMKNUWAY.js}

@@ -7,38 +7,50 @@ import { PromisePool } from "@supercharge/promise-pool";
 import _ from "lodash";
 async function fileExists(path6) {
   try {
-    await fsAsync.access(path6);
+    await fsAsync.stat(path6);
     return true;
-  } catch {
-    return false;
+  } catch (e) {
+    if (e?.code == "ENOENT") {
+      return false;
+    }
+    throw e;
   }
 }
 async function makeTmpDir(prefix) {
   return fsAsync.mkdtemp(path.join(os.tmpdir(), prefix ?? "tmp-"));
 }
 async function atomicCreate(dest, func, opts = {}) {
+  const { replace = true, preserveTmpDir = false } = opts;
   dest = path.resolve(dest);
-  const createdParentDir = await fsAsync.mkdir(path.dirname(dest), { recursive: true });
-  const tmpDir = await fsAsync.mkdtemp(path.join(path.dirname(dest), `.${path.basename(dest)}.tmp.`));
-  let success = false;
+  const parentDir = path.dirname(dest);
+  if (!replace && await fileExists(dest)) return;
+  await fsAsync.mkdir(parentDir, { recursive: true });
+  const scratch = await fsAsync.mkdtemp(path.join(parentDir, `.${path.basename(dest)}.tmp.`));
   try {
-    let result = await func(tmpDir) ?? tmpDir;
-    result = path.resolve(tmpDir, result);
-    if (!result.startsWith(tmpDir)) {
-      throw new Error(`Returned path ${result} not under tmpDir`);
+    let result = await func(scratch) ?? scratch;
+    result = path.resolve(scratch, result);
+    if (!result.startsWith(scratch)) {
+      throw new Error(`Returned path ${result} not under scratch`);
     }
-    if (await fileExists(dest) && (await fsAsync.stat(dest)).isDirectory()) {
-      await fsAsync.rename(dest, tmpDir + ".old");
+    if (replace) {
+      if ((await fsAsync.stat(dest).catch(() => null))?.isDirectory()) {
+        await fsAsync.rename(dest, `${scratch}.old`);
+      }
+      await fsAsync.rename(result, dest);
+    } else {
+      if (!await fileExists(dest)) {
+        await fsAsync.rename(result, dest).catch((e) => {
+          if (e?.code != "ENOTEMPTY") throw e;
+        });
+      }
     }
-    await fsAsync.rename(result, dest);
-    success = true;
-  } finally {
-    if (success) {
-      await fsAsync.rm(tmpDir + ".old", { recursive: true, force: true });
-      await fsAsync.rm(tmpDir, { recursive: true, force: true });
-    } else if (!opts.preserveTmpDir) {
-      await fsAsync.rm(createdParentDir ?? tmpDir, { recursive: true, force: true });
+    await fsAsync.rm(scratch, { recursive: true, force: true });
+    await fsAsync.rm(`${scratch}.old`, { recursive: true, force: true });
+  } catch (e) {
+    if (!preserveTmpDir) {
+      await fsAsync.rm(scratch, { recursive: true, force: true });
     }
+    throw e;
   }
 }
 async function linkOrCp(src, dest) {
@@ -170,32 +182,37 @@ async function fetchGitHubAPIPaginated(url, params = {}) {
 }
 async function obsidianApiLogin(opts) {
   const { interactive = false, savePath } = opts;
-  if (savePath) dotenv.config({ path: [savePath], quiet: true });
-  let email = env.OBSIDIAN_EMAIL;
-  let password = env.OBSIDIAN_PASSWORD;
+  const cached = savePath ? dotenv.parse(await fsAsync2.readFile(savePath).catch(() => "")) : {};
+  let email = env.OBSIDIAN_EMAIL ?? cached.OBSIDIAN_EMAIL;
+  let password = env.OBSIDIAN_PASSWORD ?? cached.OBSIDIAN_PASSWORD;
+  let promptedCredentials = false;
   if (!email || !password) {
     if (interactive) {
       console.log("Obsidian Insiders account is required to download Obsidian beta versions.");
       email = email || readlineSync.question("Obsidian email: ");
       password = password || readlineSync.question("Obsidian password: ", { hideEchoBack: true });
+      promptedCredentials = true;
     } else {
       throw Error(
         "Obsidian Insiders account is required to download Obsidian beta versions. Either set the OBSIDIAN_EMAIL and OBSIDIAN_PASSWORD env vars (.env file is supported) or pre-download the Obsidian beta with `npx obsidian-launcher download app -v <version>`"
       );
     }
   }
+  function parseSignin(r) {
+    return { token: r.token ? "token" : void 0, error: r.error?.toString(), license: r.license };
+  }
   let needsMfa = false;
   let retries = 0;
   let signin = void 0;
   while (!signin?.token && retries < 3) {
     if (retries > 0 || env.CI) {
-      await sleep(2 * Math.random() + retries * retries * 2);
+      await sleep(2 * Math.random() + retries * retries * 3);
     }
     let mfa = "";
     if (needsMfa && interactive) {
       mfa = readlineSync.question("Obsidian 2FA: ");
     }
-    signin = await fetch("https://api.obsidian.md/user/signin", {
+    const response = await fetch("https://api.obsidian.md/user/signin", {
       method: "post",
       headers: {
         "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",
@@ -204,6 +221,7 @@ async function obsidianApiLogin(opts) {
       },
       body: JSON.stringify({ email, password, mfa })
     }).then((r) => r.json());
+    signin = parseSignin(response);
     const error = signin.error?.toLowerCase();
     if (error?.includes("2fa") && !needsMfa) {
       needsMfa = true;
@@ -214,6 +232,7 @@ async function obsidianApiLogin(opts) {
       }
     } else if (["please wait", "try again"].some((m) => error?.includes(m))) {
       console.warn(`Obsidian login failed: ${signin.error}`);
+      console.warn("Retrying obsidian login...");
       retries++;
     } else if (!signin.token) {
       throw Error(`Obsidian login failed: ${signin.error ?? "unknown error"}`);
@@ -224,7 +243,7 @@ async function obsidianApiLogin(opts) {
   } 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)) {
+  if (savePath && promptedCredentials) {
     const save = readlineSync.question("Cache credentails to disk? [y/n]: ");
     if (["y", "yes"].includes(save.toLowerCase())) {
       await fsAsync2.writeFile(
@@ -239,6 +258,9 @@ OBSIDIAN_PASSWORD='${password}'
   return signin.token;
 }
 async function fetchObsidianApi(url, opts) {
+  if (!opts.token) {
+    throw Error("Obsidian credentials required to download Obsidian beta release");
+  }
   url = createURL(url, "https://releases.obsidian.md");
   const response = await fetch(url, {
     headers: {
@@ -370,16 +392,16 @@ ${stderr}`);
   return result;
 }
 async function extractObsidianAppImage(appImage, dest) {
-  await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-o.", path4.relative(tmpDir, appImage)], { cwd: tmpDir });
-    return tmpDir;
+  await atomicCreate(dest, async (scratch) => {
+    await sevenZ(["x", "-o.", path4.relative(scratch, appImage)], { cwd: scratch });
+    return scratch;
   });
 }
 async function extractObsidianTar(tar, dest) {
-  await atomicCreate(dest, async (tmpDir) => {
-    await extractGz(tar, path4.join(tmpDir, "inflated.tar"));
-    await sevenZ(["x", "-o.", "inflated.tar"], { cwd: tmpDir });
-    return (await fsAsync3.readdir(tmpDir)).find((p) => p.match("obsidian-"));
+  await atomicCreate(dest, async (scratch) => {
+    await extractGz(tar, path4.join(scratch, "inflated.tar"));
+    await sevenZ(["x", "-o.", "inflated.tar"], { cwd: scratch });
+    return (await fsAsync3.readdir(scratch)).find((p) => p.match("obsidian-"));
   });
 }
 async function extractObsidianExe(exe, arch, dest) {
@@ -393,17 +415,17 @@ async function extractObsidianExe(exe, arch, dest) {
   } else {
     throw Error(`No Obsidian installer found for ${process.platform} ${process.arch}`);
   }
-  await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-oinstaller", path4.relative(tmpDir, exe), subArchive], { cwd: tmpDir });
-    await sevenZ(["x", "-oobsidian", path4.join("installer", subArchive)], { cwd: tmpDir });
+  await atomicCreate(dest, async (scratch) => {
+    await sevenZ(["x", "-oinstaller", path4.relative(scratch, exe), subArchive], { cwd: scratch });
+    await sevenZ(["x", "-oobsidian", path4.join("installer", subArchive)], { cwd: scratch });
     return "obsidian";
   });
 }
 async function extractObsidianDmg(dmg, dest) {
   dest = path4.resolve(dest);
-  await atomicCreate(dest, async (tmpDir) => {
-    await sevenZ(["x", "-o.", path4.relative(tmpDir, dmg), "*/Obsidian.app", "Obsidian.app"], { cwd: tmpDir });
-    const files = await fsAsync3.readdir(tmpDir);
+  await atomicCreate(dest, async (scratch) => {
+    await sevenZ(["x", "-o.", path4.relative(scratch, dmg), "*/Obsidian.app", "Obsidian.app"], { cwd: scratch });
+    const files = await fsAsync3.readdir(scratch);
     if (files.includes("Obsidian.app")) {
       return "Obsidian.app";
     } else {
@@ -546,7 +568,11 @@ function updateObsidianVersionList(args) {
         minInstallerVersion = version;
       }
     }
-    newVersions[version] = _3.merge({ minInstallerVersion, maxInstallerVersion }, newVersions[version]);
+    newVersions[version] = _3.merge(newVersions[version], {
+      minInstallerVersion: newVersions[version]?.minInstallerVersion ?? minInstallerVersion,
+      maxInstallerVersion
+      // override maxInstallerVersion if it was already set
+    });
   }
   for (const installerInfo of installerInfos) {
     newVersions[installerInfo.version] = _3.merge(newVersions[installerInfo.version] ?? {}, {
@@ -705,10 +731,10 @@ var ObsidianLauncher = class {
           return d;
         }));
         if (response.success) {
-          await atomicCreate(dest, async (tmpDir) => {
-            await fsAsync4.writeFile(path5.join(tmpDir, "download.json"), response.result);
-            return path5.join(tmpDir, "download.json");
-          });
+          await atomicCreate(dest, async (scratch) => {
+            await fsAsync4.writeFile(path5.join(scratch, "download.json"), response.result);
+            return path5.join(scratch, "download.json");
+          }, { replace: true });
           data = JSON.parse(response.result);
         } else {
           error = response.error;
@@ -775,7 +801,7 @@ var ObsidianLauncher = class {
    * Resolves Obsidian app and installer version strings to absolute versions.
    * @param appVersion specific version or one of
    *   - "latest": Get the current latest non-beta Obsidian version
-   *   - "latest-beta": Get the current latest beta Obsidian version (or latest is there is no current beta)
+   *   - "latest-beta": Get the current latest beta Obsidian version (or latest if there is no current beta)
    *   - "earliest": Get the `minAppVersion` set in your `manifest.json`
    * @param installerVersion specific version or one of
    *   - "latest": Get the latest Obsidian installer compatible with `appVersion`
@@ -909,31 +935,29 @@ var ObsidianLauncher = class {
     const versionInfo = await this.getVersionInfo(installerVersion);
     installerVersion = versionInfo.version;
     const installerInfo = await this.getInstallerInfo(installerVersion, { platform, arch });
-    const cacheDir = path5.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
+    const installerDir = path5.join(this.cacheDir, `obsidian-installer/${platform}-${arch}/Obsidian-${installerVersion}`);
     let binaryPath;
     let extractor;
     if (platform == "linux") {
-      binaryPath = path5.join(cacheDir, "obsidian");
+      binaryPath = path5.join(installerDir, "obsidian");
       extractor = (installer, dest) => extractObsidianAppImage(installer, dest);
     } else if (platform == "win32") {
-      binaryPath = path5.join(cacheDir, "Obsidian.exe");
+      binaryPath = path5.join(installerDir, "Obsidian.exe");
       extractor = (installer, dest) => extractObsidianExe(installer, arch, dest);
     } else if (platform == "darwin") {
-      binaryPath = path5.join(cacheDir, "Contents/MacOS/Obsidian");
+      binaryPath = path5.join(installerDir, "Contents/MacOS/Obsidian");
       extractor = (installer, dest) => extractObsidianDmg(installer, dest);
     } else {
       throw Error(`Unsupported platform ${platform}`);
     }
-    if (!await fileExists(binaryPath)) {
+    await atomicCreate(installerDir, async (scratch) => {
       console.log(`Downloading Obsidian installer v${installerVersion}...`);
-      await atomicCreate(cacheDir, async (tmpDir) => {
-        const installer = path5.join(tmpDir, "installer");
-        await downloadResponse(await fetch(installerInfo.url), installer);
-        const extracted = path5.join(tmpDir, "extracted");
-        await extractor(installer, extracted);
-        return extracted;
-      });
-    }
+      const installer = path5.join(scratch, "installer");
+      await downloadResponse(await fetch(installerInfo.url), installer);
+      const extracted = path5.join(scratch, "extracted");
+      await extractor(installer, extracted);
+      return extracted;
+    }, { replace: false });
     return binaryPath;
   }
   /**
@@ -952,29 +976,27 @@ var ObsidianLauncher = class {
       throw Error(`No asar found for Obsidian version ${appVersion}`);
     }
     const appPath = path5.join(this.cacheDir, "obsidian-app", `obsidian-${versionInfo.version}.asar`);
-    if (!await fileExists(appPath)) {
-      console.log(`Downloading Obsidian app v${versionInfo.version} ...`);
-      await atomicCreate(appPath, async (tmpDir) => {
-        const isInsiders = new URL(appUrl).hostname.endsWith(".obsidian.md");
-        let response;
-        if (isInsiders) {
-          if (!this.obsidianApiToken) {
-            this.obsidianApiToken = await obsidianApiLogin({
-              interactive: this.interactive,
-              savePath: path5.join(this.cacheDir, "obsidian-credentials.env")
-            });
-          }
-          response = await fetchObsidianApi(appUrl, { token: this.obsidianApiToken });
-        } else {
-          response = await fetch(appUrl);
-        }
-        const archive = path5.join(tmpDir, "app.asar.gz");
-        const asar = path5.join(tmpDir, "app.asar");
-        await downloadResponse(response, archive);
-        await extractGz(archive, asar);
-        return asar;
+    const isInsiders = new URL(appUrl).hostname.endsWith(".obsidian.md");
+    if (isInsiders && !this.obsidianApiToken && !await fileExists(appPath)) {
+      this.obsidianApiToken = await obsidianApiLogin({
+        interactive: this.interactive,
+        savePath: path5.join(this.cacheDir, "obsidian-credentials.env")
       });
     }
+    await atomicCreate(appPath, async (scratch) => {
+      console.log(`Downloading Obsidian app v${versionInfo.version} ...`);
+      let response;
+      if (isInsiders) {
+        response = await fetchObsidianApi(appUrl, { token: this.obsidianApiToken });
+      } else {
+        response = await fetch(appUrl);
+      }
+      const archive = path5.join(scratch, "app.asar.gz");
+      const asar = path5.join(scratch, "app.asar");
+      await downloadResponse(response, archive);
+      await extractGz(archive, asar);
+      return asar;
+    }, { replace: false });
     return appPath;
   }
   /**
@@ -991,26 +1013,24 @@ var ObsidianLauncher = class {
   async downloadChromedriver(installerVersion, opts = {}) {
     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}`);
+    const chromedriverDir = path5.join(this.cacheDir, `electron-chromedriver/${platform}-${arch}/${installerInfo.electron}`);
     let chromedriverPath;
     if (process.platform == "win32") {
-      chromedriverPath = path5.join(cacheDir, `chromedriver.exe`);
+      chromedriverPath = path5.join(chromedriverDir, `chromedriver.exe`);
     } else {
-      chromedriverPath = path5.join(cacheDir, `chromedriver`);
+      chromedriverPath = path5.join(chromedriverDir, `chromedriver`);
     }
-    if (!await fileExists(chromedriverPath)) {
+    await atomicCreate(chromedriverDir, async (scratch) => {
       console.log(`Downloading chromedriver for electron ${installerInfo.electron} ...`);
-      await atomicCreate(cacheDir, async (tmpDir) => {
-        const chromedriverZipPath = await downloadArtifact({
-          version: installerInfo.electron,
-          artifactName: "chromedriver",
-          cacheRoot: path5.join(tmpDir, "download")
-        });
-        const extracted = path5.join(tmpDir, "extracted");
-        await extractZip(chromedriverZipPath, { dir: extracted });
-        return extracted;
+      const chromedriverZipPath = await downloadArtifact({
+        version: installerInfo.electron,
+        artifactName: "chromedriver",
+        cacheRoot: path5.join(scratch, "download")
       });
-    }
+      const extracted = path5.join(scratch, "extracted");
+      await extractZip(chromedriverZipPath, { dir: extracted });
+      return extracted;
+    }, { replace: false });
     return chromedriverPath;
   }
   /**
@@ -1025,14 +1045,12 @@ var ObsidianLauncher = class {
       );
     }
     const apkPath = path5.join(this.cacheDir, "obsidian-apk", `obsidian-${versionInfo.version}.apk`);
-    if (!await fileExists(apkPath)) {
+    await atomicCreate(apkPath, async (scratch) => {
       console.log(`Downloading Obsidian apk v${versionInfo.version} ...`);
-      await atomicCreate(apkPath, async (tmpDir) => {
-        const dest = path5.join(tmpDir, "obsidian.apk");
-        await downloadResponse(await fetch(apkUrl), dest);
-        return dest;
-      });
-    }
+      const dest = path5.join(scratch, "obsidian.apk");
+      await downloadResponse(await fetch(apkUrl), dest);
+      return dest;
+    }, { replace: false });
     return apkPath;
   }
   /** Gets the latest version of a plugin. */
@@ -1059,23 +1077,21 @@ var ObsidianLauncher = class {
     }
     version = semver2.valid(version);
     const pluginDir = path5.join(this.cacheDir, "obsidian-plugins", repo, version);
-    if (!await fileExists(pluginDir)) {
-      await atomicCreate(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 fetch(url);
-            if (response.ok) {
-              await downloadResponse(response, path5.join(tmpDir, file));
-            } else if (required) {
-              throw Error(`No ${file} found for ${repo} version ${version}`);
-            }
-          })
-        );
-        return tmpDir;
-      });
-    }
+    await atomicCreate(pluginDir, async (scratch) => {
+      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 fetch(url);
+          if (response.ok) {
+            await downloadResponse(response, path5.join(scratch, file));
+          } else if (required) {
+            throw Error(`No ${file} found for ${repo} version ${version}`);
+          }
+        })
+      );
+      return scratch;
+    }, { replace: false });
     return pluginDir;
   }
   /**
@@ -1227,31 +1243,29 @@ var ObsidianLauncher = class {
     }
     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 atomicCreate(themeDir, async (scratch) => {
+      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`);
         }
-        await Promise.all(
-          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}`);
-              }
+        baseUrl = `https://raw.githubusercontent.com/${repo}/HEAD`;
+      }
+      await Promise.all(
+        assetsToDownload.map(
+          async (file) => {
+            const url = `${baseUrl}/${file}`;
+            const response = await fetch(url);
+            if (response.ok) {
+              await downloadResponse(response, path5.join(scratch, file));
+            } else {
+              throw Error(`No ${file} found for ${repo}`);
             }
-          )
-        );
-      });
-    }
+          }
+        )
+      );
+    }, { replace: false });
     return themeDir;
   }
   /**
@@ -1569,4 +1583,4 @@ export {
   watchFiles,
   ObsidianLauncher
 };
-//# sourceMappingURL=chunk-RDGKX2LW.js.map
+//# sourceMappingURL=chunk-HMKNUWAY.js.map