obsidian-integration-testing 2.6.1 → 2.7.0

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

@@ -28,7 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var transport_desktop_cli_exports = {};
 __export(transport_desktop_cli_exports, {
-  DesktopCliTransport: () => DesktopCliTransport
+  DesktopCliTransport: () => DesktopCliTransport,
+  destroyCurrentWindow: () => destroyCurrentWindow,
+  ipcSendSync: () => ipcSendSync
 });
 module.exports = __toCommonJS(transport_desktop_cli_exports);
 var import_node_fs = require("node:fs");
@@ -38,6 +40,7 @@ var import_node_path = require("node:path");
 var import_node_process = __toESM(require("node:process"), 1);
 var import_exec = require("./exec.cjs");
 var import_function_expression = require("./function-expression.cjs");
+var import_generate_function_call = require("./generate-function-call.cjs");
 var import_log = require("./log.cjs");
 var import_noop = require("./noop.cjs");
 var import_obsidian_config = require("./obsidian-config.cjs");
@@ -50,7 +53,9 @@ const VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 3e4;
 const VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1e3;
 const VAULT_EVAL_TIMEOUT_IN_MILLISECONDS = 1e4;
 class DesktopCliTransport {
-  /** */
+  /**
+   * Indicates whether this transport is for a mobile platform. Always `false` for this transport.
+   */
   isMobile = false;
   /**
    * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.
@@ -128,7 +133,9 @@ class DesktopCliTransport {
       );
     }
     if (!(0, import_obsidian_config.isCliEnabled)()) {
-      throw new Error("Obsidian CLI is disabled. Enable it in Obsidian Settings \u2192 General \u2192 CLI.");
+      (0, import_log.log)("[cli-transport] CLI is disabled in obsidian.json. Enabling and restarting Obsidian...");
+      (0, import_obsidian_config.enableCliInConfig)();
+      await this.restartObsidian(vaultPath);
     }
     await this.assertCliAvailable();
     (0, import_log.log)("[cli-transport] Preflight check passed.");
@@ -144,17 +151,17 @@ class DesktopCliTransport {
   async registerVault(vaultPath) {
     (0, import_log.log)(`[cli-transport] Registering vault: ${vaultPath}`);
     const existingVaultPath = (0, import_obsidian_config.getAnyRegisteredVaultPath)();
-    if (!existingVaultPath) {
-      throw new Error("Cannot register a vault: no existing vault is registered in Obsidian. Open Obsidian and create or open at least one vault first.");
+    if (existingVaultPath) {
+      const registerExpr = (0, import_generate_function_call.generateFunctionCall)(ipcSendSync, { args: [vaultPath, false], channel: "vault-open", ensureLayoutReady: import_generate_function_call.ensureLayoutReady });
+      await this.evaluate(registerExpr, { cwd: existingVaultPath });
+      await this.enablePluginsInLocalStorage(vaultPath, existingVaultPath);
+    } else {
+      (0, import_log.log)("[cli-transport] No existing vault registered. Writing vault entry directly to obsidian.json...");
+      (0, import_obsidian_config.registerVaultInConfig)(vaultPath);
+      (0, import_log.log)("[cli-transport] Vault entry written. Opening vault via URI protocol...");
+      await openVaultViaUri(vaultPath);
     }
-    const registerExpr = buildIpcExpression(
-      `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false);`
-    );
-    await this.evaluate(registerExpr, { cwd: existingVaultPath });
-    await this.enablePluginsInLocalStorage(vaultPath, existingVaultPath);
-    const pollExpr = buildSimpleExpression(
-      "return JSON.stringify(app.vault.adapter.getBasePath());"
-    );
+    const pollExpr = (0, import_generate_function_call.generateFunctionCall)(pollVaultBasePath, { ensureLayoutReady: import_generate_function_call.ensureLayoutReady });
     (0, import_log.log)(`[cli-transport] Polling for vault readiness (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);
     const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;
     while (Date.now() < deadline) {
@@ -180,13 +187,7 @@ class DesktopCliTransport {
    */
   async unregisterVault(vaultPath) {
     (0, import_log.log)(`[cli-transport] Unregistering vault: closing window for ${vaultPath}...`);
-    const destroyExpr = buildSimpleExpression(`
-      setTimeout(() => {
-        if (window.electron && window.electron.remote) {
-          window.electron.remote.getCurrentWindow().destroy();
-        }
-      }, 0);
-    `);
+    const destroyExpr = (0, import_generate_function_call.generateFunctionCall)(destroyCurrentWindow, { ensureLayoutReady: import_generate_function_call.ensureLayoutReady });
     try {
       await this.evaluate(destroyExpr, { cwd: vaultPath, timeoutInMilliseconds: VAULT_EVAL_TIMEOUT_IN_MILLISECONDS });
       (0, import_log.log)("[cli-transport] Window destroy command sent.");
@@ -196,15 +197,14 @@ class DesktopCliTransport {
     (0, import_log.log)("[cli-transport] Waiting for window to close...");
     await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);
     (0, import_log.log)("[cli-transport] Removing vault from registry...");
-    const removeExpr = buildIpcExpression(
-      `window.electron.ipcRenderer.sendSync('vault-remove', ${JSON.stringify(vaultPath)});`
-    );
+    const removeExpr = (0, import_generate_function_call.generateFunctionCall)(ipcSendSync, { args: [vaultPath], channel: "vault-remove", ensureLayoutReady: import_generate_function_call.ensureLayoutReady });
     const existingVaultForRemoval = (0, import_obsidian_config.getAnyRegisteredVaultPath)();
     try {
       if (existingVaultForRemoval) {
         await this.evaluate(removeExpr, { cwd: existingVaultForRemoval, timeoutInMilliseconds: VAULT_EVAL_TIMEOUT_IN_MILLISECONDS });
       } else {
-        (0, import_log.log)("[cli-transport] No existing vault to target for removal IPC \u2014 skipping.");
+        (0, import_log.log)("[cli-transport] No existing vault to target for removal IPC \u2014 removing directly from obsidian.json.");
+        (0, import_obsidian_config.removeVaultFromConfig)(vaultPath);
       }
       (0, import_log.log)("[cli-transport] Vault removed from registry.");
     } catch (error) {
@@ -241,9 +241,7 @@ class DesktopCliTransport {
       (0, import_log.log)("[cli-transport] Could not find vault ID \u2014 skipping localStorage trust flag.");
       return;
     }
-    const enableExpr = buildSimpleExpression(
-      `localStorage.setItem(${JSON.stringify(`enable-plugin-${vaultId}`)}, 'true');`
-    );
+    const enableExpr = (0, import_generate_function_call.generateFunctionCall)(setLocalStorageItem, { ensureLayoutReady: import_generate_function_call.ensureLayoutReady, key: `enable-plugin-${vaultId}`, value: "true" });
     await this.evaluate(enableExpr, { cwd: evalTargetVaultPath });
     (0, import_log.log)(`[cli-transport] Set enable-plugin-${vaultId} in localStorage.`);
   }
@@ -277,9 +275,32 @@ class DesktopCliTransport {
     }
     throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);
   }
+  /**
+   * Restarts Obsidian by killing the running process and relaunching it.
+   *
+   * Used when a config change (like enabling CLI) requires a restart to take effect.
+   *
+   * @param vaultPath - The vault path to use for polling after restart.
+   */
+  async restartObsidian(vaultPath) {
+    (0, import_log.log)("[cli-transport] Killing Obsidian process...");
+    try {
+      await (0, import_exec.exec)(getKillObsidianCommand(), { isQuiet: true });
+    } catch {
+    }
+    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);
+    const command = ["obsidian", "eval", "--vault", vaultPath, "--expression", '"1"'];
+    await this.ensureObsidianRunningAndRetry(command, vaultPath);
+  }
+}
+async function destroyCurrentWindow(params) {
+  await params.ensureLayoutReady(params);
+  await sleep(0);
+  window.electronWindow.destroy();
 }
