obsidian-integration-testing 2.7.2 → 3.0.1

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

@@ -29,8 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var transport_desktop_cli_exports = {};
 __export(transport_desktop_cli_exports, {
   DesktopCliTransport: () => DesktopCliTransport,
-  destroyCurrentWindow: () => destroyCurrentWindow,
-  ipcSendSync: () => ipcSendSync
+  invokeAndWriteResult: () => invokeAndWriteResult
 });
 module.exports = __toCommonJS(transport_desktop_cli_exports);
 var import_node_fs = require("node:fs");
@@ -40,8 +39,8 @@ 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_namespace_bootstrap = require("./namespace-bootstrap.cjs");
 var import_noop = require("./noop.cjs");
 var import_obsidian_config = require("./obsidian-config.cjs");
 var import_serialize_error = require("./serialize-error.cjs");
@@ -76,20 +75,22 @@ class DesktopCliTransport {
     const SLICE_START = 2;
     const scriptId = String(Math.random()).slice(SLICE_START);
     const scriptDir = (0, import_node_path.join)((0, import_node_os.tmpdir)(), "obsidian-integration-testing");
-    const scriptPath = (0, import_node_path.join)(scriptDir, `${scriptId}.cjs`);
+    const scriptPath = (0, import_node_path.join)(scriptDir, `${scriptId}.js`);
     const resultPath = (0, import_node_path.join)(scriptDir, `${scriptId}.result.json`);
     await (0, import_promises.mkdir)(scriptDir, { recursive: true });
-    const invokeName = `invoke_${scriptId}`;
-    const scriptContent = buildScriptFile(expression, resultPath, invokeName);
+    const scriptContent = buildScriptFile(expression, resultPath);
     await (0, import_promises.writeFile)(scriptPath, scriptContent);
     try {
-      const safeRequire = `module.constructor._load(${JSON.stringify(scriptPath.replace(/\\/g, "/"))})`;
-      const requireExpr = `(async () => { await ${safeRequire}.${invokeName}() })()`;
-      const command = ["obsidian", "eval", "--allow-focus-steal", `code=${requireExpr}`];
+      const safeScriptPath = scriptPath.replace(/\\/g, "/");
+      const cliExpr = `(${(0, import_function_expression.getFunctionExpressionString)(executeScriptFile)})(${JSON.stringify(safeScriptPath)})`;
+      const vaultId = (0, import_obsidian_config.getVaultId)(options.cwd);
+      const command = ["obsidian", ...vaultId ? [`vault=${vaultId}`] : [], "eval", "--allow-focus-steal", `code=${cliExpr}`];
+      let execResult;
       try {
-        await (0, import_exec.exec)(command, {
+        execResult = await (0, import_exec.exec)(command, {
           cwd: options.cwd,
           isQuiet: true,
+          shouldIncludeDetails: true,
           ...options.timeoutInMilliseconds !== void 0 && { timeoutInMilliseconds: options.timeoutInMilliseconds }
         });
       } catch (error) {
@@ -101,7 +102,16 @@ class DesktopCliTransport {
         }
       }
       if (!(0, import_node_fs.existsSync)(resultPath)) {
-        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.`);
+        const diagnostics = await buildDiagnostics({
+          command,
+          cwd: options.cwd,
+          execResult,
+          resultPath,
+          scriptContent,
+          scriptPath
+        });
+        throw new Error(`Script did not execute for path: ${options.cwd}
+${diagnostics}`);
       }
       const resultStr = await (0, import_promises.readFile)(resultPath, "utf-8");
       const envelope = JSON.parse(resultStr);
@@ -121,7 +131,8 @@ class DesktopCliTransport {
    * Runs CLI-specific preflight checks.
    *
    * Verifies that the vault is registered, CLI is enabled in Obsidian settings,
-   * and the `obsidian` CLI binary is available in PATH.
+   * and the `obsidian` CLI binary is available in PATH. If the vault is registered
+   * but not open, opens it via URI protocol and polls until it is ready.
    *
    * @param vaultPath - The absolute path to the vault folder.
    */
@@ -138,6 +149,11 @@ class DesktopCliTransport {
       await this.restartObsidian(vaultPath);
     }
     await this.assertCliAvailable();
+    if (!(0, import_obsidian_config.isVaultOpen)(vaultPath)) {
+      (0, import_log.log)(`[cli-transport] Vault is registered but not open: ${vaultPath}. Opening via URI...`);
+      await openVaultViaUri(vaultPath);
+      await this.pollVaultReady(vaultPath);
+    }
     (0, import_log.log)("[cli-transport] Preflight check passed.");
   }
   /**
@@ -152,7 +168,8 @@ class DesktopCliTransport {
     (0, import_log.log)(`[cli-transport] Registering vault: ${vaultPath}`);
     const existingVaultPath = (0, import_obsidian_config.getAnyRegisteredVaultPath)();
     if (existingVaultPath) {
-      const registerExpr = (0, import_generate_function_call.generateFunctionCall)(ipcSendSync, { args: [vaultPath, false], channel: "vault-open", ensureLayoutReady: import_generate_function_call.ensureLayoutReady });
+      await (0, import_namespace_bootstrap.ensureNamespaceBootstrapped)(this, existingVaultPath);
+      const registerExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath, false], channel: "vault-open" })})`;
       await this.evaluate(registerExpr, { cwd: existingVaultPath });
       await this.enablePluginsInLocalStorage(vaultPath, existingVaultPath);
     } else {
@@ -160,22 +177,12 @@ class DesktopCliTransport {
       (0, import_obsidian_config.registerVaultInConfig)(vaultPath);
       (0, import_log.log)("[cli-transport] Vault entry written. Opening vault via URI protocol...");
       await openVaultViaUri(vaultPath);
+      await this.pollVaultReady(vaultPath);
+      await this.enablePluginsInLocalStorage(vaultPath, vaultPath);
+      await this.dismissTrustDialog(vaultPath);
+      return;
     }
-    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) {
-      try {
-        const basePath = await this.evaluate(pollExpr, { cwd: vaultPath });
-        if (JSON.parse(basePath) === vaultPath) {
-          (0, import_log.log)("[cli-transport] Vault is ready.");
-          return;
-        }
-      } catch {
-      }
-      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);
-    }
-    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);
+    await this.pollVaultReady(vaultPath);
   }
   /**
    * Unregisters a vault from the running Obsidian instance.
@@ -187,8 +194,9 @@ class DesktopCliTransport {
    */
   async unregisterVault(vaultPath) {
     (0, import_log.log)(`[cli-transport] Unregistering vault: closing window for ${vaultPath}...`);
-    const destroyExpr = (0, import_generate_function_call.generateFunctionCall)(destroyCurrentWindow, { ensureLayoutReady: import_generate_function_call.ensureLayoutReady });
     try {
+      await (0, import_namespace_bootstrap.ensureNamespaceBootstrapped)(this, vaultPath);
+      const destroyExpr = "window.__obsidianIntegrationTesting.destroyCurrentWindow()";
       await this.evaluate(destroyExpr, { cwd: vaultPath, timeoutInMilliseconds: VAULT_EVAL_TIMEOUT_IN_MILLISECONDS });
       (0, import_log.log)("[cli-transport] Window destroy command sent.");
     } catch (error) {
@@ -197,10 +205,11 @@ 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 = (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 (0, import_namespace_bootstrap.ensureNamespaceBootstrapped)(this, existingVaultForRemoval);
+        const removeExpr = `window.__obsidianIntegrationTesting.ipcSendSync(${JSON.stringify({ args: [vaultPath], channel: "vault-remove" })})`;
         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 removing directly from obsidian.json.");
@@ -222,6 +231,33 @@ class DesktopCliTransport {
       throw new Error("Obsidian CLI is not available. Ensure Obsidian is installed and its CLI is in your PATH.");
     }
   }
+  /**
+   * Dismisses the "Do you trust the author of this vault?" dialog if present.
+   *
+   * Clicks the "Trust author and enable plugins" button (`.mod-cta`) inside any
+   * modal whose text includes "Do you trust the author". This is needed when a
+   * vault with community plugins is opened without a prior `enable-plugin-<id>`
+   * entry in localStorage (e.g., the very first vault registered via config file).
+   *
+   * @param vaultPath - The vault path to evaluate in.
+   */
+  async dismissTrustDialog(vaultPath) {
+    await (0, import_namespace_bootstrap.ensureNamespaceBootstrapped)(this, vaultPath);
+    const dismissExpr = `(function() {
+      var modals = document.querySelectorAll('.modal-container');
+      for (var i = 0; i < modals.length; i++) {
+        if (modals[i].textContent.includes('Do you trust the author')) {
+          var btn = modals[i].querySelector('.mod-cta');
+          if (btn) { btn.click(); return true; }
+        }
+      }
+      return false;
+    })()`;
+    const result = await this.evaluate(dismissExpr, { cwd: vaultPath });
+    if (result === "true") {
+      (0, import_log.log)('[cli-transport] Dismissed "Do you trust the author" dialog.');
+    }
+  }
   /**
    * Sets `enable-plugin-<vaultId>` in Obsidian's localStorage to prevent
    * the "Do you trust the author of this vault?" dialog from appearing
@@ -241,7 +277,8 @@ class DesktopCliTransport {
       (0, import_log.log)("[cli-transport] Could not find vault ID \u2014 skipping localStorage trust flag.");
       return;
     }
-    const enableExpr = (0, import_generate_function_call.generateFunctionCall)(setLocalStorageItem, { ensureLayoutReady: import_generate_function_call.ensureLayoutReady, key: `enable-plugin-${vaultId}`, value: "true" });
+    await (0, import_namespace_bootstrap.ensureNamespaceBootstrapped)(this, evalTargetVaultPath);
+    const enableExpr = `window.__obsidianIntegrationTesting.setLocalStorageItem(${JSON.stringify({ key: `enable-plugin-${vaultId}`, value: "true" })})`;
     await this.evaluate(enableExpr, { cwd: evalTargetVaultPath });
     (0, import_log.log)(`[cli-transport] Set enable-plugin-${vaultId} in localStorage.`);
   }
@@ -275,6 +312,34 @@ class DesktopCliTransport {
     }
     throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);
   }
+  /**
+   * Polls until the vault is ready and responding to eval calls.
+   *
+   * @param vaultPath - The absolute path to the vault folder.
+   */
+  async pollVaultReady(vaultPath) {
+    const pollExpr = "window.__obsidianIntegrationTesting.pollVaultBasePath()";
+    (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;
+    let isBootstrapped = false;
+    while (Date.now() < deadline) {
+      try {
+        if (!isBootstrapped) {
+          await (0, import_namespace_bootstrap.ensureNamespaceBootstrapped)(this, vaultPath);
+          isBootstrapped = true;
+        }
+        const basePath = await this.evaluate(pollExpr, { cwd: vaultPath });
+        if (JSON.parse(basePath) === vaultPath) {
+          (0, import_log.log)("[cli-transport] Vault is ready.");
+          return;
+        }
+      } catch {
+        isBootstrapped = false;
+      }
+      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);
+    }
+    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);
+  }
   /**
    * Restarts Obsidian by killing the running process and relaunching it.
    *
@@ -289,48 +354,101 @@ class DesktopCliTransport {
     } catch {
     }
     await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);
-    const command = ["obsidian", "eval", "--vault", vaultPath, "--expression", '"1"'];
+    const restartVaultId = (0, import_obsidian_config.getVaultId)(vaultPath);
+    const command = ["obsidian", ...restartVaultId ? [`vault=${restartVaultId}`] : [], "eval", 'code="1"'];
     await this.ensureObsidianRunningAndRetry(command, vaultPath);
   }
 }
-async function destroyCurrentWindow(params) {
-  await params.ensureLayoutReady(params);
-  await sleep(0);
-  window.electronWindow.destroy();
-}
-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, "/"));
-  return `"use strict";
-const fs = require("fs");
-const serializeError = ${(0, import_function_expression.getFunctionExpressionString)(import_serialize_error.serializeError)};
-
-async function ${invokeName}() {
+async function invokeAndWriteResult(params) {
+  const { writeFile: writeResultFile } = window.require("node:fs/promises");
   try {
-    const result = await (${expression});
-    if (result === undefined) {
-      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: "", type: "undefined" }));
+    const result = await params.evaluate();
+    if (result === void 0) {
+      await writeResultFile(params.resultPath, JSON.stringify({ type: "undefined", value: "" }));
     } else if (result === null) {
-      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: "", type: "null" }));
+      await writeResultFile(params.resultPath, JSON.stringify({ type: "null", value: "" }));
     } else {
-      fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: String(result) }));
+      await writeResultFile(params.resultPath, JSON.stringify({ value: String(result) }));
     }
   } catch (err) {
-    fs.writeFileSync(${resultPathJson}, JSON.stringify({ value: serializeError(err), type: "error" }));
+    await writeResultFile(params.resultPath, JSON.stringify({ type: "error", value: params.serializeError(err) }));
+  }
+}
+async function buildDiagnostics(params) {
+  const lines = [];
+  lines.push(`  Command: ${params.command.join(" ")}`);
+  lines.push(`  Working directory: ${params.cwd}`);
+  lines.push(`  Script path: ${params.scriptPath}`);
+  lines.push(`  Expected result file: ${params.resultPath}`);
+  if (params.execResult) {
+    lines.push(`  Exit code: ${params.execResult.exitCode === null ? "(null \u2014 process did not exit normally)" : String(params.execResult.exitCode)}`);
+    if (params.execResult.exitSignal) {
+      lines.push(`  Exit signal: ${params.execResult.exitSignal}`);
+    }
+    if (params.execResult.stdout.trim()) {
+      lines.push(`  stdout: ${params.execResult.stdout.trim()}`);
+    }
+    if (params.execResult.stderr.trim()) {
+      lines.push(`  stderr: ${params.execResult.stderr.trim()}`);
+    }
+    if (!params.execResult.stdout.trim() && !params.execResult.stderr.trim()) {
+      lines.push("  stdout/stderr: (empty)");
+    }
+  } else {
+    lines.push("  exec result: (not available \u2014 Obsidian was auto-started and retried)");
+  }
+  lines.push("Environment checks:");
+  lines.push(`  Obsidian running: ${await isObsidianRunning() ? "yes" : "NO"}`);
+  lines.push(`  CLI enabled in obsidian.json: ${(0, import_obsidian_config.isCliEnabled)() ? "yes" : "NO"}`);
+  lines.push(`  Vault registered: ${(0, import_obsidian_config.isVaultRegistered)(params.cwd) ? "yes" : "NO"}`);
+  lines.push(`  Script file exists: ${(0, import_node_fs.existsSync)(params.scriptPath) ? "yes" : "no (already cleaned up)"}`);
+  lines.push(`  Result file exists: ${(0, import_node_fs.existsSync)(params.resultPath) ? "yes" : "no"}`);
+  const registeredVaults = (0, import_obsidian_config.getRegisteredVaults)();
+  if (registeredVaults.length === 0) {
+    lines.push("  Registered vaults: (none)");
+  } else {
+    lines.push("  Registered vaults:");
+    for (const vault of registeredVaults) {
+      lines.push(`    - ${vault.path} (open: ${String(vault.open)})`);
+    }
   }
+  lines.push(`  Script content:
+${params.scriptContent}`);
+  return lines.join("\n");
 }
-
-exports.${invokeName} = ${invokeName};
-`;
+function buildScriptFile(expression, resultPath) {
+  const fnStr = (0, import_function_expression.getFunctionExpressionString)(invokeAndWriteResult);
+  const serializeErrorStr = (0, import_function_expression.getFunctionExpressionString)(import_serialize_error.serializeError);
+  const resultPathJson = JSON.stringify(resultPath.replace(/\\/g, "/"));
+  return `(${fnStr})({ evaluate: async () => (${expression}), resultPath: ${resultPathJson}, serializeError: ${serializeErrorStr} })`;
 }
 function delay(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
 }
+async function executeScriptFile(scriptPath) {
+  const fsPromises = window.require("node:fs/promises");
+  try {
+    await fsPromises.access(scriptPath);
+  } catch (cause) {
+    throw new Error(`Script file not found: ${scriptPath}`, { cause });
+  }
+  const script = await fsPromises.readFile(scriptPath, "utf-8");
+  console.debug(`Executing ${scriptPath}:
+${script}`);
+  let fn;
+  try {
+    fn = new Function(`return ${script}`);
+  } catch (cause) {
+    throw new Error(`Error parsing ${scriptPath}`, { cause });
+  }
+  try {
+    await fn();
+  } catch (cause) {
+    throw new Error(`Error executing ${scriptPath}`, { cause });
+  }
+}
 function getKillObsidianCommand() {
   if (import_node_process.default.platform === "win32") {
     return "taskkill /IM Obsidian.exe /F";
@@ -356,9 +474,24 @@ function getOpenUriCommand(uri) {
   }
   return `xdg-open "${uri}"`;
 }
+async function isObsidianRunning() {
+  const command = import_node_process.default.platform === "win32" ? 'tasklist /FI "IMAGENAME eq Obsidian.exe" /NH' : "pgrep -f Obsidian";
+  try {
+    const output = await (0, import_exec.exec)(command, { isQuiet: true });
+    if (import_node_process.default.platform === "win32") {
+      return output.includes("Obsidian.exe");
+    }
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
 async function openVaultViaUri(vaultPath) {
-  const encodedPath = encodeURIComponent(vaultPath);
-  const uri = `obsidian://open?path=${encodedPath}`;
+  const vaultId = (0, import_obsidian_config.getVaultId)(vaultPath);
+  if (!vaultId) {
+    throw new Error(`Cannot open vault via URI: vault is not registered in obsidian.json: ${vaultPath}`);
+  }
+  const uri = `obsidian://open?vault=${encodeURIComponent(vaultId)}`;
   const command = getOpenUriCommand(uri);
   (0, import_log.log)(`[cli-transport] Opening vault via URI: ${uri}`);
   try {
@@ -367,18 +500,9 @@ async function openVaultViaUri(vaultPath) {
     (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,
-  destroyCurrentWindow,
-  ipcSendSync
+  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 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"]
}

+//# 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 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  const { writeFile: writeResultFile } = window.require('node:fs/promises') as typeof import('node:fs/promises');\n  try {\n    const result = await params.evaluate();\n    if (result === undefined) {\n      await writeResultFile(params.resultPath, JSON.stringify({ type: 'undefined', value: '' }));\n    } else if (result === null) {\n      await writeResultFile(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 writeResultFile(params.resultPath, JSON.stringify({ value: String(result) }));\n    }\n  } catch (err) {\n    await writeResultFile(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  const fsPromises = window.require('node:fs/promises') as typeof import('node:fs/promises');\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": "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",
  "names": ["process"]
}
