obsidian-launcher 2.2.1 → 2.3.1

package/README.md

@@ -82,7 +82,7 @@ Options:
 - `-p, --plugin <plugin>`: Plugin(s) to install
 - `-t, --theme <plugin>`: Theme(s) to install
 - `--copy`: Copy the vault first
-- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ".obsidian-cache")
+- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ~/.obsidian-cache)
 
 ### watch
 Downloads Obsidian and opens a vault, then watches for changes to plugins and themes.
@@ -98,7 +98,7 @@ Options:
 - `-p, --plugin <plugin>`: Plugin(s) to install
 - `-t, --theme <plugin>`: Theme to install
 - `--copy`: Copy the vault first
-- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ".obsidian-cache")
+- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ~/.obsidian-cache)
 
 ### install
 Install plugins and themes into an Obsidian vault.
@@ -109,7 +109,7 @@ Arguments:
 Options:
 - `-p, --plugin <plugin>`: Plugin(s) to install
 - `-t, --theme <plugin>`: Theme(s) to install.
-- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ".obsidian-cache")
+- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ~/.obsidian-cache)
 
 ### download
 Download Obsidian to the cache.
@@ -128,5 +128,5 @@ Options:
 - `-i, --installer <version>`: Obsidian installer version (default: "earliest")
 - `--platform <platform>`: Platform of the installer, one of linux, win32, darwin. (default: system platform)
 - `--arch <arch>`: Architecture of the installer, one of arm64, ia32, x64. (default: system arch)
-- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ".obsidian-cache")
+- `-c, --cache <cache>`: Directory to use as the download cache (default: OBSIDIAN_CACHE env var or ~/.obsidian-cache)
 

package/dist/{chunk-LBBOWJGG.js → chunk-4A3EFE5K.js}

@@ -77,6 +77,10 @@ async function linkOrCp(src, dest) {
     await fsAsync.copyFile(src, dest);
   }
 }
+function pathIsUnder(parent, child) {
+  const rel = path.relative(path.resolve(parent), path.resolve(child));
+  return rel != "" && rel.split(path.sep)[0] != ".." && !path.isAbsolute(rel);
+}
 async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -176,6 +180,7 @@ import crypto from "crypto";
 import extractZip from "extract-zip";
 import { downloadArtifact } from "@electron/get";
 import child_process2 from "child_process";
+import os3 from "os";
 import semver2 from "semver";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import _4 from "lodash";
@@ -434,6 +439,7 @@ var ChromeLocalStorage = class {
 // src/launcherUtils.ts
 import fsAsync3 from "fs/promises";
 import fs3 from "fs";
+import os2 from "os";
 import path4 from "path";
 import { promisify } from "util";
 import child_process from "child_process";
@@ -523,17 +529,18 @@ async function extractObsidianDmg(dmg, dest) {
     }
   });
 }
