@veolab/discoverylab 1.1.0 → 1.2.0

package/dist/chunk-2OGZX6C4.js

@@ -0,0 +1,588 @@
+import {
+  PROJECTS_DIR
+} from "./chunk-TJ3H23LL.js";
+
+// src/core/testing/playwright.ts
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import { createRequire } from "module";
+
+// src/core/security/sensitiveInput.ts
+function normalizeHint(value) {
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function buildHintText(context) {
+  if (!context) return "";
+  return [
+    normalizeHint(context.actionType),
+    normalizeHint(context.selector),
+    normalizeHint(context.description),
+    normalizeHint(context.fieldHint)
+  ].filter(Boolean).join(" ");
+}
+function looksLikeEmail(value) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+}
+function looksLikeCpf(value) {
+  const digits = value.replace(/\D/g, "");
+  return digits.length === 11 && /^(\d{3}\.?\d{3}\.?\d{3}-?\d{2})$/.test(value);
+}
+function looksLikeCnpj(value) {
+  const digits = value.replace(/\D/g, "");
+  return digits.length === 14 && /^(\d{2}\.?\d{3}\.?\d{3}\/?\d{4}-?\d{2})$/.test(value);
+}
+function looksLikePhone(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length < 10 || digits.length > 13) return false;
+  return /^\+?[\d\s().-]+$/.test(value);
+}
+function looksLikeMaskedPassword(value) {
+  return /^[*•●·]+$/.test(value);
+}
+function looksLikeNumericCode(value) {
+  const digits = value.replace(/\D/g, "");
+  return digits.length >= 4 && digits.length <= 8 && digits === value.trim();
+}
+function hasAny(hint, patterns) {
+  return patterns.some((pattern) => pattern.test(hint));
+}
+function redactSensitiveTestInput(rawValue, context) {
+  if (typeof rawValue !== "string") return rawValue;
+  const value = rawValue.trim();
+  if (!value) return rawValue;
+  const hint = buildHintText(context);
+  const digits = value.replace(/\D/g, "");
+  const passwordHint = hasAny(hint, [/\bpassword\b/, /\bsenha\b/, /\bpasscode\b/, /\bsecret\b/]);
+  if (passwordHint || looksLikeMaskedPassword(value)) {
+    return "${PASSWORD}";
+  }
+  const tokenHint = hasAny(hint, [/\btoken\b/, /\bapi[-_ ]?key\b/, /\bbearer\b/]);
+  if (tokenHint && value.length >= 6) {
+    return "${SECRET}";
+  }
+  const emailHint = hasAny(hint, [/\bemail\b/, /\be-mail\b/]);
+  if (emailHint || looksLikeEmail(value)) {
+    return "${EMAIL}";
+  }
+  const cpfHint = hasAny(hint, [/\bcpf\b/, /\bdocumento\b/]);
+  if (cpfHint && digits.length === 11 || looksLikeCpf(value)) {
+    return "${CPF}";
+  }
+  const cnpjHint = hasAny(hint, [/\bcnpj\b/]);
+  if (cnpjHint && digits.length === 14 || looksLikeCnpj(value)) {
+    return "${CNPJ}";
+  }
+  const otpHint = hasAny(hint, [/\botp\b/, /\b2fa\b/, /\bpin\b/, /\bverification\b/, /\bcodigo\b/, /\bcódigo\b/, /\bcode\b/]);
+  if (otpHint && looksLikeNumericCode(value)) {
+    return hint.includes("pin") ? "${PIN}" : "${OTP_CODE}";
+  }
+  const phoneHint = hasAny(hint, [/\bphone\b/, /\btelefone\b/, /\bcelular\b/, /\bwhats(app)?\b/, /\btel\b/]);
+  if (phoneHint && digits.length >= 8 && digits.length <= 13 || looksLikePhone(value)) {
+    return "${PHONE}";
+  }
+  const usernameHint = hasAny(hint, [/\busername\b/, /\buser\b/, /\blogin\b/]);
+  if (usernameHint) {
+    return "${USERNAME}";
+  }
+  return rawValue;
+}
+function redactQuotedStringsInText(rawText, context) {
+  if (typeof rawText !== "string" || !rawText) return rawText;
+  return rawText.replace(/"([^"]*)"/g, (_match, quoted) => {
+    const redacted = redactSensitiveTestInput(String(quoted), context);
+    return `"${redacted}"`;
+  });
+}
+
+// src/core/testing/playwright.ts
+var execAsync = promisify(exec);
+var requireFromHere = createRequire(import.meta.url);
+function resolveInstalledPlaywrightVersion() {
+  try {
+    const pkgPath = requireFromHere.resolve("playwright/package.json");
+    const raw = fs.readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    return typeof pkg.version === "string" && pkg.version.trim() ? pkg.version.trim() : "installed";
+  } catch {
+    return null;
+  }
+}
+async function isPlaywrightInstalled() {
+  return !!resolveInstalledPlaywrightVersion();
+}
+async function getPlaywrightVersion() {
+  return resolveInstalledPlaywrightVersion();
+}
+async function installPlaywrightBrowsers() {
+  try {
+    await execAsync("npx playwright install");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var BrowserDevices = {
+  "Desktop Chrome": {
+    name: "Desktop Chrome",
+    viewport: { width: 1280, height: 720 },
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    deviceScaleFactor: 1,
+    isMobile: false,
+    hasTouch: false
+  },
+  "Desktop Safari": {
+    name: "Desktop Safari",
+    viewport: { width: 1280, height: 720 },
+    userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+    deviceScaleFactor: 1,
+    isMobile: false,
+    hasTouch: false
+  },
+  "iPhone 15 Pro": {
+    name: "iPhone 15 Pro",
+    viewport: { width: 393, height: 852 },
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
+    deviceScaleFactor: 3,
+    isMobile: true,
+    hasTouch: true
+  },
+  "iPhone 14": {
+    name: "iPhone 14",
+    viewport: { width: 390, height: 844 },
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
+    deviceScaleFactor: 3,
+    isMobile: true,
+    hasTouch: true
+  },
+  "Pixel 8": {
+    name: "Pixel 8",
+    viewport: { width: 412, height: 915 },
+    userAgent: "Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36",
+    deviceScaleFactor: 2.625,
+    isMobile: true,
+    hasTouch: true
+  },
+  "iPad Pro 12.9": {
+    name: "iPad Pro 12.9",
+    viewport: { width: 1024, height: 1366 },
+    userAgent: "Mozilla/5.0 (iPad; CPU OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
+    deviceScaleFactor: 2,
+    isMobile: true,
+    hasTouch: true
+  }
+};
+function listBrowserDevices() {
+  return Object.values(BrowserDevices);
+}
+function getBrowserDevice(name) {
+  return BrowserDevices[name] || null;
+}
+function generatePlaywrightScript(script) {
+  const { name, baseURL, viewport, actions } = script;
+  const lines = [
+    "import { test, expect } from '@playwright/test';",
+    ""
+  ];
+  lines.push(`test('${name || "Generated Test"}', async ({ page }) => {`);
+  if (viewport) {
+    lines.push(`  await page.setViewportSize({ width: ${viewport.width}, height: ${viewport.height} });`);
+  }
+  if (baseURL) {
+    lines.push(`  await page.goto('${baseURL}');`);
+  }
+  for (const action of actions) {
+    const code = generateActionCode(action);
+    if (code) {
+      lines.push(`  ${code}`);
+    }
+  }
+  lines.push("});");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateActionCode(action) {
+  const { type, selector, value, url, key, options } = action;
+  switch (type) {
+    case "goto":
+      return `await page.goto('${url || ""}');`;
+    case "click":
+      if (!selector) return null;
+      return `await page.click('${selector}');`;
+    case "fill":
+      if (!selector) return null;
+      return `await page.fill('${selector}', '${redactSensitiveTestInput(String(value || ""), { actionType: "fill", selector })}');`;
+    case "type":
+      if (!selector) return null;
+      return `await page.type('${selector}', '${redactSensitiveTestInput(String(value || ""), { actionType: "type", selector })}');`;
+    case "press":
+      if (!selector) return null;
+      return `await page.press('${selector}', '${key || "Enter"}');`;
+    case "check":
+      if (!selector) return null;
+      return `await page.check('${selector}');`;
+    case "uncheck":
+      if (!selector) return null;
+      return `await page.uncheck('${selector}');`;
+    case "selectOption":
+      if (!selector) return null;
+      return `await page.selectOption('${selector}', '${value || ""}');`;
+    case "hover":
+      if (!selector) return null;
+      return `await page.hover('${selector}');`;
+    case "focus":
+      if (!selector) return null;
+      return `await page.focus('${selector}');`;
+    case "screenshot":
+      return `await page.screenshot({ path: '${value || "screenshot.png"}' });`;
+    case "wait":
+      return `await page.waitForTimeout(${value || 1e3});`;
+    case "waitForSelector":
+      if (!selector) return null;
+      return `await page.waitForSelector('${selector}');`;
+    case "waitForURL":
+      return `await page.waitForURL('${url || ""}');`;
+    case "expectVisible":
+      if (!selector) return null;
+      return `await expect(page.locator('${selector}')).toBeVisible();`;
+    case "expectHidden":
+      if (!selector) return null;
+      return `await expect(page.locator('${selector}')).toBeHidden();`;
+    case "expectText":
+      if (!selector) return null;
+      return `await expect(page.locator('${selector}')).toHaveText('${value || ""}');`;
+    case "expectURL":
+      return `await expect(page).toHaveURL('${url || ""}');`;
+    case "expectTitle":
+      return `await expect(page).toHaveTitle('${value || ""}');`;
+    case "scroll":
+      if (selector) {
+        return `await page.locator('${selector}').scrollIntoViewIfNeeded();`;
+      }
+      return `await page.evaluate(() => window.scrollBy(0, ${value || 500}));`;
+    case "evaluate":
+      return `await page.evaluate(() => { ${value || ""} });`;
+    default:
+      return null;
+  }
+}
+var PlaywrightActions = {
+  // Navigation
+  goto: (url) => ({ type: "goto", url }),
+  goBack: () => ({ type: "evaluate", value: "history.back()" }),
+  goForward: () => ({ type: "evaluate", value: "history.forward()" }),
+  reload: () => ({ type: "evaluate", value: "location.reload()" }),
+  // Interactions
+  click: (selector) => ({ type: "click", selector }),
+  fill: (selector, value) => ({ type: "fill", selector, value }),
+  type: (selector, value) => ({ type: "type", selector, value }),
+  press: (selector, key) => ({ type: "press", selector, key }),
+  check: (selector) => ({ type: "check", selector }),
+  uncheck: (selector) => ({ type: "uncheck", selector }),
+  selectOption: (selector, value) => ({ type: "selectOption", selector, value }),
+  hover: (selector) => ({ type: "hover", selector }),
+  focus: (selector) => ({ type: "focus", selector }),
+  // Waiting
+  wait: (ms) => ({ type: "wait", value: String(ms) }),
+  waitForSelector: (selector) => ({ type: "waitForSelector", selector }),
+  waitForURL: (url) => ({ type: "waitForURL", url }),
+  // Screenshots
+  screenshot: (path2) => ({ type: "screenshot", value: path2 }),
+  // Scrolling
+  scroll: (pixels) => ({ type: "scroll", value: String(pixels || 500) }),
+  scrollToElement: (selector) => ({ type: "scroll", selector }),
+  // Assertions
+  expectVisible: (selector) => ({ type: "expectVisible", selector }),
+  expectHidden: (selector) => ({ type: "expectHidden", selector }),
+  expectText: (selector, text) => ({ type: "expectText", selector, value: text }),
+  expectURL: (url) => ({ type: "expectURL", url }),
+  expectTitle: (title) => ({ type: "expectTitle", value: title }),
+  // Custom
+  evaluate: (code) => ({ type: "evaluate", value: code })
+};
+async function runPlaywrightTest(options) {
+  const installed = await isPlaywrightInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: "Playwright is not installed. Install with: npm install -D @playwright/test && npx playwright install"
+    };
+  }
+  const {
+    testPath,
+    testPattern,
+    config = {},
+    outputDir = path.join(PROJECTS_DIR, "playwright-output", Date.now().toString()),
+    project,
+    workers = 1,
+    retries = 0,
+    reporter = "json"
+  } = options;
+  await fs.promises.mkdir(outputDir, { recursive: true });
+  const startTime = Date.now();
+  const args = ["playwright", "test"];
+  if (testPath) {
+    args.push(testPath);
+  }
+  if (testPattern) {
+    args.push("-g", testPattern);
+  }
+  if (project) {
+    args.push("--project", project);
+  }
+  args.push("--workers", workers.toString());
+  if (retries > 0) {
+    args.push("--retries", retries.toString());
+  }
+  args.push("--reporter", reporter);
+  args.push("--output", outputDir);
+  if (config.browser) {
+    args.push("--browser", config.browser);
+  }
+  if (config.headless === false) {
+    args.push("--headed");
+  }
+  try {
+    const { stdout, stderr } = await execAsync(`npx ${args.join(" ")}`, {
+      timeout: config.timeout || 3e5,
+      cwd: process.cwd()
+    });
+    const duration = Date.now() - startTime;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const passedMatch = stdout.match(/(\d+) passed/);
+    const failedMatch = stdout.match(/(\d+) failed/);
+    const skippedMatch = stdout.match(/(\d+) skipped/);
+    if (passedMatch) passed = parseInt(passedMatch[1], 10);
+    if (failedMatch) failed = parseInt(failedMatch[1], 10);
+    if (skippedMatch) skipped = parseInt(skippedMatch[1], 10);
+    const videos = [];
+    const screenshots = [];
+    const traces = [];
+    if (fs.existsSync(outputDir)) {
+      const collectArtifacts = async (dir) => {
+        const files = await fs.promises.readdir(dir, { withFileTypes: true });
+        for (const file of files) {
+          const filePath = path.join(dir, file.name);
+          if (file.isDirectory()) {
+            await collectArtifacts(filePath);
+          } else if (file.name.endsWith(".webm") || file.name.endsWith(".mp4")) {
+            videos.push(filePath);
+          } else if (file.name.endsWith(".png")) {
+            screenshots.push(filePath);
+          } else if (file.name.endsWith(".zip") && file.name.includes("trace")) {
+            traces.push(filePath);
+          }
+        }
+      };
+      await collectArtifacts(outputDir);
+    }
+    return {
+      success: failed === 0,
+      duration,
+      passed,
+      failed,
+      skipped,
+      output: stdout + stderr,
+      reportPath: path.join(outputDir, "report.json"),
+      videos,
+      screenshots,
+      traces
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const message = error instanceof Error ? error.message : String(error);
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const passedMatch = message.match(/(\d+) passed/);
+    const failedMatch = message.match(/(\d+) failed/);
+    const skippedMatch = message.match(/(\d+) skipped/);
+    if (passedMatch) passed = parseInt(passedMatch[1], 10);
+    if (failedMatch) failed = parseInt(failedMatch[1], 10);
+    if (skippedMatch) skipped = parseInt(skippedMatch[1], 10);
+    return {
+      success: false,
+      error: message,
+      duration,
+      passed,
+      failed,
+      skipped,
+      output: message
+    };
+  }
+}
+async function runPlaywrightScript(script, options = {}) {
+  const outputDir = options.outputDir || path.join(PROJECTS_DIR, "playwright-output", Date.now().toString());
+  await fs.promises.mkdir(outputDir, { recursive: true });
+  const scriptContent = generatePlaywrightScript(script);
+  const scriptPath = path.join(outputDir, "test.spec.ts");
+  await fs.promises.writeFile(scriptPath, scriptContent);
+  const configContent = `
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: '.',
+  timeout: ${options.config?.timeout || 3e4},
+  use: {
+    headless: ${options.config?.headless !== false},
+    video: '${options.config?.video || "off"}',
+    screenshot: '${options.config?.screenshot || "off"}',
+    trace: '${options.config?.trace || "off"}',
+    ${script.baseURL ? `baseURL: '${script.baseURL}',` : ""}
+    ${script.viewport ? `viewport: { width: ${script.viewport.width}, height: ${script.viewport.height} },` : ""}
+  },
+  reporter: [['json', { outputFile: 'report.json' }]],
+  outputDir: './results',
+});
+`;
+  const configPath = path.join(outputDir, "playwright.config.ts");
+  await fs.promises.writeFile(configPath, configContent);
+  return runPlaywrightTest({
+    ...options,
+    testPath: scriptPath,
+    outputDir
+  });
+}
+async function savePlaywrightScript(script, outputPath) {
+  const content = generatePlaywrightScript(script);
+  const filePath = outputPath || path.join(
+    PROJECTS_DIR,
+    "scripts",
+    `${script.name?.replace(/\s+/g, "_") || "test"}_${Date.now()}.spec.ts`
+  );
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, content);
+  return filePath;
+}
+async function startPlaywrightCodegen(url, options = {}) {
+  const installed = await isPlaywrightInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: "Playwright is not installed"
+    };
+  }
+  try {
+    const args = ["playwright", "codegen"];
+    if (options.browser) {
+      args.push("--browser", options.browser);
+    }
+    if (options.device) {
+      args.push("--device", `"${options.device}"`);
+    }
+    if (options.outputPath) {
+      args.push("-o", options.outputPath);
+    }
+    if (url) {
+      args.push(url);
+    }
+    spawn("npx", args, {
+      detached: true,
+      stdio: "ignore",
+      shell: true
+    }).unref();
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function showPlaywrightReport(reportDir) {
+  const installed = await isPlaywrightInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: "Playwright is not installed"
+    };
+  }
+  try {
+    const args = ["playwright", "show-report"];
+    if (reportDir) {
+      args.push(reportDir);
+    }
+    spawn("npx", args, {
+      detached: true,
+      stdio: "ignore",
+      shell: true
+    }).unref();
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createLoginScript(baseURL, usernameSelector, passwordSelector, submitSelector, successURL) {
+  return {
+    name: "Login Test",
+    baseURL,
+    actions: [
+      PlaywrightActions.goto(baseURL),
+      PlaywrightActions.fill(usernameSelector, "${USERNAME}"),
+      PlaywrightActions.fill(passwordSelector, "${PASSWORD}"),
+      PlaywrightActions.click(submitSelector),
+      PlaywrightActions.waitForURL(successURL),
+      PlaywrightActions.expectURL(successURL),
+      PlaywrightActions.screenshot("login-success.png")
+    ]
+  };
+}
+function createNavigationScript(baseURL, links) {
+  const actions = [PlaywrightActions.goto(baseURL)];
+  for (const link of links) {
+    actions.push(PlaywrightActions.click(link.selector));
+    actions.push(PlaywrightActions.waitForURL(link.expectedURL));
+    actions.push(PlaywrightActions.screenshot(`${link.name}.png`));
+    actions.push(PlaywrightActions.goBack());
+  }
+  return {
+    name: "Navigation Test",
+    baseURL,
+    actions
+  };
+}
+function createFormSubmissionScript(baseURL, formFields, submitSelector, successIndicator) {
+  const actions = [PlaywrightActions.goto(baseURL)];
+  for (const field of formFields) {
+    actions.push(PlaywrightActions.fill(field.selector, field.value));
+  }
+  actions.push(PlaywrightActions.click(submitSelector));
+  actions.push(PlaywrightActions.waitForSelector(successIndicator));
+  actions.push(PlaywrightActions.expectVisible(successIndicator));
+  actions.push(PlaywrightActions.screenshot("form-success.png"));
+  return {
+    name: "Form Submission Test",
+    baseURL,
+    actions
+  };
+}
+
+export {
+  redactSensitiveTestInput,
+  redactQuotedStringsInText,
+  isPlaywrightInstalled,
+  getPlaywrightVersion,
+  installPlaywrightBrowsers,
+  BrowserDevices,
+  listBrowserDevices,
+  getBrowserDevice,
+  generatePlaywrightScript,
+  PlaywrightActions,
+  runPlaywrightTest,
+  runPlaywrightScript,
+  savePlaywrightScript,
+  startPlaywrightCodegen,
+  showPlaywrightReport,
+  createLoginScript,
+  createNavigationScript,
+  createFormSubmissionScript
+};