intelwatch 1.0.0

package/src/trackers/competitor.js

@@ -0,0 +1,268 @@
+import { analyzeSite, analyzeKeyPages } from '../scrapers/site-analyzer.js';
+import { scrapeNewsMentions } from '../scrapers/google-news.js';
+import { searchPressMentions, extractRatingsFromResults } from '../scrapers/brave-search.js';
+import { pappersLookup, hasPappersKey } from '../scrapers/pappers.js';
+import { diffTechStacks } from '../utils/tech-detect.js';
+import { fetch } from '../utils/fetcher.js';
+import { load } from '../utils/parser.js';
+import { analyzeSentiment, categorizeMention } from '../utils/sentiment.js';
+
+export async function runCompetitorCheck(tracker) {
+  const { url } = tracker;
+
+  const siteData = await analyzeSite(url);
+  const keyPages = await analyzeKeyPages(url, ['/', '/about', '/pricing']);
+
+  // Merge keyPages from deep analysis with the separate call
+  const mergedKeyPages = { ...siteData.keyPages, ...keyPages };
+
+  // --- Press & reputation layer ---
+  const brandName = tracker.name || new URL(url).hostname.replace('www.', '').split('.')[0];
+  
+  let press = { articles: [], totalCount: 0 };
+  let reputation = { reviews: [], avgRating: null, platforms: [] };
+
+  try {
+    // Try Brave Search API first (reliable, no rate limiting)
+    const braveData = await searchPressMentions(brandName);
+    
+    if (!braveData.error && braveData.mentions.length > 0) {
+      // Brave API worked
+      const allMentions = braveData.mentions;
+      const pressArticles = allMentions.filter(m => m.category === 'press' || m.source === 'news');
+      const forumMentions = allMentions.filter(m => m.category === 'forum' || m.category === 'social');
+      const reviewMentions = allMentions.filter(m => m.category === 'review' || m.source === 'review');
+
+      press = {
+        articles: allMentions.filter(m => m.source !== 'review').slice(0, 15).map(m => ({
+          title: m.title,
+          url: m.url,
+          domain: m.domain,
+          sentiment: m.sentiment,
+          category: m.category,
+          source: m.source,
+          age: m.age,
+        })),
+        totalCount: allMentions.filter(m => m.source !== 'review').length,
+        pressCount: pressArticles.length,
+        forumCount: forumMentions.length,
+        sentimentBreakdown: {
+          positive: allMentions.filter(m => m.sentiment === 'positive' || m.sentiment === 'slightly_positive').length,
+          neutral: allMentions.filter(m => m.sentiment === 'neutral').length,
+          negative: allMentions.filter(m => m.sentiment === 'negative' || m.sentiment === 'slightly_negative').length,
+        },
+      };
+
+      // Extract ratings from review results
+      reputation.platforms = extractRatingsFromResults(reviewMentions);
+      reputation.reviews = reviewMentions.slice(0, 5).map(m => ({
+        title: m.title,
+        url: m.url,
+        domain: m.domain,
+        sentiment: m.sentiment,
+      }));
+    } else {
+      // Fallback to Google scraping
+      const newsData = await scrapeNewsMentions(brandName, { lang: 'fr' });
+      if (newsData.mentions.length > 0) {
+        press = {
+          articles: newsData.mentions.slice(0, 15).map(m => ({
+            title: m.title, url: m.url, domain: m.domain,
+            sentiment: m.sentiment, category: m.category, source: m.source,
+          })),
+          totalCount: newsData.mentionCount,
+          pressCount: newsData.mentions.filter(m => m.category === 'press').length,
+          forumCount: newsData.mentions.filter(m => m.category === 'forum' || m.category === 'social').length,
+          sentimentBreakdown: {
+            positive: newsData.mentions.filter(m => m.sentiment === 'positive' || m.sentiment === 'slightly_positive').length,
+            neutral: newsData.mentions.filter(m => m.sentiment === 'neutral').length,
+            negative: newsData.mentions.filter(m => m.sentiment === 'negative' || m.sentiment === 'slightly_negative').length,
+          },
+        };
+      }
+    }
+  } catch {}
+
+  // --- Pappers lookup for .fr domains ---
+  let pappers = null;
+  const hostname = new URL(url).hostname;
+  if (hostname.endsWith('.fr') && hasPappersKey()) {
+    try {
+      pappers = await pappersLookup(brandName);
+    } catch {}
+  }
+
+  return {
+    type: 'competitor',
+    trackerId: tracker.id,
+    url,
+    checkedAt: new Date().toISOString(),
+    status: siteData.status,
+    error: siteData.error,
+    meta: siteData.meta,
+    techStack: siteData.techStack,
+    socialLinks: siteData.socialLinks,
+    links: siteData.links,
+    pageCount: siteData.pageCount,
+    pricing: siteData.pricing,
+    jobs: siteData.jobs,
+    keyPages: mergedKeyPages,
+    performance: siteData.performance,
+    security: siteData.security,
+    seoSignals: siteData.seoSignals,
+    contentStats: siteData.contentStats,
+    press,
+    reputation,
+    pappers,
+  };
+}
+
+export function diffCompetitorSnapshots(prev, curr) {
+  const changes = [];
+
+  if (!prev) {
+    changes.push({ type: 'new', field: 'tracker', value: 'Initial snapshot created' });
+    return changes;
+  }
+
+  // Page count change
+  const prevCount = prev.pageCount || 0;
+  const currCount = curr.pageCount || 0;
+  if (currCount !== prevCount) {
+    const diff = currCount - prevCount;
+    changes.push({
+      type: diff > 0 ? 'new' : 'removed',
+      field: 'pageCount',
+      value: `${prevCount} → ${currCount} (${diff > 0 ? '+' : ''}${diff} pages)`,
+    });
+  }
+
+  // New/removed pages
+  const prevLinks = new Set(prev.links || []);
+  const currLinks = new Set(curr.links || []);
+  const newPages = [...currLinks].filter(l => !prevLinks.has(l)).slice(0, 10);
+  const removedPages = [...prevLinks].filter(l => !currLinks.has(l)).slice(0, 10);
+
+  for (const page of newPages) {
+    changes.push({ type: 'new', field: 'page', value: page });
+  }
+  for (const page of removedPages) {
+    changes.push({ type: 'removed', field: 'page', value: page });
+  }
+
+  // Tech stack changes
+  const techDiff = diffTechStacks(prev.techStack || [], curr.techStack || []);
+  for (const tech of techDiff.added) {
+    changes.push({ type: 'new', field: 'tech', value: `${tech.name} (${tech.category})` });
+  }
+  for (const tech of techDiff.removed) {
+    changes.push({ type: 'removed', field: 'tech', value: `${tech.name} (${tech.category})` });
+  }
+
+  // Pricing changes
+  if (prev.pricing && curr.pricing) {
+    if (prev.pricing.hash !== curr.pricing.hash) {
+      changes.push({
+        type: 'changed',
+        field: 'pricing',
+        value: `Pricing page content changed`,
+      });
+    }
+  } else if (!prev.pricing && curr.pricing) {
+    changes.push({ type: 'new', field: 'pricing', value: 'Pricing page detected' });
+  }
+
+  // Job changes
+  const prevJobs = prev.jobs?.estimatedOpenings || 0;
+  const currJobs = curr.jobs?.estimatedOpenings || 0;
+  if (currJobs !== prevJobs && (prevJobs > 0 || currJobs > 0)) {
+    const diff = currJobs - prevJobs;
+    changes.push({
+      type: diff > 0 ? 'new' : 'changed',
+      field: 'jobs',
+      value: `Estimated openings: ${prevJobs} → ${currJobs} (${diff > 0 ? '+' : ''}${diff})`,
+    });
+  }
+
+  // Meta title/description changes on key pages
+  for (const [page, currPage] of Object.entries(curr.keyPages || {})) {
+    const prevPage = (prev.keyPages || {})[page];
+    if (!prevPage) {
+      if (currPage.title) {
+        changes.push({ type: 'new', field: `meta:${page}`, value: currPage.title });
+      }
+      continue;
+    }
+    if (prevPage.title !== currPage.title) {
+      changes.push({
+        type: 'changed',
+        field: `title:${page}`,
+        value: `"${prevPage.title}" → "${currPage.title}"`,
+      });
+    }
+    if (prevPage.description !== currPage.description) {
+      changes.push({
+        type: 'changed',
+        field: `description:${page}`,
+        value: currPage.description,
+      });
+    }
+  }
+
+  // Social links changes
+  const prevSocials = Object.keys(prev.socialLinks || {});
+  const currSocials = Object.keys(curr.socialLinks || {});
+  for (const platform of currSocials) {
+    if (!prevSocials.includes(platform)) {
+      changes.push({ type: 'new', field: 'social', value: `${platform}: ${curr.socialLinks[platform]}` });
+    }
+  }
+  for (const platform of prevSocials) {
+    if (!currSocials.includes(platform)) {
+      changes.push({ type: 'removed', field: 'social', value: `${platform} removed` });
+    }
+  }
+
+  // Press mention changes
+  const prevPressCount = prev.press?.totalCount || 0;
+  const currPressCount = curr.press?.totalCount || 0;
+  if (currPressCount > 0 && currPressCount !== prevPressCount) {
+    changes.push({
+      type: currPressCount > prevPressCount ? 'new' : 'changed',
+      field: 'press',
+      value: `${prevPressCount} → ${currPressCount} mentions (${curr.press.sentimentBreakdown?.negative || 0} negative)`,
+    });
+  }
+
+  // Reputation changes
+  const prevRating = prev.reputation?.platforms?.[0]?.rating;
+  const currRating = curr.reputation?.platforms?.[0]?.rating;
+  if (currRating && currRating !== prevRating) {
+    changes.push({
+      type: 'changed',
+      field: 'reputation',
+      value: prevRating ? `Rating: ${prevRating} → ${currRating}` : `Rating: ${currRating}/5`,
+    });
+  }
+
+  return changes;
+}
+
+export function computeThreatScore(tracker, recentChanges) {
+  let score = 0;
+
+  for (const change of recentChanges) {
+    if (change.field === 'pageCount') score += 1;
+    if (change.field === 'page') score += 0.3;
+    if (change.field === 'tech') score += 2;
+    if (change.field === 'pricing') score += 3;
+    if (change.field === 'jobs') {
+      const match = change.value.match(/\+(\d+)/);
+      if (match) score += Math.min(parseInt(match[1]), 5);
+    }
+    if (change.field.startsWith('title:')) score += 2;
+    if (change.field.startsWith('description:')) score += 1;
+  }
+
+  return Math.min(Math.round(score), 10);
+}

