npm - @checksum-ai/runtime - Versions diffs - 4.16.2 → 4.16.3 - Mend

@checksum-ai/runtime 4.16.2 → 4.16.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/.env +1 -1
package/README.md +8 -9
package/checksum-root/checksum.config.ts +2 -2
package/checksumlib.js +1 -1
package/cli.js +115 -122
package/index.d.ts +0 -2
package/index.js +1 -1
package/package.json +2 -2
package/scripts/patch.js +1 -11
package/scripts/playwright_patches/1.41.2.js +16 -31
package/scripts/playwright_patches/1.46.0.js +6 -59
package/scripts/playwright_patches/1.51.0.js +6 -70
package/scripts/playwright_patches/1.52.0.js +5 -53
package/scripts/playwright_patches/1.56.1.js +5 -47
package/scripts/playwright_patches/1.59.0.js +5 -47
package/scripts/playwright_patches/1.62.1.js +562 -0
package/test-run-monitor.js +1 -1

package/scripts/playwright_patches/1.62.1.js ADDED Viewed

@@ -0,0 +1,562 @@
+const fs = require("fs");
+const crypto = require("crypto");
+const { join } = require("path");
+// Args
+const on = process.argv[2] !== "off";
+// -------- [Modifiers] -------- //
+// Amends the file with the given entry point text and append text
+// When "on" is true, the append text is added to the entry point,
+// otherwise the append text is completely removed from the file
+function amend(filePath, entryPointText, appendText) {
+  const data = fs.readFileSync(filePath, "utf8");
+  if (!data.includes(entryPointText)) {
+    throw new Error("Entry point not found!", entryPointText);
+  }
+  // Ignore if the append text is already present
+  if (on && data.includes(appendText)) {
+    return;
+  }
+  // Add or clear according to on state
+  const result = on
+    ? data.replace(entryPointText, entryPointText + appendText)
+    : data.replace(appendText, "");
+  // Write
+  fs.writeFileSync(filePath, result, "utf8");
+}
+// Bracket each injected block with a per-patch unique marker derived from a
+// hash of `originalContent`. This guarantees OFF mode reverts only the patch
+// that produced the marker, instead of accidentally matching another patch's
+// shared `/* checksumai */ ` prefix (which previously caused
+// `alwaysInjectScripts` OFF — whose newContent collapses to the bare marker —
+// to clobber the FIRST `/* checksumai */ ` it found, corrupting whichever
+// patch happened to live at the lowest line number).
+//
+// Backward-compat for the legacy single-marker format: in OFF mode, if the
+// new bracketed form is not present but the legacy `/* checksumai */ <body>`
+// form is, revert that and exit. New ON installs always write the bracketed
+// form.
+function replaceContent(filePath, originalContent, newContent) {
+  const fileContent = fs.readFileSync(filePath, "utf8");
+  const id = crypto
+    .createHash("sha1")
+    .update(originalContent)
+    .digest("hex")
+    .slice(0, 8);
+  const openMarker = `/*checksumai:${id}*/`;
+  const closeMarker = `/*checksumai:end:${id}*/`;
+  const taggedNewContent = `${openMarker}${newContent}${closeMarker}`;
+  if (on) {
+    if (fileContent.includes(taggedNewContent)) {
+      // Already patched.
+      return;
+    }
+    if (!fileContent.includes(originalContent)) {
+      // Nothing to replace. Either already migrated to a different shape or
+      // the playwright internals changed and this patch needs updating.
+      return;
+    }
+    fs.writeFileSync(
+      filePath,
+      fileContent.replace(originalContent, taggedNewContent),
+      "utf8"
+    );
+    return;
+  }
+  // OFF: precise revert via the unique bracketed block.
+  if (fileContent.includes(taggedNewContent)) {
+    fs.writeFileSync(
+      filePath,
+      fileContent.replace(taggedNewContent, originalContent),
+      "utf8"
+    );
+    return;
+  }
+  // OFF (legacy): older patched files used `/* checksumai */ ${newContent}`
+  // with a shared marker. Revert that exact body if present so users coming
+  // from a previous runtime version aren't stranded with stale injections.
+  const legacyTagged = `/* checksumai */ ${newContent}`;
+  if (fileContent.includes(legacyTagged)) {
+    fs.writeFileSync(
+      filePath,
+      fileContent.replace(legacyTagged, originalContent),
+      "utf8"
+    );
+  }
+}
+function doesFileExist(filePath) {
+  if (!fs.existsSync(filePath)) {
+    console.warn("File not found", filePath);
+    return false;
+  }
+  return true;
+}
+// -------- [Modifications] -------- //
+// File targets are unchanged from 1.60 (the big lib/ -> esbuild-bundle
+// collapse landed there):
+//   playwright-core/lib/coreBundle.js
+//   playwright/lib/worker/workerProcessEntry.js
+//   playwright/lib/common/index.js
+//   playwright/lib/index.js
+//   playwright/lib/runner/index.js
+//
+// 1.60 -> 1.62 moved three anchors:
+//   - `_wrapApiCall(func, options2)` -> `_wrapApiCall(func, options)`; the
+//     esbuild dedup suffix on `options` disappeared, so every `options2`
+//     reference in the channelOwner patch reverts to `options`.
+//   - `_failWithError(error)` -> `_failWithError(root)`; the method now walks
+//     an error tree via a local `visit()`.
+//   - Inside workerProcessEntry the helpers are no longer namespaced imports:
+//     `(0, import_util2.testInfoError)` -> `testInfoError` and
+//     `(0, import_utils.stringifyStackFrames)` -> `stringifyStackFrames2`.
+// `import_fs5`, `toPosixPath2` and `import_path8` in runner/index.js kept
+// their 1.60 suffixes — but these are build-pipeline artifacts, so re-validate
+// every anchor on each upgrade rather than assuming the previous patch applies.
+// Remove conditions for injecting Playwright scripts
+function alwaysInjectScripts(projectRoot) {
+  const file = join(
+    projectRoot,
+    "node_modules/playwright-core/lib/coreBundle.js"
+  );
+  if (!doesFileExist(file)) {
+    return;
+  }
+  const originalContent = 'if (debugMode() === "console")';
+  const newContent = "";
+  replaceContent(file, originalContent, newContent);
+}
+// Add implementation for generateSelectorAndLocator and inject to Playwright console API
+function addGenerateSelectorAndLocator(projectRoot) {
+  const file = join(
+    projectRoot,
+    "node_modules/playwright-core/lib/coreBundle.js"
+  );
+  if (!doesFileExist(file)) {
+    return;
+  }
+  const entryPointText1 = "this._generateLocator(element, language),\\n      ";
+  const appendText1 =
+    "generateSelectorAndLocator: (element, language) => this._generateSelectorAndLocator(element, language),\\n asLocator,\\n     ";
+  amend(file, entryPointText1, appendText1);
+  const entryPointText2 = `return asLocator(language || "javascript", selector);\\n  }\\n  `;
+  const appendText2 =
+    '_generateSelectorAndLocator(element, language) {\\n    if (!(element instanceof Element))\\n      throw new Error(`Usage: playwright.locator(element).`);\\n    const selector = this._injectedScript.generateSelectorSimple(element);\\n    return {selector, locator: asLocator(language || \\"javascript\\", selector)};\\n  }\\n  ';
+  amend(file, entryPointText2, appendText2);
+}
+// -------- [Runtime modifications] -------- //
+function expect(projectRoot) {
+  const file = join(
+    projectRoot,
+    "node_modules/playwright/lib/matchers/expect.js"
+  );
+  if (!doesFileExist(file)) {
+    return;
+  }
+  let originalContent, newContent;
+  // originalContent = `return (...args) => {
+  //     const testInfo = (0, _globals.currentTestInfo)();`;
+  // newContent = `return (...args) => {
+  //     let noSoft = false;
+  //     if (args.find(arg=>arg==='no-soft')){
+  //       noSoft = true;
+  //       args.pop();
+  //     }
+  //     const testInfo = (0, _globals.currentTestInfo)();`;
+  // replaceContent(file, originalContent, newContent);
+  // originalContent = `step.complete({
+  //         error
+  //       })`;
+  // newContent = `step.complete({
+  //         error,
+  //         noSoft
+  //       })`;
+  // replaceContent(file, originalContent, newContent);
+  // originalContent = `if (this._info.isSoft) testInfo._failWithError(error);else throw error;`;
+  // newContent = `if (this._info.isSoft && !noSoft) testInfo._failWithError(error);else throw error;`;
+  // replaceContent(file, originalContent, newContent);
+}
+function testInfo(projectRoot) {
+  const file = join(
+    projectRoot,
+    "node_modules/playwright/lib/worker/workerProcessEntry.js"
+  );
+  if (!doesFileExist(file)) {
+    return;
+  }
+  let originalContent, newContent;
+  let entryPointText, appendText;
+  // originalContent = `const filteredStack = (0, _util.filteredStackTrace)((0, _utils.captureRawStack)());`;
+  // newContent = `const filteredStack = (0, _util.filteredStackTrace)((0, _utils.captureRawStack)().filter(s=>!s.includes('@checksum-ai/runtime')));`;
+  // replaceContent(file, originalContent, newContent);
+  entryPointText = `location = location || filteredStack[0];`;
+  appendText = `\nif (this._checksumInternal) {
+      location = undefined;
+      this._checksumInternal = false;
+    }
+    if (this._checksumNoLocation){
+      location = undefined;
+    }`;
+  amend(file, entryPointText, appendText);
+  originalContent = `if (childStep.error && childStep.infectParentStepsWithError) {`;
+  newContent = `if (childStep.error && childStep.infectParentStepsWithError && !step.preventInfectParentStepsWithError) {`;
+  replaceContent(file, originalContent, newContent);
+  originalContent = `_failWithError(root) {`;
+  newContent = `addError(error, message) {
+    const serialized = testInfoError(error);
+    serialized.message = [message, serialized.message].join('\\n\\n');
+    serialized.stack = [message, serialized.stack].join('\\n\\n');
+    const step = error[stepSymbol];
+    if (step && step.boxedStack) serialized.stack = \`\${error.name}: \${error.message}\\n\${stringifyStackFrames2(step.boxedStack).join('\\n')}\`;
+    this.errors.push(serialized);
+  }
+  _failWithError(root) {`;
+  replaceContent(file, originalContent, newContent);
+}
+function testType(projectRoot) {
+  const file = join(projectRoot, "node_modules/playwright/lib/common/index.js");
+  if (!doesFileExist(file)) {
+    return;
+  }
+  entryPointText = `return await currentZone().with("stepZone", step).run(async () => {`;
+  appendText = `\nif (options.obtainStep){
+        options.obtainStep(step);
+      }`;
+  amend(file, entryPointText, appendText);
+}
+function indexContent(projectRoot) {
+  const file = join(projectRoot, "node_modules/playwright/lib/index.js");
+  if (!doesFileExist(file)) {
+    return;
+  }
+  let originalContent, newContent;
+  originalContent = `const browser = await playwright[browserName].launch();`;
+  newContent = `
+    let browser = playwright[browserName];
+    try {
+      const { playwrightExtra } = workerInfo?.project?.use || {};
+      if (playwrightExtra && playwrightExtra?.length) {
+        const pw = require("playwright-extra")
+        const PupeteerExtraPlugin = require("puppeteer-extra-plugin").PuppeteerExtraPlugin
+        const chromium = pw.chromium;
+        playwrightExtra.forEach((plugin, i) => {
+          try {
+            if(!(plugin instanceof PupeteerExtraPlugin)){
+              console.warn(\`Plugin at index \${i} is not an instance of PupeteerExtraPlugin\`);
+            }
+            chromium.use(plugin);
+          } catch (e) {
+            console.warn(e);
+          }
+        });
+        browser = chromium;
+      }
+    } catch (e) {
+      console.warn(
+        "CHECKSUM: Failed to load Playwright Extra, using Playwright instead.",
+        e
+      );
+    }
+    browser = await browser.launch();
+  `;
+  replaceContent(file, originalContent, newContent);
+}
+function channelOwner(projectRoot) {
+  const file = join(
+    projectRoot,
+    "node_modules/playwright-core/lib/coreBundle.js"
+  );
+  if (!doesFileExist(file)) {
+    return;
+  }
+  let originalContent, newContent;
+  let entryPointText, appendText;
+  entryPointText = `async _wrapApiCall(func, options) {`;
+  appendText = `\nif (this._checksumInternal){
+      options = options || {};
+      options.internal = true;
+    }`;
+  amend(file, entryPointText, appendText);
+  entryPointText = `const apiZone = { title: options?.title, apiName: stackTrace.apiName, frames: stackTrace.frames, internal: options?.internal ?? false, reported: false, userData: void 0, stepId: void 0 };`;
+  appendText = `\nif (!apiZone.internal && this._checksumTitle){
+      apiZone.apiName = this._checksumTitle;
+      this._checksumTitle = undefined;
+    }
+    if (!apiZone.apiName){
+      options = options || {};
+      options.internal = true;
+      apiZone.internal = true;
+      apiZone.reported = true;
+    }
+    if (apiZone.apiName && apiZone.apiName.startsWith('proxy')) {
+      apiZone.apiName = apiZone.apiName.replace('proxy', 'page');
+    }`;
+  amend(file, entryPointText, appendText);
+}
+function stackTrace(projectRoot) {
+  const file = join(
+    projectRoot,
+    "node_modules/playwright-core/lib/coreBundle.js"
+  );
+  if (!doesFileExist(file)) {
+    return;
+  }
+  let originalContent, newContent;
+  // Create a regex for getting a file for each line in the stacktrace that overrides the original regex
+  // This regex is only used for getting files, the original regex is sitll used for the rest of the content
+  originalContent = `let file = match[7];`;
+  const fileRe = /(\/.*?\.[a-zA-Z0-9]+)(?=:\d+:\d+)/;
+  newContent = `
+  const fileRe = new RegExp(${JSON.stringify(fileRe.source)}, "${
+    fileRe.flags
+  }");
+  const m = fileRe.exec(match[0] ?? "");
+  let file = m ? m[1] : undefined;
+  `;
+  replaceContent(file, originalContent, newContent);
+  // Filter out checksum-ai/runtime from stack traces
+  originalContent = `return stack.split("\\n");`;
+  newContent = `return stack.split("\\n").filter(s=>!s.includes('@checksum-ai/runtime'));`;
+  replaceContent(file, originalContent, newContent);
+}
+function reportTraceFile(projectRoot) {
+  const file = join(projectRoot, "node_modules/playwright/lib/runner/index.js");
+  if (!doesFileExist(file)) {
+    return;
+  }
+  let originalContent, newContent;
+  originalContent = `const buffer = import_fs5.default.readFileSync(a.path);`;
+  newContent = `let buffer = import_fs5.default.readFileSync(a.path);
+          if (a.name === "trace") {
+            let retries = 2;
+            while (!buffer.slice(0,100).toString().startsWith("checksum-playwright-trace") && retries > 0) {
+              Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5000);
+              buffer = import_fs5.default.readFileSync(a.path)
+              retries--;
+            }
+          }`;
+  replaceContent(file, originalContent, newContent);
+}
+function htmlReporter(projectRoot) {
+  const file = join(projectRoot, "node_modules/playwright/lib/runner/index.js");
+  if (!doesFileExist(file)) {
+    return;
+  }
+  let originalContent, newContent;
+  // Filter out runtime files from snippet generation
+  originalContent = `function createSnippets(stepsInFile) {
+  for (const file of stepsInFile.keys()) {
+    let source;
+    try {
+      source = import_fs5.default.readFileSync(file, "utf-8") + "\\n//";
+    } catch (e) {
+      continue;
+    }`;
+  newContent = `function createSnippets(stepsInFile) {
+  for (const file of stepsInFile.keys()) {
+    // Skip runtime files to reduce report size
+    if (file.includes('@checksum-ai/runtime') || file.includes('node_modules')) {
+      continue;
+    }
+    let source;
+    try {
+      source = import_fs5.default.readFileSync(file, "utf-8") + "\\n//";
+    } catch (e) {
+      continue;
+    }`;
+  replaceContent(file, originalContent, newContent);
+  // Also filter from error codeframe generation
+  originalContent = `function createErrorCodeframe(message, location) {
+  let source;
+  try {
+    source = import_fs5.default.readFileSync(location.file, "utf-8") + "\\n//";
+  } catch (e) {
+    return;
+  }`;
+  newContent = `function createErrorCodeframe(message, location) {
+  // Skip runtime files to reduce report size
+  if (location.file && (location.file.includes('@checksum-ai/runtime') || location.file.includes('node_modules'))) {
+    return;
+  }
+  let source;
+  try {
+    source = import_fs5.default.readFileSync(location.file, "utf-8") + "\\n//";
+  } catch (e) {
+    return;
+  }`;
+  replaceContent(file, originalContent, newContent);
+  // Filter out steps with locations in runtime/node_modules files completely
+  originalContent = `_createTestStep(dedupedStep, result) {
+    const { step, duration, count } = dedupedStep;
+    const skipped = dedupedStep.step.annotations?.find((a) => a.type === "skip");
+    let title = step.title;
+    if (skipped)
+      title = \`\${title} (skipped\${skipped.description ? ": " + skipped.description : ""})\`;
+    const testStep = {
+      title,
+      startTime: step.startTime.toISOString(),
+      duration,
+      steps: dedupeSteps(step.steps).map((s) => this._createTestStep(s, result)),
+      attachments: step.attachments.map((s) => {
+        const index = result.attachments.indexOf(s);
+        if (index === -1)
+          throw new Error("Unexpected, attachment not found");
+        return index;
+      }),
+      location: this._relativeLocation(step.location),
+      error: step.error?.message,
+      count,
+      skipped: !!skipped
+    };
+    if (step.location)
+      this._stepsInFile.set(step.location.file, testStep);
+    return testStep;
+  }`;
+  newContent = `_createTestStep(dedupedStep, result) {
+    const { step, duration, count } = dedupedStep;
+    // Skip "Evaluate" steps with locations in runtime/node_modules files
+    if (step.location && step.title === "Evaluate" && (step.location.file.includes('@checksum-ai/runtime') || step.location.file.includes('node_modules'))) {
+      // Return null to indicate this step should be filtered out
+      return null;
+    }
+    const skipped = dedupedStep.step.annotations?.find((a) => a.type === "skip");
+    let title = step.title;
+    if (skipped)
+      title = \`\${title} (skipped\${skipped.description ? ": " + skipped.description : ""})\`;
+    const testStep = {
+      title,
+      startTime: step.startTime.toISOString(),
+      duration,
+      steps: dedupeSteps(step.steps).map((s) => this._createTestStep(s, result)).filter(s => s !== null),
+      attachments: step.attachments.map((s) => {
+        const index = result.attachments.indexOf(s);
+        if (index === -1)
+          throw new Error("Unexpected, attachment not found");
+        return index;
+      }),
+      location: this._relativeLocation(step.location),
+      error: step.error?.message,
+      count,
+      skipped: !!skipped
+    };
+    if (step.location)
+      this._stepsInFile.set(step.location.file, testStep);
+    return testStep;
+  }`;
+  replaceContent(file, originalContent, newContent);
+  // Also filter steps when creating test results
+  originalContent = `steps: dedupeSteps(result.steps).map((s) => this._createTestStep(s, result)),`;
+  newContent = `steps: dedupeSteps(result.steps).map((s) => this._createTestStep(s, result)).filter(s => s !== null),`;
+  replaceContent(file, originalContent, newContent);
+  // Normalize locations for steps from runtime/index.js - hide location if it's index.js from runtime
+  originalContent = `_relativeLocation(location) {
+    if (!location)
+      return void 0;
+    const file = toPosixPath2(import_path8.default.relative(this._config.rootDir, location.file));
+    return {
+      file,
+      line: location.line,
+      column: location.column
+    };
+  }`;
+  newContent = `_relativeLocation(location) {
+    if (!location)
+      return void 0;
+    // Hide location for steps from runtime/index.js to reduce clutter
+    if (location.file && location.file.includes('@checksum-ai/runtime') && location.file.endsWith('index.js')) {
+      return void 0;
+    }
+    const file = toPosixPath2(import_path8.default.relative(this._config.rootDir, location.file));
+    return {
+      file,
+      line: location.line,
+      column: location.column
+    };
+  }`;
+  replaceContent(file, originalContent, newContent);
+}
+// -------- [Run] -------- //
+const isRuntime = true || process.env.RUNTIME === "true";
+function run(projectPath) {
+  try {
+    if (fs.existsSync(projectPath)) {
+      alwaysInjectScripts(projectPath);
+      addGenerateSelectorAndLocator(projectPath);
+      if (isRuntime) {
+        expect(projectPath);
+        testInfo(projectPath);
+        testType(projectPath);
+        channelOwner(projectPath);
+        stackTrace(projectPath);
+        indexContent(projectPath);
+        // Skipped in merge mode (CHECKSUM_SKIP_TRACE_PATCH): this patch makes
+        // the HTML reporter sleep ~10s per `trace` attachment waiting for a
+        // `checksum-playwright-trace` file that only the live run produces; in
+        // the merge path (real Playwright traces) it is pure dead time.
+        if (process.env.CHECKSUM_SKIP_TRACE_PATCH !== "true") {
+          reportTraceFile(projectPath);
+        }
+        htmlReporter(projectPath);
+      }
+    } else {
+      console.warn("Project path not found", projectPath);
+    }
+  } catch (e) {
+    // ignore
+    console.error(e);
+  }
+}
+module.exports = run;