obsidian-integration-testing 2.2.2 → 2.2.3

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

@@ -51,328 +51,361 @@ 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 DEFAULT_TRANSPORT_TYPE = "obsidian-cli";
 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) {
-  if (!options || options.type === "obsidian-cli") {
-    (0, import_log.log)("[transport-factory] Creating DesktopCliTransport (no options or type=obsidian-cli)");
-    return new import_transport_desktop_cli.DesktopCliTransport();
+class AppiumTransportFactory {
+  type;
+  constructor(type) {
+    this.type = type;
   }
-  if (options.type === "obsidian-cdp") {
-    (0, import_log.log)(`[transport-factory] Creating DesktopCdpTransport (host=${options.host ?? "localhost"}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);
-    return new import_transport_desktop_cdp.DesktopCdpTransport({
-      ...options.host !== void 0 && { cdpHost: options.host },
-      ...options.port !== void 0 && { cdpPort: options.port },
-      ...options.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }
-    });
+  /**
+   * Creates an Appium transport by establishing a WebDriverIO session.
+   *
+   * @param options - Android Appium transport options.
+   * @returns A configured Appium transport.
+   */
+  async create(options) {
+    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, device=${options.deviceId})`);
+    const url = new URL(options.appiumUrl);
+    const port = Number(url.port);
+    if (isNaN(port)) {
+      throw new Error(`Invalid port in appiumUrl: ${url.port}`);
+    }
+    const appId = options.appId ?? APP_PACKAGE;
+    let appiumProcess;
+    let emulatorProcess;
+    try {
+      let killAutoStartedProcesses2 = function() {
+        if (appiumProcess) {
+          killProcessTree(appiumProcess);
+          (0, import_log.log)(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);
+        }
+        if (emulatorProcess) {
+          killProcessTree(emulatorProcess);
+          (0, import_log.log)(`[transport-factory:${options.type}] Auto-started emulator stopped.`);
+        }
+      };
+      var killAutoStartedProcesses = killAutoStartedProcesses2;
+      [appiumProcess, emulatorProcess] = await this.startAppiumAndEmulator({
+        appiumUrl: url,
+        avdName: options.avdName,
+        deviceId: options.deviceId,
+        port,
+        shouldAutoStartAppium: options.shouldAutoStartAppium
+      });
+      this.log(
+        `Connecting to Appium (device=${options.deviceId}, app=${appId}, retryTimeout: ${String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`
+      );
+      const browser = await (0, import_webdriverio.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,
+        logLevel: "warn",
+        path: url.pathname,
+        port
+      });
+      this.log("Appium session established.");
+      const appiumTransport = new import_transport_appium.AppiumTransport({
+        appId,
+        browser,
+        platform: "android",
+        ...options.vaultBasePath !== void 0 && { vaultBasePath: options.vaultBasePath }
+      });
+      const originalDispose = appiumTransport.dispose.bind(appiumTransport);
+      const transport = appiumTransport;
+      transport.dispose = async () => {
+        try {
+          await originalDispose();
+        } finally {
+          killAutoStartedProcesses2();
+        }
+      };
+      transport.disposeSync = () => {
+        killAutoStartedProcesses2();
+      };
+      return transport;
+    } catch (error) {
+      if (appiumProcess) {
+        killProcessTree(appiumProcess);
+        this.log("Killed auto-started Appium server after connection failure.");
+      }
+      if (emulatorProcess) {
+        killProcessTree(emulatorProcess);
+        this.log("Killed auto-started emulator after connection failure.");
+      }
+      throw error;
+    }
   }
-  (0, import_log.log)(`[transport-factory] Creating AppiumTransport (url=${options.appiumUrl}, device=${options.deviceId})`);
-  return createAppiumTransport(options);
-}
-async function getOrCreateTransport(options) {
-  if (cachedTransport) {
-    return cachedTransport;
+  checkAppiumReachable(url) {
+    return new Promise((resolve, reject) => {
+      const statusUrl = new URL("/status", url);
+      const req = import_node_http.default.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {
+        res.resume();
+        resolve();
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        reject(
+          new Error(
+            `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`
+          )
+        );
+      });
+      req.on("error", (err) => {
+        reject(
+          new Error(
+            `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`
+          )
+        );
+      });
+    });
   }
-  const result = await createTransportFromOptions(options);
-  cachedTransport = result;
-  return result;
-}
-function checkAppiumReachable(url) {
-  return new Promise((resolve, reject) => {
-    const statusUrl = new URL("/status", url);
-    const req = import_node_http.default.get(statusUrl, { timeout: APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS }, (res) => {
-      res.resume();
-      resolve();
+  async checkDeviceConnected(deviceId) {
+    const output = await new Promise((resolve, reject) => {
+      (0, import_node_child_process.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) {
+          this.log(`ADB stderr: ${stderr.trim()}`);
+        }
+        resolve(stdout);
+      });
     });
-    req.on("timeout", () => {
-      req.destroy();
-      reject(
-        new Error(
-          `Appium server at ${url.origin} did not respond within ${String(APPIUM_PREFLIGHT_TIMEOUT_IN_MILLISECONDS)}ms. Is the Appium server running?`
-        )
+    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 ensureDeviceConnected(avdName, deviceId) {
+    this.log(`Checking device ${deviceId} is connected via ADB...`);
+    if (await this.checkDeviceConnected(deviceId)) {
+      this.log(`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.`
       );
-    });
-    req.on("error", (err) => {
-      reject(
-        new Error(
-          `Cannot reach Appium server at ${url.origin}: ${err.message}. Is the Appium server running?`
-        )
+    }
+    this.log(`Device ${deviceId} not found, starting emulator AVD "${avdName}"...`);
+    const emulatorProcess = this.startEmulator(avdName);
+    await this.waitForDevice(deviceId);
+    this.log(`Emulator "${avdName}" started, device ${deviceId} is connected.`);
+    return emulatorProcess;
+  }
+  log(message) {
+    (0, import_log.log)(`[transport-factory:${this.type}] ${message}`);
+  }
+  resolveEmulatorBinary() {
+    const sdkRoot = import_node_process.default.env["ANDROID_HOME"] ?? import_node_process.default.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 (0, import_node_path.join)(sdkRoot, "emulator", "emulator");
+  }
+  async sendKeyEvent(deviceId, keyCode, description) {
+    await new Promise((resolve) => {
+      (0, import_node_child_process.execFile)(
+        "adb",
+        ["-s", deviceId, "shell", "input", "keyevent", String(keyCode)],
+        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },
+        (error) => {
+          if (error) {
+            this.log(
+              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : "unknown error"}`
+            );
+          }
+          resolve();
+        }
       );
     });
-  });
-}
-async function checkDeviceConnected(deviceId) {
-  const output = await new Promise((resolve, reject) => {
-    (0, import_node_child_process.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) {
-        (0, import_log.log)(`[transport-factory] ADB stderr: ${stderr.trim()}`);
+  }
+  async startAppiumAndEmulator(params) {
+    const { appiumUrl, avdName, deviceId, port, shouldAutoStartAppium } = params;
+    let needsAppiumStart = false;
+    this.log(`Checking Appium server at ${appiumUrl.href}...`);
+    try {
+      await this.checkAppiumReachable(appiumUrl);
+      this.log("Appium server is reachable.");
+    } catch (error) {
+      if (shouldAutoStartAppium === false) {
+        throw error;
       }
-      resolve(stdout);
+      needsAppiumStart = true;
+    }
+    let appiumProcess;
+    if (needsAppiumStart) {
+      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);
+      appiumProcess = this.startAppiumServer(port);
+    }
+    const [, emulatorProcess] = await Promise.all([
+      needsAppiumStart ? this.waitForAppiumReady(appiumUrl).then(() => {
+        this.log("Auto-started Appium server is ready.");
+      }) : Promise.resolve(),
+      this.ensureDeviceConnected(avdName, deviceId)
+    ]);
+    return [appiumProcess, emulatorProcess];
+  }
+  startAppiumServer(port) {
+    const child = (0, import_node_child_process.spawn)(`npx appium --log-timestamp --port ${String(port)}`, {
+      detached: true,
+      shell: true,
+      stdio: ["ignore", "inherit", "inherit"]
     });
-  });
-  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);
-  if (isNaN(port)) {
-    throw new Error(`Invalid port in appiumUrl: ${url.port}`);
+    child.unref();
+    return child;
   }
-  const appId = options.appId ?? APP_PACKAGE;
-  let appiumProcess;
-  let emulatorProcess;
-  try {
-    let killAutoStartedProcesses2 = function() {
-      if (appiumProcess) {
-        appiumProcess.kill();
-        (0, import_log.log)("[transport-factory] Auto-started Appium server stopped.");
-      }
-      if (emulatorProcess) {
-        emulatorProcess.kill();
-        (0, import_log.log)("[transport-factory] Auto-started emulator stopped.");
-      }
-    };
-    var killAutoStartedProcesses = killAutoStartedProcesses2;
-    [appiumProcess, emulatorProcess] = await startAppiumAndEmulator({
-      appiumUrl: url,
-      avdName: options.avdName,
-      deviceId: options.deviceId,
-      port,
-      shouldAutoStartAppium: options.shouldAutoStartAppium
+  startEmulator(avdName) {
+    const emulatorBinary = this.resolveEmulatorBinary();
+    this.log(`Running: ${emulatorBinary} -avd ${avdName} -no-snapshot-save`);
+    const child = (0, import_node_child_process.spawn)(emulatorBinary, ["-avd", avdName, "-no-snapshot-save"], {
+      detached: true,
+      stdio: ["ignore", "ignore", "ignore"]
     });
-    (0, import_log.log)(
-      `[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId}, retryTimeout: ${String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)}ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`
+    child.unref();
+    return child;
+  }
+  async waitForAppiumReady(url) {
+    this.log(
+      `Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`
     );
-    const browser = await (0, import_webdriverio.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,
-      logLevel: "warn",
-      path: url.pathname,
-      port
-    });
-    (0, import_log.log)("[transport-factory] Appium session established.");
-    const appiumTransport = new import_transport_appium.AppiumTransport({
-      appId,
-      browser,
-      platform: "android",
-      ...options.vaultBasePath !== void 0 && { vaultBasePath: options.vaultBasePath }
-    });
-    const originalDispose = appiumTransport.dispose.bind(appiumTransport);
-    const transport = appiumTransport;
-    transport.dispose = async () => {
+    const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;
+    while (Date.now() < deadline) {
       try {
-        await originalDispose();
-      } finally {
-        killAutoStartedProcesses2();
+        await this.checkAppiumReachable(url);
+        return;
+      } catch {
+        await new Promise((resolve) => {
+          setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);
+        });
       }
-    };
-    transport.disposeSync = () => {
-      killAutoStartedProcesses2();
-    };
-    return transport;
-  } catch (error) {
-    if (appiumProcess) {
-      appiumProcess.kill();
-      (0, import_log.log)("[transport-factory] Killed auto-started Appium server after connection failure.");
     }
-    if (emulatorProcess) {
-      emulatorProcess.kill();
-      (0, import_log.log)("[transport-factory] Killed auto-started emulator after connection failure.");
-    }
-    throw error;
-  }
-}
-async function ensureDeviceConnected(params) {
-  const { avdName, deviceId } = params;
-  (0, import_log.log)(`[transport-factory] Checking device ${deviceId} is connected via ADB...`);
-  if (await checkDeviceConnected(deviceId)) {
-    (0, import_log.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.`
+      `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`
     );
   }
-  (0, import_log.log)(`[transport-factory] Device ${deviceId} not found, starting emulator AVD "${avdName}"...`);
-  const emulatorProcess = startEmulator(avdName);
-  await waitForDevice(deviceId);
-  (0, import_log.log)(`[transport-factory] Emulator "${avdName}" started, device ${deviceId} is connected.`);
-  return emulatorProcess;
-}
-function resolveEmulatorBinary() {
-  const sdkRoot = import_node_process.default.env["ANDROID_HOME"] ?? import_node_process.default.env["ANDROID_SDK_ROOT"];
-  if (!sdkRoot) {
-    throw new Error(
-      "Cannot find Android emulator: neither ANDROID_HOME nor ANDROID_SDK_ROOT environment variable is set."
+  async waitForBoot(deviceId, deadline) {
+    const remainingMs = Math.max(0, deadline - Date.now());
+    this.log(
+      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`
     );
-  }
-  return (0, import_node_path.join)(sdkRoot, "emulator", "emulator");
-}
-async function sendKeyEvent(deviceId, keyCode, description) {
-  await new Promise((resolve) => {
-    (0, import_node_child_process.execFile)(
-      "adb",
-      ["-s", deviceId, "shell", "input", "keyevent", String(keyCode)],
-      { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },
-      (error) => {
-        if (error) {
-          (0, import_log.log)(
-            `[transport-factory] Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : "unknown error"}`
-          );
-        }
-        resolve();
+    while (Date.now() < deadline) {
+      const isBooted = await new Promise((resolve) => {
+        (0, import_node_child_process.execFile)(
+          "adb",
+          ["-s", deviceId, "shell", "getprop", "sys.boot_completed"],
+          { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },
+          (_error, stdout) => {
+            resolve(stdout.trim() === "1");
+          }
+        );
+      });
+      if (isBooted) {
+        this.log(`Device ${deviceId} boot completed.`);
+        return;
       }
-    );
-  });
-}
-async function startAppiumAndEmulator(params) {
-  const { appiumUrl, avdName, deviceId, port, shouldAutoStartAppium } = params;
-  let needsAppiumStart = false;
-  (0, import_log.log)(`[transport-factory] Checking Appium server at ${appiumUrl.href}...`);
-  try {
-    await checkAppiumReachable(appiumUrl);
-    (0, import_log.log)("[transport-factory] Appium server is reachable.");
-  } catch (error) {
-    if (shouldAutoStartAppium === false) {
-      throw error;
+      await new Promise((resolve) => {
+        setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);
+      });
     }
-    needsAppiumStart = true;
-  }
-  let appiumProcess;
-  if (needsAppiumStart) {
-    (0, import_log.log)(`[transport-factory] Appium not reachable, auto-starting on port ${String(port)}...`);
-    appiumProcess = startAppiumServer(port);
+    throw new Error(
+      `Device "${deviceId}" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`
+    );
   }
-  const [, emulatorProcess] = await Promise.all([
-    needsAppiumStart ? waitForAppiumReady(appiumUrl).then(() => {
-      (0, import_log.log)("[transport-factory] Auto-started Appium server is ready.");
-    }) : Promise.resolve(),
-    ensureDeviceConnected({ avdName, deviceId })
-  ]);
-  return [appiumProcess, emulatorProcess];
-}
-function startAppiumServer(port) {
-  const child = (0, import_node_child_process.spawn)(`npx appium --log-timestamp --port ${String(port)}`, {
-    detached: true,
-    shell: true,
-    stdio: ["ignore", "inherit", "inherit"]
-  });
-  child.unref();
-  return child;
-}
-function startEmulator(avdName) {
-  const emulatorBinary = resolveEmulatorBinary();
-  (0, import_log.log)(`[transport-factory] Running: ${emulatorBinary} -avd ${avdName} -no-snapshot-save`);
-  const child = (0, import_node_child_process.spawn)(emulatorBinary, ["-avd", avdName, "-no-snapshot-save"], {
-    detached: true,
-    stdio: ["ignore", "ignore", "ignore"]
-  });
-  child.unref();
-  return child;
-}
-async function waitForAppiumReady(url) {
-  (0, import_log.log)(
-    `[transport-factory] Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`
-  );
-  const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;
-  while (Date.now() < deadline) {
-    try {
-      await checkAppiumReachable(url);
-      return;
-    } catch {
+  async waitForDevice(deviceId) {
+    this.log(
+      `Waiting for device ${deviceId} to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`
+    );
+    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;
+    while (Date.now() < deadline) {
+      if (await this.checkDeviceConnected(deviceId)) {
+        this.log(`Device ${deviceId} appeared in ADB, waiting for boot to complete...`);
+        await this.waitForBoot(deviceId, deadline);
+        await this.wakeScreen(deviceId);
+        return;
+      }
       await new Promise((resolve) => {
-        setTimeout(resolve, APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS);
+        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 wakeScreen(deviceId) {
+    this.log(`Waking screen on device ${deviceId}...`);
+    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, "wake screen");
+    await this.sendKeyEvent(deviceId, KEYCODE_MENU, "dismiss lock screen");
+    this.log(`Screen wake complete on device ${deviceId}.`);
   }
-  throw new Error(
-    `Auto-started Appium server did not become ready within ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms`
-  );
 }
-async function waitForBoot(deviceId, deadline) {
-  const remainingMs = Math.max(0, deadline - Date.now());
-  (0, import_log.log)(
-    `[transport-factory] Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`
-  );
-  while (Date.now() < deadline) {
-    const isBooted = await new Promise((resolve) => {
-      (0, import_node_child_process.execFile)(
-        "adb",
-        ["-s", deviceId, "shell", "getprop", "sys.boot_completed"],
-        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },
-        (_error, stdout) => {
-          resolve(stdout.trim() === "1");
-        }
-      );
-    });
-    if (isBooted) {
-      (0, import_log.log)(`[transport-factory] Device ${deviceId} boot completed.`);
-      return;
-    }
-    await new Promise((resolve) => {
-      setTimeout(resolve, EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS);
+async function createTransportFromOptions(options) {
+  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;
+  if (!options || options.type === "obsidian-cli") {
+    (0, import_log.log)(`[transport-factory:${type}] Creating DesktopCliTransport`);
+    return new import_transport_desktop_cli.DesktopCliTransport();
+  }
+  if (options.type === "obsidian-cdp") {
+    (0, import_log.log)(`[transport-factory:${type}] Creating DesktopCdpTransport (host=${options.host ?? "localhost"}, port=${String(options.port ?? CDP_DEFAULT_PORT)})`);
+    return new import_transport_desktop_cdp.DesktopCdpTransport({
+      ...options.host !== void 0 && { cdpHost: options.host },
+      ...options.port !== void 0 && { cdpPort: options.port },
+      ...options.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }
     });
   }
-  throw new Error(
-    `Device "${deviceId}" connected but did not finish booting within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`
-  );
+  const factory = new AppiumTransportFactory(type);
+  return factory.create(options);
 }
-async function waitForDevice(deviceId) {
-  (0, import_log.log)(
-    `[transport-factory] Waiting for device ${deviceId} to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)}ms)...`
-  );
-  const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;
-  while (Date.now() < deadline) {
-    if (await checkDeviceConnected(deviceId)) {
-      (0, import_log.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);
-    });
+async function getOrCreateTransport(options) {
+  if (cachedTransport) {
+    return cachedTransport;
   }
-  throw new Error(
-    `Emulator device "${deviceId}" did not appear within ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms.`
-  );
+  const result = await createTransportFromOptions(options);
+  cachedTransport = result;
+  return result;
 }
-async function wakeScreen(deviceId) {
-  (0, import_log.log)(`[transport-factory] Waking screen on device ${deviceId}...`);
-  await sendKeyEvent(deviceId, KEYCODE_WAKEUP, "wake screen");
-  await sendKeyEvent(deviceId, KEYCODE_MENU, "dismiss lock screen");
-  (0, import_log.log)(`[transport-factory] Screen wake complete on device ${deviceId}.`);
+function killProcessTree(child) {
+  if (child.pid === void 0) {
+    return;
+  }
+  if (import_node_process.default.platform === "win32") {
+    try {
+      (0, import_node_child_process.execFileSync)("taskkill", ["/F", "/T", "/PID", String(child.pid)], { stdio: "ignore" });
+    } catch (error) {
+      (0, import_log.log)(
+        `[transport-factory] taskkill for PID ${String(child.pid)} failed (may have already exited): ${error instanceof Error ? error.message : "unknown error"}`
+      );
+    }
+  } else {
+    child.kill("SIGKILL");
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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 {\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.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { log } from './log.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.cjs';\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<ObsidianTransport> {\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(\n      `[transport-factory] Connecting to Appium (device=${options.deviceId}, app=${appId}, retryTimeout: ${\n        String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)\n      }ms, retries: ${String(APPIUM_CONNECTION_RETRY_COUNT)})...`\n    );\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      logLevel: 'warn',\n      path: url.pathname,\n      port\n    });\n\n    log('[transport-factory] Appium session established.');\n    const appiumTransport = new AppiumTransport({\n      appId,\n      browser,\n      platform: 'android',\n      ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath })\n    });\n\n    const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n    const transport: ObsidianTransport = appiumTransport;\n    transport.dispose = async (): Promise<void> => {\n      try {\n        await originalDispose();\n      } finally {\n        killAutoStartedProcesses();\n      }\n    };\n\n    transport.disposeSync = (): void => {\n      killAutoStartedProcesses();\n    };\n\n    return transport;\n\n    function killAutoStartedProcesses(): void {\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  } 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 * Sends a key event to a device via ADB. Failures are logged as warnings\n * instead of throwing, since key events are best-effort (e.g., the screen\n * may already be on).\n *\n * @param deviceId - The device UDID.\n * @param keyCode - The Android keycode to send.\n * @param description - Human-readable description for log messages.\n */\nasync function sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n  await new Promise<void>((resolve) => {\n    execFile(\n      'adb',\n      ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n      { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n      (error) => {\n        if (error) {\n          log(\n            `[transport-factory] Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n          );\n        }\n\n        resolve();\n      }\n    );\n  });\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  log(\n    `[transport-factory] Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n      String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)\n    }ms)...`\n  );\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  const remainingMs = Math.max(0, deadline - Date.now());\n  log(\n    `[transport-factory] Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${\n      String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n    }ms)...`\n  );\n\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  log(\n    `[transport-factory] Waiting for device ${deviceId} to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n      String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n    }ms)...`\n  );\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 sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n  await sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n  log(`[transport-factory] Screen wake complete on device ${deviceId}.`);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,gCAGO;AACP,uBAAiB;AACjB,uBAAqB;AACrB,0BAAoB;AACpB,yBAAuB;AAQvB,iBAAoB;AACpB,8BAAgC;AAChC,mCAAoC;AACpC,mCAAoC;AAEpC,MAAM,cAAc;AACpB,MAAM,eAAe,GAAG,WAAW;AACnC,MAAM,2CAA2C;AACjD,MAAM,gCAAgC;AACtC,MAAM,kDAAkD;AACxD,MAAM,2CAA2C;AACjD,MAAM,6CAA6C;AACnD,MAAM,uCAAuC;AAC7C,MAAM,mBAAmB;AACzB,MAAM,kCAAkC;AACxC,MAAM,8CAA8C;AACpD,MAAM,wCAAwC;AAC9C,MAAM,eAAe;AACrB,MAAM,iBAAiB;AACvB,MAAM,wCAAwC;AAiC9C,IAAI;AAQJ,eAAsB,2BAA2B,SAAgE;AAC/G,MAAI,CAAC,WAAW,QAAQ,SAAS,gBAAgB;AAC/C,wBAAI,oFAAoF;AACxF,WAAO,IAAI,iDAAoB;AAAA,EACjC;AAEA,MAAI,QAAQ,SAAS,gBAAgB;AACnC,wBAAI,0DAA0D,QAAQ,QAAQ,WAAW,UAAU,OAAO,QAAQ,QAAQ,gBAAgB,CAAC,GAAG;AAC9I,WAAO,IAAI,iDAAoB;AAAA,MAC7B,GAAI,QAAQ,SAAS,UAAa,EAAE,SAAS,QAAQ,KAAK;AAAA,MAC1D,GAAI,QAAQ,SAAS,UAAa,EAAE,SAAS,QAAQ,KAAK;AAAA,MAC1D,GAAI,QAAQ,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IACjI,CAAC;AAAA,EACH;AAEA,sBAAI,qDAAqD,QAAQ,SAAS,YAAY,QAAQ,QAAQ,GAAG;AACzG,SAAO,sBAAsB,OAAO;AACtC;AAYA,eAAsB,qBAAqB,SAAgE;AACzG,MAAI,iBAAiB;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,MAAM,2BAA2B,OAAO;AAEvD,oBAAkB;AAClB,SAAO;AACT;AAUA,SAAS,qBAAqB,KAAyB;AACrD,SAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACtC,UAAM,YAAY,IAAI,IAAI,WAAW,GAAG;AACxC,UAAM,MAAM,iBAAAA,QAAK,IAAI,WAAW,EAAE,SAAS,yCAAyC,GAAG,CAAC,QAAQ;AAC9F,UAAI,OAAO;AACX,cAAQ;AAAA,IACV,CAAC;AACD,QAAI,GAAG,WAAW,MAAM;AACtB,UAAI,QAAQ;AACZ;AAAA,QACE,IAAI;AAAA,UACF,oBAAoB,IAAI,MAAM,2BAA2B,OAAO,wCAAwC,CAAC;AAAA,QAC3G;AAAA,MACF;AAAA,IACF,CAAC;AACD,QAAI,GAAG,SAAS,CAAC,QAAQ;AACvB;AAAA,QACE,IAAI;AAAA,UACF,iCAAiC,IAAI,MAAM,KAAK,IAAI,OAAO;AAAA,QAC7D;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;AAQA,eAAe,qBAAqB,UAAoC;AACtE,QAAM,SAAS,MAAM,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC5D,4CAAS,OAAO,CAAC,SAAS,GAAG,EAAE,SAAS,yCAAyC,GAAG,CAAC,OAAO,QAAQ,WAAW;AAC7G,UAAI,OAAO;AACT,eAAO,IAAI,MAAM,gCAAgC,MAAM,OAAO,iCAAiC,CAAC;AAChG;AAAA,MACF;AACA,UAAI,QAAQ;AACV,4BAAI,mCAAmC,OAAO,KAAK,CAAC,EAAE;AAAA,MACxD;AACA,cAAQ,MAAM;AAAA,IAChB,CAAC;AAAA,EACH,CAAC;AAED,QAAM,QAAQ,OAAO,MAAM,IAAI,EAAE,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;AAC5F,QAAM,aAAa,MAAM,KAAK,CAAC,SAAS,KAAK,WAAW,QAAQ,CAAC;AACjE,SAAO,YAAY,SAAS,SAAU,KAAK;AAC7C;AAQA,eAAe,sBAAsB,SAA4E;AAC/G,QAAM,MAAM,IAAI,IAAI,QAAQ,SAAS;AAErC,QAAM,OAAO,OAAO,IAAI,IAAI;AAC5B,MAAI,MAAM,IAAI,GAAG;AACf,UAAM,IAAI,MAAM,8BAA8B,IAAI,IAAI,EAAE;AAAA,EAC1D;AAEA,QAAM,QAAQ,QAAQ,SAAS;AAE/B,MAAI;AACJ,MAAI;AAEJ,MAAI;AA8DF,QAASC,4BAAT,WAA0C;AACxC,UAAI,eAAe;AACjB,sBAAc,KAAK;AACnB,4BAAI,yDAAyD;AAAA,MAC/D;AACA,UAAI,iBAAiB;AACnB,wBAAgB,KAAK;AACrB,4BAAI,oDAAoD;AAAA,MAC1D;AAAA,IACF;AATS,mCAAAA;AA7DT,KAAC,eAAe,eAAe,IAAI,MAAM,uBAAuB;AAAA,MAC9D,WAAW;AAAA,MACX,SAAS,QAAQ;AAAA,MACjB,UAAU,QAAQ;AAAA,MAClB;AAAA,MACA,uBAAuB,QAAQ;AAAA,IACjC,CAAC;AAED;AAAA,MACE,oDAAoD,QAAQ,QAAQ,SAAS,KAAK,mBAChF,OAAO,+CAA+C,CACxD,gBAAgB,OAAO,6BAA6B,CAAC;AAAA,IACvD;AACA,UAAM,UAAU,UAAM,2BAAO;AAAA,MAC3B,cAAc;AAAA,QACZ,sBAAsB;AAAA,QACtB,qBAAqB;AAAA,QACrB,+BAA+B;AAAA,QAC/B,yBAAyB;AAAA,QACzB,4BAA4B;AAAA,QAC5B,kBAAkB;AAAA,QAClB,mBAAmB;AAAA,UACjB,mCAAmC;AAAA,QACrC;AAAA,QACA,iCAAiC;AAAA,QACjC,eAAe,QAAQ;AAAA,QACvB,0CAA0C;AAAA,QAC1C,gBAAgB;AAAA,MAClB;AAAA,MACA,sBAAsB;AAAA,MACtB,wBAAwB;AAAA,MACxB,UAAU,IAAI;AAAA,MACd,UAAU;AAAA,MACV,MAAM,IAAI;AAAA,MACV;AAAA,IACF,CAAC;AAED,wBAAI,iDAAiD;AACrD,UAAM,kBAAkB,IAAI,wCAAgB;AAAA,MAC1C;AAAA,MACA;AAAA,MACA,UAAU;AAAA,MACV,GAAI,QAAQ,kBAAkB,UAAa,EAAE,eAAe,QAAQ,cAAc;AAAA,IACpF,CAAC;AAED,UAAM,kBAAkB,gBAAgB,QAAQ,KAAK,eAAe;AACpE,UAAM,YAA+B;AACrC,cAAU,UAAU,YAA2B;AAC7C,UAAI;AACF,cAAM,gBAAgB;AAAA,MACxB,UAAE;AACA,QAAAA,0BAAyB;AAAA,MAC3B;AAAA,IACF;AAEA,cAAU,cAAc,MAAY;AAClC,MAAAA,0BAAyB;AAAA,IAC3B;AAEA,WAAO;AAAA,EAYT,SAAS,OAAgB;AACvB,QAAI,eAAe;AACjB,oBAAc,KAAK;AACnB,0BAAI,iFAAiF;AAAA,IACvF;AACA,QAAI,iBAAiB;AACnB,sBAAgB,KAAK;AACrB,0BAAI,4EAA4E;AAAA,IAClF;AACA,UAAM;AAAA,EACR;AACF;AAWA,eAAe,sBAAsB,QAAwE;AAC3G,QAAM,EAAE,SAAS,SAAS,IAAI;AAC9B,sBAAI,uCAAuC,QAAQ,0BAA0B;AAE7E,MAAI,MAAM,qBAAqB,QAAQ,GAAG;AACxC,wBAAI,8BAA8B,QAAQ,gBAAgB;AAC1D,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR,WAAW,QAAQ;AAAA,IAErB;AAAA,EACF;AAEA,sBAAI,8BAA8B,QAAQ,sCAAsC,OAAO,MAAM;AAC7F,QAAM,kBAAkB,cAAc,OAAO;AAC7C,QAAM,cAAc,QAAQ;AAC5B,sBAAI,iCAAiC,OAAO,qBAAqB,QAAQ,gBAAgB;AACzF,SAAO;AACT;AAUA,SAAS,wBAAgC;AACvC,QAAM,UAAU,oBAAAC,QAAQ,IAAI,cAAc,KAAK,oBAAAA,QAAQ,IAAI,kBAAkB;AAC7E,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,aAAO,uBAAK,SAAS,YAAY,UAAU;AAC7C;AAWA,eAAe,aAAa,UAAkB,SAAiB,aAAoC;AACjG,QAAM,IAAI,QAAc,CAAC,YAAY;AACnC;AAAA,MACE;AAAA,MACA,CAAC,MAAM,UAAU,SAAS,SAAS,YAAY,OAAO,OAAO,CAAC;AAAA,MAC9D,EAAE,SAAS,yCAAyC;AAAA,MACpD,CAAC,UAAU;AACT,YAAI,OAAO;AACT;AAAA,YACE,0CAA0C,WAAW,cAAc,OAAO,OAAO,CAAC,MAAM,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,UAClJ;AAAA,QACF;AAEA,gBAAQ;AAAA,MACV;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAQA,eAAe,uBAAuB,QAAqG;AACzI,QAAM,EAAE,WAAW,SAAS,UAAU,MAAM,sBAAsB,IAAI;AAEtE,MAAI,mBAAmB;AAEvB,sBAAI,iDAAiD,UAAU,IAAI,KAAK;AACxE,MAAI;AACF,UAAM,qBAAqB,SAAS;AACpC,wBAAI,iDAAiD;AAAA,EACvD,SAAS,OAAgB;AACvB,QAAI,0BAA0B,OAAO;AACnC,YAAM;AAAA,IACR;AACA,uBAAmB;AAAA,EACrB;AAEA,MAAI;AAEJ,MAAI,kBAAkB;AACpB,wBAAI,mEAAmE,OAAO,IAAI,CAAC,KAAK;AACxF,oBAAgB,kBAAkB,IAAI;AAAA,EACxC;AAEA,QAAM,CAAC,EAAE,eAAe,IAAI,MAAM,QAAQ,IAAI;AAAA,IAC5C,mBACI,mBAAmB,SAAS,EAAE,KAAK,MAAM;AACzC,0BAAI,0DAA0D;AAAA,IAChE,CAAC,IACC,QAAQ,QAAQ;AAAA,IACpB,sBAAsB,EAAE,SAAS,SAAS,CAAC;AAAA,EAC7C,CAAC;AAED,SAAO,CAAC,eAAe,eAAe;AACxC;AAQA,SAAS,kBAAkB,MAA4B;AACrD,QAAM,YAAQ,iCAAM,qCAAqC,OAAO,IAAI,CAAC,IAAI;AAAA,IACvE,UAAU;AAAA,IACV,OAAO;AAAA,IACP,OAAO,CAAC,UAAU,WAAW,SAAS;AAAA,EACxC,CAAC;AAED,QAAM,MAAM;AACZ,SAAO;AACT;AAQA,SAAS,cAAc,SAA+B;AACpD,QAAM,iBAAiB,sBAAsB;AAC7C,sBAAI,gCAAgC,cAAc,SAAS,OAAO,oBAAoB;AACtF,QAAM,YAAQ,iCAAM,gBAAgB,CAAC,QAAQ,SAAS,mBAAmB,GAAG;AAAA,IAC1E,UAAU;AAAA,IACV,OAAO,CAAC,UAAU,UAAU,QAAQ;AAAA,EACtC,CAAC;AAED,QAAM,MAAM;AACZ,SAAO;AACT;AAOA,eAAe,mBAAmB,KAAyB;AACzD;AAAA,IACE,6CAA6C,IAAI,IAAI,cAAc,OAAO,oCAAoC,CAAC,aAC7G,OAAO,0CAA0C,CACnD;AAAA,EACF;AACA,QAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,QAAI;AACF,YAAM,qBAAqB,GAAG;AAC9B;AAAA,IACF,QAAQ;AACN,YAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,mBAAW,SAAS,0CAA0C;AAAA,MAChE,CAAC;AAAA,IACH;AAAA,EACF;AAEA,QAAM,IAAI;AAAA,IACR,0DAA0D,OAAO,oCAAoC,CAAC;AAAA,EACxG;AACF;AAQA,eAAe,YAAY,UAAkB,UAAiC;AAC5E,QAAM,cAAc,KAAK,IAAI,GAAG,WAAW,KAAK,IAAI,CAAC;AACrD;AAAA,IACE,0CAA0C,QAAQ,kCAAkC,OAAO,WAAW,CAAC,aACrG,OAAO,2CAA2C,CACpD;AAAA,EACF;AAEA,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,UAAM,WAAW,MAAM,IAAI,QAAiB,CAAC,YAAY;AACvD;AAAA,QACE;AAAA,QACA,CAAC,MAAM,UAAU,SAAS,WAAW,oBAAoB;AAAA,QACzD,EAAE,SAAS,yCAAyC;AAAA,QACpD,CAAC,QAAQ,WAAW;AAClB,kBAAQ,OAAO,KAAK,MAAM,GAAG;AAAA,QAC/B;AAAA,MACF;AAAA,IACF,CAAC;AAED,QAAI,UAAU;AACZ,0BAAI,8BAA8B,QAAQ,kBAAkB;AAC5D;AAAA,IACF;AAEA,UAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,iBAAW,SAAS,2CAA2C;AAAA,IACjE,CAAC;AAAA,EACH;AAEA,QAAM,IAAI;AAAA,IACR,WAAW,QAAQ,iDAAiD,OAAO,qCAAqC,CAAC;AAAA,EACnH;AACF;AASA,eAAe,cAAc,UAAiC;AAC5D;AAAA,IACE,0CAA0C,QAAQ,+BAA+B,OAAO,qCAAqC,CAAC,aAC5H,OAAO,2CAA2C,CACpD;AAAA,EACF;AACA,QAAM,WAAW,KAAK,IAAI,IAAI;AAE9B,SAAO,KAAK,IAAI,IAAI,UAAU;AAC5B,QAAI,MAAM,qBAAqB,QAAQ,GAAG;AACxC,0BAAI,8BAA8B,QAAQ,mDAAmD;AAC7F,YAAM,YAAY,UAAU,QAAQ;AACpC,YAAM,WAAW,QAAQ;AACzB;AAAA,IACF;AAEA,UAAM,IAAI,QAAQ,CAAC,YAAY;AAC7B,iBAAW,SAAS,2CAA2C;AAAA,IACjE,CAAC;AAAA,EACH;AAEA,QAAM,IAAI;AAAA,IACR,oBAAoB,QAAQ,2BAA2B,OAAO,qCAAqC,CAAC;AAAA,EACtG;AACF;AAUA,eAAe,WAAW,UAAiC;AACzD,sBAAI,+CAA+C,QAAQ,KAAK;AAEhE,QAAM,aAAa,UAAU,gBAAgB,aAAa;AAC1D,QAAM,aAAa,UAAU,cAAc,qBAAqB;AAEhE,sBAAI,sDAAsD,QAAQ,GAAG;AACvE;",
  "names": ["http", "killAutoStartedProcesses", "process"]
}

+//# 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  execFileSync,\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.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { log } from './log.cjs';\nimport { AppiumTransport } from './transport-appium.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { DesktopCliTransport } from './transport-desktop-cli.cjs';\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 DEFAULT_TRANSPORT_TYPE = 'obsidian-cli';\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 AppiumTransportFactory.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 * Encapsulates all Appium transport creation logic, including Appium server\n * startup, emulator management, and WebDriverIO session establishment.\n *\n * Using a class avoids threading the transport `type` label through every\n * helper function \u2014 `this.log()` automatically prefixes it.\n */\nclass AppiumTransportFactory {\n  private readonly type: string;\n\n  public constructor(type: string) {\n    this.type = type;\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   */\n  public async create(options: ObsidianAndroidAppiumTransportOptions): Promise<ObsidianTransport> {\n    this.log(`Creating AppiumTransport (url=${options.appiumUrl}, device=${options.deviceId})`);\n\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 this.startAppiumAndEmulator({\n        appiumUrl: url,\n        avdName: options.avdName,\n        deviceId: options.deviceId,\n        port,\n        shouldAutoStartAppium: options.shouldAutoStartAppium\n      });\n\n      this.log(\n        `Connecting to Appium (device=${options.deviceId}, app=${appId}, retryTimeout: ${String(APPIUM_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS)}ms, retries: ${\n          String(APPIUM_CONNECTION_RETRY_COUNT)\n        })...`\n      );\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        logLevel: 'warn',\n        path: url.pathname,\n        port\n      });\n\n      this.log('Appium session established.');\n      const appiumTransport = new AppiumTransport({\n        appId,\n        browser,\n        platform: 'android',\n        ...(options.vaultBasePath !== undefined && { vaultBasePath: options.vaultBasePath })\n      });\n\n      const originalDispose = appiumTransport.dispose.bind(appiumTransport);\n      const transport: ObsidianTransport = appiumTransport;\n      transport.dispose = async (): Promise<void> => {\n        try {\n          await originalDispose();\n        } finally {\n          killAutoStartedProcesses();\n        }\n      };\n\n      transport.disposeSync = (): void => {\n        killAutoStartedProcesses();\n      };\n\n      return transport;\n\n      function killAutoStartedProcesses(): void {\n        if (appiumProcess) {\n          killProcessTree(appiumProcess);\n          // Cannot use this.log inside nested function \u2014 `this` is not captured.\n          log(`[transport-factory:${options.type}] Auto-started Appium server stopped.`);\n        }\n        if (emulatorProcess) {\n          killProcessTree(emulatorProcess);\n          log(`[transport-factory:${options.type}] Auto-started emulator stopped.`);\n        }\n      }\n    } catch (error: unknown) {\n      if (appiumProcess) {\n        killProcessTree(appiumProcess);\n        this.log('Killed auto-started Appium server after connection failure.');\n      }\n      if (emulatorProcess) {\n        killProcessTree(emulatorProcess);\n        this.log('Killed auto-started emulator after connection failure.');\n      }\n      throw error;\n    }\n  }\n\n  private 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  private async 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          this.log(`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  private async ensureDeviceConnected(avdName: string | undefined, deviceId: string): Promise<ChildProcess | undefined> {\n    this.log(`Checking device ${deviceId} is connected via ADB...`);\n\n    if (await this.checkDeviceConnected(deviceId)) {\n      this.log(`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    this.log(`Device ${deviceId} not found, starting emulator AVD \"${avdName}\"...`);\n    const emulatorProcess = this.startEmulator(avdName);\n    await this.waitForDevice(deviceId);\n    this.log(`Emulator \"${avdName}\" started, device ${deviceId} is connected.`);\n    return emulatorProcess;\n  }\n\n  private log(message: string): void {\n    log(`[transport-factory:${this.type}] ${message}`);\n  }\n\n  private 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  private async sendKeyEvent(deviceId: string, keyCode: number, description: string): Promise<void> {\n    await new Promise<void>((resolve) => {\n      execFile(\n        'adb',\n        ['-s', deviceId, 'shell', 'input', 'keyevent', String(keyCode)],\n        { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS },\n        (error) => {\n          if (error) {\n            this.log(\n              `Warning: failed to ${description} (keyevent ${String(keyCode)}): ${error instanceof Error ? error.message : 'unknown error'}`\n            );\n          }\n\n          resolve();\n        }\n      );\n    });\n  }\n\n  private async startAppiumAndEmulator(params: StartAppiumAndEmulatorParams): Promise<[ChildProcess | undefined, ChildProcess | undefined]> {\n    const { appiumUrl, avdName, deviceId, port, shouldAutoStartAppium } = params;\n\n    let needsAppiumStart = false;\n\n    this.log(`Checking Appium server at ${appiumUrl.href}...`);\n    try {\n      await this.checkAppiumReachable(appiumUrl);\n      this.log('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      this.log(`Appium not reachable, auto-starting on port ${String(port)}...`);\n      appiumProcess = this.startAppiumServer(port);\n    }\n\n    const [, emulatorProcess] = await Promise.all([\n      needsAppiumStart\n        ? this.waitForAppiumReady(appiumUrl).then(() => {\n          this.log('Auto-started Appium server is ready.');\n        })\n        : Promise.resolve(),\n      this.ensureDeviceConnected(avdName, deviceId)\n    ]);\n\n    return [appiumProcess, emulatorProcess];\n  }\n\n  private 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  private startEmulator(avdName: string): ChildProcess {\n    const emulatorBinary = this.resolveEmulatorBinary();\n    this.log(`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  private async waitForAppiumReady(url: URL): Promise<void> {\n    this.log(\n      `Waiting for Appium at ${url.href} (timeout: ${String(APPIUM_START_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(APPIUM_START_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + APPIUM_START_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      try {\n        await this.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  private async waitForBoot(deviceId: string, deadline: number): Promise<void> {\n    const remainingMs = Math.max(0, deadline - Date.now());\n    this.log(\n      `Waiting for device ${deviceId} to finish booting (remaining: ${String(remainingMs)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n\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        this.log(`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  private async waitForDevice(deviceId: string): Promise<void> {\n    this.log(\n      `Waiting for device ${deviceId} to appear in ADB (timeout: ${String(EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS)}ms, poll: ${\n        String(EMULATOR_BOOT_POLL_INTERVAL_IN_MILLISECONDS)\n      }ms)...`\n    );\n    const deadline = Date.now() + EMULATOR_BOOT_TIMEOUT_IN_MILLISECONDS;\n\n    while (Date.now() < deadline) {\n      if (await this.checkDeviceConnected(deviceId)) {\n        this.log(`Device ${deviceId} appeared in ADB, waiting for boot to complete...`);\n        await this.waitForBoot(deviceId, deadline);\n        await this.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  private async wakeScreen(deviceId: string): Promise<void> {\n    this.log(`Waking screen on device ${deviceId}...`);\n\n    await this.sendKeyEvent(deviceId, KEYCODE_WAKEUP, 'wake screen');\n    await this.sendKeyEvent(deviceId, KEYCODE_MENU, 'dismiss lock screen');\n\n    this.log(`Screen wake complete on device ${deviceId}.`);\n  }\n}\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  const type = options?.type ?? DEFAULT_TRANSPORT_TYPE;\n\n  if (!options || options.type === 'obsidian-cli') {\n    log(`[transport-factory:${type}] Creating DesktopCliTransport`);\n    return new DesktopCliTransport();\n  }\n\n  if (options.type === 'obsidian-cdp') {\n    log(`[transport-factory:${type}] 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  const factory = new AppiumTransportFactory(type);\n  return factory.create(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 * Kills a child process and its entire process tree.\n *\n * On Windows, `child.kill()` only sends SIGTERM to the direct process,\n * leaving spawned grandchildren (e.g. QEMU, UiAutomator) alive.\n * `taskkill /F /T /PID` forcefully terminates the entire tree.\n *\n * @param child - The child process to kill.\n */\nfunction killProcessTree(child: ChildProcess): void {\n  if (child.pid === undefined) {\n    return;\n  }\n\n  if (process.platform === 'win32') {\n    try {\n      execFileSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { stdio: 'ignore' });\n    } catch (error: unknown) {\n      log(\n        `[transport-factory] taskkill for PID ${String(child.pid)} failed (may have already exited): ${\n          error instanceof Error ? error.message : 'unknown error'\n        }`\n      );\n    }\n  } else {\n    child.kill('SIGKILL');\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["killAutoStartedProcesses", "http", "process"]
}