-function buildIpcExpression(ipcStatement) {
-  return buildSimpleExpression(ipcStatement);
+async function ipcSendSync(params) {
+  await params.ensureLayoutReady(params);
+  window.electron.ipcRenderer.sendSync(params.channel, ...params.args);
 }
 function buildScriptFile(expression, resultPath, invokeName) {
   const resultPathJson = JSON.stringify(resultPath.replace(/\\/g, "/"));
@@ -305,19 +326,17 @@ async function ${invokeName}() {
 exports.${invokeName} = ${invokeName};
 `;
 }
-function buildSimpleExpression(body) {
-  return `(async () => {
-  if (!app.workspace.layoutReady) {
-    await new Promise((resolve) => app.workspace.onLayoutReady(resolve));
-  }
-  ${body}
-})()`;
-}
 function delay(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
+function getKillObsidianCommand() {
+  if (import_node_process.default.platform === "win32") {
+    return "taskkill /IM Obsidian.exe /F";
+  }
+  return "pkill -f Obsidian";
+}
 function getObsidianLaunchCommand() {
   if (import_node_process.default.platform === "win32") {
     const localAppData = import_node_process.default.env["LOCALAPPDATA"] ?? "";
@@ -328,8 +347,38 @@ function getObsidianLaunchCommand() {
   }
   return "obsidian &";
 }
+function getOpenUriCommand(uri) {
+  if (import_node_process.default.platform === "win32") {
+    return `start "" "${uri}"`;
+  }
+  if (import_node_process.default.platform === "darwin") {
+    return `open "${uri}"`;
+  }
+  return `xdg-open "${uri}"`;
+}
+async function openVaultViaUri(vaultPath) {
+  const encodedPath = encodeURIComponent(vaultPath);
+  const uri = `obsidian://open?path=${encodedPath}`;
+  const command = getOpenUriCommand(uri);
+  (0, import_log.log)(`[cli-transport] Opening vault via URI: ${uri}`);
+  try {
+    await (0, import_exec.exec)(command, { isQuiet: true });
+  } catch (error) {
+    (0, import_log.log)(`[cli-transport] URI open failed (non-fatal): ${(0, import_serialize_error.serializeError)(error)}`);
+  }
+}
+async function pollVaultBasePath(params) {
+  await params.ensureLayoutReady(params);
+  return JSON.stringify(params.app.vault.adapter.getBasePath());
+}
+async function setLocalStorageItem(params) {
+  await params.ensureLayoutReady(params);
+  localStorage.setItem(params.key, params.value);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DesktopCliTransport
+  DesktopCliTransport,
+  destroyCurrentWindow,
+  ipcSendSync
 });
-//# 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 {\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 { noop } from './noop.cjs';\nimport {\n  getAnyRegisteredVaultPath,\n  getVaultId,\n  isCliEnabled,\n  isVaultRegistered\n} from './obsidian-config.cjs';\nimport { serializeError } from './serialize-error.cjs';\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\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  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}.cjs`);\n    const resultPath = join(scriptDir, `${scriptId}.result.json`);\n\n    await mkdir(scriptDir, { recursive: true });\n\n    const invokeName = `invoke_${scriptId}`;\n    const scriptContent = buildScriptFile(expression, resultPath, invokeName);\n    await writeFile(scriptPath, scriptContent);\n\n    try {\n      // Use module.constructor._load to bypass any monkey-patched require()\n      // (e.g., obsidian-codescript-toolkit patches require in the renderer process).\n      const safeRequire = `module.constructor._load(${JSON.stringify(scriptPath.replace(/\\\\/g, '/'))})`;\n      const requireExpr = `(async () => { await ${safeRequire}.${invokeName}() })()`;\n      const command = ['obsidian', 'eval', '--allow-focus-steal', `code=${requireExpr}`];\n\n      try {\n        await exec(command, {\n          cwd: options.cwd,\n          isQuiet: 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        throw new Error(`Script did not execute for path: ${options.cwd} \u2014 the vault may not be found or Obsidian did not run the eval.`);\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.\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      throw new Error('Obsidian CLI is disabled. Enable it in Obsidian Settings \\u2192 General \\u2192 CLI.');\n    }\n\n    await this.assertCliAvailable();\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    if (!existingVaultPath) {\n      throw new Error('Cannot register a vault: no existing vault is registered in Obsidian. Open Obsidian and create or open at least one vault first.');\n    }\n\n    const registerExpr = buildIpcExpression(\n      `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false);`\n    );\n    await this.evaluate(registerExpr, { cwd: existingVaultPath });\n\n    await this.enablePluginsInLocalStorage(vaultPath, existingVaultPath);\n\n    const pollExpr = buildSimpleExpression(\n      'return JSON.stringify(app.vault.adapter.getBasePath());'\n    );\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    while (Date.now() < deadline) {\n      try {\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.\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 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    const destroyExpr = buildSimpleExpression(`\n      setTimeout(() => {\n        if (window.electron && window.electron.remote) {\n          window.electron.remote.getCurrentWindow().destroy();\n        }\n      }, 0);\n    `);\n    try {\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 removeExpr = buildIpcExpression(\n      `window.electron.ipcRenderer.sendSync('vault-remove', ${JSON.stringify(vaultPath)});`\n    );\n    const existingVaultForRemoval = getAnyRegisteredVaultPath();\n    try {\n      if (existingVaultForRemoval) {\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 skipping.');\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   * 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    const enableExpr = buildSimpleExpression(\n      `localStorage.setItem(${JSON.stringify(`enable-plugin-${vaultId}`)}, 'true');`\n    );\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/**\n * Builds an async IIFE that waits for layout ready and executes an IPC call.\n * The return value is `JSON.stringify(undefined)` so the CLI produces `(no output)`.\n *\n * @param ipcStatement - The IPC statement to execute.\n * @returns The IIFE expression string.\n */\nfunction buildIpcExpression(ipcStatement: string): string {\n  return buildSimpleExpression(ipcStatement);\n}\n\n/**\n * Builds the content of a temporary `.cjs` script file.\n *\n * The script defines an async `invoke()` function that evaluates the\n * expression, writes the result (or error) to `resultPath`, and is\n * exported for the CLI to `require()` and call.\n *\n * @param expression - The JavaScript expression to evaluate.\n * @param resultPath - The absolute path to the result file.\n * @param invokeName - The unique function name to export (avoids collisions).\n * @returns The script file content.\n */\nfunction buildScriptFile(expression: string, resultPath: string, invokeName: string): string {\n  const resultPathJson = JSON.stringify(resultPath.replace(/\\\\/g, '/'));\n  return `\"use strict\";\nconst fs = require(\"fs\");\nconst serializeError = ${getFunctionExpressionString(serializeError)};\n\nasync function ${invokeName}() {\n  try {\n    const result = await (${expression});\n    if (result === undefined) {\n      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: \"\", type: \"undefined\" }));\n    } else if (result === null) {\n      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: \"\", type: \"null\" }));\n    } else {\n      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: String(result) }));\n    }\n  } catch (err) {\n    fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: serializeError(err), type: \"error\" }));\n  }\n}\n\nexports.${invokeName} = ${invokeName};\n`;\n}\n\n/**\n * Builds a simple async IIFE expression that waits for layout ready.\n *\n * @param body - The JavaScript statements to execute.\n * @returns The IIFE expression string.\n */\nfunction buildSimpleExpression(body: string): string {\n  return `(async () => {\n  if (!app.workspace.layoutReady) {\n    await new Promise((resolve) => app.workspace.onLayoutReady(resolve));\n  }\n  ${body}\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 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/* v8 ignore stop */\n"],
  "mappings": "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",
  "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 type { FileSystemAdapter } from 'obsidian';\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 {\n  EnsureLayoutReadyParams,\n  GenerateFunctionCallParams\n} from './generate-function-call.cjs';\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.cjs';\nimport { getFunctionExpressionString } from './function-expression.cjs';\nimport {\n  ensureLayoutReady,\n  generateFunctionCall\n} from './generate-function-call.cjs';\nimport { log } from './log.cjs';\nimport { noop } from './noop.cjs';\nimport {\n  enableCliInConfig,\n  getAnyRegisteredVaultPath,\n  getVaultId,\n  isCliEnabled,\n  isVaultRegistered,\n  registerVaultInConfig,\n  removeVaultFromConfig\n} from './obsidian-config.cjs';\nimport { serializeError } from './serialize-error.cjs';\n\ninterface IpcSendSyncParams extends EnsureLayoutReadyParams {\n  args: unknown[];\n  channel: 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\ninterface SetLocalStorageItemParams extends EnsureLayoutReadyParams {\n  key: string;\n  value: string;\n}\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\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- For consistency and future extensibility.\ninterface DestroyCurrentWindowParams extends EnsureLayoutReadyParams {\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- For consistency and future extensibility.\ninterface PollVaultBasePathParams extends EnsureLayoutReadyParams {\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}.cjs`);\n    const resultPath = join(scriptDir, `${scriptId}.result.json`);\n\n    await mkdir(scriptDir, { recursive: true });\n\n    const invokeName = `invoke_${scriptId}`;\n    const scriptContent = buildScriptFile(expression, resultPath, invokeName);\n    await writeFile(scriptPath, scriptContent);\n\n    try {\n      // Use module.constructor._load to bypass any monkey-patched require()\n      // (e.g., obsidian-codescript-toolkit patches require in the renderer process).\n      const safeRequire = `module.constructor._load(${JSON.stringify(scriptPath.replace(/\\\\/g, '/'))})`;\n      const requireExpr = `(async () => { await ${safeRequire}.${invokeName}() })()`;\n      const command = ['obsidian', 'eval', '--allow-focus-steal', `code=${requireExpr}`];\n\n      try {\n        await exec(command, {\n          cwd: options.cwd,\n          isQuiet: 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        throw new Error(`Script did not execute for path: ${options.cwd} \u2014 the vault may not be found or Obsidian did not run the eval.`);\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.\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    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      const registerExpr = generateFunctionCall(ipcSendSync, { args: [vaultPath, false], channel: 'vault-open', ensureLayoutReady });\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    }\n\n    const pollExpr = generateFunctionCall(pollVaultBasePath, { ensureLayoutReady });\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    while (Date.now() < deadline) {\n      try {\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.\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 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    const destroyExpr = generateFunctionCall(destroyCurrentWindow, { ensureLayoutReady });\n    try {\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 removeExpr = generateFunctionCall(ipcSendSync, { args: [vaultPath], channel: 'vault-remove', ensureLayoutReady });\n    const existingVaultForRemoval = getAnyRegisteredVaultPath();\n    try {\n      if (existingVaultForRemoval) {\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   * 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    const enableExpr = generateFunctionCall(setLocalStorageItem, { ensureLayoutReady, 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   * 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 command = ['obsidian', 'eval', '--vault', vaultPath, '--expression', '\"1\"'];\n    await this.ensureObsidianRunningAndRetry(command, vaultPath);\n  }\n}\n\n/**\n * Waits for Obsidian's workspace layout to be ready, then destroys the\n * current Electron window via `remote.getCurrentWindow().destroy()`.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param params - Params.\n */\nexport async function destroyCurrentWindow(params: GenerateFunctionCallParams<DestroyCurrentWindowParams>): Promise<void> {\n  await params.ensureLayoutReady(params);\n  await sleep(0);\n  window.electronWindow.destroy();\n}\n\n/**\n * Waits for Obsidian's workspace layout to be ready, then sends an IPC\n * message synchronously via Electron's `ipcRenderer`.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param params - The IPC channel and arguments.\n * @param params.channel - The IPC channel name.\n * @param params.args - The arguments to send.\n */\nexport async function ipcSendSync(params: GenerateFunctionCallParams<IpcSendSyncParams>): Promise<void> {\n  await params.ensureLayoutReady(params);\n  window.electron.ipcRenderer.sendSync(params.channel, ...params.args);\n}\n\n/**\n * Builds the content of a temporary `.cjs` script file.\n *\n * The script defines an async `invoke()` function that evaluates the\n * expression, writes the result (or error) to `resultPath`, and is\n * exported for the CLI to `require()` and call.\n *\n * @param expression - The JavaScript expression to evaluate.\n * @param resultPath - The absolute path to the result file.\n * @param invokeName - The unique function name to export (avoids collisions).\n * @returns The script file content.\n */\nfunction buildScriptFile(expression: string, resultPath: string, invokeName: string): string {\n  const resultPathJson = JSON.stringify(resultPath.replace(/\\\\/g, '/'));\n  return `\"use strict\";\nconst fs = require(\"fs\");\nconst serializeError = ${getFunctionExpressionString(serializeError)};\n\nasync function ${invokeName}() {\n  try {\n    const result = await (${expression});\n    if (result === undefined) {\n      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: \"\", type: \"undefined\" }));\n    } else if (result === null) {\n      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: \"\", type: \"null\" }));\n    } else {\n      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: String(result) }));\n    }\n  } catch (err) {\n    fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: serializeError(err), type: \"error\" }));\n  }\n}\n\nexports.${invokeName} = ${invokeName};\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 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 * 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 encodedPath = encodeURIComponent(vaultPath);\n  const uri = `obsidian://open?path=${encodedPath}`;\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/**\n * Waits for Obsidian's workspace layout to be ready, then returns the\n * vault's base path as a JSON-encoded string.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param params - Params.\n * @returns The JSON-encoded base path string.\n */\nasync function pollVaultBasePath(params: GenerateFunctionCallParams<PollVaultBasePathParams>): Promise<string> {\n  await params.ensureLayoutReady(params);\n  return JSON.stringify((params.app.vault.adapter as FileSystemAdapter).getBasePath());\n}\n\n/**\n * Waits for Obsidian's workspace layout to be ready, then sets a\n * `localStorage` item.\n *\n * Serialized via `toString()` and executed inside the Obsidian process.\n * Must NOT reference any outer scope.\n *\n * @param params - Params.\n */\nasync function setLocalStorageItem(params: GenerateFunctionCallParams<SetLocalStorageItemParams>): Promise<void> {\n  await params.ensureLayoutReady(params);\n  localStorage.setItem(params.key, params.value);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}


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

@@ -4,13 +4,22 @@
  * Desktop CLI transport — evaluates expressions via `obsidian eval` and manages
  * vaults via Electron IPC.
  */
+import type { EnsureLayoutReadyParams, GenerateFunctionCallParams } from './generate-function-call.cjs';
 import type { ObsidianTransport, TransportEvalOptions } from './transport.cjs';
+interface IpcSendSyncParams extends EnsureLayoutReadyParams {
+    args: unknown[];
+    channel: string;
+}
+interface DestroyCurrentWindowParams extends EnsureLayoutReadyParams {
+}
 /**
  * Transport that communicates with Desktop Obsidian via the `obsidian eval` CLI command
  * and manages vaults via Electron IPC.
  */
 export declare class DesktopCliTransport implements ObsidianTransport {
-    /** */
+    /**
+     * Indicates whether this transport is for a mobile platform. Always `false` for this transport.
+     */
     readonly isMobile = false;
     /**
      * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.
@@ -80,4 +89,35 @@ export declare class DesktopCliTransport implements ObsidianTransport {
      * @param cwd - The working directory.
      */
     private ensureObsidianRunningAndRetry;
+    /**
+     * Restarts Obsidian by killing the running process and relaunching it.
+     *
+     * Used when a config change (like enabling CLI) requires a restart to take effect.
+     *
+     * @param vaultPath - The vault path to use for polling after restart.
+     */
+    private restartObsidian;
 }
+/**
+ * Waits for Obsidian's workspace layout to be ready, then destroys the
+ * current Electron window via `remote.getCurrentWindow().destroy()`.
+ *
+ * Serialized via `toString()` and executed inside the Obsidian process.
+ * Must NOT reference any outer scope.
+ *
+ * @param params - Params.
+ */
+export declare function destroyCurrentWindow(params: GenerateFunctionCallParams<DestroyCurrentWindowParams>): Promise<void>;
+/**
+ * Waits for Obsidian's workspace layout to be ready, then sends an IPC
+ * message synchronously via Electron's `ipcRenderer`.
+ *
+ * Serialized via `toString()` and executed inside the Obsidian process.
+ * Must NOT reference any outer scope.
+ *
+ * @param params - The IPC channel and arguments.
+ * @param params.channel - The IPC channel name.
+ * @param params.args - The arguments to send.
+ */
+export declare function ipcSendSync(params: GenerateFunctionCallParams<IpcSendSyncParams>): Promise<void>;
+export {};

package/dist/lib/esm/eval-in-obsidian.mjs

@@ -1,11 +1,12 @@
 import { existsSync } from "node:fs";
 import process from "node:process";
 import { getTransportOptions } from "./context-provider.mjs";
-import { getFunctionExpressionString } from "./function-expression.mjs";
-import { jsonWithFunctions } from "./json-with-functions.mjs";
+import {
+  ensureLayoutReady,
+  generateFunctionCall
+} from "./generate-function-call.mjs";
 import { serializeError } from "./serialize-error.mjs";
 import { getOrCreateTransport } from "./transport-factory.mjs";
-const EVAL_ERROR_MARKER = "__obsidianEvalError__";
 const NO_OUTPUT = "(no output)";
 async function evalInObsidian(params) {
   const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;
@@ -17,57 +18,56 @@ async function evalInObsidian(params) {
   if (!shouldSkipPreflightChecks) {
     await transport.preflightCheck(cwd);
   }
-  const SLICE_START = 2;
-  const randomSuffix = String(Math.random()).slice(SLICE_START);
-  const contextExpr = contextId ? `((window.__obsidianContexts__ ??= {})["${String(contextId)}"] ??= {})` : "{}";
-  const expression = `
-(async () => {
-  const fn${randomSuffix} = ${getFunctionExpressionString(fn)};
-  const obsidianModule${randomSuffix} = await (async () => {
-    if (!app.workspace.app.workspace.layoutReady) {
-      await new Promise((resolve) => app.workspace.onLayoutReady(resolve));
-    }
-    if (!app.plugins.isEnabled()) {
-      await app.plugins.setEnable(true);
-    }
-    ${getFunctionExpressionString(getObsidianModulePluginFn)}
-    ${getFunctionExpressionString(getObsidianModule)}
-    return await getObsidianModule();
-  })();
-  ${getFunctionExpressionString(serializeError)}
-  const args${randomSuffix} = ${jsonWithFunctions(args)};
-  const context${randomSuffix} = ${contextExpr};
-  const fullArgs${randomSuffix} = Object.assign(args${randomSuffix}, { app, obsidianModule: obsidianModule${randomSuffix}, context: context${randomSuffix} });
-  try {
-    const result${randomSuffix} = await fn${randomSuffix}(fullArgs${randomSuffix});
-    if (result${randomSuffix} === undefined) {
-      return "";
-    }
-    return JSON.stringify(result${randomSuffix});
-  } catch (evalError${randomSuffix}) {
-    return JSON.stringify({ ${EVAL_ERROR_MARKER}: serializeError(evalError${randomSuffix}) });
-  }
-})()`;
+  const expression = generateFunctionCall(evalWrapper, {
+    args,
+    contextId,
+    ensureLayoutReady,
+    fn,
+    getObsidianModule,
+    serializeError
+  });
   const resultStr = await transport.evaluate(expression, { cwd });
   if (resultStr === "" || resultStr === NO_OUTPUT) {
     return void 0;
   }
-  let parsed;
+  let envelope;
   try {
-    parsed = JSON.parse(resultStr);
+    envelope = JSON.parse(resultStr);
   } catch {
     throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);
   }
-  if (parsed !== null && typeof parsed === "object" && EVAL_ERROR_MARKER in parsed) {
-    const errorDetail = String(parsed[EVAL_ERROR_MARKER]);
-    const sanitizedDetail = errorDetail.replace(/\(https?:\/\/localhost\/:(?<line>\d)/g, "(obsidian-webview:$<line>");
-    throw new Error(`evalInObsidian: Error inside Obsidian:
+  if ("type" in envelope) {
+    if (envelope.type === "error") {
+      const sanitizedDetail = envelope.value.replace(/\(https?:\/\/localhost\/:(?<line>\d)/g, "(obsidian-webview:$<line>");
+      throw new Error(`evalInObsidian: Error inside Obsidian:
 ${sanitizedDetail}`);
+    }
+    return void 0;
   }
-  return parsed;
+  return envelope.value;
 }
-async function getObsidianModule() {
-  const app = window.app;
+async function evalWrapper(params) {
+  const app = params.app;
+  if (!app.plugins.isEnabled()) {
+    await app.plugins.setEnable(true);
+  }
+  const obsidianModule = await params.getObsidianModule(params);
+  const contextHolder = window;
+  const contextRaw = params.contextId ? (contextHolder.__obsidianContexts__ ??= {})[String(params.contextId)] ??= {} : {};
+  const context = contextRaw;
+  const fullArgs = { ...params.args, app, context, obsidianModule };
+  try {
+    const result = await params.fn(fullArgs);
+    if (result === void 0) {
+      return JSON.stringify({ type: "undefined" });
+    }
+    return JSON.stringify({ value: result });
+  } catch (evalError) {
+    return JSON.stringify({ type: "error", value: params.serializeError(evalError) });
+  }
+}
+async function getObsidianModule(params) {
+  const app = params.app;
   const obsidianModuleHolder = app;
   if (obsidianModuleHolder.obsidianModule) {
     return obsidianModuleHolder.obsidianModule;
@@ -94,17 +94,17 @@ async function getObsidianModule() {
     return obsidianModuleHolder.obsidianModule;
   }
   throw new Error("Failed to load obsidian module");
-}
-function getObsidianModulePluginFn() {
-  const app = window.app;
-  const obsidianModuleHolder = app;
-  const pluginRequire = require;
-  const pluginExports = exports;
-  const obsidianModule = pluginRequire("obsidian");
-  obsidianModuleHolder.obsidianModule = obsidianModule;
-  pluginExports.default = obsidianModule.Plugin;
+  function getObsidianModulePluginFn() {
+    const app2 = window.app;
+    const obsidianModuleHolder2 = app2;
+    const pluginRequire = require;
+    const pluginExports = exports;
+    const obsidianModule = pluginRequire("obsidian");
+    obsidianModuleHolder2.obsidianModule = obsidianModule;
+    pluginExports.default = obsidianModule.Plugin;
+  }
 }
 export {
   evalInObsidian
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type { App } from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId\n} from './context-id.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { getTransportOptions } from './context-provider.mjs';\nimport { getFunctionExpressionString } from './function-expression.mjs';\nimport { jsonWithFunctions } from './json-with-functions.mjs';\nimport { serializeError } from './serialize-error.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\n\nconst EVAL_ERROR_MARKER = '__obsidianEvalError__';\n\ninterface ExportsWithDefault {\n  default: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  const SLICE_START = 2;\n  const randomSuffix = String(Math.random()).slice(SLICE_START);\n  const contextExpr = contextId\n    ? `((window.__obsidianContexts__ ??= {})[\"${String(contextId)}\"] ??= {})`\n    : '{}';\n  const expression = `\n(async () => {\n  const fn${randomSuffix} = ${getFunctionExpressionString(fn)};\n  const obsidianModule${randomSuffix} = await (async () => {\n    if (!app.workspace.app.workspace.layoutReady) {\n      await new Promise((resolve) => app.workspace.onLayoutReady(resolve));\n    }\n    if (!app.plugins.isEnabled()) {\n      await app.plugins.setEnable(true);\n    }\n    ${getFunctionExpressionString(getObsidianModulePluginFn)}\n    ${getFunctionExpressionString(getObsidianModule)}\n    return await getObsidianModule();\n  })();\n  ${getFunctionExpressionString(serializeError)}\n  const args${randomSuffix} = ${jsonWithFunctions(args)};\n  const context${randomSuffix} = ${contextExpr};\n  const fullArgs${randomSuffix} = Object.assign(args${randomSuffix}, { app, obsidianModule: obsidianModule${randomSuffix}, context: context${randomSuffix} });\n  try {\n    const result${randomSuffix} = await fn${randomSuffix}(fullArgs${randomSuffix});\n    if (result${randomSuffix} === undefined) {\n      return \"\";\n    }\n    return JSON.stringify(result${randomSuffix});\n  } catch (evalError${randomSuffix}) {\n    return JSON.stringify({ ${EVAL_ERROR_MARKER}: serializeError(evalError${randomSuffix}) });\n  }\n})()`;\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(resultStr);\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if (parsed !== null && typeof parsed === 'object' && EVAL_ERROR_MARKER in parsed) {\n    const errorDetail = String((parsed as Record<string, unknown>)[EVAL_ERROR_MARKER]);\n    // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n    // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n    // With EISDIR when it tries to readFileSync on the root directory.\n    const sanitizedDetail = errorDetail\n      .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n    throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n  }\n\n  return parsed as Result;\n}\n\n/* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process, not in Node. Covered by integration tests. */\n\n/**\n * Injected into the Obsidian process to resolve the `obsidian` module.\n * Uses a cached value on `app` if available, otherwise installs a temporary\n * plugin that calls `require('obsidian')` and caches the result.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n * `getObsidianModulePluginFn` must be defined in the same scope\n * (the generated IIFE handles this).\n *\n * @returns The `obsidian` module.\n */\nasync function getObsidianModule(): Promise<typeof obsidian> {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n  const app = window.app;\n  interface ObsidianModuleHolder {\n    obsidianModule: typeof obsidian;\n  }\n  const obsidianModuleHolder = app as Partial<ObsidianModuleHolder>;\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  const SLICE_START = 2;\n  const randomSuffix = String(Math.random()).slice(SLICE_START);\n  const tempModuleName = `get-obsidian-module-${randomSuffix}`;\n  const dir = `${app.vault.configDir}/plugins/${tempModuleName}`;\n  app.plugins.manifests[tempModuleName] = {\n    author: '',\n    description: '',\n    dir,\n    id: tempModuleName,\n    isDesktopOnly: false,\n    minAppVersion: '',\n    name: tempModuleName,\n    version: ''\n  };\n  await app.vault.adapter.mkdir(dir);\n  await app.vault.adapter.write(`${dir}/main.js`, `(${String(getObsidianModulePluginFn)})();`);\n  await app.plugins.loadPlugin(tempModuleName);\n  await app.plugins.uninstallPlugin(tempModuleName);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It will be initialized within `loadPlugin`.\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  throw new Error('Failed to load obsidian module');\n}\n\n/**\n * The body of the temporary plugin that extracts the `obsidian` module.\n * Serialized via `toString()` and written to `main.js` by {@link getObsidianModule}.\n * Must NOT reference any outer scope.\n */\nfunction getObsidianModulePluginFn(): void {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n  const app = window.app;\n  interface ObsidianModuleHolder {\n    obsidianModule: typeof obsidian;\n  }\n  const obsidianModuleHolder = app as Partial<ObsidianModuleHolder>;\n\n  const pluginRequire = require;\n  const pluginExports = exports as ExportsWithDefault;\n\n  const obsidianModule = pluginRequire('obsidian') as typeof obsidian;\n  obsidianModuleHolder.obsidianModule = obsidianModule;\n  pluginExports.default = obsidianModule.Plugin;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\n */\n\nimport type { App } from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId,\n  ContextOf\n} from './context-id.mjs';\nimport type {\n  EnsureLayoutReadyParams,\n  GenerateFunctionCallParams\n} from './generate-function-call.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { getTransportOptions } from './context-provider.mjs';\nimport {\n  ensureLayoutReady,\n  generateFunctionCall\n} from './generate-function-call.mjs';\nimport { serializeError } from './serialize-error.mjs';\nimport { getOrCreateTransport } from './transport-factory.mjs';\n\n/**\n * Discriminated envelope returned by {@link evalWrapper} from inside the Obsidian process.\n *\n * - `{ type: 'error', value: string }` \u2014 `fn` threw; `value` is the serialized error.\n * - `{ type: 'undefined' }` \u2014 `fn` returned `undefined`.\n * - `{ value: unknown }` \u2014 `fn` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | { type: 'error'; value: string }\n  | { type: 'undefined' }\n  | { value: unknown };\n\ninterface ExportsWithDefault {\n  default: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  transport?: ObsidianTransport;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\ninterface EvalWrapperParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> extends EnsureLayoutReadyParams {\n  args: Args;\n  contextId: TContextId;\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n  getObsidianModule(params: GenerateFunctionCallParams): Promise<typeof obsidian>;\n  serializeError(error: unknown): string;\n}\n\ninterface ObsidianModuleHolder {\n  obsidianModule: typeof obsidian;\n}\n\n/* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process, not in Node. Covered by integration tests. */\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the active transport and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  const expression = generateFunctionCall(evalWrapper, {\n    args,\n    contextId,\n    ensureLayoutReady,\n    fn,\n    getObsidianModule,\n    serializeError\n  });\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultStr) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n\n/**\n * The top-level wrapper that is serialized and invoked inside the Obsidian\n * process via {@link generateFunctionCall}. It wires up the obsidian module,\n * context, and error handling, then delegates to the caller-supplied `fn`.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n *\n * @param params - The parameters for the wrapper.\n * @param params.args - The user-supplied arguments to pass to `fn`.\n * @param params.contextId - The context identifier for persistent storage.\n * @param params.fn - The user function to evaluate.\n * @param params.resolveObsidianModule - Resolves the `obsidian` module at runtime.\n * @param params.stringifyError - Serializes an error into a human-readable string.\n * @returns A JSON-stringified {@link EvalResultEnvelope}.\n */\nasync function evalWrapper<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: GenerateFunctionCallParams<EvalWrapperParams<Args, Result, TContextId>>\n): Promise<string> {\n  const app = params.app;\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n  const obsidianModule = await params.getObsidianModule(params);\n  interface ContextHolder {\n    __obsidianContexts__: Record<string, Record<string, unknown>>;\n  }\n  const contextHolder = window as Partial<ContextHolder>;\n  const contextRaw = params.contextId\n    ? ((contextHolder.__obsidianContexts__ ??= {})[String(params.contextId)] ??= {})\n    : {};\n  const context = contextRaw as ContextOf<TContextId>;\n  const fullArgs = ({ ...params.args, app, context, obsidianModule }) as Args & CommonArgs & ContextArgs<TContextId>;\n  try {\n    const result = await params.fn(fullArgs) as Result | undefined;\n    if (result === undefined) {\n      return JSON.stringify({ type: 'undefined' });\n    }\n    return JSON.stringify({ value: result });\n  } catch (evalError) {\n    return JSON.stringify({ type: 'error', value: params.serializeError(evalError) });\n  }\n}\n\n/**\n * Injected into the Obsidian process to resolve the `obsidian` module.\n * Uses a cached value on `app` if available, otherwise installs a temporary\n * plugin that calls `require('obsidian')` and caches the result.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n * `getObsidianModulePluginFn` must be defined in the same scope\n * (the generated IIFE handles this).\n *\n * @param params - The parameters, including the `app` instance.\n * @returns The `obsidian` module.\n */\nasync function getObsidianModule(params: GenerateFunctionCallParams): Promise<typeof obsidian> {\n  const app = params.app;\n\n  const obsidianModuleHolder = app as Partial<ObsidianModuleHolder>;\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  const SLICE_START = 2;\n  const randomSuffix = String(Math.random()).slice(SLICE_START);\n  const tempModuleName = `get-obsidian-module-${randomSuffix}`;\n  const dir = `${app.vault.configDir}/plugins/${tempModuleName}`;\n  app.plugins.manifests[tempModuleName] = {\n    author: '',\n    description: '',\n    dir,\n    id: tempModuleName,\n    isDesktopOnly: false,\n    minAppVersion: '',\n    name: tempModuleName,\n    version: ''\n  };\n  await app.vault.adapter.mkdir(dir);\n  await app.vault.adapter.write(`${dir}/main.js`, `(${String(getObsidianModulePluginFn)})();`);\n  await app.plugins.loadPlugin(tempModuleName);\n  await app.plugins.uninstallPlugin(tempModuleName);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It will be initialized within `loadPlugin`.\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  throw new Error('Failed to load obsidian module');\n\n  /**\n   * The body of the temporary plugin that extracts the `obsidian` module.\n   * Serialized via `toString()` and written to `main.js` by {@link getObsidianModule}.\n   * Must NOT reference any outer scope.\n   */\n  function getObsidianModulePluginFn(): void {\n    // eslint-disable-next-line @typescript-eslint/no-deprecated, no-shadow -- We need global `app` variable. Intentional redeclaration \u2014 self-contained serialized function.\n    const app = window.app;\n\n    const obsidianModuleHolder2 = app as Partial<ObsidianModuleHolder>;\n\n    const pluginRequire = require;\n    const pluginExports = exports as ExportsWithDefault;\n\n    const obsidianModule = pluginRequire('obsidian') as typeof obsidian;\n    obsidianModuleHolder2.obsidianModule = obsidianModule;\n    pluginExports.default = obsidianModule.Plugin;\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["app"]
}
