obsidian-integration-testing 1.1.1 → 1.2.0

package/dist/lib/esm/transport-appium.d.mts

@@ -0,0 +1,164 @@
+/**
+ * @file
+ *
+ * Appium transport — evaluates expressions inside Obsidian Mobile via WebView
+ * JavaScript injection. Manages vault lifecycle via localStorage and file push.
+ *
+ * Configured via `environmentOptions.obsidianTransport` in vitest config:
+ *
+ * ```typescript
+ * // vitest.config.ts
+ * environmentOptions: {
+ *   obsidianTransport: {
+ *     type: 'obsidian-android-appium',
+ *     appiumUrl: 'http://localhost:4723',
+ *     deviceId: 'emulator-5554',
+ *   },
+ * }
+ * ```
+ *
+ * For BrowserStack, set `appiumUrl` to the BrowserStack hub URL
+ * — the transport itself is hub-agnostic.
+ *
+ * ## How vault registration works on mobile
+ *
+ * Obsidian Mobile stores its vault registry in the WebView's `localStorage`:
+ *
+ * - `mobile-external-vaults` — JSON array of registered vault paths
+ * - `mobile-selected-vault` — the currently active vault path
+ * - `enable-plugin-<vaultPath>` — `"true"` to enable the plugin system for the vault
+ *
+ * To register a vault programmatically (without UI interaction):
+ *
+ * 1. Push vault files to the device (e.g. `/sdcard/Documents/<Name>/.obsidian/app.json`)
+ * 2. Switch to `WEBVIEW_md.obsidian` context
+ * 3. Set the localStorage entries
+ * 4. Call `location.reload()` — Obsidian re-reads localStorage and opens the vault
+ *
+ * This avoids the onboarding flow entirely.
+ */
+import type { Browser } from 'webdriverio';
+import type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
+/**
+ * Configuration for the Appium transport.
+ */
+export interface AppiumTransportConfig {
+    /**
+     * App package (Android) or bundle ID (iOS).
+     * Defaults to `'md.obsidian'`.
+     */
+    appId?: string;
+    /**
+     * The Appium browser/driver instance.
+     * Created by the consumer via e.g. WebDriverIO's `remote()`.
+     */
+    browser: Browser;
+    /**
+     * Target platform. Determines WebView context naming and device file paths.
+     */
+    platform: 'android' | 'ios';
+    /**
+     * Base path on the device where Obsidian stores vaults.
+     *
+     * Defaults:
+     * - Android: `/sdcard/Documents/`
+     * - iOS: `@md.obsidian:documents/`
+     */
+    vaultBasePath?: string;
+}
+/**
+ * Transport that communicates with Obsidian Mobile via Appium WebView JS injection.
+ *
+ * Evaluates expressions by switching to the `WEBVIEW_md.obsidian` context and
+ * calling `execute()`. Manages vaults by writing to the WebView's `localStorage`
+ * (which Obsidian uses as its vault registry on mobile) and pushing files to the device.
+ */
+export declare class AppiumTransport implements ObsidianTransport {
+    /** */
+    readonly isMobile = true;
+    private readonly appId;
+    private readonly browser;
+    private readonly platform;
+    private readonly vaultBasePath;
+    /**
+     * Creates a new Appium transport.
+     *
+     * @param config - Appium transport configuration.
+     */
+    constructor(config: AppiumTransportConfig);
+    /**
+     * Ends the Appium session.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Evaluates a JavaScript expression inside Obsidian Mobile's WebView.
+     *
+     * Switches to the `WEBVIEW_md.obsidian` context, executes the expression,
+     * and returns the result string.
+     *
+     * @param expression - The JavaScript expression to evaluate.
+     * @param _options - Evaluation options (cwd is not used on mobile — vault targeting is via localStorage).
+     * @returns The normalized result string.
+     */
+    evaluate(expression: string, _options: TransportEvalOptions): Promise<string>;
+    /**
+     * Verifies that the Obsidian app is running and the WebView is available.
+     *
+     * @param _vaultPath - Not used on mobile.
+     */
+    preflightCheck(_vaultPath: string): Promise<void>;
+    /**
+     * Pushes vault files to the device.
+     *
+     * @param vaultPath - The vault path (used as the vault directory name on device).
+     * @param files - Map of relative file paths to content strings.
+     */
+    pushFiles(vaultPath: string, files: Record<string, string>): Promise<void>;
+    /**
+     * Registers a vault on mobile by pushing files and configuring localStorage.
+     *
+     * The registration flow:
+     * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault
+     * 2. Switch to the WebView context
+     * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,
+     *    `enable-plugin-<path>`)
+     * 4. Trigger `location.reload()` so Obsidian re-reads localStorage and opens the vault
+     * 5. Wait for `app.workspace.layoutReady`
+     *
+     * Existing vault registrations in localStorage are preserved (append, not overwrite).
+     *
+     * @param vaultPath - The absolute path to the vault on the host machine.
+     */
+    registerVault(vaultPath: string): Promise<void>;
+    /**
+     * Unregisters a vault on mobile by removing it from localStorage.
+     *
+     * Preserves other vault registrations. If the unregistered vault was selected,
+     * switches to the first remaining vault (or clears the selection).
+     *
+     * Note: Vault files on the device are not deleted. The test harness or CI
+     * environment should handle device cleanup.
+     *
+     * @param vaultPath - The absolute path to the vault on the host machine.
+     */
+    unregisterVault(vaultPath: string): Promise<void>;
+    /**
+     * Switches the driver to the `WEBVIEW_md.obsidian` context.
+     *
+     * Polls until the context becomes available (the app may still be loading).
+     * Uses the `WEBVIEW_md.obsidian` context specifically to avoid connecting
+     * to Chrome or other WebViews on the device.
+     */
+    private ensureWebViewContext;
+    /**
+     * Converts a host-side vault path to the device-side path.
+     *
+     * @param vaultPath - Absolute path on the host machine.
+     * @returns The device-side vault path.
+     */
+    private getDeviceVaultPath;
+    /**
+     * Polls until `app.workspace.layoutReady` is `true` in the WebView.
+     */
+    private waitForLayoutReady;
+}

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

