@veolab/discoverylab 1.3.1 → 1.3.3

package/dist/chunk-GAKEFJ5T.js

@@ -1,481 +0,0 @@
-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
-};