@veolab/discoverylab 1.2.1 → 1.3.0

package/dist/{chunk-L4SA5F5W.js → chunk-4L76GPRC.js}

@@ -1,15 +1,23 @@
+import {
+  createErrorResult,
+  createJsonResult,
+  createTextResult
+} from "./chunk-XKX6NBHF.js";
 import {
   createLoginFlow,
   createNavigationTestFlow,
   createOnboardingFlow,
   generateMaestroFlow,
+  getAdbCommand,
+  getAvailableTemplates,
   getMaestroVersion,
   isMaestroInstalled,
+  isTemplatesInstalled,
   listMaestroDevices,
   runMaestroTest,
   runMaestroWithCapture,
   startMaestroStudio
-} from "./chunk-GSWHWEYC.js";
+} from "./chunk-3QRQEDWR.js";
 import {
   createFormSubmissionScript,
   createLoginScript,
@@ -22,13 +30,33 @@ import {
   savePlaywrightScript,
   showPlaywrightReport,
   startPlaywrightCodegen
-} from "./chunk-43U6UYV7.js";
+} from "./chunk-FIL7IWEL.js";
 import {
-  analyzeText,
-  getAvailableOCREngines,
-  recognizeText,
-  recognizeTextBatch
-} from "./chunk-W3WJGYR6.js";
+  buildAppLabNetworkProfile
+} from "./chunk-LB3RNE3O.js";
+import {
+  attachESVPNetworkTrace,
+  captureESVPCheckpoint,
+  clearESVPNetwork,
+  configureESVPNetwork,
+  createESVPSession,
+  finishESVPSession,
+  getESVPArtifactContent,
+  getESVPConnection,
+  getESVPHealth,
+  getESVPReplayConsistency,
+  getESVPSession,
+  getESVPSessionNetwork,
+  getESVPTranscript,
+  inspectESVPSession,
+  listESVPArtifacts,
+  listESVPDevices,
+  listESVPSessions,
+  replayESVPSession,
+  runESVPActions,
+  runESVPPreflight,
+  validateESVPReplay
+} from "./chunk-GAKEFJ5T.js";
 import {
   DATA_DIR,
   EXPORTS_DIR,
@@ -39,12 +67,13 @@ import {
   projectExports,
   projects,
   testVariables
-} from "./chunk-TJ3H23LL.js";
+} from "./chunk-VVIOB362.js";
 import {
-  createErrorResult,
-  createJsonResult,
-  createTextResult
-} from "./chunk-QJXXHOV7.js";
+  analyzeText,
+  getAvailableOCREngines,
+  recognizeText,
+  recognizeTextBatch
+} from "./chunk-XFVDP332.js";
 
 // src/mcp/tools/ui.ts
 import { z } from "zod";
@@ -337,17 +366,17 @@ async function captureMacScreenshot(outputPath, options) {
     args.push("-R", `${x},${y},${width},${height}`);
   }
   args.push(outputPath);
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const proc = spawn("screencapture", args);
     proc.on("close", (code) => {
       if (code === 0 && existsSync(outputPath)) {
-        resolve({ success: true, filePath: outputPath });
+        resolve2({ success: true, filePath: outputPath });
       } else {
-        resolve({ success: false, error: `screencapture exited with code ${code}` });
+        resolve2({ success: false, error: `screencapture exited with code ${code}` });
       }
     });
     proc.on("error", (err) => {
-      resolve({ success: false, error: err.message });
+      resolve2({ success: false, error: err.message });
     });
   });
 }
@@ -356,16 +385,16 @@ async function captureLinuxScreenshot(outputPath, options) {
   if (options.windowId) {
     args.push("-w");
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let proc = spawn("gnome-screenshot", args);
     proc.on("error", () => {
       proc = spawn("scrot", [outputPath]);
     });
     proc.on("close", (code) => {
       if (code === 0 && existsSync(outputPath)) {
-        resolve({ success: true, filePath: outputPath });
+        resolve2({ success: true, filePath: outputPath });
       } else {
-        resolve({ success: false, error: `Screenshot failed with code ${code}` });
+        resolve2({ success: false, error: `Screenshot failed with code ${code}` });
       }
     });
   });