-async function getCdpSession(launcher, appVersion, installerVersion) {
-  [appVersion, installerVersion] = await launcher.resolveVersion(appVersion, installerVersion);
+async function getCdpSession(launcher, params) {
+  const [appVersion, installerVersion] = await launcher.resolveVersion(
+    params.appVersion ?? "latest",
+    params.installerVersion ?? "latest"
+  );
   const cleanup = [];
   const doCleanup = async () => {
     for (const func of [...cleanup].reverse()) {
       await func();
     }
   };
-  const vault = await makeTmpDir("obsidian-vault-");
-  cleanup.push(() => fsAsync3.rm(vault, { recursive: true, force: true }));
-  const pluginDir = path4.join(vault, ".obsidian", "plugins", "obsidian-launcher");
+  const pluginDir = path4.join(params.vault, ".obsidian", "plugins", "obsidian-launcher");
   await fsAsync3.mkdir(pluginDir, { recursive: true });
   await fsAsync3.writeFile(path4.join(pluginDir, "manifest.json"), JSON.stringify({
     id: "obsidian-launcher",
@@ -551,19 +558,23 @@ async function getCdpSession(launcher, appVersion, installerVersion) {
         }
         module.exports = ObsidianLauncherPlugin;
     `);
-  await fsAsync3.writeFile(path4.join(vault, ".obsidian", "community-plugins.json"), JSON.stringify([
-    "obsidian-launcher"
-  ]));
+  const communityPluginsPath = path4.join(params.vault, ".obsidian", "community-plugins.json");
+  let communityPlugins = ["obsidian-launcher"];
+  if (await fileExists(communityPluginsPath)) {
+    communityPlugins = [...JSON.parse(await fsAsync3.readFile(communityPluginsPath, "utf-8")), ...communityPlugins];
+  }
+  await fsAsync3.writeFile(communityPluginsPath, JSON.stringify(communityPlugins));
   try {
-    const { proc, configDir } = await launcher.launch({
-      appVersion,
-      installerVersion,
-      vault,
-      copy: false,
-      args: [`--remote-debugging-port=0`, "--test-type=webdriver"]
+    const launchResult = await launcher.launch({
+      ...params,
       // will choose a random available port
+      args: [`--remote-debugging-port=0`, "--test-type=webdriver", ...params.args ?? []]
     });
-    cleanup.push(() => fsAsync3.rm(configDir, { recursive: true, force: true }));
+    if (params.copy) {
+      cleanup.push(() => fsAsync3.rm(launchResult.vault, { recursive: true, force: true }));
+    }
+    const { proc } = launchResult;
+    cleanup.push(() => fsAsync3.rm(launchResult.configDir, { recursive: true, force: true }));
     const procExit = new Promise((resolve) => proc.on("close", (code) => resolve(code ?? -1)));
     cleanup.push(async () => {
       proc.kill("SIGTERM");
@@ -595,9 +606,10 @@ async function getCdpSession(launcher, appVersion, installerVersion) {
       { timeout: 5e3 }
     );
     return {
+      ...launchResult,
       client,
       cleanup: doCleanup,
-      proc
+      vault: launchResult.vault
     };
   } catch (e) {
     await doCleanup();
@@ -614,6 +626,85 @@ async function cdpEvaluate(client, expression) {
 async function cdpEvaluateUntil(client, expression, opts) {
   return await until(() => cdpEvaluate(client, expression), opts);
 }
+async function getProcesses() {
+  if (process.platform === "win32") {
+    const { stdout } = await execFile("powershell.exe", [
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      "Get-CimInstance Win32_Process | Sort-Object -Property CreationDate | Select-Object ProcessId,CommandLine | ConvertTo-Json"
+    ]);
+    const data = JSON.parse(stdout);
+    const list = Array.isArray(data) ? data : [data];
+    return list.map((p) => ({ pid: p.ProcessId, command: p.CommandLine || "" }));
+  } else {
+    const { stdout } = await execFile("ps", ["-xww", "-o", "lstart=,pid=,command="]);
+    const processes = stdout.split("\n").map((l) => l.trim()).filter((line) => line).map((line) => {
+      const [_5, startTime, pid, command] = line.match(/^(\w+ \w+ \d+ \d\d:\d\d:\d\d \d\d\d\d)\s+(\d+)\s+(.*)$/);
+      return {
+        pid: Number(pid),
+        startTime: new Date(startTime).getTime(),
+        command
+      };
+    });
+    return _3.sortBy(processes, (i) => i.startTime).map((i) => _3.omit(i, "startTime"));
+  }
+}
+async function getObsidianCli(args) {
+  const clean = (s) => {
+    return s.trim().match(/^["']?(.*?)["']?$/)[1];
+  };
+  let processes = await getProcesses();
+  processes = processes.filter((p) => p.command.includes("--tag=obsidian-launcher"));
+  let obsidianInstances = [];
+  for (const proc of processes) {
+    try {
+      const match2 = proc.command.match(/(.*?) --user-data-dir=(.*?obsidian-launcher-config-.+?)( |$)/);
+      const [_5, exe2, configDir] = match2.map(clean);
+      const obsidianJson = JSON.parse(await fsAsync3.readFile(path4.join(configDir, "obsidian.json"), "utf-8"));
+      for (const [vaultId, vaultInfo] of Object.entries(obsidianJson.vaults)) {
+        const vaultPath = await fsAsync3.realpath(vaultInfo.path);
+        obsidianInstances.push({ pid: proc.pid, exe: exe2, configDir, vaultId, vaultPath });
+      }
+    } catch (e) {
+      console.warn(`Failed to connect to obsidian-launcher instance ${proc.pid}: ${e}`);
+    }
+  }
+  obsidianInstances = obsidianInstances.reverse();
+  let match;
+  let newArgs = [...args];
+  if (args.length > 0 && args[0].startsWith("vault=")) {
+    const vault = args[0].slice(6);
+    match = obsidianInstances.find((i) => i.vaultId == vault || path4.basename(i.vaultPath).toUpperCase() == vault.toUpperCase());
+    if (!match) {
+      const systemTmpDir = await fsAsync3.realpath(os2.tmpdir());
+      match = obsidianInstances.find((i) => pathIsUnder(systemTmpDir, i.vaultPath) && path4.basename(i.vaultPath).toUpperCase().match(/(.*)-.{6}/)?.[1] == vault.toUpperCase());
+    }
+    if (!match) {
+      throw Error(`No running Obsidian instance for ${vault}`);
+    }
+    newArgs = args.slice(1);
+  }
+  if (!match) {
+    const cwd = await fsAsync3.realpath(process.cwd()).catch(() => process.cwd());
+    match = obsidianInstances.find((i) => cwd == i.vaultPath || pathIsUnder(i.vaultPath, cwd));
+  }
+  if (!match) {
+    match = obsidianInstances.at(0);
+  }
+  if (!match) {
+    throw Error(`No running Obsidian instance`);
+  }
+  const exe = match.exe.replace(/.exe$/, ".com");
+  newArgs = [
+    `vault=${match.vaultId}`,
+    ...newArgs,
+    `--user-data-dir=${match.configDir}`,
+    ...process.platform == "linux" ? ["--no-sandbox"] : []
+  ];
+  return [exe, newArgs];
+}
 async function fetchObsidianDesktopReleases(sinceDate, sinceSha) {
   const repo = "obsidianmd/obsidian-releases";
   let commitHistory = await fetchGitHubAPIPaginated(`repos/${repo}/commits`, {
@@ -769,8 +860,9 @@ async function checkCompatibility(launcher, appVersion, installerVersion) {
   consola.log(`Checking if app ${appVersion} and installer ${installerVersion} are compatible...`);
   await launcher.downloadApp(appVersion);
   await launcher.downloadInstaller(installerVersion);
+  const vault = await makeTmpDir("obsidian-launcher-");
   const cdpResult = await maybe(retry(
-    () => getCdpSession(launcher, appVersion, installerVersion),
+    () => getCdpSession(launcher, { appVersion, installerVersion, vault }),
     { retries: 3, backoff: 4e3 }
   ));
   if (!cdpResult.success) {
@@ -812,6 +904,7 @@ async function checkCompatibility(launcher, appVersion, installerVersion) {
     }
   } finally {
     await cleanup();
+    await fsAsync3.rm(vault, { recursive: true, force: true });
   }
   consola.log(`app ${appVersion} and installer ${installerVersion} are ${!result ? "in" : ""}compatible`);
   return result;
@@ -996,7 +1089,7 @@ var minSupportedObsidianVersion = "0.12.8";
 var ObsidianLauncher = class {
   /**
    * Construct an ObsidianLauncher.
-   * @param opts.cacheDir Path to the cache directory. Defaults to "OBSIDIAN_CACHE" env var or ".obsidian-cache".
+   * @param opts.cacheDir Path to the cache directory. Defaults to "OBSIDIAN_CACHE" env var or ~/.obsidian-cache.
    * @param opts.versionsUrl Custom `obsidian-versions.json` url. Can be a file URL.
    * @param opts.communityPluginsUrl Custom `community-plugins.json` url. Can be a file URL.
    * @param opts.communityThemesUrl Custom `community-css-themes.json` url. Can be a file URL.
@@ -1005,7 +1098,9 @@ var ObsidianLauncher = class {
    */
   constructor(opts = {}) {
     this.interactive = false;
-    this.cacheDir = path5.resolve(opts.cacheDir ?? process.env.OBSIDIAN_CACHE ?? "./.obsidian-cache");
+    this.cacheDir = path5.resolve(
+      opts.cacheDir ?? process.env.OBSIDIAN_CACHE ?? path5.join(os3.homedir(), ".obsidian-cache")
+    );
     const defaultVersionsUrl = "https://raw.githubusercontent.com/jesse-r-s-hines/wdio-obsidian-service/HEAD/obsidian-versions.json";
     this.versionsUrl = opts.versionsUrl ?? defaultVersionsUrl;
     const defaultCommunityPluginsUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
@@ -1728,12 +1823,18 @@ var ObsidianLauncher = class {
     };
     const chromePreferences = _4.merge(
       // disables the "allow pasting" bit in the dev tools console
-      { "electron": { "devtools": { "preferences": { "disable-self-xss-warning": "true" } } } },
+      { "electron": { "devtools": { "preferences": {
+        // chrome switched between using kebab-case and CamelCase sometime between 114.0.5735.289 and 120.0.6099.283
+        "disable-self-xss-warning": "true",
+        "disableSelfXssWarning": "true"
+      } } } },
       params.chromePreferences ?? {}
     );
     const obsidianJson = {
-      updateDisabled: true
+      updateDisabled: true,
       // prevents Obsidian trying to auto-update on boot.
+      cli: true
+      // enable the CLI
     };
     if (params.vault !== void 0) {
       if (!await fileExists(params.vault)) {
@@ -1826,7 +1927,9 @@ var ObsidianLauncher = class {
       `--user-data-dir=${configDir}`,
       // Workaround for SUID issue on linux. See https://github.com/electron/electron/issues/42510
       ...process.platform == "linux" ? ["--no-sandbox"] : [],
-      ...params.args ?? []
+      ...params.args ?? [],
+      "--tag=obsidian-launcher"
+      // hack so we can identify obsidian-launcher processes when connecting the CLI
     ], {
       ...params.spawnOptions
     });
@@ -1874,6 +1977,35 @@ var ObsidianLauncher = class {
       return true;
     }
   }
+  /**
+   * Return the command needed to run the Obsidian CLI.
+   * 
+   * As obsidian-launcher sandboxes the config dir for each Obsidian instance, the Obsidian CLI won't connect to the
+   * launched instances by default. This method takes Obsidian CLI args, and then returns an [executable, args] tuple
+   * that can be used to launch the Obsidian CLI against the sandboxed instances.
+   * 
+   * Like the the regular Obsidian CLI, it will connect to the instance matching the `vault=` argument if present, or
+   * the cwd.
+   * 
+   * Just pass the result to child_process.spawn or child_process.execFile to run the command.
+   * 
+   * Example:
+   * ```js
+   * import child_process from "child_process";
+   * import util from "util";
+   * const execFile = util.promisify(child_process.execFile);
+   * const [executable, args] = await launcher.getObsidianCli(["file", "file=Dashboard"]);
+   * const {stdout, stderr} = await execFile(executable, args);
+   * ```
+   * 
+   * The Obsidian CLI only works on Obsidian >=1.12.0 with installer >=1.11.7.
+   * See https://help.obsidian.md/cli
+   * 
+   * @returns [executable, args] tuple
+   */
+  async getObsidianCli(args) {
+    return await getObsidianCli(args);
+  }
 };
 
 export {
@@ -1882,4 +2014,4 @@ export {
   minSupportedObsidianVersion,
   ObsidianLauncher
 };
-//# sourceMappingURL=chunk-LBBOWJGG.js.map
+//# sourceMappingURL=chunk-4A3EFE5K.js.map