@@ -0,0 +1,208 @@
+const NO_OUTPUT = "(no output)";
+const APP_STATE_FOREGROUND = 4;
+const WEBVIEW_CONTEXT_PREFIX = "WEBVIEW_md.obsidian";
+const WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS = 500;
+const WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS = 3e4;
+const LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;
+const LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 3e4;
+const APP_RESTART_DELAY_IN_MILLISECONDS = 2e3;
+const DEFAULT_APP_ID = "md.obsidian";
+const DEFAULT_VAULT_BASE_PATH = {
+  android: "/sdcard/Documents/",
+  ios: "@md.obsidian:documents/"
+};
+class AppiumTransport {
+  /** */
+  isMobile = true;
+  appId;
+  browser;
+  platform;
+  vaultBasePath;
+  /**
+   * Creates a new Appium transport.
+   *
+   * @param config - Appium transport configuration.
+   */
+  constructor(config) {
+    this.browser = config.browser;
+    this.platform = config.platform;
+    this.appId = config.appId ?? DEFAULT_APP_ID;
+    this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? "/sdcard/Documents/";
+  }
+  /**
+   * Ends the Appium session.
+   */
+  async dispose() {
+    await this.browser.deleteSession();
+  }
+  /**
+   * Evaluates a JavaScript expression inside Obsidian Mobile's WebView.
+   *
+   * Switches to the `WEBVIEW_md.obsidian` context, executes the expression,
+   * and returns the result string.
+   *
+   * @param expression - The JavaScript expression to evaluate.
+   * @param _options - Evaluation options (cwd is not used on mobile — vault targeting is via localStorage).
+   * @returns The normalized result string.
+   */
+  async evaluate(expression, _options) {
+    await this.ensureWebViewContext();
+    const result = await this.browser.execute(
+      `return (${expression})`
+    );
+    if (result === void 0 || result === null) {
+      return NO_OUTPUT;
+    }
+    return result;
+  }
+  /**
+   * Verifies that the Obsidian app is running and the WebView is available.
+   *
+   * @param _vaultPath - Not used on mobile.
+   */
+  async preflightCheck(_vaultPath) {
+    const state = await this.browser.queryAppState(this.appId);
+    if (state !== APP_STATE_FOREGROUND) {
+      await this.browser.activateApp(this.appId);
+      await delay(APP_RESTART_DELAY_IN_MILLISECONDS);
+    }
+    await this.ensureWebViewContext();
+  }
+  /**
+   * Pushes vault files to the device.
+   *
+   * @param vaultPath - The vault path (used as the vault directory name on device).
+   * @param files - Map of relative file paths to content strings.
+   */
+  async pushFiles(vaultPath, files) {
+    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);
+    for (const [filePath, content] of Object.entries(files)) {
+      const deviceFilePath = `${deviceVaultPath}/${filePath}`;
+      const base64Content = Buffer.from(content, "utf-8").toString("base64");
+      await this.browser.pushFile(deviceFilePath, base64Content);
+    }
+  }
+  /**
+   * Registers a vault on mobile by pushing files and configuring localStorage.
+   *
+   * The registration flow:
+   * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault
+   * 2. Switch to the WebView context
+   * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,
+   *    `enable-plugin-<path>`)
+   * 4. Trigger `location.reload()` so Obsidian re-reads localStorage and opens the vault
+   * 5. Wait for `app.workspace.layoutReady`
+   *
+   * Existing vault registrations in localStorage are preserved (append, not overwrite).
+   *
+   * @param vaultPath - The absolute path to the vault on the host machine.
+   */
+  async registerVault(vaultPath) {
+    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);
+    const obsidianMarker = `${deviceVaultPath}/.obsidian/app.json`;
+    const base64Content = Buffer.from("{}", "utf-8").toString("base64");
+    await this.browser.pushFile(obsidianMarker, base64Content);
+    await this.ensureWebViewContext();
+    await this.browser.execute((path) => {
+      const existing = JSON.parse(localStorage.getItem("mobile-external-vaults") ?? "[]");
+      if (!existing.includes(path)) {
+        existing.push(path);
+        localStorage.setItem("mobile-external-vaults", JSON.stringify(existing));
+      }
+      localStorage.setItem("mobile-selected-vault", path);
+      localStorage.setItem(`enable-plugin-${path}`, "true");
+      location.reload();
+    }, deviceVaultPath);
+    await this.waitForLayoutReady();
+  }
+  /**
+   * Unregisters a vault on mobile by removing it from localStorage.
+   *
+   * Preserves other vault registrations. If the unregistered vault was selected,
+   * switches to the first remaining vault (or clears the selection).
+   *
+   * Note: Vault files on the device are not deleted. The test harness or CI
+   * environment should handle device cleanup.
+   *
+   * @param vaultPath - The absolute path to the vault on the host machine.
+   */
+  async unregisterVault(vaultPath) {
+    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);
+    await this.ensureWebViewContext();
+    await this.browser.execute((path) => {
+      const existing = JSON.parse(localStorage.getItem("mobile-external-vaults") ?? "[]");
+      const filtered = existing.filter((v) => v !== path);
+      localStorage.setItem("mobile-external-vaults", JSON.stringify(filtered));
+      localStorage.removeItem(`enable-plugin-${path}`);
+      if (localStorage.getItem("mobile-selected-vault") === path) {
+        if (filtered.length > 0) {
+          localStorage.setItem("mobile-selected-vault", filtered[0] ?? "");
+        } else {
+          localStorage.removeItem("mobile-selected-vault");
+        }
+      }
+    }, deviceVaultPath);
+  }
+  /**
+   * Switches the driver to the `WEBVIEW_md.obsidian` context.
+   *
+   * Polls until the context becomes available (the app may still be loading).
+   * Uses the `WEBVIEW_md.obsidian` context specifically to avoid connecting
+   * to Chrome or other WebViews on the device.
+   */
+  async ensureWebViewContext() {
+    const deadline = Date.now() + WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;
+    while (Date.now() < deadline) {
+      const contexts = await this.browser.getContexts();
+      const obsidianContext = contexts.find((ctx) => typeof ctx === "string" && ctx.startsWith(WEBVIEW_CONTEXT_PREFIX));
+      if (obsidianContext) {
+        await this.browser.switchContext(obsidianContext);
+        return;
+      }
+      await delay(WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS);
+    }
+    throw new Error(`No ${WEBVIEW_CONTEXT_PREFIX} context found within ${String(WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS)}ms. Is the Obsidian app fully loaded?`);
+  }
+  /**
+   * Converts a host-side vault path to the device-side path.
+   *
+   * @param vaultPath - Absolute path on the host machine.
+   * @returns The device-side vault path.
+   */
+  getDeviceVaultPath(vaultPath) {
+    return `${this.vaultBasePath}${extractVaultName(vaultPath)}`;
+  }
+  /**
+   * Polls until `app.workspace.layoutReady` is `true` in the WebView.
+   */
+  async waitForLayoutReady() {
+    const deadline = Date.now() + LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS;
+    while (Date.now() < deadline) {
+      try {
+        const isReady = await this.browser.execute(
+          'return typeof app !== "undefined" && app.workspace && app.workspace.layoutReady === true'
+        );
+        if (isReady) {
+          return;
+        }
+      } catch {
+      }
+      await delay(LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS);
+    }
+    throw new Error(`Obsidian layout did not become ready within ${String(LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function extractVaultName(vaultPath) {
+  const normalized = vaultPath.replace(/[\\/]+$/, "");
+  const lastSep = Math.max(normalized.lastIndexOf("/"), normalized.lastIndexOf("\\"));
+  return normalized.slice(lastSep + 1);
+}
+export {
+  AppiumTransport
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-appium.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Appium transport \u2014 evaluates expressions inside Obsidian Mobile via WebView\n * JavaScript injection. Manages vault lifecycle via localStorage and file push.\n *\n * Configured via `environmentOptions.obsidianTransport` in vitest config:\n *\n * ```typescript\n * // vitest.config.ts\n * environmentOptions: {\n *   obsidianTransport: {\n *     type: 'obsidian-android-appium',\n *     appiumUrl: 'http://localhost:4723',\n *     deviceId: 'emulator-5554',\n *   },\n * }\n * ```\n *\n * For BrowserStack, set `appiumUrl` to the BrowserStack hub URL\n * \u2014 the transport itself is hub-agnostic.\n *\n * ## How vault registration works on mobile\n *\n * Obsidian Mobile stores its vault registry in the WebView's `localStorage`:\n *\n * - `mobile-external-vaults` \u2014 JSON array of registered vault paths\n * - `mobile-selected-vault` \u2014 the currently active vault path\n * - `enable-plugin-<vaultPath>` \u2014 `\"true\"` to enable the plugin system for the vault\n *\n * To register a vault programmatically (without UI interaction):\n *\n * 1. Push vault files to the device (e.g. `/sdcard/Documents/<Name>/.obsidian/app.json`)\n * 2. Switch to `WEBVIEW_md.obsidian` context\n * 3. Set the localStorage entries\n * 4. Call `location.reload()` \u2014 Obsidian re-reads localStorage and opens the vault\n *\n * This avoids the onboarding flow entirely.\n */\n\n/* v8 ignore start -- Integration-time code covered by integration tests, not unit tests. */\n\nimport type { Browser } from 'webdriverio';\n\nimport type {\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.mjs';\n\n/**\n * Configuration for the Appium transport.\n */\nexport interface AppiumTransportConfig {\n  /**\n   * App package (Android) or bundle ID (iOS).\n   * Defaults to `'md.obsidian'`.\n   */\n  appId?: string;\n\n  /**\n   * The Appium browser/driver instance.\n   * Created by the consumer via e.g. WebDriverIO's `remote()`.\n   */\n  browser: Browser;\n\n  /**\n   * Target platform. Determines WebView context naming and device file paths.\n   */\n  platform: 'android' | 'ios';\n\n  /**\n   * Base path on the device where Obsidian stores vaults.\n   *\n   * Defaults:\n   * - Android: `/sdcard/Documents/`\n   * - iOS: `@md.obsidian:documents/`\n   */\n  vaultBasePath?: string;\n}\n\nconst NO_OUTPUT = '(no output)';\nconst APP_STATE_FOREGROUND = 4;\nconst WEBVIEW_CONTEXT_PREFIX = 'WEBVIEW_md.obsidian';\nconst WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\nconst LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 30000;\nconst APP_RESTART_DELAY_IN_MILLISECONDS = 2000;\nconst DEFAULT_APP_ID = 'md.obsidian';\n\nconst DEFAULT_VAULT_BASE_PATH: Record<string, string> = {\n  android: '/sdcard/Documents/',\n  ios: '@md.obsidian:documents/'\n};\n\n/**\n * Transport that communicates with Obsidian Mobile via Appium WebView JS injection.\n *\n * Evaluates expressions by switching to the `WEBVIEW_md.obsidian` context and\n * calling `execute()`. Manages vaults by writing to the WebView's `localStorage`\n * (which Obsidian uses as its vault registry on mobile) and pushing files to the device.\n */\nexport class AppiumTransport implements ObsidianTransport {\n  /** */\n  public readonly isMobile = true;\n  private readonly appId: string;\n  private readonly browser: Browser;\n  private readonly platform: 'android' | 'ios';\n  private readonly vaultBasePath: string;\n\n  /**\n   * Creates a new Appium transport.\n   *\n   * @param config - Appium transport configuration.\n   */\n  public constructor(config: AppiumTransportConfig) {\n    this.browser = config.browser;\n    this.platform = config.platform;\n    this.appId = config.appId ?? DEFAULT_APP_ID;\n    this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? '/sdcard/Documents/';\n  }\n\n  /**\n   * Ends the Appium session.\n   */\n  public async dispose(): Promise<void> {\n    await this.browser.deleteSession();\n  }\n\n  /**\n   * Evaluates a JavaScript expression inside Obsidian Mobile's WebView.\n   *\n   * Switches to the `WEBVIEW_md.obsidian` context, executes the expression,\n   * and returns the result string.\n   *\n   * @param expression - The JavaScript expression to evaluate.\n   * @param _options - Evaluation options (cwd is not used on mobile \u2014 vault targeting is via localStorage).\n   * @returns The normalized result string.\n   */\n  public async evaluate(expression: string, _options: TransportEvalOptions): Promise<string> {\n    await this.ensureWebViewContext();\n\n    const result = await this.browser.execute<null | string | undefined, []>(\n      `return (${expression})`\n    );\n\n    if (result === undefined || result === null) {\n      return NO_OUTPUT;\n    }\n\n    return result;\n  }\n\n  /**\n   * Verifies that the Obsidian app is running and the WebView is available.\n   *\n   * @param _vaultPath - Not used on mobile.\n   */\n  public async preflightCheck(_vaultPath: string): Promise<void> {\n    const state = await this.browser.queryAppState(this.appId);\n    if (state !== APP_STATE_FOREGROUND) {\n      await this.browser.activateApp(this.appId);\n      await delay(APP_RESTART_DELAY_IN_MILLISECONDS);\n    }\n\n    await this.ensureWebViewContext();\n  }\n\n  /**\n   * Pushes vault files to the device.\n   *\n   * @param vaultPath - The vault path (used as the vault directory name on device).\n   * @param files - Map of relative file paths to content strings.\n   */\n  public async pushFiles(vaultPath: string, files: Record<string, string>): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    for (const [filePath, content] of Object.entries(files)) {\n      const deviceFilePath = `${deviceVaultPath}/${filePath}`;\n      const base64Content = Buffer.from(content, 'utf-8').toString('base64');\n      await this.browser.pushFile(deviceFilePath, base64Content);\n    }\n  }\n\n  /**\n   * Registers a vault on mobile by pushing files and configuring localStorage.\n   *\n   * The registration flow:\n   * 1. Push a minimal `.obsidian/app.json` to the device so Obsidian recognizes the vault\n   * 2. Switch to the WebView context\n   * 3. Add the vault to localStorage (`mobile-external-vaults`, `mobile-selected-vault`,\n   *    `enable-plugin-<path>`)\n   * 4. Trigger `location.reload()` so Obsidian re-reads localStorage and opens the vault\n   * 5. Wait for `app.workspace.layoutReady`\n   *\n   * Existing vault registrations in localStorage are preserved (append, not overwrite).\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    // Push a minimal .obsidian directory so Obsidian recognizes it as a vault.\n    const obsidianMarker = `${deviceVaultPath}/.obsidian/app.json`;\n    const base64Content = Buffer.from('{}', 'utf-8').toString('base64');\n    await this.browser.pushFile(obsidianMarker, base64Content);\n\n    // Switch to WebView and configure localStorage.\n    await this.ensureWebViewContext();\n\n    await this.browser.execute((path: string) => {\n      const existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n      if (!existing.includes(path)) {\n        existing.push(path);\n        localStorage.setItem('mobile-external-vaults', JSON.stringify(existing));\n      }\n      localStorage.setItem('mobile-selected-vault', path);\n      localStorage.setItem(`enable-plugin-${path}`, 'true');\n      location.reload();\n    }, deviceVaultPath);\n\n    // Wait for reload + vault initialization.\n    await this.waitForLayoutReady();\n  }\n\n  /**\n   * Unregisters a vault on mobile by removing it from localStorage.\n   *\n   * Preserves other vault registrations. If the unregistered vault was selected,\n   * switches to the first remaining vault (or clears the selection).\n   *\n   * Note: Vault files on the device are not deleted. The test harness or CI\n   * environment should handle device cleanup.\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async unregisterVault(vaultPath: string): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    await this.ensureWebViewContext();\n\n    await this.browser.execute((path: string) => {\n      const existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n      const filtered = existing.filter((v) => v !== path);\n      localStorage.setItem('mobile-external-vaults', JSON.stringify(filtered));\n      localStorage.removeItem(`enable-plugin-${path}`);\n      if (localStorage.getItem('mobile-selected-vault') === path) {\n        if (filtered.length > 0) {\n          localStorage.setItem('mobile-selected-vault', filtered[0] ?? '');\n        } else {\n          localStorage.removeItem('mobile-selected-vault');\n        }\n      }\n    }, deviceVaultPath);\n  }\n\n  /**\n   * Switches the driver to the `WEBVIEW_md.obsidian` context.\n   *\n   * Polls until the context becomes available (the app may still be loading).\n   * Uses the `WEBVIEW_md.obsidian` context specifically to avoid connecting\n   * to Chrome or other WebViews on the device.\n   */\n  private async ensureWebViewContext(): Promise<void> {\n    const deadline = Date.now() + WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      const contexts = await this.browser.getContexts();\n      const obsidianContext = contexts.find((ctx): ctx is string => typeof ctx === 'string' && ctx.startsWith(WEBVIEW_CONTEXT_PREFIX));\n\n      if (obsidianContext) {\n        await this.browser.switchContext(obsidianContext);\n        return;\n      }\n\n      await delay(WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`No ${WEBVIEW_CONTEXT_PREFIX} context found within ${String(WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS)}ms. Is the Obsidian app fully loaded?`);\n  }\n\n  /**\n   * Converts a host-side vault path to the device-side path.\n   *\n   * @param vaultPath - Absolute path on the host machine.\n   * @returns The device-side vault path.\n   */\n  private getDeviceVaultPath(vaultPath: string): string {\n    return `${this.vaultBasePath}${extractVaultName(vaultPath)}`;\n  }\n\n  /**\n   * Polls until `app.workspace.layoutReady` is `true` in the WebView.\n   */\n  private async waitForLayoutReady(): Promise<void> {\n    const deadline = Date.now() + LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      try {\n        const isReady = await this.browser.execute<boolean, []>(\n          'return typeof app !== \"undefined\" && app.workspace && app.workspace.layoutReady === true'\n        );\n        if (isReady) {\n          return;\n        }\n      } catch {\n        // App not ready yet (page may be reloading).\n      }\n\n      await delay(LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`Obsidian layout did not become ready within ${String(LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);\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 * Extracts the vault directory name from a host-side vault path.\n *\n * @param vaultPath - Absolute path on the host machine.\n * @returns The last path segment (vault directory name).\n */\nfunction extractVaultName(vaultPath: string): string {\n  const normalized = vaultPath.replace(/[\\\\/]+$/, '');\n  const lastSep = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\\\'));\n  return normalized.slice(lastSep + 1);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


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

@@ -0,0 +1,158 @@
+/**
+ * @file
+ *
+ * Desktop CDP transport — evaluates expressions via Chrome DevTools Protocol
+ * over WebSocket and manages vaults via Electron IPC.
+ *
+ * Obsidian exposes CDP on port 8315 by default. This transport connects to
+ * page targets, sends `Runtime.evaluate` commands, and routes to the correct
+ * vault target using `getBasePath()` probing.
+ *
+ * Advantages over CLI transport:
+ * - No CLI binary installation needed
+ * - No "CLI enabled" setting required in Obsidian
+ * - Lower overhead (WebSocket vs. process spawn per eval)
+ *
+ * Requirements:
+ * - Obsidian must be running with remote debugging enabled (port 8315)
+ * - Node.js 22+ (uses built-in `WebSocket` and `fetch` globals)
+ */
+import type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
+/**
+ * Configuration for the CDP transport.
+ */
+export interface DesktopCdpTransportConfig {
+    /**
+     * CDP host. Defaults to `'localhost'`.
+     */
+    cdpHost?: string;
+    /**
+     * CDP port. Defaults to `8315`.
+     */
+    cdpPort?: number;
+    /**
+     * Timeout in milliseconds for individual CDP commands.
+     * Defaults to `30000`.
+     */
+    commandTimeoutInMilliseconds?: number;
+}
+/**
+ * Transport that communicates with Desktop Obsidian via Chrome DevTools Protocol.
+ *
+ * Connects to Obsidian's CDP WebSocket endpoint, sends `Runtime.evaluate`
+ * commands, and routes expressions to the correct vault target.
+ */
+export declare class DesktopCdpTransport implements ObsidianTransport {
+    /** */
+    readonly isMobile = false;
+    private activeVaultPath;
+    private readonly cdpPort;
+    private readonly cdpUrl;
+    private readonly commandTimeoutInMilliseconds;
+    private messageId;
+    private ws;
+    /**
+     * Creates a new CDP transport.
+     *
+     * @param config - CDP connection configuration.
+     */
+    constructor(config?: DesktopCdpTransportConfig);
+    /**
+     * Disposes of the active WebSocket connection.
+     */
+    dispose(): Promise<void>;
+    /**
+     * 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.
+     */
+    evaluate(expression: string, options: TransportEvalOptions): Promise<string>;
+    /**
+     * 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).
+     */
+    preflightCheck(vaultPath: string): Promise<void>;
+    /**
+     * 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.
+     */
+    registerVault(vaultPath: string): Promise<void>;
+    /**
+     * Unregisters a vault by destroying its window and removing it from the registry.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    unregisterVault(vaultPath: string): Promise<void>;
+    /**
+     * Connects to a CDP target's WebSocket endpoint.
+     *
+     * @param target - The CDP target to connect to.
+     * @returns The open WebSocket connection.
+     */
+    private connectToTarget;
+    /**
+     * Disconnects the active WebSocket connection.
+     */
+    private disconnect;
+    /**
+     * 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.
+     */
+    private ensureConnection;
+    /**
+     * Launches Obsidian with `--remote-debugging-port` and polls until CDP becomes available.
+     */
+    private ensureObsidianRunning;
+    /**
+     * 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.
+     */
+    private findTargetForVault;
+    /**
+     * Fetches the list of page-type targets from the CDP `/json` endpoint.
+     *
+     * @returns The list of page targets.
+     */
+    private getPageTargets;
+    /**
+     * 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.
+     */
+    private probeVaultPath;
+    /**
+     * 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.
+     */
+    private sendCommand;
+}