@@ -380,17 +409,17 @@ async function captureWindowsScreenshot(outputPath, _options) {
       $bitmap.Save('${outputPath.replace(/\\/g, "\\\\")}')
     }
   `;
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const proc = spawn("powershell", ["-Command", psScript]);
     proc.on("close", (code) => {
       if (code === 0 && existsSync(outputPath)) {
-        resolve({ success: true, filePath: outputPath });
+        resolve2({ success: true, filePath: outputPath });
       } else {
-        resolve({ success: false, error: `PowerShell screenshot failed with code ${code}` });
+        resolve2({ success: false, error: `PowerShell screenshot failed with code ${code}` });
       }
     });
     proc.on("error", (err) => {
-      resolve({ success: false, error: err.message });
+      resolve2({ success: false, error: err.message });
     });
   });
 }
@@ -497,7 +526,7 @@ async function stopRecording(sessionId) {
   if (!session) {
     return { success: false, error: `Recording session not found: ${sessionId}` };
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     if (session.process.stdin) {
       session.process.stdin.write("q");
       session.process.stdin.end();
@@ -510,13 +539,13 @@ async function stopRecording(sessionId) {
       activeRecordings.delete(sessionId);
       const duration = (Date.now() - session.startTime.getTime()) / 1e3;
       if (existsSync(session.outputPath)) {
-        resolve({
+        resolve2({
           success: true,
           filePath: session.outputPath,
           duration
         });
       } else {
-        resolve({ success: false, error: "Recording file not found" });
+        resolve2({ success: false, error: "Recording file not found" });
       }
     });
   });
@@ -645,7 +674,7 @@ async function captureIOSSimulatorScreenshot(options) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = `ios-screenshot-${timestamp}.png`;
   const outputPath = join2(projectDir, filename);
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const args = ["simctl", "io", options.deviceId, "screenshot", outputPath];
     const proc = spawn2("xcrun", args);
     let stderr = "";
@@ -654,13 +683,13 @@ async function captureIOSSimulatorScreenshot(options) {
     });
     proc.on("close", (code) => {
       if (code === 0 && existsSync2(outputPath)) {
-        resolve({ success: true, filePath: outputPath });
+        resolve2({ success: true, filePath: outputPath });
       } else {
-        resolve({ success: false, error: stderr || `xcrun simctl failed with code ${code}` });
+        resolve2({ success: false, error: stderr || `xcrun simctl failed with code ${code}` });
       }
     });
     proc.on("error", (err) => {
-      resolve({ success: false, error: err.message });
+      resolve2({ success: false, error: err.message });
     });
   });
 }
@@ -692,7 +721,7 @@ async function stopIOSSimulatorRecording(sessionId) {
   if (!session) {
     return { success: false, error: `Recording session not found: ${sessionId}` };
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     session.process.kill("SIGINT");
     const timeout = setTimeout(() => {
       session.process.kill("SIGKILL");
@@ -701,16 +730,30 @@ async function stopIOSSimulatorRecording(sessionId) {
       clearTimeout(timeout);
       iosRecordingSessions.delete(sessionId);
       if (existsSync2(session.outputPath)) {
-        resolve({ success: true, filePath: session.outputPath });
+        resolve2({ success: true, filePath: session.outputPath });
       } else {
-        resolve({ success: false, error: "Recording file not found" });
+        resolve2({ success: false, error: "Recording file not found" });
       }
     });
   });
 }
+function quoteCommand(cmd) {
+  return cmd.includes(" ") ? `"${cmd}"` : cmd;
+}
+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 listAndroidEmulators() {
   try {
-    const output = execSync2("adb devices -l", { encoding: "utf-8" });
+    const adbCommand = getAdbCommand();
+    if (!adbCommand) {
+      return [];
+    }
+    const output = execSync2(`${quoteCommand(adbCommand)} devices -l`, { encoding: "utf-8" });
     const lines = output.split("\n").slice(1);
     const devices3 = [];
     for (const line of lines) {
@@ -747,28 +790,35 @@ async function captureAndroidEmulatorScreenshot(options) {
   const filename = `android-screenshot-${timestamp}.png`;
   const outputPath = join2(projectDir, filename);
   const tempPath = "/sdcard/screenshot.png";
-  return new Promise((resolve) => {
-    const captureProc = spawn2("adb", ["-s", options.deviceId, "shell", "screencap", "-p", tempPath]);
+  return new Promise((resolve2) => {
+    let adbCommand;
+    try {
+      adbCommand = getAdbCommandOrThrow();
+    } catch (error) {
+      resolve2({ success: false, error: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    const captureProc = spawn2(adbCommand, ["-s", options.deviceId, "shell", "screencap", "-p", tempPath]);
     captureProc.on("close", (captureCode) => {
       if (captureCode !== 0) {
-        resolve({ success: false, error: `screencap failed with code ${captureCode}` });
+        resolve2({ success: false, error: `screencap failed with code ${captureCode}` });
         return;
       }
-      const pullProc = spawn2("adb", ["-s", options.deviceId, "pull", tempPath, outputPath]);
+      const pullProc = spawn2(adbCommand, ["-s", options.deviceId, "pull", tempPath, outputPath]);
       pullProc.on("close", (pullCode) => {
-        spawn2("adb", ["-s", options.deviceId, "shell", "rm", tempPath]);
+        spawn2(adbCommand, ["-s", options.deviceId, "shell", "rm", tempPath]);
         if (pullCode === 0 && existsSync2(outputPath)) {
-          resolve({ success: true, filePath: outputPath });
+          resolve2({ success: true, filePath: outputPath });
         } else {
-          resolve({ success: false, error: `adb pull failed with code ${pullCode}` });
+          resolve2({ success: false, error: `adb pull failed with code ${pullCode}` });
         }
       });
       pullProc.on("error", (err) => {
-        resolve({ success: false, error: err.message });
+        resolve2({ success: false, error: err.message });
       });
     });
     captureProc.on("error", (err) => {
-      resolve({ success: false, error: err.message });
+      resolve2({ success: false, error: err.message });
     });
   });
 }
@@ -782,14 +832,21 @@ async function startAndroidEmulatorRecording(options) {
   const filename = `android-recording-${timestamp}.mp4`;
   const outputPath = join2(projectDir, filename);
   const tempPath = "/sdcard/recording.mp4";
+  let adbCommand;
+  try {
+    adbCommand = getAdbCommandOrThrow();
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
   const args = ["-s", options.deviceId, "shell", "screenrecord"];
   if (options.duration) {
     args.push("--time-limit", Math.min(options.duration, 180).toString());
   }
   args.push(tempPath);
-  const proc = spawn2("adb", args, { stdio: ["pipe", "pipe", "pipe"] });
+  const proc = spawn2(adbCommand, args, { stdio: ["pipe", "pipe", "pipe"] });
   androidRecordingSessions.set(sessionId, {
     process: proc,
+    adbCommand,
     deviceId: options.deviceId,
     tempPath,
     outputPath
@@ -802,22 +859,22 @@ async function stopAndroidEmulatorRecording(sessionId) {
   if (!session) {
     return { success: false, error: `Recording session not found: ${sessionId}` };
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     session.process.kill("SIGINT");
     setTimeout(() => {
-      const pullProc = spawn2("adb", ["-s", session.deviceId, "pull", session.tempPath, session.outputPath]);
+      const pullProc = spawn2(session.adbCommand, ["-s", session.deviceId, "pull", session.tempPath, session.outputPath]);
       pullProc.on("close", (pullCode) => {
-        spawn2("adb", ["-s", session.deviceId, "shell", "rm", session.tempPath]);
+        spawn2(session.adbCommand, ["-s", session.deviceId, "shell", "rm", session.tempPath]);
         androidRecordingSessions.delete(sessionId);
         if (pullCode === 0 && existsSync2(session.outputPath)) {
-          resolve({ success: true, filePath: session.outputPath });
+          resolve2({ success: true, filePath: session.outputPath });
         } else {
-          resolve({ success: false, error: "Failed to pull recording file" });
+          resolve2({ success: false, error: "Failed to pull recording file" });
         }
       });
       pullProc.on("error", (err) => {
         androidRecordingSessions.delete(sessionId);
-        resolve({ success: false, error: err.message });
+        resolve2({ success: false, error: err.message });
       });
     }, 1e3);
   });
@@ -875,7 +932,9 @@ async function stopEmulatorRecording(sessionId, platformHint) {
 }
 function checkADB() {
   try {
-    execSync2("adb version", { stdio: "ignore" });
+    const adbCommand = getAdbCommand();
+    if (!adbCommand) return false;
+    execSync2(`${quoteCommand(adbCommand)} version`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -1197,7 +1256,7 @@ async function extractFrames(options) {
     return { success: false, error: "Failed to read video information" };
   }
   const args = buildFFmpegArgs(options, framesDir, videoInfo, outputFormat);
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const proc = spawn3("ffmpeg", args);
     let stderr = "";
     proc.stderr.on("data", (data) => {
@@ -1205,11 +1264,11 @@ async function extractFrames(options) {
     });
     proc.on("close", (code) => {
       if (code !== 0) {
-        resolve({ success: false, error: `FFmpeg failed: ${stderr.slice(-500)}` });
+        resolve2({ success: false, error: `FFmpeg failed: ${stderr.slice(-500)}` });
         return;
       }
       const frames2 = listExtractedFrames(framesDir, videoInfo.fps, options.fps || 1);
-      resolve({
+      resolve2({
         success: true,
         framesDir,
         frameCount: frames2.length,
@@ -1217,7 +1276,7 @@ async function extractFrames(options) {
       });
     });
     proc.on("error", (err) => {
-      resolve({ success: false, error: err.message });
+      resolve2({ success: false, error: err.message });
     });
   });
 }
@@ -2959,7 +3018,7 @@ function buildOverlayFilter(overlay) {
   return null;
 }
 async function runFFmpegWithProgress(args, onProgress) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const ffmpeg = spawn4("ffmpeg", args, { stdio: ["pipe", "pipe", "pipe"] });
     ffmpeg.stderr?.on("data", (data) => {
       const output = data.toString();
@@ -2981,7 +3040,7 @@ async function runFFmpegWithProgress(args, onProgress) {
     });
     ffmpeg.on("close", (code) => {
       if (code === 0) {
-        resolve();
+        resolve2();
       } else {
         reject(new Error(`FFmpeg exited with code ${code}`));
       }
@@ -6314,6 +6373,1025 @@ var taskHubTools = [
   taskHubTestMapToggleTool
 ];
 
+// src/mcp/tools/esvp.ts
+import { readFile } from "fs/promises";
+import { join as join13, resolve } from "path";
+import { z as z10 } from "zod";
+var jsonObjectSchema = z10.record(z10.string(), z10.any());
+var actionSchema = z10.object({
+  name: z10.string().min(1).describe("ESVP action name"),
+  args: jsonObjectSchema.optional().describe("Action arguments"),
+  checkpointAfter: z10.boolean().optional(),
+  checkpointLabel: z10.string().optional()
+});
+var crashClipSchema = z10.object({
+  enabled: z10.boolean().optional(),
+  pre_seconds: z10.number().optional(),
+  post_seconds: z10.number().optional(),
+  chunk_seconds: z10.number().optional()
+});
+var proxySchema = z10.object({
+  host: z10.string(),
+  port: z10.number(),
+  protocol: z10.string().optional(),
+  bypass: z10.array(z10.string()).optional()
+});
+var projectRecordingSchema = z10.object({
+  recordingId: z10.string().min(1).describe("Mobile recording / project ID inside ~/.discoverylab/projects/maestro-recordings")
+});
+var projectValidationProfileIdSchema = z10.enum([
+  "standard",
+  "app-http-trace",
+  "mitm-simulator",
+  "inject-503",
+  "timeout",
+  "delay-1200"
+]);
+var projectValidationNetworkSchema = z10.object({
+  enabled: z10.boolean().optional(),
+  mode: z10.enum(["managed-proxy", "external-proxy", "external-mitm", "app-http-trace"]).optional(),
+  profile: z10.string().optional(),
+  label: z10.string().optional(),
+  connectivity: z10.enum(["online", "offline", "reset"]).optional(),
+  proxy: jsonObjectSchema.optional(),
+  capture: jsonObjectSchema.optional(),
+  faults: jsonObjectSchema.optional()
+}).nullable();
+function getMobileRecordingDir(recordingId) {
+  return join13(PROJECTS_DIR, "maestro-recordings", recordingId);
+}
+function getMobileRecordingSessionPath(recordingId) {
+  return join13(getMobileRecordingDir(recordingId), "session.json");
+}
+async function readMobileRecordingSession(recordingId) {
+  const sessionPath = getMobileRecordingSessionPath(recordingId);
+  const raw = await readFile(sessionPath, "utf8").catch(() => null);
+  if (!raw) {
+    throw new Error(`Recording not found: ${recordingId}`);
+  }
+  return JSON.parse(raw);
+}
+function resolveProjectRecordingESVPState(session) {
+  return session?.esvp && typeof session.esvp === "object" ? session.esvp : null;
+}
+function resolveProjectRecordingESVPSourceSessionId(session) {
+  const esvp = resolveProjectRecordingESVPState(session);
+  if (!esvp) return null;
+  const validation = esvp.validation && typeof esvp.validation === "object" ? esvp.validation : null;
+  const network = esvp.network && typeof esvp.network === "object" ? esvp.network : null;
+  const validationId = typeof validation?.sourceSessionId === "string" ? validation.sourceSessionId.trim() : "";
+  const networkId = typeof network?.sourceSessionId === "string" ? network.sourceSessionId.trim() : "";
+  const directId = typeof esvp.currentSessionId === "string" ? esvp.currentSessionId.trim() : "";
+  return validationId || networkId || directId || null;
+}
+function resolveProjectRecordingReplaySessionId(session) {
+  const esvp = resolveProjectRecordingESVPState(session);
+  const validation = esvp?.validation && typeof esvp.validation === "object" ? esvp.validation : null;
+  const replayId = typeof validation?.replaySessionId === "string" ? validation.replaySessionId.trim() : "";
+  return replayId || null;
+}
+function resolveProjectRecordingESVPServerUrl(session) {
+  const esvp = resolveProjectRecordingESVPState(session);
+  if (!esvp || typeof esvp.serverUrl !== "string") return void 0;
+  const serverUrl = esvp.serverUrl.trim();
+  return serverUrl || void 0;
+}
+function resolveAppLabBaseUrl(appLabUrl) {
+  const raw = String(appLabUrl || process.env.DISCOVERYLAB_APP_URL || "http://127.0.0.1:3847").trim();
+  return raw.replace(/\/+$/, "");
+}
+async function callAppLabJson(path10, init = {}, appLabUrl) {
+  const baseUrl = resolveAppLabBaseUrl(appLabUrl);
+  const targetUrl = `${baseUrl}${path10.startsWith("/") ? path10 : `/${path10}`}`;
+  const response = await fetch(targetUrl, init).catch((error) => {
+    throw new Error(`Failed to reach App Lab at ${baseUrl}. Start the local App Lab server before using project-scoped ESVP tools. ${error instanceof Error ? error.message : String(error)}`);
+  });
+  const text = await response.text();
+  let payload = null;
+  if (text.trim()) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = { raw: text };
+    }
+  }
+  if (!response.ok) {
+    const message = payload?.error || payload?.message || `App Lab request failed (${response.status} ${response.statusText})`;
+    throw new Error(String(message));
+  }
+  return {
+    appLabUrl: baseUrl,
+    payload
+  };
+}
+function buildProjectValidationNetwork(profileId, network) {
+  if (network) return network;
+  switch (profileId) {
+    case "app-http-trace":
+      return {
+        enabled: true,
+        profile: "applab-app-http-trace",
+        label: "App Lab App HTTP Trace",
+        mode: "app-http-trace"
+      };
+    case "mitm-simulator":
+      return {
+        enabled: true,
+        profile: "applab-mitm-beta",
+        label: "App Lab MITM Beta",
+        mode: "external-mitm"
+      };
+    case "inject-503":
+      return {
+        enabled: true,
+        profile: "applab-inject-503",
+        label: "App Lab Inject 503",
+        mode: "managed-proxy",
+        faults: {
+          status_code: 503,
+          body_patch: {
+            error: "Injected by ESVP"
+          }
+        }
+      };
+    case "timeout":
+      return {
+        enabled: true,
+        profile: "applab-timeout",
+        label: "App Lab Timeout",
+        mode: "managed-proxy",
+        faults: {
+          timeout: true
+        }
+      };
+    case "delay-1200":
+      return {
+        enabled: true,
+        profile: "applab-delay-1200",
+        label: "App Lab Delay 1200ms",
+        mode: "managed-proxy",
+        faults: {
+          delay_ms: 1200
+        }
+      };
+    case "standard":
+    default:
+      return {
+        enabled: true,
+        profile: "applab-standard",
+        label: "App Lab Standard Capture",
+        mode: "external-proxy"
+      };
+  }
+}
+function resolveDefaultDeviceId(executor) {
+  if (executor === "fake") return void 0;
+  const wantedPlatform = executor === "ios-sim" || executor === "maestro-ios" ? "ios" : "android";
+  const booted = listAllEmulators().find(
+    (device) => device.platform === wantedPlatform && device.state === "booted"
+  );
+  return booted?.id;
+}
+function executorToPlatform(executor) {
+  if (executor === "ios-sim" || executor === "maestro-ios") return "ios";
+  if (executor === "adb") return "android";
+  return void 0;
+}
+async function makeBaseResult(serverUrl) {
+  const connection = await getESVPConnection(serverUrl);
+  return {
+    serverUrl: connection.serverUrl,
+    connectionMode: connection.mode
+  };
+}
+function normalizeActions(actions) {
+  return actions.map((action) => ({
+    name: action.name,
+    ...action.args ? { args: action.args } : {},
+    ...action.checkpointAfter !== void 0 ? { checkpointAfter: action.checkpointAfter } : {},
+    ...action.checkpointLabel ? { checkpointLabel: action.checkpointLabel } : {}
+  }));
+}
+async function resolveTracePayload(params) {
+  if (params.payload !== void 0) return params.payload;
+  if (!params.traceFilePath) {
+    throw new Error("payload ou traceFilePath \xE9 obrigat\xF3rio");
+  }
+  const absPath = params.traceFilePath.startsWith("/") ? params.traceFilePath : resolve(process.cwd(), params.traceFilePath);
+  const raw = await readFile(absPath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+var esvpStatusTool = {
+  name: "dlab.esvp.status",
+  description: "Check if an ESVP control-plane is reachable and return its health payload.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL")
+  }),
+  handler: async (params) => {
+    try {
+      const health = await getESVPHealth(params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        health
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpDevicesTool = {
+  name: "dlab.esvp.devices",
+  description: "List ESVP-visible ADB devices and/or iOS Simulators from the public control-plane.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    platform: z10.enum(["adb", "ios-sim", "maestro-ios", "all"]).optional().describe("Which device family to query")
+  }),
+  handler: async (params) => {
+    try {
+      const devices3 = await listESVPDevices(params.platform || "all", params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        devices: devices3
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionsListTool = {
+  name: "dlab.esvp.sessions.list",
+  description: "List public ESVP sessions from the configured server.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL")
+  }),
+  handler: async (params) => {
+    try {
+      const sessions = await listESVPSessions(params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...sessions
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionCreateTool = {
+  name: "dlab.esvp.session.create",
+  description: "Create an ESVP session using the public contract. Auto-selects a booted emulator/simulator when possible. Use withNetwork to auto-configure the default App Lab external-proxy profile.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    executor: z10.enum(["fake", "adb", "ios-sim", "maestro-ios"]).describe("Public ESVP executor"),
+    deviceId: z10.string().optional().describe("Device ID. Optional for fake and for booted local emulators/simulators"),
+    meta: jsonObjectSchema.optional().describe("Session metadata"),
+    crashClip: crashClipSchema.optional().describe("Optional crash clip config"),
+    withNetwork: z10.boolean().optional().describe("Auto-configure the default App Lab external-proxy profile after creating the session")
+  }),
+  handler: async (params) => {
+    try {
+      const resolvedDeviceId = params.deviceId || resolveDefaultDeviceId(params.executor);
+      const response = await createESVPSession(
+        {
+          executor: params.executor,
+          ...resolvedDeviceId ? { deviceId: resolvedDeviceId } : {},
+          meta: {
+            source: "applab-discovery",
+            ...params.meta || {}
+          },
+          ...params.crashClip ? {
+            crash_clip: params.crashClip
+          } : {}
+        },
+        params.serverUrl
+      );
+      let networkConfigured = null;
+      if (params.withNetwork) {
+        const sessionId = String(response?.session?.id || response?.id || "");
+        if (sessionId) {
+          networkConfigured = await configureESVPNetwork(
+            sessionId,
+            buildAppLabNetworkProfile(
+              {
+                enabled: true,
+                mode: "external-proxy",
+                profile: "applab-standard-capture",
+                label: "App Lab Standard Capture"
+              },
+              {
+                platform: executorToPlatform(params.executor),
+                deviceId: resolvedDeviceId
+              }
+            ) || {},
+            params.serverUrl
+          ).catch((err) => ({ error: err instanceof Error ? err.message : String(err) }));
+        }
+      }
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        autoSelectedDeviceId: resolvedDeviceId || null,
+        ...response,
+        ...networkConfigured ? { networkConfigured } : {}
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionInspectTool = {
+  name: "dlab.esvp.session.inspect",
+  description: "Inspect an ESVP session and optionally include transcript and artifacts.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    includeTranscript: z10.boolean().optional(),
+    includeArtifacts: z10.boolean().optional()
+  }),
+  handler: async (params) => {
+    try {
+      const inspection = await inspectESVPSession(
+        params.sessionId,
+        {
+          includeTranscript: params.includeTranscript === true,
+          includeArtifacts: params.includeArtifacts === true
+        },
+        params.serverUrl
+      );
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...inspection
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionTranscriptTool = {
+  name: "dlab.esvp.session.transcript",
+  description: "Fetch the canonical public transcript for an ESVP session.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID")
+  }),
+  handler: async (params) => {
+    try {
+      const transcript = await getESVPTranscript(params.sessionId, params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        sessionId: params.sessionId,
+        transcript: transcript?.events || []
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionArtifactsListTool = {
+  name: "dlab.esvp.session.artifacts.list",
+  description: "List public artifacts for an ESVP session.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID")
+  }),
+  handler: async (params) => {
+    try {
+      const result = await listESVPArtifacts(params.sessionId, params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        sessionId: params.sessionId,
+        artifacts: result?.artifacts || []
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionArtifactGetTool = {
+  name: "dlab.esvp.session.artifact.get",
+  description: "Fetch the contents of a public ESVP artifact.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    artifactPath: z10.string().describe("Artifact relative path returned by artifacts.list")
+  }),
+  handler: async (params) => {
+    try {
+      const content = await getESVPArtifactContent(params.sessionId, params.artifactPath, params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        sessionId: params.sessionId,
+        artifactPath: params.artifactPath,
+        content
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionActionsTool = {
+  name: "dlab.esvp.session.actions",
+  description: "Run public ESVP actions in an existing session. Use withNetwork to auto-configure the default App Lab external-proxy profile if not already active.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    actions: z10.array(actionSchema).min(1).describe("Public ESVP actions"),
+    finish: z10.boolean().optional().describe("Finish the session after running the actions"),
+    captureLogcat: z10.boolean().optional().describe("Capture logcat on finish when supported"),
+    checkpointAfterEach: z10.boolean().optional().describe("Enable checkpointAfter for every action"),
+    withNetwork: z10.boolean().optional().describe("Auto-configure the default App Lab external-proxy profile before running actions if not already configured")
+  }),
+  handler: async (params) => {
+    try {
+      let networkConfigured = null;
+      if (params.withNetwork) {
+        const networkState = await getESVPSessionNetwork(params.sessionId, params.serverUrl).catch(() => null);
+        const hasActiveProfile = networkState?.network?.active_profile || networkState?.network?.effective_profile;
+        if (!hasActiveProfile) {
+          networkConfigured = await configureESVPNetwork(
+            params.sessionId,
+            buildAppLabNetworkProfile(
+              {
+                enabled: true,
+                mode: "external-proxy",
+                profile: "applab-standard-capture",
+                label: "App Lab Standard Capture"
+              },
+              {
+                platform: executorToPlatform(typeof networkState?.session?.executor === "string" ? networkState.session.executor : void 0),
+                deviceId: typeof networkState?.session?.device_id === "string" ? networkState.session.device_id : void 0
+              }
+            ) || {},
+            params.serverUrl
+          ).catch((err) => ({ error: err instanceof Error ? err.message : String(err) }));
+        }
+      }
+      const result = await runESVPActions(
+        params.sessionId,
+        {
+          actions: normalizeActions(params.actions),
+          finish: params.finish === true,
+          captureLogcat: params.captureLogcat,
+          checkpointAfterEach: params.checkpointAfterEach
+        },
+        params.serverUrl
+      );
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...networkConfigured ? { networkConfigured } : {},
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionCheckpointTool = {
+  name: "dlab.esvp.session.checkpoint",
+  description: "Capture a public ESVP checkpoint for an existing session.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    label: z10.string().optional().describe("Optional checkpoint label")
+  }),
+  handler: async (params) => {
+    try {
+      const result = await captureESVPCheckpoint(
+        params.sessionId,
+        {
+          ...params.label ? { label: params.label } : {}
+        },
+        params.serverUrl
+      );
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionFinishTool = {
+  name: "dlab.esvp.session.finish",
+  description: "Finish an ESVP session.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    captureLogcat: z10.boolean().optional().describe("Capture logcat on finish when supported")
+  }),
+  handler: async (params) => {
+    try {
+      const result = await finishESVPSession(
+        params.sessionId,
+        {
+          captureLogcat: params.captureLogcat
+        },
+        params.serverUrl
+      );
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpReplayRunTool = {
+  name: "dlab.esvp.replay.run",
+  description: "Replay an ESVP session to a new session using the public replay endpoint.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("Base ESVP session ID"),
+    executor: z10.enum(["fake", "adb", "ios-sim", "maestro-ios"]).optional().describe("Replay executor"),
+    deviceId: z10.string().optional().describe("Replay device ID"),
+    captureLogcat: z10.boolean().optional(),
+    meta: jsonObjectSchema.optional()
+  }),
+  handler: async (params) => {
+    try {
+      const result = await replayESVPSession(
+        params.sessionId,
+        {
+          executor: params.executor,
+          deviceId: params.deviceId,
+          captureLogcat: params.captureLogcat,
+          meta: {
+            source: "applab-discovery",
+            ...params.meta || {}
+          }
+        },
+        params.serverUrl
+      );
+      const consistency = result?.replay_session?.id ? await getESVPReplayConsistency(result.replay_session.id, params.serverUrl).catch(() => null) : null;
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result,
+        replayConsistency: consistency?.replay_consistency || null
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpNetworkConfigureTool = {
+  name: "dlab.esvp.network.configure",
+  description: "Configure an ESVP network profile through the public network contract.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    profile: z10.string().optional(),
+    label: z10.string().optional(),
+    connectivity: z10.enum(["online", "offline", "reset"]).optional(),
+    proxy: proxySchema.optional(),
+    faults: jsonObjectSchema.optional(),
+    capture: jsonObjectSchema.optional(),
+    clear: z10.boolean().optional().describe("Clear the active network profile instead of applying one")
+  }),
+  handler: async (params) => {
+    try {
+      if (params.clear === true) {
+        const cleared = await clearESVPNetwork(params.sessionId, params.serverUrl);
+        return createJsonResult({
+          ...await makeBaseResult(params.serverUrl),
+          ...cleared
+        });
+      }
+      const result = await configureESVPNetwork(
+        params.sessionId,
+        {
+          ...params.profile ? { profile: params.profile } : {},
+          ...params.label ? { label: params.label } : {},
+          ...params.connectivity ? { connectivity: params.connectivity } : {},
+          ...params.proxy ? { proxy: params.proxy } : {},
+          ...params.faults ? { faults: params.faults } : {},
+          ...params.capture ? { capture: params.capture } : {}
+        },
+        params.serverUrl
+      );
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionNetworkTool = {
+  name: "dlab.esvp.session.network",
+  description: "Read the public network state for an ESVP session.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID")
+  }),
+  handler: async (params) => {
+    try {
+      const result = await getESVPSessionNetwork(params.sessionId, params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpNetworkTraceAttachTool = {
+  name: "dlab.esvp.network.trace.attach",
+  description: "Attach a network trace artifact to an ESVP session using the public contract.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    traceKind: z10.string().describe("Trace kind, e.g. http_trace or har"),
+    label: z10.string().optional(),
+    source: z10.string().optional(),
+    requestId: z10.string().optional(),
+    method: z10.string().optional(),
+    url: z10.string().optional(),
+    statusCode: z10.number().optional(),
+    format: z10.string().optional(),
+    payload: z10.any().optional().describe("Trace payload object/string"),
+    traceFilePath: z10.string().optional().describe("Optional local file path to JSON/text trace payload")
+  }),
+  handler: async (params) => {
+    try {
+      const payload = await resolveTracePayload({
+        payload: params.payload,
+        traceFilePath: params.traceFilePath
+      });
+      const result = await attachESVPNetworkTrace(
+        params.sessionId,
+        {
+          trace_kind: params.traceKind,
+          ...params.label ? { label: params.label } : {},
+          ...params.source ? { source: params.source } : {},
+          ...params.requestId ? { request_id: params.requestId } : {},
+          ...params.method ? { method: params.method } : {},
+          ...params.url ? { url: params.url } : {},
+          ...params.statusCode !== void 0 ? { status_code: params.statusCode } : {},
+          ...params.format ? { format: params.format } : {},
+          payload
+        },
+        params.serverUrl
+      );
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpSessionGetTool = {
+  name: "dlab.esvp.session.get",
+  description: "Get the latest public summary for an ESVP session.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID")
+  }),
+  handler: async (params) => {
+    try {
+      const result = await getESVPSession(params.sessionId, params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpReplayValidateTool = {
+  name: "dlab.esvp.replay.validate",
+  description: "Validate whether an ESVP session supports canonical replay and inspect the result.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID")
+  }),
+  handler: async (params) => {
+    try {
+      const result = await validateESVPReplay(params.sessionId, params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var preflightRuleSchema = z10.object({
+  kind: z10.enum(["permission", "dismiss_dialog", "wait_for_stable", "clear_data", "set_setting"]).describe("Preflight rule kind"),
+  permission: z10.string().optional().describe("Android permission (for kind=permission)"),
+  action: z10.enum(["grant", "revoke"]).optional().describe("Permission action (for kind=permission)"),
+  selector: z10.string().optional().describe("Selector to find and dismiss (for kind=dismiss_dialog)"),
+  timeout_ms: z10.number().optional().describe("Timeout in ms (for kind=wait_for_stable/dismiss_dialog)"),
+  poll_ms: z10.number().optional().describe("Poll interval in ms (for kind=wait_for_stable)"),
+  namespace: z10.string().optional().describe("Settings namespace: system|secure|global (for kind=set_setting)"),
+  key: z10.string().optional().describe("Setting key (for kind=set_setting)"),
+  value: z10.string().optional().describe("Setting value (for kind=set_setting)")
+});
+var esvpSessionPreflightTool = {
+  name: "dlab.esvp.session.preflight",
+  description: "Run preflight/bootstrap rules on an ESVP session before executing actions. Supports permission grants, dialog dismissal, wait for stable UI, clear data, and system settings.",
+  inputSchema: z10.object({
+    serverUrl: z10.string().url().optional().describe("ESVP control-plane base URL"),
+    sessionId: z10.string().describe("ESVP session ID"),
+    policy: z10.string().optional().describe("Preflight policy name (e.g. fresh_install)"),
+    appId: z10.string().optional().describe("Target app ID (e.g. com.example.app)"),
+    rules: z10.array(preflightRuleSchema).optional().describe("Preflight rules to execute")
+  }),
+  handler: async (params) => {
+    try {
+      const config = {
+        ...params.policy ? { policy: params.policy } : {},
+        ...params.appId ? { appId: params.appId } : {},
+        ...params.rules ? { rules: params.rules } : {}
+      };
+      const result = await runESVPPreflight(params.sessionId, config, params.serverUrl);
+      return createJsonResult({
+        ...await makeBaseResult(params.serverUrl),
+        ...result
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var projectESVPCurrentTool = {
+  name: "dlab.project.esvp.current",
+  description: "Read the current ESVP state stored for an App Lab mobile recording/project without requiring the web UI.",
+  inputSchema: projectRecordingSchema,
+  handler: async (params) => {
+    try {
+      const session = await readMobileRecordingSession(params.recordingId);
+      const esvp = resolveProjectRecordingESVPState(session);
+      const validation = esvp?.validation && typeof esvp.validation === "object" ? esvp.validation : null;
+      const network = esvp?.network && typeof esvp.network === "object" ? esvp.network : null;
+      return createJsonResult({
+        recordingId: params.recordingId,
+        recordingDir: getMobileRecordingDir(params.recordingId),
+        sessionPath: getMobileRecordingSessionPath(params.recordingId),
+        recording: {
+          id: String(session.id || params.recordingId),
+          name: String(session.name || `Recording ${params.recordingId}`),
+          platform: session.platform === "ios" ? "ios" : "android",
+          deviceId: typeof session.deviceId === "string" ? session.deviceId : null,
+          deviceName: typeof session.deviceName === "string" ? session.deviceName : null,
+          appId: typeof session.appId === "string" ? session.appId : null,
+          actionsCount: Array.isArray(session.actions) ? session.actions.length : 0
+        },
+        esvp: {
+          serverUrl: resolveProjectRecordingESVPServerUrl(session) || null,
+          connectionMode: typeof esvp?.connectionMode === "string" ? esvp.connectionMode : null,
+          executor: typeof esvp?.executor === "string" ? esvp.executor : null,
+          currentSessionId: typeof esvp?.currentSessionId === "string" ? esvp.currentSessionId : null,
+          sourceSessionId: resolveProjectRecordingESVPSourceSessionId(session),
+          replaySessionId: resolveProjectRecordingReplaySessionId(session),
+          validationSupported: validation?.supported === false ? false : validation ? true : null,
+          validatedAt: typeof validation?.validatedAt === "string" ? validation.validatedAt : null,
+          replayedAt: typeof validation?.replayedAt === "string" ? validation.replayedAt : null,
+          replayConsistency: validation?.replayConsistency || null,
+          checkpointComparison: validation?.checkpointComparison || null,
+          network: {
+            entryCount: Number.isFinite(Number(network?.entryCount)) ? Number(network?.entryCount) : 0,
+            traceCount: Number.isFinite(Number(network?.traceCount)) ? Number(network?.traceCount) : 0,
+            traceKinds: Array.isArray(network?.traceKinds) ? network.traceKinds : [],
+            captureStatus: typeof network?.captureStatus === "string" ? network.captureStatus : null,
+            networkSupported: typeof network?.networkSupported === "boolean" ? network.networkSupported : null,
+            activeProfile: network?.activeProfile || null,
+            effectiveProfile: network?.effectiveProfile || null,
+            captureProxy: network?.captureProxy || null,
+            appTraceCollector: network?.appTraceCollector || null,
+            managedProxy: network?.managedProxy || null,
+            syncedAt: typeof network?.syncedAt === "string" ? network.syncedAt : null
+          }
+        }
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var projectESVPValidateTool = {
+  name: "dlab.project.esvp.validate",
+  description: "Run the App Lab ESVP validation flow for a mobile recording/project. Requires the local App Lab server to be running.",
+  inputSchema: projectRecordingSchema.extend({
+    appLabUrl: z10.string().url().optional().describe("App Lab server base URL, defaults to http://127.0.0.1:3847"),
+    serverUrl: z10.string().url().optional().describe("Optional ESVP control-plane base URL"),
+    replay: z10.boolean().optional().describe("Run replay after source validation"),
+    captureLogcat: z10.boolean().optional(),
+    profileId: projectValidationProfileIdSchema.optional().describe("Convenience network profile shortcut"),
+    network: projectValidationNetworkSchema.optional().describe("Explicit network profile payload. Overrides profileId. Pass null to validate without network capture.")
+  }),
+  handler: async (params) => {
+    try {
+      const network = params.network === null ? null : buildProjectValidationNetwork(params.profileId, params.network);
+      const result = await callAppLabJson(
+        `/api/testing/mobile/recordings/${encodeURIComponent(params.recordingId)}/esvp/validate`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            ...params.serverUrl ? { serverUrl: params.serverUrl } : {},
+            ...params.captureLogcat !== void 0 ? { captureLogcat: params.captureLogcat } : {},
+            ...params.replay !== void 0 ? { replay: params.replay } : {},
+            ...network ? { network } : {}
+          })
+        },
+        params.appLabUrl
+      );
+      return createJsonResult({
+        appLabUrl: result.appLabUrl,
+        recordingId: params.recordingId,
+        result: result.payload
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var projectESVPReplayTool = {
+  name: "dlab.project.esvp.replay",
+  description: "Replay the canonical ESVP source session already attached to a mobile recording/project. Requires the local App Lab server to be running.",
+  inputSchema: projectRecordingSchema.extend({
+    appLabUrl: z10.string().url().optional().describe("App Lab server base URL, defaults to http://127.0.0.1:3847"),
+    serverUrl: z10.string().url().optional().describe("Optional ESVP control-plane base URL"),
+    captureLogcat: z10.boolean().optional()
+  }),
+  handler: async (params) => {
+    try {
+      const result = await callAppLabJson(
+        `/api/testing/mobile/recordings/${encodeURIComponent(params.recordingId)}/esvp/replay`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            ...params.serverUrl ? { serverUrl: params.serverUrl } : {},
+            ...params.captureLogcat !== void 0 ? { captureLogcat: params.captureLogcat } : {}
+          })
+        },
+        params.appLabUrl
+      );
+      return createJsonResult({
+        appLabUrl: result.appLabUrl,
+        recordingId: params.recordingId,
+        result: result.payload
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var projectESVPSyncNetworkTool = {
+  name: "dlab.project.esvp.sync_network",
+  description: "Sync the latest attached ESVP network trace into an App Lab mobile recording/project. Requires the local App Lab server to be running.",
+  inputSchema: projectRecordingSchema.extend({
+    appLabUrl: z10.string().url().optional().describe("App Lab server base URL, defaults to http://127.0.0.1:3847"),
+    serverUrl: z10.string().url().optional().describe("Optional ESVP control-plane base URL"),
+    sessionId: z10.string().optional().describe("Optional ESVP session ID override")
+  }),
+  handler: async (params) => {
+    try {
+      const result = await callAppLabJson(
+        `/api/testing/mobile/recordings/${encodeURIComponent(params.recordingId)}/esvp/sync-network`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            ...params.serverUrl ? { serverUrl: params.serverUrl } : {},
+            ...params.sessionId ? { sessionId: params.sessionId } : {}
+          })
+        },
+        params.appLabUrl
+      );
+      return createJsonResult({
+        appLabUrl: result.appLabUrl,
+        recordingId: params.recordingId,
+        result: result.payload
+      });
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var projectESVPAppTraceBootstrapTool = {
+  name: "dlab.project.esvp.app_trace_bootstrap",
+  description: "Fetch the active local app_http_trace bootstrap config for an App Lab mobile recording/project. Requires the local App Lab server to be running when a collector is active.",
+  inputSchema: projectRecordingSchema.extend({
+    appLabUrl: z10.string().url().optional().describe("App Lab server base URL, defaults to http://127.0.0.1:3847"),
+    appId: z10.string().optional().describe("Optional app ID override when multiple collectors are active")
+  }),
+  handler: async (params) => {
+    try {
+      const session = await readMobileRecordingSession(params.recordingId);
+      const collector = session?.esvp?.network?.appTraceCollector || null;
+      const searchParams = new URLSearchParams();
+      if (params.recordingId) searchParams.set("recordingId", params.recordingId);
+      if (params.appId) searchParams.set("appId", params.appId);
+      const path10 = `/api/testing/mobile/app-http-trace/bootstrap?${searchParams.toString()}`;
+      try {
+        const result = await callAppLabJson(path10, { method: "GET" }, params.appLabUrl);
+        return createJsonResult({
+          appLabUrl: result.appLabUrl,
+          recordingId: params.recordingId,
+          result: result.payload
+        });
+      } catch (error) {
+        return createJsonResult({
+          appLabUrl: resolveAppLabBaseUrl(params.appLabUrl),
+          recordingId: params.recordingId,
+          activeCollector: collector,
+          bootstrap: null,
+          warning: error instanceof Error ? error.message : String(error)
+        });
+      }
+    } catch (error) {
+      return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var esvpTools = [
+  esvpStatusTool,
+  esvpDevicesTool,
+  esvpSessionsListTool,
+  esvpSessionCreateTool,
+  esvpSessionGetTool,
+  esvpSessionInspectTool,
+  esvpSessionTranscriptTool,
+  esvpSessionArtifactsListTool,
+  esvpSessionArtifactGetTool,
+  esvpSessionActionsTool,
+  esvpSessionCheckpointTool,
+  esvpSessionFinishTool,
+  esvpSessionPreflightTool,
+  esvpReplayRunTool,
+  esvpReplayValidateTool,
+  esvpSessionNetworkTool,
+  esvpNetworkConfigureTool,
+  esvpNetworkTraceAttachTool,
+  projectESVPCurrentTool,
+  projectESVPValidateTool,
+  projectESVPReplayTool,
+  projectESVPSyncNetworkTool,
+  projectESVPAppTraceBootstrapTool
+];
+
+// src/mcp/tools/templates.ts
+import { z as z11 } from "zod";
+var templateListTool = {
+  name: "dlab.template.list",
+  description: "List available Remotion video templates. Returns installed templates with their metadata, or indicates templates are not installed.",
+  inputSchema: z11.object({}),
+  handler: async () => {
+    const installed = isTemplatesInstalled();
+    if (!installed) {
+      return createJsonResult({
+        installed: false,
+        templates: [],
+        message: "Templates not installed. Install discoverylab-templates to ~/.discoverylab/templates/"
+      });
+    }
+    const templates = getAvailableTemplates();
+    return createJsonResult({
+      installed: true,
+      templates: templates.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        resolution: `${t.width}x${t.height}`,
+        fps: t.fps,
+        durationFrames: t.durationFrames
+      }))
+    });
+  }
+};
+var templateRenderTool = {
+  name: "dlab.template.render",
+  description: "Render a project video with a Remotion template. Starts an async render job and returns the job ID. Use the web UI to monitor progress.",
+  inputSchema: z11.object({
+    projectId: z11.string().describe("The project ID to render"),
+    templateId: z11.enum(["studio", "showcase"]).describe('Template to use: "studio" (device + terminal) or "showcase" (floating device + artistic title + terminal)')
+  }),
+  handler: async ({ projectId, templateId }) => {
+    if (!isTemplatesInstalled()) {
+      return createErrorResult("Templates not installed. Install discoverylab-templates first.");
+    }
+    return createTextResult(
+      `To render project "${projectId}" with template "${templateId}", use the web UI or call POST /api/templates/render with { projectId: "${projectId}", templateId: "${templateId}" }. The render runs asynchronously and progress is broadcast via WebSocket.`
+    );
+  }
+};
+var templateTools = [
+  templateListTool,
+  templateRenderTool
+];
+
 export {
   uiOpenTool,
   uiStatusTool,
@@ -6393,5 +7471,31 @@ export {
   taskHubRequirementsGetTool,
   taskHubTestMapGetTool,
   taskHubTestMapToggleTool,
-  taskHubTools
+  taskHubTools,
+  esvpStatusTool,
+  esvpDevicesTool,
+  esvpSessionsListTool,
+  esvpSessionCreateTool,
+  esvpSessionInspectTool,
+  esvpSessionTranscriptTool,
+  esvpSessionArtifactsListTool,
+  esvpSessionArtifactGetTool,
+  esvpSessionActionsTool,
+  esvpSessionCheckpointTool,
+  esvpSessionFinishTool,
+  esvpReplayRunTool,
+  esvpNetworkConfigureTool,
+  esvpSessionNetworkTool,
+  esvpNetworkTraceAttachTool,
+  esvpSessionGetTool,
+  esvpReplayValidateTool,
+  projectESVPCurrentTool,
+  projectESVPValidateTool,
+  projectESVPReplayTool,
+  projectESVPSyncNetworkTool,
+  projectESVPAppTraceBootstrapTool,
+  esvpTools,
+  templateListTool,
+  templateRenderTool,
+  templateTools
 };