package/src/trackers/keyword.js

@@ -0,0 +1,121 @@
+import { scrapeSerp } from '../scrapers/google.js';
+import { searchKeywordRankings } from '../scrapers/brave-search.js';
+
+export async function runKeywordCheck(tracker) {
+  const { keyword } = tracker;
+
+  // Try Brave Search API first
+  let results = [];
+  let error = null;
+
+  try {
+    const braveResults = await searchKeywordRankings(keyword);
+    if (braveResults.length > 0) {
+      results = braveResults.map(r => ({
+        ...r,
+        isFeaturedSnippet: false,
+      }));
+    }
+  } catch (e) {
+    // Brave failed, try Google fallback
+  }
+
+  if (results.length === 0) {
+    const serpData = await scrapeSerp(keyword, { num: 20 });
+    results = serpData.results || [];
+    error = serpData.error;
+  }
+
+  return {
+    type: 'keyword',
+    trackerId: tracker.id,
+    keyword,
+    checkedAt: new Date().toISOString(),
+    results,
+    resultCount: results.length,
+    error,
+    featuredSnippet: results.find(r => r.isFeaturedSnippet) || null,
+  };
+}
+
+export function diffKeywordSnapshots(prev, curr) {
+  const changes = [];
+
+  if (!prev) {
+    changes.push({ type: 'new', field: 'tracker', value: `Initial snapshot — ${curr.resultCount} results found` });
+    return changes;
+  }
+
+  const prevByDomain = {};
+  for (const r of (prev.results || [])) {
+    prevByDomain[r.domain] = r.position;
+  }
+
+  const currByDomain = {};
+  for (const r of (curr.results || [])) {
+    currByDomain[r.domain] = r.position;
+  }
+
+  // Position changes
+  for (const [domain, currPos] of Object.entries(currByDomain)) {
+    const prevPos = prevByDomain[domain];
+    if (prevPos === undefined) {
+      changes.push({
+        type: 'new',
+        field: 'serp_entry',
+        value: `${domain} entered at #${currPos}`,
+        domain,
+        position: currPos,
+      });
+    } else if (prevPos !== currPos) {
+      const diff = prevPos - currPos;
+      changes.push({
+        type: 'changed',
+        field: 'serp_position',
+        value: `${domain}: #${prevPos} → #${currPos} (${diff > 0 ? '↑' : '↓'}${Math.abs(diff)})`,
+        domain,
+        prevPosition: prevPos,
+        currPosition: currPos,
+        delta: diff,
+      });
+    }
+  }
+
+  // Exits
+  for (const [domain, prevPos] of Object.entries(prevByDomain)) {
+    if (!currByDomain[domain]) {
+      changes.push({
+        type: 'removed',
+        field: 'serp_exit',
+        value: `${domain} dropped out (was #${prevPos})`,
+        domain,
+        prevPosition: prevPos,
+      });
+    }
+  }
+
+  // Featured snippet change
+  const prevFeatured = prev.featuredSnippet?.domain;
+  const currFeatured = curr.featuredSnippet?.domain;
+  if (prevFeatured !== currFeatured) {
+    if (currFeatured) {
+      changes.push({
+        type: 'changed',
+        field: 'featured_snippet',
+        value: `Featured snippet: ${prevFeatured || 'none'} → ${currFeatured}`,
+      });
+    }
+  }
+
+  return changes;
+}
+
+export function getRankingsTable(snapshot) {
+  return (snapshot.results || []).map(r => ({
+    position: r.position,
+    domain: r.domain,
+    title: r.title?.slice(0, 60) || '',
+    snippet: r.snippet?.slice(0, 80) || '',
+    isFeaturedSnippet: r.isFeaturedSnippet,
+  }));
+}

