@veolab/discoverylab 1.2.1 → 1.3.0

package/dist/chunk-PYUCY3U6.js

@@ -1,1340 +0,0 @@
-import {
-  PROJECTS_DIR
-} from "./chunk-TJ3H23LL.js";
-
-// src/core/testing/maestro.ts
-import { exec, execSync, 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);
-function quoteCommand(cmd) {
-  return cmd.includes(" ") ? `"${cmd}"` : cmd;
-}
-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;
-}
-async function resolveMaestroCommand() {
-  for (const candidate of getMaestroCommandCandidates()) {
-    try {
-      const cmd = quoteCommand(candidate);
-      await execAsync(`${cmd} --version`);
-      return candidate;
-    } catch {
-    }
-  }
-  return 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 = quoteCommand(command);
-    const { stdout } = await execAsync(`${cmd} --version`);
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-async function listMaestroDevices() {
-  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 { stdout: androidOutput } = await execAsync("adb 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 {
-  }
-  return devices;
-}
-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 = quoteCommand(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 { stdout, stderr } = await execAsync(`${maestroCmd} ${args.join(" ")}`, {
-      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") {
-        recordingProcess = spawn("adb", ["-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") {
-        await execAsync(`adb -s ${device} pull /sdcard/recording.mp4 "${videoPath}"`);
-        await execAsync(`adb -s ${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 {
-      execSync("which maestro", { encoding: "utf-8", timeout: 2e3 });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  canRunMaestro(cmd) {
-    try {
-      execSync(`"${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 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("adb", ["-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("adb", ["-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) {
-    exec(`adb -s ${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("adb", ["-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") {
-        await execAsync(`adb -s ${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 {
-          await execAsync(`adb -s ${this.session.deviceId} pull /sdcard/maestro-recording.mp4 "${this.session.videoPath}"`);
-          await execAsync(`adb -s ${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 {
-  isMaestroInstalled,
-  isIdbInstalled,
-  tapViaIdb,
-  killZombieMaestroProcesses,
-  getMaestroVersion,
-  listMaestroDevices,
-  generateMaestroFlow,
-  runMaestroTest,
-  runMaestroWithCapture,
-  startMaestroStudio,
-  createLoginFlow,
-  createOnboardingFlow,
-  createNavigationTestFlow,
-  getMaestroRecorder
-};