@veolab/discoverylab 1.2.1 → 1.3.0

package/dist/{chunk-TAODYZ52.js → chunk-3QRQEDWR.js}

@@ -1,9 +1,231 @@
 import {
-  PROJECTS_DIR
-} from "./chunk-TJ3H23LL.js";
+  PROJECTS_DIR,
+  TEMPLATES_DIR
+} from "./chunk-VVIOB362.js";
+
+// src/core/templates/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var MANIFEST_FILE = "manifest.json";
+var BUNDLE_DIR = "bundle";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var BUNDLED_TEMPLATES_DIR = join(__dirname, "..", "..", "templates");
+var cachedManifest = null;
+var cachedTemplatesDir = null;
+var cachedAt = 0;
+var CACHE_TTL = 3e4;
+function resolveTemplatesDir() {
+  const localManifest = join(TEMPLATES_DIR, MANIFEST_FILE);
+  const localBundle = join(TEMPLATES_DIR, BUNDLE_DIR);
+  if (existsSync(localManifest) && existsSync(localBundle)) {
+    return TEMPLATES_DIR;
+  }
+  const bundledManifest = join(BUNDLED_TEMPLATES_DIR, MANIFEST_FILE);
+  const bundledBundle = join(BUNDLED_TEMPLATES_DIR, BUNDLE_DIR);
+  if (existsSync(bundledManifest) && existsSync(bundledBundle)) {
+    return BUNDLED_TEMPLATES_DIR;
+  }
+  return null;
+}
+function loadManifest() {
+  const now = Date.now();
+  if (cachedManifest && now - cachedAt < CACHE_TTL) {
+    return cachedManifest;
+  }
+  const dir = resolveTemplatesDir();
+  if (!dir) {
+    cachedManifest = null;
+    cachedTemplatesDir = null;
+    cachedAt = now;
+    return null;
+  }
+  try {
+    const raw = readFileSync(join(dir, MANIFEST_FILE), "utf-8");
+    const manifest = JSON.parse(raw);
+    cachedManifest = manifest;
+    cachedTemplatesDir = dir;
+    cachedAt = now;
+    return manifest;
+  } catch {
+    cachedManifest = null;
+    cachedTemplatesDir = null;
+    cachedAt = now;
+    return null;
+  }
+}
+function isTemplatesInstalled() {
+  return loadManifest() !== null;
+}
+function getAvailableTemplates() {
+  const manifest = loadManifest();
+  return manifest?.templates ?? [];
+}
+function getTemplate(id) {
+  const templates = getAvailableTemplates();
+  return templates.find((t) => t.id === id) ?? null;
+}
+function getBundlePath() {
+  loadManifest();
+  if (!cachedTemplatesDir) return null;
+  const bundlePath = join(cachedTemplatesDir, BUNDLE_DIR);
+  if (!existsSync(bundlePath)) return null;
+  return bundlePath;
+}
+
+// src/core/android/adb.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } 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 (existsSync2(join2(envPath, "platform-tools", "adb"))) {
+      return envPath;
+    }
+  }
+  const home = homedir();
+  const commonPaths = [
+    join2(home, "Library", "Android", "sdk"),
+    join2(home, "Android", "Sdk"),
+    "/opt/android-sdk",
+    "/usr/local/android-sdk"
+  ];
+  for (const sdkPath of commonPaths) {
+    if (existsSync2(join2(sdkPath, "platform-tools", "adb"))) {
+      return sdkPath;
+    }
+  }
+  return null;
+}
+function getAdbPath() {
+  const sdkPath = findAndroidSdkPath();
+  if (!sdkPath) return null;
+  const adbPath = join2(sdkPath, "platform-tools", "adb");
+  return existsSync2(adbPath) ? adbPath : null;
+}
+function getEmulatorPath() {
+  const sdkPath = findAndroidSdkPath();
+  if (!sdkPath) return null;
+  const emulatorPath = join2(sdkPath, "emulator", "emulator");
+  return existsSync2(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 (!existsSync2(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, spawn } from "child_process";
+import { exec, execSync as execSync2, spawn } from "child_process";
 import { promisify } from "util";
 import * as fs from "fs";
 import * as path from "path";
@@ -18,14 +240,21 @@ var maestroCommandCache = null;
 var maestroCommandResolveInFlight = null;
 var maestroDeviceListCache = null;
 var maestroDeviceListInFlight = null;
-function quoteCommand(cmd) {
+function quoteCommand2(cmd) {
   return cmd.includes(" ") ? `"${cmd}"` : cmd;
 }
-function shellQuoteArg(value) {
+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");
@@ -59,7 +288,7 @@ async function resolveMaestroCommand(options) {
   maestroCommandResolveInFlight = (async () => {
     for (const candidate of getMaestroCommandCandidates()) {
       try {
-        const cmd = quoteCommand(candidate);
+        const cmd = quoteCommand2(candidate);
         await execAsync(`${cmd} --version`);
         maestroCommandCache = { value: candidate, checkedAt: Date.now() };
         return candidate;
@@ -114,7 +343,7 @@ async function getMaestroVersion() {
   try {
     const command = await resolveMaestroCommand();
     if (!command) return null;
-    const cmd = quoteCommand(command);
+    const cmd = quoteCommand2(command);
     const { stdout } = await execAsync(`${cmd} --version`);
     return stdout.trim();
   } catch {
@@ -152,19 +381,22 @@ async function listMaestroDevices(options) {
     } 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"
-          });
+      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 {
@@ -320,7 +552,7 @@ async function runMaestroTest(options) {
   await fs.promises.mkdir(outputDir, { recursive: true });
   const startTime = Date.now();
   const args = ["test", flowPath];
-  const maestroCmd = quoteCommand(command);
+  const maestroCmd = quoteCommand2(command);
   if (device) {
     args.push("--device", device);
   }
@@ -330,7 +562,7 @@ async function runMaestroTest(options) {
   args.push("--format", "junit");
   args.push("--output", path.join(outputDir, "report.xml"));
   try {
-    const shellArgs = args.map(shellQuoteArg).join(" ");
+    const shellArgs = args.map(shellQuoteArg2).join(" ");
     const { stdout, stderr } = await execAsync(`${maestroCmd} ${shellArgs}`, {
       timeout,
       env: { ...process.env, ...env }
@@ -387,7 +619,8 @@ async function runMaestroWithCapture(options, onProgress) {
       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"]);
+        const adbCommand = getAdbCommandOrThrow();
+        recordingProcess = spawn(adbCommand, ["-s", device, "shell", "screenrecord", "/sdcard/recording.mp4"]);
       }
     }
     onProgress?.("Running Maestro test...");
@@ -399,8 +632,9 @@ async function runMaestroWithCapture(options, onProgress) {
       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`);
+        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 {
@@ -499,6 +733,212 @@ function createNavigationTestFlow(appId, tabs) {
     steps
   };
 }
+function parseMaestroActionsFromYaml(yamlContent) {
+  const actions = [];
+  const lines = yamlContent.split("\n");
+  let currentAction = null;
+  let actionIndex = 0;
+  const nextId = () => `action_${String(++actionIndex).padStart(3, "0")}`;
+  const stripInlineComment = (value) => {
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+      const char = value[index];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"' && !inSingle) {
+        inDouble = !inDouble;
+        continue;
+      }
+      if (char === "'" && !inDouble) {
+        inSingle = !inSingle;
+        continue;
+      }
+      if (char === "#" && !inSingle && !inDouble) {
+        return value.slice(0, index).trimEnd();
+      }
+    }
+    return value;
+  };
+  const cleanValue = (value) => stripInlineComment(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:")) {
+      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;
+}
 var MaestroRecorder = class extends EventEmitter {
   session = null;
   adbProcess = null;
@@ -527,7 +967,7 @@ var MaestroRecorder = class extends EventEmitter {
    */
   isMaestroInPath() {
     try {
-      execSync("which maestro", { encoding: "utf-8", timeout: 2e3 });
+      execSync2("which maestro", { encoding: "utf-8", timeout: 2e3 });
       return true;
     } catch {
       return false;
@@ -535,7 +975,7 @@ var MaestroRecorder = class extends EventEmitter {
   }
   canRunMaestro(cmd) {
     try {
-      execSync(`"${cmd}" --version`, { encoding: "utf-8", timeout: 3e3 });
+      execSync2(`"${cmd}" --version`, { encoding: "utf-8", timeout: 3e3 });
       return true;
     } catch {
       return false;
@@ -652,6 +1092,7 @@ var MaestroRecorder = class extends EventEmitter {
     };
     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");
@@ -729,7 +1170,7 @@ var MaestroRecorder = class extends EventEmitter {
           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]);
+          this.videoProcess = spawn(adbCommand, ["-s", deviceId, "shell", "screenrecord", "--time-limit", "180", tempVideoPath]);
         }
       } else {
         if (useNativeRecord) {
@@ -737,7 +1178,7 @@ var MaestroRecorder = class extends EventEmitter {
         }
         if (platform === "android") {
           const tempVideoPath = "/sdcard/maestro-recording.mp4";
-          this.videoProcess = spawn("adb", ["-s", deviceId, "shell", "screenrecord", "--time-limit", "180", tempVideoPath]);
+          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]);
@@ -765,12 +1206,17 @@ var MaestroRecorder = class extends EventEmitter {
    * Capture Android touch events via ADB
    */
   startAndroidEventCapture(deviceId) {
-    exec(`adb -s ${deviceId} shell wm size`, (err, stdout) => {
+    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("adb", ["-s", deviceId, "shell", "getevent", "-lt"]);
+      this.adbProcess = spawn(adbCommand, ["-s", deviceId, "shell", "getevent", "-lt"]);
       let touchStartTime = 0;
       let touchStartX = 0;
       let touchStartY = 0;
@@ -910,7 +1356,8 @@ var MaestroRecorder = class extends EventEmitter {
     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}"`);
+        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}"`);
       }
@@ -1010,8 +1457,9 @@ var MaestroRecorder = class extends EventEmitter {
       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`);
+          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);
         }
@@ -1027,6 +1475,18 @@ var MaestroRecorder = class extends EventEmitter {
         console.log("[MaestroRecorder] Generated flow YAML from recorded actions");
       }
     }
+    if (this.session.actions.length === 0 && this.session.flowPath && fs.existsSync(this.session.flowPath)) {
+      try {
+        const fallbackYaml = await fs.promises.readFile(this.session.flowPath, "utf-8");
+        const parsedActions = parseMaestroActionsFromYaml(fallbackYaml);
+        if (parsedActions.length > 0) {
+          this.session.actions = parsedActions;
+          console.log(`[MaestroRecorder] Rehydrated ${parsedActions.length} actions from YAML for manual capture`);
+        }
+      } catch (error) {
+        console.error("[MaestroRecorder] Failed to rehydrate actions from YAML:", error);
+      }
+    }
     const metadataPath = path.join(this.session.screenshotsDir, "..", "session.json");
     await fs.promises.writeFile(metadataPath, JSON.stringify(this.session, null, 2));
     this.clearPendingSession();
@@ -1040,186 +1500,13 @@ var MaestroRecorder = class extends EventEmitter {
    * 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;
-          }
-        }
-      }
+    const parsedActions = parseMaestroActionsFromYaml(yamlContent);
+    const appIdMatch = yamlContent.match(/^\s*appId:\s*([^\n#]+)/m);
+    const parsedAppId = appIdMatch?.[1]?.trim().replace(/^["']|["']$/g, "") || "";
+    if (this.session && parsedAppId && !this.session.appId) {
+      this.session.appId = parsedAppId;
     }
-    return actions;
+    return parsedActions;
   }
   mergeParsedActionsWithRecorded(parsedActions, recordedActions) {
     if (parsedActions.length === 0) return recordedActions;
@@ -1376,6 +1663,15 @@ function getMaestroRecorder() {
 }
 
 export {
+  isTemplatesInstalled,
+  getAvailableTemplates,
+  getTemplate,
+  getBundlePath,
+  findAndroidSdkPath,
+  getEmulatorPath,
+  getAdbCommand,
+  listConnectedAndroidDevices,
+  resolveAndroidDeviceSerial,
   isMaestroInstalled,
   isIdbInstalled,
   tapViaIdb,
@@ -1389,5 +1685,6 @@ export {
   createLoginFlow,
   createOnboardingFlow,
   createNavigationTestFlow,
+  parseMaestroActionsFromYaml,
   getMaestroRecorder
 };