package/src/trackers/person.js

@@ -0,0 +1,132 @@
+import { braveNewsSearch, braveWebSearch, searchSocial } from '../scrapers/brave-search.js';
+import { analyzeSentiment, categorizeMention } from '../utils/sentiment.js';
+
+export async function runPersonCheck(tracker) {
+  const { personName, org } = tracker;
+  const query = org ? `"${personName}" "${org}"` : `"${personName}"`;
+
+  const mentions = [];
+
+  // 1. News search
+  const news = await braveNewsSearch(personName, { freshness: 'pm' });
+  for (const r of news.results) {
+    // Filter by org if provided (keep results that mention org or have no org context)
+    if (org) {
+      const text = (r.title + ' ' + r.snippet).toLowerCase();
+      if (!text.includes(org.toLowerCase())) continue;
+    }
+    const sentiment = analyzeSentiment(r.title + ' ' + r.snippet);
+    mentions.push({
+      source: 'news',
+      url: r.url,
+      domain: r.domain || r.source,
+      title: r.title,
+      snippet: r.snippet?.substring(0, 300),
+      age: r.age,
+      sentiment: sentiment.label,
+      sentimentScore: sentiment.score,
+      category: categorizeMention(r.url, r.title, r.snippet),
+    });
+  }
+
+  // 2. Web search for recent mentions
+  await new Promise(r => setTimeout(r, 500));
+  const web = await braveWebSearch(query, { freshness: 'pw' });
+  for (const r of web.results) {
+    if (mentions.some(m => m.url === r.url)) continue;
+    const sentiment = analyzeSentiment(r.title + ' ' + r.snippet);
+    mentions.push({
+      source: 'web',
+      url: r.url,
+      domain: r.domain,
+      title: r.title,
+      snippet: r.snippet?.substring(0, 300),
+      age: r.age,
+      sentiment: sentiment.label,
+      sentimentScore: sentiment.score,
+      category: categorizeMention(r.url, r.title, r.snippet),
+    });
+  }
+
+  // 3. Social search (X, Reddit, LinkedIn)
+  await new Promise(r => setTimeout(r, 500));
+  const social = await searchSocial(query, ['twitter', 'reddit', 'linkedin']);
+  const socialMentions = {};
+  for (const [platform, results] of Object.entries(social.byPlatform || {})) {
+    socialMentions[platform] = results.slice(0, 5).map(r => ({
+      url: r.url,
+      title: r.title,
+      snippet: r.snippet?.substring(0, 200),
+      age: r.age,
+    }));
+  }
+
+  const sentimentBreakdown = {
+    positive: mentions.filter(m => m.sentiment === 'positive' || m.sentiment === 'slightly_positive').length,
+    neutral: mentions.filter(m => m.sentiment === 'neutral').length,
+    negative: mentions.filter(m => m.sentiment === 'negative' || m.sentiment === 'slightly_negative').length,
+  };
+
+  return {
+    type: 'person',
+    trackerId: tracker.id,
+    personName,
+    org: org || null,
+    checkedAt: new Date().toISOString(),
+    mentions: mentions.slice(0, 30),
+    mentionCount: mentions.length,
+    socialMentions,
+    socialCount: social.results.length,
+    sentimentBreakdown,
+    error: (news.error && web.error) ? news.error : null,
+  };
+}
+
+export function diffPersonSnapshots(prev, curr) {
+  const changes = [];
+
+  if (!prev) {
+    changes.push({
+      type: 'new',
+      field: 'tracker',
+      value: `Initial snapshot — ${curr.mentionCount} mentions found`,
+    });
+    return changes;
+  }
+
+  const prevUrls = new Set((prev.mentions || []).map(m => m.url));
+
+  for (const mention of (curr.mentions || [])) {
+    if (!prevUrls.has(mention.url)) {
+      const sentLabel = mention.sentiment === 'negative' || mention.sentiment === 'slightly_negative' ? '⚠ ' : '';
+      changes.push({
+        type: 'new',
+        field: 'mention',
+        value: `${sentLabel}[${mention.category}] ${mention.title?.slice(0, 80)} — ${mention.domain}`,
+      });
+    }
+  }
+
+  const prevCount = prev.mentionCount || 0;
+  const currCount = curr.mentionCount || 0;
+  if (currCount !== prevCount) {
+    changes.push({
+      type: 'changed',
+      field: 'mentionCount',
+      value: `Mention count: ${prevCount} → ${currCount}`,
+    });
+  }
+
+  // Social count changes
+  const prevSocial = prev.socialCount || 0;
+  const currSocial = curr.socialCount || 0;
+  if (currSocial !== prevSocial && (prevSocial > 0 || currSocial > 0)) {
+    changes.push({
+      type: 'changed',
+      field: 'socialMentions',
+      value: `Social mentions: ${prevSocial} → ${currSocial}`,
+    });
+  }
+
+  return changes;
+}

