obsidian-integration-testing 1.1.2 → 1.2.0

package/dist/lib/esm/transport-desktop-cdp.mjs

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


package/dist/lib/esm/transport-desktop-cli.d.mts

@@ -0,0 +1,65 @@
+/**
+ * @file
+ *
+ * Desktop CLI transport — evaluates expressions via `obsidian eval` and manages
+ * vaults via Electron IPC.
+ */
+import type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
+/**
+ * Transport that communicates with Desktop Obsidian via the `obsidian eval` CLI command
+ * and manages vaults via Electron IPC.
+ */
+export declare class DesktopCliTransport implements ObsidianTransport {
+    /** */
+    readonly isMobile = false;
+    /**
+     * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.
+     *
+     * Handles auto-start: if Obsidian is not running, launches it via URI protocol
+     * and retries until it becomes available.
+     *
+     * @param expression - The JavaScript expression to evaluate.
+     * @param options - Evaluation options.
+     * @returns The normalized result string (transport-specific prefixes stripped).
+     */
+    evaluate(expression: string, options: TransportEvalOptions): Promise<string>;
+    /**
+     * 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.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    preflightCheck(vaultPath: string): Promise<void>;
+    /**
+     * Registers a vault in the running Obsidian instance via Electron IPC.
+     *
+     * Uses `vault-open` IPC to register and open the vault, then polls until
+     * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    registerVault(vaultPath: string): Promise<void>;
+    /**
+     * Unregisters a vault from the running Obsidian instance.
+     *
+     * Schedules the vault window to close, waits, then removes the vault
+     * from the registry via `vault-remove` IPC.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    unregisterVault(vaultPath: string): Promise<void>;
+    /**
+     * Checks whether the Obsidian CLI binary is available in the system PATH.
+     */
+    private assertCliAvailable;
+    /**
+     * Launches Obsidian binary and retries the eval until it responds.
+     *
+     * @param command - The CLI command array to retry.
+     * @param cwd - The working directory.
+     * @returns The result string from the successful eval.
+     */
+    private ensureObsidianRunningAndRetry;
+}