obsidian-integration-testing 2.0.2 → 2.0.4

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

@@ -1,5 +1,10 @@
-import { spawn } from "node:child_process";
+import {
+  execFile,
+  spawn
+} from "node:child_process";
 import http from "node:http";
+import { join } from "node:path";
+import process from "node:process";
 import { remote } from "webdriverio";
 import { log } from "./log.mjs";
 import { AppiumTransport } from "./transport-appium.mjs";
@@ -7,13 +12,18 @@ import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
 import { DesktopCliTransport } from "./transport-desktop-cli.mjs";
 const APP_PACKAGE = "md.obsidian";
 const APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;
+const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5e3;
 const APPIUM_CONNECTION_RETRY_COUNT = 1;
-const APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 1e4;
+const APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 6e4;
 const APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5e3;
 const APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;
 const APPIUM_START_TIMEOUT_IN_MILLISECONDS = 6e4;
 const CDP_DEFAULT_PORT = 8315;
 const COMMAND_TIMEOUT_IN_MILLISECONDS = 300;
+const EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2e3;
+const EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 12e4;
+const KEYCODE_MENU = 82;
+const KEYCODE_WAKEUP = 224;
 const SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 3e4;
 let cachedTransport;
 async function createTransportFromOptions(options) {
@@ -64,6 +74,23 @@ function checkAppiumReachable(url) {
     });
   });
 }
