obsidian-integration-testing 9.2.2 → 10.1.0

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

@@ -0,0 +1,166 @@
+"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 temporary_vault_exports = {};
+__export(temporary_vault_exports, {
+  TemporaryVault: () => TemporaryVault
+});
+module.exports = __toCommonJS(temporary_vault_exports);
+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_context_provider = require("./context-provider.cjs");
+var import_leftover_cleanup = require("./leftover-cleanup.cjs");
+var import_transport_factory = require("./transport-factory.cjs");
+var import_vault_registry = require("./vault-registry.cjs");
+const RM_RETRY_DELAY_IN_MILLISECONDS = 500;
+const RM_RETRY_TIMEOUT_IN_MILLISECONDS = 1e4;
+class TemporaryVault {
+  /**
+   * The absolute path to the temporary vault.
+   */
+  path;
+  /**
+   * Creates a new temp vault.
+   *
+   * @param path - An explicit vault path. If omitted, a temp directory is created.
+   */
+  constructor(path) {
+    this.path = path ?? (0, import_node_fs.mkdtempSync)((0, import_node_path.join)((0, import_node_os.tmpdir)(), import_leftover_cleanup.TEMP_VAULT_DIR_PREFIX));
+  }
+  /**
+   * Unregisters the vault from Obsidian and deletes the temp directory.
+   *
+   * @param transportOverride - An explicit transport to use when unregistering.
+   *   When omitted, falls back to the transport configured via the context provider.
+   */
+  async dispose(transportOverride) {
+    try {
+      await (0, import_vault_registry.unregisterVault)(this.path, transportOverride);
+    } finally {
+      await retryRm(this.path);
+    }
+  }
+  /**
+   * Writes files and folders into the vault directory.
+   * Parent directories are created automatically.
+   *
+   * - `string` values are written as UTF-8 text files.
+   * - `Uint8Array` values (including `Buffer`) are written as binary files.
+   * - Paths ending with `/` are treated as empty folders (value must be `undefined`).
+   *
+   * @param files - Map of file/folder paths to content.
+   */
+  populate(files) {
+    for (const [filePath, content] of Object.entries(files)) {
+      const fullPath = (0, import_node_path.join)(this.path, filePath);
+      if (filePath.endsWith("/")) {
+        if (content !== void 0) {
+          throw new Error(`Folder path "${filePath}" must have undefined content`);
+        }
+        (0, import_node_fs.mkdirSync)(fullPath, { recursive: true });
+      } else {
+        if (content === void 0) {
+          throw new Error(`File path "${filePath}" must have defined content; use a trailing "/" for folders`);
+        }
+        (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(fullPath), { recursive: true });
+        (0, import_node_fs.writeFileSync)(fullPath, content);
+      }
+    }
+  }
+  /**
+   * Registers this vault in the running Obsidian instance so the CLI can target it.
+   *
+   * @param transportOverride - An explicit transport to use. When omitted,
+   *   falls back to the transport configured via the context provider.
+   */
+  async register(transportOverride) {
+    await (0, import_vault_registry.registerVault)(this.path, transportOverride);
+  }
+  /**
+   * Async disposable support for `await using`.
+   *
+   * @returns A promise that resolves when the vault is disposed.
+   */
+  async [Symbol.asyncDispose]() {
+    return this.dispose();
+  }
+  /* v8 ignore start -- Integration-time code that requires a running transport. */
+  /**
+   * 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.
+   *
+   * @param transportOverride - An explicit transport to use. When omitted,
+   *   falls back to the transport configured via the context provider.
+   */
+  async syncToDevice(transportOverride) {
+    const transport = transportOverride ?? await (0, import_transport_factory.getOrCreateTransport)((0, import_context_provider.getTransportOptions)());
+    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 directory - The directory to read.
+   * @returns A map of relative file paths to content buffers.
+   */
+  async collectFiles(directory) {
+    const result = {};
+    const entries = await (0, import_promises.readdir)(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path.join)(directory, 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);
+      }
+    }
+    return result;
+  }
+  /* v8 ignore stop */
+}
+async function retryRm(path) {
+  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_IN_MILLISECONDS);
+      });
+    }
+  }
+  await (0, import_promises.rm)(path, { force: true, recursive: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TemporaryVault
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/temporary-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';\n\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { getTransportOptions } from './context-provider.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\nimport {\n  registerVault,\n  unregisterVault\n} from './vault-registry.cjs';\n\n/**\n * Content value for a single entry in a {@link PopulateFiles} map.\n *\n * - `string` \u2014 text file (written as UTF-8).\n * - `Uint8Array` \u2014 binary file (written as raw bytes; `Buffer` is accepted\n *   because `Buffer extends Uint8Array`).\n * - `undefined` \u2014 empty folder (the key **must** end with `/`).\n */\nexport type PopulateFileContent = string | Uint8Array | undefined;\n\n/**\n * A map of vault-relative paths to their content, used by\n * {@link TemporaryVault.populate}.\n *\n * Paths ending with `/` denote folders and **must** have an `undefined` value.\n * All other paths are written as files.\n */\nexport type PopulateFilesParams = Record<string, PopulateFileContent>;\n\nconst RM_RETRY_DELAY_IN_MILLISECONDS = 500;\nconst RM_RETRY_TIMEOUT_IN_MILLISECONDS = 10_000;\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 TemporaryVault {\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_DIR_PREFIX));\n  }\n\n  /**\n   * Unregisters the vault from Obsidian and deletes the temp directory.\n   *\n   * @param transportOverride - An explicit transport to use when unregistering.\n   *   When omitted, falls back to the transport configured via the context provider.\n   */\n  public async dispose(transportOverride?: ObsidianTransport): Promise<void> {\n    try {\n      await unregisterVault(this.path, transportOverride);\n    } finally {\n      await retryRm(this.path);\n    }\n  }\n\n  /**\n   * Writes files and folders into the vault directory.\n   * Parent directories are created automatically.\n   *\n   * - `string` values are written as UTF-8 text files.\n   * - `Uint8Array` values (including `Buffer`) are written as binary files.\n   * - Paths ending with `/` are treated as empty folders (value must be `undefined`).\n   *\n   * @param files - Map of file/folder paths to content.\n   */\n  public populate(files: PopulateFilesParams): void {\n    for (const [filePath, content] of Object.entries(files)) {\n      const fullPath = join(this.path, filePath);\n      if (filePath.endsWith('/')) {\n        if (content !== undefined) {\n          throw new Error(`Folder path \"${filePath}\" must have undefined content`);\n        }\n        mkdirSync(fullPath, { recursive: true });\n      } else {\n        if (content === undefined) {\n          throw new Error(`File path \"${filePath}\" must have defined content; use a trailing \"/\" for folders`);\n        }\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   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async register(transportOverride?: ObsidianTransport): Promise<void> {\n    await registerVault(this.path, transportOverride);\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. */\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   * @param transportOverride - An explicit transport to use. When omitted,\n   *   falls back to the transport configured via the context provider.\n   */\n  public async syncToDevice(transportOverride?: ObsidianTransport): Promise<void> {\n    const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\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 directory - The directory to read.\n   * @returns A map of relative file paths to content buffers.\n   */\n  private async collectFiles(directory: string): Promise<Record<string, Uint8Array>> {\n    const result: Record<string, Uint8Array> = {};\n    const entries = await readdir(directory, { withFileTypes: true });\n\n    for (const entry of entries) {\n      const fullPath = join(directory, 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);\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": "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",
  "names": []
}


package/dist/lib/cjs/{temp-vault.d.cts → temporary-vault.d.cts}

@@ -15,7 +15,7 @@ import type { ObsidianTransport } from './transport.cjs';
 export type PopulateFileContent = string | Uint8Array | undefined;
 /**
  * A map of vault-relative paths to their content, used by
- * {@link TempVault.populate}.
+ * {@link TemporaryVault.populate}.
  *
  * Paths ending with `/` denote folders and **must** have an `undefined` value.
  * All other paths are written as files.
@@ -27,7 +27,7 @@ export type PopulateFilesParams = Record<string, PopulateFileContent>;
  * Creates a temp directory and registers it in the running Obsidian instance
  * so that the Obsidian CLI can target it via `cwd`.
  */
-export declare class TempVault {
+export declare class TemporaryVault {
     /**
      * The absolute path to the temporary vault.
      */
@@ -86,7 +86,7 @@ export declare class TempVault {
     /**
      * Recursively reads all files from a directory into a flat map.
      *
-     * @param dir - The directory to read.
+     * @param directory - The directory to read.
      * @returns A map of relative file paths to content buffers.
      */
     private collectFiles;

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

@@ -26,6 +26,7 @@ var import_node_crypto = require("node:crypto");
 var import_promises = require("node:fs/promises");
 var import_node_os = require("node:os");
 var import_node_path = require("node:path");
+var import_capture_screenshot = require("./capture-screenshot.cjs");
 var import_exec = require("./exec.cjs");
 var import_leftover_cleanup = require("./leftover-cleanup.cjs");
 var import_log = require("./log.cjs");
@@ -109,6 +110,27 @@ class AppiumTransport {
     );
     return { marker };
   }
+  /**
+   * Captures a PNG screenshot of the device's screen.
+   *
+   * The image is always the device's native framebuffer — there is no mobile
+   * equivalent of the desktop viewport override, so
+   * {@link CaptureScreenshotParams.widthInPixels} /
+   * {@link CaptureScreenshotParams.heightInPixels} are ignored. Size a mobile
+   * capture by choosing an AVD whose screen geometry already matches what the
+   * image has to be.
+   *
+   * @param _params - Capture parameters. Ignored on mobile: `cwd` does not select a window (vault targeting is via localStorage), and the size cannot be overridden.
+   * @returns The raw PNG bytes.
+   * @throws Error if the driver returns data that is not a PNG.
+   */
+  async captureScreenshot(_params) {
+    const bytes = (0, import_capture_screenshot.decodeBase64Png)(await this.browser.takeScreenshot());
+    if (!(0, import_capture_screenshot.isPng)(bytes)) {
+      throw new Error("Appium screenshot error: takeScreenshot returned data that is not a PNG.");
+    }
+    return bytes;
+  }
   /**
    * Ends the Appium session.
    *
@@ -323,7 +345,7 @@ class AppiumTransport {
         `[appium-transport] Could not deregister ${deviceVaultPath} from localStorage (${String(error)}); removing its files anyway.`
       );
     }
-    await this.removeDeviceVaultDir(deviceVaultPath);
+    await this.removeDeviceVaultDirectory(deviceVaultPath);
   }
   /**
    * Switches the driver to the `WEBVIEW_md.obsidian` context.
@@ -344,7 +366,7 @@ class AppiumTransport {
     (0, import_log.log)(`[appium-transport] Waiting for ${WEBVIEW_CONTEXT_PREFIX} context (timeout=${String(this.webviewTimeoutInMilliseconds)}ms)...`);
     while (Date.now() < deadline) {
       const contexts = await this.browser.getContexts();
-      const obsidianContext = contexts.find((ctx) => typeof ctx === "string" && ctx.startsWith(WEBVIEW_CONTEXT_PREFIX));
+      const obsidianContext = contexts.find((context) => typeof context === "string" && context.startsWith(WEBVIEW_CONTEXT_PREFIX));
       if (obsidianContext) {
         (0, import_log.log)(`[appium-transport] Found WebView context: ${obsidianContext}`);
         try {
@@ -411,7 +433,7 @@ class AppiumTransport {
    *
    * @param deviceVaultPath - The device-side vault directory path.
    */
-  async removeDeviceVaultDir(deviceVaultPath) {
+  async removeDeviceVaultDirectory(deviceVaultPath) {
     try {
       (0, import_log.log)(`[appium-transport] Removing vault directory from device: ${deviceVaultPath}`);
       await (0, import_exec.exec)(
@@ -441,7 +463,7 @@ class AppiumTransport {
     while (Date.now() < deadline) {
       try {
         const isReady = await this.browser.execute(() => {
-          const app = window.app;
+          const app = globalThis.app;
           return !!app?.workspace?.layoutReady;
         });
         if (isReady) {
@@ -464,12 +486,12 @@ function delay(ms) {
 }
 function extractVaultName(vaultPath) {
   const normalized = vaultPath.replace(/[\\/]+$/, "");
-  const lastSep = Math.max(normalized.lastIndexOf("/"), normalized.lastIndexOf("\\"));
-  return normalized.slice(lastSep + 1);
+  const lastSeparator = Math.max(normalized.lastIndexOf("/"), normalized.lastIndexOf("\\"));
+  return normalized.slice(lastSeparator + 1);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppiumTransport,
   DEFAULT_ANDROID_VAULT_BASE_PATH
 });
-//# 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 *     avdName: 'obsidian_test',\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 { randomUUID } from 'node:crypto';\nimport {\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\n\n/**\n * Session connection info returned by {@link AppiumTransport.getSessionInfo},\n * used to reattach from another process.\n */\nexport interface AppiumSessionInfo {\n  /** The device UDID (e.g. `'emulator-5554'`). */\n  deviceId: string;\n\n  /** The Appium/WebDriver session ID. */\n  sessionId: string;\n}\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   * The device UDID (e.g. `'emulator-5554'`).\n   * Used for `adb` commands when pushing files to the device.\n   */\n  deviceId: string;\n\n  /**\n   * Whether this transport owns the Appium session and should delete it on\n   * {@link AppiumTransport.dispose}.\n   *\n   * `true` for sessions created via `remote()` (global setup).\n   * `false` for sessions reattached via `attach()` (test workers).\n   *\n   * @default `true`\n   */\n  isSessionOwner?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after\n   * the vault is (re)opened.\n   *\n   * @default `90000`\n   */\n  layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Target platform. Determines WebView context naming and device file paths.\n   */\n  platform: 'android' | 'ios';\n\n  /**\n   * Whether registering a vault also prunes the **other** `temp-vault-*`\n   * registrations earlier runs left in Obsidian Mobile's `localStorage`.\n   *\n   * The device-side directories are swept before the app launches (see the\n   * factory); this removes their now-dangling registry entries, which are what\n   * Obsidian actually enumerates at startup. Unregistering this run's own vault\n   * is unaffected \u2014 that always happens.\n   *\n   * @default `true`\n   */\n  shouldSweepLeftovers?: boolean;\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  /**\n   * Timeout in milliseconds for waiting for the WebView context to become available.\n   *\n   * @default `60000`\n   */\n  webviewTimeoutInMilliseconds?: number;\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 DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS = 60000;\nconst LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 90000;\nconst APP_RESTART_DELAY_IN_MILLISECONDS = 2000;\nconst DEFAULT_APP_ID = 'md.obsidian';\nconst ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS = 30000;\n\n// --- Console capture (Layer 2 of the plugin-load error surfacing, see T88) ---\nconst CONSOLE_CAPTURE_MARKER_TAG = 'OIT_CAPTURE';\nconst CONSOLE_CAPTURE_TAIL_MAX_LENGTH = 8000;\nconst ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS = 5000;\nconst LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS = 10000;\n/**\n * `adb logcat -v time` lines look like `MM-DD HH:MM:SS.mmm LEVEL/TAG( PID): message`.\n * Keep only the tags Chromium/WebView routes JS `console.*` output and uncaught\n * errors to (`chromium`, the Capacitor console bridge, and native `AndroidRuntime`).\n */\nconst CONSOLE_CAPTURE_TAG_RE = /\\/(?:chromium|AndroidRuntime|Capacitor\\/Console)\\(/;\n\n/**\n * Base path on an Android device where Obsidian Mobile stores its vaults.\n *\n * Exported because the transport factory sweeps leftover vaults from it before\n * a transport exists (see the repo's L31).\n */\nexport const DEFAULT_ANDROID_VAULT_BASE_PATH = '/sdcard/Documents/';\n\nconst DEFAULT_VAULT_BASE_PATH: Record<string, string> = {\n  android: DEFAULT_ANDROID_VAULT_BASE_PATH,\n  ios: '@md.obsidian:documents/'\n};\n\ninterface LoadingApp {\n  workspace?: LoadingWorkspace;\n}\n\ninterface LoadingWorkspace {\n  layoutReady?: boolean;\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   * Indicates whether this transport is for a mobile platform. Always `true` for this transport.\n   */\n  public readonly isMobile = true;\n  private readonly appId: string;\n  private readonly browser: Browser;\n  private readonly deviceId: string;\n  /**\n   * Tracks whether the driver is currently switched to the WebView context.\n   *\n   * Set to `true` after a successful `switchContext(WEBVIEW_md.obsidian)`.\n   * Reset to `false` when the context is known to be invalidated\n   * (e.g. after `location.reload()` in {@link registerVault}).\n   *\n   * When `true`, {@link ensureWebViewContext} skips the expensive\n   * `getContexts()` call (which runs `adb shell cat /proc/net/unix` and\n   * can time out on slow emulators).\n   */\n  private isInWebViewContext = false;\n  private readonly isSessionOwner: boolean;\n  private readonly layoutReadyTimeoutInMilliseconds: number;\n  private readonly platform: 'android' | 'ios';\n  private readonly shouldSweepLeftovers: boolean;\n  private readonly vaultBasePath: string;\n\n  private readonly webviewTimeoutInMilliseconds: number;\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.deviceId = config.deviceId;\n    this.isSessionOwner = config.isSessionOwner ?? true;\n    this.layoutReadyTimeoutInMilliseconds = config.layoutReadyTimeoutInMilliseconds ?? DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS;\n    this.platform = config.platform;\n    this.appId = config.appId ?? DEFAULT_APP_ID;\n    this.shouldSweepLeftovers = config.shouldSweepLeftovers ?? true;\n    this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? DEFAULT_ANDROID_VAULT_BASE_PATH;\n    this.webviewTimeoutInMilliseconds = config.webviewTimeoutInMilliseconds ?? DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;\n  }\n\n  /**\n   * Begins a console capture by stamping the device log with a unique marker.\n   *\n   * Uses `adb shell log` to write a marker into `logcat` at capture start so a\n   * later {@link AppiumTransport.readConsoleCaptureSince} can slice out\n   * everything the WebView logged afterwards \u2014 without the invasive `logcat -c`\n   * buffer clear.\n   *\n   * @returns A handle carrying the unique marker.\n   */\n  public async beginConsoleCapture(): Promise<ConsoleCaptureHandle> {\n    const marker = `${CONSOLE_CAPTURE_MARKER_TAG}_${randomUUID()}`;\n    await exec(\n      ['adb', '-s', this.deviceId, 'shell', 'log', '-t', CONSOLE_CAPTURE_MARKER_TAG, marker],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS }\n    );\n    return { marker };\n  }\n\n  /**\n   * Ends the Appium session.\n   *\n   * Only deletes the session if this transport owns it. Transports created\n   * via `attach()` (test workers reusing the global setup's session) skip\n   * deletion so the session remains available for the owning process.\n   */\n  public async dispose(): Promise<void> {\n    if (this.isSessionOwner) {\n      await this.browser.deleteSession();\n    }\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    try {\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    } catch (error: unknown) {\n      // Context may have been lost mid-execution (e.g. page reload).\n      this.isInWebViewContext = false;\n      throw error;\n    }\n  }\n\n  /**\n   * Returns the session connection info needed to reattach to this session\n   * from another process (e.g. a test worker).\n   *\n   * @returns The session ID and device ID.\n   */\n  public getSessionInfo(): AppiumSessionInfo {\n    return {\n      deviceId: this.deviceId,\n      sessionId: this.browser.sessionId\n    };\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    log('[appium-transport] Running preflight check...');\n    const state = await this.browser.queryAppState(this.appId);\n    log(`[appium-transport] App state: ${String(state)} (need ${String(APP_STATE_FOREGROUND)}=foreground)`);\n    if (state !== APP_STATE_FOREGROUND) {\n      log(`[appium-transport] Activating app ${this.appId}...`);\n      this.isInWebViewContext = false;\n      await this.browser.activateApp(this.appId);\n      await delay(APP_RESTART_DELAY_IN_MILLISECONDS);\n    }\n\n    await this.ensureWebViewContext();\n    log('[appium-transport] Preflight check passed.');\n  }\n\n  /**\n   * Pushes vault files to the device via compressed `adb push`.\n   *\n   * Creates a tar.gz archive of the local vault directory, pushes it to the\n   * device as a single file, and extracts it in-place. This avoids the\n   * webdriver `RangeError` on large base64 payloads and is significantly\n   * faster than per-file `browser.pushFile()` calls.\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 buffers (unused \u2014 adb pushes the directory directly).\n   */\n  public async pushFiles(vaultPath: string, _files: Record<string, Uint8Array>): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n    const archiveName = `vault-${randomUUID()}.tar.gz`;\n    const localArchive = join(tmpdir(), archiveName);\n    const remoteArchive = `/data/local/tmp/${archiveName}`;\n\n    try {\n      log(`[appium-transport] Creating archive: ${localArchive}`);\n      await exec(['tar', 'czf', archiveName, '-C', vaultPath, '.'], { cwd: tmpdir(), isQuiet: true });\n\n      log(`[appium-transport] Pushing archive to device ${this.deviceId}...`);\n      await exec(['adb', '-s', this.deviceId, 'push', localArchive, remoteArchive], { isQuiet: true });\n\n      log(`[appium-transport] Extracting archive on device at ${deviceVaultPath}...`);\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', deviceVaultPath], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'shell', 'tar', 'xzf', remoteArchive, '-C', deviceVaultPath], { isQuiet: true });\n\n      log('[appium-transport] Flushing filesystem buffers...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'sync'], { isQuiet: true });\n\n      log('[appium-transport] Cleaning up remote archive...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'rm', remoteArchive], { isQuiet: true });\n    } finally {\n      await rm(localArchive, { force: true });\n    }\n  }\n\n  /**\n   * Dumps `adb logcat` and returns the WebView console/error output logged\n   * since the marker from {@link AppiumTransport.beginConsoleCapture}.\n   *\n   * Filters to the Chromium/WebView tags that carry JS `console.*` output and\n   * uncaught errors, and caps the result length. Bounded, post-hoc,\n   * failure-path-only \u2014 never a live monitor.\n   *\n   * @param handle - The capture handle (or `undefined` when capture never started).\n   * @returns The captured console/error text, or `undefined` if nothing relevant was logged.\n   */\n  public async readConsoleCaptureSince(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined> {\n    if (!handle) {\n      return undefined;\n    }\n\n    const dump = await exec(\n      ['adb', '-s', this.deviceId, 'logcat', '-d', '-v', 'time'],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS }\n    );\n\n    const markerIndex = dump.lastIndexOf(handle.marker);\n    const region = markerIndex === -1 ? dump : dump.slice(markerIndex + handle.marker.length);\n    const relevant = region\n      .split('\\n')\n      .filter((line) => CONSOLE_CAPTURE_TAG_RE.test(line))\n      .join('\\n')\n      .trim();\n\n    if (!relevant) {\n      return undefined;\n    }\n\n    return relevant.slice(-CONSOLE_CAPTURE_TAIL_MAX_LENGTH);\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\n   * overwrite) \u2014 except the **harness's own** `temp-vault-*` registrations from\n   * earlier runs, which are pruned when {@link AppiumTransportConfig.shouldSweepLeftovers}\n   * is on. Their directories are already gone (the factory sweeps them before\n   * the app launches), and it is this registry \u2014 not the filesystem \u2014 that\n   * Obsidian enumerates at startup, so leaving them is what makes each failed\n   * run slow the next one down.\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[appium-transport] Registering vault: ${vaultPath}`);\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    // Push a minimal .obsidian directory so Obsidian recognizes it as a vault.\n    await this.pushObsidianMarker(deviceVaultPath);\n\n    // Switch to WebView and configure localStorage.\n    await this.ensureWebViewContext();\n\n    // Invalidate before reload \u2014 the page will navigate and the WebView\n    // Context may be temporarily unavailable during reload.\n    this.isInWebViewContext = false;\n\n    const stalePrefix = this.shouldSweepLeftovers ? `${this.vaultBasePath}${TEMP_VAULT_DIR_PREFIX}` : '';\n\n    await this.browser.execute(\n      (path: string, prunePrefix: string) => {\n        let existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n\n        if (prunePrefix) {\n          const stale = existing.filter((registered) => registered !== path && registered.startsWith(prunePrefix));\n          for (const registered of stale) {\n            localStorage.removeItem(`enable-plugin-${registered}`);\n          }\n          existing = existing.filter((registered) => !stale.includes(registered));\n        }\n\n        if (!existing.includes(path)) {\n          existing.push(path);\n        }\n        localStorage.setItem('mobile-external-vaults', JSON.stringify(existing));\n        localStorage.setItem('mobile-selected-vault', path);\n        localStorage.setItem(`enable-plugin-${path}`, 'true');\n        location.reload();\n      },\n      deviceVaultPath,\n      stalePrefix\n    );\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   * The vault's **files are then removed from the device over `adb`, whether or\n   * not the `localStorage` step succeeded** \u2014 deliberately, because the\n   * `localStorage` step goes through the WebView and a dead WebView is exactly\n   * what most Android failures are. Routing the removal through the app was what\n   * made every failed run leak its vault (`Vault cleanup error (non-fatal): no\n   * such window`), so the filesystem-level removal must not depend on it.\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    try {\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    } catch (error: unknown) {\n      log(\n        `[appium-transport] Could not deregister ${deviceVaultPath} from localStorage `\n          + `(${String(error)}); removing its files anyway.`\n      );\n    }\n\n    await this.removeDeviceVaultDir(deviceVaultPath);\n  }\n\n  /**\n   * Switches the driver to the `WEBVIEW_md.obsidian` context.\n   *\n   * If the context was already verified (cached via {@link isInWebViewContext}),\n   * returns immediately without calling `getContexts()` \u2014 which runs\n   * `adb shell cat /proc/net/unix` and can time out on slow emulators.\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    if (this.isInWebViewContext) {\n      return;\n    }\n\n    const deadline = Date.now() + this.webviewTimeoutInMilliseconds;\n    log(`[appium-transport] Waiting for ${WEBVIEW_CONTEXT_PREFIX} context (timeout=${String(this.webviewTimeoutInMilliseconds)}ms)...`);\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        log(`[appium-transport] Found WebView context: ${obsidianContext}`);\n        try {\n          await this.browser.switchContext(obsidianContext);\n          this.isInWebViewContext = true;\n          return;\n        } catch (error: unknown) {\n          log(`[appium-transport] switchContext failed: ${String(error)}. Resetting to NATIVE_APP before retrying...`);\n          try {\n            await this.browser.switchContext('NATIVE_APP');\n          } catch (resetError: unknown) {\n            log(`[appium-transport] NATIVE_APP reset also failed: ${String(resetError)}`);\n          }\n        }\n      }\n\n      log(`[appium-transport] WebView not ready, available contexts: ${JSON.stringify(contexts)}. Retrying...`);\n      await delay(WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`No ${WEBVIEW_CONTEXT_PREFIX} context found within ${String(this.webviewTimeoutInMilliseconds)}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   * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.\n   *\n   * `browser.pushFile` (WebDriver base64) is an order of magnitude slower on a\n   * cold or loaded emulator \u2014 measured at 9\u201321s per call for this 2-byte marker,\n   * versus sub-second over `adb`. This mirrors {@link pushFiles}, which switched\n   * to `adb` for the same reason. `mkdir -p` guarantees the parent directory.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async pushObsidianMarker(deviceVaultPath: string): Promise<void> {\n    const localMarker = join(tmpdir(), `obsidian-marker-${randomUUID()}.json`);\n    const remoteMarker = `${deviceVaultPath}/.obsidian/app.json`;\n\n    try {\n      await writeFile(localMarker, '{}', 'utf-8');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', `${deviceVaultPath}/.obsidian`], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'push', localMarker, remoteMarker], { isQuiet: true });\n    } finally {\n      await rm(localMarker, { force: true });\n    }\n  }\n\n  /**\n   * Removes a vault directory from the device over `adb`, and CHECKS that it is\n   * actually gone.\n   *\n   * Best-effort: a failure is logged, not thrown, so a teardown problem never\n   * masks the test result. The next run's start-of-run sweep picks up whatever\n   * this could not remove.\n   *\n   * The check is the point. `rm -rf` runs with `shouldIgnoreExitCode`, so an\n   * unremoved directory used to leave no trace at all \u2014 which is how runs that\n   * passed end to end were still found to be leaking a vault apiece, invisibly,\n   * until someone counted the directories on the device by hand. A leak is now\n   * named in the log at the moment it happens.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async removeDeviceVaultDir(deviceVaultPath: string): Promise<void> {\n    try {\n      log(`[appium-transport] Removing vault directory from device: ${deviceVaultPath}`);\n      await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'rm', '-rf', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      const listing = await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'ls', '-d', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      if (listing.includes(deviceVaultPath)) {\n        log(\n          `[appium-transport] Warning: ${deviceVaultPath} survived removal and is now leaked residue. `\n            + 'The next run\\'s start-of-run sweep will retry it.'\n        );\n      }\n    } catch (error: unknown) {\n      log(`[appium-transport] Vault directory removal failed (non-fatal): ${String(error)}`);\n    }\n  }\n\n  /**\n   * Polls until `app.workspace.layoutReady` is `true` in the WebView.\n   */\n  private async waitForLayoutReady(): Promise<void> {\n    const start = Date.now();\n    const deadline = start + this.layoutReadyTimeoutInMilliseconds;\n    log(`[appium-transport] Waiting for layout ready (timeout=${String(this.layoutReadyTimeoutInMilliseconds)}ms)...`);\n\n    while (Date.now() < deadline) {\n      try {\n        const isReady = await this.browser.execute((): boolean => {\n          // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n          const app = window.app as LoadingApp | undefined;\n          return !!app?.workspace?.layoutReady;\n        });\n        if (isReady) {\n          log(`[appium-transport] Layout is ready after ${String(Date.now() - start)}ms.`);\n          this.isInWebViewContext = true;\n          return;\n        }\n      } catch {\n        // App not ready yet (page may be reloading).\n      }\n\n      log(`[appium-transport] Layout not ready yet (elapsed=${String(Date.now() - start)}ms). Retrying...`);\n      await delay(LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`Obsidian layout did not become ready within ${String(this.layoutReadyTimeoutInMilliseconds)}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": []
}

+//# 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 *     avdName: 'obsidian_test',\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 { randomUUID } from 'node:crypto';\nimport {\n  rm,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\n\nimport type { CaptureScreenshotParams } from './capture-screenshot.cjs';\nimport type {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport {\n  decodeBase64Png,\n  isPng\n} from './capture-screenshot.cjs';\nimport { exec } from './exec.cjs';\nimport { TEMP_VAULT_DIR_PREFIX } from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\n\n/**\n * Session connection info returned by {@link AppiumTransport.getSessionInfo},\n * used to reattach from another process.\n */\nexport interface AppiumSessionInfo {\n  /**\n  The device UDID (e.g. `'emulator-5554'`).\n   */\n  deviceId: string;\n\n  /**\n  The Appium/WebDriver session ID.\n   */\n  sessionId: string;\n}\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   * The device UDID (e.g. `'emulator-5554'`).\n   * Used for `adb` commands when pushing files to the device.\n   */\n  deviceId: string;\n\n  /**\n   * Whether this transport owns the Appium session and should delete it on\n   * {@link AppiumTransport.dispose}.\n   *\n   * `true` for sessions created via `remote()` (global setup).\n   * `false` for sessions reattached via `attach()` (test workers).\n   *\n   * @default `true`\n   */\n  isSessionOwner?: boolean;\n\n  /**\n   * Timeout in milliseconds for waiting for `app.workspace.layoutReady` after\n   * the vault is (re)opened.\n   *\n   * @default `90000`\n   */\n  layoutReadyTimeoutInMilliseconds?: number;\n\n  /**\n   * Target platform. Determines WebView context naming and device file paths.\n   */\n  platform: 'android' | 'ios';\n\n  /**\n   * Whether registering a vault also prunes the **other** `temp-vault-*`\n   * registrations earlier runs left in Obsidian Mobile's `localStorage`.\n   *\n   * The device-side directories are swept before the app launches (see the\n   * factory); this removes their now-dangling registry entries, which are what\n   * Obsidian actually enumerates at startup. Unregistering this run's own vault\n   * is unaffected \u2014 that always happens.\n   *\n   * @default `true`\n   */\n  shouldSweepLeftovers?: boolean;\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  /**\n   * Timeout in milliseconds for waiting for the WebView context to become available.\n   *\n   * @default `60000`\n   */\n  webviewTimeoutInMilliseconds?: number;\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 DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS = 60_000;\nconst LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 90_000;\nconst APP_RESTART_DELAY_IN_MILLISECONDS = 2000;\nconst DEFAULT_APP_ID = 'md.obsidian';\nconst ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS = 30_000;\n\n// --- Console capture (Layer 2 of the plugin-load error surfacing, see T88) ---\nconst CONSOLE_CAPTURE_MARKER_TAG = 'OIT_CAPTURE';\nconst CONSOLE_CAPTURE_TAIL_MAX_LENGTH = 8000;\nconst ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS = 5000;\nconst LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS = 10_000;\n/**\n * `adb logcat -v time` lines look like `MM-DD HH:MM:SS.mmm LEVEL/TAG( PID): message`.\n * Keep only the tags Chromium/WebView routes JS `console.*` output and uncaught\n * errors to (`chromium`, the Capacitor console bridge, and native `AndroidRuntime`).\n */\nconst CONSOLE_CAPTURE_TAG_RE = /\\/(?:chromium|AndroidRuntime|Capacitor\\/Console)\\(/;\n\n/**\n * Base path on an Android device where Obsidian Mobile stores its vaults.\n *\n * Exported because the transport factory sweeps leftover vaults from it before\n * a transport exists (see the repo's L31).\n */\nexport const DEFAULT_ANDROID_VAULT_BASE_PATH = '/sdcard/Documents/';\n\nconst DEFAULT_VAULT_BASE_PATH: Record<string, string> = {\n  android: DEFAULT_ANDROID_VAULT_BASE_PATH,\n  ios: '@md.obsidian:documents/'\n};\n\ninterface LoadingApp {\n  workspace?: LoadingWorkspace;\n}\n\ninterface LoadingWorkspace {\n  layoutReady?: boolean;\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   * Indicates whether this transport is for a mobile platform. Always `true` for this transport.\n   */\n  public readonly isMobile = true;\n  private readonly appId: string;\n  private readonly browser: Browser;\n  private readonly deviceId: string;\n  /**\n   * Tracks whether the driver is currently switched to the WebView context.\n   *\n   * Set to `true` after a successful `switchContext(WEBVIEW_md.obsidian)`.\n   * Reset to `false` when the context is known to be invalidated\n   * (e.g. after `location.reload()` in {@link registerVault}).\n   *\n   * When `true`, {@link ensureWebViewContext} skips the expensive\n   * `getContexts()` call (which runs `adb shell cat /proc/net/unix` and\n   * can time out on slow emulators).\n   */\n  private isInWebViewContext = false;\n  private readonly isSessionOwner: boolean;\n  private readonly layoutReadyTimeoutInMilliseconds: number;\n  private readonly platform: 'android' | 'ios';\n  private readonly shouldSweepLeftovers: boolean;\n  private readonly vaultBasePath: string;\n\n  private readonly webviewTimeoutInMilliseconds: number;\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.deviceId = config.deviceId;\n    this.isSessionOwner = config.isSessionOwner ?? true;\n    this.layoutReadyTimeoutInMilliseconds = config.layoutReadyTimeoutInMilliseconds ?? DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS;\n    this.platform = config.platform;\n    this.appId = config.appId ?? DEFAULT_APP_ID;\n    this.shouldSweepLeftovers = config.shouldSweepLeftovers ?? true;\n    this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? DEFAULT_ANDROID_VAULT_BASE_PATH;\n    this.webviewTimeoutInMilliseconds = config.webviewTimeoutInMilliseconds ?? DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;\n  }\n\n  /**\n   * Begins a console capture by stamping the device log with a unique marker.\n   *\n   * Uses `adb shell log` to write a marker into `logcat` at capture start so a\n   * later {@link AppiumTransport.readConsoleCaptureSince} can slice out\n   * everything the WebView logged afterwards \u2014 without the invasive `logcat -c`\n   * buffer clear.\n   *\n   * @returns A handle carrying the unique marker.\n   */\n  public async beginConsoleCapture(): Promise<ConsoleCaptureHandle> {\n    const marker = `${CONSOLE_CAPTURE_MARKER_TAG}_${randomUUID()}`;\n    await exec(\n      ['adb', '-s', this.deviceId, 'shell', 'log', '-t', CONSOLE_CAPTURE_MARKER_TAG, marker],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS }\n    );\n    return { marker };\n  }\n\n  /**\n   * Captures a PNG screenshot of the device's screen.\n   *\n   * The image is always the device's native framebuffer \u2014 there is no mobile\n   * equivalent of the desktop viewport override, so\n   * {@link CaptureScreenshotParams.widthInPixels} /\n   * {@link CaptureScreenshotParams.heightInPixels} are ignored. Size a mobile\n   * capture by choosing an AVD whose screen geometry already matches what the\n   * image has to be.\n   *\n   * @param _params - Capture parameters. Ignored on mobile: `cwd` does not select a window (vault targeting is via localStorage), and the size cannot be overridden.\n   * @returns The raw PNG bytes.\n   * @throws Error if the driver returns data that is not a PNG.\n   */\n  public async captureScreenshot(_params: CaptureScreenshotParams): Promise<Uint8Array> {\n    const bytes = decodeBase64Png(await this.browser.takeScreenshot());\n    if (!isPng(bytes)) {\n      throw new Error('Appium screenshot error: takeScreenshot returned data that is not a PNG.');\n    }\n\n    return bytes;\n  }\n\n  /**\n   * Ends the Appium session.\n   *\n   * Only deletes the session if this transport owns it. Transports created\n   * via `attach()` (test workers reusing the global setup's session) skip\n   * deletion so the session remains available for the owning process.\n   */\n  public async dispose(): Promise<void> {\n    if (this.isSessionOwner) {\n      await this.browser.deleteSession();\n    }\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    try {\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    } catch (error: unknown) {\n      // Context may have been lost mid-execution (e.g. page reload).\n      this.isInWebViewContext = false;\n      throw error;\n    }\n  }\n\n  /**\n   * Returns the session connection info needed to reattach to this session\n   * from another process (e.g. a test worker).\n   *\n   * @returns The session ID and device ID.\n   */\n  public getSessionInfo(): AppiumSessionInfo {\n    return {\n      deviceId: this.deviceId,\n      sessionId: this.browser.sessionId\n    };\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    log('[appium-transport] Running preflight check...');\n    const state = await this.browser.queryAppState(this.appId);\n    log(`[appium-transport] App state: ${String(state)} (need ${String(APP_STATE_FOREGROUND)}=foreground)`);\n    if (state !== APP_STATE_FOREGROUND) {\n      log(`[appium-transport] Activating app ${this.appId}...`);\n      this.isInWebViewContext = false;\n      await this.browser.activateApp(this.appId);\n      await delay(APP_RESTART_DELAY_IN_MILLISECONDS);\n    }\n\n    await this.ensureWebViewContext();\n    log('[appium-transport] Preflight check passed.');\n  }\n\n  /**\n   * Pushes vault files to the device via compressed `adb push`.\n   *\n   * Creates a tar.gz archive of the local vault directory, pushes it to the\n   * device as a single file, and extracts it in-place. This avoids the\n   * webdriver `RangeError` on large base64 payloads and is significantly\n   * faster than per-file `browser.pushFile()` calls.\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 buffers (unused \u2014 adb pushes the directory directly).\n   */\n  public async pushFiles(vaultPath: string, _files: Record<string, Uint8Array>): Promise<void> {\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n    const archiveName = `vault-${randomUUID()}.tar.gz`;\n    const localArchive = join(tmpdir(), archiveName);\n    const remoteArchive = `/data/local/tmp/${archiveName}`;\n\n    try {\n      log(`[appium-transport] Creating archive: ${localArchive}`);\n      await exec(['tar', 'czf', archiveName, '-C', vaultPath, '.'], { cwd: tmpdir(), isQuiet: true });\n\n      log(`[appium-transport] Pushing archive to device ${this.deviceId}...`);\n      await exec(['adb', '-s', this.deviceId, 'push', localArchive, remoteArchive], { isQuiet: true });\n\n      log(`[appium-transport] Extracting archive on device at ${deviceVaultPath}...`);\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', deviceVaultPath], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'shell', 'tar', 'xzf', remoteArchive, '-C', deviceVaultPath], { isQuiet: true });\n\n      log('[appium-transport] Flushing filesystem buffers...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'sync'], { isQuiet: true });\n\n      log('[appium-transport] Cleaning up remote archive...');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'rm', remoteArchive], { isQuiet: true });\n    } finally {\n      await rm(localArchive, { force: true });\n    }\n  }\n\n  /**\n   * Dumps `adb logcat` and returns the WebView console/error output logged\n   * since the marker from {@link AppiumTransport.beginConsoleCapture}.\n   *\n   * Filters to the Chromium/WebView tags that carry JS `console.*` output and\n   * uncaught errors, and caps the result length. Bounded, post-hoc,\n   * failure-path-only \u2014 never a live monitor.\n   *\n   * @param handle - The capture handle (or `undefined` when capture never started).\n   * @returns The captured console/error text, or `undefined` if nothing relevant was logged.\n   */\n  public async readConsoleCaptureSince(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined> {\n    if (!handle) {\n      return undefined;\n    }\n\n    const dump = await exec(\n      ['adb', '-s', this.deviceId, 'logcat', '-d', '-v', 'time'],\n      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS }\n    );\n\n    const markerIndex = dump.lastIndexOf(handle.marker);\n    const region = markerIndex === -1 ? dump : dump.slice(markerIndex + handle.marker.length);\n    const relevant = region\n      .split('\\n')\n      .filter((line) => CONSOLE_CAPTURE_TAG_RE.test(line))\n      .join('\\n')\n      .trim();\n\n    if (!relevant) {\n      return undefined;\n    }\n\n    return relevant.slice(-CONSOLE_CAPTURE_TAIL_MAX_LENGTH);\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\n   * overwrite) \u2014 except the **harness's own** `temp-vault-*` registrations from\n   * earlier runs, which are pruned when {@link AppiumTransportConfig.shouldSweepLeftovers}\n   * is on. Their directories are already gone (the factory sweeps them before\n   * the app launches), and it is this registry \u2014 not the filesystem \u2014 that\n   * Obsidian enumerates at startup, so leaving them is what makes each failed\n   * run slow the next one down.\n   *\n   * @param vaultPath - The absolute path to the vault on the host machine.\n   */\n  public async registerVault(vaultPath: string): Promise<void> {\n    log(`[appium-transport] Registering vault: ${vaultPath}`);\n    const deviceVaultPath = this.getDeviceVaultPath(vaultPath);\n\n    // Push a minimal .obsidian directory so Obsidian recognizes it as a vault.\n    await this.pushObsidianMarker(deviceVaultPath);\n\n    // Switch to WebView and configure localStorage.\n    await this.ensureWebViewContext();\n\n    // Invalidate before reload \u2014 the page will navigate and the WebView\n    // Context may be temporarily unavailable during reload.\n    this.isInWebViewContext = false;\n\n    const stalePrefix = this.shouldSweepLeftovers ? `${this.vaultBasePath}${TEMP_VAULT_DIR_PREFIX}` : '';\n\n    await this.browser.execute(\n      (path: string, prunePrefix: string) => {\n        let existing = JSON.parse(localStorage.getItem('mobile-external-vaults') ?? '[]') as string[];\n\n        if (prunePrefix) {\n          const stale = existing.filter((registered) => registered !== path && registered.startsWith(prunePrefix));\n          for (const registered of stale) {\n            localStorage.removeItem(`enable-plugin-${registered}`);\n          }\n          existing = existing.filter((registered) => !stale.includes(registered));\n        }\n\n        if (!existing.includes(path)) {\n          existing.push(path);\n        }\n        localStorage.setItem('mobile-external-vaults', JSON.stringify(existing));\n        localStorage.setItem('mobile-selected-vault', path);\n        localStorage.setItem(`enable-plugin-${path}`, 'true');\n        location.reload();\n      },\n      deviceVaultPath,\n      stalePrefix\n    );\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   * The vault's **files are then removed from the device over `adb`, whether or\n   * not the `localStorage` step succeeded** \u2014 deliberately, because the\n   * `localStorage` step goes through the WebView and a dead WebView is exactly\n   * what most Android failures are. Routing the removal through the app was what\n   * made every failed run leak its vault (`Vault cleanup error (non-fatal): no\n   * such window`), so the filesystem-level removal must not depend on it.\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    try {\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    } catch (error: unknown) {\n      log(\n        `[appium-transport] Could not deregister ${deviceVaultPath} from localStorage `\n          + `(${String(error)}); removing its files anyway.`\n      );\n    }\n\n    await this.removeDeviceVaultDirectory(deviceVaultPath);\n  }\n\n  /**\n   * Switches the driver to the `WEBVIEW_md.obsidian` context.\n   *\n   * If the context was already verified (cached via {@link isInWebViewContext}),\n   * returns immediately without calling `getContexts()` \u2014 which runs\n   * `adb shell cat /proc/net/unix` and can time out on slow emulators.\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    if (this.isInWebViewContext) {\n      return;\n    }\n\n    const deadline = Date.now() + this.webviewTimeoutInMilliseconds;\n    log(`[appium-transport] Waiting for ${WEBVIEW_CONTEXT_PREFIX} context (timeout=${String(this.webviewTimeoutInMilliseconds)}ms)...`);\n\n    while (Date.now() < deadline) {\n      const contexts = await this.browser.getContexts();\n      const obsidianContext = contexts.find((context): context is string => typeof context === 'string' && context.startsWith(WEBVIEW_CONTEXT_PREFIX));\n\n      if (obsidianContext) {\n        log(`[appium-transport] Found WebView context: ${obsidianContext}`);\n        try {\n          await this.browser.switchContext(obsidianContext);\n          this.isInWebViewContext = true;\n          return;\n        } catch (error: unknown) {\n          log(`[appium-transport] switchContext failed: ${String(error)}. Resetting to NATIVE_APP before retrying...`);\n          try {\n            await this.browser.switchContext('NATIVE_APP');\n          } catch (resetError: unknown) {\n            log(`[appium-transport] NATIVE_APP reset also failed: ${String(resetError)}`);\n          }\n        }\n      }\n\n      log(`[appium-transport] WebView not ready, available contexts: ${JSON.stringify(contexts)}. Retrying...`);\n      await delay(WEBVIEW_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`No ${WEBVIEW_CONTEXT_PREFIX} context found within ${String(this.webviewTimeoutInMilliseconds)}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   * Pushes the minimal `.obsidian/app.json` vault marker via `adb push`.\n   *\n   * `browser.pushFile` (WebDriver base64) is an order of magnitude slower on a\n   * cold or loaded emulator \u2014 measured at 9\u201321s per call for this 2-byte marker,\n   * versus sub-second over `adb`. This mirrors {@link pushFiles}, which switched\n   * to `adb` for the same reason. `mkdir -p` guarantees the parent directory.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async pushObsidianMarker(deviceVaultPath: string): Promise<void> {\n    const localMarker = join(tmpdir(), `obsidian-marker-${randomUUID()}.json`);\n    const remoteMarker = `${deviceVaultPath}/.obsidian/app.json`;\n\n    try {\n      await writeFile(localMarker, '{}', 'utf-8');\n      await exec(['adb', '-s', this.deviceId, 'shell', 'mkdir', '-p', `${deviceVaultPath}/.obsidian`], { isQuiet: true });\n      await exec(['adb', '-s', this.deviceId, 'push', localMarker, remoteMarker], { isQuiet: true });\n    } finally {\n      await rm(localMarker, { force: true });\n    }\n  }\n\n  /**\n   * Removes a vault directory from the device over `adb`, and CHECKS that it is\n   * actually gone.\n   *\n   * Best-effort: a failure is logged, not thrown, so a teardown problem never\n   * masks the test result. The next run's start-of-run sweep picks up whatever\n   * this could not remove.\n   *\n   * The check is the point. `rm -rf` runs with `shouldIgnoreExitCode`, so an\n   * unremoved directory used to leave no trace at all \u2014 which is how runs that\n   * passed end to end were still found to be leaking a vault apiece, invisibly,\n   * until someone counted the directories on the device by hand. A leak is now\n   * named in the log at the moment it happens.\n   *\n   * @param deviceVaultPath - The device-side vault directory path.\n   */\n  private async removeDeviceVaultDirectory(deviceVaultPath: string): Promise<void> {\n    try {\n      log(`[appium-transport] Removing vault directory from device: ${deviceVaultPath}`);\n      await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'rm', '-rf', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      const listing = await exec(\n        ['adb', '-s', this.deviceId, 'shell', 'ls', '-d', deviceVaultPath],\n        { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_VAULT_REMOVE_TIMEOUT_IN_MILLISECONDS }\n      );\n\n      if (listing.includes(deviceVaultPath)) {\n        log(\n          `[appium-transport] Warning: ${deviceVaultPath} survived removal and is now leaked residue. `\n            + 'The next run\\'s start-of-run sweep will retry it.'\n        );\n      }\n    } catch (error: unknown) {\n      log(`[appium-transport] Vault directory removal failed (non-fatal): ${String(error)}`);\n    }\n  }\n\n  /**\n   * Polls until `app.workspace.layoutReady` is `true` in the WebView.\n   */\n  private async waitForLayoutReady(): Promise<void> {\n    const start = Date.now();\n    const deadline = start + this.layoutReadyTimeoutInMilliseconds;\n    log(`[appium-transport] Waiting for layout ready (timeout=${String(this.layoutReadyTimeoutInMilliseconds)}ms)...`);\n\n    while (Date.now() < deadline) {\n      try {\n        const isReady = await this.browser.execute((): boolean => {\n          // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n          const app = globalThis.app as LoadingApp | undefined;\n          return !!app?.workspace?.layoutReady;\n        });\n        if (isReady) {\n          log(`[appium-transport] Layout is ready after ${String(Date.now() - start)}ms.`);\n          this.isInWebViewContext = true;\n          return;\n        }\n      } catch {\n        // App not ready yet (page may be reloading).\n      }\n\n      log(`[appium-transport] Layout not ready yet (elapsed=${String(Date.now() - start)}ms). Retrying...`);\n      await delay(LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS);\n    }\n\n    throw new Error(`Obsidian layout did not become ready within ${String(this.layoutReadyTimeoutInMilliseconds)}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 lastSeparator = Math.max(normalized.lastIndexOf('/'), normalized.lastIndexOf('\\\\'));\n  return normalized.slice(lastSeparator + 1);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


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

@@ -38,15 +38,20 @@
  * This avoids the onboarding flow entirely.
  */
 import type { Browser } from 'webdriverio';
+import type { CaptureScreenshotParams } from './capture-screenshot.cjs';
 import type { ConsoleCaptureHandle, ObsidianTransport, TransportEvalOptions } from './transport.cjs';
 /**
  * Session connection info returned by {@link AppiumTransport.getSessionInfo},
  * used to reattach from another process.
  */
 export interface AppiumSessionInfo {
-    /** The device UDID (e.g. `'emulator-5554'`). */
+    /**
+    The device UDID (e.g. `'emulator-5554'`).
+     */
     deviceId: string;
-    /** The Appium/WebDriver session ID. */
+    /**
+    The Appium/WebDriver session ID.
+     */
     sessionId: string;
 }
 /**
@@ -173,6 +178,21 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @returns A handle carrying the unique marker.
      */
     beginConsoleCapture(): Promise<ConsoleCaptureHandle>;
+    /**
+     * Captures a PNG screenshot of the device's screen.
+     *
+     * The image is always the device's native framebuffer — there is no mobile
+     * equivalent of the desktop viewport override, so
+     * {@link CaptureScreenshotParams.widthInPixels} /
+     * {@link CaptureScreenshotParams.heightInPixels} are ignored. Size a mobile
+     * capture by choosing an AVD whose screen geometry already matches what the
+     * image has to be.
+     *
+     * @param _params - Capture parameters. Ignored on mobile: `cwd` does not select a window (vault targeting is via localStorage), and the size cannot be overridden.
+     * @returns The raw PNG bytes.
+     * @throws Error if the driver returns data that is not a PNG.
+     */
+    captureScreenshot(_params: CaptureScreenshotParams): Promise<Uint8Array>;
     /**
      * Ends the Appium session.
      *
@@ -313,7 +333,7 @@ export declare class AppiumTransport implements ObsidianTransport {
      *
      * @param deviceVaultPath - The device-side vault directory path.
      */
-    private removeDeviceVaultDir;
+    private removeDeviceVaultDirectory;
     /**
      * Polls until `app.workspace.layoutReady` is `true` in the WebView.
      */