obsidian-integration-testing 1.2.0 → 1.2.2

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

@@ -72,6 +72,7 @@ class DesktopCdpTransport {
    * @param vaultPath - The vault path (used for vault registration check).
    */
   async preflightCheck(vaultPath) {
+    console.warn(`[cdp-transport] Running preflight check for vault: ${vaultPath}`);
     if (!isVaultRegistered(vaultPath)) {
       throw new Error(
         `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`
@@ -82,6 +83,7 @@ class DesktopCdpTransport {
       if (targets.length === 0) {
         throw new Error("No page targets");
       }
+      console.warn(`[cdp-transport] CDP reachable, ${String(targets.length)} target(s) found.`);
     } catch {
       await this.ensureObsidianRunning();
     }
@@ -95,6 +97,7 @@ class DesktopCdpTransport {
    * @param vaultPath - The absolute path to the vault folder.
    */
   async registerVault(vaultPath) {
+    console.warn(`[cdp-transport] Registering vault: ${vaultPath}`);
     const targets = await this.getPageTargets();
     if (targets.length === 0) {
       throw new Error("No Obsidian CDP targets available. Is Obsidian running?");
@@ -112,10 +115,12 @@ class DesktopCdpTransport {
     } finally {
       ipcWs.close();
     }
+    console.warn(`[cdp-transport] Polling for vault target (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);
     const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;
     while (Date.now() < deadline) {
       try {
         await this.findTargetForVault(vaultPath);
+        console.warn("[cdp-transport] Vault target found.");
         return;
       } catch {
       }
@@ -222,20 +227,23 @@ class DesktopCdpTransport {
    * 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...");
+    console.warn("[cdp-transport] Obsidian CDP not reachable. Starting Obsidian with remote debugging...");
     try {
       await exec(getObsidianLaunchCommand(this.cdpPort), { isQuiet: true });
     } catch {
     }
+    console.warn(`[cdp-transport] Polling for CDP endpoint at ${this.cdpUrl} (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);
     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) {
+          console.warn(`[cdp-transport] Obsidian CDP ready, ${String(targets.length)} target(s) found.`);
           return;
         }
       } catch {
+        console.warn("[cdp-transport] CDP not ready yet, retrying...");
       }
     }
     throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms. Ensure Obsidian is installed and accessible.`);
@@ -353,4 +361,4 @@ function getObsidianLaunchCommand(port) {
 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": []
}

+//# 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    console.warn(`[cdp-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    try {\n      const targets = await this.getPageTargets();\n      if (targets.length === 0) {\n        throw new Error('No page targets');\n      }\n      console.warn(`[cdp-transport] CDP reachable, ${String(targets.length)} target(s) found.`);\n    } catch {\n      await this.ensureObsidianRunning();\n    }\n  }\n\n  /**\n   * Registers a vault via Electron IPC evaluated through CDP.\n   *\n   * Uses an existing Obsidian target to send the `vault-open` IPC command,\n   * then polls until the new vault's target appears.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    console.warn(`[cdp-transport] Registering vault: ${vaultPath}`);\n    const targets = await this.getPageTargets();\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets available. Is Obsidian running?');\n    }\n\n    const ipcWs = await this.connectToTarget(ensureNonNullable(targets[0]));\n    try {\n      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    console.warn(`[cdp-transport] Polling for vault target (timeout=${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + VAULT_POLL_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      try {\n        await this.findTargetForVault(vaultPath);\n        console.warn('[cdp-transport] Vault target found.');\n        return;\n      } catch {\n        // Vault target not ready yet.\n      }\n      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\n  }\n\n  /**\n   * Unregisters a vault by destroying its window and removing it from the registry.\n   *\n   * @param vaultPath - The absolute path to the vault folder.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    try {\n      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('[cdp-transport] Obsidian CDP not reachable. Starting Obsidian with remote debugging...');\n\n    try {\n      await exec(getObsidianLaunchCommand(this.cdpPort), { isQuiet: true });\n    } catch {\n      // The launch command may fail on some systems \u2014 we'll still try polling.\n    }\n\n    console.warn(`[cdp-transport] Polling for CDP endpoint at ${this.cdpUrl} (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);\n    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;\n    while (Date.now() < deadline) {\n      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);\n      try {\n        const targets = await this.getPageTargets();\n        if (targets.length > 0) {\n          console.warn(`[cdp-transport] Obsidian CDP ready, ${String(targets.length)} target(s) found.`);\n          return;\n        }\n      } catch {\n        console.warn('[cdp-transport] CDP not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms. Ensure Obsidian is installed and accessible.`);\n  }\n\n  /**\n   * Finds the CDP target that has the given vault open.\n   *\n   * For a single target, returns it directly. For multiple targets,\n   * probes each by evaluating `getBasePath()` to find the match.\n   *\n   * @param vaultPath - The vault path to match.\n   * @returns The matching CDP target.\n   */\n  private async findTargetForVault(vaultPath: string): Promise<CdpTarget> {\n    const targets = await this.getPageTargets();\n\n    if (targets.length === 0) {\n      throw new Error('No Obsidian CDP targets found');\n    }\n\n    if (targets.length === 1) {\n      return ensureNonNullable(targets[0]);\n    }\n\n    for (const target of targets) {\n      try {\n        const basePath = await this.probeVaultPath(target);\n        if (basePath === vaultPath) {\n          return target;\n        }\n      } catch {\n        // Not a vault target or not ready.\n      }\n    }\n\n    throw new Error(`No CDP target found for vault: ${vaultPath}`);\n  }\n\n  /**\n   * Fetches the list of page-type targets from the CDP `/json` endpoint.\n   *\n   * @returns The list of page targets.\n   */\n  private async getPageTargets(): Promise<CdpTarget[]> {\n    const response = await fetch(`${this.cdpUrl}/json`);\n    const targets = await response.json() as CdpTarget[];\n    return targets.filter((t) => t.type === 'page');\n  }\n\n  /**\n   * Probes a target to discover which vault path it has open.\n   *\n   * Creates a temporary WebSocket connection, evaluates `getBasePath()`,\n   * and returns the result.\n   *\n   * @param target - The CDP target to probe.\n   * @returns The vault's base path.\n   */\n  private async probeVaultPath(target: CdpTarget): Promise<string> {\n    const ws = await this.connectToTarget(target);\n    try {\n      const response = await this.sendCommand(ws, 'Runtime.evaluate', {\n        expression: 'app.vault.adapter.getBasePath()',\n        returnByValue: true\n      });\n      return String(response.result?.result?.value);\n    } finally {\n      ws.close();\n    }\n  }\n\n  /**\n   * Sends a CDP command over WebSocket and waits for the response.\n   *\n   * @param ws - The WebSocket connection.\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The CDP response.\n   */\n  private async sendCommand(ws: WebSocket, method: string, params: Record<string, unknown>): Promise<CdpResponse> {\n    const id = ++this.messageId;\n\n    return new Promise<CdpResponse>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        ws.removeEventListener('message', handler);\n        reject(new Error(`CDP command timed out after ${String(this.commandTimeoutInMilliseconds)}ms: ${method}`));\n      }, this.commandTimeoutInMilliseconds);\n\n      function handler(event: MessageEvent): void {\n        const msg = JSON.parse(String(event.data)) as CdpResponse;\n        if (msg.id === id) {\n          clearTimeout(timeout);\n          ws.removeEventListener('message', handler);\n          resolve(msg);\n        }\n      }\n\n      ws.addEventListener('message', handler);\n      ws.send(JSON.stringify({ id, method, params }));\n    });\n  }\n}\n\n/**\n * 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.mjs

@@ -55,6 +55,7 @@ class DesktopCliTransport {
    * @param vaultPath - The absolute path to the vault folder.
    */
   async preflightCheck(vaultPath) {
+    console.warn(`[cli-transport] Running preflight check for vault: ${vaultPath}`);
     if (!isVaultRegistered(vaultPath)) {
       throw new Error(
         `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`
@@ -64,6 +65,7 @@ class DesktopCliTransport {
       throw new Error("Obsidian CLI is disabled. Enable it in Obsidian Settings \u2192 General \u2192 CLI.");
     }
     await this.assertCliAvailable();
+    console.warn("[cli-transport] Preflight check passed.");
   }
   /**
    * Registers a vault in the running Obsidian instance via Electron IPC.
@@ -74,6 +76,7 @@ class DesktopCliTransport {
    * @param vaultPath - The absolute path to the vault folder.
    */
   async registerVault(vaultPath) {
+    console.warn(`[cli-transport] Registering vault: ${vaultPath}`);
     const registerExpr = buildIpcExpression(
       `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false);`
     );
@@ -81,11 +84,13 @@ class DesktopCliTransport {
     const pollExpr = buildSimpleExpression(
       "return JSON.stringify(app.vault.adapter.getBasePath());"
     );
+    console.warn(`[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) {
+          console.warn("[cli-transport] Vault is ready.");
           return;
         }
       } catch {
@@ -139,21 +144,25 @@ class DesktopCliTransport {
    * @returns The result string from the successful eval.
    */
   async ensureObsidianRunningAndRetry(command, cwd) {
-    console.warn("Obsidian is not running. Starting Obsidian...");
+    console.warn("[cli-transport] Obsidian is not running. Starting Obsidian...");
     try {
       await exec(getObsidianLaunchCommand(), { isQuiet: true });
     } catch {
     }
+    console.warn(`[cli-transport] Polling for Obsidian CLI (timeout=${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms)...`);
     const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;
     while (Date.now() < deadline) {
       await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);
       try {
-        return await exec(command, { cwd, isQuiet: true });
+        const result = await exec(command, { cwd, isQuiet: true });
+        console.warn("[cli-transport] Obsidian CLI responded.");
+        return result;
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         if (!message.includes(UNABLE_TO_FIND_OBSIDIAN)) {
           throw error;
         }
+        console.warn("[cli-transport] Obsidian not ready yet, retrying...");
       }
     }
     throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);
@@ -187,4 +196,4 @@ function getObsidianLaunchCommand() {
 export {
   DesktopCliTransport
 };
-//# 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 process from 'node:process';\n\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\n\nimport { exec } from './exec.mjs';\nimport {\n  isCliEnabled,\n  isVaultRegistered\n} from './obsidian-config.mjs';\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;\n\n/**\n * Transport that communicates with Desktop Obsidian via the `obsidian eval` CLI command\n * and manages vaults via Electron IPC.\n */\nexport class DesktopCliTransport implements ObsidianTransport {\n  /** */\n  public readonly isMobile = false;\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.\n   *\n   * 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 command = ['obsidian', 'eval', `code=${expression}`];\n\n    let resultStr: string;\n    try {\n      resultStr = await exec(command, { cwd: options.cwd, isQuiet: true });\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n        resultStr = await this.ensureObsidianRunningAndRetry(command, options.cwd);\n      } else {\n        throw error;\n      }\n    }\n\n    if (resultStr === '' || resultStr === 'Vault not found.') {\n      throw new Error(`Unexpected empty response from Obsidian for path: ${options.cwd}`);\n    }\n\n    // The CLI may prepend error/warning lines before the result.\n    // Find the last `=> ` line which contains the actual result.\n    const lines = resultStr.split('\\n');\n    const resultLine = lines.findLast((line) => line.startsWith('=> '));\n    if (resultLine) {\n      return resultLine.slice('=> '.length);\n    }\n\n    return resultStr;\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    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    if (!isCliEnabled()) {\n      throw new Error('Obsidian CLI is disabled. Enable it in Obsidian Settings \\u2192 General \\u2192 CLI.');\n    }\n\n    await this.assertCliAvailable();\n  }\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    const registerExpr = buildIpcExpression(\n      `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false);`\n    );\n    await this.evaluate(registerExpr, { cwd: process.cwd() });\n\n    const pollExpr = buildSimpleExpression(\n      'return JSON.stringify(app.vault.adapter.getBasePath());'\n    );\n\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          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    const destroyExpr = buildSimpleExpression(`\n      setTimeout(() => {\n        if (window.electron && window.electron.remote) {\n          window.electron.remote.getCurrentWindow().destroy();\n        }\n      }, 0);\n    `);\n    try {\n      await this.evaluate(destroyExpr, { cwd: vaultPath });\n    } catch {\n      // The window may have closed before the response was sent \u2014 that's OK.\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const removeExpr = buildIpcExpression(\n      `window.electron.ipcRenderer.sendSync('vault-remove', ${JSON.stringify(vaultPath)});`\n    );\n    await this.evaluate(removeExpr, { cwd: process.cwd() });\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   * 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   * @returns The result string from the successful eval.\n   */\n  private async ensureObsidianRunningAndRetry(command: string[], cwd: string): Promise<string> {\n    console.warn('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    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        return await exec(command, { cwd, isQuiet: true });\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      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);\n  }\n}\n\n/**\n * Builds an async IIFE that waits for layout ready and executes an IPC call.\n * The return value is `JSON.stringify(undefined)` so the CLI produces `(no output)`.\n *\n * @param ipcStatement - The IPC statement to execute.\n * @returns The IIFE expression string.\n */\nfunction buildIpcExpression(ipcStatement: string): string {\n  return buildSimpleExpression(ipcStatement);\n}\n\n/**\n * Builds a simple async IIFE expression that waits for layout ready.\n *\n * @param body - The JavaScript statements to execute.\n * @returns The IIFE expression string.\n */\nfunction buildSimpleExpression(body: string): string {\n  return `(async () => {\n  if (!app.workspace.layoutReady) {\n    await new Promise((resolve) => app.workspace.onLayoutReady(resolve));\n  }\n  ${body}\n})()`;\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Returns the platform-specific command to launch the Obsidian binary.\n *\n * @returns The shell command string.\n */\nfunction getObsidianLaunchCommand(): string {\n  if (process.platform === 'win32') {\n    return 'start \"\" \"%LOCALAPPDATA%\\\\Programs\\\\Obsidian\\\\Obsidian.exe\"';\n  }\n\n  if (process.platform === 'darwin') {\n    return '/Applications/Obsidian.app/Contents/MacOS/Obsidian &';\n  }\n\n  return 'obsidian &';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# 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 process from 'node:process';\n\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\n\nimport { exec } from './exec.mjs';\nimport {\n  isCliEnabled,\n  isVaultRegistered\n} from './obsidian-config.mjs';\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;\n\n/**\n * Transport that communicates with Desktop Obsidian via the `obsidian eval` CLI command\n * and manages vaults via Electron IPC.\n */\nexport class DesktopCliTransport implements ObsidianTransport {\n  /** */\n  public readonly isMobile = false;\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.\n   *\n   * 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 command = ['obsidian', 'eval', `code=${expression}`];\n\n    let resultStr: string;\n    try {\n      resultStr = await exec(command, { cwd: options.cwd, isQuiet: true });\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n        resultStr = await this.ensureObsidianRunningAndRetry(command, options.cwd);\n      } else {\n        throw error;\n      }\n    }\n\n    if (resultStr === '' || resultStr === 'Vault not found.') {\n      throw new Error(`Unexpected empty response from Obsidian for path: ${options.cwd}`);\n    }\n\n    // The CLI may prepend error/warning lines before the result.\n    // Find the last `=> ` line which contains the actual result.\n    const lines = resultStr.split('\\n');\n    const resultLine = lines.findLast((line) => line.startsWith('=> '));\n    if (resultLine) {\n      return resultLine.slice('=> '.length);\n    }\n\n    return resultStr;\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    console.warn(`[cli-transport] Running preflight check for vault: ${vaultPath}`);\n    if (!isVaultRegistered(vaultPath)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    if (!isCliEnabled()) {\n      throw new Error('Obsidian CLI is disabled. Enable it in Obsidian Settings \\u2192 General \\u2192 CLI.');\n    }\n\n    await this.assertCliAvailable();\n    console.warn('[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    console.warn(`[cli-transport] Registering vault: ${vaultPath}`);\n    const registerExpr = buildIpcExpression(\n      `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false);`\n    );\n    await this.evaluate(registerExpr, { cwd: process.cwd() });\n\n    const pollExpr = buildSimpleExpression(\n      'return JSON.stringify(app.vault.adapter.getBasePath());'\n    );\n\n    console.warn(`[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          console.warn('[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    const destroyExpr = buildSimpleExpression(`\n      setTimeout(() => {\n        if (window.electron && window.electron.remote) {\n          window.electron.remote.getCurrentWindow().destroy();\n        }\n      }, 0);\n    `);\n    try {\n      await this.evaluate(destroyExpr, { cwd: vaultPath });\n    } catch {\n      // The window may have closed before the response was sent \u2014 that's OK.\n    }\n\n    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);\n\n    const removeExpr = buildIpcExpression(\n      `window.electron.ipcRenderer.sendSync('vault-remove', ${JSON.stringify(vaultPath)});`\n    );\n    await this.evaluate(removeExpr, { cwd: process.cwd() });\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   * 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   * @returns The result string from the successful eval.\n   */\n  private async ensureObsidianRunningAndRetry(command: string[], cwd: string): Promise<string> {\n    console.warn('[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    console.warn(`[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        const result = await exec(command, { cwd, isQuiet: true });\n        console.warn('[cli-transport] Obsidian CLI responded.');\n        return result;\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        console.warn('[cli-transport] Obsidian not ready yet, retrying...');\n      }\n    }\n\n    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);\n  }\n}\n\n/**\n * Builds an async IIFE that waits for layout ready and executes an IPC call.\n * The return value is `JSON.stringify(undefined)` so the CLI produces `(no output)`.\n *\n * @param ipcStatement - The IPC statement to execute.\n * @returns The IIFE expression string.\n */\nfunction buildIpcExpression(ipcStatement: string): string {\n  return buildSimpleExpression(ipcStatement);\n}\n\n/**\n * Builds a simple async IIFE expression that waits for layout ready.\n *\n * @param body - The JavaScript statements to execute.\n * @returns The IIFE expression string.\n */\nfunction buildSimpleExpression(body: string): string {\n  return `(async () => {\n  if (!app.workspace.layoutReady) {\n    await new Promise((resolve) => app.workspace.onLayoutReady(resolve));\n  }\n  ${body}\n})()`;\n}\n\n/**\n * Returns a promise that resolves after the given delay.\n *\n * @param ms - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(ms: number): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\n/**\n * Returns the platform-specific command to launch the Obsidian binary.\n *\n * @returns The shell command string.\n */\nfunction getObsidianLaunchCommand(): string {\n  if (process.platform === 'win32') {\n    return 'start \"\" \"%LOCALAPPDATA%\\\\Programs\\\\Obsidian\\\\Obsidian.exe\"';\n  }\n\n  if (process.platform === 'darwin') {\n    return '/Applications/Obsidian.app/Contents/MacOS/Obsidian &';\n  }\n\n  return 'obsidian &';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/transport-factory.mjs

@@ -1,23 +1,31 @@
+import http from "node:http";
 import { remote } from "webdriverio";
 import { AppiumTransport } from "./transport-appium.mjs";
 import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
 import { DesktopCliTransport } from "./transport-desktop-cli.mjs";
 const APP_PACKAGE = "md.obsidian";
 const APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;
+const APPIUM_CONNECTION_RETRY_COUNT = 1;
+const APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 1e4;
+const APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5e3;
+const CDP_DEFAULT_PORT = 8315;
 const COMMAND_TIMEOUT_IN_MILLISECONDS = 300;
 const SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 3e4;
 let cachedTransport;
 async function createTransportFromOptions(options) {
   if (!options || options.type === "obsidian-cli") {
+    console.warn("[transport-factory] Creating DesktopCliTransport (no options or type=obsidian-cli)");
     return new DesktopCliTransport();
   }
   if (options.type === "obsidian-cdp") {
+    console.warn(`[transport-factory] Creating DesktopCdpTransport (host=${options.host ?? "localhost"}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);
     return new DesktopCdpTransport({
       ...options.host !== void 0 && { cdpHost: options.host },
       ...options.port !== void 0 && { cdpPort: options.port },
       ...options.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }
     });
   }
+  console.warn(`[transport-factory] Creating AppiumTransport (url=${options.appiumUrl}, device=${options.deviceId})`);
   return createAppiumTransport(options);
 }
 async function getOrCreateTransport(options) {
@@ -28,6 +36,30 @@ async function getOrCreateTransport(options) {
   cachedTransport = result;
   return result;
 }
+function checkAppiumReachable(url) {
+  return new Promise((resolve, reject) => {
+    const statusUrl = new URL("/status", url);
+    const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {
+      res.resume();
+      resolve();
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      reject(
+        new Error(
+          `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`
+        )
+      );
+    });
+    req.on("error", (err) => {
+      reject(
+        new Error(
+          `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`
+        )
+      );
+    });
+  });
+}
 async function createAppiumTransport(options) {
   const url = new URL(options.appiumUrl);
   const port = Number(url.port);
@@ -35,6 +67,10 @@ async function createAppiumTransport(options) {
     throw new Error(`Invalid port in appiumUrl: ${url.port}`);
   }
   const appId = options.appId ?? APP_PACKAGE;
+  console.warn(`[transport-factory] Checking Appium server at ${options.appiumUrl}...`);
+  await checkAppiumReachable(url);
+  console.warn("[transport-factory] Appium server is reachable.");
+  console.warn(`[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId})...`);
   const browser = await remote({
     capabilities: {
       "appium:appActivity": APP_ACTIVITY,
@@ -51,10 +87,13 @@ async function createAppiumTransport(options) {
       "appium:uiautomator2ServerLaunchTimeout": SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,
       "platformName": "Android"
     },
+    connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,
+    connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
     hostname: url.hostname,
     path: url.pathname,
     port
   });
+  console.warn("[transport-factory] Appium session established.");
   return new AppiumTransport({
     appId,
     browser,
@@ -66,4 +105,4 @@ export {
   createTransportFromOptions,
   getOrCreateTransport
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport http from 'node:http';\nimport { remote } from 'webdriverio';\n\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst APPIUM_CONNECTION_RETRY_COUNT = 1;\nconst APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 10000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst CDP_DEFAULT_PORT = 8315;\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 30000;\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (!options || options.type === 'obsidian-cli') {\n    console.warn('[transport-factory] Creating DesktopCliTransport (no options or type=obsidian-cli)');\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    console.warn(`[transport-factory] Creating DesktopCdpTransport (host=${options.host ?? 'localhost'}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      ...(options.port !== undefined && { cdpPort: options.port }),\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds })\n    });\n  }\n\n  console.warn(`[transport-factory] Creating AppiumTransport (url=${options.appiumUrl}, device=${options.deviceId})`);\n  return createAppiumTransport(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Performs a quick HTTP check against the Appium server's status endpoint.\n *\n * Fails fast (within {@link APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS}) with\n * a clear error message instead of letting WebDriverIO retry silently for minutes.\n *\n * @param url - The parsed Appium URL.\n */\nfunction checkAppiumReachable(url: URL): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const statusUrl = new URL('/status', url);\n    const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n      res.resume();\n      resolve();\n    });\n    req.on('timeout', () => {\n      req.destroy();\n      reject(\n        new Error(\n          `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n        )\n      );\n    });\n    req.on('error', (err) => {\n      reject(\n        new Error(\n          `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n        )\n      );\n    });\n  });\n}\n\n/**\n * Creates an Appium transport by establishing a WebDriverIO session.\n *\n * @param options - Android Appium transport options.\n * @returns A configured Appium transport.\n */\nasync function createAppiumTransport(options: ObsidianAndroidAppiumTransportOptions): Promise<AppiumTransport> {\n  const url = new URL(options.appiumUrl);\n\n  const port = Number(url.port);\n  if (isNaN(port)) {\n    throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n  }\n\n  const appId = options.appId ?? APP_PACKAGE;\n\n  console.warn(`[transport-factory] Checking Appium server at ${options.appiumUrl}...`);\n  await checkAppiumReachable(url);\n  console.warn('[transport-factory] Appium server is reachable.');\n\n  console.warn(`[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId})...`);\n  const browser = await remote({\n    capabilities: {\n      'appium:appActivity': APP_ACTIVITY,\n      'appium:appPackage': appId,\n      'appium:autoGrantPermissions': true,\n      'appium:automationName': 'UiAutomator2',\n      'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n      'appium:noReset': true,\n      'appium:settings': {\n        'appium:chromedriverAutodownload': true\n      },\n      'appium:skipServerInstallation': true,\n      'appium:udid': options.deviceId,\n      'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n      'platformName': 'Android'\n    },\n    connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n    connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,\n    hostname: url.hostname,\n    path: url.pathname,\n    port\n  });\n\n  console.warn('[transport-factory] Appium session established.');\n  return new AppiumTransport({\n    appId,\n    browser,\n    platform: 'android',\n    ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath })\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",
@@ -49,6 +49,7 @@
     "**/package.json",
     "dist/",
     "LICENSE",
+    "patches/",
     "README.md",
     "scripts/postinstall.mjs"
   ],
@@ -117,7 +118,6 @@
     "nano-staged": "latest",
     "obsidian": "latest",
     "obsidian-typings": "obsidian-public-latest",
-    "puppeteer-core": "latest",
     "semver": "latest",
     "type-fest": "latest",
     "typescript": "latest",
@@ -136,6 +136,7 @@
     "type-fest": "latest"
   },
   "dependencies": {
-    "webdriverio": "^9.27.0"
+    "puppeteer-core": "latest",
+    "webdriverio": "latest"
   }
 }

package/patches/@wdio+protocols+9.27.0.patch

@@ -0,0 +1,12 @@
+diff --git a/node_modules/@wdio/protocols/tsconfig.json b/node_modules/@wdio/protocols/tsconfig.json
+index 21e7b19..8dbebc0 100644
+--- a/node_modules/@wdio/protocols/tsconfig.json
++++ b/node_modules/@wdio/protocols/tsconfig.json
+@@ -1,7 +1,5 @@
+ {
+-  "extends": "../../tsconfig",
+   "compilerOptions": {
+-    "baseUrl": ".",
+     "outDir": "build",
+     "rootDir": "src",
+     "removeComments": false

package/patches/@wdio+types+9.27.0.patch

@@ -0,0 +1,13 @@
+diff --git a/node_modules/@wdio/types/build/Capabilities.d.ts b/node_modules/@wdio/types/build/Capabilities.d.ts
+index 945fb98..e17332d 100644
+--- a/node_modules/@wdio/types/build/Capabilities.d.ts
++++ b/node_modules/@wdio/types/build/Capabilities.d.ts
+@@ -146,7 +146,7 @@ export interface WithRequestedCapabilities {
+      * })
+      * ```
+      */
+-    capabilities: RequestedStandaloneCapabilities;
++    capabilities?: RequestedStandaloneCapabilities;
+ }
+ /**
+  * The `capabilities` property is a required property when defining a testrunner configuration.

package/patches/urlpattern-polyfill+10.1.0.patch

@@ -0,0 +1,13 @@
+diff --git a/node_modules/urlpattern-polyfill/dist/index.d.ts b/node_modules/urlpattern-polyfill/dist/index.d.ts
+index 429e17c..534a0a1 100644
+--- a/node_modules/urlpattern-polyfill/dist/index.d.ts
++++ b/node_modules/urlpattern-polyfill/dist/index.d.ts
+@@ -2,8 +2,5 @@ import type * as Types from "./types.js";
+ export { URLPattern } from "./types.js";
+ 
+ declare global {
+-  class URLPattern extends Types.URLPattern {}
+-  type URLPatternInit = Types.URLPatternInit;
+-  type URLPatternResult = Types.URLPatternResult;
+   type URLPatternComponentResult = Types.URLPatternComponentResult;
+ }