obsidian-integration-testing 1.0.0

package/dist/lib/esm/obsidian-cli.mjs

@@ -0,0 +1,161 @@
+import { existsSync } from "node:fs";
+import process from "node:process";
+import { exec } from "./exec.mjs";
+import { getFunctionExpressionString } from "./function-expression.mjs";
+import { jsonWithFunctions } from "./json-with-functions.mjs";
+import {
+  getVaultId,
+  isCliEnabled,
+  isVaultRegistered
+} from "./obsidian-config.mjs";
+const NO_OUTPUT = "(no output)";
+const UNABLE_TO_FIND_OBSIDIAN = "unable to find Obsidian";
+const AUTO_START_POLL_INTERVAL_MS = 2e3;
+const AUTO_START_TIMEOUT_MS = 3e4;
+async function evalInObsidian(params) {
+  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, vaultPath } = params;
+  const cwd = vaultPath ?? process.cwd();
+  if (vaultPath !== void 0 && !existsSync(vaultPath)) {
+    throw new Error(`Vault path does not exist: ${vaultPath}`);
+  }
+  if (!shouldSkipPreflightChecks) {
+    if (!isVaultRegistered(cwd)) {
+      throw new Error(
+        `Vault is not registered in Obsidian: ${cwd}. Register the vault first with registerVault() or TempVault.register().`
+      );
+    }
+    if (!isCliEnabled()) {
+      throw new Error("Obsidian CLI is disabled. Enable it in Obsidian Settings \u2192 General \u2192 CLI.");
+    }
+    await assertObsidianCliAvailable();
+  }
+  const SLICE_START = 2;
+  const randomSuffix = String(Math.random()).slice(SLICE_START);
+  const contextExpr = contextId ? `((window.__obsidianContexts__ ??= {})["${String(contextId)}"] ??= {})` : "{}";
+  const expression = `
+(async () => {
+  const fn${randomSuffix} = ${getFunctionExpressionString(fn)};
+  const obsidianModule${randomSuffix} = await (async () => {
+    if (!app.workspace.app.workspace.layoutReady) {
+      await new Promise((resolve) => app.workspace.onLayoutReady(resolve));
+    }
+    if (!app.plugins.isEnabled()) {
+      await app.plugins.setEnable(true);
+    }
+    ${getFunctionExpressionString(getObsidianModulePluginFn)}
+    ${getFunctionExpressionString(getObsidianModule)}
+    return await getObsidianModule();
+  })();
+  const args${randomSuffix} = ${jsonWithFunctions(args)};
+  const context${randomSuffix} = ${contextExpr};
+  const fullArgs${randomSuffix} = Object.assign(args${randomSuffix}, { app, obsidianModule: obsidianModule${randomSuffix}, context: context${randomSuffix} });
+  return JSON.stringify(await fn${randomSuffix}(fullArgs${randomSuffix}));
+})()`;
+  const command = ["obsidian", "eval", `code=${expression}`];
+  let resultStr;
+  try {
+    resultStr = await exec(command, { cwd, isQuiet: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {
+      resultStr = await ensureObsidianRunning({ command, cwd });
+    } else {
+      throw error;
+    }
+  }
+  if (resultStr === "" || resultStr === "Vault not found.") {
+    throw new Error(`Unexpected empty response from Obsidian CLI for path: ${cwd}`);
+  }
+  const resultJson = resultStr.startsWith("=> ") ? resultStr.slice("=> ".length) : resultStr;
+  if (resultJson === NO_OUTPUT) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);
+  }
+}
+async function assertObsidianCliAvailable() {
+  const command = process.platform === "win32" ? "where.exe obsidian.com" : "which obsidian";
+  try {
+    await exec(command, { isQuiet: true });
+  } catch {
+    throw new Error("Obsidian CLI is not available. Ensure Obsidian is installed and its CLI is in your PATH.");
+  }
+}
+async function ensureObsidianRunning(params) {
+  console.warn("Obsidian is not running. Starting Obsidian...");
+  const vaultId = getVaultId(params.cwd);
+  const uri = vaultId ? `obsidian://open?vault=${vaultId}` : "obsidian://open";
+  try {
+    await exec(getOpenUriCommand(uri), { isQuiet: true });
+  } catch {
+  }
+  const deadline = Date.now() + AUTO_START_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => {
+      setTimeout(r, AUTO_START_POLL_INTERVAL_MS);
+    });
+    try {
+      return await exec(params.command, { cwd: params.cwd, isQuiet: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes(UNABLE_TO_FIND_OBSIDIAN)) {
+        throw error;
+      }
+    }
+  }
+  throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_MS)}ms.`);
+}
+async function getObsidianModule() {
+  const app = window.app;
+  const obsidianModuleHolder = app;
+  if (obsidianModuleHolder.obsidianModule) {
+    return obsidianModuleHolder.obsidianModule;
+  }
+  const SLICE_START = 2;
+  const randomSuffix = String(Math.random()).slice(SLICE_START);
+  const tempModuleName = `get-obsidian-module-${randomSuffix}`;
+  const dir = `${app.vault.configDir}/plugins/${tempModuleName}`;
+  app.plugins.manifests[tempModuleName] = {
+    author: "",
+    description: "",
+    dir,
+    id: tempModuleName,
+    isDesktopOnly: true,
+    minAppVersion: "",
+    name: tempModuleName,
+    version: ""
+  };
+  await app.vault.adapter.mkdir(dir);
+  await app.vault.adapter.write(`${dir}/main.js`, `(${String(getObsidianModulePluginFn)})();`);
+  await app.plugins.loadPlugin(tempModuleName);
+  await app.plugins.uninstallPlugin(tempModuleName);
+  if (obsidianModuleHolder.obsidianModule) {
+    return obsidianModuleHolder.obsidianModule;
+  }
+  throw new Error("Failed to load obsidian module");
+}
+function getObsidianModulePluginFn() {
+  const app = window.app;
+  const obsidianModuleHolder = app;
+  const pluginRequire = require;
+  const pluginExports = exports;
+  const obsidianModule = pluginRequire("obsidian");
+  obsidianModuleHolder.obsidianModule = obsidianModule;
+  pluginExports.default = obsidianModule.Plugin;
+}
+function getOpenUriCommand(uri) {
+  if (process.platform === "win32") {
+    return `start "" "${uri}"`;
+  }
+  if (process.platform === "darwin") {
+    return `open "${uri}"`;
+  }
+  return `xdg-open "${uri}"`;
+}
+export {
+  evalInObsidian
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-cli.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Evaluates a function inside a running Obsidian instance via the Obsidian CLI.\n */\n\nimport type { App } from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId\n} from './context-id.mjs';\n\nimport { exec } from './exec.mjs';\nimport { getFunctionExpressionString } from './function-expression.mjs';\nimport { jsonWithFunctions } from './json-with-functions.mjs';\nimport {\n  getVaultId,\n  isCliEnabled,\n  isVaultRegistered\n} from './obsidian-config.mjs';\n\nconst NO_OUTPUT = '(no output)';\nconst UNABLE_TO_FIND_OBSIDIAN = 'unable to find Obsidian';\nconst AUTO_START_POLL_INTERVAL_MS = 2000;\nconst AUTO_START_TIMEOUT_MS = 30000;\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the Obsidian CLI and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, vaultPath } = params;\n  const cwd = vaultPath ?? process.cwd();\n\n  // Check 1: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  if (!shouldSkipPreflightChecks) {\n    // Check 2: Vault is registered in Obsidian.\n    if (!isVaultRegistered(cwd)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${cwd}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    // Check 3: CLI is enabled in Obsidian settings.\n    if (!isCliEnabled()) {\n      throw new Error('Obsidian CLI is disabled. Enable it in Obsidian Settings \\u2192 General \\u2192 CLI.');\n    }\n\n    // Check 4: Obsidian CLI binary is in PATH.\n    await assertObsidianCliAvailable();\n  }\n\n  const SLICE_START = 2;\n  const randomSuffix = String(Math.random()).slice(SLICE_START);\n  const contextExpr = contextId\n    ? `((window.__obsidianContexts__ ??= {})[\"${String(contextId)}\"] ??= {})`\n    : '{}';\n  const expression = `\n(async () => {\n  const fn${randomSuffix} = ${getFunctionExpressionString(fn)};\n  const obsidianModule${randomSuffix} = await (async () => {\n    if (!app.workspace.app.workspace.layoutReady) {\n      await new Promise((resolve) => app.workspace.onLayoutReady(resolve));\n    }\n    if (!app.plugins.isEnabled()) {\n      await app.plugins.setEnable(true);\n    }\n    ${getFunctionExpressionString(getObsidianModulePluginFn)}\n    ${getFunctionExpressionString(getObsidianModule)}\n    return await getObsidianModule();\n  })();\n  const args${randomSuffix} = ${jsonWithFunctions(args)};\n  const context${randomSuffix} = ${contextExpr};\n  const fullArgs${randomSuffix} = Object.assign(args${randomSuffix}, { app, obsidianModule: obsidianModule${randomSuffix}, context: context${randomSuffix} });\n  return JSON.stringify(await fn${randomSuffix}(fullArgs${randomSuffix}));\n})()`;\n\n  const command = ['obsidian', 'eval', `code=${expression}`];\n\n  let resultStr: string;\n  try {\n    resultStr = await exec(command, { cwd, isQuiet: true });\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n      // Check 5: Obsidian is not running \u2014 auto-start it.\n      resultStr = await ensureObsidianRunning({ command, cwd });\n    } else {\n      throw error;\n    }\n  }\n\n  if (resultStr === '' || resultStr === 'Vault not found.') {\n    throw new Error(`Unexpected empty response from Obsidian CLI for path: ${cwd}`);\n  }\n\n  const resultJson = resultStr.startsWith('=> ') ? resultStr.slice('=> '.length) : resultStr;\n  if (resultJson === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  try {\n    return JSON.parse(resultJson) as Result;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n}\n\n/**\n * Checks whether the Obsidian CLI binary is available in the system PATH.\n *\n * @throws If the CLI binary is not found.\n */\nasync function assertObsidianCliAvailable(): Promise<void> {\n  const command = process.platform === 'win32' ? 'where.exe obsidian.com' : 'which obsidian';\n  try {\n    await exec(command, { isQuiet: true });\n  } catch {\n    throw new Error('Obsidian CLI is not available. Ensure Obsidian is installed and its CLI is in your PATH.');\n  }\n}\n\n/**\n * Launches Obsidian via the `obsidian://` URI protocol and retries the eval\n * until Obsidian becomes available.\n *\n * @param params - The exec parameters for the eval command.\n * @param params.command - The CLI command array to retry.\n * @param params.cwd - The working directory for the eval command.\n * @returns The result string from the successful eval.\n */\nasync function ensureObsidianRunning(params: { command: string[]; cwd: string }): Promise<string> {\n  console.warn('Obsidian is not running. Starting Obsidian...');\n\n  const vaultId = getVaultId(params.cwd);\n  const uri = vaultId ? `obsidian://open?vault=${vaultId}` : 'obsidian://open';\n\n  try {\n    await exec(getOpenUriCommand(uri), { isQuiet: true });\n  } catch {\n    // The open command may fail on some systems \u2014 we'll still try polling.\n  }\n\n  const deadline = Date.now() + AUTO_START_TIMEOUT_MS;\n  while (Date.now() < deadline) {\n    await new Promise((r) => {\n      setTimeout(r, AUTO_START_POLL_INTERVAL_MS);\n    });\n    try {\n      return await exec(params.command, { cwd: params.cwd, isQuiet: true });\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      if (!message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n        throw error;\n      }\n    }\n  }\n\n  throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_MS)}ms.`);\n}\n\n/* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process, not in Node. Covered by integration tests. */\n\n/**\n * Injected into the Obsidian process to resolve the `obsidian` module.\n * Uses a cached value on `app` if available, otherwise installs a temporary\n * plugin that calls `require('obsidian')` and caches the result.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n * `getObsidianModulePluginFn` must be defined in the same scope\n * (the generated IIFE handles this).\n *\n * @returns The `obsidian` module.\n */\nasync function getObsidianModule(): Promise<typeof obsidian> {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n  const app = window.app;\n  interface ObsidianModuleHolder {\n    obsidianModule: typeof obsidian;\n  }\n  const obsidianModuleHolder = app as Partial<ObsidianModuleHolder>;\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  const SLICE_START = 2;\n  const randomSuffix = String(Math.random()).slice(SLICE_START);\n  const tempModuleName = `get-obsidian-module-${randomSuffix}`;\n  const dir = `${app.vault.configDir}/plugins/${tempModuleName}`;\n  app.plugins.manifests[tempModuleName] = {\n    author: '',\n    description: '',\n    dir,\n    id: tempModuleName,\n    isDesktopOnly: true,\n    minAppVersion: '',\n    name: tempModuleName,\n    version: ''\n  };\n  await app.vault.adapter.mkdir(dir);\n  await app.vault.adapter.write(`${dir}/main.js`, `(${String(getObsidianModulePluginFn)})();`);\n  await app.plugins.loadPlugin(tempModuleName);\n  await app.plugins.uninstallPlugin(tempModuleName);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It will be initialized within `loadPlugin`.\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  throw new Error('Failed to load obsidian module');\n}\n\n/**\n * The body of the temporary plugin that extracts the `obsidian` module.\n * Serialized via `toString()` and written to `main.js` by {@link getObsidianModule}.\n * Must NOT reference any outer scope.\n */\nfunction getObsidianModulePluginFn(): void {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n  const app = window.app;\n  interface ObsidianModuleHolder {\n    obsidianModule: typeof obsidian;\n  }\n  const obsidianModuleHolder = app as Partial<ObsidianModuleHolder>;\n\n  const pluginRequire = require;\n  const pluginExports = exports as {\n    default: unknown;\n  };\n\n  const obsidianModule = pluginRequire('obsidian') as typeof obsidian;\n  obsidianModuleHolder.obsidianModule = obsidianModule;\n  pluginExports.default = obsidianModule.Plugin;\n}\n\n/* v8 ignore stop */\n\n/**\n * Returns the platform-specific command to open a URI.\n *\n * @param uri - The URI to open.\n * @returns The shell command string.\n */\nfunction getOpenUriCommand(uri: string): string {\n  if (process.platform === 'win32') {\n    return `start \"\" \"${uri}\"`;\n  }\n\n  if (process.platform === 'darwin') {\n    return `open \"${uri}\"`;\n  }\n\n  return `xdg-open \"${uri}\"`;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian-config.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @packageDocumentation
+ *
+ * Reads and queries Obsidian's local configuration (`obsidian.json`).
+ */
+/**
+ * Returns the hex vault ID for a given vault path from Obsidian's registry.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ * @returns The vault ID, or `undefined` if the vault is not registered.
+ */
+export declare function getVaultId(vaultPath: string): string | undefined;
+/**
+ * Checks whether the Obsidian CLI is enabled in Obsidian's settings.
+ *
+ * @returns `true` if the CLI is enabled, `false` otherwise.
+ */
+export declare function isCliEnabled(): boolean;
+/**
+ * Checks whether a vault path is registered in Obsidian's vault registry.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ * @returns `true` if the vault is registered, `false` otherwise.
+ */
+export declare function isVaultRegistered(vaultPath: string): boolean;

package/dist/lib/esm/obsidian-config.mjs

@@ -0,0 +1,58 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import {
+  join,
+  resolve
+} from "node:path";
+import process from "node:process";
+function getVaultId(vaultPath) {
+  const config = readObsidianJson();
+  if (!config) {
+    return void 0;
+  }
+  const normalizedTarget = normalizePath(vaultPath);
+  for (const [id, entry] of Object.entries(config.vaults)) {
+    if (normalizePath(entry.path) === normalizedTarget) {
+      return id;
+    }
+  }
+  return void 0;
+}
+function isCliEnabled() {
+  const config = readObsidianJson();
+  return config?.cli === true;
+}
+function isVaultRegistered(vaultPath) {
+  return getVaultId(vaultPath) !== void 0;
+}
+function getObsidianConfigDir() {
+  if (process.platform === "win32") {
+    const appData = process.env["APPDATA"];
+    if (appData) {
+      return join(appData, "obsidian");
+    }
+  }
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Application Support", "obsidian");
+  }
+  return join(process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config"), "obsidian");
+}
+function normalizePath(vaultPath) {
+  const resolved = resolve(vaultPath);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function readObsidianJson() {
+  const configPath = join(getObsidianConfigDir(), "obsidian.json");
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+export {
+  getVaultId,
+  isCliEnabled,
+  isVaultRegistered
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/temp-vault.d.mts

@@ -0,0 +1,47 @@
+/**
+ * Parameters for the {@link TempVault} constructor.
+ */
+export interface TempVaultParams {
+    /**
+     * Map of file paths to content. Parent directories are created automatically.
+     *
+     * To create an empty folder, use a path ending with `/` and an empty string as content.
+     */
+    files?: Record<string, string>;
+    /**
+     * An explicit vault path. If omitted, a temp directory is created.
+     */
+    path?: string;
+}
+/**
+ * A temporary Obsidian vault for integration tests.
+ *
+ * Creates a temp directory and registers it in the running Obsidian instance
+ * so that the Obsidian CLI can target it via `cwd`.
+ */
+export declare class TempVault {
+    /**
+     * The absolute path to the temporary vault.
+     */
+    readonly path: string;
+    /**
+     * Creates a new temp vault, optionally pre-populated with files.
+     *
+     * @param params - Configuration for the vault.
+     */
+    constructor(params?: TempVaultParams);
+    /**
+     * Unregisters the vault from Obsidian and deletes the temp directory.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Registers this vault in the running Obsidian instance so the CLI can target it.
+     */
+    register(): Promise<void>;
+    /**
+     * Async disposable support for `await using`.
+     *
+     * @returns A promise that resolves when the vault is disposed.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/lib/esm/temp-vault.mjs

@@ -0,0 +1,82 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  writeFileSync
+} from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import {
+  dirname,
+  join
+} from "node:path";
+import {
+  registerVault,
+  unregisterVault
+} from "./vault-registry.mjs";
+const RM_RETRY_DELAY_MS = 500;
+const RM_RETRY_TIMEOUT_MS = 1e4;
+class TempVault {
+  /**
+   * The absolute path to the temporary vault.
+   */
+  path;
+  /**
+   * Creates a new temp vault, optionally pre-populated with files.
+   *
+   * @param params - Configuration for the vault.
+   */
+  constructor(params = {}) {
+    this.path = params.path ?? mkdtempSync(join(tmpdir(), "temp-vault-"));
+    for (const [filePath, content] of Object.entries(params.files ?? {})) {
+      const fullPath = join(this.path, filePath);
+      if (filePath.endsWith("/")) {
+        if (content !== "") {
+          throw new Error(`Folder path "${filePath}" must have empty content`);
+        }
+        mkdirSync(fullPath, { recursive: true });
+      } else {
+        mkdirSync(dirname(fullPath), { recursive: true });
+        writeFileSync(fullPath, content);
+      }
+    }
+  }
+  /**
+   * Unregisters the vault from Obsidian and deletes the temp directory.
+   */
+  async dispose() {
+    await unregisterVault(this.path);
+    await retryRm(this.path);
+  }
+  /**
+   * Registers this vault in the running Obsidian instance so the CLI can target it.
+   */
+  async register() {
+    await registerVault(this.path);
+  }
+  /**
+   * Async disposable support for `await using`.
+   *
+   * @returns A promise that resolves when the vault is disposed.
+   */
+  async [Symbol.asyncDispose]() {
+    return this.dispose();
+  }
+}
+async function retryRm(path) {
+  const deadline = Date.now() + RM_RETRY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      await rm(path, { force: true, recursive: true });
+      return;
+    } catch {
+      await new Promise((resolve) => {
+        setTimeout(resolve, RM_RETRY_DELAY_MS);
+      });
+    }
+  }
+  await rm(path, { force: true, recursive: true });
+}
+export {
+  TempVault
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3RlbXAtdmF1bHQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIHY4IGlnbm9yZSBzdGFydCAtLSBJbnRlZ3JhdGlvbi10aW1lIGNvZGUgY292ZXJlZCBieSBpbnRlZ3JhdGlvbiB0ZXN0cywgbm90IHVuaXQgdGVzdHMuICovXG5cbi8qKlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKlxuICogTWFuYWdlcyB0ZW1wb3JhcnkgdmF1bHQgbGlmZWN5Y2xlIGZvciBpbnRlZ3JhdGlvbiB0ZXN0cy5cbiAqL1xuXG5pbXBvcnQge1xuICBta2RpclN5bmMsXG4gIG1rZHRlbXBTeW5jLFxuICB3cml0ZUZpbGVTeW5jXG59IGZyb20gJ25vZGU6ZnMnO1xuaW1wb3J0IHsgcm0gfSBmcm9tICdub2RlOmZzL3Byb21pc2VzJztcbmltcG9ydCB7IHRtcGRpciB9IGZyb20gJ25vZGU6b3MnO1xuaW1wb3J0IHtcbiAgZGlybmFtZSxcbiAgam9pblxufSBmcm9tICdub2RlOnBhdGgnO1xuXG5pbXBvcnQge1xuICByZWdpc3RlclZhdWx0LFxuICB1bnJlZ2lzdGVyVmF1bHRcbn0gZnJvbSAnLi92YXVsdC1yZWdpc3RyeS5tanMnO1xuXG4vKipcbiAqIFBhcmFtZXRlcnMgZm9yIHRoZSB7QGxpbmsgVGVtcFZhdWx0fSBjb25zdHJ1Y3Rvci5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBUZW1wVmF1bHRQYXJhbXMge1xuICAvKipcbiAgICogTWFwIG9mIGZpbGUgcGF0aHMgdG8gY29udGVudC4gUGFyZW50IGRpcmVjdG9yaWVzIGFyZSBjcmVhdGVkIGF1dG9tYXRpY2FsbHkuXG4gICAqXG4gICAqIFRvIGNyZWF0ZSBhbiBlbXB0eSBmb2xkZXIsIHVzZSBhIHBhdGggZW5kaW5nIHdpdGggYC9gIGFuZCBhbiBlbXB0eSBzdHJpbmcgYXMgY29udGVudC5cbiAgICovXG4gIGZpbGVzPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcblxuICAvKipcbiAgICogQW4gZXhwbGljaXQgdmF1bHQgcGF0aC4gSWYgb21pdHRlZCwgYSB0ZW1wIGRpcmVjdG9yeSBpcyBjcmVhdGVkLlxuICAgKi9cbiAgcGF0aD86IHN0cmluZztcbn1cblxuY29uc3QgUk1fUkVUUllfREVMQVlfTVMgPSA1MDA7XG5jb25zdCBSTV9SRVRSWV9USU1FT1VUX01TID0gMTAwMDA7XG5cbi8qKlxuICogQSB0ZW1wb3JhcnkgT2JzaWRpYW4gdmF1bHQgZm9yIGludGVncmF0aW9uIHRlc3RzLlxuICpcbiAqIENyZWF0ZXMgYSB0ZW1wIGRpcmVjdG9yeSBhbmQgcmVnaXN0ZXJzIGl0IGluIHRoZSBydW5uaW5nIE9ic2lkaWFuIGluc3RhbmNlXG4gKiBzbyB0aGF0IHRoZSBPYnNpZGlhbiBDTEkgY2FuIHRhcmdldCBpdCB2aWEgYGN3ZGAuXG4gKi9cbmV4cG9ydCBjbGFzcyBUZW1wVmF1bHQge1xuICAvKipcbiAgICogVGhlIGFic29sdXRlIHBhdGggdG8gdGhlIHRlbXBvcmFyeSB2YXVsdC5cbiAgICovXG4gIHB1YmxpYyByZWFkb25seSBwYXRoOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBuZXcgdGVtcCB2YXVsdCwgb3B0aW9uYWxseSBwcmUtcG9wdWxhdGVkIHdpdGggZmlsZXMuXG4gICAqXG4gICAqIEBwYXJhbSBwYXJhbXMgLSBDb25maWd1cmF0aW9uIGZvciB0aGUgdmF1bHQuXG4gICAqL1xuICBwdWJsaWMgY29uc3RydWN0b3IocGFyYW1zOiBUZW1wVmF1bHRQYXJhbXMgPSB7fSkge1xuICAgIHRoaXMucGF0aCA9IHBhcmFtcy5wYXRoID8/IG1rZHRlbXBTeW5jKGpvaW4odG1wZGlyKCksICd0ZW1wLXZhdWx0LScpKTtcblxuICAgIGZvciAoY29uc3QgW2ZpbGVQYXRoLCBjb250ZW50XSBvZiBPYmplY3QuZW50cmllcyhwYXJhbXMuZmlsZXMgPz8ge30pKSB7XG4gICAgICBjb25zdCBmdWxsUGF0aCA9IGpvaW4odGhpcy5wYXRoLCBmaWxlUGF0aCk7XG4gICAgICBpZiAoZmlsZVBhdGguZW5kc1dpdGgoJy8nKSkge1xuICAgICAgICBpZiAoY29udGVudCAhPT0gJycpIHtcbiAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYEZvbGRlciBwYXRoIFwiJHtmaWxlUGF0aH1cIiBtdXN0IGhhdmUgZW1wdHkgY29udGVudGApO1xuICAgICAgICB9XG4gICAgICAgIG1rZGlyU3luYyhmdWxsUGF0aCwgeyByZWN1cnNpdmU6IHRydWUgfSk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICBta2RpclN5bmMoZGlybmFtZShmdWxsUGF0aCksIHsgcmVjdXJzaXZlOiB0cnVlIH0pO1xuICAgICAgICB3cml0ZUZpbGVTeW5jKGZ1bGxQYXRoLCBjb250ZW50KTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogVW5yZWdpc3RlcnMgdGhlIHZhdWx0IGZyb20gT2JzaWRpYW4gYW5kIGRlbGV0ZXMgdGhlIHRlbXAgZGlyZWN0b3J5LlxuICAgKi9cbiAgcHVibGljIGFzeW5jIGRpc3Bvc2UoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgdW5yZWdpc3RlclZhdWx0KHRoaXMucGF0aCk7XG4gICAgYXdhaXQgcmV0cnlSbSh0aGlzLnBhdGgpO1xuICB9XG5cbiAgLyoqXG4gICAqIFJlZ2lzdGVycyB0aGlzIHZhdWx0IGluIHRoZSBydW5uaW5nIE9ic2lkaWFuIGluc3RhbmNlIHNvIHRoZSBDTEkgY2FuIHRhcmdldCBpdC5cbiAgICovXG4gIHB1YmxpYyBhc3luYyByZWdpc3RlcigpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCByZWdpc3RlclZhdWx0KHRoaXMucGF0aCk7XG4gIH1cblxuICAvKipcbiAgICogQXN5bmMgZGlzcG9zYWJsZSBzdXBwb3J0IGZvciBgYXdhaXQgdXNpbmdgLlxuICAgKlxuICAgKiBAcmV0dXJucyBBIHByb21pc2UgdGhhdCByZXNvbHZlcyB3aGVuIHRoZSB2YXVsdCBpcyBkaXNwb3NlZC5cbiAgICovXG4gIHB1YmxpYyBhc3luYyBbU3ltYm9sLmFzeW5jRGlzcG9zZV0oKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgcmV0dXJuIHRoaXMuZGlzcG9zZSgpO1xuICB9XG59XG5cbi8qKlxuICogUmV0cmllcyBgcm1gIHVudGlsIGl0IHN1Y2NlZWRzIG9yIHRpbWVzIG91dC5cbiAqIE9ic2lkaWFuIG1heSBob2xkIGZpbGUgbG9ja3MgYnJpZWZseSBhZnRlciBhIHdpbmRvdyBpcyBkZXN0cm95ZWQuXG4gKlxuICogQHBhcmFtIHBhdGggLSBUaGUgcGF0aCB0byB0aGUgZGlyZWN0b3J5IHRvIHJlbW92ZS5cbiAqIEByZXR1cm5zIEEgcHJvbWlzZSB0aGF0IHJlc29sdmVzIHdoZW4gdGhlIGRpcmVjdG9yeSBpcyByZW1vdmVkLlxuICovXG5hc3luYyBmdW5jdGlvbiByZXRyeVJtKHBhdGg6IHN0cmluZyk6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBkZWFkbGluZSA9IERhdGUubm93KCkgKyBSTV9SRVRSWV9USU1FT1VUX01TO1xuICB3aGlsZSAoRGF0ZS5ub3coKSA8IGRlYWRsaW5lKSB7XG4gICAgdHJ5IHtcbiAgICAgIGF3YWl0IHJtKHBhdGgsIHsgZm9yY2U6IHRydWUsIHJlY3Vyc2l2ZTogdHJ1ZSB9KTtcbiAgICAgIHJldHVybjtcbiAgICB9IGNhdGNoIHtcbiAgICAgIGF3YWl0IG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7XG4gICAgICAgIHNldFRpbWVvdXQocmVzb2x2ZSwgUk1fUkVUUllfREVMQVlfTVMpO1xuICAgICAgfSk7XG4gICAgfVxuICB9XG4gIC8vIEZpbmFsIGF0dGVtcHQgXHUyMDE0IGxldCBpdCB0aHJvdy5cbiAgYXdhaXQgcm0ocGF0aCwgeyBmb3JjZTogdHJ1ZSwgcmVjdXJzaXZlOiB0cnVlIH0pO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBUUE7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxPQUNLO0FBQ1AsU0FBUyxVQUFVO0FBQ25CLFNBQVMsY0FBYztBQUN2QjtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsT0FDSztBQUVQO0FBQUEsRUFDRTtBQUFBLEVBQ0E7QUFBQSxPQUNLO0FBbUJQLE1BQU0sb0JBQW9CO0FBQzFCLE1BQU0sc0JBQXNCO0FBUXJCLE1BQU0sVUFBVTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBSUw7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPVCxZQUFZLFNBQTBCLENBQUMsR0FBRztBQUMvQyxTQUFLLE9BQU8sT0FBTyxRQUFRLFlBQVksS0FBSyxPQUFPLEdBQUcsYUFBYSxDQUFDO0FBRXBFLGVBQVcsQ0FBQyxVQUFVLE9BQU8sS0FBSyxPQUFPLFFBQVEsT0FBTyxTQUFTLENBQUMsQ0FBQyxHQUFHO0FBQ3BFLFlBQU0sV0FBVyxLQUFLLEtBQUssTUFBTSxRQUFRO0FBQ3pDLFVBQUksU0FBUyxTQUFTLEdBQUcsR0FBRztBQUMxQixZQUFJLFlBQVksSUFBSTtBQUNsQixnQkFBTSxJQUFJLE1BQU0sZ0JBQWdCLFFBQVEsMkJBQTJCO0FBQUEsUUFDckU7QUFDQSxrQkFBVSxVQUFVLEVBQUUsV0FBVyxLQUFLLENBQUM7QUFBQSxNQUN6QyxPQUFPO0FBQ0wsa0JBQVUsUUFBUSxRQUFRLEdBQUcsRUFBRSxXQUFXLEtBQUssQ0FBQztBQUNoRCxzQkFBYyxVQUFVLE9BQU87QUFBQSxNQUNqQztBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFLQSxNQUFhLFVBQXlCO0FBQ3BDLFVBQU0sZ0JBQWdCLEtBQUssSUFBSTtBQUMvQixVQUFNLFFBQVEsS0FBSyxJQUFJO0FBQUEsRUFDekI7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQUtBLE1BQWEsV0FBMEI7QUFDckMsVUFBTSxjQUFjLEtBQUssSUFBSTtBQUFBLEVBQy9CO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT0EsT0FBYyxPQUFPLFlBQVksSUFBbUI7QUFDbEQsV0FBTyxLQUFLLFFBQVE7QUFBQSxFQUN0QjtBQUNGO0FBU0EsZUFBZSxRQUFRLE1BQTZCO0FBQ2xELFFBQU0sV0FBVyxLQUFLLElBQUksSUFBSTtBQUM5QixTQUFPLEtBQUssSUFBSSxJQUFJLFVBQVU7QUFDNUIsUUFBSTtBQUNGLFlBQU0sR0FBRyxNQUFNLEVBQUUsT0FBTyxNQUFNLFdBQVcsS0FBSyxDQUFDO0FBQy9DO0FBQUEsSUFDRixRQUFRO0FBQ04sWUFBTSxJQUFJLFFBQVEsQ0FBQyxZQUFZO0FBQzdCLG1CQUFXLFNBQVMsaUJBQWlCO0FBQUEsTUFDdkMsQ0FBQztBQUFBLElBQ0g7QUFBQSxFQUNGO0FBRUEsUUFBTSxHQUFHLE1BQU0sRUFBRSxPQUFPLE1BQU0sV0FBVyxLQUFLLENBQUM7QUFDakQ7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/type-guards.d.mts

@@ -0,0 +1,30 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains utility functions for type guards.
+ */
+type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
+/**
+ * Asserts that a value is not `null` or `undefined`, narrowing its type in place.
+ *
+ * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.
+ *
+ * @typeParam T - The type of the value.
+ * @param value - The value to check.
+ * @param errorOrMessage - Optional {@link Error} or error message string.
+ * @throws If the value is `null` or `undefined`.
+ */
+export declare function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T>;
+/**
+ * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.
+ *
+ * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.
+ *
+ * @typeParam T - The type of the value.
+ * @param value - The value to check.
+ * @param errorOrMessage - Optional {@link Error} or error message string.
+ * @returns The value with `null` and `undefined` excluded from its type.
+ * @throws If the value is `null` or `undefined`.
+ */
+export declare function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T>;
+export {};

package/dist/lib/esm/type-guards.mjs

@@ -0,0 +1,17 @@
+function assertNonNullable(value, errorOrMessage) {
+  if (value !== null && value !== void 0) {
+    return;
+  }
+  errorOrMessage ??= value === null ? "Value is null" : "Value is undefined";
+  const error = typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+  throw error;
+}
+function ensureNonNullable(value, errorOrMessage) {
+  assertNonNullable(value, errorOrMessage);
+  return value;
+}
+export {
+  assertNonNullable,
+  ensureNonNullable
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/vault-registry.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Registers a vault path in the running Obsidian instance so the CLI can target it via `cwd`.
+ *
+ * Uses the `vault-open` IPC to register and open the vault, then polls until
+ * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ */
+export declare function registerVault(vaultPath: string): Promise<void>;
+/**
+ * Unregisters a vault path from the running Obsidian instance.
+ *
+ * Schedules the vault window to close, waits for it, then removes
+ * the vault from the registry via `vault-remove` IPC.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ */
+export declare function unregisterVault(vaultPath: string): Promise<void>;

package/dist/lib/esm/vault-registry.mjs

@@ -0,0 +1,64 @@
+import { evalInObsidian } from "./obsidian-cli.mjs";
+const POLL_INTERVAL_MS = 500;
+const POLL_TIMEOUT_MS = 3e4;
+const CLOSE_DELAY_MS = 1e3;
+async function registerVault(vaultPath) {
+  await evalInObsidian({
+    args: { vaultPath },
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    fn({ vaultPath: vaultPath2 }) {
+      window.electron.ipcRenderer.sendSync("vault-open", vaultPath2, false);
+    },
+    shouldSkipPreflightChecks: true
+  });
+  const deadline = Date.now() + POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      const basePath = await evalInObsidian({
+        fn({ app }) {
+          return app.vault.adapter.getBasePath();
+        },
+        shouldSkipPreflightChecks: true,
+        vaultPath
+      });
+      if (basePath === vaultPath) {
+        return;
+      }
+    } catch {
+    }
+    await new Promise((r) => {
+      setTimeout(r, POLL_INTERVAL_MS);
+    });
+  }
+  throw new Error(`Vault at ${vaultPath} did not become ready within ${String(POLL_TIMEOUT_MS)}ms`);
+}
+async function unregisterVault(vaultPath) {
+  try {
+    await evalInObsidian({
+      fn() {
+        setTimeout(() => {
+          window.electron.remote?.getCurrentWindow().destroy();
+        }, 0);
+      },
+      shouldSkipPreflightChecks: true,
+      vaultPath
+    });
+  } catch {
+  }
+  await new Promise((r) => {
+    setTimeout(r, CLOSE_DELAY_MS);
+  });
+  await evalInObsidian({
+    args: { vaultPath },
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    fn({ vaultPath: vaultPath2 }) {
+      window.electron.ipcRenderer.sendSync("vault-remove", vaultPath2);
+    },
+    shouldSkipPreflightChecks: true
+  });
+}
+export {
+  registerVault,
+  unregisterVault
+};
+//# sourceMappingURL=data:application/json;base64,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