+async function checkDeviceConnected(deviceId) {
+  const output = await new Promise((resolve, reject) => {
+    execFile("adb", ["devices"], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));
+        return;
+      }
+      if (stderr) {
+        log(`[transport-factory] ADB stderr: ${stderr.trim()}`);
+      }
+      resolve(stdout);
+    });
+  });
+  const lines = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const deviceLine = lines.find((line) => line.startsWith(deviceId));
+  return deviceLine?.includes("	device") ?? false;
+}
 async function createAppiumTransport(options) {
   const url = new URL(options.appiumUrl);
   const port = Number(url.port);
@@ -71,65 +98,139 @@ async function createAppiumTransport(options) {
     throw new Error(`Invalid port in appiumUrl: ${url.port}`);
   }
   const appId = options.appId ?? APP_PACKAGE;
-  log(`[transport-factory] Checking Appium server at ${options.appiumUrl}...`);
   let appiumProcess;
+  let emulatorProcess;
+  try {
+    [appiumProcess, emulatorProcess] = await startAppiumAndEmulator({
+      appiumUrl: url,
+      avdName: options.avdName,
+      deviceId: options.deviceId,
+      port,
+      shouldAutoStartAppium: options.shouldAutoStartAppium
+    });
+    log(`[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId})...`);
+    const browser = await remote({
+      capabilities: {
+        "appium:appActivity": APP_ACTIVITY,
+        "appium:appPackage": appId,
+        "appium:autoGrantPermissions": true,
+        "appium:automationName": "UiAutomator2",
+        "appium:newCommandTimeout": COMMAND_TIMEOUT_IN_MILLISECONDS,
+        "appium:noReset": true,
+        "appium:settings": {
+          "appium:chromedriverAutodownload": true
+        },
+        "appium:skipServerInstallation": true,
+        "appium:udid": options.deviceId,
+        "appium:uiautomator2ServerLaunchTimeout": SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,
+        "platformName": "Android"
+      },
+      connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,
+      connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
+      hostname: url.hostname,
+      path: url.pathname,
+      port
+    });
+    log("[transport-factory] Appium session established.");
+    const transport = new AppiumTransport({
+      appId,
+      browser,
+      platform: "android",
+      ...options.vaultBasePath !== void 0 && { vaultBasePath: options.vaultBasePath }
+    });
+    const originalDispose = transport.dispose.bind(transport);
+    transport.dispose = async () => {
+      await originalDispose();
+      if (appiumProcess) {
+        appiumProcess.kill();
+        log("[transport-factory] Auto-started Appium server stopped.");
+      }
+      if (emulatorProcess) {
+        emulatorProcess.kill();
+        log("[transport-factory] Auto-started emulator stopped.");
+      }
+    };
+    return transport;
+  } catch (error) {
+    if (appiumProcess) {
+      appiumProcess.kill();
+      log("[transport-factory] Killed auto-started Appium server after connection failure.");
+    }
+    if (emulatorProcess) {
+      emulatorProcess.kill();
+      log("[transport-factory] Killed auto-started emulator after connection failure.");
+    }
+    throw error;
+  }
+}
+async function ensureDeviceConnected(params) {
+  const { avdName, deviceId } = params;
+  log(`[transport-factory] Checking device ${deviceId} is connected via ADB...`);
+  if (await checkDeviceConnected(deviceId)) {
+    log(`[transport-factory] Device ${deviceId} is connected.`);
+    return void 0;
+  }
+  if (!avdName) {
+    throw new Error(
+      `Device "${deviceId}" is not connected. Start the emulator before running integration tests, or set avdName in transport options to auto-start it.`
+    );
+  }
+  log(`[transport-factory] Device ${deviceId} not found, starting emulator AVD "${avdName}"...`);
+  const emulatorProcess = startEmulator(avdName);
+  await waitForDevice(deviceId);
+  log(`[transport-factory] Emulator "${avdName}" started, device ${deviceId} is connected.`);
+  return emulatorProcess;
+}
+function resolveEmulatorBinary() {
+  const sdkRoot = process.env["ANDROID_HOME"] ?? process.env["ANDROID_SDK_ROOT"];
+  if (!sdkRoot) {
+    throw new Error(
+      "Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set."
+    );
+  }
+  return join(sdkRoot, "emulator", "emulator");
+}
+async function startAppiumAndEmulator(params) {
+  const { appiumUrl, avdName, deviceId, port, shouldAutoStartAppium } = params;
+  let needsAppiumStart = false;
+  log(`[transport-factory] Checking Appium server at ${appiumUrl.href}...`);
   try {
-    await checkAppiumReachable(url);
+    await checkAppiumReachable(appiumUrl);
     log("[transport-factory] Appium server is reachable.");
   } catch (error) {
-    if (options.shouldAutoStartAppium === false) {
+    if (shouldAutoStartAppium === false) {
       throw error;
     }
+    needsAppiumStart = true;
+  }
+  let appiumProcess;
+  if (needsAppiumStart) {
     log(`[transport-factory] Appium not reachable, auto-starting on port ${String(port)}...`);
     appiumProcess = startAppiumServer(port);
-    await waitForAppiumReady(url);
-    log("[transport-factory] Auto-started Appium server is ready.");
-  }
-  log(`[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId})...`);
-  const browser = await remote({
-    capabilities: {
-      "appium:appActivity": APP_ACTIVITY,
-      "appium:appPackage": appId,
-      "appium:autoGrantPermissions": true,
-      "appium:automationName": "UiAutomator2",
-      "appium:newCommandTimeout": COMMAND_TIMEOUT_IN_MILLISECONDS,
-      "appium:noReset": true,
-      "appium:settings": {
-        "appium:chromedriverAutodownload": true
-      },
-      "appium:skipServerInstallation": true,
-      "appium:udid": options.deviceId,
-      "appium:uiautomator2ServerLaunchTimeout": SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,
-      "platformName": "Android"
-    },
-    connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,
-    connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
-    hostname: url.hostname,
-    path: url.pathname,
-    port
-  });
-  log("[transport-factory] Appium session established.");
-  const transport = new AppiumTransport({
-    appId,
-    browser,
-    platform: "android",
-    ...options.vaultBasePath !== void 0 && { vaultBasePath: options.vaultBasePath }
-  });
-  if (appiumProcess) {
-    const originalDispose = transport.dispose.bind(transport);
-    transport.dispose = async () => {
-      await originalDispose();
-      appiumProcess.kill();
-      log("[transport-factory] Auto-started Appium server stopped.");
-    };
   }
-  return transport;
+  const [, emulatorProcess] = await Promise.all([
+    needsAppiumStart ? waitForAppiumReady(appiumUrl).then(() => {
+      log("[transport-factory] Auto-started Appium server is ready.");
+    }) : Promise.resolve(),
+    ensureDeviceConnected({ avdName, deviceId })
+  ]);
+  return [appiumProcess, emulatorProcess];
 }
 function startAppiumServer(port) {
   const child = spawn(`npx appium --log-timestamp --port ${String(port)}`, {
     detached: true,
     shell: true,
-    stdio: "inherit"
+    stdio: ["ignore", "inherit", "inherit"]
+  });
+  child.unref();
+  return child;
+}
+function startEmulator(avdName) {
+  const emulatorBinary = resolveEmulatorBinary();
+  log(`[transport-factory] Running: ${emulatorBinary} -avd ${avdName} -no-snapshot-save`);
+  const child = spawn(emulatorBinary, ["-avd", avdName, "-no-snapshot-save"], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"]
   });
   child.unref();
   return child;
@@ -150,8 +251,81 @@ async function waitForAppiumReady(url) {
     `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`
   );
 }
