obsidian-integration-testing 1.1.1 → 1.2.0

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

@@ -0,0 +1,190 @@
+import process from "node:process";
+import { exec } from "./exec.mjs";
+import {
+  isCliEnabled,
+  isVaultRegistered
+} from "./obsidian-config.mjs";
+const UNABLE_TO_FIND_OBSIDIAN = "unable to find Obsidian";
+const AUTO_START_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
+const AUTO_START_TIMEOUT_IN_MILLISECONDS = 3e4;
+const VAULT_POLL_INTERVAL_IN_MILLISECONDS = 500;
+const VAULT_POLL_TIMEOUT_IN_MILLISECONDS = 3e4;
+const VAULT_CLOSE_DELAY_IN_MILLISECONDS = 1e3;
+class DesktopCliTransport {
+  /** */
+  isMobile = false;
+  /**
+   * Evaluates a JavaScript expression inside Obsidian via `obsidian eval`.
+   *
+   * Handles auto-start: if Obsidian is not running, launches it via URI protocol
+   * and retries until it becomes available.
+   *
+   * @param expression - The JavaScript expression to evaluate.
+   * @param options - Evaluation options.
+   * @returns The normalized result string (transport-specific prefixes stripped).
+   */
+  async evaluate(expression, options) {
+    const command = ["obsidian", "eval", `code=${expression}`];
+    let resultStr;
+    try {
+      resultStr = await exec(command, { cwd: options.cwd, isQuiet: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {
+        resultStr = await this.ensureObsidianRunningAndRetry(command, options.cwd);
+      } else {
+        throw error;
+      }
+    }
+    if (resultStr === "" || resultStr === "Vault not found.") {
+      throw new Error(`Unexpected empty response from Obsidian for path: ${options.cwd}`);
+    }
+    const lines = resultStr.split("\n");
+    const resultLine = lines.findLast((line) => line.startsWith("=> "));
+    if (resultLine) {
+      return resultLine.slice("=> ".length);
+    }
+    return resultStr;
+  }
+  /**
+   * Runs CLI-specific preflight checks.
+   *
+   * Verifies that the vault is registered, CLI is enabled in Obsidian settings,
+   * and the `obsidian` CLI binary is available in PATH.
+   *
+   * @param vaultPath - The absolute path to the vault folder.
+   */
+  async preflightCheck(vaultPath) {
+    if (!isVaultRegistered(vaultPath)) {
+      throw new Error(
+        `Vault is not registered in Obsidian: ${vaultPath}. Register the vault first with registerVault() or TempVault.register().`
+      );
+    }
+    if (!isCliEnabled()) {
+      throw new Error("Obsidian CLI is disabled. Enable it in Obsidian Settings \u2192 General \u2192 CLI.");
+    }
+    await this.assertCliAvailable();
+  }
+  /**
+   * Registers a vault in the running Obsidian instance via Electron IPC.
+   *
+   * Uses `vault-open` IPC to register and open the vault, then polls until
+   * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.
+   *
+   * @param vaultPath - The absolute path to the vault folder.
+   */
+  async registerVault(vaultPath) {
+    const registerExpr = buildIpcExpression(
+      `window.electron.ipcRenderer.sendSync('vault-open', ${JSON.stringify(vaultPath)}, false);`
+    );
+    await this.evaluate(registerExpr, { cwd: process.cwd() });
+    const pollExpr = buildSimpleExpression(
+      "return JSON.stringify(app.vault.adapter.getBasePath());"
+    );
+    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) {
+          return;
+        }
+      } catch {
+      }
+      await delay(VAULT_POLL_INTERVAL_IN_MILLISECONDS);
+    }
+    throw new Error(`Vault at ${vaultPath} did not become ready within ${String(VAULT_POLL_TIMEOUT_IN_MILLISECONDS)}ms`);
+  }
+  /**
+   * Unregisters a vault from the running Obsidian instance.
+   *
+   * Schedules the vault window to close, waits, then removes the vault
+   * from the registry via `vault-remove` IPC.
+   *
+   * @param vaultPath - The absolute path to the vault folder.
+   */
+  async unregisterVault(vaultPath) {
+    const destroyExpr = buildSimpleExpression(`
+      setTimeout(() => {
+        if (window.electron && window.electron.remote) {
+          window.electron.remote.getCurrentWindow().destroy();
+        }
+      }, 0);
+    `);
+    try {
+      await this.evaluate(destroyExpr, { cwd: vaultPath });
+    } catch {
+    }
+    await delay(VAULT_CLOSE_DELAY_IN_MILLISECONDS);
+    const removeExpr = buildIpcExpression(
+      `window.electron.ipcRenderer.sendSync('vault-remove', ${JSON.stringify(vaultPath)});`
+    );
+    await this.evaluate(removeExpr, { cwd: process.cwd() });
+  }
+  /**
+   * Checks whether the Obsidian CLI binary is available in the system PATH.
+   */
+  async assertCliAvailable() {
+    const command = process.platform === "win32" ? "where.exe obsidian" : "which obsidian";
+    try {
+      await exec(command, { isQuiet: true });
+    } catch {
+      throw new Error("Obsidian CLI is not available. Ensure Obsidian is installed and its CLI is in your PATH.");
+    }
+  }
+  /**
+   * Launches Obsidian binary and retries the eval until it responds.
+   *
+   * @param command - The CLI command array to retry.
+   * @param cwd - The working directory.
+   * @returns The result string from the successful eval.
+   */
+  async ensureObsidianRunningAndRetry(command, cwd) {
+    console.warn("Obsidian is not running. Starting Obsidian...");
+    try {
+      await exec(getObsidianLaunchCommand(), { isQuiet: true });
+    } catch {
+    }
+    const deadline = Date.now() + AUTO_START_TIMEOUT_IN_MILLISECONDS;
+    while (Date.now() < deadline) {
+      await delay(AUTO_START_POLL_INTERVAL_IN_MILLISECONDS);
+      try {
+        return await exec(command, { cwd, isQuiet: true });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes(UNABLE_TO_FIND_OBSIDIAN)) {
+          throw error;
+        }
+      }
+    }
+    throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_IN_MILLISECONDS)}ms.`);
+  }
+}
+function buildIpcExpression(ipcStatement) {
+  return buildSimpleExpression(ipcStatement);
+}
+function buildSimpleExpression(body) {
+  return `(async () => {
+  if (!app.workspace.layoutReady) {
+    await new Promise((resolve) => app.workspace.onLayoutReady(resolve));
+  }
+  ${body}
+})()`;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function getObsidianLaunchCommand() {
+  if (process.platform === "win32") {
+    return 'start "" "%LOCALAPPDATA%\\Programs\\Obsidian\\Obsidian.exe"';
+  }
+  if (process.platform === "darwin") {
+    return "/Applications/Obsidian.app/Contents/MacOS/Obsidian &";
+  }
+  return "obsidian &";
+}
+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": []
}


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

@@ -0,0 +1,25 @@
+/**
+ * @file
+ *
+ * Factory for creating transport instances from {@link ObsidianTransportOptions}.
+ */
+import type { ObsidianTransportOptions } from './transport-options.mjs';
+import type { ObsidianTransport } from './transport.mjs';
+/**
+ * Creates a new transport instance from the given options.
+ *
+ * @param options - Transport configuration. Defaults to CLI transport.
+ * @returns A new transport instance.
+ */
+export declare function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport>;
+/**
+ * Returns a cached transport instance, creating one from the given options
+ * if not already cached.
+ *
+ * The transport is cached per worker process so WebSocket/Appium sessions
+ * are reused across calls within the same test worker.
+ *
+ * @param options - Transport configuration. Defaults to CLI transport.
+ * @returns The cached or newly created transport.
+ */
+export declare function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport>;

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

@@ -0,0 +1,69 @@
+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 COMMAND_TIMEOUT_IN_MILLISECONDS = 300;
+const SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 3e4;
+let cachedTransport;
+async function createTransportFromOptions(options) {
+  if (!options || options.type === "obsidian-cli") {
+    return new DesktopCliTransport();
+  }
+  if (options.type === "obsidian-cdp") {
+    return new DesktopCdpTransport({
+      ...options.host !== void 0 && { cdpHost: options.host },
+      ...options.port !== void 0 && { cdpPort: options.port },
+      ...options.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }
+    });
+  }
+  return createAppiumTransport(options);
+}
+async function getOrCreateTransport(options) {
+  if (cachedTransport) {
+    return cachedTransport;
+  }
+  const result = await createTransportFromOptions(options);
+  cachedTransport = result;
+  return result;
+}
+async function createAppiumTransport(options) {
+  const url = new URL(options.appiumUrl);
+  const port = Number(url.port);
+  if (isNaN(port)) {
+    throw new Error(`Invalid port in appiumUrl: ${url.port}`);
+  }
+  const appId = options.appId ?? APP_PACKAGE;
+  const browser = await remote({
+    capabilities: {
+      "appium:appActivity": APP_ACTIVITY,
+      "appium:appPackage": appId,
+      "appium:autoGrantPermissions": true,
+      "appium:automationName": "UiAutomator2",
+      "appium:newCommandTimeout": COMMAND_TIMEOUT_IN_MILLISECONDS,
+      "appium:noReset": true,
+      "appium:settings": {
+        "appium:chromedriverAutodownload": true
+      },
+      "appium:skipServerInstallation": true,
+      "appium:udid": options.deviceId,
+      "appium:uiautomator2ServerLaunchTimeout": SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,
+      "platformName": "Android"
+    },
+    hostname: url.hostname,
+    path: url.pathname,
+    port
+  });
+  return new AppiumTransport({
+    appId,
+    browser,
+    platform: "android",
+    ...options.vaultBasePath !== void 0 && { vaultBasePath: options.vaultBasePath }
+  });
+}
+export {
+  createTransportFromOptions,
+  getOrCreateTransport
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,100 @@
+/**
+ * @file
+ *
+ * Discriminated union types for configuring the Obsidian transport
+ * via vitest `environmentOptions`.
+ */
+/**
+ * Transport options for Android testing via Appium WebView injection.
+ */
+export interface ObsidianAndroidAppiumTransportOptions {
+    /**
+     * App package (Android) or bundle ID (iOS).
+     * Defaults to `'md.obsidian'`
+     */
+    appId?: string;
+    /**
+     * The Appium server URL (e.g. `'http://localhost:4723'`).
+     */
+    appiumUrl: string;
+    /**
+     * The device UDID (e.g. `'emulator-5554'`).
+     */
+    deviceId: string;
+    /**
+     * Discriminant for the transport type.
+     */
+    type: 'obsidian-android-appium';
+    /**
+     * Base path on the device where Obsidian stores vaults.
+     *
+     * Defaults:
+     * - Android: `/sdcard/Documents/`
+     * - iOS: `@md.obsidian:documents/`
+     */
+    vaultBasePath?: string;
+}
+/**
+ * Transport options for desktop testing via Chrome DevTools Protocol.
+ */
+export interface ObsidianCdpTransportOptions {
+    /**
+     * Timeout in milliseconds for individual CDP commands.
+     * Defaults to 30000
+     */
+    commandTimeoutInMilliseconds?: number;
+    /**
+     * CDP host.
+     * Defaults to `'localhost'`
+     */
+    host?: string;
+    /**
+     * CDP port.
+     * Defaults to 8315
+     */
+    port?: number;
+    /**
+     * Discriminant for the transport type.
+     */
+    type: 'obsidian-cdp';
+}
+/**
+ * Transport options for desktop testing via the Obsidian CLI.
+ *
+ * This is the default transport when no `obsidianTransport` is configured.
+ */
+export interface ObsidianCliTransportOptions {
+    /**
+     * Discriminant for the transport type.
+     */
+    type: 'obsidian-cli';
+}
+/**
+ * Discriminated union of all supported transport configurations.
+ *
+ * Used in vitest `environmentOptions.obsidianTransport` to select and
+ * configure the transport for integration tests.
+ */
+export type ObsidianTransportOptions = ObsidianAndroidAppiumTransportOptions | ObsidianCdpTransportOptions | ObsidianCliTransportOptions;
+declare module 'vitest' {
+    interface EnvironmentOptions {
+        /**
+         * Configures the transport used by `obsidian-integration-testing` to
+         * communicate with a running Obsidian instance.
+         *
+         * When omitted, defaults to the CLI transport (`obsidian-cli`).
+         */
+        obsidianTransport?: ObsidianTransportOptions;
+    }
+    interface ProvidedContext {
+        /**
+         * Transport options provided by the global setup, consumed by
+         * `evalInObsidian` and other library functions via `inject()`.
+         */
+        obsidianTransport?: ObsidianTransportOptions;
+        /**
+         * Path to the temporary vault created by the global setup.
+         */
+        tempVaultPath: string;
+    }
+}

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

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,86 @@
+/**
+ * @file
+ *
+ * Defines the transport interface for communicating with a running Obsidian instance.
+ */
+/**
+ * A pluggable transport that evaluates JavaScript expressions inside a running
+ * Obsidian instance and manages vault lifecycle.
+ *
+ * Implementations handle the platform-specific details:
+ * - {@link DesktopCliTransport} — Desktop Obsidian via CLI (`obsidian eval`)
+ * - {@link DesktopCdpTransport} — Desktop Obsidian via Chrome DevTools Protocol
+ * - {@link AppiumTransport} — Mobile Obsidian via Appium WebView JS injection
+ */
+export interface ObsidianTransport {
+    /**
+     * Disposes of transport resources (e.g. WebSocket connections, Appium sessions).
+     */
+    dispose?(): Promise<void>;
+    /**
+     * Evaluates a JavaScript expression string inside Obsidian and returns the
+     * raw string result.
+     *
+     * The transport normalizes the output — stripping transport-specific prefixes
+     * and handling transport-specific errors — so callers receive a clean result
+     * string (e.g. a JSON string, or `(no output)`).
+     *
+     * @param expression - A self-contained JavaScript expression (typically an async IIFE).
+     * @param options - Evaluation options including the working directory.
+     * @returns The raw result string from Obsidian.
+     */
+    evaluate(expression: string, options: TransportEvalOptions): Promise<string>;
+    /**
+     * Whether this transport targets a mobile Obsidian instance.
+     *
+     * When `true`, desktop-only plugins (with `isDesktopOnly: true` in manifest)
+     * will refuse to run integration tests.
+     */
+    isMobile: boolean;
+    /**
+     * Runs transport-specific preflight checks before evaluation.
+     *
+     * For example, the CLI transport verifies that the vault is registered,
+     * the CLI is enabled, and the CLI binary is in PATH.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    preflightCheck(vaultPath: string): Promise<void>;
+    /**
+     * Pushes files into a vault directory on the target device.
+     *
+     * On desktop this is a no-op (files are written to the local filesystem directly).
+     * On mobile this uses the device's file transfer mechanism (e.g. Appium `pushFile`).
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     * @param files - Map of relative file paths to content strings.
+     */
+    pushFiles?(vaultPath: string, files: Record<string, string>): Promise<void>;
+    /**
+     * Registers a vault path so Obsidian can target it.
+     *
+     * On desktop: uses Electron IPC to open the vault and polls for readiness.
+     * On mobile: pushes vault files to the device and restarts the app.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    registerVault(vaultPath: string): Promise<void>;
+    /**
+     * Unregisters a vault path from the running Obsidian instance.
+     *
+     * On desktop: closes the vault window and removes it from the registry.
+     * On mobile: removes vault files from the device.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    unregisterVault(vaultPath: string): Promise<void>;
+}
+/**
+ * Options for {@link ObsidianTransport.evaluate}.
+ */
+export interface TransportEvalOptions {
+    /**
+     * The working directory (vault path) for the evaluation.
+     */
+    readonly cwd: string;
+}

package/dist/lib/esm/transport.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/type-guards.d.mts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Contains utility functions for type guards.
  */

package/dist/lib/esm/type-guards.mjs

@@ -14,4 +14,4 @@ export {
   assertNonNullable,
   ensureNonNullable
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/vault-registry.d.mts

@@ -1,8 +1,7 @@
 /**
- * Registers a vault path in the running Obsidian instance so the CLI can target it via `cwd`.
+ * Registers a vault path in the running Obsidian instance.
  *
- * Uses the `vault-open` IPC to register and open the vault, then polls until
- * the vault's CLI is ready and `getBasePath()` matches `vaultPath`.
+ * Delegates to the active transport's {@link ObsidianTransport.registerVault}.
  *
  * @param vaultPath - The absolute path to the vault folder.
  */
@@ -10,8 +9,7 @@ export declare function registerVault(vaultPath: string): Promise<void>;
 /**
  * Unregisters a vault path from the running Obsidian instance.
  *
- * Schedules the vault window to close, waits for it, then removes
- * the vault from the registry via `vault-remove` IPC.
+ * Delegates to the active transport's {@link ObsidianTransport.unregisterVault}.
  *
  * @param vaultPath - The absolute path to the vault folder.
  */

package/dist/lib/esm/vault-registry.mjs

@@ -1,64 +1,15 @@
-import { evalInObsidian } from "./obsidian-cli.mjs";
-const POLL_INTERVAL_MS = 500;
-const POLL_TIMEOUT_MS = 3e4;
-const CLOSE_DELAY_MS = 1e3;
+import { inject } from "vitest";
+import { getOrCreateTransport } from "./transport-factory.mjs";
 async function registerVault(vaultPath) {
-  await evalInObsidian({
-    args: { vaultPath },
-    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
-    fn({ vaultPath: vaultPath2 }) {
-      window.electron.ipcRenderer.sendSync("vault-open", vaultPath2, false);
-    },
-    shouldSkipPreflightChecks: true
-  });
-  const deadline = Date.now() + POLL_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    try {
-      const basePath = await evalInObsidian({
-        fn({ app }) {
-          return app.vault.adapter.getBasePath();
-        },
-        shouldSkipPreflightChecks: true,
-        vaultPath
-      });
-      if (basePath === vaultPath) {
-        return;
-      }
-    } catch {
-    }
-    await new Promise((r) => {
-      setTimeout(r, POLL_INTERVAL_MS);
-    });
-  }
-  throw new Error(`Vault at ${vaultPath} did not become ready within ${String(POLL_TIMEOUT_MS)}ms`);
+  const transport = await getOrCreateTransport(inject("obsidianTransport"));
+  await transport.registerVault(vaultPath);
 }
 async function unregisterVault(vaultPath) {
-  try {
-    await evalInObsidian({
-      fn() {
-        setTimeout(() => {
-          window.electron.remote?.getCurrentWindow().destroy();
-        }, 0);
-      },
-      shouldSkipPreflightChecks: true,
-      vaultPath
-    });
-  } catch {
-  }
-  await new Promise((r) => {
-    setTimeout(r, CLOSE_DELAY_MS);
-  });
-  await evalInObsidian({
-    args: { vaultPath },
-    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
-    fn({ vaultPath: vaultPath2 }) {
-      window.electron.ipcRenderer.sendSync("vault-remove", vaultPath2);
-    },
-    shouldSkipPreflightChecks: true
-  });
+  const transport = await getOrCreateTransport(inject("obsidianTransport"));
+  await transport.unregisterVault(vaultPath);
 }
 export {
   registerVault,
   unregisterVault
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3ZhdWx0LXJlZ2lzdHJ5LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiB2OCBpZ25vcmUgc3RhcnQgLS0gSW50ZWdyYXRpb24tdGltZSBjb2RlIGNvdmVyZWQgYnkgaW50ZWdyYXRpb24gdGVzdHMsIG5vdCB1bml0IHRlc3RzLiAqL1xuXG4vKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICpcbiAqIE1hbmFnZXMgdmF1bHQgcmVnaXN0cmF0aW9uIGluIHRoZSBydW5uaW5nIE9ic2lkaWFuIGluc3RhbmNlLlxuICovXG5cbmltcG9ydCB0eXBlIHsgRmlsZVN5c3RlbUFkYXB0ZXIgfSBmcm9tICdvYnNpZGlhbic7XG5cbmltcG9ydCB7IGV2YWxJbk9ic2lkaWFuIH0gZnJvbSAnLi9vYnNpZGlhbi1jbGkubWpzJztcblxuY29uc3QgUE9MTF9JTlRFUlZBTF9NUyA9IDUwMDtcbmNvbnN0IFBPTExfVElNRU9VVF9NUyA9IDMwMDAwO1xuY29uc3QgQ0xPU0VfREVMQVlfTVMgPSAxMDAwO1xuXG5pbnRlcmZhY2UgRWxlY3Ryb24ge1xuICByZW1vdGU6IEVsZWN0cm9uUmVtb3RlO1xufVxuXG5pbnRlcmZhY2UgRWxlY3Ryb25SZW1vdGUge1xuICBnZXRDdXJyZW50V2luZG93KCk6IEdldEN1cnJlbnRXaW5kb3dSZXN1bHQ7XG59XG5cbmludGVyZmFjZSBHZXRDdXJyZW50V2luZG93UmVzdWx0IHtcbiAgZGVzdHJveSgpOiB2b2lkO1xufVxuXG4vKipcbiAqIFJlZ2lzdGVycyBhIHZhdWx0IHBhdGggaW4gdGhlIHJ1bm5pbmcgT2JzaWRpYW4gaW5zdGFuY2Ugc28gdGhlIENMSSBjYW4gdGFyZ2V0IGl0IHZpYSBgY3dkYC5cbiAqXG4gKiBVc2VzIHRoZSBgdmF1bHQtb3BlbmAgSVBDIHRvIHJlZ2lzdGVyIGFuZCBvcGVuIHRoZSB2YXVsdCwgdGhlbiBwb2xscyB1bnRpbFxuICogdGhlIHZhdWx0J3MgQ0xJIGlzIHJlYWR5IGFuZCBgZ2V0QmFzZVBhdGgoKWAgbWF0Y2hlcyBgdmF1bHRQYXRoYC5cbiAqXG4gKiBAcGFyYW0gdmF1bHRQYXRoIC0gVGhlIGFic29sdXRlIHBhdGggdG8gdGhlIHZhdWx0IGZvbGRlci5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJlZ2lzdGVyVmF1bHQodmF1bHRQYXRoOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgLy8gT3BlbiB0aGUgdmF1bHQgdmlhIElQQy4gVGhlIHNlbmRTeW5jIHJldHVybiB2YWx1ZSBpcyB1bnJlbGlhYmxlXG4gIC8vIChDTEkgb3V0cHV0IG1heSBiZSBsb3N0IHdoZW4gdGhlIG5ldyB3aW5kb3cgb3BlbnMpLCBzbyB3ZSBpZ25vcmUgaXRcbiAgLy8gQW5kIHBvbGwgZm9yIHJlYWRpbmVzcyBpbnN0ZWFkLlxuICBhd2FpdCBldmFsSW5PYnNpZGlhbih7XG4gICAgYXJnczogeyB2YXVsdFBhdGggfSxcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIE5vIGFjdHVhbCBzaGFkb3dpbmcgYXMgdGhlIGZ1bmN0aW9uIGlzIGV4ZWN1dGVkIGV4dGVybmFsbHkuXG4gICAgZm4oeyB2YXVsdFBhdGggfSk6IHZvaWQge1xuICAgICAgd2luZG93LmVsZWN0cm9uLmlwY1JlbmRlcmVyLnNlbmRTeW5jKCd2YXVsdC1vcGVuJywgdmF1bHRQYXRoLCBmYWxzZSk7XG4gICAgfSxcbiAgICBzaG91bGRTa2lwUHJlZmxpZ2h0Q2hlY2tzOiB0cnVlXG4gIH0pO1xuXG4gIC8vIFBvbGwgdW50aWwgdGhlIG5ldyB2YXVsdCdzIENMSSByZXNwb25kcyB3aXRoIHRoZSBjb3JyZWN0IGJhc2VQYXRoLlxuICBjb25zdCBkZWFkbGluZSA9IERhdGUubm93KCkgKyBQT0xMX1RJTUVPVVRfTVM7XG4gIHdoaWxlIChEYXRlLm5vdygpIDwgZGVhZGxpbmUpIHtcbiAgICB0cnkge1xuICAgICAgY29uc3QgYmFzZVBhdGggPSBhd2FpdCBldmFsSW5PYnNpZGlhbih7XG4gICAgICAgIGZuKHsgYXBwIH0pOiBzdHJpbmcge1xuICAgICAgICAgIHJldHVybiAoYXBwLnZhdWx0LmFkYXB0ZXIgYXMgRmlsZVN5c3RlbUFkYXB0ZXIpLmdldEJhc2VQYXRoKCk7XG4gICAgICAgIH0sXG4gICAgICAgIHNob3VsZFNraXBQcmVmbGlnaHRDaGVja3M6IHRydWUsXG4gICAgICAgIHZhdWx0UGF0aFxuICAgICAgfSk7XG4gICAgICBpZiAoYmFzZVBhdGggPT09IHZhdWx0UGF0aCkge1xuICAgICAgICByZXR1cm47XG4gICAgICB9XG4gICAgfSBjYXRjaCB7XG4gICAgICAvLyBWYXVsdCBub3QgcmVhZHkgeWV0LlxuICAgIH1cbiAgICBhd2FpdCBuZXcgUHJvbWlzZSgocikgPT4ge1xuICAgICAgc2V0VGltZW91dChyLCBQT0xMX0lOVEVSVkFMX01TKTtcbiAgICB9KTtcbiAgfVxuICB0aHJvdyBuZXcgRXJyb3IoYFZhdWx0IGF0ICR7dmF1bHRQYXRofSBkaWQgbm90IGJlY29tZSByZWFkeSB3aXRoaW4gJHtTdHJpbmcoUE9MTF9USU1FT1VUX01TKX1tc2ApO1xufVxuXG4vKipcbiAqIFVucmVnaXN0ZXJzIGEgdmF1bHQgcGF0aCBmcm9tIHRoZSBydW5uaW5nIE9ic2lkaWFuIGluc3RhbmNlLlxuICpcbiAqIFNjaGVkdWxlcyB0aGUgdmF1bHQgd2luZG93IHRvIGNsb3NlLCB3YWl0cyBmb3IgaXQsIHRoZW4gcmVtb3Zlc1xuICogdGhlIHZhdWx0IGZyb20gdGhlIHJlZ2lzdHJ5IHZpYSBgdmF1bHQtcmVtb3ZlYCBJUEMuXG4gKlxuICogQHBhcmFtIHZhdWx0UGF0aCAtIFRoZSBhYnNvbHV0ZSBwYXRoIHRvIHRoZSB2YXVsdCBmb2xkZXIuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiB1bnJlZ2lzdGVyVmF1bHQodmF1bHRQYXRoOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgLy8gU2NoZWR1bGUgdGhlIHZhdWx0IHdpbmRvdyB0byBjbG9zZSBmcm9tIHdpdGhpbiBpdHMgb3duIGNvbnRleHQuXG4gIC8vIFVzZSBzZXRUaW1lb3V0IHNvIHRoZSBDTEkgcmVzcG9uc2UgaXMgc2VudCBiZWZvcmUgdGhlIHdpbmRvdyBjbG9zZXMuXG4gIHRyeSB7XG4gICAgYXdhaXQgZXZhbEluT2JzaWRpYW4oe1xuICAgICAgZm4oKTogdm9pZCB7XG4gICAgICAgIHNldFRpbWVvdXQoKCkgPT4ge1xuICAgICAgICAgICh3aW5kb3cuZWxlY3Ryb24gYXMgUGFydGlhbDxFbGVjdHJvbj4pLnJlbW90ZT8uZ2V0Q3VycmVudFdpbmRvdygpLmRlc3Ryb3koKTtcbiAgICAgICAgfSwgMCk7XG4gICAgICB9LFxuICAgICAgc2hvdWxkU2tpcFByZWZsaWdodENoZWNrczogdHJ1ZSxcbiAgICAgIHZhdWx0UGF0aFxuICAgIH0pO1xuICB9IGNhdGNoIHtcbiAgICAvLyBUaGUgd2luZG93IG1heSBoYXZlIGNsb3NlZCBiZWZvcmUgdGhlIHJlc3BvbnNlIHdhcyBzZW50IFx1MjAxNCB0aGF0J3MgT0suXG4gIH1cblxuICAvLyBXYWl0IGZvciB0aGUgd2luZG93IHRvIGFjdHVhbGx5IGNsb3NlLlxuICBhd2FpdCBuZXcgUHJvbWlzZSgocikgPT4ge1xuICAgIHNldFRpbWVvdXQociwgQ0xPU0VfREVMQVlfTVMpO1xuICB9KTtcblxuICAvLyBSZW1vdmUgZnJvbSB0aGUgcmVnaXN0cnkgKGZyb20gYW55IHJlbWFpbmluZyB2YXVsdCdzIGNvbnRleHQpLlxuICBhd2FpdCBldmFsSW5PYnNpZGlhbih7XG4gICAgYXJnczogeyB2YXVsdFBhdGggfSxcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tc2hhZG93IC0tIE5vIGFjdHVhbCBzaGFkb3dpbmcgYXMgdGhlIGZ1bmN0aW9uIGlzIGV4ZWN1dGVkIGV4dGVybmFsbHkuXG4gICAgZm4oeyB2YXVsdFBhdGggfSk6IHZvaWQge1xuICAgICAgd2luZG93LmVsZWN0cm9uLmlwY1JlbmRlcmVyLnNlbmRTeW5jKCd2YXVsdC1yZW1vdmUnLCB2YXVsdFBhdGgpO1xuICAgIH0sXG4gICAgc2hvdWxkU2tpcFByZWZsaWdodENoZWNrczogdHJ1ZVxuICB9KTtcbn1cblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICJBQVVBLFNBQVMsc0JBQXNCO0FBRS9CLE1BQU0sbUJBQW1CO0FBQ3pCLE1BQU0sa0JBQWtCO0FBQ3hCLE1BQU0saUJBQWlCO0FBc0J2QixlQUFzQixjQUFjLFdBQWtDO0FBSXBFLFFBQU0sZUFBZTtBQUFBLElBQ25CLE1BQU0sRUFBRSxVQUFVO0FBQUE7QUFBQSxJQUVsQixHQUFHLEVBQUUsV0FBQUEsV0FBVSxHQUFTO0FBQ3RCLGFBQU8sU0FBUyxZQUFZLFNBQVMsY0FBY0EsWUFBVyxLQUFLO0FBQUEsSUFDckU7QUFBQSxJQUNBLDJCQUEyQjtBQUFBLEVBQzdCLENBQUM7QUFHRCxRQUFNLFdBQVcsS0FBSyxJQUFJLElBQUk7QUFDOUIsU0FBTyxLQUFLLElBQUksSUFBSSxVQUFVO0FBQzVCLFFBQUk7QUFDRixZQUFNLFdBQVcsTUFBTSxlQUFlO0FBQUEsUUFDcEMsR0FBRyxFQUFFLElBQUksR0FBVztBQUNsQixpQkFBUSxJQUFJLE1BQU0sUUFBOEIsWUFBWTtBQUFBLFFBQzlEO0FBQUEsUUFDQSwyQkFBMkI7QUFBQSxRQUMzQjtBQUFBLE1BQ0YsQ0FBQztBQUNELFVBQUksYUFBYSxXQUFXO0FBQzFCO0FBQUEsTUFDRjtBQUFBLElBQ0YsUUFBUTtBQUFBLElBRVI7QUFDQSxVQUFNLElBQUksUUFBUSxDQUFDLE1BQU07QUFDdkIsaUJBQVcsR0FBRyxnQkFBZ0I7QUFBQSxJQUNoQyxDQUFDO0FBQUEsRUFDSDtBQUNBLFFBQU0sSUFBSSxNQUFNLFlBQVksU0FBUyxnQ0FBZ0MsT0FBTyxlQUFlLENBQUMsSUFBSTtBQUNsRztBQVVBLGVBQXNCLGdCQUFnQixXQUFrQztBQUd0RSxNQUFJO0FBQ0YsVUFBTSxlQUFlO0FBQUEsTUFDbkIsS0FBVztBQUNULG1CQUFXLE1BQU07QUFDZixVQUFDLE9BQU8sU0FBK0IsUUFBUSxpQkFBaUIsRUFBRSxRQUFRO0FBQUEsUUFDNUUsR0FBRyxDQUFDO0FBQUEsTUFDTjtBQUFBLE1BQ0EsMkJBQTJCO0FBQUEsTUFDM0I7QUFBQSxJQUNGLENBQUM7QUFBQSxFQUNILFFBQVE7QUFBQSxFQUVSO0FBR0EsUUFBTSxJQUFJLFFBQVEsQ0FBQyxNQUFNO0FBQ3ZCLGVBQVcsR0FBRyxjQUFjO0FBQUEsRUFDOUIsQ0FBQztBQUdELFFBQU0sZUFBZTtBQUFBLElBQ25CLE1BQU0sRUFBRSxVQUFVO0FBQUE7QUFBQSxJQUVsQixHQUFHLEVBQUUsV0FBQUEsV0FBVSxHQUFTO0FBQ3RCLGFBQU8sU0FBUyxZQUFZLFNBQVMsZ0JBQWdCQSxVQUFTO0FBQUEsSUFDaEU7QUFBQSxJQUNBLDJCQUEyQjtBQUFBLEVBQzdCLENBQUM7QUFDSDsiLAogICJuYW1lcyI6IFsidmF1bHRQYXRoIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,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