obsidian-launcher 2.2.1 → 2.3.0

package/dist/{chunk-KNNPLZ3O.cjs → chunk-KA32F3Y5.cjs}

@@ -22,7 +22,7 @@ async function fileExists(path6) {
     await _promises2.default.stat(path6);
     return true;
   } catch (e) {
-    if (_optionalChain([e, 'optionalAccess', _5 => _5.code]) == "ENOENT") {
+    if (_optionalChain([e, 'optionalAccess', _6 => _6.code]) == "ENOENT") {
       return false;
     }
     throw e;
@@ -53,14 +53,14 @@ async function atomicCreate(dest, func, opts = {}) {
       throw new Error(`Returned path ${result} not under scratch`);
     }
     if (replace) {
-      if (await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => null)), 'optionalAccess', async _6 => _6.isDirectory, 'call', async _7 => _7()])) {
+      if (await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => null)), 'optionalAccess', async _7 => _7.isDirectory, 'call', async _8 => _8()])) {
         await _promises2.default.rename(dest, `${scratch}.old`);
       }
       await _promises2.default.rename(result, dest);
     } else {
       if (!await fileExists(dest)) {
         await _promises2.default.rename(result, dest).catch((e) => {
-          if (_optionalChain([e, 'optionalAccess', _8 => _8.code]) != "ENOTEMPTY") throw e;
+          if (_optionalChain([e, 'optionalAccess', _9 => _9.code]) != "ENOTEMPTY") throw e;
         });
       }
     }
@@ -81,6 +81,10 @@ async function linkOrCp(src, dest) {
     await _promises2.default.copyFile(src, dest);
   }
 }
+function pathIsUnder(parent, child) {
+  const rel = _path2.default.relative(_path2.default.resolve(parent), _path2.default.resolve(child));
+  return rel != "" && rel.split(_path2.default.sep)[0] != ".." && !_path2.default.isAbsolute(rel);
+}
 async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -180,6 +184,7 @@ var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
 var _extractzip = require('extract-zip'); var _extractzip2 = _interopRequireDefault(_extractzip);
 var _get = require('@electron/get');
 var _child_process = require('child_process'); var _child_process2 = _interopRequireDefault(_child_process);
+
 var _semver = require('semver'); var _semver2 = _interopRequireDefault(_semver);
 var _url = require('url');
 
@@ -245,7 +250,7 @@ async function fetchGitHubAPIPaginated(url, params = {}) {
   while (next) {
     const response = await fetchGitHubAPI(next);
     results.push(...await response.json());
-    next = _optionalChain([parseLinkHeader, 'call', _9 => _9(_nullishCoalesce(response.headers.get("link"), () => ( ""))), 'access', _10 => _10.next, 'optionalAccess', _11 => _11.url]);
+    next = _optionalChain([parseLinkHeader, 'call', _10 => _10(_nullishCoalesce(response.headers.get("link"), () => ( ""))), 'access', _11 => _11.next, 'optionalAccess', _12 => _12.url]);
   }
   return results;
 }
@@ -270,12 +275,12 @@ async function obsidianApiLogin(opts) {
     }
   }
   function parseSignin(r) {
-    return { token: r.token ? "token" : void 0, error: _optionalChain([r, 'access', _12 => _12.error, 'optionalAccess', _13 => _13.toString, 'call', _14 => _14()]), license: r.license };
+    return { token: r.token ? "token" : void 0, error: _optionalChain([r, 'access', _13 => _13.error, 'optionalAccess', _14 => _14.toString, 'call', _15 => _15()]), license: r.license };
   }
   let needsMfa = false;
   let retries = 0;
   let signin = void 0;
