Merge 14b365d into 93137d1

Author: lucas-zimerman

.github/workflows/danger.yml

@@ -6,4 +6,9 @@ on:
 
 jobs:
   danger:
-    uses: getsentry/github-workflows/.github/workflows/danger.yml@v2
+    runs-on: ubuntu-latest
+    steps:
+      - uses: lucas-zimerman/sentry-github-workflows/danger@lz/ext-danger
+        with:
+          extra-dangerfile: scripts/check-replay-stubs.js
+# test3

packages/core/android/libs/replay-stubs.jar

@@ -0,0 +1,262 @@
+const { execFileSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const createSectionWarning = (title, content, icon = "🤖") => {
+  return `### ${icon} ${title}\n\n${content}\n`;
+};
+
+let aptInstalled = false;
+function installPackage(package) {
+  try {
+    if (!aptInstalled) {
+      execFileSync("apt-get", ["update"], { stdio: "inherit" });
+      aptInstalled = true;
+    }
+    execFileSync("apt-get", ["install", "-y", package], { stdio: "inherit" });
+    console.log(`Installed ${package}`);
+  } catch (error) {
+    console.log(`Failed to install ${package}`, error.message);
+    throw error;
+  }
+}
+
+function whichExists(package) {
+  try {
+    execFileSync(`which ${package}`, { stdio: 'ignore' });
+    console.log(`${package} exists`);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function ensurePackages() {
+  console.log(`Checking required packages...`);
+
+  const missingPackages = ['curl', 'unzip', 'java'].filter(pkg => !whichExists(pkg));
+
+  if (missingPackages.length === 0) {
+    console.log('All required packages are already available');
+    return;
+  }
+
+  console.log(`Missing packages: ${missingPackages.join(', ')}`);
+
+  // Install missing packages
+  if (missingPackages.includes('curl')) {
+      installPackage('curl');
+  }
+
+  if (missingPackages.includes('unzip')) {
+      installPackage('unzip');
+  }
+
+  if (missingPackages.includes('java')) {
+      installPackage('default-jre');
+  }
+}
+
+
+function validatePath(dirPath) {
+  const resolved = path.resolve(dirPath);
+  const cwd = process.cwd();
+  if (!resolved.startsWith(cwd)) {
+    throw new Error(`Invalid path: ${dirPath} is outside working directory`);
+  }
+  return resolved;
+}
+
+function getFilesSha(dirPath, prefix = '') {
+  const crypto = require('crypto');
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  const results = [];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const relativePath = path.join(prefix, entry.name);
+
+    if (entry.isDirectory()) {
+      results.push(...getFilesSha(fullPath, relativePath).split('\n').filter(Boolean));
+    } else if (entry.isFile()) {
+      const fileContent = fs.readFileSync(fullPath, 'utf8');
+      const hash = crypto.createHash('sha256').update(fileContent).digest('hex');
+      results.push(`${relativePath} : ${hash}`);
+    }
+  }
+
+  return results.sort().join('\n');
+}
+
+function getStubDiffMessage(oldHashMap, newHashMap, oldSrc, newSrc) {
+  let fileDiffs = [];
+
+  // Check for added, removed, and modified files
+  const allFiles = new Set([...oldHashMap.keys(), ...newHashMap.keys()]);
+
+  for (const file of allFiles) {
+    const oldHash = oldHashMap.get(file);
+    const newHash = newHashMap.get(file);
+
+    if (!oldHash && newHash) {
+      // File added
+      fileDiffs.push(`**Added:** \`${file}\``);
+      const newFilePath = path.join(newSrc, file);
+      if (fs.existsSync(newFilePath)) {
+        const content = fs.readFileSync(newFilePath, 'utf8');
+        fileDiffs.push('```java\n' + content + '\n```\n');
+      }
+    } else if (oldHash && !newHash) {
+      // File removed
+      fileDiffs.push(`**Removed:** \`${file}\``);
+      const oldFilePath = path.join(oldSrc, file);
+      if (fs.existsSync(oldFilePath)) {
+        const content = fs.readFileSync(oldFilePath, 'utf8');
+        fileDiffs.push('```java\n' + content + '\n```\n');
+      }
+    } else if (oldHash !== newHash) {
+      // File modified - show diff
+      fileDiffs.push(`**Modified:** \`${file}\``);
+      const oldFilePath = path.join(oldSrc, file);
+      const newFilePath = path.join(newSrc, file);
+
+      // Create temp files for diff if originals don't exist
+      const oldExists = fs.existsSync(oldFilePath);
+      const newExists = fs.existsSync(newFilePath);
+
+      if (oldExists && newExists) {
+        try {
+          const diff = execFileSync("diff", ["-u", oldFilePath, newFilePath], { encoding: 'utf8' });
+          fileDiffs.push('```diff\n' + diff + '\n```\n');
+        } catch (error) {
+          // diff returns exit code 1 when files differ
+          if (error.stdout) {
+            fileDiffs.push('```diff\n' + error.stdout + '\n```\n');
+          } else {
+            fileDiffs.push('_(Could not generate diff)_\n');
+          }
+        }
+      } else {
+        fileDiffs.push(`_(File missing: old=${oldExists}, new=${newExists})_\n`);
+      }
+    }
+  }
+
+  return fileDiffs.join('\n');
+}
+
+module.exports = async function ({ _, warn, __, ___, danger }) {
+  const replayJarChanged = danger.git.modified_files.includes(
+    "packages/core/android/libs/replay-stubs.jar"
+  );
+
+  if (!replayJarChanged) {
+    console.log("replay-stubs.jar not changed, skipping check.");
+    return;
+  }
+
+  // Required software for running this function.
+  ensurePackages();
+
+  console.log("Running replay stubs check...");
+
+  const jsDist = validatePath(path.join(process.cwd(), "js-dist"));
+  const newSrc = validatePath(path.join(process.cwd(), "replay-stubs-src"));
+  const oldSrc = validatePath(path.join(process.cwd(), "replay-stubs-old-src"));
+
+  [jsDist, newSrc, oldSrc].forEach(dir => {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir);
+  });
+
+  // Cleanup handler for temporary files (defined inside so it has access to the variables)
+  const cleanup = () => {
+    [jsDist, newSrc, oldSrc].forEach(dir => {
+      if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  };
+
+  process.on('exit', cleanup);
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+
+  // Tool for decompiling JARs.
+  execFileSync("curl", ["-L", "-o", `${jsDist}/jd-cli.zip`, "https://github.com/intoolswetrust/jd-cli/releases/download/jd-cli-1.2.0/jd-cli-1.2.0-dist.zip"]);
+  execFileSync("unzip", ["-o", `${jsDist}/jd-cli.zip`, "-d", jsDist]);
+
+  const newJarPath = path.join(jsDist, "replay-stubs.jar");
+  fs.copyFileSync("packages/core/android/libs/replay-stubs.jar", newJarPath);
+
+  const baseJarPath = path.join(jsDist, "replay-stubs-old.jar");
+
+  // Validate git ref to prevent command injection
+  const baseRef = danger.github.pr.base.ref;
+  if (!/^[a-zA-Z0-9/_-]+$/.test(baseRef)) {
+    throw new Error(`Invalid git ref: ${baseRef}`);
+  }
+
+  try {
+    const baseJarUrl = `https://github.com/getsentry/sentry-react-native/raw/${baseRef}/packages/core/android/libs/replay-stubs.jar`;
+    console.log(`Downloading baseline jar from: ${baseJarUrl}`);
+    execFileSync("curl", ["-L", "-o", baseJarPath, baseJarUrl]);
+  } catch (error) {
+    console.log('⚠️ Warning: Could not retrieve baseline replay-stubs.jar. Using empty file as fallback.');
+    fs.writeFileSync(baseJarPath, '');
+  }
+
+  const newJarSize = fs.statSync(newJarPath).size;
+  const baseJarSize = fs.existsSync(baseJarPath) ? fs.statSync(baseJarPath).size : 0;
+
+  console.log(`File sizes - New: ${newJarSize} bytes, Baseline: ${baseJarSize} bytes`);
+
+  if (baseJarSize === 0) {
+    console.log('⚠️ Baseline jar is empty, skipping decompilation comparison.');
+    warn(createSectionWarning("Replay Stubs Check", "⚠️ Could not retrieve baseline replay-stubs.jar for comparison. This may be the first time this file is being added."));
+    return;
+  }
+
+  console.log(`Decompiling Stubs.`);
+  try {
+    execFileSync("java", ["-jar", `${jsDist}/jd-cli.jar`, "-od", newSrc, newJarPath]);
+    execFileSync("java", ["-jar", `${jsDist}/jd-cli.jar`, "-od", oldSrc, baseJarPath]);
+  } catch (error) {
+    console.log('Error during decompilation:', error.message);
+    warn(createSectionWarning("Replay Stubs Check", `❌ Error during JAR decompilation: ${error.message}`));
+    return;
+  }
+
+  console.log(`Comparing Stubs.`);
+
+  // Get complete directory listings with all details
+  const newListing = getFilesSha(newSrc);
+  const oldListing = getFilesSha(oldSrc);
+
+  if (oldListing !== newListing) {
+    // Structural changes detected - show actual file diffs
+    console.log("🚨 Structural changes detected in replay-stubs.jar");
+
+    const oldHashes = oldListing.split('\n').filter(Boolean);
+    const newHashes = newListing.split('\n').filter(Boolean);
+
+    // Parse hash listings into maps
+    const oldHashMap = new Map(oldHashes.map(line => {
+      const [file, hash] = line.split(' : ');
+      return [file, hash];
+    }));
+
+    const newHashMap = new Map(newHashes.map(line => {
+      const [file, hash] = line.split(' : ');
+      return [file, hash];
+    }));
+
+    let diffMessage = '🚨 **Structural changes detected** in replay-stubs.jar:\n\n'
+      + getStubDiffMessage(oldHashMap, newHashMap, oldSrc, newSrc);
+
+    warn(createSectionWarning("Replay Stubs Check", diffMessage));
+  } else {
+    console.log("✅ replay-stubs.jar content is identical (same SHA-256 hashes)");
+    warn(createSectionWarning("Replay Stubs Check", `✅ **No changes detected** in replay-stubs.jar\n\nAll file contents are identical (verified by SHA-256 hash comparison).`));
+  }
+};
+