obsidian-integration-testing 4.1.5 → 4.2.0

package/dist/lib/cjs/transport-desktop-cdp.cjs

@@ -36,6 +36,7 @@ var import_exec = require("./exec.cjs");
 var import_log = require("./log.cjs");
 var import_namespace_bootstrap = require("./namespace-bootstrap.cjs");
 var import_obsidian_config = require("./obsidian-config.cjs");
+var import_obsidian_executable = require("./obsidian-executable.cjs");
 var import_type_guards = require("./type-guards.cjs");
 const CDP_DEFAULT_PORT = 8315;
 const COMMAND_TIMEOUT_IN_MILLISECONDS = 3e4;
@@ -285,8 +286,9 @@ class DesktopCdpTransport {
    */
   async ensureObsidianRunning() {
     (0, import_log.log)("[cdp-transport] Obsidian CDP not reachable. Starting Obsidian with remote debugging...");
+    const launchCommand = await getObsidianLaunchCommand(this.cdpPort);
     try {
-      await (0, import_exec.exec)(getObsidianLaunchCommand(this.cdpPort), { isQuiet: true });
+      await (0, import_exec.exec)(launchCommand, { isQuiet: true });
     } catch {
     }
     (0, import_log.log)(`[cdp-transport] Polling for CDP endpoint at ${this.cdpUrl} (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);
@@ -397,19 +399,16 @@ function delay(ms) {
     setTimeout(resolve, ms);
   });
 }
-function getObsidianLaunchCommand(port) {
+async function getObsidianLaunchCommand(port) {
+  const exePath = await (0, import_obsidian_executable.resolveObsidianExecutable)();
   const flag = `--remote-debugging-port=${String(port)}`;
   if (import_node_process.default.platform === "win32") {
-    const localAppData = import_node_process.default.env["LOCALAPPDATA"] ?? "";
-    return `start "" "${localAppData}\\Programs\\Obsidian\\Obsidian.exe" ${flag}`;
+    return `start "" "${exePath}" ${flag}`;
   }
-  if (import_node_process.default.platform === "darwin") {
-    return `/Applications/Obsidian.app/Contents/MacOS/Obsidian ${flag} &`;
-  }
-  return `obsidian ${flag} &`;
+  return `"${exePath}" ${flag} &`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DesktopCdpTransport
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-desktop-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop CDP transport \u2014 evaluates expressions via Chrome DevTools Protocol\n * over WebSocket and manages vaults via Electron IPC.\n *\n * Obsidian exposes CDP on port 8315 by default. This transport connects to\n * page targets, sends `Runtime.evaluate` commands, and routes to the correct\n * vault target using `getBasePath()` probing.\n *\n * Advantages over CLI transport:\n * - No CLI binary installation needed\n * - No \"CLI enabled\" setting required in Obsidian\n * - Lower overhead (WebSocket vs. process spawn per eval)\n *\n * Requirements:\n * - Obsidian must be running with remote debugging enabled (port 8315)\n * - Node.js 22+ (uses built-in `WebSocket` and `fetch` globals)\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport process from 'node:process';\n\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.cjs';\nimport { log } from './log.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport {\n  getVaultId,\n  isVaultRegistered,\n  removeVaultFromConfig\n} from './obsidian-config.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\n\n/**\n * Configuration for the CDP transport.\n */\nexport interface DesktopCdpTransportConfig {\n  /**\n   * CDP host. Defaults to `'localhost'`.\n   */\n  cdpHost?: string;\n\n  /**\n   * CDP port. Defaults to `8315`.\n   */\n  cdpPort?: number;\n\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   * Defaults to `30000`.\n   */\n  commandTimeoutInMilliseconds?: number;\n}\n\ninterface CdpExceptionDetails {\n  exception?: CdpExceptionObject;\n  text: string;\n}\n\ninterface CdpExceptionObject {\n  description?: string;\n}\n\ninterface CdpResponse {\n  id: number;\n  result?: CdpResponseResult;\n}\n\ninterface CdpResponseResult {\n  exceptionDetails?: CdpExceptionDetails;\n  result?: CdpValue;\n}\n\ninterface CdpTarget {\n  id: string;\n  title: string;\n  type: string;\n  url: string;\n  webSocketDebuggerUrl: string;\n}\n\ninterface CdpValue {\n  type: string;\n  value?: unknown;\n}\n\nconst CDP_DEFAULT_PORT = 8315;\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 30000;\nconst NO_OUTPUT = '(no output)';\nconst VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1000;\nconst AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst AUTO_START_TIMEOUT_IN_MILLISECONDS = 30000;\n\n/**\n * Transport that communicates with Desktop Obsidian via Chrome DevTools Protocol.\n *\n * Connects to Obsidian's CDP WebSocket endpoint, sends `Runtime.evaluate`\n * commands, and routes expressions to the correct vault target.\n */\nexport class DesktopCdpTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `false` for this transport.\n   */\n  public readonly isMobile = false;\n  private activeVaultPath: null | string = null;\n  private readonly cdpPort: number;\n  private readonly cdpUrl: string;\n  private readonly commandTimeoutInMilliseconds: number;\n  private messageId = 0;\n  private ws: null | WebSocket = null;\n\n  /**\n   * Creates a new CDP transport.\n   *\n   * @param config - CDP connection configuration.\n   */\n  public constructor(config?: DesktopCdpTransportConfig) {\n    const host = config?.cdpHost ?? 'localhost';\n    this.cdpPort = config?.cdpPort ?? CDP_DEFAULT_PORT;\n    this.cdpUrl = `http://${host}:${String(this.cdpPort)}`;\n    this.commandTimeoutInMilliseconds = config?.commandTimeoutInMilliseconds ?? COMMAND_TIMEOUT_IN_MILLISECONDS;\n  }\n\n  /**\n   * Disposes of the active WebSocket connection.\n   */\n  public async dispose(): Promise<void> {\n    this.disconnect();\n    await Promise.resolve();\n  }\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via CDP `Runtime.evaluate`.\n   *\n   * Routes to the correct vault target based on `options.cwd`.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param options - Evaluation options.\n   * @returns The normalized result string.\n   */\n  public async evaluate(expression: string, options: TransportEvalOptions): Promise<string> {\n    const ws = await this.ensureConnection(options.cwd);\n    const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n      awaitPromise: true,\n      expression,\n      returnByValue: true\n    });\n\n    if (response.result?.exceptionDetails) {\n      const desc = response.result.exceptionDetails.exception?.description\n        ?? response.result.exceptionDetails.text;\n      throw new Error(`CDP evaluation error: ${desc}`);\n    }\n\n    const resultObj = response.result?.result;\n    if (!resultObj || resultObj.type === 'undefined') {\n      return NO_OUTPUT;\n    }\n\n    return String(resultObj.value);\n  }\n\n  /**\n   * Verifies that the CDP endpoint is reachable and has Obsidian targets.\n   *\n   * If Obsidian is not running, attempts to auto-start it via URI protocol\n   * and polls until CDP becomes available.\n   *\n   * @param vaultPath - The vault path (used for vault registration check).\n   */\n  public async preflightCheck(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    try {\n      const targets = await this.getPageTargets();\n      if (targets.length === 0) {\n        throw new Error('No page targets');\n      }\n      log(`[cdp-transport] CDP reachable, ${String(targets.length)} target(s) found.`);\n    } catch {\n      await this.ensureObsidianRunning();\n    }\n  }\n\n  /**\n   * Registers a vault via Electron IPC evaluated through CDP.\n   *\n   * Uses an existing Obsidian target to send the `vault-open` IPC command,\n   * then polls until the new vault's target appears.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Registering vault: ${vaultPath}`);\n    const targets = await this.getPageTargets();\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets available. Is Obsidian running?');\n    }\n\n    const ipcWs = await this.connectToTarget(ensureNonNullable(targets[0]));\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const ipcExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath, false], channel: 'vault-open' })})`;\n      await this.sendCommand(ipcWs, 'Runtime.evaluate', {\n        awaitPromise: true,\n        expression: ipcExpr,\n        returnByValue: true\n      });\n\n      await this.enablePluginsInLocalStorage(ipcWs, vaultPath);\n    } finally {\n      ipcWs.close();\n    }\n\n    log(`[cdp-transport] Polling for vault target (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        await this.findTargetForVault(vaultPath);\n        log('[cdp-transport] Vault target found.');\n        return;\n      } catch {\n        // Vault target not ready yet.\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n\n  /**\n   * Unregisters a vault by destroying its window and removing it from the registry.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const target = await this.findTargetForVault(vaultPath);\n      const ws = await this.connectToTarget(target);\n      try {\n        const destroyExpr = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: destroyExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } catch {\n      // Window may already be closed.\n    }\n\n    if (this.activeVaultPath === vaultPath) {\n      this.disconnect();\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const targets = await this.getPageTargets();\n    if (targets.length > 0) {\n      const ws = await this.connectToTarget(ensureNonNullable(targets[0]));\n      try {\n        await ensureNamespaceBootstrapped(this, vaultPath);\n        const removeExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath], channel: 'vault-remove' })})`;\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: removeExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } else {\n      log('[cdp-transport] No CDP targets for removal IPC \u2014 removing directly from obsidian.json.');\n      removeVaultFromConfig(vaultPath);\n    }\n  }\n\n  /**\n   * Connects to a CDP target's WebSocket endpoint.\n   *\n   * @param target - The CDP target to connect to.\n   * @returns The open WebSocket connection.\n   */\n  private async connectToTarget(target: CdpTarget): Promise<WebSocket> {\n    const ws = new WebSocket(target.webSocketDebuggerUrl);\n    await new Promise<void>((resolve, reject) => {\n      ws.onopen = (): void => {\n        resolve();\n      };\n      ws.onerror = (): void => {\n        reject(new Error(`Failed to connect to CDP target: ${target.webSocketDebuggerUrl}`));\n      };\n    });\n    return ws;\n  }\n\n  /**\n   * Disconnects the active WebSocket connection.\n   */\n  private disconnect(): void {\n    if (this.ws?.readyState === WebSocket.OPEN) {\n      this.ws.close();\n    }\n    this.ws = null;\n    this.activeVaultPath = null;\n  }\n\n  /**\n   * Sets `enable-plugin-<vaultId>` in Obsidian's localStorage to prevent\n   * the \"Do you trust the author of this vault?\" dialog from appearing\n   * when a vault with community plugins is opened for the first time.\n   *\n   * Must be called after the `vault-open` IPC (so the vault ID exists in\n   * `obsidian.json`) and before the new vault window finishes loading.\n   *\n   * @param ws - An open WebSocket to an existing Obsidian target.\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async enablePluginsInLocalStorage(ws: WebSocket, vaultPath: string): Promise<void> {\n    const vaultId = getVaultId(vaultPath);\n    if (!vaultId) {\n      log('[cdp-transport] Could not find vault ID \u2014 skipping localStorage trust flag.');\n      return;\n    }\n\n    await this.sendCommand(ws, 'Runtime.evaluate', {\n      expression: `localStorage.setItem(${JSON.stringify(`enable-plugin-${vaultId}`)}, 'true');`,\n      returnByValue: true\n    });\n    log(`[cdp-transport] Set enable-plugin-${vaultId} in localStorage.`);\n  }\n\n  /**\n   * Ensures there is an active WebSocket connection to the correct vault target.\n   *\n   * Reuses the existing connection if it targets the requested vault.\n   * Otherwise, finds the correct target and reconnects.\n   *\n   * @param vaultPath - The vault path to target.\n   * @returns The active WebSocket connection.\n   */\n  private async ensureConnection(vaultPath: string): Promise<WebSocket> {\n    if (this.ws?.readyState === WebSocket.OPEN && this.activeVaultPath === vaultPath) {\n      return this.ws;\n    }\n\n    this.disconnect();\n\n    const target = await this.findTargetForVault(vaultPath);\n    this.ws = await this.connectToTarget(target);\n    this.activeVaultPath = vaultPath;\n    return this.ws;\n  }\n\n  /**\n   * Launches Obsidian with `--remote-debugging-port` and polls until CDP becomes available.\n   */\n  private async ensureObsidianRunning(): Promise<void> {\n    log('[cdp-transport] Obsidian CDP not reachable. Starting Obsidian with remote debugging...');\n\n    try {\n      await exec(getObsidianLaunchCommand(this.cdpPort), { isQuiet: true });\n    } catch {\n      // The launch command may fail on some systems \u2014 we'll still try polling.\n    }\n\n    log(`[cdp-transport] Polling for CDP endpoint at ${this.cdpUrl} (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);\n      try {\n        const targets = await this.getPageTargets();\n        if (targets.length > 0) {\n          log(`[cdp-transport] Obsidian CDP ready, ${String(targets.length)} target(s) found.`);\n          return;\n        }\n      } catch {\n        log('[cdp-transport] CDP not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms. Ensure Obsidian is installed and accessible.`);\n  }\n\n  /**\n   * Finds the CDP target that has the given vault open.\n   *\n   * For a single target, returns it directly. For multiple targets,\n   * probes each by evaluating `getBasePath()` to find the match.\n   *\n   * @param vaultPath - The vault path to match.\n   * @returns The matching CDP target.\n   */\n  private async findTargetForVault(vaultPath: string): Promise<CdpTarget> {\n    const targets = await this.getPageTargets();\n\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets found');\n    }\n\n    if (targets.length === 1) {\n      return ensureNonNullable(targets[0]);\n    }\n\n    for (const target of targets) {\n      try {\n        const basePath = await this.probeVaultPath(target);\n        if (basePath === vaultPath) {\n          return target;\n        }\n      } catch {\n        // Not a vault target or not ready.\n      }\n    }\n\n    throw new Error(`No CDP target found for vault: ${vaultPath}`);\n  }\n\n  /**\n   * Fetches the list of page-type targets from the CDP `/json` endpoint.\n   *\n   * @returns The list of page targets.\n   */\n  private async getPageTargets(): Promise<CdpTarget[]> {\n    const response = await fetch(`${this.cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.filter((t) => t.type === 'page');\n  }\n\n  /**\n   * Probes a target to discover which vault path it has open.\n   *\n   * Creates a temporary WebSocket connection, evaluates `getBasePath()`,\n   * and returns the result.\n   *\n   * @param target - The CDP target to probe.\n   * @returns The vault's base path.\n   */\n  private async probeVaultPath(target: CdpTarget): Promise<string> {\n    const ws = await this.connectToTarget(target);\n    try {\n      const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n        expression: 'app.vault.adapter.getBasePath()',\n        returnByValue: true\n      });\n      return String(response.result?.result?.value);\n    } finally {\n      ws.close();\n    }\n  }\n\n  /**\n   * Sends a CDP command over WebSocket and waits for the response.\n   *\n   * @param ws - The WebSocket connection.\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The CDP response.\n   */\n  private async sendCommand(ws: WebSocket, method: string, params: Record<string, unknown>): Promise<CdpResponse> {\n    const id = ++this.messageId;\n\n    return new Promise<CdpResponse>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        ws.removeEventListener('message', handler);\n        reject(new Error(`CDP command timed out after ${String(this.commandTimeoutInMilliseconds)}ms: ${method}`));\n      }, this.commandTimeoutInMilliseconds);\n\n      function handler(event: MessageEvent): void {\n        const msg = JSON.parse(String(event.data)) as CdpResponse;\n        if (msg.id === id) {\n          clearTimeout(timeout);\n          ws.removeEventListener('message', handler);\n          resolve(msg);\n        }\n      }\n\n      ws.addEventListener('message', handler);\n      ws.send(JSON.stringify({ id, method, params }));\n    });\n  }\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Returns the platform-specific command to launch Obsidian with remote debugging enabled.\n *\n * @param port - The CDP port to use.\n * @returns The shell command string.\n */\nfunction getObsidianLaunchCommand(port: number): string {\n  const flag = `--remote-debugging-port=${String(port)}`;\n\n  if (process.platform === 'win32') {\n    const localAppData = process.env['LOCALAPPDATA'] ?? '';\n    return `start \"\" \"${localAppData}\\\\Programs\\\\Obsidian\\\\Obsidian.exe\" ${flag}`;\n  }\n\n  if (process.platform === 'darwin') {\n    return `/Applications/Obsidian.app/Contents/MacOS/Obsidian ${flag} &`;\n  }\n\n  return `obsidian ${flag} &`;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-desktop-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop CDP transport \u2014 evaluates expressions via Chrome DevTools Protocol\n * over WebSocket and manages vaults via Electron IPC.\n *\n * Obsidian exposes CDP on port 8315 by default. This transport connects to\n * page targets, sends `Runtime.evaluate` commands, and routes to the correct\n * vault target using `getBasePath()` probing.\n *\n * Advantages over CLI transport:\n * - No CLI binary installation needed\n * - No \"CLI enabled\" setting required in Obsidian\n * - Lower overhead (WebSocket vs. process spawn per eval)\n *\n * Requirements:\n * - Obsidian must be running with remote debugging enabled (port 8315)\n * - Node.js 22+ (uses built-in `WebSocket` and `fetch` globals)\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport process from 'node:process';\n\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.cjs';\nimport { log } from './log.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport {\n  getVaultId,\n  isVaultRegistered,\n  removeVaultFromConfig\n} from './obsidian-config.cjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\n\n/**\n * Configuration for the CDP transport.\n */\nexport interface DesktopCdpTransportConfig {\n  /**\n   * CDP host. Defaults to `'localhost'`.\n   */\n  cdpHost?: string;\n\n  /**\n   * CDP port. Defaults to `8315`.\n   */\n  cdpPort?: number;\n\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   * Defaults to `30000`.\n   */\n  commandTimeoutInMilliseconds?: number;\n}\n\ninterface CdpExceptionDetails {\n  exception?: CdpExceptionObject;\n  text: string;\n}\n\ninterface CdpExceptionObject {\n  description?: string;\n}\n\ninterface CdpResponse {\n  id: number;\n  result?: CdpResponseResult;\n}\n\ninterface CdpResponseResult {\n  exceptionDetails?: CdpExceptionDetails;\n  result?: CdpValue;\n}\n\ninterface CdpTarget {\n  id: string;\n  title: string;\n  type: string;\n  url: string;\n  webSocketDebuggerUrl: string;\n}\n\ninterface CdpValue {\n  type: string;\n  value?: unknown;\n}\n\nconst CDP_DEFAULT_PORT = 8315;\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 30000;\nconst NO_OUTPUT = '(no output)';\nconst VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1000;\nconst AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst AUTO_START_TIMEOUT_IN_MILLISECONDS = 30000;\n\n/**\n * Transport that communicates with Desktop Obsidian via Chrome DevTools Protocol.\n *\n * Connects to Obsidian's CDP WebSocket endpoint, sends `Runtime.evaluate`\n * commands, and routes expressions to the correct vault target.\n */\nexport class DesktopCdpTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `false` for this transport.\n   */\n  public readonly isMobile = false;\n  private activeVaultPath: null | string = null;\n  private readonly cdpPort: number;\n  private readonly cdpUrl: string;\n  private readonly commandTimeoutInMilliseconds: number;\n  private messageId = 0;\n  private ws: null | WebSocket = null;\n\n  /**\n   * Creates a new CDP transport.\n   *\n   * @param config - CDP connection configuration.\n   */\n  public constructor(config?: DesktopCdpTransportConfig) {\n    const host = config?.cdpHost ?? 'localhost';\n    this.cdpPort = config?.cdpPort ?? CDP_DEFAULT_PORT;\n    this.cdpUrl = `http://${host}:${String(this.cdpPort)}`;\n    this.commandTimeoutInMilliseconds = config?.commandTimeoutInMilliseconds ?? COMMAND_TIMEOUT_IN_MILLISECONDS;\n  }\n\n  /**\n   * Disposes of the active WebSocket connection.\n   */\n  public async dispose(): Promise<void> {\n    this.disconnect();\n    await Promise.resolve();\n  }\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via CDP `Runtime.evaluate`.\n   *\n   * Routes to the correct vault target based on `options.cwd`.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param options - Evaluation options.\n   * @returns The normalized result string.\n   */\n  public async evaluate(expression: string, options: TransportEvalOptions): Promise<string> {\n    const ws = await this.ensureConnection(options.cwd);\n    const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n      awaitPromise: true,\n      expression,\n      returnByValue: true\n    });\n\n    if (response.result?.exceptionDetails) {\n      const desc = response.result.exceptionDetails.exception?.description\n        ?? response.result.exceptionDetails.text;\n      throw new Error(`CDP evaluation error: ${desc}`);\n    }\n\n    const resultObj = response.result?.result;\n    if (!resultObj || resultObj.type === 'undefined') {\n      return NO_OUTPUT;\n    }\n\n    return String(resultObj.value);\n  }\n\n  /**\n   * Verifies that the CDP endpoint is reachable and has Obsidian targets.\n   *\n   * If Obsidian is not running, attempts to auto-start it via URI protocol\n   * and polls until CDP becomes available.\n   *\n   * @param vaultPath - The vault path (used for vault registration check).\n   */\n  public async preflightCheck(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    try {\n      const targets = await this.getPageTargets();\n      if (targets.length === 0) {\n        throw new Error('No page targets');\n      }\n      log(`[cdp-transport] CDP reachable, ${String(targets.length)} target(s) found.`);\n    } catch {\n      await this.ensureObsidianRunning();\n    }\n  }\n\n  /**\n   * Registers a vault via Electron IPC evaluated through CDP.\n   *\n   * Uses an existing Obsidian target to send the `vault-open` IPC command,\n   * then polls until the new vault's target appears.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[cdp-transport] Registering vault: ${vaultPath}`);\n    const targets = await this.getPageTargets();\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets available. Is Obsidian running?');\n    }\n\n    const ipcWs = await this.connectToTarget(ensureNonNullable(targets[0]));\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const ipcExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath, false], channel: 'vault-open' })})`;\n      await this.sendCommand(ipcWs, 'Runtime.evaluate', {\n        awaitPromise: true,\n        expression: ipcExpr,\n        returnByValue: true\n      });\n\n      await this.enablePluginsInLocalStorage(ipcWs, vaultPath);\n    } finally {\n      ipcWs.close();\n    }\n\n    log(`[cdp-transport] Polling for vault target (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        await this.findTargetForVault(vaultPath);\n        log('[cdp-transport] Vault target found.');\n        return;\n      } catch {\n        // Vault target not ready yet.\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n\n  /**\n   * Unregisters a vault by destroying its window and removing it from the registry.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const target = await this.findTargetForVault(vaultPath);\n      const ws = await this.connectToTarget(target);\n      try {\n        const destroyExpr = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: destroyExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } catch {\n      // Window may already be closed.\n    }\n\n    if (this.activeVaultPath === vaultPath) {\n      this.disconnect();\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const targets = await this.getPageTargets();\n    if (targets.length > 0) {\n      const ws = await this.connectToTarget(ensureNonNullable(targets[0]));\n      try {\n        await ensureNamespaceBootstrapped(this, vaultPath);\n        const removeExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath], channel: 'vault-remove' })})`;\n        await this.sendCommand(ws, 'Runtime.evaluate', {\n          awaitPromise: true,\n          expression: removeExpr,\n          returnByValue: true\n        });\n      } finally {\n        ws.close();\n      }\n    } else {\n      log('[cdp-transport] No CDP targets for removal IPC \u2014 removing directly from obsidian.json.');\n      removeVaultFromConfig(vaultPath);\n    }\n  }\n\n  /**\n   * Connects to a CDP target's WebSocket endpoint.\n   *\n   * @param target - The CDP target to connect to.\n   * @returns The open WebSocket connection.\n   */\n  private async connectToTarget(target: CdpTarget): Promise<WebSocket> {\n    const ws = new WebSocket(target.webSocketDebuggerUrl);\n    await new Promise<void>((resolve, reject) => {\n      ws.onopen = (): void => {\n        resolve();\n      };\n      ws.onerror = (): void => {\n        reject(new Error(`Failed to connect to CDP target: ${target.webSocketDebuggerUrl}`));\n      };\n    });\n    return ws;\n  }\n\n  /**\n   * Disconnects the active WebSocket connection.\n   */\n  private disconnect(): void {\n    if (this.ws?.readyState === WebSocket.OPEN) {\n      this.ws.close();\n    }\n    this.ws = null;\n    this.activeVaultPath = null;\n  }\n\n  /**\n   * Sets `enable-plugin-<vaultId>` in Obsidian's localStorage to prevent\n   * the \"Do you trust the author of this vault?\" dialog from appearing\n   * when a vault with community plugins is opened for the first time.\n   *\n   * Must be called after the `vault-open` IPC (so the vault ID exists in\n   * `obsidian.json`) and before the new vault window finishes loading.\n   *\n   * @param ws - An open WebSocket to an existing Obsidian target.\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async enablePluginsInLocalStorage(ws: WebSocket, vaultPath: string): Promise<void> {\n    const vaultId = getVaultId(vaultPath);\n    if (!vaultId) {\n      log('[cdp-transport] Could not find vault ID \u2014 skipping localStorage trust flag.');\n      return;\n    }\n\n    await this.sendCommand(ws, 'Runtime.evaluate', {\n      expression: `localStorage.setItem(${JSON.stringify(`enable-plugin-${vaultId}`)}, 'true');`,\n      returnByValue: true\n    });\n    log(`[cdp-transport] Set enable-plugin-${vaultId} in localStorage.`);\n  }\n\n  /**\n   * Ensures there is an active WebSocket connection to the correct vault target.\n   *\n   * Reuses the existing connection if it targets the requested vault.\n   * Otherwise, finds the correct target and reconnects.\n   *\n   * @param vaultPath - The vault path to target.\n   * @returns The active WebSocket connection.\n   */\n  private async ensureConnection(vaultPath: string): Promise<WebSocket> {\n    if (this.ws?.readyState === WebSocket.OPEN && this.activeVaultPath === vaultPath) {\n      return this.ws;\n    }\n\n    this.disconnect();\n\n    const target = await this.findTargetForVault(vaultPath);\n    this.ws = await this.connectToTarget(target);\n    this.activeVaultPath = vaultPath;\n    return this.ws;\n  }\n\n  /**\n   * Launches Obsidian with `--remote-debugging-port` and polls until CDP becomes available.\n   */\n  private async ensureObsidianRunning(): Promise<void> {\n    log('[cdp-transport] Obsidian CDP not reachable. Starting Obsidian with remote debugging...');\n\n    const launchCommand = await getObsidianLaunchCommand(this.cdpPort);\n    try {\n      await exec(launchCommand, { isQuiet: true });\n    } catch {\n      // The launch command may fail on some systems \u2014 we'll still try polling.\n    }\n\n    log(`[cdp-transport] Polling for CDP endpoint at ${this.cdpUrl} (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);\n      try {\n        const targets = await this.getPageTargets();\n        if (targets.length > 0) {\n          log(`[cdp-transport] Obsidian CDP ready, ${String(targets.length)} target(s) found.`);\n          return;\n        }\n      } catch {\n        log('[cdp-transport] CDP not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms. Ensure Obsidian is installed and accessible.`);\n  }\n\n  /**\n   * Finds the CDP target that has the given vault open.\n   *\n   * For a single target, returns it directly. For multiple targets,\n   * probes each by evaluating `getBasePath()` to find the match.\n   *\n   * @param vaultPath - The vault path to match.\n   * @returns The matching CDP target.\n   */\n  private async findTargetForVault(vaultPath: string): Promise<CdpTarget> {\n    const targets = await this.getPageTargets();\n\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets found');\n    }\n\n    if (targets.length === 1) {\n      return ensureNonNullable(targets[0]);\n    }\n\n    for (const target of targets) {\n      try {\n        const basePath = await this.probeVaultPath(target);\n        if (basePath === vaultPath) {\n          return target;\n        }\n      } catch {\n        // Not a vault target or not ready.\n      }\n    }\n\n    throw new Error(`No CDP target found for vault: ${vaultPath}`);\n  }\n\n  /**\n   * Fetches the list of page-type targets from the CDP `/json` endpoint.\n   *\n   * @returns The list of page targets.\n   */\n  private async getPageTargets(): Promise<CdpTarget[]> {\n    const response = await fetch(`${this.cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.filter((t) => t.type === 'page');\n  }\n\n  /**\n   * Probes a target to discover which vault path it has open.\n   *\n   * Creates a temporary WebSocket connection, evaluates `getBasePath()`,\n   * and returns the result.\n   *\n   * @param target - The CDP target to probe.\n   * @returns The vault's base path.\n   */\n  private async probeVaultPath(target: CdpTarget): Promise<string> {\n    const ws = await this.connectToTarget(target);\n    try {\n      const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n        expression: 'app.vault.adapter.getBasePath()',\n        returnByValue: true\n      });\n      return String(response.result?.result?.value);\n    } finally {\n      ws.close();\n    }\n  }\n\n  /**\n   * Sends a CDP command over WebSocket and waits for the response.\n   *\n   * @param ws - The WebSocket connection.\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The CDP response.\n   */\n  private async sendCommand(ws: WebSocket, method: string, params: Record<string, unknown>): Promise<CdpResponse> {\n    const id = ++this.messageId;\n\n    return new Promise<CdpResponse>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        ws.removeEventListener('message', handler);\n        reject(new Error(`CDP command timed out after ${String(this.commandTimeoutInMilliseconds)}ms: ${method}`));\n      }, this.commandTimeoutInMilliseconds);\n\n      function handler(event: MessageEvent): void {\n        const msg = JSON.parse(String(event.data)) as CdpResponse;\n        if (msg.id === id) {\n          clearTimeout(timeout);\n          ws.removeEventListener('message', handler);\n          resolve(msg);\n        }\n      }\n\n      ws.addEventListener('message', handler);\n      ws.send(JSON.stringify({ id, method, params }));\n    });\n  }\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Returns the platform-specific command to launch Obsidian with remote debugging enabled.\n *\n * Resolves the actual installed Obsidian executable (covering installer-based\n * and `PATH`-based installs such as `scoop`) and verifies it exists before\n * returning a command. Throws if Obsidian is not installed.\n *\n * @param port - The CDP port to use.\n * @returns The shell command string.\n * @throws Error if Obsidian cannot be located.\n */\nasync function getObsidianLaunchCommand(port: number): Promise<string> {\n  const exePath = await resolveObsidianExecutable();\n  const flag = `--remote-debugging-port=${String(port)}`;\n\n  if (process.platform === 'win32') {\n    return `start \"\" \"${exePath}\" ${flag}`;\n  }\n\n  return `\"${exePath}\" ${flag} &`;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}


package/dist/lib/cjs/transport-desktop-cli.cjs

@@ -43,6 +43,7 @@ var import_log = require("./log.cjs");
 var import_namespace_bootstrap = require("./namespace-bootstrap.cjs");
 var import_noop = require("./noop.cjs");
 var import_obsidian_config = require("./obsidian-config.cjs");
+var import_obsidian_executable = require("./obsidian-executable.cjs");
 var import_serialize_error = require("./serialize-error.cjs");
 const UNABLE_TO_FIND_OBSIDIAN = "unable to find Obsidian";
 const AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
@@ -290,8 +291,9 @@ ${diagnostics}`);
    */
   async ensureObsidianRunningAndRetry(command, cwd) {
     (0, import_log.log)("[cli-transport] Obsidian is not running. Starting Obsidian...");
+    const launchCommand = await getObsidianLaunchCommand();
     try {
-      await (0, import_exec.exec)(getObsidianLaunchCommand(), { isQuiet: true });
+      await (0, import_exec.exec)(launchCommand, { isQuiet: true });
     } catch {
     }
     (0, import_log.log)(`[cli-transport] Polling for Obsidian CLI (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);
@@ -455,15 +457,12 @@ function getKillObsidianCommand() {
   }
   return "pkill -f Obsidian";
 }
-function getObsidianLaunchCommand() {
+async function getObsidianLaunchCommand() {
+  const exePath = await (0, import_obsidian_executable.resolveObsidianExecutable)();
   if (import_node_process.default.platform === "win32") {
-    const localAppData = import_node_process.default.env["LOCALAPPDATA"] ?? "";
-    return `start "" "${localAppData}\\Programs\\Obsidian\\Obsidian.exe"`;
+    return `start "" "${exePath}"`;
   }
-  if (import_node_process.default.platform === "darwin") {
-    return "/Applications/Obsidian.app/Contents/MacOS/Obsidian &";
-  }
-  return "obsidian &";
+  return `"${exePath}" &`;
 }
 function getOpenUriCommand(uri) {
   if (import_node_process.default.platform === "win32") {
@@ -505,4 +504,4 @@ async function openVaultViaUri(vaultPath) {
   DesktopCliTransport,
   invokeAndWriteResult
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-desktop-cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop CLI transport \u2014 evaluates expressions via `obsidian eval` and manages\n * vaults via Electron IPC.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport { existsSync } from 'node:fs';\nimport {\n  mkdir,\n  readFile,\n  unlink,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport type { ExecResult } from './exec.cjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.cjs';\nimport { getFunctionExpressionString } from './function-expression.cjs';\nimport { log } from './log.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport { noop } from './noop.cjs';\nimport {\n  enableCliInConfig,\n  getAnyRegisteredVaultPath,\n  getRegisteredVaults,\n  getVaultId,\n  isCliEnabled,\n  isVaultOpen,\n  isVaultRegistered,\n  registerVaultInConfig,\n  removeVaultFromConfig\n} from './obsidian-config.cjs';\nimport { serializeError } from './serialize-error.cjs';\n\ninterface ExecuteScriptFileFsPromises {\n  access(path: string): Promise<void>;\n  readFile(path: string, encoding: string): Promise<string>;\n}\n\ninterface InvokeAndWriteResultFsPromises {\n  writeFile(path: string, data: string): Promise<void>;\n}\n\ninterface InvokeAndWriteResultParams {\n  evaluate(): Promise<unknown>;\n  resultPath: string;\n  serializeError(error: unknown): string;\n}\n\n/**\n * Discriminated envelope written by the temporary script file.\n *\n * - `{ value: string, type: 'error' }` \u2014 the expression threw; `value` is the error message.\n * - `{ value: '', type: 'null' }` \u2014 the expression returned `null`.\n * - `{ value: '', type: 'undefined' }` \u2014 the expression returned `undefined`.\n * - `{ value: string }` \u2014 the expression returned a string value (no `type` field).\n */\ntype ScriptResultEnvelope =\n  | { type: 'error' | 'null' | 'undefined'; value: string }\n  | { value: string };\n\nconst UNABLE_TO_FIND_OBSIDIAN = 'unable to find Obsidian';\nconst AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst AUTO_START_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1000;\nconst VAULT_EVAL_TIMEOUT_IN_MILLISECONDS = 10000;\n\ninterface BuildDiagnosticsParams {\n  command: string[];\n  cwd: string;\n  execResult: ExecResult | undefined;\n  resultPath: string;\n  scriptContent: string;\n  scriptPath: string;\n}\n\n/**\n * Transport that communicates with Desktop Obsidian via the `obsidian eval` CLI command\n * and manages vaults via Electron IPC.\n */\nexport class DesktopCliTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `false` for this transport.\n   */\n  public readonly isMobile = false;\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.\n   *\n   * Writes the expression to a temporary `.cjs` file and executes a tiny\n   * `require().invoke()` call via the CLI. The result is written to a\n   * `.result.json` file by the script, avoiding CLI stdout size limits\n   * and IPC buffer issues.\n   *\n   * Handles auto-start: if Obsidian is not running, launches it via URI protocol\n   * and retries until it becomes available.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param options - Evaluation options.\n   * @returns The normalized result string (transport-specific prefixes stripped).\n   */\n  public async evaluate(expression: string, options: TransportEvalOptions): Promise<string> {\n    const SLICE_START = 2;\n    const scriptId = String(Math.random()).slice(SLICE_START);\n    const scriptDir = join(tmpdir(), 'obsidian-integration-testing');\n    const scriptPath = join(scriptDir, `${scriptId}.js`);\n    const resultPath = join(scriptDir, `${scriptId}.result.json`);\n\n    await mkdir(scriptDir, { recursive: true });\n\n    const scriptContent = buildScriptFile(expression, resultPath);\n    await writeFile(scriptPath, scriptContent);\n\n    try {\n      const safeScriptPath = scriptPath.replace(/\\\\/g, '/');\n      const cliExpr = `(${getFunctionExpressionString(executeScriptFile)})(${JSON.stringify(safeScriptPath)})`;\n      const vaultId = getVaultId(options.cwd);\n      const command = ['obsidian', ...(vaultId ? [`vault=${vaultId}`] : []), 'eval', '--allow-focus-steal', `code=${cliExpr}`];\n\n      let execResult: ExecResult | undefined;\n      try {\n        execResult = await exec(command, {\n          cwd: options.cwd,\n          isQuiet: true,\n          shouldIncludeDetails: true,\n          ...(options.timeoutInMilliseconds !== undefined && { timeoutInMilliseconds: options.timeoutInMilliseconds })\n        });\n      } catch (error) {\n        const message = error instanceof Error ? error.message : String(error);\n        if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n          await this.ensureObsidianRunningAndRetry(command, options.cwd);\n        } else {\n          throw error;\n        }\n      }\n\n      if (!existsSync(resultPath)) {\n        const diagnostics = await buildDiagnostics({\n          command,\n          cwd: options.cwd,\n          execResult,\n          resultPath,\n          scriptContent,\n          scriptPath\n        });\n        throw new Error(`Script did not execute for path: ${options.cwd}\\n${diagnostics}`);\n      }\n\n      const resultStr = await readFile(resultPath, 'utf-8');\n      const envelope = JSON.parse(resultStr) as ScriptResultEnvelope;\n\n      if ('type' in envelope) {\n        if (envelope.type === 'error') {\n          throw new Error(`Script error in Obsidian for path: ${options.cwd}: ${envelope.value}`);\n        }\n        return '';\n      }\n\n      return envelope.value;\n    } finally {\n      await unlink(scriptPath).catch(noop);\n      await unlink(resultPath).catch(noop);\n    }\n  }\n\n  /**\n   * Runs CLI-specific preflight checks.\n   *\n   * Verifies that the vault is registered, CLI is enabled in Obsidian settings,\n   * and the `obsidian` CLI binary is available in PATH. If the vault is registered\n   * but not open, opens it via URI protocol and polls until it is ready.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async preflightCheck(vaultPath: string): Promise<void> {\n    log(`[cli-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    if (!isCliEnabled()) {\n      log('[cli-transport] CLI is disabled in obsidian.json. Enabling and restarting Obsidian...');\n      enableCliInConfig();\n      await this.restartObsidian(vaultPath);\n    }\n\n    await this.assertCliAvailable();\n\n    if (!isVaultOpen(vaultPath)) {\n      log(`[cli-transport] Vault is registered but not open: ${vaultPath}. Opening via URI...`);\n      await openVaultViaUri(vaultPath);\n      await this.pollVaultReady(vaultPath);\n    }\n\n    log('[cli-transport] Preflight check passed.');\n  }\n\n  /**\n   * Registers a vault in the running Obsidian instance via Electron IPC.\n   *\n   * Uses `vault-open` IPC to register and open the vault, then polls until\n   * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[cli-transport] Registering vault: ${vaultPath}`);\n    const existingVaultPath = getAnyRegisteredVaultPath();\n\n    if (existingVaultPath) {\n      await ensureNamespaceBootstrapped(this, existingVaultPath);\n      const registerExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath, false], channel: 'vault-open' })})`;\n      await this.evaluate(registerExpr, { cwd: existingVaultPath });\n      await this.enablePluginsInLocalStorage(vaultPath, existingVaultPath);\n    } else {\n      log('[cli-transport] No existing vault registered. Writing vault entry directly to obsidian.json...');\n      registerVaultInConfig(vaultPath);\n      log('[cli-transport] Vault entry written. Opening vault via URI protocol...');\n      await openVaultViaUri(vaultPath);\n      await this.pollVaultReady(vaultPath);\n      await this.enablePluginsInLocalStorage(vaultPath, vaultPath);\n      await this.dismissTrustDialog(vaultPath);\n      return;\n    }\n\n    await this.pollVaultReady(vaultPath);\n  }\n\n  /**\n   * Unregisters a vault from the running Obsidian instance.\n   *\n   * Schedules the vault window to close, waits, then removes the vault\n   * from the registry via `vault-remove` IPC.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    log(`[cli-transport] Unregistering vault: closing window for ${vaultPath}...`);\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const destroyExpr = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n      await this.evaluate(destroyExpr, { cwd: vaultPath, timeoutInMilliseconds: VAULT_EVAL_TIMEOUT_IN_MILLISECONDS });\n      log('[cli-transport] Window destroy command sent.');\n    } catch (error: unknown) {\n      log(`[cli-transport] Window destroy failed (non-fatal): ${serializeError(error)}`);\n    }\n\n    log('[cli-transport] Waiting for window to close...');\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    log('[cli-transport] Removing vault from registry...');\n    const existingVaultForRemoval = getAnyRegisteredVaultPath();\n    try {\n      if (existingVaultForRemoval) {\n        await ensureNamespaceBootstrapped(this, existingVaultForRemoval);\n        const removeExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath], channel: 'vault-remove' })})`;\n        await this.evaluate(removeExpr, { cwd: existingVaultForRemoval, timeoutInMilliseconds: VAULT_EVAL_TIMEOUT_IN_MILLISECONDS });\n      } else {\n        log('[cli-transport] No existing vault to target for removal IPC \u2014 removing directly from obsidian.json.');\n        removeVaultFromConfig(vaultPath);\n      }\n      log('[cli-transport] Vault removed from registry.');\n    } catch (error: unknown) {\n      log(`[cli-transport] Vault registry removal failed (non-fatal): ${serializeError(error)}`);\n    }\n  }\n\n  /**\n   * Checks whether the Obsidian CLI binary is available in the system PATH.\n   */\n  private async assertCliAvailable(): Promise<void> {\n    const command = process.platform === 'win32' ? 'where.exe obsidian' : '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   * Dismisses the \"Do you trust the author of this vault?\" dialog if present.\n   *\n   * Clicks the \"Trust author and enable plugins\" button (`.mod-cta`) inside any\n   * modal whose text includes \"Do you trust the author\". This is needed when a\n   * vault with community plugins is opened without a prior `enable-plugin-<id>`\n   * entry in localStorage (e.g., the very first vault registered via config file).\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async dismissTrustDialog(vaultPath: string): Promise<void> {\n    await ensureNamespaceBootstrapped(this, vaultPath);\n    const dismissExpr = `(function() {\n      var modals = document.querySelectorAll('.modal-container');\n      for (var i = 0; i < modals.length; i++) {\n        if (modals[i].textContent.includes('Do you trust the author')) {\n          var btn = modals[i].querySelector('.mod-cta');\n          if (btn) { btn.click(); return true; }\n        }\n      }\n      return false;\n    })()`;\n    const result = await this.evaluate(dismissExpr, { cwd: vaultPath });\n    if (result === 'true') {\n      log('[cli-transport] Dismissed \"Do you trust the author\" dialog.');\n    }\n  }\n\n  /**\n   * Sets `enable-plugin-<vaultId>` in Obsidian's localStorage to prevent\n   * the \"Do you trust the author of this vault?\" dialog from appearing\n   * when a vault with community plugins is opened for the first time.\n   *\n   * Must be called after the `vault-open` IPC (so the vault ID exists in\n   * `obsidian.json`) and before the new vault window finishes loading.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   * @param evalTargetVaultPath - The vault path to use as eval target (an existing, loaded vault).\n   *   localStorage is shared across all Obsidian windows (same Electron origin), so the\n   *   `localStorage.setItem` call can run in any loaded vault window.\n   */\n  private async enablePluginsInLocalStorage(vaultPath: string, evalTargetVaultPath: string): Promise<void> {\n    const vaultId = getVaultId(vaultPath);\n    if (!vaultId) {\n      log('[cli-transport] Could not find vault ID \u2014 skipping localStorage trust flag.');\n      return;\n    }\n\n    await ensureNamespaceBootstrapped(this, evalTargetVaultPath);\n    const enableExpr = `window.__obsidianIntegrationTesting.setLocalStorageItem(${JSON.stringify({ key: `enable-plugin-${vaultId}`, value: 'true' })})`;\n    await this.evaluate(enableExpr, { cwd: evalTargetVaultPath });\n    log(`[cli-transport] Set enable-plugin-${vaultId} in localStorage.`);\n  }\n\n  /**\n   * Launches Obsidian binary and retries the eval until it responds.\n   *\n   * @param command - The CLI command array to retry.\n   * @param cwd - The working directory.\n   */\n  private async ensureObsidianRunningAndRetry(command: string[], cwd: string): Promise<void> {\n    log('[cli-transport] Obsidian is not running. Starting Obsidian...');\n\n    try {\n      await exec(getObsidianLaunchCommand(), { isQuiet: true });\n    } catch {\n      // The launch command may fail on some systems \u2014 we'll still try polling.\n    }\n\n    log(`[cli-transport] Polling for Obsidian CLI (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);\n      try {\n        await exec(command, { cwd, isQuiet: true });\n        log('[cli-transport] Obsidian CLI responded.');\n        return;\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        log('[cli-transport] Obsidian not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);\n  }\n\n  /**\n   * Polls until the vault is ready and responding to eval calls.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async pollVaultReady(vaultPath: string): Promise<void> {\n    const pollExpr = 'window.__obsidianIntegrationTesting.pollVaultBasePath()';\n\n    log(`[cli-transport] Polling for vault readiness (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    let isBootstrapped = false;\n    while (Date.now() < deadline) {\n      try {\n        if (!isBootstrapped) {\n          await ensureNamespaceBootstrapped(this, vaultPath);\n          isBootstrapped = true;\n        }\n        const basePath = await this.evaluate(pollExpr, { cwd: vaultPath });\n        if (JSON.parse(basePath) === vaultPath) {\n          log('[cli-transport] Vault is ready.');\n          return;\n        }\n      } catch {\n        // Vault not ready yet \u2014 namespace may not be bootstrapped yet either.\n        isBootstrapped = false;\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n\n  /**\n   * Restarts Obsidian by killing the running process and relaunching it.\n   *\n   * Used when a config change (like enabling CLI) requires a restart to take effect.\n   *\n   * @param vaultPath - The vault path to use for polling after restart.\n   */\n  private async restartObsidian(vaultPath: string): Promise<void> {\n    log('[cli-transport] Killing Obsidian process...');\n    try {\n      await exec(getKillObsidianCommand(), { isQuiet: true });\n    } catch {\n      // Process may not be running \u2014 that's fine.\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const restartVaultId = getVaultId(vaultPath);\n    const command = ['obsidian', ...(restartVaultId ? [`vault=${restartVaultId}`] : []), 'eval', 'code=\"1\"'];\n    await this.ensureObsidianRunningAndRetry(command, vaultPath);\n  }\n}\n\n/**\n * Evaluates an expression, writes the result to a JSON file.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param params - The invocation parameters.\n */\nexport async function invokeAndWriteResult(params: InvokeAndWriteResultParams): Promise<void> {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- window.app is set by Obsidian at runtime.\n  const fsPromises = Reflect.get(window.app.vault.adapter, 'fsPromises') as InvokeAndWriteResultFsPromises;\n  try {\n    const result = await params.evaluate();\n    if (result === undefined) {\n      await fsPromises.writeFile(params.resultPath, JSON.stringify({ type: 'undefined', value: '' }));\n    } else if (result === null) {\n      await fsPromises.writeFile(params.resultPath, JSON.stringify({ type: 'null', value: '' }));\n    } else {\n      // eslint-disable-next-line @typescript-eslint/no-base-to-string -- Intentional: result is an arbitrary value from the evaluated expression.\n      await fsPromises.writeFile(params.resultPath, JSON.stringify({ value: String(result) }));\n    }\n  } catch (err) {\n    await fsPromises.writeFile(params.resultPath, JSON.stringify({ type: 'error', value: params.serializeError(err) }));\n  }\n}\n\n/**\n * Builds a detailed diagnostic string for the \"Script did not execute\" error.\n *\n * Performs live environment checks (process list, vault registry, CLI config)\n * and includes the command, exec output, and script content.\n *\n * @param params - The diagnostic parameters.\n * @returns A formatted diagnostic string.\n */\nasync function buildDiagnostics(params: BuildDiagnosticsParams): Promise<string> {\n  const lines: string[] = [];\n\n  lines.push(`  Command: ${params.command.join(' ')}`);\n  lines.push(`  Working directory: ${params.cwd}`);\n  lines.push(`  Script path: ${params.scriptPath}`);\n  lines.push(`  Expected result file: ${params.resultPath}`);\n\n  if (params.execResult) {\n    lines.push(`  Exit code: ${params.execResult.exitCode === null ? '(null \u2014 process did not exit normally)' : String(params.execResult.exitCode)}`);\n    if (params.execResult.exitSignal) {\n      lines.push(`  Exit signal: ${params.execResult.exitSignal}`);\n    }\n    if (params.execResult.stdout.trim()) {\n      lines.push(`  stdout: ${params.execResult.stdout.trim()}`);\n    }\n    if (params.execResult.stderr.trim()) {\n      lines.push(`  stderr: ${params.execResult.stderr.trim()}`);\n    }\n    if (!params.execResult.stdout.trim() && !params.execResult.stderr.trim()) {\n      lines.push('  stdout/stderr: (empty)');\n    }\n  } else {\n    lines.push('  exec result: (not available \u2014 Obsidian was auto-started and retried)');\n  }\n\n  lines.push('Environment checks:');\n  lines.push(`  Obsidian running: ${await isObsidianRunning() ? 'yes' : 'NO'}`);\n  lines.push(`  CLI enabled in obsidian.json: ${isCliEnabled() ? 'yes' : 'NO'}`);\n  lines.push(`  Vault registered: ${isVaultRegistered(params.cwd) ? 'yes' : 'NO'}`);\n  lines.push(`  Script file exists: ${existsSync(params.scriptPath) ? 'yes' : 'no (already cleaned up)'}`);\n  lines.push(`  Result file exists: ${existsSync(params.resultPath) ? 'yes' : 'no'}`);\n\n  const registeredVaults = getRegisteredVaults();\n  if (registeredVaults.length === 0) {\n    lines.push('  Registered vaults: (none)');\n  } else {\n    lines.push('  Registered vaults:');\n    for (const vault of registeredVaults) {\n      lines.push(`    - ${vault.path} (open: ${String(vault.open)})`);\n    }\n  }\n\n  lines.push(`  Script content:\\n${params.scriptContent}`);\n\n  return lines.join('\\n');\n}\n\n/**\n * Builds the content of a temporary script file.\n *\n * Serializes {@link invokeAndWriteResult} into a self-contained IIFE that\n * evaluates the expression, writes the result (or error) to `resultPath`.\n *\n * @param expression - The JavaScript expression to evaluate.\n * @param resultPath - The absolute path to the result file.\n * @returns The script file content.\n */\nfunction buildScriptFile(expression: string, resultPath: string): string {\n  const fnStr = getFunctionExpressionString(invokeAndWriteResult);\n  const serializeErrorStr = getFunctionExpressionString(serializeError);\n  const resultPathJson = JSON.stringify(resultPath.replace(/\\\\/g, '/'));\n  return `(${fnStr})({ evaluate: async () => (${expression}), resultPath: ${resultPathJson}, serializeError: ${serializeErrorStr} })`;\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Reads a script file from disk, logs its content, and executes it via `new Function`.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param scriptPath - The absolute path to the script file.\n */\nasync function executeScriptFile(scriptPath: string): Promise<void> {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- window.app is set by Obsidian at runtime.\n  const fsPromises = Reflect.get(window.app.vault.adapter, 'fsPromises') as ExecuteScriptFileFsPromises;\n\n  try {\n    await fsPromises.access(scriptPath);\n  } catch (cause) {\n    throw new Error(`Script file not found: ${scriptPath}`, { cause });\n  }\n\n  const script = await fsPromises.readFile(scriptPath, 'utf-8');\n  // eslint-disable-next-line no-console -- Diagnostic logging inside Obsidian process; no logger available.\n  console.debug(`Executing ${scriptPath}:\\n${script}`);\n\n  let fn: () => Promise<void>;\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func -- The script is a trusted, self-generated IIFE expression.\n    fn = new Function(`return ${script}`) as () => Promise<void>;\n  } catch (cause) {\n    throw new Error(`Error parsing ${scriptPath}`, { cause });\n  }\n\n  try {\n    await fn();\n  } catch (cause) {\n    throw new Error(`Error executing ${scriptPath}`, { cause });\n  }\n}\n\n/**\n * Returns the platform-specific command to kill the Obsidian process.\n *\n * @returns The shell command string.\n */\nfunction getKillObsidianCommand(): string {\n  if (process.platform === 'win32') {\n    return 'taskkill /IM Obsidian.exe /F';\n  }\n\n  return 'pkill -f Obsidian';\n}\n\n/**\n * Returns the platform-specific command to launch the Obsidian binary.\n *\n * @returns The shell command string.\n */\nfunction getObsidianLaunchCommand(): string {\n  if (process.platform === 'win32') {\n    const localAppData = process.env['LOCALAPPDATA'] ?? '';\n    return `start \"\" \"${localAppData}\\\\Programs\\\\Obsidian\\\\Obsidian.exe\"`;\n  }\n\n  if (process.platform === 'darwin') {\n    return '/Applications/Obsidian.app/Contents/MacOS/Obsidian &';\n  }\n\n  return 'obsidian &';\n}\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\n/**\n * Checks whether the Obsidian process is currently running.\n *\n * @returns `true` if the Obsidian process is found, `false` otherwise.\n */\nasync function isObsidianRunning(): Promise<boolean> {\n  const command = process.platform === 'win32'\n    ? 'tasklist /FI \"IMAGENAME eq Obsidian.exe\" /NH'\n    : 'pgrep -f Obsidian';\n  try {\n    const output = await exec(command, { isQuiet: true });\n    if (process.platform === 'win32') {\n      return output.includes('Obsidian.exe');\n    }\n    return output.trim().length > 0;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Opens a vault in Obsidian using the `obsidian://open` URI protocol.\n *\n * This works whether Obsidian is already running (signals it to open the vault)\n * or not (launches Obsidian with the vault). The URI protocol is handled by the\n * OS, which routes it to the registered Obsidian handler.\n *\n * @param vaultPath - The absolute path to the vault folder.\n */\nasync function openVaultViaUri(vaultPath: string): Promise<void> {\n  const vaultId = getVaultId(vaultPath);\n  if (!vaultId) {\n    throw new Error(`Cannot open vault via URI: vault is not registered in obsidian.json: ${vaultPath}`);\n  }\n  const uri = `obsidian://open?vault=${encodeURIComponent(vaultId)}`;\n  const command = getOpenUriCommand(uri);\n  log(`[cli-transport] Opening vault via URI: ${uri}`);\n  try {\n    await exec(command, { isQuiet: true });\n  } catch (error: unknown) {\n    log(`[cli-transport] URI open failed (non-fatal): ${serializeError(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASA,qBAA2B;AAC3B,sBAKO;AACP,qBAAuB;AACvB,uBAAqB;AACrB,0BAAoB;AAQpB,kBAAqB;AACrB,iCAA4C;AAC5C,iBAAoB;AACpB,iCAA4C;AAC5C,kBAAqB;AACrB,6BAUO;AACP,6BAA+B;AA6B/B,MAAM,0BAA0B;AAChC,MAAM,2CAA2C;AACjD,MAAM,qCAAqC;AAC3C,MAAM,sCAAsC;AAC5C,MAAM,qCAAqC;AAC3C,MAAM,oCAAoC;AAC1C,MAAM,qCAAqC;AAepC,MAAM,oBAAiD;AAAA;AAAA;AAAA;AAAA,EAI5C,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiB3B,MAAa,SAAS,YAAoB,SAAgD;AACxF,UAAM,cAAc;AACpB,UAAM,WAAW,OAAO,KAAK,OAAO,CAAC,EAAE,MAAM,WAAW;AACxD,UAAM,gBAAY,2BAAK,uBAAO,GAAG,8BAA8B;AAC/D,UAAM,iBAAa,uBAAK,WAAW,GAAG,QAAQ,KAAK;AACnD,UAAM,iBAAa,uBAAK,WAAW,GAAG,QAAQ,cAAc;AAE5D,cAAM,uBAAM,WAAW,EAAE,WAAW,KAAK,CAAC;AAE1C,UAAM,gBAAgB,gBAAgB,YAAY,UAAU;AAC5D,cAAM,2BAAU,YAAY,aAAa;AAEzC,QAAI;AACF,YAAM,iBAAiB,WAAW,QAAQ,OAAO,GAAG;AACpD,YAAM,UAAU,QAAI,wDAA4B,iBAAiB,CAAC,KAAK,KAAK,UAAU,cAAc,CAAC;AACrG,YAAM,cAAU,mCAAW,QAAQ,GAAG;AACtC,YAAM,UAAU,CAAC,YAAY,GAAI,UAAU,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,GAAI,QAAQ,uBAAuB,QAAQ,OAAO,EAAE;AAEvH,UAAI;AACJ,UAAI;AACF,qBAAa,UAAM,kBAAK,SAAS;AAAA,UAC/B,KAAK,QAAQ;AAAA,UACb,SAAS;AAAA,UACT,sBAAsB;AAAA,UACtB,GAAI,QAAQ,0BAA0B,UAAa,EAAE,uBAAuB,QAAQ,sBAAsB;AAAA,QAC5G,CAAC;AAAA,MACH,SAAS,OAAO;AACd,cAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,YAAI,QAAQ,SAAS,uBAAuB,GAAG;AAC7C,gBAAM,KAAK,8BAA8B,SAAS,QAAQ,GAAG;AAAA,QAC/D,OAAO;AACL,gBAAM;AAAA,QACR;AAAA,MACF;AAEA,UAAI,KAAC,2BAAW,UAAU,GAAG;AAC3B,cAAM,cAAc,MAAM,iBAAiB;AAAA,UACzC;AAAA,UACA,KAAK,QAAQ;AAAA,UACb;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AACD,cAAM,IAAI,MAAM,oCAAoC,QAAQ,GAAG;AAAA,EAAK,WAAW,EAAE;AAAA,MACnF;AAEA,YAAM,YAAY,UAAM,0BAAS,YAAY,OAAO;AACpD,YAAM,WAAW,KAAK,MAAM,SAAS;AAErC,UAAI,UAAU,UAAU;AACtB,YAAI,SAAS,SAAS,SAAS;AAC7B,gBAAM,IAAI,MAAM,sCAAsC,QAAQ,GAAG,KAAK,SAAS,KAAK,EAAE;AAAA,QACxF;AACA,eAAO;AAAA,MACT;AAEA,aAAO,SAAS;AAAA,IAClB,UAAE;AACA,gBAAM,wBAAO,UAAU,EAAE,MAAM,gBAAI;AACnC,gBAAM,wBAAO,UAAU,EAAE,MAAM,gBAAI;AAAA,IACrC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,MAAa,eAAe,WAAkC;AAC5D,wBAAI,sDAAsD,SAAS,EAAE;AACrE,QAAI,KAAC,0CAAkB,SAAS,GAAG;AACjC,YAAM,IAAI;AAAA,QACR,wCAAwC,SAAS;AAAA,MACnD;AAAA,IACF;AAEA,QAAI,KAAC,qCAAa,GAAG;AACnB,0BAAI,uFAAuF;AAC3F,oDAAkB;AAClB,YAAM,KAAK,gBAAgB,SAAS;AAAA,IACtC;AAEA,UAAM,KAAK,mBAAmB;AAE9B,QAAI,KAAC,oCAAY,SAAS,GAAG;AAC3B,0BAAI,qDAAqD,SAAS,sBAAsB;AACxF,YAAM,gBAAgB,SAAS;AAC/B,YAAM,KAAK,eAAe,SAAS;AAAA,IACrC;AAEA,wBAAI,yCAAyC;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAa,cAAc,WAAkC;AAC3D,wBAAI,sCAAsC,SAAS,EAAE;AACrD,UAAM,wBAAoB,kDAA0B;AAEpD,QAAI,mBAAmB;AACrB,gBAAM,wDAA4B,MAAM,iBAAiB;AACzD,YAAM,eAAe,mDAAmD,KAAK,UAAU,EAAE,MAAM,CAAC,WAAW,KAAK,GAAG,SAAS,aAAa,CAAC,CAAC;AAC3I,YAAM,KAAK,SAAS,cAAc,EAAE,KAAK,kBAAkB,CAAC;AAC5D,YAAM,KAAK,4BAA4B,WAAW,iBAAiB;AAAA,IACrE,OAAO;AACL,0BAAI,gGAAgG;AACpG,wDAAsB,SAAS;AAC/B,0BAAI,wEAAwE;AAC5E,YAAM,gBAAgB,SAAS;AAC/B,YAAM,KAAK,eAAe,SAAS;AACnC,YAAM,KAAK,4BAA4B,WAAW,SAAS;AAC3D,YAAM,KAAK,mBAAmB,SAAS;AACvC;AAAA,IACF;AAEA,UAAM,KAAK,eAAe,SAAS;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAa,gBAAgB,WAAkC;AAC7D,wBAAI,2DAA2D,SAAS,KAAK;AAC7E,QAAI;AACF,gBAAM,wDAA4B,MAAM,SAAS;AACjD,YAAM,cAAc;AACpB,YAAM,KAAK,SAAS,aAAa,EAAE,KAAK,WAAW,uBAAuB,mCAAmC,CAAC;AAC9G,0BAAI,8CAA8C;AAAA,IACpD,SAAS,OAAgB;AACvB,0BAAI,0DAAsD,uCAAe,KAAK,CAAC,EAAE;AAAA,IACnF;AAEA,wBAAI,gDAAgD;AACpD,UAAM,MAAM,iCAAiC;AAE7C,wBAAI,iDAAiD;AACrD,UAAM,8BAA0B,kDAA0B;AAC1D,QAAI;AACF,UAAI,yBAAyB;AAC3B,kBAAM,wDAA4B,MAAM,uBAAuB;AAC/D,cAAM,aAAa,mDAAmD,KAAK,UAAU,EAAE,MAAM,CAAC,SAAS,GAAG,SAAS,eAAe,CAAC,CAAC;AACpI,cAAM,KAAK,SAAS,YAAY,EAAE,KAAK,yBAAyB,uBAAuB,mCAAmC,CAAC;AAAA,MAC7H,OAAO;AACL,4BAAI,0GAAqG;AACzG,0DAAsB,SAAS;AAAA,MACjC;AACA,0BAAI,8CAA8C;AAAA,IACpD,SAAS,OAAgB;AACvB,0BAAI,kEAA8D,uCAAe,KAAK,CAAC,EAAE;AAAA,IAC3F;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAc,qBAAoC;AAChD,UAAM,UAAU,oBAAAA,QAAQ,aAAa,UAAU,uBAAuB;AACtE,QAAI;AACF,gBAAM,kBAAK,SAAS,EAAE,SAAS,KAAK,CAAC;AAAA,IACvC,QAAQ;AACN,YAAM,IAAI,MAAM,0FAA0F;AAAA,IAC5G;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAc,mBAAmB,WAAkC;AACjE,cAAM,wDAA4B,MAAM,SAAS;AACjD,UAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUpB,UAAM,SAAS,MAAM,KAAK,SAAS,aAAa,EAAE,KAAK,UAAU,CAAC;AAClE,QAAI,WAAW,QAAQ;AACrB,0BAAI,6DAA6D;AAAA,IACnE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,MAAc,4BAA4B,WAAmB,qBAA4C;AACvG,UAAM,cAAU,mCAAW,SAAS;AACpC,QAAI,CAAC,SAAS;AACZ,0BAAI,kFAA6E;AACjF;AAAA,IACF;AAEA,cAAM,wDAA4B,MAAM,mBAAmB;AAC3D,UAAM,aAAa,2DAA2D,KAAK,UAAU,EAAE,KAAK,iBAAiB,OAAO,IAAI,OAAO,OAAO,CAAC,CAAC;AAChJ,UAAM,KAAK,SAAS,YAAY,EAAE,KAAK,oBAAoB,CAAC;AAC5D,wBAAI,qCAAqC,OAAO,mBAAmB;AAAA,EACrE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAc,8BAA8B,SAAmB,KAA4B;AACzF,wBAAI,+DAA+D;AAEnE,QAAI;AACF,gBAAM,kBAAK,yBAAyB,GAAG,EAAE,SAAS,KAAK,CAAC;AAAA,IAC1D,QAAQ;AAAA,IAER;AAEA,wBAAI,qDAAqD,OAAO,kCAAkC,CAAC,QAAQ;AAC3G,UAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,YAAM,MAAM,wCAAwC;AACpD,UAAI;AACF,kBAAM,kBAAK,SAAS,EAAE,KAAK,SAAS,KAAK,CAAC;AAC1C,4BAAI,yCAAyC;AAC7C;AAAA,MACF,SAAS,OAAO;AACd,cAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AACrE,YAAI,CAAC,QAAQ,SAAS,uBAAuB,GAAG;AAC9C,gBAAM;AAAA,QACR;AACA,4BAAI,qDAAqD;AAAA,MAC3D;AAAA,IACF;AAEA,UAAM,IAAI,MAAM,iCAAiC,OAAO,kCAAkC,CAAC,KAAK;AAAA,EAClG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAc,eAAe,WAAkC;AAC7D,UAAM,WAAW;AAEjB,wBAAI,wDAAwD,OAAO,kCAAkC,CAAC,QAAQ;AAC9G,UAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,QAAI,iBAAiB;AACrB,WAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,UAAI;AACF,YAAI,CAAC,gBAAgB;AACnB,oBAAM,wDAA4B,MAAM,SAAS;AACjD,2BAAiB;AAAA,QACnB;AACA,cAAM,WAAW,MAAM,KAAK,SAAS,UAAU,EAAE,KAAK,UAAU,CAAC;AACjE,YAAI,KAAK,MAAM,QAAQ,MAAM,WAAW;AACtC,8BAAI,iCAAiC;AACrC;AAAA,QACF;AAAA,MACF,QAAQ;AAEN,yBAAiB;AAAA,MACnB;AACA,YAAM,MAAM,mCAAmC;AAAA,IACjD;AACA,UAAM,IAAI,MAAM,YAAY,SAAS,gCAAgC,OAAO,kCAAkC,CAAC,IAAI;AAAA,EACrH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAc,gBAAgB,WAAkC;AAC9D,wBAAI,6CAA6C;AACjD,QAAI;AACF,gBAAM,kBAAK,uBAAuB,GAAG,EAAE,SAAS,KAAK,CAAC;AAAA,IACxD,QAAQ;AAAA,IAER;AAEA,UAAM,MAAM,iCAAiC;AAE7C,UAAM,qBAAiB,mCAAW,SAAS;AAC3C,UAAM,UAAU,CAAC,YAAY,GAAI,iBAAiB,CAAC,SAAS,cAAc,EAAE,IAAI,CAAC,GAAI,QAAQ,UAAU;AACvG,UAAM,KAAK,8BAA8B,SAAS,SAAS;AAAA,EAC7D;AACF;AAUA,eAAsB,qBAAqB,QAAmD;AAE5F,QAAM,aAAa,QAAQ,IAAI,OAAO,IAAI,MAAM,SAAS,YAAY;AACrE,MAAI;AACF,UAAM,SAAS,MAAM,OAAO,SAAS;AACrC,QAAI,WAAW,QAAW;AACxB,YAAM,WAAW,UAAU,OAAO,YAAY,KAAK,UAAU,EAAE,MAAM,aAAa,OAAO,GAAG,CAAC,CAAC;AAAA,IAChG,WAAW,WAAW,MAAM;AAC1B,YAAM,WAAW,UAAU,OAAO,YAAY,KAAK,UAAU,EAAE,MAAM,QAAQ,OAAO,GAAG,CAAC,CAAC;AAAA,IAC3F,OAAO;AAEL,YAAM,WAAW,UAAU,OAAO,YAAY,KAAK,UAAU,EAAE,OAAO,OAAO,MAAM,EAAE,CAAC,CAAC;AAAA,IACzF;AAAA,EACF,SAAS,KAAK;AACZ,UAAM,WAAW,UAAU,OAAO,YAAY,KAAK,UAAU,EAAE,MAAM,SAAS,OAAO,OAAO,eAAe,GAAG,EAAE,CAAC,CAAC;AAAA,EACpH;AACF;AAWA,eAAe,iBAAiB,QAAiD;AAC/E,QAAM,QAAkB,CAAC;AAEzB,QAAM,KAAK,cAAc,OAAO,QAAQ,KAAK,GAAG,CAAC,EAAE;AACnD,QAAM,KAAK,wBAAwB,OAAO,GAAG,EAAE;AAC/C,QAAM,KAAK,kBAAkB,OAAO,UAAU,EAAE;AAChD,QAAM,KAAK,2BAA2B,OAAO,UAAU,EAAE;AAEzD,MAAI,OAAO,YAAY;AACrB,UAAM,KAAK,gBAAgB,OAAO,WAAW,aAAa,OAAO,gDAA2C,OAAO,OAAO,WAAW,QAAQ,CAAC,EAAE;AAChJ,QAAI,OAAO,WAAW,YAAY;AAChC,YAAM,KAAK,kBAAkB,OAAO,WAAW,UAAU,EAAE;AAAA,IAC7D;AACA,QAAI,OAAO,WAAW,OAAO,KAAK,GAAG;AACnC,YAAM,KAAK,aAAa,OAAO,WAAW,OAAO,KAAK,CAAC,EAAE;AAAA,IAC3D;AACA,QAAI,OAAO,WAAW,OAAO,KAAK,GAAG;AACnC,YAAM,KAAK,aAAa,OAAO,WAAW,OAAO,KAAK,CAAC,EAAE;AAAA,IAC3D;AACA,QAAI,CAAC,OAAO,WAAW,OAAO,KAAK,KAAK,CAAC,OAAO,WAAW,OAAO,KAAK,GAAG;AACxE,YAAM,KAAK,0BAA0B;AAAA,IACvC;AAAA,EACF,OAAO;AACL,UAAM,KAAK,6EAAwE;AAAA,EACrF;AAEA,QAAM,KAAK,qBAAqB;AAChC,QAAM,KAAK,uBAAuB,MAAM,kBAAkB,IAAI,QAAQ,IAAI,EAAE;AAC5E,QAAM,KAAK,uCAAmC,qCAAa,IAAI,QAAQ,IAAI,EAAE;AAC7E,QAAM,KAAK,2BAAuB,0CAAkB,OAAO,GAAG,IAAI,QAAQ,IAAI,EAAE;AAChF,QAAM,KAAK,6BAAyB,2BAAW,OAAO,UAAU,IAAI,QAAQ,yBAAyB,EAAE;AACvG,QAAM,KAAK,6BAAyB,2BAAW,OAAO,UAAU,IAAI,QAAQ,IAAI,EAAE;AAElF,QAAM,uBAAmB,4CAAoB;AAC7C,MAAI,iBAAiB,WAAW,GAAG;AACjC,UAAM,KAAK,6BAA6B;AAAA,EAC1C,OAAO;AACL,UAAM,KAAK,sBAAsB;AACjC,eAAW,SAAS,kBAAkB;AACpC,YAAM,KAAK,SAAS,MAAM,IAAI,WAAW,OAAO,MAAM,IAAI,CAAC,GAAG;AAAA,IAChE;AAAA,EACF;AAEA,QAAM,KAAK;AAAA,EAAsB,OAAO,aAAa,EAAE;AAEvD,SAAO,MAAM,KAAK,IAAI;AACxB;AAYA,SAAS,gBAAgB,YAAoB,YAA4B;AACvE,QAAM,YAAQ,wDAA4B,oBAAoB;AAC9D,QAAM,wBAAoB,wDAA4B,qCAAc;AACpE,QAAM,iBAAiB,KAAK,UAAU,WAAW,QAAQ,OAAO,GAAG,CAAC;AACpE,SAAO,IAAI,KAAK,8BAA8B,UAAU,kBAAkB,cAAc,qBAAqB,iBAAiB;AAChI;AAQA,SAAS,MAAM,IAA2B;AACxC,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,eAAW,SAAS,EAAE;AAAA,EACxB,CAAC;AACH;AAUA,eAAe,kBAAkB,YAAmC;AAElE,QAAM,aAAa,QAAQ,IAAI,OAAO,IAAI,MAAM,SAAS,YAAY;AAErE,MAAI;AACF,UAAM,WAAW,OAAO,UAAU;AAAA,EACpC,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,0BAA0B,UAAU,IAAI,EAAE,MAAM,CAAC;AAAA,EACnE;AAEA,QAAM,SAAS,MAAM,WAAW,SAAS,YAAY,OAAO;AAE5D,UAAQ,MAAM,aAAa,UAAU;AAAA,EAAM,MAAM,EAAE;AAEnD,MAAI;AACJ,MAAI;AAEF,SAAK,IAAI,SAAS,UAAU,MAAM,EAAE;AAAA,EACtC,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,iBAAiB,UAAU,IAAI,EAAE,MAAM,CAAC;AAAA,EAC1D;AAEA,MAAI;AACF,UAAM,GAAG;AAAA,EACX,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,mBAAmB,UAAU,IAAI,EAAE,MAAM,CAAC;AAAA,EAC5D;AACF;AAOA,SAAS,yBAAiC;AACxC,MAAI,oBAAAA,QAAQ,aAAa,SAAS;AAChC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAOA,SAAS,2BAAmC;AAC1C,MAAI,oBAAAA,QAAQ,aAAa,SAAS;AAChC,UAAM,eAAe,oBAAAA,QAAQ,IAAI,cAAc,KAAK;AACpD,WAAO,aAAa,YAAY;AAAA,EAClC;AAEA,MAAI,oBAAAA,QAAQ,aAAa,UAAU;AACjC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAQA,SAAS,kBAAkB,KAAqB;AAC9C,MAAI,oBAAAA,QAAQ,aAAa,SAAS;AAChC,WAAO,aAAa,GAAG;AAAA,EACzB;AAEA,MAAI,oBAAAA,QAAQ,aAAa,UAAU;AACjC,WAAO,SAAS,GAAG;AAAA,EACrB;AAEA,SAAO,aAAa,GAAG;AACzB;AAOA,eAAe,oBAAsC;AACnD,QAAM,UAAU,oBAAAA,QAAQ,aAAa,UACjC,iDACA;AACJ,MAAI;AACF,UAAM,SAAS,UAAM,kBAAK,SAAS,EAAE,SAAS,KAAK,CAAC;AACpD,QAAI,oBAAAA,QAAQ,aAAa,SAAS;AAChC,aAAO,OAAO,SAAS,cAAc;AAAA,IACvC;AACA,WAAO,OAAO,KAAK,EAAE,SAAS;AAAA,EAChC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAWA,eAAe,gBAAgB,WAAkC;AAC/D,QAAM,cAAU,mCAAW,SAAS;AACpC,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,wEAAwE,SAAS,EAAE;AAAA,EACrG;AACA,QAAM,MAAM,yBAAyB,mBAAmB,OAAO,CAAC;AAChE,QAAM,UAAU,kBAAkB,GAAG;AACrC,sBAAI,0CAA0C,GAAG,EAAE;AACnD,MAAI;AACF,cAAM,kBAAK,SAAS,EAAE,SAAS,KAAK,CAAC;AAAA,EACvC,SAAS,OAAgB;AACvB,wBAAI,oDAAgD,uCAAe,KAAK,CAAC,EAAE;AAAA,EAC7E;AACF;",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-desktop-cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop CLI transport \u2014 evaluates expressions via `obsidian eval` and manages\n * vaults via Electron IPC.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport { existsSync } from 'node:fs';\nimport {\n  mkdir,\n  readFile,\n  unlink,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport type { ExecResult } from './exec.cjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.cjs';\nimport { getFunctionExpressionString } from './function-expression.cjs';\nimport { log } from './log.cjs';\nimport { ensureNamespaceBootstrapped } from './namespace-bootstrap.cjs';\nimport { noop } from './noop.cjs';\nimport {\n  enableCliInConfig,\n  getAnyRegisteredVaultPath,\n  getRegisteredVaults,\n  getVaultId,\n  isCliEnabled,\n  isVaultOpen,\n  isVaultRegistered,\n  registerVaultInConfig,\n  removeVaultFromConfig\n} from './obsidian-config.cjs';\nimport { resolveObsidianExecutable } from './obsidian-executable.cjs';\nimport { serializeError } from './serialize-error.cjs';\n\ninterface ExecuteScriptFileFsPromises {\n  access(path: string): Promise<void>;\n  readFile(path: string, encoding: string): Promise<string>;\n}\n\ninterface InvokeAndWriteResultFsPromises {\n  writeFile(path: string, data: string): Promise<void>;\n}\n\ninterface InvokeAndWriteResultParams {\n  evaluate(): Promise<unknown>;\n  resultPath: string;\n  serializeError(error: unknown): string;\n}\n\n/**\n * Discriminated envelope written by the temporary script file.\n *\n * - `{ value: string, type: 'error' }` \u2014 the expression threw; `value` is the error message.\n * - `{ value: '', type: 'null' }` \u2014 the expression returned `null`.\n * - `{ value: '', type: 'undefined' }` \u2014 the expression returned `undefined`.\n * - `{ value: string }` \u2014 the expression returned a string value (no `type` field).\n */\ntype ScriptResultEnvelope =\n  | { type: 'error' | 'null' | 'undefined'; value: string }\n  | { value: string };\n\nconst UNABLE_TO_FIND_OBSIDIAN = 'unable to find Obsidian';\nconst AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst AUTO_START_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\nconst VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1000;\nconst VAULT_EVAL_TIMEOUT_IN_MILLISECONDS = 10000;\n\ninterface BuildDiagnosticsParams {\n  command: string[];\n  cwd: string;\n  execResult: ExecResult | undefined;\n  resultPath: string;\n  scriptContent: string;\n  scriptPath: string;\n}\n\n/**\n * Transport that communicates with Desktop Obsidian via the `obsidian eval` CLI command\n * and manages vaults via Electron IPC.\n */\nexport class DesktopCliTransport implements ObsidianTransport {\n  /**\n   * Indicates whether this transport is for a mobile platform. Always `false` for this transport.\n   */\n  public readonly isMobile = false;\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.\n   *\n   * Writes the expression to a temporary `.cjs` file and executes a tiny\n   * `require().invoke()` call via the CLI. The result is written to a\n   * `.result.json` file by the script, avoiding CLI stdout size limits\n   * and IPC buffer issues.\n   *\n   * Handles auto-start: if Obsidian is not running, launches it via URI protocol\n   * and retries until it becomes available.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param options - Evaluation options.\n   * @returns The normalized result string (transport-specific prefixes stripped).\n   */\n  public async evaluate(expression: string, options: TransportEvalOptions): Promise<string> {\n    const SLICE_START = 2;\n    const scriptId = String(Math.random()).slice(SLICE_START);\n    const scriptDir = join(tmpdir(), 'obsidian-integration-testing');\n    const scriptPath = join(scriptDir, `${scriptId}.js`);\n    const resultPath = join(scriptDir, `${scriptId}.result.json`);\n\n    await mkdir(scriptDir, { recursive: true });\n\n    const scriptContent = buildScriptFile(expression, resultPath);\n    await writeFile(scriptPath, scriptContent);\n\n    try {\n      const safeScriptPath = scriptPath.replace(/\\\\/g, '/');\n      const cliExpr = `(${getFunctionExpressionString(executeScriptFile)})(${JSON.stringify(safeScriptPath)})`;\n      const vaultId = getVaultId(options.cwd);\n      const command = ['obsidian', ...(vaultId ? [`vault=${vaultId}`] : []), 'eval', '--allow-focus-steal', `code=${cliExpr}`];\n\n      let execResult: ExecResult | undefined;\n      try {\n        execResult = await exec(command, {\n          cwd: options.cwd,\n          isQuiet: true,\n          shouldIncludeDetails: true,\n          ...(options.timeoutInMilliseconds !== undefined && { timeoutInMilliseconds: options.timeoutInMilliseconds })\n        });\n      } catch (error) {\n        const message = error instanceof Error ? error.message : String(error);\n        if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n          await this.ensureObsidianRunningAndRetry(command, options.cwd);\n        } else {\n          throw error;\n        }\n      }\n\n      if (!existsSync(resultPath)) {\n        const diagnostics = await buildDiagnostics({\n          command,\n          cwd: options.cwd,\n          execResult,\n          resultPath,\n          scriptContent,\n          scriptPath\n        });\n        throw new Error(`Script did not execute for path: ${options.cwd}\\n${diagnostics}`);\n      }\n\n      const resultStr = await readFile(resultPath, 'utf-8');\n      const envelope = JSON.parse(resultStr) as ScriptResultEnvelope;\n\n      if ('type' in envelope) {\n        if (envelope.type === 'error') {\n          throw new Error(`Script error in Obsidian for path: ${options.cwd}: ${envelope.value}`);\n        }\n        return '';\n      }\n\n      return envelope.value;\n    } finally {\n      await unlink(scriptPath).catch(noop);\n      await unlink(resultPath).catch(noop);\n    }\n  }\n\n  /**\n   * Runs CLI-specific preflight checks.\n   *\n   * Verifies that the vault is registered, CLI is enabled in Obsidian settings,\n   * and the `obsidian` CLI binary is available in PATH. If the vault is registered\n   * but not open, opens it via URI protocol and polls until it is ready.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async preflightCheck(vaultPath: string): Promise<void> {\n    log(`[cli-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    if (!isCliEnabled()) {\n      log('[cli-transport] CLI is disabled in obsidian.json. Enabling and restarting Obsidian...');\n      enableCliInConfig();\n      await this.restartObsidian(vaultPath);\n    }\n\n    await this.assertCliAvailable();\n\n    if (!isVaultOpen(vaultPath)) {\n      log(`[cli-transport] Vault is registered but not open: ${vaultPath}. Opening via URI...`);\n      await openVaultViaUri(vaultPath);\n      await this.pollVaultReady(vaultPath);\n    }\n\n    log('[cli-transport] Preflight check passed.');\n  }\n\n  /**\n   * Registers a vault in the running Obsidian instance via Electron IPC.\n   *\n   * Uses `vault-open` IPC to register and open the vault, then polls until\n   * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[cli-transport] Registering vault: ${vaultPath}`);\n    const existingVaultPath = getAnyRegisteredVaultPath();\n\n    if (existingVaultPath) {\n      await ensureNamespaceBootstrapped(this, existingVaultPath);\n      const registerExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath, false], channel: 'vault-open' })})`;\n      await this.evaluate(registerExpr, { cwd: existingVaultPath });\n      await this.enablePluginsInLocalStorage(vaultPath, existingVaultPath);\n    } else {\n      log('[cli-transport] No existing vault registered. Writing vault entry directly to obsidian.json...');\n      registerVaultInConfig(vaultPath);\n      log('[cli-transport] Vault entry written. Opening vault via URI protocol...');\n      await openVaultViaUri(vaultPath);\n      await this.pollVaultReady(vaultPath);\n      await this.enablePluginsInLocalStorage(vaultPath, vaultPath);\n      await this.dismissTrustDialog(vaultPath);\n      return;\n    }\n\n    await this.pollVaultReady(vaultPath);\n  }\n\n  /**\n   * Unregisters a vault from the running Obsidian instance.\n   *\n   * Schedules the vault window to close, waits, then removes the vault\n   * from the registry via `vault-remove` IPC.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    log(`[cli-transport] Unregistering vault: closing window for ${vaultPath}...`);\n    try {\n      await ensureNamespaceBootstrapped(this, vaultPath);\n      const destroyExpr = 'window.__obsidianIntegrationTesting.destroyCurrentWindow()';\n      await this.evaluate(destroyExpr, { cwd: vaultPath, timeoutInMilliseconds: VAULT_EVAL_TIMEOUT_IN_MILLISECONDS });\n      log('[cli-transport] Window destroy command sent.');\n    } catch (error: unknown) {\n      log(`[cli-transport] Window destroy failed (non-fatal): ${serializeError(error)}`);\n    }\n\n    log('[cli-transport] Waiting for window to close...');\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    log('[cli-transport] Removing vault from registry...');\n    const existingVaultForRemoval = getAnyRegisteredVaultPath();\n    try {\n      if (existingVaultForRemoval) {\n        await ensureNamespaceBootstrapped(this, existingVaultForRemoval);\n        const removeExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath], channel: 'vault-remove' })})`;\n        await this.evaluate(removeExpr, { cwd: existingVaultForRemoval, timeoutInMilliseconds: VAULT_EVAL_TIMEOUT_IN_MILLISECONDS });\n      } else {\n        log('[cli-transport] No existing vault to target for removal IPC \u2014 removing directly from obsidian.json.');\n        removeVaultFromConfig(vaultPath);\n      }\n      log('[cli-transport] Vault removed from registry.');\n    } catch (error: unknown) {\n      log(`[cli-transport] Vault registry removal failed (non-fatal): ${serializeError(error)}`);\n    }\n  }\n\n  /**\n   * Checks whether the Obsidian CLI binary is available in the system PATH.\n   */\n  private async assertCliAvailable(): Promise<void> {\n    const command = process.platform === 'win32' ? 'where.exe obsidian' : '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   * Dismisses the \"Do you trust the author of this vault?\" dialog if present.\n   *\n   * Clicks the \"Trust author and enable plugins\" button (`.mod-cta`) inside any\n   * modal whose text includes \"Do you trust the author\". This is needed when a\n   * vault with community plugins is opened without a prior `enable-plugin-<id>`\n   * entry in localStorage (e.g., the very first vault registered via config file).\n   *\n   * @param vaultPath - The vault path to evaluate in.\n   */\n  private async dismissTrustDialog(vaultPath: string): Promise<void> {\n    await ensureNamespaceBootstrapped(this, vaultPath);\n    const dismissExpr = `(function() {\n      var modals = document.querySelectorAll('.modal-container');\n      for (var i = 0; i < modals.length; i++) {\n        if (modals[i].textContent.includes('Do you trust the author')) {\n          var btn = modals[i].querySelector('.mod-cta');\n          if (btn) { btn.click(); return true; }\n        }\n      }\n      return false;\n    })()`;\n    const result = await this.evaluate(dismissExpr, { cwd: vaultPath });\n    if (result === 'true') {\n      log('[cli-transport] Dismissed \"Do you trust the author\" dialog.');\n    }\n  }\n\n  /**\n   * Sets `enable-plugin-<vaultId>` in Obsidian's localStorage to prevent\n   * the \"Do you trust the author of this vault?\" dialog from appearing\n   * when a vault with community plugins is opened for the first time.\n   *\n   * Must be called after the `vault-open` IPC (so the vault ID exists in\n   * `obsidian.json`) and before the new vault window finishes loading.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   * @param evalTargetVaultPath - The vault path to use as eval target (an existing, loaded vault).\n   *   localStorage is shared across all Obsidian windows (same Electron origin), so the\n   *   `localStorage.setItem` call can run in any loaded vault window.\n   */\n  private async enablePluginsInLocalStorage(vaultPath: string, evalTargetVaultPath: string): Promise<void> {\n    const vaultId = getVaultId(vaultPath);\n    if (!vaultId) {\n      log('[cli-transport] Could not find vault ID \u2014 skipping localStorage trust flag.');\n      return;\n    }\n\n    await ensureNamespaceBootstrapped(this, evalTargetVaultPath);\n    const enableExpr = `window.__obsidianIntegrationTesting.setLocalStorageItem(${JSON.stringify({ key: `enable-plugin-${vaultId}`, value: 'true' })})`;\n    await this.evaluate(enableExpr, { cwd: evalTargetVaultPath });\n    log(`[cli-transport] Set enable-plugin-${vaultId} in localStorage.`);\n  }\n\n  /**\n   * Launches Obsidian binary and retries the eval until it responds.\n   *\n   * @param command - The CLI command array to retry.\n   * @param cwd - The working directory.\n   */\n  private async ensureObsidianRunningAndRetry(command: string[], cwd: string): Promise<void> {\n    log('[cli-transport] Obsidian is not running. Starting Obsidian...');\n\n    const launchCommand = await getObsidianLaunchCommand();\n    try {\n      await exec(launchCommand, { isQuiet: true });\n    } catch {\n      // The launch command may fail on some systems \u2014 we'll still try polling.\n    }\n\n    log(`[cli-transport] Polling for Obsidian CLI (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);\n      try {\n        await exec(command, { cwd, isQuiet: true });\n        log('[cli-transport] Obsidian CLI responded.');\n        return;\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        log('[cli-transport] Obsidian not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);\n  }\n\n  /**\n   * Polls until the vault is ready and responding to eval calls.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  private async pollVaultReady(vaultPath: string): Promise<void> {\n    const pollExpr = 'window.__obsidianIntegrationTesting.pollVaultBasePath()';\n\n    log(`[cli-transport] Polling for vault readiness (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    let isBootstrapped = false;\n    while (Date.now() < deadline) {\n      try {\n        if (!isBootstrapped) {\n          await ensureNamespaceBootstrapped(this, vaultPath);\n          isBootstrapped = true;\n        }\n        const basePath = await this.evaluate(pollExpr, { cwd: vaultPath });\n        if (JSON.parse(basePath) === vaultPath) {\n          log('[cli-transport] Vault is ready.');\n          return;\n        }\n      } catch {\n        // Vault not ready yet \u2014 namespace may not be bootstrapped yet either.\n        isBootstrapped = false;\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n\n  /**\n   * Restarts Obsidian by killing the running process and relaunching it.\n   *\n   * Used when a config change (like enabling CLI) requires a restart to take effect.\n   *\n   * @param vaultPath - The vault path to use for polling after restart.\n   */\n  private async restartObsidian(vaultPath: string): Promise<void> {\n    log('[cli-transport] Killing Obsidian process...');\n    try {\n      await exec(getKillObsidianCommand(), { isQuiet: true });\n    } catch {\n      // Process may not be running \u2014 that's fine.\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const restartVaultId = getVaultId(vaultPath);\n    const command = ['obsidian', ...(restartVaultId ? [`vault=${restartVaultId}`] : []), 'eval', 'code=\"1\"'];\n    await this.ensureObsidianRunningAndRetry(command, vaultPath);\n  }\n}\n\n/**\n * Evaluates an expression, writes the result to a JSON file.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param params - The invocation parameters.\n */\nexport async function invokeAndWriteResult(params: InvokeAndWriteResultParams): Promise<void> {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- window.app is set by Obsidian at runtime.\n  const fsPromises = Reflect.get(window.app.vault.adapter, 'fsPromises') as InvokeAndWriteResultFsPromises;\n  try {\n    const result = await params.evaluate();\n    if (result === undefined) {\n      await fsPromises.writeFile(params.resultPath, JSON.stringify({ type: 'undefined', value: '' }));\n    } else if (result === null) {\n      await fsPromises.writeFile(params.resultPath, JSON.stringify({ type: 'null', value: '' }));\n    } else {\n      // eslint-disable-next-line @typescript-eslint/no-base-to-string -- Intentional: result is an arbitrary value from the evaluated expression.\n      await fsPromises.writeFile(params.resultPath, JSON.stringify({ value: String(result) }));\n    }\n  } catch (err) {\n    await fsPromises.writeFile(params.resultPath, JSON.stringify({ type: 'error', value: params.serializeError(err) }));\n  }\n}\n\n/**\n * Builds a detailed diagnostic string for the \"Script did not execute\" error.\n *\n * Performs live environment checks (process list, vault registry, CLI config)\n * and includes the command, exec output, and script content.\n *\n * @param params - The diagnostic parameters.\n * @returns A formatted diagnostic string.\n */\nasync function buildDiagnostics(params: BuildDiagnosticsParams): Promise<string> {\n  const lines: string[] = [];\n\n  lines.push(`  Command: ${params.command.join(' ')}`);\n  lines.push(`  Working directory: ${params.cwd}`);\n  lines.push(`  Script path: ${params.scriptPath}`);\n  lines.push(`  Expected result file: ${params.resultPath}`);\n\n  if (params.execResult) {\n    lines.push(`  Exit code: ${params.execResult.exitCode === null ? '(null \u2014 process did not exit normally)' : String(params.execResult.exitCode)}`);\n    if (params.execResult.exitSignal) {\n      lines.push(`  Exit signal: ${params.execResult.exitSignal}`);\n    }\n    if (params.execResult.stdout.trim()) {\n      lines.push(`  stdout: ${params.execResult.stdout.trim()}`);\n    }\n    if (params.execResult.stderr.trim()) {\n      lines.push(`  stderr: ${params.execResult.stderr.trim()}`);\n    }\n    if (!params.execResult.stdout.trim() && !params.execResult.stderr.trim()) {\n      lines.push('  stdout/stderr: (empty)');\n    }\n  } else {\n    lines.push('  exec result: (not available \u2014 Obsidian was auto-started and retried)');\n  }\n\n  lines.push('Environment checks:');\n  lines.push(`  Obsidian running: ${await isObsidianRunning() ? 'yes' : 'NO'}`);\n  lines.push(`  CLI enabled in obsidian.json: ${isCliEnabled() ? 'yes' : 'NO'}`);\n  lines.push(`  Vault registered: ${isVaultRegistered(params.cwd) ? 'yes' : 'NO'}`);\n  lines.push(`  Script file exists: ${existsSync(params.scriptPath) ? 'yes' : 'no (already cleaned up)'}`);\n  lines.push(`  Result file exists: ${existsSync(params.resultPath) ? 'yes' : 'no'}`);\n\n  const registeredVaults = getRegisteredVaults();\n  if (registeredVaults.length === 0) {\n    lines.push('  Registered vaults: (none)');\n  } else {\n    lines.push('  Registered vaults:');\n    for (const vault of registeredVaults) {\n      lines.push(`    - ${vault.path} (open: ${String(vault.open)})`);\n    }\n  }\n\n  lines.push(`  Script content:\\n${params.scriptContent}`);\n\n  return lines.join('\\n');\n}\n\n/**\n * Builds the content of a temporary script file.\n *\n * Serializes {@link invokeAndWriteResult} into a self-contained IIFE that\n * evaluates the expression, writes the result (or error) to `resultPath`.\n *\n * @param expression - The JavaScript expression to evaluate.\n * @param resultPath - The absolute path to the result file.\n * @returns The script file content.\n */\nfunction buildScriptFile(expression: string, resultPath: string): string {\n  const fnStr = getFunctionExpressionString(invokeAndWriteResult);\n  const serializeErrorStr = getFunctionExpressionString(serializeError);\n  const resultPathJson = JSON.stringify(resultPath.replace(/\\\\/g, '/'));\n  return `(${fnStr})({ evaluate: async () => (${expression}), resultPath: ${resultPathJson}, serializeError: ${serializeErrorStr} })`;\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Reads a script file from disk, logs its content, and executes it via `new Function`.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param scriptPath - The absolute path to the script file.\n */\nasync function executeScriptFile(scriptPath: string): Promise<void> {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- window.app is set by Obsidian at runtime.\n  const fsPromises = Reflect.get(window.app.vault.adapter, 'fsPromises') as ExecuteScriptFileFsPromises;\n\n  try {\n    await fsPromises.access(scriptPath);\n  } catch (cause) {\n    throw new Error(`Script file not found: ${scriptPath}`, { cause });\n  }\n\n  const script = await fsPromises.readFile(scriptPath, 'utf-8');\n  // eslint-disable-next-line no-console -- Diagnostic logging inside Obsidian process; no logger available.\n  console.debug(`Executing ${scriptPath}:\\n${script}`);\n\n  let fn: () => Promise<void>;\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func -- The script is a trusted, self-generated IIFE expression.\n    fn = new Function(`return ${script}`) as () => Promise<void>;\n  } catch (cause) {\n    throw new Error(`Error parsing ${scriptPath}`, { cause });\n  }\n\n  try {\n    await fn();\n  } catch (cause) {\n    throw new Error(`Error executing ${scriptPath}`, { cause });\n  }\n}\n\n/**\n * Returns the platform-specific command to kill the Obsidian process.\n *\n * @returns The shell command string.\n */\nfunction getKillObsidianCommand(): string {\n  if (process.platform === 'win32') {\n    return 'taskkill /IM Obsidian.exe /F';\n  }\n\n  return 'pkill -f Obsidian';\n}\n\n/**\n * Returns the platform-specific command to launch the Obsidian binary.\n *\n * Resolves the actual installed Obsidian executable (covering installer-based\n * and `PATH`-based installs such as `scoop`) and verifies it exists before\n * returning a command. Throws if Obsidian is not installed.\n *\n * @returns The shell command string.\n * @throws Error if Obsidian cannot be located.\n */\nasync function getObsidianLaunchCommand(): Promise<string> {\n  const exePath = await resolveObsidianExecutable();\n\n  if (process.platform === 'win32') {\n    return `start \"\" \"${exePath}\"`;\n  }\n\n  return `\"${exePath}\" &`;\n}\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\n/**\n * Checks whether the Obsidian process is currently running.\n *\n * @returns `true` if the Obsidian process is found, `false` otherwise.\n */\nasync function isObsidianRunning(): Promise<boolean> {\n  const command = process.platform === 'win32'\n    ? 'tasklist /FI \"IMAGENAME eq Obsidian.exe\" /NH'\n    : 'pgrep -f Obsidian';\n  try {\n    const output = await exec(command, { isQuiet: true });\n    if (process.platform === 'win32') {\n      return output.includes('Obsidian.exe');\n    }\n    return output.trim().length > 0;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Opens a vault in Obsidian using the `obsidian://open` URI protocol.\n *\n * This works whether Obsidian is already running (signals it to open the vault)\n * or not (launches Obsidian with the vault). The URI protocol is handled by the\n * OS, which routes it to the registered Obsidian handler.\n *\n * @param vaultPath - The absolute path to the vault folder.\n */\nasync function openVaultViaUri(vaultPath: string): Promise<void> {\n  const vaultId = getVaultId(vaultPath);\n  if (!vaultId) {\n    throw new Error(`Cannot open vault via URI: vault is not registered in obsidian.json: ${vaultPath}`);\n  }\n  const uri = `obsidian://open?vault=${encodeURIComponent(vaultId)}`;\n  const command = getOpenUriCommand(uri);\n  log(`[cli-transport] Opening vault via URI: ${uri}`);\n  try {\n    await exec(command, { isQuiet: true });\n  } catch (error: unknown) {\n    log(`[cli-transport] URI open failed (non-fatal): ${serializeError(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}


package/dist/lib/cjs/vitest/global-setup.cjs

@@ -30,6 +30,7 @@ var import_log = require("../log.cjs");
 var import_serialize_error = require("../serialize-error.cjs");
 var import_temp_vault = require("../temp-vault.cjs");
 (0, import_context_provider.setTransportOptionsResolver)(() => (0, import_vitest.inject)("obsidianTransport"));
+(0, import_context_provider.setVaultPathResolver)(() => (0, import_vitest.inject)("tempVaultPath"));
 let setupResult;
 function getTempVault() {
   const tempVaultPath = (0, import_vitest.inject)("tempVaultPath");
@@ -62,4 +63,4 @@ async function teardown() {
   setup,
   teardown
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/context-id.mjs

@@ -56,4 +56,4 @@ class ContextId {
 export {
   ContextId
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/context-provider.d.mts

@@ -3,22 +3,32 @@
  *
  * Framework-neutral context provider for integration test state.
  *
- * Each framework adapter (vitest, jest) registers a resolver via
- * {@link setTransportOptionsResolver} during module initialization.
- * Core modules call {@link getTransportOptions} to retrieve the
- * transport options without depending on any specific test framework.
+ * Each framework adapter (vitest, jest) registers resolvers via
+ * {@link setTransportOptionsResolver} and {@link setVaultPathResolver}
+ * during module initialization. Core modules call the corresponding
+ * getters to retrieve state without depending on any specific test framework.
  */
 import type { ObsidianTransportOptions } from './transport-options.mjs';
 /**
  * A function that resolves the current transport options.
  */
 export type TransportOptionsResolver = () => ObsidianTransportOptions | undefined;
+/**
+ * A function that resolves the current vault path.
+ */
+export type VaultPathResolver = () => string | undefined;
 /**
  * Returns the transport options resolved by the registered framework adapter.
  *
  * @returns The transport options, or `undefined` if not configured (defaults to CLI transport).
  */
 export declare function getTransportOptions(): ObsidianTransportOptions | undefined;
+/**
+ * Returns the vault path resolved by the registered framework adapter.
+ *
+ * @returns The vault path, or `undefined` if not configured (falls back to `process.cwd()`).
+ */
+export declare function getVaultPath(): string | undefined;
 /**
  * Registers a resolver function for transport options. Called by framework
  * adapters at module load time to bridge their native injection mechanisms.
@@ -26,3 +36,10 @@ export declare function getTransportOptions(): ObsidianTransportOptions | undefi
  * @param fn - The resolver function.
  */
 export declare function setTransportOptionsResolver(fn: TransportOptionsResolver): void;
+/**
+ * Registers a resolver function for the vault path. Called by framework
+ * adapters at module load time to bridge their native injection mechanisms.
+ *
+ * @param fn - The resolver function.
+ */
+export declare function setVaultPathResolver(fn: VaultPathResolver): void;