obsidian-integration-testing 8.4.0 → 9.1.0

package/dist/lib/cjs/poll-in-obsidian.d.cts

@@ -0,0 +1,92 @@
+/**
+ * @file
+ *
+ * Node-side "kick off, then poll" helper over {@link evalInObsidian}.
+ *
+ * A single `evalInObsidian` closure cannot run longer than CDP's ~30s
+ * `Runtime.evaluate` cap, so a long-running in-Obsidian operation (e.g. a whole
+ * plugin/vault bootstrap) cannot be awaited inside one closure. This helper does
+ * it from Node instead: it optionally runs a short `start` closure once to kick
+ * the work off, then repeatedly runs a short `poll` closure — each a separate,
+ * well-under-30s eval — until the Node-side `until` predicate accepts a poll
+ * result, or a Node-side timeout elapses. It removes the per-test hand-rolled
+ * `evalInObsidian` + `sleep` loop.
+ *
+ * The timing loop lives in the pure, unit-tested {@link pollUntil}; this module is
+ * the integration-only wiring (it drives a live Obsidian), covered by an
+ * integration test.
+ */
+import type { Promisable } from 'type-fest';
+import type { ContextArgs } from './context-id.cjs';
+import type { CommonArgs, GenericObject } from './eval-in-obsidian.cjs';
+import type { ObsidianTransport } from './transport.cjs';
+import { ContextId } from './context-id.cjs';
+/**
+ * Parameters for {@link pollInObsidian}. Mirrors {@link EvalInObsidianParams} for
+ * the shared forwarded fields (`args` / `contextId` / `transport` / `vaultPath`);
+ * `start` / `poll` are the in-Obsidian closures and `until` is the Node-side
+ * acceptance predicate.
+ */
+export interface PollInObsidianParams<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined> {
+    /**
+     * Additional arguments passed to both `start` and `poll` (serialized like
+     * {@link EvalInObsidianParams.args}).
+     */
+    readonly args?: Args;
+    /**
+     * A {@link ContextId} shared by `start` and `poll`, so `start` can stash
+     * non-serializable state that `poll` later reads. When omitted, each closure
+     * gets a fresh empty `context`.
+     */
+    readonly contextId?: TContextId;
+    /**
+     * Delay between `poll` attempts, in milliseconds.
+     *
+     * @default `500`
+     */
+    readonly intervalInMilliseconds?: number;
+    /**
+     * The closure polled repeatedly inside Obsidian. Keep it short (well under the
+     * ~30s CDP cap): it should read and return a JSON-serializable status, not
+     * await the long operation itself.
+     */
+    poll(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<PollResult>;
+    /**
+     * An optional closure run **once** before polling begins, to kick off the
+     * long-running work (fire-and-forget from Node's perspective). Keep it short —
+     * start the work and return; do not await it to completion here.
+     */
+    start?(this: void, args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<unknown>;
+    /**
+     * Total budget before the poll rejects, in milliseconds.
+     *
+     * @default `120000`
+     */
+    readonly timeoutInMilliseconds?: number;
+    /**
+     * Optional detail appended to the timeout error message.
+     */
+    readonly timeoutMessage?: string;
+    /**
+     * Override the transport (forwarded to every underlying `evalInObsidian`).
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * Whether a given `poll` result is acceptable, evaluated in **Node**. Returning
+     * `true` resolves {@link pollInObsidian} with that result.
+     */
+    until(this: void, result: PollResult): boolean;
+    /**
+     * The vault path to evaluate against (forwarded to every underlying
+     * `evalInObsidian`).
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Kicks off an optional `start` closure once, then polls `poll` from Node until
+ * `until` accepts a result or the timeout elapses.
+ *
+ * @param params - The poll parameters.
+ * @returns A {@link Promise} that resolves with the first accepted `poll` result.
+ */
+export declare function pollInObsidian<Args extends GenericObject, PollResult, TContextId extends ContextId<unknown> | undefined = undefined>(params: PollInObsidianParams<Args, PollResult, TContextId>): Promise<PollResult>;

package/dist/lib/cjs/poll-until.cjs

@@ -0,0 +1,43 @@
+"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 poll_until_exports = {};
+__export(poll_until_exports, {
+  pollUntil: () => pollUntil
+});
+module.exports = __toCommonJS(poll_until_exports);
+async function pollUntil(params) {
+  const { attempt, intervalInMilliseconds, nowInMilliseconds, sleep, timeoutInMilliseconds, timeoutMessage, until } = params;
+  const deadline = nowInMilliseconds() + timeoutInMilliseconds;
+  while (true) {
+    const result = await attempt();
+    if (until(result)) {
+      return result;
+    }
+    if (nowInMilliseconds() >= deadline) {
+      const suffix = timeoutMessage === void 0 ? "" : `: ${timeoutMessage}`;
+      throw new Error(`pollInObsidian timed out after ${String(timeoutInMilliseconds)} milliseconds${suffix}`);
+    }
+    await sleep(intervalInMilliseconds);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pollUntil
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/poll-until.d.cts

@@ -0,0 +1,42 @@
+/**
+ * @file
+ *
+ * Pure poll-until-satisfied loop: repeatedly runs an async `attempt`, returning
+ * its result once `until` accepts it, or throwing when a timeout elapses.
+ *
+ * Extracted from the integration-only {@link pollInObsidian} wrapper (which binds
+ * `attempt` to an `evalInObsidian` call and is excluded from unit tests) so the
+ * timing/timeout logic stays unit-testable. The clock and sleep are injected so
+ * the loop is deterministic under test.
+ */
+/**
+ * Parameters for {@link pollUntil}.
+ */
+export interface PollUntilParams<Result> {
+    /** Runs one attempt and resolves with its result. */
+    attempt(this: void): Promise<Result>;
+    /** Delay between attempts, in milliseconds. */
+    readonly intervalInMilliseconds: number;
+    /** Returns the current time in milliseconds (injected for deterministic tests). */
+    nowInMilliseconds(this: void): number;
+    /** Sleeps for the given number of milliseconds (injected for deterministic tests). */
+    sleep(this: void, milliseconds: number): Promise<void>;
+    /** Total budget before the poll rejects, in milliseconds. */
+    readonly timeoutInMilliseconds: number;
+    /** Optional detail appended to the timeout error message. */
+    readonly timeoutMessage?: string;
+    /** Whether a given attempt result is acceptable (stops the poll). */
+    until(this: void, result: Result): boolean;
+}
+/**
+ * Runs `attempt` immediately, then repeatedly every `intervalInMilliseconds`,
+ * until `until(result)` is truthy — resolving with that result — or the
+ * `timeoutInMilliseconds` budget elapses, at which point it rejects. At least one
+ * attempt always runs; the timeout is checked after each unsatisfied attempt, so
+ * a slow single attempt cannot be interrupted mid-flight but no further attempt
+ * starts past the deadline.
+ *
+ * @param params - The poll parameters.
+ * @returns A {@link Promise} that resolves with the first accepted attempt result.
+ */
+export declare function pollUntil<Result>(params: PollUntilParams<Result>): Promise<Result>;

package/dist/lib/cjs/process-exit-message.cjs

@@ -0,0 +1,47 @@
+"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 process_exit_message_exports = {};
+__export(process_exit_message_exports, {
+  buildProcessExitMessage: () => buildProcessExitMessage
+});
+module.exports = __toCommonJS(process_exit_message_exports);
+function buildProcessExitMessage(params) {
+  const { exitInfo, output, outputLabel, subject } = params;
+  const reason = resolveReason(exitInfo);
+  const trimmedOutput = output.trim();
+  const details = trimmedOutput.length > 0 ? `
+
+${outputLabel} (tail):
+${trimmedOutput}` : "";
+  return `${subject} ${reason} during startup.${details}`;
+}
+function resolveReason(exitInfo) {
+  if (exitInfo.spawnError !== void 0) {
+    return `failed to start (${exitInfo.spawnError})`;
+  }
+  if (exitInfo.signal !== null) {
+    return `was terminated by signal ${exitInfo.signal}`;
+  }
+  return `exited prematurely with code ${exitInfo.code === null ? "(null)" : String(exitInfo.code)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildProcessExitMessage
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/process-exit-message.d.cts

@@ -0,0 +1,48 @@
+/**
+ * @file
+ *
+ * Pure builder for the diagnostic message describing an auto-started child
+ * process (the Android emulator or the Appium server) that died during startup,
+ * appending the captured output tail when available.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the message formatting stays unit-testable — the launchers
+ * themselves spawn real processes.
+ */
+/**
+ * Parameters for {@link buildProcessExitMessage}.
+ */
+export interface BuildProcessExitMessageParams {
+    /** The process's exit / spawn-failure details. */
+    readonly exitInfo: ProcessExitInfo;
+    /** The captured stdout+stderr tail (empty when none was captured). */
+    readonly output: string;
+    /** Label for the captured output section (e.g. `"Emulator output"`). */
+    readonly outputLabel: string;
+    /** Human-readable subject of the process (e.g. `"Android emulator"`). */
+    readonly subject: string;
+}
+/**
+ * Details of a spawned child process that has exited or failed to spawn.
+ *
+ * A normal exit sets `code`/`signal` (exactly one is non-`null`); a spawn
+ * failure (e.g. `ENOENT` for a missing binary) leaves both `null` and sets
+ * `spawnError` to the failure message.
+ */
+export interface ProcessExitInfo {
+    /** Exit code, or `null` when terminated by a signal or when it failed to spawn. */
+    readonly code: null | number;
+    /** Terminating signal, or `null` when it exited normally or failed to spawn. */
+    readonly signal: NodeJS.Signals | null;
+    /** The spawn-failure message when the process never started (e.g. `ENOENT`), otherwise absent. */
+    readonly spawnError?: string;
+}
+/**
+ * Builds a descriptive error message for an auto-started child process that
+ * exited (or failed to spawn) during startup, appending the captured output
+ * tail when available.
+ *
+ * @param params - The subject, exit details, and captured output.
+ * @returns A human-readable error message.
+ */
+export declare function buildProcessExitMessage(params: BuildProcessExitMessageParams): string;

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

@@ -36,6 +36,11 @@ const LAYOUT_READY_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const DEFAULT_LAYOUT_READY_POLL_TIMEOUT_IN_MILLISECONDS = 9e4;
 const APP_RESTART_DELAY_IN_MILLISECONDS = 2e3;
 const DEFAULT_APP_ID = "md.obsidian";
+const CONSOLE_CAPTURE_MARKER_TAG = "OIT_CAPTURE";
+const CONSOLE_CAPTURE_TAIL_MAX_LENGTH = 8e3;
+const ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS = 5e3;
+const LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS = 1e4;
+const CONSOLE_CAPTURE_TAG_RE = /\/(?:chromium|AndroidRuntime|Capacitor\/Console)\(/;
 const DEFAULT_VAULT_BASE_PATH = {
   android: "/sdcard/Documents/",
   ios: "@md.obsidian:documents/"
@@ -80,6 +85,24 @@ class AppiumTransport {
     this.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? "/sdcard/Documents/";
     this.webviewTimeoutInMilliseconds = config.webviewTimeoutInMilliseconds ?? DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;
   }
+  /**
+   * Begins a console capture by stamping the device log with a unique marker.
+   *
+   * Uses `adb shell log` to write a marker into `logcat` at capture start so a
+   * later {@link AppiumTransport.readConsoleCaptureSince} can slice out
+   * everything the WebView logged afterwards — without the invasive `logcat -c`
+   * buffer clear.
+   *
+   * @returns A handle carrying the unique marker.
+   */
+  async beginConsoleCapture() {
+    const marker = `${CONSOLE_CAPTURE_MARKER_TAG}_${(0, import_node_crypto.randomUUID)()}`;
+    await (0, import_exec.exec)(
+      ["adb", "-s", this.deviceId, "shell", "log", "-t", CONSOLE_CAPTURE_MARKER_TAG, marker],
+      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: ADB_LOG_MARKER_TIMEOUT_IN_MILLISECONDS }
+    );
+    return { marker };
+  }
   /**
    * Ends the Appium session.
    *
@@ -179,6 +202,33 @@ class AppiumTransport {
       await (0, import_promises.rm)(localArchive, { force: true });
     }
   }
+  /**
+   * Dumps `adb logcat` and returns the WebView console/error output logged
+   * since the marker from {@link AppiumTransport.beginConsoleCapture}.
+   *
+   * Filters to the Chromium/WebView tags that carry JS `console.*` output and
+   * uncaught errors, and caps the result length. Bounded, post-hoc,
+   * failure-path-only — never a live monitor.
+   *
+   * @param handle - The capture handle (or `undefined` when capture never started).
+   * @returns The captured console/error text, or `undefined` if nothing relevant was logged.
+   */
+  async readConsoleCaptureSince(handle) {
+    if (!handle) {
+      return void 0;
+    }
+    const dump = await (0, import_exec.exec)(
+      ["adb", "-s", this.deviceId, "logcat", "-d", "-v", "time"],
+      { isQuiet: true, shouldIgnoreExitCode: true, timeoutInMilliseconds: LOGCAT_DUMP_TIMEOUT_IN_MILLISECONDS }
+    );
+    const markerIndex = dump.lastIndexOf(handle.marker);
+    const region = markerIndex === -1 ? dump : dump.slice(markerIndex + handle.marker.length);
+    const relevant = region.split("\n").filter((line) => CONSOLE_CAPTURE_TAG_RE.test(line)).join("\n").trim();
+    if (!relevant) {
+      return void 0;
+    }
+    return relevant.slice(-CONSOLE_CAPTURE_TAIL_MAX_LENGTH);
+  }
   /**
    * Registers a vault on mobile by pushing files and configuring localStorage.
    *
@@ -350,4 +400,4 @@ function extractVaultName(vaultPath) {
 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 *     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  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.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   * 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';\n\nconst DEFAULT_VAULT_BASE_PATH: Record<string, string> = {\n  android: '/sdcard/Documents/',\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 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.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? '/sdcard/Documents/';\n    this.webviewTimeoutInMilliseconds = config.webviewTimeoutInMilliseconds ?? DEFAULT_WEBVIEW_POLL_TIMEOUT_IN_MILLISECONDS;\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   * 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    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    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   * 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   * 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 {\n  ConsoleCaptureHandle,\n  ObsidianTransport,\n  TransportEvalOptions\n} from './transport.cjs';\n\nimport { exec } from './exec.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   * 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';\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\nconst DEFAULT_VAULT_BASE_PATH: Record<string, string> = {\n  android: '/sdcard/Documents/',\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 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.vaultBasePath = config.vaultBasePath ?? DEFAULT_VAULT_BASE_PATH[this.platform] ?? '/sdcard/Documents/';\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 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    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    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   * 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   * 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": []
}


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

@@ -38,7 +38,7 @@
  * This avoids the onboarding flow entirely.
  */
 import type { Browser } from 'webdriverio';
-import type { ObsidianTransport, TransportEvalOptions } from './transport.cjs';
+import type { ConsoleCaptureHandle, ObsidianTransport, TransportEvalOptions } from './transport.cjs';
 /**
  * Session connection info returned by {@link AppiumTransport.getSessionInfo},
  * used to reattach from another process.
@@ -142,6 +142,17 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param config - Appium transport configuration.
      */
     constructor(config: AppiumTransportConfig);
+    /**
+     * Begins a console capture by stamping the device log with a unique marker.
+     *
+     * Uses `adb shell log` to write a marker into `logcat` at capture start so a
+     * later {@link AppiumTransport.readConsoleCaptureSince} can slice out
+     * everything the WebView logged afterwards — without the invasive `logcat -c`
+     * buffer clear.
+     *
+     * @returns A handle carrying the unique marker.
+     */
+    beginConsoleCapture(): Promise<ConsoleCaptureHandle>;
     /**
      * Ends the Appium session.
      *
@@ -186,6 +197,18 @@ export declare class AppiumTransport implements ObsidianTransport {
      * @param _files - Map of relative file paths to content buffers (unused — adb pushes the directory directly).
      */
     pushFiles(vaultPath: string, _files: Record<string, Uint8Array>): Promise<void>;
+    /**
+     * Dumps `adb logcat` and returns the WebView console/error output logged
+     * since the marker from {@link AppiumTransport.beginConsoleCapture}.
+     *
+     * Filters to the Chromium/WebView tags that carry JS `console.*` output and
+     * uncaught errors, and caps the result length. Bounded, post-hoc,
+     * failure-path-only — never a live monitor.
+     *
+     * @param handle - The capture handle (or `undefined` when capture never started).
+     * @returns The captured console/error text, or `undefined` if nothing relevant was logged.
+     */
+    readConsoleCaptureSince(handle: ConsoleCaptureHandle | undefined): Promise<string | undefined>;
     /**
      * Registers a vault on mobile by pushing files and configuring localStorage.
      *