+async function waitForBoot(deviceId, deadline) {
+  while (Date.now() < deadline) {
+    const isBooted = await new Promise((resolve) => {
+      execFile(
+        "adb",
+        ["-s", deviceId, "shell", "getprop", "sys.boot_completed"],
+        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },
+        (_error, stdout) => {
+          resolve(stdout.trim() === "1");
+        }
+      );
+    });
+    if (isBooted) {
+      log(`[transport-factory] Device ${deviceId} boot completed.`);
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);
+    });
+  }
+  throw new Error(
+    `Device "${deviceId}" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`
+  );
+}
+async function waitForDevice(deviceId) {
+  const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;
+  while (Date.now() < deadline) {
+    if (await checkDeviceConnected(deviceId)) {
+      log(`[transport-factory] Device ${deviceId} appeared in ADB, waiting for boot to complete...`);
+      await waitForBoot(deviceId, deadline);
+      await wakeScreen(deviceId);
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);
+    });
+  }
+  throw new Error(
+    `Emulator device "${deviceId}" did not appear within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`
+  );
+}
+async function wakeScreen(deviceId) {
+  log(`[transport-factory] Waking screen on device ${deviceId}...`);
+  await new Promise((resolve, reject) => {
+    execFile(
+      "adb",
+      ["-s", deviceId, "shell", "input", "keyevent", String(KEYCODE_WAKEUP)],
+      { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },
+      (error) => {
+        if (error) {
+          reject(new Error(`Failed to wake screen: ${error instanceof Error ? error.message : "unknown error"}`));
+        } else {
+          resolve();
+        }
+      }
+    );
+  });
+  await new Promise((resolve, reject) => {
+    execFile(
+      "adb",
+      ["-s", deviceId, "shell", "input", "keyevent", String(KEYCODE_MENU)],
+      { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },
+      (error) => {
+        if (error) {
+          reject(new Error(`Failed to dismiss lock screen: ${error instanceof Error ? error.message : "unknown error"}`));
+        } else {
+          resolve();
+        }
+      }
+    );
+  });
+  log(`[transport-factory] Screen wake complete on device ${deviceId}.`);
+}
 export {
   createTransportFromOptions,
   getOrCreateTransport
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport http from 'node:http';\nimport { remote } from 'webdriverio';\n\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { log } from './log.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst APPIUM_CONNECTION_RETRY_COUNT = 1;\nconst APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 10000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_START_TIMEOUT_IN_MILLISECONDS = 60000;\nconst CDP_DEFAULT_PORT = 8315;\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 30000;\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (!options || options.type === 'obsidian-cli') {\n    log('[transport-factory] Creating DesktopCliTransport (no options or type=obsidian-cli)');\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    log(`[transport-factory] Creating DesktopCdpTransport (host=${options.host ?? 'localhost'}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      ...(options.port !== undefined && { cdpPort: options.port }),\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds })\n    });\n  }\n\n  log(`[transport-factory] Creating AppiumTransport (url=${options.appiumUrl}, device=${options.deviceId})`);\n  return createAppiumTransport(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Performs a quick HTTP check against the Appium server's status endpoint.\n *\n * Fails fast (within {@link APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS}) with\n * a clear error message instead of letting WebDriverIO retry silently for minutes.\n *\n * @param url - The parsed Appium URL.\n */\nfunction checkAppiumReachable(url: URL): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const statusUrl = new URL('/status', url);\n    const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n      res.resume();\n      resolve();\n    });\n    req.on('timeout', () => {\n      req.destroy();\n      reject(\n        new Error(\n          `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n        )\n      );\n    });\n    req.on('error', (err) => {\n      reject(\n        new Error(\n          `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n        )\n      );\n    });\n  });\n}\n\n/**\n * Creates an Appium transport by establishing a WebDriverIO session.\n *\n * @param options - Android Appium transport options.\n * @returns A configured Appium transport.\n */\nasync function createAppiumTransport(options: ObsidianAndroidAppiumTransportOptions): Promise<AppiumTransport> {\n  const url = new URL(options.appiumUrl);\n\n  const port = Number(url.port);\n  if (isNaN(port)) {\n    throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n  }\n\n  const appId = options.appId ?? APP_PACKAGE;\n\n  log(`[transport-factory] Checking Appium server at ${options.appiumUrl}...`);\n  let appiumProcess: ChildProcess | undefined;\n\n  try {\n    await checkAppiumReachable(url);\n    log('[transport-factory] Appium server is reachable.');\n  } catch (error: unknown) {\n    if (options.shouldAutoStartAppium === false) {\n      throw error;\n    }\n\n    log(`[transport-factory] Appium not reachable, auto-starting on port ${String(port)}...`);\n    appiumProcess = startAppiumServer(port);\n    await waitForAppiumReady(url);\n    log('[transport-factory] Auto-started Appium server is ready.');\n  }\n\n  log(`[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId})...`);\n  const browser = await remote({\n    capabilities: {\n      'appium:appActivity': APP_ACTIVITY,\n      'appium:appPackage': appId,\n      'appium:autoGrantPermissions': true,\n      'appium:automationName': 'UiAutomator2',\n      'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n      'appium:noReset': true,\n      'appium:settings': {\n        'appium:chromedriverAutodownload': true\n      },\n      'appium:skipServerInstallation': true,\n      'appium:udid': options.deviceId,\n      'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n      'platformName': 'Android'\n    },\n    connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n    connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,\n    hostname: url.hostname,\n    path: url.pathname,\n    port\n  });\n\n  log('[transport-factory] Appium session established.');\n  const transport = new AppiumTransport({\n    appId,\n    browser,\n    platform: 'android',\n    ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath })\n  });\n\n  if (appiumProcess) {\n    const originalDispose = transport.dispose.bind(transport);\n    transport.dispose = async (): Promise<void> => {\n      await originalDispose();\n      appiumProcess.kill();\n      log('[transport-factory] Auto-started Appium server stopped.');\n    };\n  }\n\n  return transport;\n}\n\n/**\n * Spawns an Appium server as a detached background process.\n *\n * @param port - The port to start Appium on.\n * @returns The spawned child process.\n */\nfunction startAppiumServer(port: number): ChildProcess {\n  const child = spawn(`npx appium --log-timestamp --port ${String(port)}`, {\n    detached: true,\n    shell: true,\n    stdio: 'inherit'\n  });\n\n  child.unref();\n  return child;\n}\n\n/**\n * Polls the Appium server until it responds to `/status`.\n *\n * @param url - The Appium server URL.\n */\nasync function waitForAppiumReady(url: URL): Promise<void> {\n  const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;\n\n  while (Date.now() < deadline) {\n    try {\n      await checkAppiumReachable(url);\n      return;\n    } catch {\n      await new Promise((resolve) => {\n        setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n  }\n\n  throw new Error(\n    `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`\n  );\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/transport-factory.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Factory for creating transport instances from {@link ObsidianTransportOptions}.\n */\n\n/* v8 ignore start -- Integration-time factory covered by integration tests, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport {\n  execFile,\n  spawn\n} from 'node:child_process';\nimport http from 'node:http';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { remote } from 'webdriverio';\n\nimport type {\n  ObsidianAndroidAppiumTransportOptions,\n  ObsidianTransportOptions\n} from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { log } from './log.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.mjs';\n\nconst APP_PACKAGE = 'md.obsidian';\nconst APP_ACTIVITY = `${APP_PACKAGE}.MainActivity`;\nconst ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_CONNECTION_RETRY_COUNT = 1;\nconst APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 60000;\nconst APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS = 5000;\nconst APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst APPIUM_START_TIMEOUT_IN_MILLISECONDS = 60000;\nconst CDP_DEFAULT_PORT = 8315;\nconst COMMAND_TIMEOUT_IN_MILLISECONDS = 300;\nconst EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS = 2000;\nconst EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS = 120000;\nconst KEYCODE_MENU = 82;\nconst KEYCODE_WAKEUP = 224;\nconst SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS = 30000;\n\n/**\n * Parameters for {@link ensureDeviceConnected}.\n */\ninterface EnsureDeviceConnectedParams {\n  /** AVD name to auto-start if the device is not connected. */\n  avdName?: string | undefined;\n\n  /** Device UDID to check (e.g. `'emulator-5554'`). */\n  deviceId: string;\n}\n\n/**\n * Parameters for {@link startAppiumAndEmulator}.\n */\ninterface StartAppiumAndEmulatorParams {\n  /** The Appium server URL. */\n  appiumUrl: URL;\n\n  /** AVD name to auto-start if the device is not connected. */\n  avdName?: string | undefined;\n\n  /** Device UDID. */\n  deviceId: string;\n\n  /** The Appium server port. */\n  port: number;\n\n  /** Whether Appium auto-start is allowed. */\n  shouldAutoStartAppium?: boolean | undefined;\n}\n\nlet cachedTransport: ObsidianTransport | undefined;\n\n/**\n * Creates a new transport instance from the given options.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns A new transport instance.\n */\nexport async function createTransportFromOptions(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (!options || options.type === 'obsidian-cli') {\n    log('[transport-factory] Creating DesktopCliTransport (no options or type=obsidian-cli)');\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    log(`[transport-factory] Creating DesktopCdpTransport (host=${options.host ?? 'localhost'}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);\n    return new DesktopCdpTransport({\n      ...(options.host !== undefined && { cdpHost: options.host }),\n      ...(options.port !== undefined && { cdpPort: options.port }),\n      ...(options.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds })\n    });\n  }\n\n  log(`[transport-factory] Creating AppiumTransport (url=${options.appiumUrl}, device=${options.deviceId})`);\n  return createAppiumTransport(options);\n}\n\n/**\n * Returns a cached transport instance, creating one from the given options\n * if not already cached.\n *\n * The transport is cached per worker process so WebSocket/Appium sessions\n * are reused across calls within the same test worker.\n *\n * @param options - Transport configuration. Defaults to CLI transport.\n * @returns The cached or newly created transport.\n */\nexport async function getOrCreateTransport(options?: ObsidianTransportOptions): Promise<ObsidianTransport> {\n  if (cachedTransport) {\n    return cachedTransport;\n  }\n\n  const result = await createTransportFromOptions(options);\n  // eslint-disable-next-line require-atomic-updates -- Single-threaded worker; no concurrent writes.\n  cachedTransport = result;\n  return result;\n}\n\n/**\n * Performs a quick HTTP check against the Appium server's status endpoint.\n *\n * Fails fast (within {@link APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS}) with\n * a clear error message instead of letting WebDriverIO retry silently for minutes.\n *\n * @param url - The parsed Appium URL.\n */\nfunction checkAppiumReachable(url: URL): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const statusUrl = new URL('/status', url);\n    const req = http.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {\n      res.resume();\n      resolve();\n    });\n    req.on('timeout', () => {\n      req.destroy();\n      reject(\n        new Error(\n          `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`\n        )\n      );\n    });\n    req.on('error', (err) => {\n      reject(\n        new Error(\n          `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`\n        )\n      );\n    });\n  });\n}\n\n/**\n * Checks whether the specified device is connected via ADB.\n *\n * @param deviceId - The device UDID to check (e.g. `'emulator-5554'`).\n * @returns `true` if the device is connected and in the `device` state.\n */\nasync function checkDeviceConnected(deviceId: string): Promise<boolean> {\n  const output = await new Promise<string>((resolve, reject) => {\n    execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n      if (error) {\n        reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n        return;\n      }\n      if (stderr) {\n        log(`[transport-factory] ADB stderr: ${stderr.trim()}`);\n      }\n      resolve(stdout);\n    });\n  });\n\n  const lines = output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);\n  const deviceLine = lines.find((line) => line.startsWith(deviceId));\n  return deviceLine?.includes('\\tdevice') ?? false;\n}\n\n/**\n * Creates an Appium transport by establishing a WebDriverIO session.\n *\n * @param options - Android Appium transport options.\n * @returns A configured Appium transport.\n */\nasync function createAppiumTransport(options: ObsidianAndroidAppiumTransportOptions): Promise<AppiumTransport> {\n  const url = new URL(options.appiumUrl);\n\n  const port = Number(url.port);\n  if (isNaN(port)) {\n    throw new Error(`Invalid port in appiumUrl: ${url.port}`);\n  }\n\n  const appId = options.appId ?? APP_PACKAGE;\n\n  let appiumProcess: ChildProcess | undefined;\n  let emulatorProcess: ChildProcess | undefined;\n\n  try {\n    [appiumProcess, emulatorProcess] = await startAppiumAndEmulator({\n      appiumUrl: url,\n      avdName: options.avdName,\n      deviceId: options.deviceId,\n      port,\n      shouldAutoStartAppium: options.shouldAutoStartAppium\n    });\n\n    log(`[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId})...`);\n    const browser = await remote({\n      capabilities: {\n        'appium:appActivity': APP_ACTIVITY,\n        'appium:appPackage': appId,\n        'appium:autoGrantPermissions': true,\n        'appium:automationName': 'UiAutomator2',\n        'appium:newCommandTimeout': COMMAND_TIMEOUT_IN_MILLISECONDS,\n        'appium:noReset': true,\n        'appium:settings': {\n          'appium:chromedriverAutodownload': true\n        },\n        'appium:skipServerInstallation': true,\n        'appium:udid': options.deviceId,\n        'appium:uiautomator2ServerLaunchTimeout': SERVER_LAUNCH_TIMEOUT_IN_MILLISECONDS,\n        'platformName': 'Android'\n      },\n      connectionRetryCount: APPIUM_CONNECTION_RETRY_COUNT,\n      connectionRetryTimeout: APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,\n      hostname: url.hostname,\n      path: url.pathname,\n      port\n    });\n\n    log('[transport-factory] Appium session established.');\n    const transport = new AppiumTransport({\n      appId,\n      browser,\n      platform: 'android',\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath })\n    });\n\n    const originalDispose = transport.dispose.bind(transport);\n    transport.dispose = async (): Promise<void> => {\n      await originalDispose();\n      if (appiumProcess) {\n        appiumProcess.kill();\n        log('[transport-factory] Auto-started Appium server stopped.');\n      }\n      if (emulatorProcess) {\n        emulatorProcess.kill();\n        log('[transport-factory] Auto-started emulator stopped.');\n      }\n    };\n\n    return transport;\n  } catch (error: unknown) {\n    if (appiumProcess) {\n      appiumProcess.kill();\n      log('[transport-factory] Killed auto-started Appium server after connection failure.');\n    }\n    if (emulatorProcess) {\n      emulatorProcess.kill();\n      log('[transport-factory] Killed auto-started emulator after connection failure.');\n    }\n    throw error;\n  }\n}\n\n/**\n * Ensures the specified device is connected, optionally auto-starting an\n * emulator if an AVD name is provided.\n *\n * @param params - Device and optional AVD configuration.\n * @param params.avdName - AVD name to auto-start if the device is not connected.\n * @param params.deviceId - Device UDID to check.\n * @returns The emulator child process if one was auto-started, or `undefined`.\n */\nasync function ensureDeviceConnected(params: EnsureDeviceConnectedParams): Promise<ChildProcess | undefined> {\n  const { avdName, deviceId } = params;\n  log(`[transport-factory] Checking device ${deviceId} is connected via ADB...`);\n\n  if (await checkDeviceConnected(deviceId)) {\n    log(`[transport-factory] Device ${deviceId} is connected.`);\n    return undefined;\n  }\n\n  if (!avdName) {\n    throw new Error(\n      `Device \"${deviceId}\" is not connected. Start the emulator before running integration tests,`\n        + ' or set avdName in transport options to auto-start it.'\n    );\n  }\n\n  log(`[transport-factory] Device ${deviceId} not found, starting emulator AVD \"${avdName}\"...`);\n  const emulatorProcess = startEmulator(avdName);\n  await waitForDevice(deviceId);\n  log(`[transport-factory] Emulator \"${avdName}\" started, device ${deviceId} is connected.`);\n  return emulatorProcess;\n}\n\n/**\n * Resolves the path to the Android emulator binary.\n *\n * Uses `ANDROID_HOME` or `ANDROID_SDK_ROOT` environment variable if set,\n * otherwise falls back to `emulator` (assumes it's in PATH).\n *\n * @returns The path to the emulator binary.\n */\nfunction resolveEmulatorBinary(): string {\n  const sdkRoot = process.env['ANDROID_HOME'] ?? process.env['ANDROID_SDK_ROOT'];\n  if (!sdkRoot) {\n    throw new Error(\n      'Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set.'\n    );\n  }\n  return join(sdkRoot, 'emulator', 'emulator');\n}\n\n/**\n * Starts the Appium server and emulator in parallel when both need auto-starting.\n *\n * @param params - Configuration for Appium and emulator startup.\n * @returns A tuple of `[appiumProcess, emulatorProcess]`, either of which may be `undefined`.\n */\nasync function startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<[ChildProcess | undefined, ChildProcess | undefined]> {\n  const { appiumUrl, avdName, deviceId, port, shouldAutoStartAppium } = params;\n\n  let needsAppiumStart = false;\n\n  log(`[transport-factory] Checking Appium server at ${appiumUrl.href}...`);\n  try {\n    await checkAppiumReachable(appiumUrl);\n    log('[transport-factory] Appium server is reachable.');\n  } catch (error: unknown) {\n    if (shouldAutoStartAppium === false) {\n      throw error;\n    }\n    needsAppiumStart = true;\n  }\n\n  let appiumProcess: ChildProcess | undefined;\n\n  if (needsAppiumStart) {\n    log(`[transport-factory] Appium not reachable, auto-starting on port ${String(port)}...`);\n    appiumProcess = startAppiumServer(port);\n  }\n\n  const [, emulatorProcess] = await Promise.all([\n    needsAppiumStart\n      ? waitForAppiumReady(appiumUrl).then(() => {\n        log('[transport-factory] Auto-started Appium server is ready.');\n      })\n      : Promise.resolve(),\n    ensureDeviceConnected({ avdName, deviceId })\n  ]);\n\n  return [appiumProcess, emulatorProcess];\n}\n\n/**\n * Spawns an Appium server as a detached background process.\n *\n * @param port - The port to start Appium on.\n * @returns The spawned child process.\n */\nfunction startAppiumServer(port: number): ChildProcess {\n  const child = spawn(`npx appium --log-timestamp --port ${String(port)}`, {\n    detached: true,\n    shell: true,\n    stdio: ['ignore', 'inherit', 'inherit']\n  });\n\n  child.unref();\n  return child;\n}\n\n/**\n * Spawns an Android emulator as a background process.\n *\n * @param avdName - The AVD name to start.\n * @returns The spawned child process.\n */\nfunction startEmulator(avdName: string): ChildProcess {\n  const emulatorBinary = resolveEmulatorBinary();\n  log(`[transport-factory] Running: ${emulatorBinary} -avd ${avdName} -no-snapshot-save`);\n  const child = spawn(emulatorBinary, ['-avd', avdName, '-no-snapshot-save'], {\n    detached: true,\n    stdio: ['ignore', 'ignore', 'ignore']\n  });\n\n  child.unref();\n  return child;\n}\n\n/**\n * Polls the Appium server until it responds to `/status`.\n *\n * @param url - The Appium server URL.\n */\nasync function waitForAppiumReady(url: URL): Promise<void> {\n  const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;\n\n  while (Date.now() < deadline) {\n    try {\n      await checkAppiumReachable(url);\n      return;\n    } catch {\n      await new Promise((resolve) => {\n        setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n  }\n\n  throw new Error(\n    `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`\n  );\n}\n\n/**\n * Waits for the device to finish booting by polling `sys.boot_completed`.\n *\n * @param deviceId - The device UDID.\n * @param deadline - Absolute timestamp deadline.\n */\nasync function waitForBoot(deviceId: string, deadline: number): Promise<void> {\n  while (Date.now() < deadline) {\n    const isBooted = await new Promise<boolean>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'getprop', 'sys.boot_completed'],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (_error, stdout) => {\n          resolve(stdout.trim() === '1');\n        }\n      );\n    });\n\n    if (isBooted) {\n      log(`[transport-factory] Device ${deviceId} boot completed.`);\n      return;\n    }\n\n    await new Promise((resolve) => {\n      setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n    });\n  }\n\n  throw new Error(\n    `Device \"${deviceId}\" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n  );\n}\n\n/**\n * Polls `adb devices` until the specified device appears in the `device` state.\n *\n * Also waits for the device to finish booting by checking `sys.boot_completed`.\n *\n * @param deviceId - The device UDID to wait for.\n */\nasync function waitForDevice(deviceId: string): Promise<void> {\n  const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n  while (Date.now() < deadline) {\n    if (await checkDeviceConnected(deviceId)) {\n      log(`[transport-factory] Device ${deviceId} appeared in ADB, waiting for boot to complete...`);\n      await waitForBoot(deviceId, deadline);\n      await wakeScreen(deviceId);\n      return;\n    }\n\n    await new Promise((resolve) => {\n      setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);\n    });\n  }\n\n  throw new Error(\n    `Emulator device \"${deviceId}\" did not appear within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`\n  );\n}\n\n/**\n * Wakes the emulator screen and dismisses the lock screen.\n *\n * After boot, the emulator screen may be off. Sends `KEYCODE_WAKEUP` to turn\n * on the display and `KEYCODE_MENU` to dismiss the lock screen.\n *\n * @param deviceId - The device UDID.\n */\nasync function wakeScreen(deviceId: string): Promise<void> {\n  log(`[transport-factory] Waking screen on device ${deviceId}...`);\n\n  await new Promise<void>((resolve, reject) => {\n    execFile(\n      'adb',\n      ['-s', deviceId, 'shell', 'input', 'keyevent', String(KEYCODE_WAKEUP)],\n      { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n      (error) => {\n        if (error) {\n          reject(new Error(`Failed to wake screen: ${error instanceof Error ? error.message : 'unknown error'}`));\n        } else {\n          resolve();\n        }\n      }\n    );\n  });\n\n  await new Promise<void>((resolve, reject) => {\n    execFile(\n      'adb',\n      ['-s', deviceId, 'shell', 'input', 'keyevent', String(KEYCODE_MENU)],\n      { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n      (error) => {\n        if (error) {\n          reject(new Error(`Failed to dismiss lock screen: ${error instanceof Error ? error.message : 'unknown error'}`));\n        } else {\n          resolve();\n        }\n      }\n    );\n  });\n\n  log(`[transport-factory] Screen wake complete on device ${deviceId}.`);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


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

@@ -17,6 +17,18 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * The Appium server URL (e.g. `'http://localhost:4723'`).
      */
     appiumUrl: string;
+    /**
+     * The Android AVD (Android Virtual Device) name to auto-start if
+     * the device specified by {@link deviceId} is not connected.
+     *
+     * When provided and the device is not found via `adb devices`, the
+     * transport factory launches `emulator -avd <avdName>` as a background
+     * process and polls until the device appears. The emulator is killed
+     * on transport disposal.
+     *
+     * Run `emulator -list-avds` to see available AVD names.
+     */
+    avdName?: string;
     /**
      * The device UDID (e.g. `'emulator-5554'`).
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",