@continuum8032/playwright-ai-tools 0.2.0-oidc-bootstrap.0

package/dist/chunk-QL3XW2UN.js

@@ -0,0 +1,205 @@
+// src/trace.ts
+import { readFile } from "fs/promises";
+import { inflateRawSync } from "zlib";
+import path from "path";
+function parseEvents(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) return parsed;
+    if (Array.isArray(parsed.events)) return parsed.events;
+    if (Array.isArray(parsed.traceEvents)) return parsed.traceEvents;
+    return [parsed];
+  } catch {
+    return trimmed.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  }
+}
+function isZip(buffer, filePath) {
+  return path.extname(filePath).toLowerCase() === ".zip" || buffer.readUInt32LE(0) === 67324752;
+}
+function isTextTraceEntry(name) {
+  const lower = name.toLowerCase();
+  if (lower.startsWith("resources/")) return false;
+  return lower.endsWith(".trace") || lower.endsWith(".network") || lower.endsWith(".json") || lower.endsWith(".jsonl") || lower.includes("trace") || lower.includes("network");
+}
+function findEndOfCentralDirectory(buffer) {
+  for (let index = buffer.length - 22; index >= 0; index -= 1) {
+    if (buffer.readUInt32LE(index) === 101010256) return index;
+  }
+  throw new Error("ZIP central directory not found in trace artifact");
+}
+function extractZipTexts(buffer) {
+  const eocd = findEndOfCentralDirectory(buffer);
+  const totalEntries = buffer.readUInt16LE(eocd + 10);
+  let offset = buffer.readUInt32LE(eocd + 16);
+  const texts = [];
+  for (let entry = 0; entry < totalEntries; entry += 1) {
+    if (buffer.readUInt32LE(offset) !== 33639248) break;
+    const method = buffer.readUInt16LE(offset + 10);
+    const compressedSize = buffer.readUInt32LE(offset + 20);
+    const nameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const localOffset = buffer.readUInt32LE(offset + 42);
+    const name = buffer.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
+    offset += 46 + nameLength + extraLength + commentLength;
+    if (!isTextTraceEntry(name) || buffer.readUInt32LE(localOffset) !== 67324752) continue;
+    const localNameLength = buffer.readUInt16LE(localOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    const compressed = buffer.subarray(dataStart, dataStart + compressedSize);
+    if (method === 0) {
+      texts.push(compressed.toString("utf8"));
+    } else if (method === 8) {
+      texts.push(inflateRawSync(compressed).toString("utf8"));
+    }
+  }
+  return texts;
+}
+async function readTraceTexts(filePath) {
+  const buffer = await readFile(filePath);
+  if (isZip(buffer, filePath)) {
+    return extractZipTexts(buffer);
+  }
+  return [buffer.toString("utf8")];
+}
+function timestamp(event) {
+  return event.wallTime || event.timestamp || event.time;
+}
+function actionFromEvent(event) {
+  const name = event.apiName || event.method || event.action;
+  if (!name) return null;
+  return {
+    name: String(name),
+    selector: event.selector || event.params?.selector,
+    url: event.url || event.params?.url,
+    timestamp: timestamp(event),
+    pageId: event.pageId
+  };
+}
+function consoleFromEvent(event) {
+  const level = String(event.level || event.messageType || "").toLowerCase();
+  const text = event.text || event.message || event.args?.join?.(" ");
+  if (!text || !["error", "warning", "warn"].includes(level)) return null;
+  return {
+    level: level === "warn" ? "warning" : level,
+    text: String(text),
+    url: event.location?.url || event.url,
+    lineNumber: event.location?.lineNumber,
+    columnNumber: event.location?.columnNumber,
+    timestamp: timestamp(event)
+  };
+}
+function networkFromEvent(event) {
+  const snapshot = event.snapshot || event;
+  const request = snapshot.request || event.request || {};
+  const response = snapshot.response || event.response || {};
+  const url = request.url || event.url;
+  const status = Number(response.status ?? event.status ?? 0);
+  const errorText = event.errorText || snapshot.errorText || response.errorText;
+  if (!url || status < 400 && !errorText) return null;
+  return {
+    url: String(url),
+    method: request.method || event.method,
+    status: status || void 0,
+    statusText: response.statusText,
+    errorText,
+    timestamp: timestamp(event)
+  };
+}
+function trimLastActions(actions) {
+  return actions.slice(-10);
+}
+async function parseTraceArtifact(filePath) {
+  const texts = await readTraceTexts(filePath);
+  const events = texts.flatMap(parseEvents);
+  const summary = {
+    consoleErrors: [],
+    networkFailures: [],
+    lastActions: [],
+    artifactRefs: [{ type: "trace", path: filePath }]
+  };
+  for (const event of events) {
+    if (!event || typeof event !== "object") continue;
+    if (event.type === "context-options" || event.browserName || event.viewport) {
+      const { type: _type, ...context } = event;
+      summary.browserContext = { ...summary.browserContext || {}, ...context };
+    }
+    if (event.type === "before" || event.type === "action") {
+      const action = actionFromEvent(event);
+      if (action) summary.lastActions = trimLastActions([...summary.lastActions, action]);
+    }
+    if (event.type === "after" && event.result) {
+      summary.page = {
+        ...summary.page || {},
+        url: event.result.url || summary.page?.url,
+        title: event.result.title || summary.page?.title
+      };
+    }
+    const consoleEvent = consoleFromEvent(event);
+    if (consoleEvent) summary.consoleErrors.push(consoleEvent);
+    const networkEvent = networkFromEvent(event);
+    if (networkEvent) summary.networkFailures.push(networkEvent);
+    const snapshot = event.snapshot?.html || event.snapshot?.body || event.html;
+    if (event.type === "page-snapshot" && snapshot) {
+      summary.pageSnapshot = String(snapshot);
+      summary.page = { ...summary.page || {}, snapshot: summary.pageSnapshot };
+    }
+  }
+  return summary;
+}
+
+// src/evidence.ts
+import path2 from "path";
+function isTraceArtifact(artifact) {
+  const haystack = `${artifact.type} ${artifact.path} ${artifact.contentType || ""}`.toLowerCase();
+  return haystack.includes("trace") || haystack.includes("jsonl") || haystack.includes("application/zip");
+}
+function resolveArtifactPath(artifactPath, root) {
+  if (path2.isAbsolute(artifactPath)) return artifactPath;
+  return path2.resolve(root || process.cwd(), artifactPath);
+}
+async function enrichFailureWithArtifacts(failure, options = {}) {
+  const artifacts = failure.artifacts || [];
+  const artifactRefs = [...failure.artifactRefs || [], ...artifacts];
+  let enriched = { ...failure, artifactRefs };
+  for (const artifact of artifacts.filter(isTraceArtifact)) {
+    let trace;
+    try {
+      trace = await parseTraceArtifact(resolveArtifactPath(artifact.path, options.artifactRoot));
+    } catch (error) {
+      enriched = {
+        ...enriched,
+        artifactRefs: [
+          ...artifactRefs,
+          {
+            ...artifact,
+            metadata: {
+              ...artifact.metadata || {},
+              parseError: error?.message || String(error)
+            }
+          }
+        ]
+      };
+      continue;
+    }
+    enriched = {
+      ...enriched,
+      trace,
+      browserContext: trace.browserContext || enriched.browserContext,
+      page: trace.page || enriched.page,
+      pageSnapshot: trace.pageSnapshot || enriched.pageSnapshot,
+      consoleErrors: [...enriched.consoleErrors || [], ...trace.consoleErrors],
+      networkFailures: [...enriched.networkFailures || [], ...trace.networkFailures],
+      lastActions: [...enriched.lastActions || [], ...trace.lastActions].slice(-10),
+      artifactRefs: [...artifactRefs, ...trace.artifactRefs]
+    };
+  }
+  return enriched;
+}
+
+export {
+  parseTraceArtifact,
+  enrichFailureWithArtifacts
+};