@veolab/discoverylab 1.2.2 → 1.3.0

package/dist/{chunk-I6YD3QFM.js → chunk-FIL7IWEL.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SLNJEF32.js";
 import {
   PROJECTS_DIR
-} from "./chunk-VY3BLXBW.js";
+} from "./chunk-VVIOB362.js";
 
 // src/core/testing/playwright.ts
 import { exec, spawn } from "child_process";
@@ -234,7 +234,8 @@ async function runPlaywrightTest(options) {
     project,
     workers = 1,
     retries = 0,
-    reporter = "json"
+    reporter = "json",
+    env = {}
   } = options;
   await fs.promises.mkdir(outputDir, { recursive: true });
   const startTime = Date.now();
@@ -263,7 +264,8 @@ async function runPlaywrightTest(options) {
   try {
     const { stdout, stderr } = await execAsync(`npx ${args.join(" ")}`, {
       timeout: config.timeout || 3e5,
-      cwd: process.cwd()
+      cwd: process.cwd(),
+      env: { ...process.env, ...env }
     });
     const duration = Date.now() - startTime;
     let passed = 0;

package/dist/{chunk-G524UVBK.js → chunk-FNUN7EPB.js}

@@ -1,11 +1,11 @@
-import {
-  DATA_DIR,
-  DB_PATH
-} from "./chunk-TJ3H23LL.js";
 import {
   createJsonResult,
   createTextResult
 } from "./chunk-XKX6NBHF.js";
+import {
+  DATA_DIR,
+  DB_PATH
+} from "./chunk-VVIOB362.js";
 
 // src/mcp/tools/setup.ts
 import { z } from "zod";
@@ -224,7 +224,7 @@ var setupInitTool = {
   inputSchema: z.object({}),
   handler: async () => {
     try {
-      const { getDatabase, DATA_DIR: DATA_DIR2, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR } = await import("./db-ADBEBNH6.js");
+      const { getDatabase, DATA_DIR: DATA_DIR2, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR } = await import("./db-6WLEVKUV.js");
       getDatabase();
       return createJsonResult({
         message: "DiscoveryLab initialized successfully",

package/dist/chunk-GAKEFJ5T.js

@@ -0,0 +1,481 @@
+import {
+  DATA_DIR
+} from "./chunk-VVIOB362.js";
+
+// src/core/integrations/esvp-local.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+var localServerPromise = null;
+var cleanupRegistered = false;
+var activeLocalServer = null;
+async function resolveESVPConnection(serverUrl) {
+  const explicit = typeof serverUrl === "string" && serverUrl.trim() ? normalizeBaseUrl(serverUrl) : null;
+  if (explicit) {
+    return {
+      mode: "remote",
+      serverUrl: explicit
+    };
+  }
+  const envUrl = typeof process.env.ESVP_BASE_URL === "string" && process.env.ESVP_BASE_URL.trim() ? normalizeBaseUrl(process.env.ESVP_BASE_URL) : null;
+  if (envUrl) {
+    return {
+      mode: "remote",
+      serverUrl: envUrl
+    };
+  }
+  if (!localServerPromise) {
+    localServerPromise = startEmbeddedLocalServer().catch((error) => {
+      localServerPromise = null;
+      throw error;
+    });
+  }
+  return localServerPromise;
+}
+function normalizeBaseUrl(value) {
+  return value.trim().replace(/\/+$/, "");
+}
+async function startEmbeddedLocalServer() {
+  const runtime = await loadLocalRuntimeModule();
+  const rootDir = join(DATA_DIR, "esvp-local");
+  const started = await runtime.startServer({
+    host: "127.0.0.1",
+    port: 0,
+    rootDir
+  });
+  activeLocalServer = {
+    startResult: started,
+    runtime
+  };
+  if (!cleanupRegistered) {
+    cleanupRegistered = true;
+    const cleanup = async () => {
+      try {
+        await stopEmbeddedESVPServer();
+      } catch {
+      }
+    };
+    process.once("beforeExit", () => {
+      void cleanup();
+    });
+    process.once("SIGINT", () => {
+      void cleanup().finally(() => process.exit(0));
+    });
+    process.once("SIGTERM", () => {
+      void cleanup().finally(() => process.exit(0));
+    });
+    process.once("uncaughtException", (error) => {
+      void cleanup().finally(() => {
+        console.error("[esvp-local] uncaught exception after proxy cleanup:", error);
+        process.exit(1);
+      });
+    });
+    process.once("unhandledRejection", (reason) => {
+      void cleanup().finally(() => {
+        console.error("[esvp-local] unhandled rejection after proxy cleanup:", reason);
+        process.exit(1);
+      });
+    });
+  }
+  return {
+    mode: "local",
+    serverUrl: normalizeBaseUrl(started.url)
+  };
+}
+async function stopEmbeddedESVPServer() {
+  const current = activeLocalServer;
+  activeLocalServer = null;
+  localServerPromise = null;
+  if (!current) return;
+  const manager = current.startResult.manager;
+  if (manager && typeof manager.cleanupIosSimProxies === "function") {
+    try {
+      await manager.cleanupIosSimProxies();
+    } catch {
+    }
+  }
+  if (current.runtime.stopServer) {
+    await current.runtime.stopServer(current.startResult);
+    return;
+  }
+  await new Promise((resolveClose, rejectClose) => {
+    current.startResult.server.close((error) => {
+      if (error) {
+        rejectClose(error);
+        return;
+      }
+      resolveClose();
+    });
+  });
+}
+async function loadLocalRuntimeModule() {
+  const explicitModulePath = process.env.DISCOVERYLAB_ESVP_LOCAL_MODULE?.trim();
+  const candidates = explicitModulePath ? [explicitModulePath] : ["@entropylab/esvp-local", ...discoverWorkspaceRuntimeCandidates()];
+  let lastError = null;
+  for (const candidate of candidates) {
+    try {
+      const module = await dynamicImport(resolveModuleSpecifier(candidate));
+      if (typeof module.startServer === "function") {
+        return module;
+      }
+      throw new Error(`M\xF3dulo ${candidate} n\xE3o exporta startServer()`);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw new Error(
+    [
+      "ESVP local n\xE3o dispon\xEDvel.",
+      "Instale o pacote p\xFAblico @entropylab/esvp-local, mantenha o entropy-poc acess\xEDvel no workspace, ou defina DISCOVERYLAB_ESVP_LOCAL_MODULE com o caminho do server.js do runtime local.",
+      lastError instanceof Error ? `Detalhe: ${lastError.message}` : null
+    ].filter(Boolean).join(" ")
+  );
+}
+function discoverWorkspaceRuntimeCandidates() {
+  const seen = /* @__PURE__ */ new Set();
+  const roots = [process.cwd(), dirname(fileURLToPath(import.meta.url))];
+  const suffixes = [
+    ["esvp-server-reference", "server.js"],
+    ["entropy-poc", "esvp-server-reference", "server.js"],
+    ["entropy", "entropy-poc", "esvp-server-reference", "server.js"]
+  ];
+  const candidates = [];
+  for (const root of roots) {
+    let current = resolve(root);
+    for (let depth = 0; depth < 6; depth += 1) {
+      for (const suffix of suffixes) {
+        const candidate = join(current, ...suffix);
+        if (existsSync(candidate) && !seen.has(candidate)) {
+          seen.add(candidate);
+          candidates.push(candidate);
+        }
+      }
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  return candidates;
+}
+function resolveModuleSpecifier(value) {
+  if (value.startsWith(".") || value.startsWith("/") || value.startsWith("file://")) {
+    return value.startsWith("file://") ? value : pathToFileURL(resolve(process.cwd(), value)).href;
+  }
+  return value;
+}
+async function dynamicImport(specifier) {
+  return Function("specifier", "return import(specifier)")(specifier);
+}
+
+// src/core/integrations/esvp.ts
+var DEFAULT_ESVP_BASE_URL = "http://127.0.0.1:8787";
+var DEFAULT_ESVP_REQUEST_TIMEOUT_MS = 2e4;
+var LONG_RUNNING_ESVP_REQUEST_TIMEOUT_MS = 12e4;
+function normalizeBaseUrl2(serverUrl) {
+  const raw = (serverUrl || process.env.ESVP_BASE_URL || DEFAULT_ESVP_BASE_URL).trim();
+  return raw.replace(/\/+$/, "");
+}
+async function resolveBaseUrl(serverUrl) {
+  return resolveESVPConnection(serverUrl);
+}
+async function readJsonSafe(response) {
+  const text = await response.text();
+  if (!text.trim()) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+async function readResponseContent(response) {
+  const contentType = (response.headers.get("content-type") || "").toLowerCase();
+  const text = await response.text();
+  if (!text.trim()) return null;
+  if (contentType.includes("json")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function esvpRequest(path, init = {}, serverUrl, timeoutMs = DEFAULT_ESVP_REQUEST_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const connection = await resolveBaseUrl(serverUrl);
+    const response = await fetch(`${connection.serverUrl}${path}`, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        ...init.headers || {}
+      },
+      signal: controller.signal
+    });
+    const payload = await readJsonSafe(response);
+    if (!response.ok) {
+      const message = payload?.error || payload?.message || `ESVP request failed (${response.status} ${response.statusText})`;
+      throw new Error(message);
+    }
+    return payload;
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      throw new Error(`ESVP request timed out after ${timeoutMs}ms: ${path}`);
+    }
+    if (error instanceof TypeError) {
+      throw new Error(`ESVP connection failed: ${error.message}`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function getESVPBaseUrl(serverUrl) {
+  return normalizeBaseUrl2(serverUrl);
+}
+async function resolveESVPBaseUrl(serverUrl) {
+  const connection = await resolveBaseUrl(serverUrl);
+  return connection.serverUrl;
+}
+async function getESVPConnection(serverUrl) {
+  return resolveBaseUrl(serverUrl);
+}
+async function getESVPHealth(serverUrl) {
+  return esvpRequest("/health", { method: "GET" }, serverUrl);
+}
+async function listESVPSessions(serverUrl) {
+  return esvpRequest("/sessions", { method: "GET" }, serverUrl);
+}
+async function createESVPSession(input, serverUrl) {
+  return esvpRequest(
+    "/sessions",
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    },
+    serverUrl
+  );
+}
+async function getESVPSession(sessionId, serverUrl) {
+  return esvpRequest(`/sessions/${encodeURIComponent(sessionId)}`, { method: "GET" }, serverUrl);
+}
+async function getESVPTranscript(sessionId, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/transcript`,
+    { method: "GET" },
+    serverUrl
+  );
+}
+async function listESVPArtifacts(sessionId, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/artifacts`,
+    { method: "GET" },
+    serverUrl
+  );
+}
+async function runESVPActions(sessionId, input, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/actions`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    },
+    serverUrl,
+    LONG_RUNNING_ESVP_REQUEST_TIMEOUT_MS
+  );
+}
+async function finishESVPSession(sessionId, input = {}, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/finish`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    },
+    serverUrl
+  );
+}
+async function runESVPPreflight(sessionId, config, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/preflight`,
+    { method: "POST", body: JSON.stringify(config) },
+    serverUrl,
+    LONG_RUNNING_ESVP_REQUEST_TIMEOUT_MS
+  );
+}
+async function inspectESVPSession(sessionId, input = {}, serverUrl) {
+  const [session, transcript, artifacts] = await Promise.all([
+    getESVPSession(sessionId, serverUrl),
+    input.includeTranscript === true ? esvpRequest(
+      `/sessions/${encodeURIComponent(sessionId)}/transcript`,
+      { method: "GET" },
+      serverUrl
+    ) : Promise.resolve(null),
+    input.includeArtifacts === true ? esvpRequest(
+      `/sessions/${encodeURIComponent(sessionId)}/artifacts`,
+      { method: "GET" },
+      serverUrl
+    ) : Promise.resolve(null)
+  ]);
+  return {
+    session: session?.session || session,
+    transcript: transcript?.events || null,
+    artifacts: artifacts?.artifacts || null
+  };
+}
+async function getESVPArtifactContent(sessionId, artifactPath, serverUrl) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 2e4);
+  try {
+    const connection = await resolveBaseUrl(serverUrl);
+    const response = await fetch(
+      `${connection.serverUrl}/sessions/${encodeURIComponent(sessionId)}/artifacts/${artifactPath.split("/").map((part) => encodeURIComponent(part)).join("/")}`,
+      {
+        method: "GET",
+        signal: controller.signal
+      }
+    );
+    const payload = await readResponseContent(response);
+    if (!response.ok) {
+      const message = (payload && typeof payload === "object" ? payload.error || payload.message : null) || `ESVP artifact request failed (${response.status} ${response.statusText})`;
+      throw new Error(String(message));
+    }
+    return payload;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function getESVPSessionNetwork(sessionId, serverUrl) {
+  return esvpRequest(`/sessions/${encodeURIComponent(sessionId)}/network`, { method: "GET" }, serverUrl);
+}
+async function replayESVPSession(sessionId, input = {}, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/replay-run`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    },
+    serverUrl,
+    LONG_RUNNING_ESVP_REQUEST_TIMEOUT_MS
+  );
+}
+async function getESVPReplayConsistency(sessionId, serverUrl) {
+  return esvpRequest(`/sessions/${encodeURIComponent(sessionId)}/replay-consistency`, { method: "GET" }, serverUrl);
+}
+async function validateESVPReplay(sessionId, serverUrl) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), LONG_RUNNING_ESVP_REQUEST_TIMEOUT_MS);
+  try {
+    const connection = await resolveBaseUrl(serverUrl);
+    const response = await fetch(`${connection.serverUrl}/sessions/${encodeURIComponent(sessionId)}/replay-validate`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({}),
+      signal: controller.signal
+    });
+    const payload = await readJsonSafe(response);
+    if (!response.ok && ![409, 422].includes(response.status)) {
+      const message = payload?.error || payload?.message || `ESVP replay validation failed (${response.status} ${response.statusText})`;
+      throw new Error(message);
+    }
+    return {
+      http_status: response.status,
+      ...payload && typeof payload === "object" ? payload : { payload }
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function captureESVPCheckpoint(sessionId, input = {}, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/checkpoint`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    },
+    serverUrl
+  );
+}
+async function configureESVPNetwork(sessionId, input, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/network/profile`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    },
+    serverUrl
+  );
+}
+async function clearESVPNetwork(sessionId, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/network/clear`,
+    {
+      method: "POST",
+      body: JSON.stringify({})
+    },
+    serverUrl
+  );
+}
+async function attachESVPNetworkTrace(sessionId, input, serverUrl) {
+  return esvpRequest(
+    `/sessions/${encodeURIComponent(sessionId)}/network/trace`,
+    {
+      method: "POST",
+      body: JSON.stringify(input)
+    },
+    serverUrl
+  );
+}
+async function listESVPDevices(platform = "all", serverUrl) {
+  if (platform === "adb") {
+    return esvpRequest("/devices/adb", { method: "GET" }, serverUrl);
+  }
+  if (platform === "ios-sim") {
+    return esvpRequest("/devices/ios-sim", { method: "GET" }, serverUrl);
+  }
+  if (platform === "maestro-ios") {
+    return esvpRequest("/devices/maestro-ios", { method: "GET" }, serverUrl);
+  }
+  const [adb, iosSim, maestroIos] = await Promise.all([
+    esvpRequest("/devices/adb", { method: "GET" }, serverUrl).catch((error) => ({ error: error instanceof Error ? error.message : String(error), devices: [] })),
+    esvpRequest("/devices/ios-sim", { method: "GET" }, serverUrl).catch((error) => ({ error: error instanceof Error ? error.message : String(error), devices: [] })),
+    esvpRequest("/devices/maestro-ios", { method: "GET" }, serverUrl).catch((error) => ({ error: error instanceof Error ? error.message : String(error), devices: [] }))
+  ]);
+  return {
+    adb,
+    iosSim,
+    maestroIos
+  };
+}
+
+export {
+  getESVPBaseUrl,
+  resolveESVPBaseUrl,
+  getESVPConnection,
+  getESVPHealth,
+  listESVPSessions,
+  createESVPSession,
+  getESVPSession,
+  getESVPTranscript,
+  listESVPArtifacts,
+  runESVPActions,
+  finishESVPSession,
+  runESVPPreflight,
+  inspectESVPSession,
+  getESVPArtifactContent,
+  getESVPSessionNetwork,
+  replayESVPSession,
+  getESVPReplayConsistency,
+  validateESVPReplay,
+  captureESVPCheckpoint,
+  configureESVPNetwork,
+  clearESVPNetwork,
+  attachESVPNetworkTrace,
+  listESVPDevices
+};

package/dist/chunk-LB3RNE3O.js

@@ -0,0 +1,109 @@
+// src/core/integrations/esvp-network-profile.ts
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized ? normalized : null;
+}
+function normalizeOptionalPort(value) {
+  const port = Number(value);
+  if (!Number.isFinite(port) || port <= 0) return null;
+  return Math.round(port);
+}
+function normalizeOptionalBypass(value) {
+  if (!Array.isArray(value)) return null;
+  const normalized = value.map((entry) => normalizeOptionalString(entry)).filter((entry) => Boolean(entry));
+  return normalized.length > 0 ? normalized : null;
+}
+function readExternalProxyPortFromEnv() {
+  return normalizeOptionalPort(process.env.DISCOVERYLAB_NETWORK_PROXY_PORT);
+}
+function readExternalProxyHostFromEnv() {
+  return normalizeOptionalString(process.env.DISCOVERYLAB_NETWORK_PROXY_HOST);
+}
+function readExternalProxyProtocolFromEnv() {
+  return normalizeOptionalString(process.env.DISCOVERYLAB_NETWORK_PROXY_PROTOCOL);
+}
+function readExternalProxyBypassFromEnv() {
+  const raw = normalizeOptionalString(process.env.DISCOVERYLAB_NETWORK_PROXY_BYPASS);
+  if (!raw) return null;
+  const normalized = raw.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeAppLabNetworkMode(mode) {
+  const normalized = String(mode || "").trim().toLowerCase();
+  if (normalized === "managed-proxy") return "managed-proxy";
+  if (normalized === "external-mitm") return "external-mitm";
+  if (normalized === "app-http-trace") return "app-http-trace";
+  return "external-proxy";
+}
+function inferAppLabExternalProxyHost(input) {
+  const explicitHost = normalizeOptionalString(input.explicitHost);
+  if (explicitHost) return explicitHost;
+  const envHost = readExternalProxyHostFromEnv();
+  if (envHost) return envHost;
+  const platform = String(input.platform || "").trim().toLowerCase();
+  if (platform === "ios") return "127.0.0.1";
+  if (platform === "android") {
+    const deviceId = String(input.deviceId || "").trim();
+    if (deviceId.startsWith("emulator-")) return "10.0.2.2";
+  }
+  return null;
+}
+function resolveAppLabExternalProxy(input) {
+  const explicitProxy = isObject(input.proxy) ? input.proxy : null;
+  const host = inferAppLabExternalProxyHost({
+    platform: input.platform,
+    deviceId: input.deviceId,
+    explicitHost: explicitProxy?.host
+  });
+  const port = normalizeOptionalPort(explicitProxy?.port) || readExternalProxyPortFromEnv();
+  if (!host || !port) return null;
+  const proxy = {
+    host,
+    port,
+    protocol: normalizeOptionalString(explicitProxy?.protocol) || readExternalProxyProtocolFromEnv() || "http"
+  };
+  const bypass = normalizeOptionalBypass(explicitProxy?.bypass) || readExternalProxyBypassFromEnv();
+  if (bypass) proxy.bypass = bypass;
+  return proxy;
+}
+function buildAppLabNetworkProfile(input, context) {
+  if (!input || input.enabled === false) return null;
+  const mode = normalizeAppLabNetworkMode(input.mode);
+  const capture = {
+    ...isObject(input.capture) ? input.capture : {},
+    enabled: true,
+    mode: mode === "managed-proxy" ? "esvp-managed-proxy" : mode === "app-http-trace" ? "app-http-trace" : "external-proxy",
+    ...mode === "external-mitm" ? { applabMode: "external-mitm" } : {}
+  };
+  const profile = {
+    ...input.profile ? { profile: input.profile } : {},
+    ...input.label ? { label: input.label } : {},
+    ...input.connectivity ? { connectivity: input.connectivity } : {},
+    ...isObject(input.faults) ? { faults: input.faults } : {},
+    capture
+  };
+  if (mode === "managed-proxy" || mode === "app-http-trace") {
+    if (isObject(input.proxy)) {
+      profile.proxy = input.proxy;
+    }
+    return profile;
+  }
+  const resolvedProxy = resolveAppLabExternalProxy({
+    platform: context?.platform,
+    deviceId: context?.deviceId,
+    proxy: isObject(input.proxy) ? input.proxy : null
+  });
+  if (resolvedProxy) {
+    profile.proxy = resolvedProxy;
+  }
+  return profile;
+}
+
+export {
+  inferAppLabExternalProxyHost,
+  buildAppLabNetworkProfile
+};