-  while (!_optionalChain([signin, 'optionalAccess', _15 => _15.token]) && retries < 3) {
+  while (!_optionalChain([signin, 'optionalAccess', _16 => _16.token]) && retries < 3) {
     if (retries > 0 || _process.env.CI) {
       await sleep(2 * Math.random() + retries * retries * 3);
     }
@@ -293,15 +298,15 @@ async function obsidianApiLogin(opts) {
       body: JSON.stringify({ email, password, mfa })
     }).then((r) => r.json());
     signin = parseSignin(response);
-    const error = _optionalChain([signin, 'access', _16 => _16.error, 'optionalAccess', _17 => _17.toLowerCase, 'call', _18 => _18()]);
-    if (_optionalChain([error, 'optionalAccess', _19 => _19.includes, 'call', _20 => _20("2fa")]) && !needsMfa) {
+    const error = _optionalChain([signin, 'access', _17 => _17.error, 'optionalAccess', _18 => _18.toLowerCase, 'call', _19 => _19()]);
+    if (_optionalChain([error, 'optionalAccess', _20 => _20.includes, 'call', _21 => _21("2fa")]) && !needsMfa) {
       needsMfa = true;
       if (!interactive) {
         throw Error(
           "Can't login with 2FA in a non-interactive session. To download Obsidian beta versions disable 2FA on your account" + (_process.env.CI ? "." : ` or ${predownloadMessage}`)
         );
       }
-    } else if (["please wait", "try again"].some((m) => _optionalChain([error, 'optionalAccess', _21 => _21.includes, 'call', _22 => _22(m)]))) {
+    } else if (["please wait", "try again"].some((m) => _optionalChain([error, 'optionalAccess', _22 => _22.includes, 'call', _23 => _23(m)]))) {
       consola.warn(`Obsidian login failed: ${signin.error}`);
       consola.warn("Retrying obsidian login...");
       retries++;
@@ -309,9 +314,9 @@ async function obsidianApiLogin(opts) {
       throw Error(`Obsidian login failed: ${_nullishCoalesce(signin.error, () => ( "unknown error"))}`);
     }
   }
-  if (!_optionalChain([signin, 'optionalAccess', _23 => _23.token])) {
-    throw Error(`Obsidian login failed: ${_nullishCoalesce(_optionalChain([signin, 'optionalAccess', _24 => _24.error]), () => ( "unknown error"))}`);
-  } else if (!_optionalChain([signin, 'optionalAccess', _25 => _25.license])) {
+  if (!_optionalChain([signin, 'optionalAccess', _24 => _24.token])) {
+    throw Error(`Obsidian login failed: ${_nullishCoalesce(_optionalChain([signin, 'optionalAccess', _25 => _25.error]), () => ( "unknown error"))}`);
+  } else if (!_optionalChain([signin, 'optionalAccess', _26 => _26.license])) {
     throw Error("Obsidian Insiders account is required to download Obsidian beta versions");
   }
   if (savePath && promptedCredentials) {
@@ -439,6 +444,7 @@ var ChromeLocalStorage = class {
 
 
 
+
 var _util = require('util');
 
 
@@ -449,7 +455,7 @@ var _zlib = require('zlib'); var _zlib2 = _interopRequireDefault(_zlib);
 var _chromeremoteinterface = require('chrome-remote-interface'); var _chromeremoteinterface2 = _interopRequireDefault(_chromeremoteinterface);
 var execFile = _util.promisify.call(void 0, _child_process2.default.execFile);
 function normalizeGitHubRepo(repo) {
-  return _nullishCoalesce(_optionalChain([repo, 'access', _26 => _26.match, 'call', _27 => _27(/^(https?:\/\/)?(github.com\/)?(.*?)\/?$/), 'optionalAccess', _28 => _28[3]]), () => ( repo));
+  return _nullishCoalesce(_optionalChain([repo, 'access', _27 => _27.match, 'call', _28 => _28(/^(https?:\/\/)?(github.com\/)?(.*?)\/?$/), 'optionalAccess', _29 => _29[3]]), () => ( repo));
 }
 async function extractGz(archive, dest) {
   await _promises3.pipeline.call(void 0, _fs2.default.createReadStream(archive), _zlib2.default.createGunzip(), _fs2.default.createWriteStream(dest));
@@ -527,17 +533,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(
+    _nullishCoalesce(params.appVersion, () => ( "latest")),
+    _nullishCoalesce(params.installerVersion, () => ( "latest"))
+  );
   const cleanup = [];
   const doCleanup = async () => {
     for (const func of [...cleanup].reverse()) {
       await func();
     }
   };
-  const vault = await makeTmpDir("obsidian-vault-");
-  cleanup.push(() => _promises2.default.rm(vault, { recursive: true, force: true }));
-  const pluginDir = _path2.default.join(vault, ".obsidian", "plugins", "obsidian-launcher");
+  const pluginDir = _path2.default.join(params.vault, ".obsidian", "plugins", "obsidian-launcher");
   await _promises2.default.mkdir(pluginDir, { recursive: true });
   await _promises2.default.writeFile(_path2.default.join(pluginDir, "manifest.json"), JSON.stringify({
     id: "obsidian-launcher",
@@ -555,19 +562,23 @@ async function getCdpSession(launcher, appVersion, installerVersion) {
         }
         module.exports = ObsidianLauncherPlugin;
     `);
-  await _promises2.default.writeFile(_path2.default.join(vault, ".obsidian", "community-plugins.json"), JSON.stringify([
-    "obsidian-launcher"
-  ]));
+  const communityPluginsPath = _path2.default.join(params.vault, ".obsidian", "community-plugins.json");
+  let communityPlugins = ["obsidian-launcher"];
+  if (await fileExists(communityPluginsPath)) {
+    communityPlugins = [...JSON.parse(await _promises2.default.readFile(communityPluginsPath, "utf-8")), ...communityPlugins];
+  }
+  await _promises2.default.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", ..._nullishCoalesce(params.args, () => ( []))]
     });
-    cleanup.push(() => _promises2.default.rm(configDir, { recursive: true, force: true }));
+    if (params.copy) {
+      cleanup.push(() => _promises2.default.rm(launchResult.vault, { recursive: true, force: true }));
+    }
+    const { proc } = launchResult;
+    cleanup.push(() => _promises2.default.rm(launchResult.configDir, { recursive: true, force: true }));
     const procExit = new Promise((resolve) => proc.on("close", (code) => resolve(_nullishCoalesce(code, () => ( -1)))));
     cleanup.push(async () => {
       proc.kill("SIGTERM");
@@ -581,7 +592,7 @@ async function getCdpSession(launcher, appVersion, installerVersion) {
     const portPromise = new Promise((resolve, reject) => {
       void procExit.then(() => reject(Error("Processed ended without opening a port")));
       proc.stderr.on("data", (data) => {
-        const port2 = _optionalChain([data, 'access', _29 => _29.toString, 'call', _30 => _30(), 'access', _31 => _31.match, 'call', _32 => _32(/ws:\/\/[\w.]+?:(\d+)/), 'optionalAccess', _33 => _33[1]]);
+        const port2 = _optionalChain([data, 'access', _30 => _30.toString, 'call', _31 => _31(), 'access', _32 => _32.match, 'call', _33 => _33(/ws:\/\/[\w.]+?:(\d+)/), 'optionalAccess', _34 => _34[1]]);
         if (port2) {
           resolve(Number(port2));
         }
@@ -599,9 +610,10 @@ async function getCdpSession(launcher, appVersion, installerVersion) {
       { timeout: 5e3 }
     );
     return {
+      ...launchResult,
       client,
       cleanup: doCleanup,
-      proc
+      vault: launchResult.vault
     };
   } catch (e) {
     await doCleanup();
@@ -618,6 +630,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 _lodash2.default.sortBy(processes, (i) => i.startTime).map((i) => _lodash2.default.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 _promises2.default.readFile(_path2.default.join(configDir, "obsidian.json"), "utf-8"));
+      for (const [vaultId, vaultInfo] of Object.entries(obsidianJson.vaults)) {
+        const vaultPath = await _promises2.default.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 || _path2.default.basename(i.vaultPath).toUpperCase() == vault.toUpperCase());
+    if (!match) {
+      const systemTmpDir = await _promises2.default.realpath(_os2.default.tmpdir());
+      match = obsidianInstances.find((i) => pathIsUnder(systemTmpDir, i.vaultPath) && _optionalChain([_path2.default, 'access', _35 => _35.basename, 'call', _36 => _36(i.vaultPath), 'access', _37 => _37.toUpperCase, 'call', _38 => _38(), 'access', _39 => _39.match, 'call', _40 => _40(/(.*)-.{6}/), 'optionalAccess', _41 => _41[1]]) == vault.toUpperCase());
+    }
+    if (!match) {
+      throw Error(`No running Obsidian instance for ${vault}`);
+    }
+    newArgs = args.slice(1);
+  }
+  if (!match) {
+    const cwd = await _promises2.default.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`, {
@@ -633,8 +724,8 @@ async function fetchObsidianDesktopReleases(sinceDate, sinceSha) {
     commitHistory,
     (commit) => fetch(`https://raw.githubusercontent.com/${repo}/${commit.sha}/desktop-releases.json`).then((r) => r.json())
   );
-  const commitDate = _nullishCoalesce(_optionalChain([commitHistory, 'access', _34 => _34.at, 'call', _35 => _35(-1), 'optionalAccess', _36 => _36.commit, 'access', _37 => _37.committer, 'access', _38 => _38.date]), () => ( sinceDate));
-  const commitSha = _nullishCoalesce(_optionalChain([commitHistory, 'access', _39 => _39.at, 'call', _40 => _40(-1), 'optionalAccess', _41 => _41.sha]), () => ( sinceSha));
+  const commitDate = _nullishCoalesce(_optionalChain([commitHistory, 'access', _42 => _42.at, 'call', _43 => _43(-1), 'optionalAccess', _44 => _44.commit, 'access', _45 => _45.committer, 'access', _46 => _46.date]), () => ( sinceDate));
+  const commitSha = _nullishCoalesce(_optionalChain([commitHistory, 'access', _47 => _47.at, 'call', _48 => _48(-1), 'optionalAccess', _49 => _49.sha]), () => ( sinceSha));
   return [fileHistory, { commitDate, commitSha }];
 }
 async function fetchObsidianGitHubReleases() {
@@ -685,14 +776,14 @@ function parseObsidianGithubRelease(gitHubRelease) {
     version,
     gitHubRelease: gitHubRelease.html_url,
     downloads: {
-      asar: _optionalChain([asar, 'optionalAccess', _42 => _42.url]),
-      appImage: _optionalChain([appImage, 'optionalAccess', _43 => _43.url]),
-      appImageArm: _optionalChain([appImageArm, 'optionalAccess', _44 => _44.url]),
-      tar: _optionalChain([tar, 'optionalAccess', _45 => _45.url]),
-      tarArm: _optionalChain([tarArm, 'optionalAccess', _46 => _46.url]),
-      dmg: _optionalChain([dmg, 'optionalAccess', _47 => _47.url]),
-      exe: _optionalChain([exe, 'optionalAccess', _48 => _48.url]),
-      apk: _optionalChain([apk, 'optionalAccess', _49 => _49.url])
+      asar: _optionalChain([asar, 'optionalAccess', _50 => _50.url]),
+      appImage: _optionalChain([appImage, 'optionalAccess', _51 => _51.url]),
+      appImageArm: _optionalChain([appImageArm, 'optionalAccess', _52 => _52.url]),
+      tar: _optionalChain([tar, 'optionalAccess', _53 => _53.url]),
+      tarArm: _optionalChain([tarArm, 'optionalAccess', _54 => _54.url]),
+      dmg: _optionalChain([dmg, 'optionalAccess', _55 => _55.url]),
+      exe: _optionalChain([exe, 'optionalAccess', _56 => _56.url]),
+      apk: _optionalChain([apk, 'optionalAccess', _57 => _57.url])
     },
     installers: {
       appImage: appImage ? { digest: appImage.digest } : void 0,
@@ -773,8 +864,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) {
@@ -816,6 +908,7 @@ async function checkCompatibility(launcher, appVersion, installerVersion) {
     }
   } finally {
     await cleanup();
+    await _promises2.default.rm(vault, { recursive: true, force: true });
   }
   consola.log(`app ${appVersion} and installer ${installerVersion} are ${!result ? "in" : ""}compatible`);
   return result;
@@ -888,8 +981,8 @@ async function getCompatibilityInfos(versions, { _checkCompatibility = checkComp
 }
 function normalizeObsidianVersionInfo(versionInfo) {
   versionInfo = _lodash2.default.cloneDeep(versionInfo);
-  versionInfo.electronVersion = _optionalChain([versionInfo, 'access', _50 => _50.installers, 'optionalAccess', _51 => _51.appImage, 'optionalAccess', _52 => _52.electron]);
-  versionInfo.chromeVersion = _optionalChain([versionInfo, 'access', _53 => _53.installers, 'optionalAccess', _54 => _54.appImage, 'optionalAccess', _55 => _55.chrome]);
+  versionInfo.electronVersion = _optionalChain([versionInfo, 'access', _58 => _58.installers, 'optionalAccess', _59 => _59.appImage, 'optionalAccess', _60 => _60.electron]);
+  versionInfo.chromeVersion = _optionalChain([versionInfo, 'access', _61 => _61.installers, 'optionalAccess', _62 => _62.appImage, 'optionalAccess', _63 => _63.chrome]);
   versionInfo.downloads = _nullishCoalesce(versionInfo.downloads, () => ( {}));
   versionInfo.installers = _nullishCoalesce(versionInfo.installers, () => ( {}));
   const canonicalForm = {
@@ -928,11 +1021,11 @@ async function updateObsidianVersionList(original, {
   _extractInstallerInfo = extractInstallerInfo,
   _checkCompatibility = checkCompatibility
 } = {}) {
-  const oldVersions = _lodash2.default.keyBy(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _56 => _56.versions]), () => ( [])), (v) => v.version);
+  const oldVersions = _lodash2.default.keyBy(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _64 => _64.versions]), () => ( [])), (v) => v.version);
   let newVersions = _lodash2.default.cloneDeep(oldVersions);
   const [destkopReleases, commitInfo] = await _fetchObsidianDesktopReleases(
-    _optionalChain([original, 'optionalAccess', _57 => _57.metadata, 'access', _58 => _58.commitDate]),
-    _optionalChain([original, 'optionalAccess', _59 => _59.metadata, 'access', _60 => _60.commitSha])
+    _optionalChain([original, 'optionalAccess', _65 => _65.metadata, 'access', _66 => _66.commitDate]),
+    _optionalChain([original, 'optionalAccess', _67 => _67.metadata, 'access', _68 => _68.commitSha])
   );
   for (const destkopRelease of destkopReleases) {
     const { current, beta } = parseObsidianDesktopRelease(destkopRelease);
@@ -947,8 +1040,8 @@ async function updateObsidianVersionList(original, {
       const parsed = parseObsidianGithubRelease(githubRelease);
       const newVersion = _lodash2.default.merge(_nullishCoalesce(newVersions[parsed.version], () => ( {})), parsed);
       for (const installerKey of INSTALLER_KEYS) {
-        const oldDigest = _optionalChain([oldVersions, 'access', _61 => _61[parsed.version], 'optionalAccess', _62 => _62.installers, 'access', _63 => _63[installerKey], 'optionalAccess', _64 => _64.digest]);
-        const newDigest = _optionalChain([newVersion, 'access', _65 => _65.installers, 'optionalAccess', _66 => _66[installerKey], 'optionalAccess', _67 => _67.digest]);
+        const oldDigest = _optionalChain([oldVersions, 'access', _69 => _69[parsed.version], 'optionalAccess', _70 => _70.installers, 'access', _71 => _71[installerKey], 'optionalAccess', _72 => _72.digest]);
+        const newDigest = _optionalChain([newVersion, 'access', _73 => _73.installers, 'optionalAccess', _74 => _74[installerKey], 'optionalAccess', _75 => _75.digest]);
         if (oldDigest && oldDigest != newDigest) {
           newVersion.installers[installerKey] = { digest: newDigest };
         }
@@ -957,7 +1050,7 @@ async function updateObsidianVersionList(original, {
     }
   }
   newVersions = _lodash2.default.omitBy(newVersions, (v) => BROKEN_VERSIONS.includes(v.version));
-  const newInstallers = Object.values(newVersions).flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => _optionalChain([v, 'access', _68 => _68.downloads, 'optionalAccess', _69 => _69[key]]) && !_optionalChain([v, 'access', _70 => _70.installers, 'optionalAccess', _71 => _71[key], 'optionalAccess', _72 => _72.chrome]));
+  const newInstallers = Object.values(newVersions).flatMap((v) => INSTALLER_KEYS.map((k) => [v, k])).filter(([v, key]) => _optionalChain([v, 'access', _76 => _76.downloads, 'optionalAccess', _77 => _77[key]]) && !_optionalChain([v, 'access', _78 => _78.installers, 'optionalAccess', _79 => _79[key], 'optionalAccess', _80 => _80.chrome]));
   const installerInfos = await pool(maxInstances, newInstallers, async ([v, key]) => {
     const installerInfo = await _extractInstallerInfo(v.version, key, v.downloads[key]);
     return { version: v.version, installers: { [key]: installerInfo } };
@@ -977,13 +1070,13 @@ async function updateObsidianVersionList(original, {
       schemaVersion: obsidianVersionsSchemaVersion,
       commitDate: commitInfo.commitDate,
       commitSha: commitInfo.commitSha,
-      timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _73 => _73.metadata, 'access', _74 => _74.timestamp]), () => ( ""))
+      timestamp: _nullishCoalesce(_optionalChain([original, 'optionalAccess', _81 => _81.metadata, 'access', _82 => _82.timestamp]), () => ( ""))
       // set down below
     },
     versions: Object.values(newVersions).map(normalizeObsidianVersionInfo).sort((a, b) => _semver2.default.compare(a.version, b.version))
   };
   const dayMs = 24 * 60 * 60 * 1e3;
-  const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _75 => _75.metadata, 'access', _76 => _76.timestamp]), () => ( 0))).getTime();
+  const timeSinceLastUpdate = (/* @__PURE__ */ new Date()).getTime() - new Date(_nullishCoalesce(_optionalChain([original, 'optionalAccess', _83 => _83.metadata, 'access', _84 => _84.timestamp]), () => ( 0))).getTime();
   if (!_lodash2.default.isEqual(original, result) || timeSinceLastUpdate > 29 * dayMs) {
     result.metadata.timestamp = (/* @__PURE__ */ new Date()).toISOString();
   }
@@ -1000,7 +1093,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.
@@ -1009,7 +1102,9 @@ var ObsidianLauncher = class {
    */
   constructor(opts = {}) {
     this.interactive = false;
-    this.cacheDir = _path2.default.resolve(_nullishCoalesce(_nullishCoalesce(opts.cacheDir, () => ( process.env.OBSIDIAN_CACHE)), () => ( "./.obsidian-cache")));
+    this.cacheDir = _path2.default.resolve(
+      _nullishCoalesce(_nullishCoalesce(opts.cacheDir, () => ( process.env.OBSIDIAN_CACHE)), () => ( _path2.default.join(_os2.default.homedir(), ".obsidian-cache")))
+    );
     const defaultVersionsUrl = "https://raw.githubusercontent.com/jesse-r-s-hines/wdio-obsidian-service/HEAD/obsidian-versions.json";
     this.versionsUrl = _nullishCoalesce(opts.versionsUrl, () => ( defaultVersionsUrl));
     const defaultCommunityPluginsUrl = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/HEAD/community-plugins.json";
@@ -1030,7 +1125,7 @@ var ObsidianLauncher = class {
     if (!(dest in this.metadataCache)) {
       let data;
       let error;
-      const cacheMtime = await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => void 0)), 'optionalAccess', async _77 => _77.mtime]);
+      const cacheMtime = await _asyncOptionalChain([(await _promises2.default.stat(dest).catch(() => void 0)), 'optionalAccess', async _85 => _85.mtime]);
       if (url.startsWith("file:")) {
         data = JSON.parse(await _promises2.default.readFile(_url.fileURLToPath.call(void 0, url), "utf-8"));
       }
@@ -1180,7 +1275,7 @@ var ObsidianLauncher = class {
       appVersion = versions.filter((v) => !v.isBeta).at(-1).version;
     } else if (appVersion == "earliest") {
       const manifest = await this.getRootManifest();
-      if (!_optionalChain([manifest, 'optionalAccess', _78 => _78.minAppVersion])) {
+      if (!_optionalChain([manifest, 'optionalAccess', _86 => _86.minAppVersion])) {
         throw Error('Unable to resolve Obsidian appVersion "earliest", no manifest.json or minAppVersion found.');
       }
       appVersion = manifest.minAppVersion;
@@ -1732,12 +1827,18 @@ var ObsidianLauncher = class {
     };
     const chromePreferences = _lodash2.default.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"
+      } } } },
       _nullishCoalesce(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)) {
@@ -1830,7 +1931,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"] : [],
-      ..._nullishCoalesce(params.args, () => ( []))
+      ..._nullishCoalesce(params.args, () => ( [])),
+      "--tag=obsidian-launcher"
+      // hack so we can identify obsidian-launcher processes when connecting the CLI
     ], {
       ...params.spawnOptions
     });
@@ -1878,6 +1981,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);
+  }
 };
 
 
@@ -1886,4 +2018,4 @@ var ObsidianLauncher = class {
 
 
 exports.consola = consola; exports.watchFiles = watchFiles; exports.minSupportedObsidianVersion = minSupportedObsidianVersion; exports.ObsidianLauncher = ObsidianLauncher;
-//# sourceMappingURL=chunk-KNNPLZ3O.cjs.map
+//# sourceMappingURL=chunk-KA32F3Y5.cjs.map