obsidian-integration-testing 1.1.2 → 1.2.0

package/dist/lib/cjs/temp-vault.cjs

@@ -25,9 +25,11 @@ var import_node_fs = require("node:fs");
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
+var import_vitest = require("vitest");
+var import_transport_factory = require("./transport-factory.cjs");
 var import_vault_registry = require("./vault-registry.cjs");
-const RM_RETRY_DELAY_MS = 500;
-const RM_RETRY_TIMEOUT_MS = 1e4;
+const RM_RETRY_DELAY_IN_MILLISECONDS = 500;
+const RM_RETRY_TIMEOUT_IN_MILLISECONDS = 1e4;
 class TempVault {
   /**
    * The absolute path to the temporary vault.
@@ -83,16 +85,56 @@ class TempVault {
   async [Symbol.asyncDispose]() {
     return this.dispose();
   }
+  /* v8 ignore start -- Integration-time code that requires a running transport via inject(). */
+  /**
+   * Pushes all files from the local staging directory to the target device
+   * via the active transport's `pushFiles()`.
+   *
+   * On desktop transports this is a no-op (files are already local).
+   * On mobile transports (Appium) this pushes files to the device.
+   *
+   * Call this after {@link populate} and before {@link register} when using
+   * a mobile transport.
+   */
+  async syncToDevice() {
+    const transport = await (0, import_transport_factory.getOrCreateTransport)((0, import_vitest.inject)("obsidianTransport"));
+    if (!transport.pushFiles) {
+      return;
+    }
+    const files = await this.collectFiles(this.path);
+    await transport.pushFiles(this.path, files);
+  }
+  /**
+   * Recursively reads all files from a directory into a flat map.
+   *
+   * @param dir - The directory to read.
+   * @returns A map of relative file paths to content strings.
+   */
+  async collectFiles(dir) {
+    const result = {};
+    const entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path.join)(dir, entry.name);
+      const relativePath = (0, import_node_path.relative)(this.path, fullPath);
+      if (entry.isDirectory()) {
+        Object.assign(result, await this.collectFiles(fullPath));
+      } else {
+        result[relativePath] = await (0, import_promises.readFile)(fullPath, "utf-8");
+      }
+    }
+    return result;
+  }
+  /* v8 ignore stop */
 }
 async function retryRm(path) {
-  const deadline = Date.now() + RM_RETRY_TIMEOUT_MS;
+  const deadline = Date.now() + RM_RETRY_TIMEOUT_IN_MILLISECONDS;
   while (Date.now() < deadline) {
     try {
       await (0, import_promises.rm)(path, { force: true, recursive: true });
       return;
     } catch {
       await new Promise((resolve) => {
-        setTimeout(resolve, RM_RETRY_DELAY_MS);
+        setTimeout(resolve, RM_RETRY_DELAY_IN_MILLISECONDS);
       });
     }
   }
@@ -102,4 +144,4 @@ async function retryRm(path) {
 0 && (module.exports = {
   TempVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/temp-vault.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Manages temporary vault lifecycle for integration tests.\n */\n\nimport {\n  mkdirSync,\n  mkdtempSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  readdir,\n  readFile,\n  rm\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport {\n  dirname,\n  join,\n  relative\n} from 'node:path';\nimport { inject } from 'vitest';\n\nimport { getOrCreateTransport } from './transport-factory.cjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\n\nconst RM_RETRY_DELAY_IN_MILLISECONDS = 500;\nconst RM_RETRY_TIMEOUT_IN_MILLISECONDS = 10000;\n\n/**\n * A temporary Obsidian vault for integration tests.\n *\n * Creates a temp directory and registers it in the running Obsidian instance\n * so that the Obsidian CLI can target it via `cwd`.\n */\nexport class TempVault {\n  /**\n   * The absolute path to the temporary vault.\n   */\n  public readonly path: string;\n\n  /**\n   * Creates a new temp vault.\n   *\n   * @param path - An explicit vault path. If omitted, a temp directory is created.\n   */\n  public constructor(path?: string) {\n    this.path = path ?? mkdtempSync(join(tmpdir(), 'temp-vault-'));\n  }\n\n  /**\n   * Unregisters the vault from Obsidian and deletes the temp directory.\n   */\n  public async dispose(): Promise<void> {\n    await unregisterVault(this.path);\n    await retryRm(this.path);\n  }\n\n  /**\n   * Writes files and folders into the vault directory.\n   * Parent directories are created automatically.\n   * Paths ending with `/` are treated as empty folders (content must be empty string).\n   *\n   * @param files - Map of file/folder paths to content.\n   */\n  public populate(files: Record<string, string>): void {\n    for (const [filePath, content] of Object.entries(files)) {\n      const fullPath = join(this.path, filePath);\n      if (filePath.endsWith('/')) {\n        if (content !== '') {\n          throw new Error(`Folder path \"${filePath}\" must have empty content`);\n        }\n        mkdirSync(fullPath, { recursive: true });\n      } else {\n        mkdirSync(dirname(fullPath), { recursive: true });\n        writeFileSync(fullPath, content);\n      }\n    }\n  }\n\n  /**\n   * Registers this vault in the running Obsidian instance so the CLI can target it.\n   */\n  public async register(): Promise<void> {\n    await registerVault(this.path);\n  }\n\n  /**\n   * Async disposable support for `await using`.\n   *\n   * @returns A promise that resolves when the vault is disposed.\n   */\n  public async [Symbol.asyncDispose](): Promise<void> {\n    return this.dispose();\n  }\n\n  /* v8 ignore start -- Integration-time code that requires a running transport via inject(). */\n\n  /**\n   * Pushes all files from the local staging directory to the target device\n   * via the active transport's `pushFiles()`.\n   *\n   * On desktop transports this is a no-op (files are already local).\n   * On mobile transports (Appium) this pushes files to the device.\n   *\n   * Call this after {@link populate} and before {@link register} when using\n   * a mobile transport.\n   */\n  public async syncToDevice(): Promise<void> {\n    const transport = await getOrCreateTransport(inject('obsidianTransport'));\n    if (!transport.pushFiles) {\n      return;\n    }\n\n    const files = await this.collectFiles(this.path);\n    await transport.pushFiles(this.path, files);\n  }\n\n  /**\n   * Recursively reads all files from a directory into a flat map.\n   *\n   * @param dir - The directory to read.\n   * @returns A map of relative file paths to content strings.\n   */\n  private async collectFiles(dir: string): Promise<Record<string, string>> {\n    const result: Record<string, string> = {};\n    const entries = await readdir(dir, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(dir, entry.name);\n      const relativePath = relative(this.path, fullPath);\n\n      if (entry.isDirectory()) {\n        Object.assign(result, await this.collectFiles(fullPath));\n      } else {\n        result[relativePath] = await readFile(fullPath, 'utf-8');\n      }\n    }\n\n    return result;\n  }\n  /* v8 ignore stop */\n}\n\n/**\n * Retries `rm` until it succeeds or times out.\n * Obsidian may hold file locks briefly after a window is destroyed.\n *\n * @param path - The path to the directory to remove.\n * @returns A promise that resolves when the directory is removed.\n */\nasync function retryRm(path: string): Promise<void> {\n  const deadline = Date.now() + RM_RETRY_TIMEOUT_IN_MILLISECONDS;\n  while (Date.now() < deadline) {\n    try {\n      await rm(path, { force: true, recursive: true });\n      return;\n    } catch {\n      await new Promise((resolve) => {\n        setTimeout(resolve, RM_RETRY_DELAY_IN_MILLISECONDS);\n      });\n    }\n  }\n  // Final attempt \u2014 let it throw.\n  await rm(path, { force: true, recursive: true });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAIO;AACP,sBAIO;AACP,qBAAuB;AACvB,uBAIO;AACP,oBAAuB;AAEvB,+BAAqC;AACrC,4BAGO;AAEP,MAAM,iCAAiC;AACvC,MAAM,mCAAmC;AAQlC,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA,EAIL;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOT,YAAY,MAAe;AAChC,SAAK,OAAO,YAAQ,gCAAY,2BAAK,uBAAO,GAAG,aAAa,CAAC;AAAA,EAC/D;AAAA;AAAA;AAAA;AAAA,EAKA,MAAa,UAAyB;AACpC,cAAM,uCAAgB,KAAK,IAAI;AAC/B,UAAM,QAAQ,KAAK,IAAI;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,SAAS,OAAqC;AACnD,eAAW,CAAC,UAAU,OAAO,KAAK,OAAO,QAAQ,KAAK,GAAG;AACvD,YAAM,eAAW,uBAAK,KAAK,MAAM,QAAQ;AACzC,UAAI,SAAS,SAAS,GAAG,GAAG;AAC1B,YAAI,YAAY,IAAI;AAClB,gBAAM,IAAI,MAAM,gBAAgB,QAAQ,2BAA2B;AAAA,QACrE;AACA,sCAAU,UAAU,EAAE,WAAW,KAAK,CAAC;AAAA,MACzC,OAAO;AACL,0CAAU,0BAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAChD,0CAAc,UAAU,OAAO;AAAA,MACjC;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,MAAa,WAA0B;AACrC,cAAM,qCAAc,KAAK,IAAI;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAc,OAAO,YAAY,IAAmB;AAClD,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,MAAa,eAA8B;AACzC,UAAM,YAAY,UAAM,mDAAqB,sBAAO,mBAAmB,CAAC;AACxE,QAAI,CAAC,UAAU,WAAW;AACxB;AAAA,IACF;AAEA,UAAM,QAAQ,MAAM,KAAK,aAAa,KAAK,IAAI;AAC/C,UAAM,UAAU,UAAU,KAAK,MAAM,KAAK;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAc,aAAa,KAA8C;AACvE,UAAM,SAAiC,CAAC;AACxC,UAAM,UAAU,UAAM,yBAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAE1D,eAAW,SAAS,SAAS;AAC3B,YAAM,eAAW,uBAAK,KAAK,MAAM,IAAI;AACrC,YAAM,mBAAe,2BAAS,KAAK,MAAM,QAAQ;AAEjD,UAAI,MAAM,YAAY,GAAG;AACvB,eAAO,OAAO,QAAQ,MAAM,KAAK,aAAa,QAAQ,CAAC;AAAA,MACzD,OAAO;AACL,eAAO,YAAY,IAAI,UAAM,0BAAS,UAAU,OAAO;AAAA,MACzD;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAEF;AASA,eAAe,QAAQ,MAA6B;AAClD,QAAM,WAAW,KAAK,IAAI,IAAI;AAC9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,QAAI;AACF,gBAAM,oBAAG,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAC/C;AAAA,IACF,QAAQ;AACN,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,8BAA8B;AAAA,MACpD,CAAC;AAAA,IACH;AAAA,EACF;AAEA,YAAM,oBAAG,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AACjD;",
  "names": []
}


package/dist/lib/cjs/temp-vault.d.cts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Manages temporary vault lifecycle for integration tests.
  */
@@ -42,4 +42,22 @@ export declare class TempVault {
      * @returns A promise that resolves when the vault is disposed.
      */
     [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Pushes all files from the local staging directory to the target device
+     * via the active transport's `pushFiles()`.
+     *
+     * On desktop transports this is a no-op (files are already local).
+     * On mobile transports (Appium) this pushes files to the device.
+     *
+     * Call this after {@link populate} and before {@link register} when using
+     * a mobile transport.
+     */
+    syncToDevice(): Promise<void>;
+    /**
+     * Recursively reads all files from a directory into a flat map.
+     *
+     * @param dir - The directory to read.
+     * @returns A map of relative file paths to content strings.
+     */
+    private collectFiles;
 }

package/dist/lib/cjs/transport-appium.cjs

@@ -0,0 +1,232 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transport_appium_exports = {};
+__export(transport_appium_exports, {
+  AppiumTransport: () => AppiumTransport
+});
+module.exports = __toCommonJS(transport_appium_exports);
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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.cjs';\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/cjs/transport-appium.d.cts

@@ -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.cjs';
+/**
+ * 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;
+}