obsidian-integration-testing 2.7.2 → 3.0.1

package/dist/lib/cjs/native-dialog-monitor.cjs

@@ -0,0 +1,190 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var native_dialog_monitor_exports = {};
+__export(native_dialog_monitor_exports, {
+  NativeDialogMonitor: () => NativeDialogMonitor
+});
+module.exports = __toCommonJS(native_dialog_monitor_exports);
+var import_node_process = __toESM(require("node:process"), 1);
+var import_exec = require("./exec.cjs");
+const DIALOG_TITLES = [
+  "Error",
+  "Vault not found."
+];
+const POLL_INTERVAL_IN_MILLISECONDS = 500;
+class NativeDialogMonitor {
+  events = [];
+  intervalId;
+  isPolling = false;
+  /**
+   * Asserts that no native dialogs were detected during monitoring.
+   *
+   * @throws If any dialogs were recorded.
+   */
+  assertNoDialogs() {
+    if (this.events.length > 0) {
+      const descriptions = this.events.map((e) => `  - "${e.title}" at ${new Date(e.timestamp).toISOString()}`).join("\n");
+      throw new Error(`Native dialog(s) detected during test:
+${descriptions}`);
+    }
+  }
+  /**
+   * Returns all dialog events recorded since the monitor started.
+   *
+   * @returns The recorded dialog events.
+   */
+  getEvents() {
+    return this.events;
+  }
+  /**
+   * Resets the recorded events without stopping the monitor.
+   */
+  reset() {
+    this.events = [];
+  }
+  /**
+   * Starts polling for native dialogs in the background.
+   */
+  start() {
+    if (this.intervalId) {
+      return;
+    }
+    this.events = [];
+    this.intervalId = setInterval(() => {
+      this.poll().catch(() => {
+      });
+    }, POLL_INTERVAL_IN_MILLISECONDS);
+  }
+  /**
+   * Stops polling and returns all recorded events.
+   *
+   * @returns The recorded dialog events.
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    return this.events;
+  }
+  /**
+   * Single poll iteration: detects and dismisses any Obsidian dialog windows.
+   */
+  async poll() {
+    if (this.isPolling) {
+      return;
+    }
+    this.isPolling = true;
+    try {
+      const titles = await getObsidianWindowTitles();
+      for (const title of titles) {
+        if (DIALOG_TITLES.includes(title)) {
+          this.events.push({ timestamp: Date.now(), title });
+          await dismissDialogByTitle(title);
+        }
+      }
+    } catch {
+    } finally {
+      this.isPolling = false;
+    }
+  }
+}
+async function dismissDialogByTitle(title) {
+  if (import_node_process.default.platform === "win32") {
+    await dismissDialogWindows(title);
+  } else if (import_node_process.default.platform === "darwin") {
+    await dismissDialogMac(title);
+  } else {
+    await dismissDialogLinux(title);
+  }
+}
+async function dismissDialogLinux(title) {
+  const escapedTitle = title.replace(/"/g, '\\"');
+  await (0, import_exec.exec)(
+    `xdotool search --name "${escapedTitle}" windowactivate --sync key Return 2>/dev/null || true`,
+    { isQuiet: true }
+  );
+}
+async function dismissDialogMac(title) {
+  const escapedTitle = title.replace(/"/g, '\\"');
+  await (0, import_exec.exec)(
+    `osascript -e 'tell application "System Events" to tell process "Obsidian" to click button 1 of window "${escapedTitle}"'`,
+    { isQuiet: true }
+  );
+}
+async function dismissDialogWindows(title) {
+  const escapedTitle = title.replace(/'/g, "''");
+  const script = [
+    'Add-Type -TypeDefinition @"',
+    "using System; using System.Runtime.InteropServices;",
+    "public class DlgClose {",
+    '  [DllImport("user32.dll")] public static extern IntPtr FindWindow(string c, string t);',
+    '  [DllImport("user32.dll")] public static extern IntPtr SendMessage(IntPtr h, uint m, IntPtr w, IntPtr l);',
+    "}",
+    '"@',
+    `$h = [DlgClose]::FindWindow($null, '${escapedTitle}')`,
+    "if ($h -ne [IntPtr]::Zero) { [DlgClose]::SendMessage($h, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero) }"
+  ].join("; ");
+  await (0, import_exec.exec)(`powershell -Command "${script}"`, { isQuiet: true });
+}
+async function getObsidianWindowTitles() {
+  if (import_node_process.default.platform === "win32") {
+    return getWindowTitlesWindows();
+  }
+  if (import_node_process.default.platform === "darwin") {
+    return getWindowTitlesMac();
+  }
+  return getWindowTitlesLinux();
+}
+async function getWindowTitlesLinux() {
+  const output = await (0, import_exec.exec)(
+    'xdotool search --name "Obsidian" getwindowname 2>/dev/null || true',
+    { isQuiet: true }
+  );
+  return output.trim().split("\n").filter(Boolean);
+}
+async function getWindowTitlesMac() {
+  const output = await (0, import_exec.exec)(
+    `osascript -e 'tell application "System Events" to get name of every window of (processes whose name is "Obsidian")'`,
+    { isQuiet: true }
+  );
+  return output.trim().split(", ").filter(Boolean);
+}
+async function getWindowTitlesWindows() {
+  const output = await (0, import_exec.exec)(
+    `powershell -Command "Get-Process Obsidian -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowTitle -ne '' } | Select-Object -ExpandProperty MainWindowTitle"`,
+    { isQuiet: true }
+  );
+  return output.trim().split("\n").map((line) => line.trim()).filter(Boolean);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NativeDialogMonitor
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/native-dialog-monitor.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Monitors for native OS dialogs (Electron `dialog.showErrorBox`, `dialog.showMessageBoxSync`)\n * from the Obsidian process. These dialogs block the main process and cannot be intercepted\n * from the renderer via `@electron/remote`.\n *\n * Uses platform-specific process window title inspection to detect dialogs, and\n * auto-dismisses them so they don't block test execution.\n */\n\n/* v8 ignore start -- Integration-time utility. Not unit-testable: relies on OS process inspection. */\n\nimport process from 'node:process';\n\nimport { exec } from './exec.cjs';\n\n/**\n * A captured native dialog event.\n */\nexport interface NativeDialogEvent {\n  /**\n   * When the dialog was detected.\n   */\n  timestamp: number;\n\n  /**\n   * The window title of the dialog.\n   */\n  title: string;\n}\n\n/**\n * Known Obsidian dialog window titles that indicate an error or blocking prompt.\n */\nconst DIALOG_TITLES = [\n  'Error',\n  'Vault not found.'\n];\n\nconst POLL_INTERVAL_IN_MILLISECONDS = 500;\n\n/**\n * Monitors the Obsidian process for native OS dialogs by polling process window titles.\n *\n * Detected dialogs are auto-dismissed (via WM_CLOSE / AppleScript / xdotool) so they\n * don't block the main process, and recorded for later assertion.\n *\n * Cross-platform: works on Windows, macOS, and Linux.\n */\nexport class NativeDialogMonitor {\n  private events: NativeDialogEvent[] = [];\n  private intervalId: ReturnType<typeof setInterval> | undefined;\n  private isPolling = false;\n\n  /**\n   * Asserts that no native dialogs were detected during monitoring.\n   *\n   * @throws If any dialogs were recorded.\n   */\n  public assertNoDialogs(): void {\n    if (this.events.length > 0) {\n      const descriptions = this.events\n        .map((e) => `  - \"${e.title}\" at ${new Date(e.timestamp).toISOString()}`)\n        .join('\\n');\n      throw new Error(`Native dialog(s) detected during test:\\n${descriptions}`);\n    }\n  }\n\n  /**\n   * Returns all dialog events recorded since the monitor started.\n   *\n   * @returns The recorded dialog events.\n   */\n  public getEvents(): readonly NativeDialogEvent[] {\n    return this.events;\n  }\n\n  /**\n   * Resets the recorded events without stopping the monitor.\n   */\n  public reset(): void {\n    this.events = [];\n  }\n\n  /**\n   * Starts polling for native dialogs in the background.\n   */\n  public start(): void {\n    if (this.intervalId) {\n      return;\n    }\n    this.events = [];\n    this.intervalId = setInterval(() => {\n      this.poll().catch(() => {\n        // Ignore poll errors.\n      });\n    }, POLL_INTERVAL_IN_MILLISECONDS);\n  }\n\n  /**\n   * Stops polling and returns all recorded events.\n   *\n   * @returns The recorded dialog events.\n   */\n  public stop(): readonly NativeDialogEvent[] {\n    if (this.intervalId) {\n      clearInterval(this.intervalId);\n      this.intervalId = undefined;\n    }\n    return this.events;\n  }\n\n  /**\n   * Single poll iteration: detects and dismisses any Obsidian dialog windows.\n   */\n  private async poll(): Promise<void> {\n    if (this.isPolling) {\n      return;\n    }\n    this.isPolling = true;\n    try {\n      const titles = await getObsidianWindowTitles();\n      for (const title of titles) {\n        if (DIALOG_TITLES.includes(title)) {\n          this.events.push({ timestamp: Date.now(), title });\n          await dismissDialogByTitle(title);\n        }\n      }\n    } catch {\n      // Process may not be running \u2014 ignore.\n    } finally {\n      this.isPolling = false;\n    }\n  }\n}\n\n/**\n * Dismisses a native dialog window by its title.\n *\n * @param title - The window title to dismiss.\n */\nasync function dismissDialogByTitle(title: string): Promise<void> {\n  if (process.platform === 'win32') {\n    await dismissDialogWindows(title);\n  } else if (process.platform === 'darwin') {\n    await dismissDialogMac(title);\n  } else {\n    await dismissDialogLinux(title);\n  }\n}\n\n/**\n * Dismisses a dialog on Linux via xdotool.\n *\n * @param title - The window title to dismiss.\n */\nasync function dismissDialogLinux(title: string): Promise<void> {\n  const escapedTitle = title.replace(/\"/g, '\\\\\"');\n  await exec(\n    `xdotool search --name \"${escapedTitle}\" windowactivate --sync key Return 2>/dev/null || true`,\n    { isQuiet: true }\n  );\n}\n\n/**\n * Dismisses a dialog on macOS via AppleScript.\n *\n * @param title - The window title to dismiss.\n */\nasync function dismissDialogMac(title: string): Promise<void> {\n  const escapedTitle = title.replace(/\"/g, '\\\\\"');\n  await exec(\n    `osascript -e 'tell application \"System Events\" to tell process \"Obsidian\" to click button 1 of window \"${escapedTitle}\"'`,\n    { isQuiet: true }\n  );\n}\n\n/**\n * Dismisses a dialog on Windows by sending WM_CLOSE via Win32 API.\n *\n * @param title - The window title to dismiss.\n */\nasync function dismissDialogWindows(title: string): Promise<void> {\n  const escapedTitle = title.replace(/'/g, '\\'\\'');\n  const script = [\n    'Add-Type -TypeDefinition @\"',\n    'using System; using System.Runtime.InteropServices;',\n    'public class DlgClose {',\n    '  [DllImport(\"user32.dll\")] public static extern IntPtr FindWindow(string c, string t);',\n    '  [DllImport(\"user32.dll\")] public static extern IntPtr SendMessage(IntPtr h, uint m, IntPtr w, IntPtr l);',\n    '}',\n    '\"@',\n    `$h = [DlgClose]::FindWindow($null, '${escapedTitle}')`,\n    'if ($h -ne [IntPtr]::Zero) { [DlgClose]::SendMessage($h, 0x0010, [IntPtr]::Zero, [IntPtr]::Zero) }'\n  ].join('; ');\n  await exec(`powershell -Command \"${script}\"`, { isQuiet: true });\n}\n\n/**\n * Returns window titles of all Obsidian process windows.\n *\n * @returns An array of window title strings.\n */\nasync function getObsidianWindowTitles(): Promise<string[]> {\n  if (process.platform === 'win32') {\n    return getWindowTitlesWindows();\n  }\n\n  if (process.platform === 'darwin') {\n    return getWindowTitlesMac();\n  }\n\n  return getWindowTitlesLinux();\n}\n\n/**\n * Returns Obsidian window titles on Linux via xdotool.\n *\n * @returns An array of window title strings.\n */\nasync function getWindowTitlesLinux(): Promise<string[]> {\n  const output = await exec(\n    'xdotool search --name \"Obsidian\" getwindowname 2>/dev/null || true',\n    { isQuiet: true }\n  );\n  return output.trim().split('\\n').filter(Boolean);\n}\n\n/**\n * Returns Obsidian window titles on macOS via AppleScript.\n *\n * @returns An array of window title strings.\n */\nasync function getWindowTitlesMac(): Promise<string[]> {\n  const output = await exec(\n    'osascript -e \\'tell application \"System Events\" to get name of every window of (processes whose name is \"Obsidian\")\\'',\n    { isQuiet: true }\n  );\n  return output.trim().split(', ').filter(Boolean);\n}\n\n/**\n * Returns Obsidian window titles on Windows via Get-Process.\n *\n * @returns An array of window title strings.\n */\nasync function getWindowTitlesWindows(): Promise<string[]> {\n  const output = await exec(\n    'powershell -Command \"Get-Process Obsidian -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowTitle -ne \\'\\' } | Select-Object -ExpandProperty MainWindowTitle\"',\n    { isQuiet: true }\n  );\n  return output.trim().split('\\n').map((line) => line.trim()).filter(Boolean);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}


package/dist/lib/cjs/native-dialog-monitor.d.cts

@@ -0,0 +1,66 @@
+/**
+ * @file
+ *
+ * Monitors for native OS dialogs (Electron `dialog.showErrorBox`, `dialog.showMessageBoxSync`)
+ * from the Obsidian process. These dialogs block the main process and cannot be intercepted
+ * from the renderer via `@electron/remote`.
+ *
+ * Uses platform-specific process window title inspection to detect dialogs, and
+ * auto-dismisses them so they don't block test execution.
+ */
+/**
+ * A captured native dialog event.
+ */
+export interface NativeDialogEvent {
+    /**
+     * When the dialog was detected.
+     */
+    timestamp: number;
+    /**
+     * The window title of the dialog.
+     */
+    title: string;
+}
+/**
+ * Monitors the Obsidian process for native OS dialogs by polling process window titles.
+ *
+ * Detected dialogs are auto-dismissed (via WM_CLOSE / AppleScript / xdotool) so they
+ * don't block the main process, and recorded for later assertion.
+ *
+ * Cross-platform: works on Windows, macOS, and Linux.
+ */
+export declare class NativeDialogMonitor {
+    private events;
+    private intervalId;
+    private isPolling;
+    /**
+     * Asserts that no native dialogs were detected during monitoring.
+     *
+     * @throws If any dialogs were recorded.
+     */
+    assertNoDialogs(): void;
+    /**
+     * Returns all dialog events recorded since the monitor started.
+     *
+     * @returns The recorded dialog events.
+     */
+    getEvents(): readonly NativeDialogEvent[];
+    /**
+     * Resets the recorded events without stopping the monitor.
+     */
+    reset(): void;
+    /**
+     * Starts polling for native dialogs in the background.
+     */
+    start(): void;
+    /**
+     * Stops polling and returns all recorded events.
+     *
+     * @returns The recorded dialog events.
+     */
+    stop(): readonly NativeDialogEvent[];
+    /**
+     * Single poll iteration: detects and dismisses any Obsidian dialog windows.
+     */
+    private poll;
+}

package/dist/lib/cjs/obsidian-config.cjs

@@ -30,8 +30,10 @@ var obsidian_config_exports = {};
 __export(obsidian_config_exports, {
   enableCliInConfig: () => enableCliInConfig,
   getAnyRegisteredVaultPath: () => getAnyRegisteredVaultPath,
+  getRegisteredVaults: () => getRegisteredVaults,
   getVaultId: () => getVaultId,
   isCliEnabled: () => isCliEnabled,
+  isVaultOpen: () => isVaultOpen,
   isVaultRegistered: () => isVaultRegistered,
   registerVaultInConfig: () => registerVaultInConfig,
   removeVaultFromConfig: () => removeVaultFromConfig
@@ -55,6 +57,17 @@ function getAnyRegisteredVaultPath() {
   const firstEntry = Object.values(config.vaults)[0];
   return firstEntry?.path;
 }
+function getRegisteredVaults() {
+  const config = readObsidianJson();
+  if (!config) {
+    return [];
+  }
+  return Object.entries(config.vaults).map(([id, entry]) => ({
+    id,
+    open: entry.open === true,
+    path: entry.path
+  }));
+}
 function getVaultId(vaultPath) {
   const config = readObsidianJson();
   if (!config) {
@@ -72,6 +85,19 @@ function isCliEnabled() {
   const config = readObsidianJson();
   return config?.cli === true;
 }
+function isVaultOpen(vaultPath) {
+  const config = readObsidianJson();
+  if (!config) {
+    return false;
+  }
+  const normalizedTarget = normalizePath(vaultPath);
+  for (const entry of Object.values(config.vaults)) {
+    if (normalizePath(entry.path) === normalizedTarget) {
+      return entry.open === true;
+    }
+  }
+  return false;
+}
 function isVaultRegistered(vaultPath) {
   return getVaultId(vaultPath) !== void 0;
 }
@@ -135,10 +161,12 @@ function writeObsidianJson(config) {
 0 && (module.exports = {
   enableCliInConfig,
   getAnyRegisteredVaultPath,
+  getRegisteredVaults,
   getVaultId,
   isCliEnabled,
+  isVaultOpen,
   isVaultRegistered,
   registerVaultInConfig,
   removeVaultFromConfig
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Reads and queries Obsidian's local configuration (`obsidian.json`).\n */\n\nimport { randomBytes } from 'node:crypto';\nimport {\n  readFileSync,\n  writeFileSync\n} from 'node:fs';\nimport { homedir } from 'node:os';\nimport {\n  join,\n  resolve\n} from 'node:path';\nimport process from 'node:process';\n\n/**\n * The top-level structure of Obsidian's `obsidian.json` config file.\n */\ninterface ObsidianJson {\n  /**\n   * Whether the CLI is enabled in Obsidian settings.\n   */\n  cli?: boolean;\n\n  /**\n   * Map of vault IDs to vault entries.\n   */\n  vaults: Record<string, ObsidianVaultEntry>;\n}\n\n/**\n * A single vault entry in `obsidian.json`.\n */\ninterface ObsidianVaultEntry {\n  /**\n   * Whether the vault is currently open.\n   */\n  open?: boolean;\n\n  /**\n   * The absolute path to the vault folder.\n   */\n  path: string;\n\n  /**\n   * Timestamp of the last access.\n   */\n  ts: number;\n}\n\n/**\n * Enables the CLI in Obsidian's `obsidian.json` config file.\n *\n * Sets `cli: true` so that Obsidian starts its CLI server on next launch.\n * If the config file doesn't exist, creates it with an empty vaults object.\n */\nexport function enableCliInConfig(): void {\n  const config = readObsidianJson() ?? { vaults: {} };\n  config.cli = true;\n  writeObsidianJson(config);\n}\n\n/**\n * Returns the path of any vault that is currently registered in Obsidian's registry.\n *\n * This is useful when an `obsidian eval` call must run inside an existing vault\n * window (e.g., to issue IPC commands that register or remove other vaults).\n *\n * @returns The absolute path to a registered vault, or `undefined` if no vaults are registered.\n */\nexport function getAnyRegisteredVaultPath(): string | undefined {\n  const config = readObsidianJson();\n  if (!config) {\n    return undefined;\n  }\n\n  const firstEntry = Object.values(config.vaults)[0];\n  return firstEntry?.path;\n}\n\n/**\n * Returns the hex vault ID for a given vault path from Obsidian's registry.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns The vault ID, or `undefined` if the vault is not registered.\n */\nexport function getVaultId(vaultPath: string): string | undefined {\n  const config = readObsidianJson();\n  if (!config) {\n    return undefined;\n  }\n\n  const normalizedTarget = normalizePath(vaultPath);\n\n  for (const [id, entry] of Object.entries(config.vaults)) {\n    if (normalizePath(entry.path) === normalizedTarget) {\n      return id;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Checks whether the Obsidian CLI is enabled in Obsidian's settings.\n *\n * @returns `true` if the CLI is enabled, `false` otherwise.\n */\nexport function isCliEnabled(): boolean {\n  const config = readObsidianJson();\n  return config?.cli === true;\n}\n\n/**\n * Checks whether a vault path is registered in Obsidian's vault registry.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns `true` if the vault is registered, `false` otherwise.\n */\nexport function isVaultRegistered(vaultPath: string): boolean {\n  return getVaultId(vaultPath) !== undefined;\n}\n\n/**\n * Registers a vault directly in Obsidian's `obsidian.json` config file.\n *\n * This writes a new vault entry with a random hex ID. Used when no existing\n * vault is available to send IPC commands through \u2014 the vault is registered\n * \"offline\" so Obsidian will open it on next launch.\n *\n * @param vaultPath - The absolute path to the vault folder.\n */\nexport function registerVaultInConfig(vaultPath: string): void {\n  const config = readObsidianJson() ?? { vaults: {} };\n  const VAULT_ID_BYTE_LENGTH = 8;\n  const id = randomBytes(VAULT_ID_BYTE_LENGTH).toString('hex');\n  config.vaults[id] = { path: vaultPath, ts: Date.now() };\n  config.cli = true;\n  writeObsidianJson(config);\n}\n\n/**\n * Removes a vault entry from Obsidian's `obsidian.json` config file.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns `true` if the vault was found and removed, `false` otherwise.\n */\nexport function removeVaultFromConfig(vaultPath: string): boolean {\n  const config = readObsidianJson();\n  if (!config) {\n    return false;\n  }\n\n  const normalizedTarget = normalizePath(vaultPath);\n  let wasFound = false;\n\n  for (const [id, entry] of Object.entries(config.vaults)) {\n    if (normalizePath(entry.path) === normalizedTarget) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Removing a vault entry by its dynamic key.\n      delete config.vaults[id];\n      wasFound = true;\n      break;\n    }\n  }\n\n  if (wasFound) {\n    writeObsidianJson(config);\n  }\n\n  return wasFound;\n}\n\n/**\n * Returns the platform-specific path to Obsidian's config directory.\n *\n * @returns The absolute path to the `obsidian/` config directory.\n */\nfunction getObsidianConfigDir(): string {\n  if (process.platform === 'win32') {\n    const appData = process.env['APPDATA'];\n    if (appData) {\n      return join(appData, 'obsidian');\n    }\n  }\n\n  if (process.platform === 'darwin') {\n    return join(homedir(), 'Library', 'Application Support', 'obsidian');\n  }\n\n  return join(process.env['XDG_CONFIG_HOME'] ?? join(homedir(), '.config'), 'obsidian');\n}\n\n/**\n * Normalizes a vault path for comparison.\n * On Windows, paths are case-insensitive and separators may vary.\n *\n * @param vaultPath - The path to normalize.\n * @returns The normalized path.\n */\nfunction normalizePath(vaultPath: string): string {\n  const resolved = resolve(vaultPath);\n  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;\n}\n\n/**\n * Reads and parses Obsidian's `obsidian.json` config file.\n *\n * @returns The parsed config, or `undefined` if the file doesn't exist or can't be parsed.\n */\nfunction readObsidianJson(): ObsidianJson | undefined {\n  const configPath = join(getObsidianConfigDir(), 'obsidian.json');\n  try {\n    const content = readFileSync(configPath, 'utf-8');\n    return JSON.parse(content) as ObsidianJson;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Writes the given config object to Obsidian's `obsidian.json` file.\n *\n * @param config - The config to write.\n */\nfunction writeObsidianJson(config: ObsidianJson): void {\n  const configPath = join(getObsidianConfigDir(), 'obsidian.json');\n  writeFileSync(configPath, JSON.stringify(config));\n}\n"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Reads and queries Obsidian's local configuration (`obsidian.json`).\n */\n\nimport { randomBytes } from 'node:crypto';\nimport {\n  readFileSync,\n  writeFileSync\n} from 'node:fs';\nimport { homedir } from 'node:os';\nimport {\n  join,\n  resolve\n} from 'node:path';\nimport process from 'node:process';\n\n/**\n * A registered vault entry returned by {@link getRegisteredVaults}.\n */\nexport interface RegisteredVault {\n  /**\n   * The hex vault ID from `obsidian.json`.\n   */\n  id: string;\n\n  /**\n   * Whether the vault is currently marked as open.\n   */\n  open: boolean;\n\n  /**\n   * The absolute path to the vault folder.\n   */\n  path: string;\n}\n\n/**\n * The top-level structure of Obsidian's `obsidian.json` config file.\n */\ninterface ObsidianJson {\n  /**\n   * Whether the CLI is enabled in Obsidian settings.\n   */\n  cli?: boolean;\n\n  /**\n   * Map of vault IDs to vault entries.\n   */\n  vaults: Record<string, ObsidianVaultEntry>;\n}\n\n/**\n * A single vault entry in `obsidian.json`.\n */\ninterface ObsidianVaultEntry {\n  /**\n   * Whether the vault is currently open.\n   */\n  open?: boolean;\n\n  /**\n   * The absolute path to the vault folder.\n   */\n  path: string;\n\n  /**\n   * Timestamp of the last access.\n   */\n  ts: number;\n}\n\n/**\n * Enables the CLI in Obsidian's `obsidian.json` config file.\n *\n * Sets `cli: true` so that Obsidian starts its CLI server on next launch.\n * If the config file doesn't exist, creates it with an empty vaults object.\n */\nexport function enableCliInConfig(): void {\n  const config = readObsidianJson() ?? { vaults: {} };\n  config.cli = true;\n  writeObsidianJson(config);\n}\n\n/**\n * Returns the path of any vault that is currently registered in Obsidian's registry.\n *\n * This is useful when an `obsidian eval` call must run inside an existing vault\n * window (e.g., to issue IPC commands that register or remove other vaults).\n *\n * @returns The absolute path to a registered vault, or `undefined` if no vaults are registered.\n */\nexport function getAnyRegisteredVaultPath(): string | undefined {\n  const config = readObsidianJson();\n  if (!config) {\n    return undefined;\n  }\n\n  const firstEntry = Object.values(config.vaults)[0];\n  return firstEntry?.path;\n}\n\n/**\n * Returns all registered vaults from Obsidian's `obsidian.json` registry.\n *\n * @returns An array of registered vault entries.\n */\nexport function getRegisteredVaults(): RegisteredVault[] {\n  const config = readObsidianJson();\n  if (!config) {\n    return [];\n  }\n\n  return Object.entries(config.vaults).map(([id, entry]) => ({\n    id,\n    open: entry.open === true,\n    path: entry.path\n  }));\n}\n\n/**\n * Returns the hex vault ID for a given vault path from Obsidian's registry.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns The vault ID, or `undefined` if the vault is not registered.\n */\nexport function getVaultId(vaultPath: string): string | undefined {\n  const config = readObsidianJson();\n  if (!config) {\n    return undefined;\n  }\n\n  const normalizedTarget = normalizePath(vaultPath);\n\n  for (const [id, entry] of Object.entries(config.vaults)) {\n    if (normalizePath(entry.path) === normalizedTarget) {\n      return id;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Checks whether the Obsidian CLI is enabled in Obsidian's settings.\n *\n * @returns `true` if the CLI is enabled, `false` otherwise.\n */\nexport function isCliEnabled(): boolean {\n  const config = readObsidianJson();\n  return config?.cli === true;\n}\n\n/**\n * Checks whether a vault is marked as open in Obsidian's vault registry.\n *\n * Note: This checks the `open` flag in `obsidian.json`, which is updated\n * asynchronously by Obsidian. It may not reflect the current runtime state.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns `true` if the vault is registered and marked as open, `false` otherwise.\n */\nexport function isVaultOpen(vaultPath: string): boolean {\n  const config = readObsidianJson();\n  if (!config) {\n    return false;\n  }\n\n  const normalizedTarget = normalizePath(vaultPath);\n\n  for (const entry of Object.values(config.vaults)) {\n    if (normalizePath(entry.path) === normalizedTarget) {\n      return entry.open === true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Checks whether a vault path is registered in Obsidian's vault registry.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns `true` if the vault is registered, `false` otherwise.\n */\nexport function isVaultRegistered(vaultPath: string): boolean {\n  return getVaultId(vaultPath) !== undefined;\n}\n\n/**\n * Registers a vault directly in Obsidian's `obsidian.json` config file.\n *\n * This writes a new vault entry with a random hex ID. Used when no existing\n * vault is available to send IPC commands through \u2014 the vault is registered\n * \"offline\" so Obsidian will open it on next launch.\n *\n * @param vaultPath - The absolute path to the vault folder.\n */\nexport function registerVaultInConfig(vaultPath: string): void {\n  const config = readObsidianJson() ?? { vaults: {} };\n  const VAULT_ID_BYTE_LENGTH = 8;\n  const id = randomBytes(VAULT_ID_BYTE_LENGTH).toString('hex');\n  config.vaults[id] = { path: vaultPath, ts: Date.now() };\n  config.cli = true;\n  writeObsidianJson(config);\n}\n\n/**\n * Removes a vault entry from Obsidian's `obsidian.json` config file.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns `true` if the vault was found and removed, `false` otherwise.\n */\nexport function removeVaultFromConfig(vaultPath: string): boolean {\n  const config = readObsidianJson();\n  if (!config) {\n    return false;\n  }\n\n  const normalizedTarget = normalizePath(vaultPath);\n  let wasFound = false;\n\n  for (const [id, entry] of Object.entries(config.vaults)) {\n    if (normalizePath(entry.path) === normalizedTarget) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Removing a vault entry by its dynamic key.\n      delete config.vaults[id];\n      wasFound = true;\n      break;\n    }\n  }\n\n  if (wasFound) {\n    writeObsidianJson(config);\n  }\n\n  return wasFound;\n}\n\n/**\n * Returns the platform-specific path to Obsidian's config directory.\n *\n * @returns The absolute path to the `obsidian/` config directory.\n */\nfunction getObsidianConfigDir(): string {\n  if (process.platform === 'win32') {\n    const appData = process.env['APPDATA'];\n    if (appData) {\n      return join(appData, 'obsidian');\n    }\n  }\n\n  if (process.platform === 'darwin') {\n    return join(homedir(), 'Library', 'Application Support', 'obsidian');\n  }\n\n  return join(process.env['XDG_CONFIG_HOME'] ?? join(homedir(), '.config'), 'obsidian');\n}\n\n/**\n * Normalizes a vault path for comparison.\n * On Windows, paths are case-insensitive and separators may vary.\n *\n * @param vaultPath - The path to normalize.\n * @returns The normalized path.\n */\nfunction normalizePath(vaultPath: string): string {\n  const resolved = resolve(vaultPath);\n  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;\n}\n\n/**\n * Reads and parses Obsidian's `obsidian.json` config file.\n *\n * @returns The parsed config, or `undefined` if the file doesn't exist or can't be parsed.\n */\nfunction readObsidianJson(): ObsidianJson | undefined {\n  const configPath = join(getObsidianConfigDir(), 'obsidian.json');\n  try {\n    const content = readFileSync(configPath, 'utf-8');\n    return JSON.parse(content) as ObsidianJson;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Writes the given config object to Obsidian's `obsidian.json` file.\n *\n * @param config - The config to write.\n */\nfunction writeObsidianJson(config: ObsidianJson): void {\n  const configPath = join(getObsidianConfigDir(), 'obsidian.json');\n  writeFileSync(configPath, JSON.stringify(config));\n}\n"],
  "mappings": "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",
  "names": ["process"]
}


package/dist/lib/cjs/obsidian-config.d.cts

@@ -3,6 +3,23 @@
  *
  * Reads and queries Obsidian's local configuration (`obsidian.json`).
  */
+/**
+ * A registered vault entry returned by {@link getRegisteredVaults}.
+ */
+export interface RegisteredVault {
+    /**
+     * The hex vault ID from `obsidian.json`.
+     */
+    id: string;
+    /**
+     * Whether the vault is currently marked as open.
+     */
+    open: boolean;
+    /**
+     * The absolute path to the vault folder.
+     */
+    path: string;
+}
 /**
  * Enables the CLI in Obsidian's `obsidian.json` config file.
  *
@@ -19,6 +36,12 @@ export declare function enableCliInConfig(): void;
  * @returns The absolute path to a registered vault, or `undefined` if no vaults are registered.
  */
 export declare function getAnyRegisteredVaultPath(): string | undefined;
+/**
+ * Returns all registered vaults from Obsidian's `obsidian.json` registry.
+ *
+ * @returns An array of registered vault entries.
+ */
+export declare function getRegisteredVaults(): RegisteredVault[];
 /**
  * Returns the hex vault ID for a given vault path from Obsidian's registry.
  *
@@ -32,6 +55,16 @@ export declare function getVaultId(vaultPath: string): string | undefined;
  * @returns `true` if the CLI is enabled, `false` otherwise.
  */
 export declare function isCliEnabled(): boolean;
+/**
+ * Checks whether a vault is marked as open in Obsidian's vault registry.
+ *
+ * Note: This checks the `open` flag in `obsidian.json`, which is updated
+ * asynchronously by Obsidian. It may not reflect the current runtime state.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ * @returns `true` if the vault is registered and marked as open, `false` otherwise.
+ */
+export declare function isVaultOpen(vaultPath: string): boolean;
 /**
  * Checks whether a vault path is registered in Obsidian's vault registry.
  *

package/dist/lib/cjs/obsidian-namespace.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var obsidian_namespace_exports = {};
+module.exports = __toCommonJS(obsidian_namespace_exports);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian-namespace.d.cts

@@ -0,0 +1,114 @@
+/**
+ * @file
+ *
+ * Type definitions for the `window.__obsidianIntegrationTesting` namespace
+ * used inside the Obsidian process. All library state and registered helper
+ * functions live under this single namespace to avoid polluting `window`.
+ */
+/**
+ * Parameters for the registered `evalWrapper` function.
+ */
+export interface EvalWrapperNamespaceParams {
+    /** User-supplied arguments to pass to `fn`. */
+    args: Record<string, unknown>;
+    /** Optional context ID for persistent storage. */
+    contextId?: string;
+    /** The user function to evaluate. */
+    fn(args: Record<string, unknown>): unknown;
+}
+/**
+ * Parameters for {@link ObsidianIntegrationTestingNamespace.ipcSendSync}.
+ */
+export interface IpcSendSyncNamespaceParams {
+    /** The IPC arguments. */
+    args: unknown[];
+    /** The IPC channel name. */
+    channel: string;
+}
+/**
+ * Holder interface for type-safe access to `window.__obsidianIntegrationTesting`.
+ * Use with `Partial<ObsidianIntegrationTestingHolder>` to safely check existence.
+ */
+export interface ObsidianIntegrationTestingHolder {
+    __obsidianIntegrationTesting: ObsidianIntegrationTestingNamespace;
+}
+/**
+ * The namespace object stored on `window.__obsidianIntegrationTesting`
+ * inside the Obsidian process. Registered once via {@link bootstrapNamespace}
+ * and reused across all subsequent `evalInObsidian` calls.
+ *
+ * All functions access `window.app` directly — callers do not need to pass it.
+ */
+export interface ObsidianIntegrationTestingNamespace {
+    /**
+     * Persistent context objects keyed by {@link ContextId} string.
+     * Preserved across version upgrades so live context references survive.
+     */
+    contexts: Record<string, Record<string, unknown>>;
+    /**
+     * Destroys the current Electron window.
+     */
+    destroyCurrentWindow(): Promise<void>;
+    /**
+     * Waits for the Obsidian workspace layout to be ready.
+     */
+    ensureLayoutReady(): Promise<void>;
+    /**
+     * The top-level wrapper that sets up context, resolves the obsidian module,
+     * calls the user's function, and returns a JSON envelope.
+     *
+     * @param params - Parameters including the user's function, args, and context ID.
+     * @returns A JSON-stringified result envelope.
+     */
+    evalWrapper(params: EvalWrapperNamespaceParams): Promise<string>;
+    /**
+     * Resolves the `obsidian` module at runtime inside the Obsidian process.
+     *
+     * @returns The `obsidian` module.
+     */
+    getObsidianModule(): Promise<unknown>;
+    /**
+     * Sends an IPC message synchronously via Electron's `ipcRenderer`.
+     *
+     * @param params - The IPC channel and arguments.
+     */
+    ipcSendSync(params: IpcSendSyncNamespaceParams): Promise<void>;
+    /**
+     * Cached `obsidian` module, set by {@link getObsidianModule} on first resolution.
+     */
+    obsidianModule?: unknown;
+    /**
+     * Returns the vault's base path as a JSON-encoded string.
+     *
+     * @returns The JSON-encoded base path.
+     */
+    pollVaultBasePath(): Promise<string>;
+    /**
+     * Serializes an error into a human-readable string with stack trace and cause chain.
+     *
+     * @param error - The error to serialize.
+     * @param depth - The current nesting depth.
+     * @returns A formatted error string.
+     */
+    serializeError(error: unknown, depth?: number): string;
+    /**
+     * Sets a `localStorage` item.
+     *
+     * @param params - The key and value to set.
+     */
+    setLocalStorageItem(params: SetLocalStorageItemNamespaceParams): Promise<void>;
+    /**
+     * The library version that was used to bootstrap this namespace.
+     * Used to detect version mismatches and re-initialize.
+     */
+    version: string;
+}
+/**
+ * Parameters for {@link ObsidianIntegrationTestingNamespace.setLocalStorageItem}.
+ */
+export interface SetLocalStorageItemNamespaceParams {
+    /** The localStorage key. */
+    key: string;
+    /** The localStorage value. */
+    value: string;
+}