@veolab/discoverylab 1.2.1 → 1.2.2

package/dist/chunk-YEZ26ENO.js

@@ -0,0 +1,1569 @@
+import {
+  PROJECTS_DIR
+} from "./chunk-TJ3H23LL.js";
+
+// src/core/android/adb.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var ADB_COMMAND_CACHE_SUCCESS_TTL_MS = 5 * 60 * 1e3;
+var ADB_COMMAND_CACHE_FAILURE_TTL_MS = 5 * 1e3;
+var adbCommandCache = null;
+function quoteCommand(cmd) {
+  return cmd.includes(" ") ? `"${cmd}"` : cmd;
+}
+function shellQuoteArg(value) {
+  const str = String(value ?? "");
+  if (!str) return "''";
+  return `'${str.replace(/'/g, `'"'"'`)}'`;
+}
+function findAndroidSdkPath() {
+  const envPaths = [
+    process.env.ANDROID_HOME,
+    process.env.ANDROID_SDK_ROOT,
+    process.env.ANDROID_SDK
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  for (const envPath of envPaths) {
+    if (existsSync(join(envPath, "platform-tools", "adb"))) {
+      return envPath;
+    }
+  }
+  const home = homedir();
+  const commonPaths = [
+    join(home, "Library", "Android", "sdk"),
+    join(home, "Android", "Sdk"),
+    "/opt/android-sdk",
+    "/usr/local/android-sdk"
+  ];
+  for (const sdkPath of commonPaths) {
+    if (existsSync(join(sdkPath, "platform-tools", "adb"))) {
+      return sdkPath;
+    }
+  }
+  return null;
+}
+function getAdbPath() {
+  const sdkPath = findAndroidSdkPath();
+  if (!sdkPath) return null;
+  const adbPath = join(sdkPath, "platform-tools", "adb");
+  return existsSync(adbPath) ? adbPath : null;
+}
+function getEmulatorPath() {
+  const sdkPath = findAndroidSdkPath();
+  if (!sdkPath) return null;
+  const emulatorPath = join(sdkPath, "emulator", "emulator");
+  return existsSync(emulatorPath) ? emulatorPath : null;
+}
+function getAdbCommand(options) {
+  const forceRefresh = options?.forceRefresh === true;
+  const now = Date.now();
+  if (!forceRefresh && adbCommandCache) {
+    const ttlMs = adbCommandCache.value ? ADB_COMMAND_CACHE_SUCCESS_TTL_MS : ADB_COMMAND_CACHE_FAILURE_TTL_MS;
+    if (now - adbCommandCache.checkedAt < ttlMs) {
+      return adbCommandCache.value;
+    }
+  }
+  const candidates = [
+    getAdbPath(),
+    "/opt/homebrew/bin/adb",
+    "/usr/local/bin/adb",
+    "adb"
+  ].filter((value, index, arr) => Boolean(value) && arr.indexOf(value) === index);
+  for (const candidate of candidates) {
+    try {
+      if (candidate === "adb") {
+        execSync("which adb", { stdio: "pipe", timeout: 2e3 });
+      } else if (!existsSync(candidate)) {
+        continue;
+      }
+      adbCommandCache = { value: candidate, checkedAt: Date.now() };
+      return candidate;
+    } catch {
+    }
+  }
+  adbCommandCache = { value: null, checkedAt: Date.now() };
+  return null;
+}
+function normalizeAndroidDeviceToken(value) {
+  return value.trim().replace(/^android:/i, "").replace(/\s+/g, "_").toLowerCase();
+}
+function listConnectedAndroidDevices(adbCommand = getAdbCommand()) {
+  if (!adbCommand) return [];
+  try {
+    const adbOutput = execSync(`${quoteCommand(adbCommand)} devices -l`, {
+      encoding: "utf8",
+      timeout: 4e3
+    });
+    const lines = adbOutput.split("\n").slice(1);
+    const devices = [];
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      const parts = line.split(/\s+/);
+      const serial = parts[0];
+      const state = parts[1];
+      if (!serial || !state) continue;
+      const modelMatch = line.match(/model:(\S+)/);
+      const deviceMatch = line.match(/device:(\S+)/);
+      const deviceInfo = {
+        serial,
+        state,
+        model: modelMatch?.[1],
+        device: deviceMatch?.[1]
+      };
+      if (serial.startsWith("emulator-") && state === "device") {
+        try {
+          const avdNameOutput = execSync(
+            `${quoteCommand(adbCommand)} -s ${shellQuoteArg(serial)} emu avd name`,
+            {
+              encoding: "utf8",
+              timeout: 1500
+            }
+          );
+          const avdName = avdNameOutput.split("\n").map((value) => value.trim()).find((value) => value && value !== "OK");
+          if (avdName) {
+            deviceInfo.avdName = avdName;
+          }
+        } catch {
+        }
+      }
+      devices.push(deviceInfo);
+    }
+    return devices;
+  } catch {
+    return [];
+  }
+}
+function resolveAndroidDeviceSerial(deviceId, adbCommand = getAdbCommand()) {
+  const connectedDevices = listConnectedAndroidDevices(adbCommand);
+  const onlineDevices = connectedDevices.filter((device) => device.state === "device");
+  if (onlineDevices.length === 0) return null;
+  const requested = typeof deviceId === "string" ? deviceId.trim() : "";
+  if (!requested) {
+    return onlineDevices[0]?.serial || null;
+  }
+  const requestedToken = normalizeAndroidDeviceToken(requested);
+  for (const device of onlineDevices) {
+    const candidates = [device.serial, device.avdName, device.model, device.device].filter((value) => Boolean(value)).map((value) => normalizeAndroidDeviceToken(value));
+    if (candidates.includes(requestedToken)) {
+      return device.serial;
+    }
+  }
+  return null;
+}
+
+// src/core/testing/maestro.ts
+import { exec, execSync as execSync2, spawn } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { createHash } from "crypto";
+import { EventEmitter } from "events";
+var execAsync = promisify(exec);
+var MAESTRO_COMMAND_CACHE_SUCCESS_TTL_MS = 5 * 60 * 1e3;
+var MAESTRO_COMMAND_CACHE_FAILURE_TTL_MS = 5 * 1e3;
+var MAESTRO_DEVICE_CACHE_TTL_MS = 4 * 1e3;
+var maestroCommandCache = null;
+var maestroCommandResolveInFlight = null;
+var maestroDeviceListCache = null;
+var maestroDeviceListInFlight = null;
+function quoteCommand2(cmd) {
+  return cmd.includes(" ") ? `"${cmd}"` : cmd;
+}
+function shellQuoteArg2(value) {
+  const str = String(value ?? "");
+  if (!str) return "''";
+  return `'${str.replace(/'/g, `'"'"'`)}'`;
+}
+function getAdbCommandOrThrow() {
+  const adbCommand = getAdbCommand();
+  if (!adbCommand) {
+    throw new Error("ADB not found. Set ANDROID_HOME/ANDROID_SDK_ROOT or add adb to PATH.");
+  }
+  return adbCommand;
+}
+function getMaestroCommandCandidates() {
+  const candidates = [];
+  const maestroHomePath = path.join(os.homedir(), ".maestro", "bin", "maestro");
+  if (fs.existsSync(maestroHomePath)) {
+    candidates.push(maestroHomePath);
+  }
+  const brewPaths = ["/opt/homebrew/bin/maestro", "/usr/local/bin/maestro"];
+  for (const brewPath of brewPaths) {
+    if (fs.existsSync(brewPath)) {
+      candidates.push(brewPath);
+    }
+  }
+  candidates.push("maestro");
+  return candidates;
+}
+function getMaestroCommandCacheTtlMs(value) {
+  return value ? MAESTRO_COMMAND_CACHE_SUCCESS_TTL_MS : MAESTRO_COMMAND_CACHE_FAILURE_TTL_MS;
+}
+async function resolveMaestroCommand(options) {
+  const forceRefresh = options?.forceRefresh === true;
+  const now = Date.now();
+  if (!forceRefresh && maestroCommandCache) {
+    const ttlMs = getMaestroCommandCacheTtlMs(maestroCommandCache.value);
+    if (now - maestroCommandCache.checkedAt < ttlMs) {
+      return maestroCommandCache.value;
+    }
+  }
+  if (!forceRefresh && maestroCommandResolveInFlight) {
+    return maestroCommandResolveInFlight;
+  }
+  maestroCommandResolveInFlight = (async () => {
+    for (const candidate of getMaestroCommandCandidates()) {
+      try {
+        const cmd = quoteCommand2(candidate);
+        await execAsync(`${cmd} --version`);
+        maestroCommandCache = { value: candidate, checkedAt: Date.now() };
+        return candidate;
+      } catch {
+      }
+    }
+    maestroCommandCache = { value: null, checkedAt: Date.now() };
+    return null;
+  })();
+  try {
+    return await maestroCommandResolveInFlight;
+  } finally {
+    maestroCommandResolveInFlight = null;
+  }
+}
+var PENDING_SESSION_FILE = path.join(PROJECTS_DIR, ".maestro-pending-session.json");
+async function isMaestroInstalled() {
+  try {
+    return !!await resolveMaestroCommand();
+  } catch {
+    return false;
+  }
+}
+async function isIdbInstalled() {
+  try {
+    await execAsync("idb --version", { timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function tapViaIdb(deviceId, x, y) {
+  try {
+    await execAsync(`idb ui tap ${Math.round(x)} ${Math.round(y)} --udid ${deviceId}`, {
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    console.error("[idb tap failed]", error instanceof Error ? error.message : error);
+    return false;
+  }
+}
+async function killZombieMaestroProcesses() {
+  try {
+    await execAsync('pkill -f "maestro test" || true', { timeout: 3e3 });
+    await execAsync('pkill -f "maestro record" || true', { timeout: 3e3 });
+    console.log("[MaestroCleanup] Killed zombie maestro processes");
+  } catch {
+  }
+}
+async function getMaestroVersion() {
+  try {
+    const command = await resolveMaestroCommand();
+    if (!command) return null;
+    const cmd = quoteCommand2(command);
+    const { stdout } = await execAsync(`${cmd} --version`);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function listMaestroDevices(options) {
+  const forceRefresh = options?.forceRefresh === true;
+  const ttlMs = Math.max(0, Number(options?.ttlMs ?? MAESTRO_DEVICE_CACHE_TTL_MS));
+  const now = Date.now();
+  if (!forceRefresh && maestroDeviceListCache && now - maestroDeviceListCache.fetchedAt < ttlMs) {
+    return maestroDeviceListCache.devices;
+  }
+  if (!forceRefresh && maestroDeviceListInFlight) {
+    return maestroDeviceListInFlight;
+  }
+  maestroDeviceListInFlight = (async () => {
+    const devices = [];
+    try {
+      const { stdout: iosOutput } = await execAsync("xcrun simctl list devices -j");
+      const iosData = JSON.parse(iosOutput);
+      for (const [runtime, deviceList] of Object.entries(iosData.devices || {})) {
+        if (!Array.isArray(deviceList)) continue;
+        for (const device of deviceList) {
+          if (device.state === "Booted") {
+            devices.push({
+              id: device.udid,
+              name: device.name,
+              platform: "ios",
+              status: "connected"
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    try {
+      const adbCommand = getAdbCommand();
+      if (adbCommand) {
+        const { stdout: androidOutput } = await execAsync(`${quoteCommand2(adbCommand)} devices -l`);
+        const lines = androidOutput.split("\n").slice(1);
+        for (const line of lines) {
+          const match = line.match(/^(\S+)\s+device\s+(.*)$/);
+          if (match) {
+            const [, id, info] = match;
+            const modelMatch = info.match(/model:(\S+)/);
+            devices.push({
+              id,
+              name: modelMatch ? modelMatch[1] : id,
+              platform: "android",
+              status: "connected"
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    maestroDeviceListCache = { devices, fetchedAt: Date.now() };
+    return devices;
+  })();
+  try {
+    return await maestroDeviceListInFlight;
+  } finally {
+    maestroDeviceListInFlight = null;
+  }
+}
+function generateMaestroFlow(flow) {
+  const lines = [];
+  lines.push(`appId: ${flow.appId}`);
+  lines.push("");
+  if (flow.name) {
+    lines.push(`name: ${flow.name}`);
+    lines.push("");
+  }
+  if (flow.env && Object.keys(flow.env).length > 0) {
+    lines.push("env:");
+    for (const [key, value] of Object.entries(flow.env)) {
+      lines.push(`  ${key}: "${value}"`);
+    }
+    lines.push("");
+  }
+  if (flow.onFlowStart && flow.onFlowStart.length > 0) {
+    lines.push("onFlowStart:");
+    for (const step of flow.onFlowStart) {
+      lines.push(formatFlowStep(step, 2));
+    }
+    lines.push("");
+  }
+  if (flow.onFlowComplete && flow.onFlowComplete.length > 0) {
+    lines.push("onFlowComplete:");
+    for (const step of flow.onFlowComplete) {
+      lines.push(formatFlowStep(step, 2));
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  for (const step of flow.steps) {
+    lines.push(formatFlowStep(step, 0));
+  }
+  return lines.join("\n");
+}
+function formatFlowStep(step, indent) {
+  const prefix = " ".repeat(indent);
+  const { action, params } = step;
+  if (!params || Object.keys(params).length === 0) {
+    return `${prefix}- ${action}`;
+  }
+  if (Object.keys(params).length === 1) {
+    const [key, value] = Object.entries(params)[0];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return `${prefix}- ${action}:
+${prefix}    ${key}: ${formatValue(value)}`;
+    }
+  }
+  const lines = [`${prefix}- ${action}:`];
+  for (const [key, value] of Object.entries(params)) {
+    lines.push(`${prefix}    ${key}: ${formatValue(value)}`);
+  }
+  return lines.join("\n");
+}
+function formatValue(value) {
+  if (typeof value === "string") {
+    return value.includes("\n") || value.includes(":") ? `"${value}"` : value;
+  }
+  return String(value);
+}
+var MaestroActions = {
+  // App lifecycle
+  launchApp: (appId) => ({ action: "launchApp", params: appId ? { appId } : void 0 }),
+  stopApp: (appId) => ({ action: "stopApp", params: appId ? { appId } : void 0 }),
+  clearState: (appId) => ({ action: "clearState", params: appId ? { appId } : void 0 }),
+  clearKeychain: () => ({ action: "clearKeychain" }),
+  // Navigation
+  tapOn: (text) => ({ action: "tapOn", params: { text } }),
+  tapOnId: (id) => ({ action: "tapOn", params: { id } }),
+  tapOnPoint: (x, y) => ({ action: "tapOn", params: { point: `${x},${y}` } }),
+  doubleTapOn: (text) => ({ action: "doubleTapOn", params: { text } }),
+  longPressOn: (text) => ({ action: "longPressOn", params: { text } }),
+  // Input
+  inputText: (text) => ({ action: "inputText", params: { text } }),
+  inputRandomText: () => ({ action: "inputRandomText" }),
+  inputRandomNumber: () => ({ action: "inputRandomNumber" }),
+  inputRandomEmail: () => ({ action: "inputRandomEmail" }),
+  eraseText: (chars) => ({ action: "eraseText", params: chars ? { charactersToErase: chars } : void 0 }),
+  // Gestures
+  scroll: () => ({ action: "scroll" }),
+  scrollDown: () => ({ action: "scrollUntilVisible", params: { direction: "DOWN" } }),
+  scrollUp: () => ({ action: "scrollUntilVisible", params: { direction: "UP" } }),
+  swipeLeft: () => ({ action: "swipe", params: { direction: "LEFT" } }),
+  swipeRight: () => ({ action: "swipe", params: { direction: "RIGHT" } }),
+  swipeDown: () => ({ action: "swipe", params: { direction: "DOWN" } }),
+  swipeUp: () => ({ action: "swipe", params: { direction: "UP" } }),
+  // Assertions
+  assertVisible: (text) => ({ action: "assertVisible", params: { text } }),
+  assertNotVisible: (text) => ({ action: "assertNotVisible", params: { text } }),
+  assertTrue: (condition) => ({ action: "assertTrue", params: { condition } }),
+  // Wait
+  waitForAnimationToEnd: (timeout) => ({
+    action: "waitForAnimationToEnd",
+    params: timeout ? { timeout } : void 0
+  }),
+  wait: (ms) => ({ action: "extendedWaitUntil", params: { timeout: ms } }),
+  // Screenshots
+  takeScreenshot: (path2) => ({ action: "takeScreenshot", params: { path: path2 } }),
+  // Keyboard
+  hideKeyboard: () => ({ action: "hideKeyboard" }),
+  pressKey: (key) => ({ action: "pressKey", params: { key } }),
+  back: () => ({ action: "back" }),
+  // Conditional
+  runFlow: (flowPath) => ({ action: "runFlow", params: { file: flowPath } }),
+  runScript: (script) => ({ action: "runScript", params: { script } }),
+  // Device
+  openLink: (url) => ({ action: "openLink", params: { link: url } }),
+  setLocation: (lat, lon) => ({ action: "setLocation", params: { latitude: lat, longitude: lon } }),
+  travel: (steps) => ({ action: "travel", params: { points: steps } })
+};
+async function runMaestroTest(options) {
+  const installed = await isMaestroInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: 'Maestro CLI is not installed. Install with: curl -Ls "https://get.maestro.mobile.dev" | bash'
+    };
+  }
+  const {
+    flowPath,
+    appId,
+    device,
+    env = {},
+    timeout = 3e5,
+    // 5 minutes default
+    captureVideo = false,
+    captureScreenshots = false,
+    outputDir = path.join(PROJECTS_DIR, "maestro-output", Date.now().toString())
+  } = options;
+  const command = await resolveMaestroCommand();
+  if (!command) {
+    return {
+      success: false,
+      error: 'Maestro CLI is not installed or not runnable. Install with: curl -Ls "https://get.maestro.mobile.dev" | bash'
+    };
+  }
+  if (!fs.existsSync(flowPath)) {
+    return { success: false, error: `Flow file not found: ${flowPath}` };
+  }
+  await fs.promises.mkdir(outputDir, { recursive: true });
+  const startTime = Date.now();
+  const args = ["test", flowPath];
+  const maestroCmd = quoteCommand2(command);
+  if (device) {
+    args.push("--device", device);
+  }
+  for (const [key, value] of Object.entries(env)) {
+    args.push("-e", `${key}=${value}`);
+  }
+  args.push("--format", "junit");
+  args.push("--output", path.join(outputDir, "report.xml"));
+  try {
+    const shellArgs = args.map(shellQuoteArg2).join(" ");
+    const { stdout, stderr } = await execAsync(`${maestroCmd} ${shellArgs}`, {
+      timeout,
+      env: { ...process.env, ...env }
+    });
+    const duration = Date.now() - startTime;
+    const screenshots = [];
+    const videoPath = captureVideo ? path.join(outputDir, "recording.mp4") : void 0;
+    if (captureScreenshots) {
+      const files = await fs.promises.readdir(outputDir);
+      for (const file of files) {
+        if (file.endsWith(".png")) {
+          screenshots.push(path.join(outputDir, file));
+        }
+      }
+    }
+    return {
+      success: true,
+      duration,
+      flowPath,
+      output: stdout + stderr,
+      screenshots,
+      video: videoPath
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const message = error instanceof Error ? error.message : String(error);
+    const errLike = error;
+    const stdout = typeof errLike?.stdout === "string" ? errLike.stdout : Buffer.isBuffer(errLike?.stdout) ? errLike.stdout.toString("utf8") : "";
+    const stderr = typeof errLike?.stderr === "string" ? errLike.stderr : Buffer.isBuffer(errLike?.stderr) ? errLike.stderr.toString("utf8") : "";
+    const detailedOutput = [stderr?.trim(), stdout?.trim(), message].filter(Boolean).join("\n\n").slice(-16e3);
+    return {
+      success: false,
+      error: stderr?.trim() || message,
+      duration,
+      flowPath,
+      output: detailedOutput || message
+    };
+  }
+}
+async function runMaestroWithCapture(options, onProgress) {
+  const {
+    flowPath,
+    device,
+    outputDir = path.join(PROJECTS_DIR, "maestro-output", Date.now().toString())
+  } = options;
+  await fs.promises.mkdir(outputDir, { recursive: true });
+  const videoPath = path.join(outputDir, "recording.mp4");
+  let recordingProcess = null;
+  try {
+    onProgress?.("Starting screen recording...");
+    if (device) {
+      const devices = await listMaestroDevices();
+      const targetDevice = devices.find((d) => d.id === device || d.name === device);
+      if (targetDevice?.platform === "ios") {
+        recordingProcess = spawn("xcrun", ["simctl", "io", device, "recordVideo", videoPath]);
+      } else if (targetDevice?.platform === "android") {
+        const adbCommand = getAdbCommandOrThrow();
+        recordingProcess = spawn(adbCommand, ["-s", device, "shell", "screenrecord", "/sdcard/recording.mp4"]);
+      }
+    }
+    onProgress?.("Running Maestro test...");
+    const result = await runMaestroTest({ ...options, outputDir });
+    onProgress?.("Stopping screen recording...");
+    if (recordingProcess) {
+      recordingProcess.kill("SIGINT");
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      const devices = await listMaestroDevices();
+      const targetDevice = devices.find((d) => d.id === device || d.name === device);
+      if (targetDevice?.platform === "android") {
+        const adbCommand = getAdbCommandOrThrow();
+        await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(device)} pull /sdcard/recording.mp4 "${videoPath}"`);
+        await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(device)} shell rm /sdcard/recording.mp4`);
+      }
+    }
+    return {
+      ...result,
+      video: fs.existsSync(videoPath) ? videoPath : void 0
+    };
+  } catch (error) {
+    if (recordingProcess) {
+      recordingProcess.kill("SIGKILL");
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      flowPath
+    };
+  }
+}
+async function startMaestroStudio(appId) {
+  const installed = await isMaestroInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: "Maestro CLI is not installed"
+    };
+  }
+  try {
+    const args = ["studio"];
+    if (appId) {
+      args.push(appId);
+    }
+    const maestroCmd = await resolveMaestroCommand();
+    if (!maestroCmd) {
+      return { success: false, error: "Maestro CLI is not installed or not runnable" };
+    }
+    spawn(maestroCmd, args, {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createLoginFlow(appId, usernameField, passwordField, loginButton, successIndicator) {
+  return {
+    appId,
+    name: "Login Flow",
+    steps: [
+      MaestroActions.launchApp(appId),
+      MaestroActions.waitForAnimationToEnd(),
+      MaestroActions.tapOn(usernameField),
+      MaestroActions.inputText("${USERNAME}"),
+      MaestroActions.tapOn(passwordField),
+      MaestroActions.inputText("${PASSWORD}"),
+      MaestroActions.hideKeyboard(),
+      MaestroActions.tapOn(loginButton),
+      MaestroActions.waitForAnimationToEnd(5e3),
+      MaestroActions.assertVisible(successIndicator)
+    ]
+  };
+}
+function createOnboardingFlow(appId, screens) {
+  const steps = [
+    MaestroActions.launchApp(appId),
+    MaestroActions.waitForAnimationToEnd()
+  ];
+  for (const screen of screens) {
+    if (screen.waitFor) {
+      steps.push(MaestroActions.assertVisible(screen.waitFor));
+    }
+    steps.push(MaestroActions.tapOn(screen.nextButton));
+    steps.push(MaestroActions.waitForAnimationToEnd());
+  }
+  return {
+    appId,
+    name: "Onboarding Flow",
+    steps
+  };
+}
+function createNavigationTestFlow(appId, tabs) {
+  const steps = [
+    MaestroActions.launchApp(appId),
+    MaestroActions.waitForAnimationToEnd()
+  ];
+  for (const tab of tabs) {
+    steps.push(MaestroActions.tapOn(tab));
+    steps.push(MaestroActions.waitForAnimationToEnd());
+    steps.push(MaestroActions.takeScreenshot(`${tab.replace(/\s+/g, "_")}.png`));
+  }
+  return {
+    appId,
+    name: "Navigation Test",
+    steps
+  };
+}
+var MaestroRecorder = class extends EventEmitter {
+  session = null;
+  adbProcess = null;
+  videoProcess = null;
+  maestroRecordProcess = null;
+  // Native maestro record process
+  actionCounter = 0;
+  screenshotInterval = null;
+  useNativeMaestroRecord = true;
+  // Use native maestro record for better accuracy
+  legacyCaptureStarted = false;
+  lastMaestroRecordErrorLine = null;
+  baseScreenshotIntervalMs = 2e3;
+  maxScreenshotIntervalMs = 12e3;
+  currentScreenshotIntervalMs = this.baseScreenshotIntervalMs;
+  nextScreenshotAt = 0;
+  lastScreenshotHash = null;
+  unchangedScreenshotCount = 0;
+  screenshotBackoffThreshold = 3;
+  constructor() {
+    super();
+    this.loadPendingSession();
+  }
+  /**
+   * Check if maestro is available in system PATH
+   */
+  isMaestroInPath() {
+    try {
+      execSync2("which maestro", { encoding: "utf-8", timeout: 2e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  canRunMaestro(cmd) {
+    try {
+      execSync2(`"${cmd}" --version`, { encoding: "utf-8", timeout: 3e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  startLegacyCapture(deviceId, platform) {
+    if (platform === "android") {
+      if (!this.adbProcess) {
+        this.startAndroidEventCapture(deviceId);
+      }
+    } else {
+      this.startIOSEventCapture(deviceId);
+    }
+    this.legacyCaptureStarted = true;
+  }
+  fallbackToLegacyCapture(reason) {
+    if (!this.session || this.session.status !== "recording") return;
+    if (this.legacyCaptureStarted) return;
+    console.log(`[MaestroRecorder] Native record stopped (${reason}). Falling back to manual capture.`);
+    this.session.captureMode = "manual";
+    const stderrSuffix = this.lastMaestroRecordErrorLine ? ` | ${this.lastMaestroRecordErrorLine}` : "";
+    this.session.captureModeReason = `maestro record falhou (${reason})${stderrSuffix}`;
+    this.startLegacyCapture(this.session.deviceId, this.session.platform);
+  }
+  /**
+   * Save session state to disk for recovery after server restart
+   */
+  savePendingSession() {
+    if (!this.session) return;
+    try {
+      fs.writeFileSync(PENDING_SESSION_FILE, JSON.stringify(this.session, null, 2));
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to save pending session:", error);
+    }
+  }
+  /**
+   * Load pending session from disk (after server restart)
+   */
+  loadPendingSession() {
+    try {
+      if (fs.existsSync(PENDING_SESSION_FILE)) {
+        const data = fs.readFileSync(PENDING_SESSION_FILE, "utf8");
+        const savedSession = JSON.parse(data);
+        if (savedSession.status === "recording") {
+          console.log("[MaestroRecorder] Restoring pending session from disk:", savedSession.id);
+          this.session = savedSession;
+          this.actionCounter = savedSession.actions.length;
+        }
+      }
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to load pending session:", error);
+      try {
+        fs.unlinkSync(PENDING_SESSION_FILE);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Clear pending session file (after successful stop)
+   */
+  clearPendingSession() {
+    try {
+      if (fs.existsSync(PENDING_SESSION_FILE)) {
+        fs.unlinkSync(PENDING_SESSION_FILE);
+      }
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to clear pending session:", error);
+    }
+  }
+  /**
+   * Persist session metadata to session.json (available during recording)
+   */
+  async writeSessionMetadata() {
+    if (!this.session) return;
+    try {
+      const metadataPath = path.join(this.session.screenshotsDir, "..", "session.json");
+      await fs.promises.writeFile(metadataPath, JSON.stringify(this.session, null, 2));
+    } catch (error) {
+      console.error("[MaestroRecorder] Failed to write session metadata:", error);
+    }
+  }
+  /**
+   * Start recording a mobile session
+   */
+  async startRecording(name, deviceId, deviceName, platform, appId, options = {}) {
+    if (this.session?.status === "recording") {
+      const hasActiveProcesses = !!(this.videoProcess || this.maestroRecordProcess || this.adbProcess);
+      if (hasActiveProcesses) {
+        throw new Error("Recording already in progress");
+      }
+      console.log("[MaestroRecorder] Stale recording session detected. Clearing before starting a new one.");
+      this.session = null;
+      if (this.screenshotInterval) {
+        clearInterval(this.screenshotInterval);
+        this.screenshotInterval = null;
+      }
+      this.clearPendingSession();
+    }
+    const sessionId = `maestro_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const baseDir = path.join(PROJECTS_DIR, "maestro-recordings", sessionId);
+    const screenshotsDir = path.join(baseDir, "screenshots");
+    await fs.promises.mkdir(screenshotsDir, { recursive: true });
+    this.session = {
+      id: sessionId,
+      name,
+      startedAt: Date.now(),
+      appId,
+      deviceId,
+      deviceName,
+      platform,
+      actions: [],
+      screenshotsDir,
+      status: "recording"
+    };
+    this.actionCounter = 0;
+    try {
+      const adbCommand = platform === "android" ? getAdbCommandOrThrow() : null;
+      const flowPath = path.join(baseDir, "test.yaml");
+      this.session.flowPath = flowPath;
+      const videoPath = path.join(baseDir, "recording.mp4");
+      this.session.videoPath = videoPath;
+      const maestroHomePath = path.join(os.homedir(), ".maestro", "bin", "maestro");
+      const maestroPath = fs.existsSync(maestroHomePath) ? maestroHomePath : "maestro";
+      const maestroExists = fs.existsSync(maestroHomePath) || this.isMaestroInPath();
+      const maestroRunnable = maestroExists && this.canRunMaestro(maestroPath);
+      const preferNativeRecord = options.preferNativeRecord !== false;
+      const useNativeRecord = preferNativeRecord && this.useNativeMaestroRecord && maestroRunnable;
+      if (!maestroRunnable && this.useNativeMaestroRecord) {
+        console.log("[MaestroRecorder] \u26A0\uFE0F Maestro CLI not available or not runnable. Falling back to screenshot-based capture.");
+        console.log('[MaestroRecorder] Ensure Java is installed or reinstall Maestro: curl -Ls "https://get.maestro.mobile.dev" | bash');
+        this.session.captureModeReason = "Maestro CLI indispon\xEDvel/n\xE3o execut\xE1vel (verifique Java e reinstale o Maestro).";
+      }
+      if (!preferNativeRecord) {
+        console.log("[MaestroRecorder] Native record disabled for this session (manual capture mode).");
+        this.session.captureModeReason = "Native Maestro record desabilitado para esta sess\xE3o.";
+      }
+      let nativeRecordStarted = false;
+      this.legacyCaptureStarted = false;
+      if (useNativeRecord) {
+        console.log("[MaestroRecorder] Starting native maestro record...");
+        this.lastMaestroRecordErrorLine = null;
+        try {
+          const recordArgs = ["record", flowPath, "--device", deviceId];
+          this.maestroRecordProcess = spawn(maestroPath, recordArgs, {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env }
+          });
+          nativeRecordStarted = true;
+          this.maestroRecordProcess.stdout?.on("data", (data) => {
+            console.log("[MaestroRecord]", data.toString().trim());
+          });
+          this.maestroRecordProcess.stderr?.on("data", (data) => {
+            const text = data.toString().trim();
+            console.log("[MaestroRecord ERROR]", text);
+            const lastLine = text.split("\n").map((line) => line.trim()).filter(Boolean).pop();
+            if (lastLine) {
+              this.lastMaestroRecordErrorLine = lastLine;
+            }
+          });
+          this.maestroRecordProcess.on("error", (err) => {
+            console.log("[MaestroRecord] Spawn error:", err.message);
+            this.fallbackToLegacyCapture("spawn error");
+            this.maestroRecordProcess = null;
+          });
+          this.maestroRecordProcess.on("close", (code) => {
+            console.log(`[MaestroRecord] Process exited with code ${code}`);
+            this.fallbackToLegacyCapture(`exit code ${code}`);
+            this.maestroRecordProcess = null;
+          });
+        } catch (err) {
+          console.log("[MaestroRecorder] Failed to start native record, using legacy capture");
+          this.maestroRecordProcess = null;
+          nativeRecordStarted = false;
+          this.session.captureModeReason = err instanceof Error ? `Falha ao iniciar maestro record: ${err.message}` : "Falha ao iniciar maestro record";
+        }
+      }
+      this.session.captureMode = nativeRecordStarted ? "native" : "manual";
+      if (nativeRecordStarted) {
+        this.session.captureModeReason = void 0;
+      }
+      if (!nativeRecordStarted && this.session.flowPath) {
+        try {
+          const initialYaml = this.generateFlowYaml();
+          await fs.promises.writeFile(this.session.flowPath, initialYaml);
+        } catch (error) {
+          console.error("[MaestroRecorder] Failed to write initial flow YAML:", error);
+        }
+      }
+      await this.writeSessionMetadata();
+      if (nativeRecordStarted) {
+        if (platform === "ios") {
+          this.videoProcess = spawn("xcrun", ["simctl", "io", deviceId, "recordVideo", videoPath]);
+        } else {
+          const tempVideoPath = "/sdcard/maestro-recording.mp4";
+          this.videoProcess = spawn(adbCommand, ["-s", deviceId, "shell", "screenrecord", "--time-limit", "180", tempVideoPath]);
+        }
+      } else {
+        if (useNativeRecord) {
+          console.log("[MaestroRecorder] Native record failed to start, using legacy capture");
+        }
+        if (platform === "android") {
+          const tempVideoPath = "/sdcard/maestro-recording.mp4";
+          this.videoProcess = spawn(adbCommand, ["-s", deviceId, "shell", "screenrecord", "--time-limit", "180", tempVideoPath]);
+          this.startLegacyCapture(deviceId, platform);
+        } else {
+          this.videoProcess = spawn("xcrun", ["simctl", "io", deviceId, "recordVideo", videoPath]);
+          this.startLegacyCapture(deviceId, platform);
+        }
+      }
+      this.currentScreenshotIntervalMs = this.baseScreenshotIntervalMs;
+      this.nextScreenshotAt = 0;
+      this.lastScreenshotHash = null;
+      this.unchangedScreenshotCount = 0;
+      this.screenshotInterval = setInterval(() => {
+        this.captureScreenshot(void 0, { reason: "periodic" });
+      }, 2e3);
+      this.savePendingSession();
+      this.emit("status", "recording");
+      return this.session;
+    } catch (error) {
+      this.session.status = "error";
+      this.clearPendingSession();
+      this.emit("error", error);
+      throw error;
+    }
+  }
+  /**
+   * Capture Android touch events via ADB
+   */
+  startAndroidEventCapture(deviceId) {
+    const adbCommand = getAdbCommand();
+    if (!adbCommand) {
+      console.error("[MaestroRecorder] ADB not found. Android event capture is unavailable.");
+      return;
+    }
+    exec(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(deviceId)} shell wm size`, (err, stdout) => {
+      if (err) return;
+      const match = stdout.match(/(\d+)x(\d+)/);
+      const screenWidth = match ? parseInt(match[1]) : 1080;
+      const screenHeight = match ? parseInt(match[2]) : 1920;
+      this.adbProcess = spawn(adbCommand, ["-s", deviceId, "shell", "getevent", "-lt"]);
+      let touchStartTime = 0;
+      let touchStartX = 0;
+      let touchStartY = 0;
+      let currentX = 0;
+      let currentY = 0;
+      let isTracking = false;
+      this.adbProcess.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n");
+        for (const line of lines) {
+          if (line.includes("ABS_MT_POSITION_X")) {
+            const match2 = line.match(/ABS_MT_POSITION_X\s+([0-9a-f]+)/i);
+            if (match2) {
+              currentX = Math.round(parseInt(match2[1], 16) / 32767 * screenWidth);
+            }
+          }
+          if (line.includes("ABS_MT_POSITION_Y")) {
+            const match2 = line.match(/ABS_MT_POSITION_Y\s+([0-9a-f]+)/i);
+            if (match2) {
+              currentY = Math.round(parseInt(match2[1], 16) / 32767 * screenHeight);
+            }
+          }
+          if (line.includes("BTN_TOUCH") && line.includes("DOWN")) {
+            touchStartTime = Date.now();
+            touchStartX = currentX;
+            touchStartY = currentY;
+            isTracking = true;
+          }
+          if (line.includes("BTN_TOUCH") && line.includes("UP") && isTracking) {
+            const duration = Date.now() - touchStartTime;
+            const deltaX = Math.abs(currentX - touchStartX);
+            const deltaY = Math.abs(currentY - touchStartY);
+            if (deltaX > 50 || deltaY > 50) {
+              this.recordAction({
+                type: "swipe",
+                x: touchStartX,
+                y: touchStartY,
+                endX: currentX,
+                endY: currentY,
+                duration,
+                description: `Swipe from (${touchStartX}, ${touchStartY}) to (${currentX}, ${currentY})`
+              });
+            } else if (duration > 500) {
+              this.recordAction({
+                type: "longPress",
+                x: touchStartX,
+                y: touchStartY,
+                duration,
+                description: `Long press at (${touchStartX}, ${touchStartY})`
+              });
+            } else {
+              this.recordAction({
+                type: "tap",
+                x: touchStartX,
+                y: touchStartY,
+                description: `Tap at (${touchStartX}, ${touchStartY})`
+              });
+            }
+            isTracking = false;
+          }
+          if (line.includes("KEY_BACK") && line.includes("DOWN")) {
+            this.recordAction({
+              type: "back",
+              description: "Press back button"
+            });
+          }
+          if (line.includes("KEY_HOME") && line.includes("DOWN")) {
+            this.recordAction({
+              type: "home",
+              description: "Press home button"
+            });
+          }
+        }
+      });
+    });
+  }
+  /**
+   * Capture iOS events (limited - mainly screenshots)
+   */
+  startIOSEventCapture(deviceId) {
+    console.log("[MaestroRecorder] iOS event capture started (screenshot-based)");
+  }
+  /**
+   * Record an action
+   */
+  async recordAction(actionData) {
+    if (!this.session || this.session.status !== "recording") return;
+    this.actionCounter++;
+    const actionId = `action_${this.actionCounter.toString().padStart(3, "0")}`;
+    const screenshotPath = await this.captureScreenshot(actionId, { force: true, reason: "action" });
+    const action = {
+      id: actionId,
+      type: actionData.type || "tap",
+      timestamp: Date.now(),
+      x: actionData.x,
+      y: actionData.y,
+      endX: actionData.endX,
+      endY: actionData.endY,
+      text: actionData.text,
+      direction: actionData.direction,
+      seconds: actionData.seconds,
+      appId: actionData.appId,
+      duration: actionData.duration,
+      description: actionData.description || actionData.type || "Action",
+      screenshotPath
+    };
+    this.session.actions.push(action);
+    this.emit("action", action);
+    console.log("[MaestroRecorder] Action captured:", action.type, action.description);
+    if (action.type === "launch") {
+      const launchAppId = action.appId || action.text;
+      if (launchAppId && !this.session.appId) {
+        this.session.appId = launchAppId;
+      }
+    }
+    const shouldWriteFlow = this.session.captureMode !== "native" || !this.maestroRecordProcess;
+    if (shouldWriteFlow && this.session.flowPath) {
+      try {
+        const flowYaml = this.generateFlowYaml();
+        await fs.promises.writeFile(this.session.flowPath, flowYaml);
+      } catch (error) {
+        console.error("[MaestroRecorder] Failed to update flow YAML during recording:", error);
+      }
+    }
+    await this.writeSessionMetadata();
+    this.savePendingSession();
+  }
+  /**
+   * Capture a screenshot
+   */
+  async captureScreenshot(name, options = {}) {
+    if (!this.session) return void 0;
+    const now = Date.now();
+    if (!options.force && now < this.nextScreenshotAt) {
+      return void 0;
+    }
+    const screenshotName = name ? `${name}.png` : `screenshot_${Date.now()}.png`;
+    const screenshotPath = path.join(this.session.screenshotsDir, screenshotName);
+    try {
+      if (this.session.platform === "android") {
+        const adbCommand = getAdbCommandOrThrow();
+        await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(this.session.deviceId)} exec-out screencap -p > "${screenshotPath}"`);
+      } else {
+        await execAsync(`xcrun simctl io ${this.session.deviceId} screenshot "${screenshotPath}"`);
+      }
+      const screenshotBuffer = await fs.promises.readFile(screenshotPath);
+      const screenshotHash = createHash("sha1").update(screenshotBuffer).digest("hex");
+      if (!options.force && this.lastScreenshotHash === screenshotHash) {
+        this.unchangedScreenshotCount += 1;
+        await fs.promises.unlink(screenshotPath);
+        if (this.unchangedScreenshotCount >= this.screenshotBackoffThreshold) {
+          this.currentScreenshotIntervalMs = Math.min(
+            this.currentScreenshotIntervalMs * 2,
+            this.maxScreenshotIntervalMs
+          );
+        }
+        this.nextScreenshotAt = now + this.currentScreenshotIntervalMs;
+        return void 0;
+      }
+      this.lastScreenshotHash = screenshotHash;
+      this.unchangedScreenshotCount = 0;
+      this.currentScreenshotIntervalMs = this.baseScreenshotIntervalMs;
+      this.nextScreenshotAt = now + this.currentScreenshotIntervalMs;
+      this.emit("screenshot", screenshotPath);
+      return screenshotPath;
+    } catch (error) {
+      console.error("Screenshot failed:", error);
+      return void 0;
+    }
+  }
+  /**
+   * Add a manual action (for iOS or user-initiated)
+   */
+  addManualAction(type, description, params) {
+    return this.recordAction({
+      type,
+      description,
+      ...params
+    });
+  }
+  /**
+   * Stop recording and generate outputs
+   */
+  async stopRecording() {
+    if (!this.session) throw new Error("No recording session");
+    this.session.status = "stopped";
+    this.session.endedAt = Date.now();
+    await killZombieMaestroProcesses();
+    if (this.adbProcess) {
+      this.adbProcess.kill();
+      this.adbProcess = null;
+    }
+    if (this.screenshotInterval) {
+      clearInterval(this.screenshotInterval);
+      this.screenshotInterval = null;
+    }
+    if (this.maestroRecordProcess) {
+      console.log("[MaestroRecorder] Stopping native maestro record...");
+      this.maestroRecordProcess.kill("SIGINT");
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          console.log("[MaestroRecorder] Timeout waiting for maestro record, forcing kill");
+          this.maestroRecordProcess?.kill("SIGKILL");
+          resolve();
+        }, 5e3);
+        this.maestroRecordProcess?.on("close", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      });
+      this.maestroRecordProcess = null;
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const recordedActions = this.session.actions;
+      let parsedActions = [];
+      if (this.session.flowPath && fs.existsSync(this.session.flowPath)) {
+        console.log("[MaestroRecorder] Reading generated YAML from:", this.session.flowPath);
+        try {
+          const yamlContent = await fs.promises.readFile(this.session.flowPath, "utf-8");
+          parsedActions = this.parseActionsFromYaml(yamlContent);
+          console.log(`[MaestroRecorder] Parsed ${parsedActions.length} actions from YAML`);
+          this.session.actions = this.mergeParsedActionsWithRecorded(parsedActions, recordedActions);
+        } catch (e) {
+          console.error("[MaestroRecorder] Failed to read/parse YAML:", e);
+        }
+      } else {
+        console.log("[MaestroRecorder] No YAML file found at:", this.session.flowPath);
+      }
+      const flowPath = this.session.flowPath || path.join(this.session.screenshotsDir, "..", "test.yaml");
+      if ((parsedActions.length === 0 || !fs.existsSync(flowPath)) && recordedActions.length > 0) {
+        const flowYaml = this.generateFlowYaml();
+        await fs.promises.writeFile(flowPath, flowYaml);
+        this.session.flowPath = flowPath;
+        this.session.actions = recordedActions;
+        console.log("[MaestroRecorder] Fallback YAML generated from recorded actions");
+      }
+    }
+    if (this.videoProcess) {
+      this.videoProcess.kill("SIGINT");
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      if (this.session.platform === "android" && this.session.videoPath) {
+        try {
+          const adbCommand = getAdbCommandOrThrow();
+          await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(this.session.deviceId)} pull /sdcard/maestro-recording.mp4 "${this.session.videoPath}"`);
+          await execAsync(`${quoteCommand2(adbCommand)} -s ${shellQuoteArg2(this.session.deviceId)} shell rm /sdcard/maestro-recording.mp4`);
+        } catch (e) {
+          console.error("Failed to pull video:", e);
+        }
+      }
+      this.videoProcess = null;
+    }
+    if (!this.session.flowPath || !fs.existsSync(this.session.flowPath)) {
+      if (this.session.actions.length > 0) {
+        const flowYaml = this.generateFlowYaml();
+        const fallbackFlowPath = path.join(this.session.screenshotsDir, "..", "test.yaml");
+        await fs.promises.writeFile(fallbackFlowPath, flowYaml);
+        this.session.flowPath = fallbackFlowPath;
+        console.log("[MaestroRecorder] Generated flow YAML from recorded actions");
+      }
+    }
+    const metadataPath = path.join(this.session.screenshotsDir, "..", "session.json");
+    await fs.promises.writeFile(metadataPath, JSON.stringify(this.session, null, 2));
+    this.clearPendingSession();
+    this.emit("status", "stopped");
+    this.emit("stopped", this.session);
+    const result = this.session;
+    this.session = null;
+    return result;
+  }
+  /**
+   * Parse actions from Maestro YAML content
+   */
+  parseActionsFromYaml(yamlContent) {
+    const actions = [];
+    const lines = yamlContent.split("\n");
+    let currentAction = null;
+    let actionIndex = 0;
+    const nextId = () => `action_${String(++actionIndex).padStart(3, "0")}`;
+    const cleanValue = (value) => value.trim().replace(/^["']|["']$/g, "");
+    const pushAction = (action) => {
+      actions.push({
+        id: action.id || nextId(),
+        type: action.type || "tap",
+        timestamp: action.timestamp || Date.now(),
+        description: action.description || action.type || "Action",
+        x: action.x,
+        y: action.y,
+        endX: action.endX,
+        endY: action.endY,
+        text: action.text,
+        direction: action.direction,
+        seconds: action.seconds,
+        appId: action.appId,
+        duration: action.duration,
+        screenshotPath: action.screenshotPath
+      });
+    };
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#") || trimmed === "" || trimmed === "---") {
+        continue;
+      }
+      if (trimmed.startsWith("appId:")) {
+        const parsedAppId = cleanValue(trimmed.replace("appId:", ""));
+        if (this.session && parsedAppId && !this.session.appId) {
+          this.session.appId = parsedAppId;
+        }
+        continue;
+      }
+      if (trimmed.startsWith("- tapOn:")) {
+        const inlineValue = cleanValue(trimmed.replace("- tapOn:", ""));
+        if (inlineValue) {
+          pushAction({
+            type: "tap",
+            description: `Tap on "${inlineValue}"`,
+            text: inlineValue
+          });
+          continue;
+        }
+        currentAction = { type: "tap", description: "Tap" };
+      } else if (trimmed.startsWith("- tap:")) {
+        currentAction = { type: "tap", description: "Tap" };
+      } else if (trimmed.startsWith("- swipe:")) {
+        currentAction = { type: "swipe", description: "Swipe" };
+      } else if (trimmed.startsWith("- scroll:")) {
+        currentAction = { type: "scroll", description: "Scroll" };
+      } else if (trimmed.startsWith("- scrollUntilVisible:")) {
+        currentAction = { type: "scroll", description: "Scroll" };
+      } else if (trimmed.startsWith("- inputText:")) {
+        const text = cleanValue(trimmed.replace("- inputText:", ""));
+        pushAction({
+          type: "input",
+          description: `Input: ${text.slice(0, 20)}${text.length > 20 ? "..." : ""}`,
+          text
+        });
+        continue;
+      } else if (trimmed.startsWith("- launchApp:")) {
+        const appId = cleanValue(trimmed.replace("- launchApp:", ""));
+        pushAction({
+          type: "launch",
+          description: `Launch: ${appId}`,
+          text: appId,
+          appId
+        });
+        continue;
+      } else if (trimmed === "- launchApp") {
+        pushAction({
+          type: "launch",
+          description: "Launch app"
+        });
+        continue;
+      } else if (trimmed.startsWith("- assertVisible:")) {
+        const inlineValue = cleanValue(trimmed.replace("- assertVisible:", ""));
+        if (inlineValue) {
+          pushAction({
+            type: "assert",
+            description: `Assert visible "${inlineValue}"`,
+            text: inlineValue
+          });
+          continue;
+        }
+        currentAction = { type: "assert", description: "Assert visible" };
+      } else if (trimmed.startsWith("- extendedWaitUntil:")) {
+        currentAction = { type: "wait", description: "Wait" };
+      } else if (trimmed.startsWith("- pressKey:")) {
+        const key = cleanValue(trimmed.replace("- pressKey:", "")).toLowerCase();
+        if (key === "back") {
+          pushAction({ type: "back", description: "Back button" });
+        } else if (key === "home") {
+          pushAction({ type: "home", description: "Home button" });
+        } else {
+          pushAction({
+            type: "pressKey",
+            description: `Press: ${key}`,
+            text: key
+          });
+        }
+        continue;
+      } else if (trimmed.startsWith("- back")) {
+        pushAction({ type: "back", description: "Back button" });
+        continue;
+      }
+      if (currentAction && trimmed.startsWith("point:")) {
+        const point = cleanValue(trimmed.replace("point:", ""));
+        const [x, y] = point.split(",").map((n) => parseInt(n.trim()));
+        if (!isNaN(x) && !isNaN(y)) {
+          currentAction.x = x;
+          currentAction.y = y;
+          currentAction.description = `Tap at (${x}, ${y})`;
+          pushAction(currentAction);
+          currentAction = null;
+          continue;
+        }
+      }
+      if (currentAction && trimmed.startsWith("text:")) {
+        const text = cleanValue(trimmed.replace("text:", ""));
+        currentAction.text = text;
+        if (currentAction.type === "assert") {
+          currentAction.description = `Assert visible "${text}"`;
+        } else {
+          currentAction.description = `Tap on "${text}"`;
+        }
+        pushAction(currentAction);
+        currentAction = null;
+        continue;
+      }
+      if (currentAction && trimmed.startsWith("id:")) {
+        const id = cleanValue(trimmed.replace("id:", ""));
+        currentAction.text = id;
+        currentAction.description = `Tap on id: ${id}`;
+        pushAction(currentAction);
+        currentAction = null;
+        continue;
+      }
+      if (currentAction && (currentAction.type === "swipe" || currentAction.type === "scroll") && trimmed.startsWith("direction:")) {
+        const direction = cleanValue(trimmed.replace("direction:", "")).toLowerCase();
+        currentAction.direction = direction;
+        currentAction.description = currentAction.type === "swipe" ? `Swipe ${direction}` : `Scroll ${direction}`;
+        pushAction(currentAction);
+        currentAction = null;
+        continue;
+      }
+      if (currentAction && currentAction.type === "wait" && trimmed.startsWith("timeout:")) {
+        const timeoutMs = parseInt(cleanValue(trimmed.replace("timeout:", "")), 10);
+        const seconds = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.max(1, Math.round(timeoutMs / 1e3)) : 3;
+        currentAction.seconds = seconds;
+        currentAction.description = `Wait ${seconds}s`;
+        pushAction(currentAction);
+        currentAction = null;
+        continue;
+      }
+      if (currentAction && currentAction.type === "swipe") {
+        if (trimmed.startsWith("start:")) {
+          const point = cleanValue(trimmed.replace("start:", ""));
+          const [x, y] = point.split(",").map((n) => parseInt(n.trim()));
+          if (!isNaN(x) && !isNaN(y)) {
+            currentAction.x = x;
+            currentAction.y = y;
+          }
+        } else if (trimmed.startsWith("end:")) {
+          const point = cleanValue(trimmed.replace("end:", ""));
+          const [x, y] = point.split(",").map((n) => parseInt(n.trim()));
+          if (!isNaN(x) && !isNaN(y)) {
+            currentAction.endX = x;
+            currentAction.endY = y;
+            currentAction.description = `Swipe from (${currentAction.x}, ${currentAction.y}) to (${x}, ${y})`;
+            pushAction(currentAction);
+            currentAction = null;
+          }
+        }
+      }
+    }
+    return actions;
+  }
+  mergeParsedActionsWithRecorded(parsedActions, recordedActions) {
+    if (parsedActions.length === 0) return recordedActions;
+    if (recordedActions.length === 0) return parsedActions;
+    const recordedWithScreens = recordedActions.filter((action) => action.screenshotPath);
+    if (recordedWithScreens.length === 0) return parsedActions;
+    const shouldMapScreenshot = (action) => action.type === "tap" || action.type === "swipe" || action.type === "scroll" || action.type === "longPress" || action.type === "back" || action.type === "home" || action.type === "assert" || action.type === "wait";
+    let recordedIndex = 0;
+    return parsedActions.map((action) => {
+      if (!shouldMapScreenshot(action) || recordedIndex >= recordedWithScreens.length) {
+        return action;
+      }
+      const recorded = recordedWithScreens[recordedIndex++];
+      return {
+        ...recorded,
+        ...action,
+        id: recorded.id || action.id,
+        screenshotPath: recorded.screenshotPath,
+        x: action.x ?? recorded.x,
+        y: action.y ?? recorded.y,
+        endX: action.endX ?? recorded.endX,
+        endY: action.endY ?? recorded.endY,
+        text: action.text ?? recorded.text,
+        direction: action.direction ?? recorded.direction,
+        seconds: action.seconds ?? recorded.seconds,
+        appId: action.appId ?? recorded.appId,
+        duration: action.duration ?? recorded.duration,
+        timestamp: recorded.timestamp || action.timestamp,
+        description: action.description || recorded.description,
+        type: action.type
+      };
+    });
+  }
+  /**
+   * Generate Maestro YAML from recorded actions
+   */
+  generateFlowYaml() {
+    if (!this.session) return "";
+    const escapeYaml = (value) => value.replace(/"/g, '\\"');
+    const lines = [
+      `# Maestro Flow: ${this.session.name}`,
+      `# Recorded: ${new Date(this.session.startedAt).toISOString()}`,
+      `# Generated by DiscoveryLab`,
+      ``
+    ];
+    if (this.session.appId) {
+      lines.push(`appId: ${this.session.appId}`);
+      lines.push(``);
+    }
+    lines.push(`---`);
+    lines.push(``);
+    for (const action of this.session.actions) {
+      lines.push(`# ${action.description}`);
+      switch (action.type) {
+        case "tap":
+          if (action.text) {
+            lines.push(`- tapOn:`);
+            lines.push(`    text: "${escapeYaml(action.text)}"`);
+          } else if (action.x !== void 0 && action.y !== void 0) {
+            lines.push(`- tapOn:`);
+            lines.push(`    point: "${action.x},${action.y}"`);
+          }
+          break;
+        case "swipe":
+          if (action.x !== void 0 && action.y !== void 0 && action.endX !== void 0 && action.endY !== void 0) {
+            lines.push(`- swipe:`);
+            lines.push(`    start: "${action.x},${action.y}"`);
+            lines.push(`    end: "${action.endX},${action.endY}"`);
+            if (action.duration) {
+              lines.push(`    duration: ${action.duration}`);
+            }
+          } else if (action.direction) {
+            lines.push(`- swipe:`);
+            lines.push(`    direction: "${action.direction.toUpperCase()}"`);
+          }
+          break;
+        case "longPress":
+          if (action.x !== void 0 && action.y !== void 0) {
+            lines.push(`- longPressOn:`);
+            lines.push(`    point: "${action.x},${action.y}"`);
+          }
+          break;
+        case "input":
+          if (action.text) {
+            lines.push(`- inputText: "${escapeYaml(action.text)}"`);
+          }
+          break;
+        case "back":
+          lines.push(`- pressKey: back`);
+          break;
+        case "home":
+          lines.push(`- pressKey: home`);
+          break;
+        case "scroll":
+          if (action.direction && action.direction.toLowerCase() === "down") {
+            lines.push(`- scrollUntilVisible:`);
+            lines.push(`    element: ".*"`);
+            lines.push(`    direction: "DOWN"`);
+          } else {
+            lines.push(`- scroll`);
+          }
+          break;
+        case "launch": {
+          const launchAppId = action.appId || action.text;
+          if (launchAppId) {
+            lines.push(`- launchApp: "${escapeYaml(launchAppId)}"`);
+            if (!this.session.appId) {
+              this.session.appId = launchAppId;
+            }
+          } else {
+            lines.push(`- launchApp`);
+          }
+          break;
+        }
+        case "assert":
+          if (action.text) {
+            lines.push(`- assertVisible:`);
+            lines.push(`    text: "${escapeYaml(action.text)}"`);
+          }
+          break;
+        case "wait": {
+          const seconds = action.seconds && action.seconds > 0 ? Math.round(action.seconds) : 3;
+          lines.push(`- extendedWaitUntil:`);
+          lines.push(`    visible: ".*"`);
+          lines.push(`    timeout: ${seconds * 1e3}`);
+          break;
+        }
+        default:
+          lines.push(`# Unknown action: ${action.type}`);
+      }
+      lines.push(``);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Check if recording is active
+   */
+  isRecording() {
+    return this.session?.status === "recording";
+  }
+};
+var maestroRecorderInstance = null;
+function getMaestroRecorder() {
+  if (!maestroRecorderInstance) {
+    maestroRecorderInstance = new MaestroRecorder();
+  }
+  return maestroRecorderInstance;
+}
+
+export {
+  findAndroidSdkPath,
+  getEmulatorPath,
+  getAdbCommand,
+  listConnectedAndroidDevices,
+  resolveAndroidDeviceSerial,
+  isMaestroInstalled,
+  isIdbInstalled,
+  tapViaIdb,
+  killZombieMaestroProcesses,
+  getMaestroVersion,
+  listMaestroDevices,
+  generateMaestroFlow,
+  runMaestroTest,
+  runMaestroWithCapture,
+  startMaestroStudio,
+  createLoginFlow,
+  createOnboardingFlow,
+  createNavigationTestFlow,
+  getMaestroRecorder
+};