Function checkPaths

background.js:813–878

(url)

}

async function checkPaths(url) {
  const settings = await getSettings();

  try {
    const urlObj = new URL(url);
    const baseUrl = `${urlObj.protocol}//${urlObj.hostname}`;

    // Get cached domain baseline
    const baseline = await getDomainBaseline(baseUrl);
    if (!baseline) return;

    // Flatten paths with severity, checking critical first
    const allPaths = [
      ...sensitivePaths.critical.map(p => ({ path: p, severity: 'critical' })),
      ...sensitivePaths.high.map(p => ({ path: p, severity: 'high' })),
      ...sensitivePaths.medium.map(p => ({ path: p, severity: 'medium' })),
    ];

    // Check paths in batches to reduce concurrent requests
    const batchSize = 3;
    for (let i = 0; i < allPaths.length; i += batchSize) {
      const batch = allPaths.slice(i, i + batchSize);

      const results = await Promise.all(
        batch.map(({ path, severity }) =>
          checkPathWithHead(baseUrl, path, settings).then(result =>
            result ? { ...result, severity, path } : null
          )
        )
      );

      for (const result of results.filter(Boolean)) {
        try {
          const pathText = await result.response.text();

          // Skip if matches soft-404 fingerprint
          if (matchesSoft404(result.response, pathText, baseline.soft404Fingerprint)) {
            continue;
          }

          // Skip common soft-404 indicators
          if (isSoft404(pathText)) continue;
          if (pathText.length < 50) continue;

          // Check for debug indicators (upgrades severity if found)
          const debugCheck = containsDebugIndicators(pathText);
          const severity = debugCheck.found ? debugCheck.level : result.severity;

          // Path exists and is not soft-404 - report it!
          // No diff comparison needed since these are different paths
          await addFinding('paths', {
            path: result.url,
            severity,
            contentLength: pathText.length,
            hasDebugInfo: debugCheck.found,
            modifiedResponse: truncateForStorage(pathText),
          });
        } catch (e) {