package/src/utils/display.js

@@ -0,0 +1,102 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+
+export function createTable(headers, options = {}) {
+  return new Table({
+    head: headers.map(h => chalk.cyan.bold(h)),
+    style: { head: [], border: ['grey'] },
+    ...options,
+  });
+}
+
+export function formatDate(dateStr) {
+  if (!dateStr) return chalk.gray('never');
+  const d = new Date(dateStr);
+  const now = new Date();
+  const diff = Math.floor((now - d) / 1000);
+
+  if (diff < 60) return `${diff}s ago`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
+  return `${Math.floor(diff / 86400)}d ago`;
+}
+
+export function statusBadge(status) {
+  switch (status) {
+    case 'active': return chalk.green('● active');
+    case 'error': return chalk.red('● error');
+    case 'checking': return chalk.yellow('● checking');
+    default: return chalk.gray('○ ' + status);
+  }
+}
+
+export function changeBadge(type) {
+  switch (type) {
+    case 'new': return chalk.green('+ NEW');
+    case 'changed': return chalk.yellow('~ CHG');
+    case 'removed': return chalk.red('- REM');
+    default: return chalk.gray('  ---');
+  }
+}
+
+export function diffLine(type, label, value = '') {
+  const badge = changeBadge(type);
+  const truncated = value.length > 80 ? value.slice(0, 77) + '...' : value;
+  switch (type) {
+    case 'new': return `${badge} ${chalk.green(label)}: ${chalk.gray(truncated)}`;
+    case 'changed': return `${badge} ${chalk.yellow(label)}: ${chalk.gray(truncated)}`;
+    case 'removed': return `${badge} ${chalk.red(label)}: ${chalk.gray(truncated)}`;
+    default: return `    ${chalk.gray(label)}: ${truncated}`;
+  }
+}
+
+export function header(text) {
+  const line = '─'.repeat(Math.min(60, process.stdout.columns || 60));
+  console.log('\n' + chalk.cyan.bold(text));
+  console.log(chalk.gray(line));
+}
+
+export function section(text) {
+  console.log('\n' + chalk.bold(text));
+}
+
+export function info(text) {
+  console.log(chalk.gray(text));
+}
+
+export function success(text) {
+  console.log(chalk.green('✓ ') + text);
+}
+
+export function warn(text) {
+  console.log(chalk.yellow('⚠ ') + text);
+}
+
+export function error(text) {
+  console.log(chalk.red('✗ ') + text);
+}
+
+export function trackerTypeIcon(type) {
+  switch (type) {
+    case 'competitor': return '🏢';
+    case 'keyword': return '🔍';
+    case 'brand': return '📣';
+    case 'person': return '👤';
+    default: return '📌';
+  }
+}
+
+export function threatLevel(score) {
+  if (score >= 8) return chalk.red('🔴 HIGH');
+  if (score >= 4) return chalk.yellow('🟡 MED');
+  return chalk.green('🟢 LOW');
+}
+
+export function printJson(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+export function truncate(str, len = 60) {
+  if (!str) return '';
+  return str.length > len ? str.slice(0, len - 3) + '...' : str;
+}

package/src/utils/fetcher.js

@@ -0,0 +1,82 @@
+import axios from 'axios';
+
+const USER_AGENTS = [
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  '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',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0',
+];
+
+function randomUserAgent() {
+  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export async function fetch(url, options = {}) {
+  const {
+    retries = 3,
+    delay = 1500,
+    timeout = 15000,
+    headers = {},
+  } = options;
+
+  const config = {
+    url,
+    method: options.method || 'GET',
+    timeout,
+    headers: {
+      'User-Agent': randomUserAgent(),
+      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'Accept-Language': 'en-US,en;q=0.9,fr;q=0.8',
+      'Accept-Encoding': 'gzip, deflate, br',
+      'Cache-Control': 'no-cache',
+      ...headers,
+    },
+    maxRedirects: 5,
+    validateStatus: status => status < 500,
+  };
+
+  let lastError;
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      if (attempt > 1) {
+        const backoff = delay * Math.pow(2, attempt - 2);
+        await sleep(backoff);
+      }
+
+      const response = await axios(config);
+
+      if (response.status === 429) {
+        const retryAfter = parseInt(response.headers['retry-after'] || '60', 10);
+        if (attempt < retries) {
+          await sleep(retryAfter * 1000);
+          continue;
+        }
+        throw new Error(`Rate limited (429) after ${retries} attempts`);
+      }
+
+      return response;
+    } catch (err) {
+      lastError = err;
+      if (attempt < retries) {
+        await sleep(delay);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+export async function fetchWithDelay(url, options = {}) {
+  const minDelay = options.minDelay ?? 1000;
+  const maxDelay = options.maxDelay ?? 2000;
+  const jitter = Math.floor(Math.random() * (maxDelay - minDelay)) + minDelay;
+  await sleep(jitter);
+  return fetch(url, options);
+}
+
+export { sleep };