crawlforge-mcp-server 3.0.17 → 3.3.1

package/src/tools/tracking/trackChanges/index.js

@@ -0,0 +1,432 @@
+/**
+ * TrackChanges — entry-point (index.js).
+ *
+ * Preserves the same exports as the original single-file trackChanges.js:
+ *   export class TrackChangesTool
+ *   export default TrackChangesTool
+ *   export const trackChangesTool          (singleton)
+ *
+ * Handler logic ≤ 150 LOC here; heavy work delegated to:
+ *   schema.js   — Zod input schema
+ *   differ.js   — fetch, merge-history, stat helpers
+ *   monitor.js  — polling monitor lifecycle
+ *   notifier.js — webhook / email / Slack notifications
+ */
+
+import { EventEmitter } from 'events';
+import ChangeTracker from '../../../core/ChangeTracker.js';
+import SnapshotManager from '../../../core/SnapshotManager.js';
+import CacheManager from '../../../core/cache/CacheManager.js';
+import { TrackChangesSchema } from './schema.js';
+import { fetchContent, mergeHistoryData, matchesSignificanceFilter, calculateAverageInterval, calculateSignificanceDistribution } from './differ.js';
+import { performMonitoringCheck, stopMonitor } from './monitor.js';
+import { sendNotifications } from './notifier.js';
+
+export class TrackChangesTool extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.options = {
+      cacheEnabled: true,
+      cacheTTL: 3600000,
+      snapshotStorageDir: './snapshots',
+      enableRealTimeMonitoring: true,
+      maxConcurrentMonitors: 50,
+      defaultPollingInterval: 300000,
+      ...options
+    };
+
+    this.changeTracker = new ChangeTracker({
+      enableRealTimeTracking: this.options.enableRealTimeMonitoring,
+      enableSemanticAnalysis: false,
+      contentSimilarityThreshold: 0.8
+    });
+
+    this.snapshotManager = new SnapshotManager({
+      storageDir: this.options.snapshotStorageDir,
+      enableCompression: true,
+      enableDeltaStorage: true,
+      cacheEnabled: this.options.cacheEnabled
+    });
+
+    this.cache = this.options.cacheEnabled
+      ? new CacheManager({ ttl: this.options.cacheTTL })
+      : null;
+
+    this.activeMonitors = new Map();
+    this.monitorStats = new Map();
+
+    this.initialize();
+  }
+
+  async initialize() {
+    try {
+      await this.snapshotManager.initialize();
+      this._setupEventHandlers();
+      this.emit('initialized');
+    } catch (error) {
+      this.emit('error', { operation: 'initialize', error: error.message });
+      throw error;
+    }
+  }
+
+  _setupEventHandlers() {
+    this.changeTracker.on('changeDetected', async (changeRecord) => {
+      if (changeRecord.significance !== 'none') {
+        try {
+          await this.snapshotManager.storeSnapshot(
+            changeRecord.url,
+            changeRecord.details.current || '',
+            { changes: changeRecord.details, significance: changeRecord.significance, changeType: changeRecord.changeType }
+          );
+        } catch (error) {
+          this.emit('error', { operation: 'storeChangeSnapshot', url: changeRecord.url, error: error.message });
+        }
+      }
+    });
+
+    this.changeTracker.on('baselineCreated', (baseline) => this.emit('baselineCreated', baseline));
+    this.snapshotManager.on('snapshotStored', (snapshot) => this.emit('snapshotStored', snapshot));
+    this.snapshotManager.on('error', (error) => this.emit('error', error));
+  }
+
+  async execute(params) {
+    try {
+      const validated = TrackChangesSchema.parse(params);
+      const { operation } = validated;
+
+      switch (operation) {
+        case 'create_baseline':         return await this.createBaseline(validated);
+        case 'compare':                 return await this.compareWithBaseline(validated);
+        case 'monitor':                 return await this.setupMonitoring(validated);
+        case 'get_history':             return await this.getChangeHistory(validated);
+        case 'get_stats':               return await this.getStatistics(validated);
+        case 'create_scheduled_monitor':return await this.createScheduledMonitor(validated);
+        case 'stop_scheduled_monitor':  return await this.stopScheduledMonitor(validated);
+        case 'get_dashboard':           return await this.getMonitoringDashboard(validated);
+        case 'export_history':          return await this.exportHistoricalData(validated);
+        case 'create_alert_rule':       return await this.createAlertRule(validated);
+        case 'generate_trend_report':   return await this.generateTrendReport(validated);
+        case 'get_monitoring_templates':return await this.getMonitoringTemplates(validated);
+        default:                        throw new Error(`Unknown operation: ${operation}`);
+      }
+    } catch (error) {
+      return { success: false, error: error.message, timestamp: Date.now() };
+    }
+  }
+
+  async createBaseline(params) {
+    const { url, content, html, trackingOptions, storageOptions = {} } = params;
+    const enableSnapshots = storageOptions.enableSnapshots !== false;
+
+    let sourceContent = content || html;
+    let fetchMeta = {};
+    if (!sourceContent) {
+      const r = await fetchContent(url);
+      sourceContent = r.content;
+      fetchMeta = r.metadata;
+    }
+    if (!sourceContent || typeof sourceContent !== 'string') throw new Error('Invalid content');
+
+    const baseline = await this.changeTracker.createBaseline(url, sourceContent, trackingOptions);
+    let snapshotInfo = null;
+    if (enableSnapshots) {
+      snapshotInfo = await this.snapshotManager.storeSnapshot(url, sourceContent, { ...fetchMeta, baseline: true, trackingOptions });
+    }
+
+    return {
+      success: true, operation: 'create_baseline', url,
+      baseline: {
+        version: baseline.version,
+        contentHash: baseline.analysis?.hashes?.page,
+        sections: Object.keys(baseline.analysis?.hashes?.sections || {}).length,
+        elements: Object.keys(baseline.analysis?.hashes?.elements || {}).length,
+        createdAt: baseline.timestamp,
+        options: trackingOptions
+      },
+      snapshot: snapshotInfo, timestamp: Date.now()
+    };
+  }
+
+  async compareWithBaseline(params) {
+    const { url, content, html, trackingOptions, storageOptions = {}, notificationOptions } = params;
+    const enableSnapshots = storageOptions.enableSnapshots !== false;
+
+    let currentContent = content || html;
+    let fetchMeta = {};
+    if (!currentContent) {
+      const r = await fetchContent(url);
+      currentContent = r.content;
+      fetchMeta = r.metadata;
+    }
+    if (!currentContent || typeof currentContent !== 'string') throw new Error('Invalid content');
+
+    const comparisonResult = await this.changeTracker.compareWithBaseline(url, currentContent, trackingOptions);
+
+    let snapshotInfo = null;
+    if (comparisonResult.hasChanges && enableSnapshots) {
+      snapshotInfo = await this.snapshotManager.storeSnapshot(url, currentContent, {
+        ...fetchMeta, changes: comparisonResult.summary, significance: comparisonResult.significance
+      });
+    }
+
+    if (comparisonResult.hasChanges && notificationOptions) {
+      await sendNotifications(url, comparisonResult, notificationOptions, this);
+    }
+
+    return {
+      success: true, operation: 'compare', url,
+      hasChanges: comparisonResult.hasChanges,
+      significance: comparisonResult.significance,
+      changeType: comparisonResult.changeType,
+      summary: comparisonResult.summary,
+      details: comparisonResult.details,
+      metrics: comparisonResult.metrics,
+      recommendations: comparisonResult.recommendations,
+      snapshot: snapshotInfo, timestamp: Date.now()
+    };
+  }
+
+  async setupMonitoring(params) {
+    const { url, monitoringOptions, trackingOptions, storageOptions, notificationOptions } = params;
+
+    if (this.activeMonitors.has(url)) {
+      clearInterval(this.activeMonitors.get(url).timer);
+    }
+
+    const deps = { changeTracker: this.changeTracker, snapshotManager: this.snapshotManager, emitter: this };
+
+    const monitorConfig = {
+      url,
+      options: { ...monitoringOptions, trackingOptions, storageOptions, notificationOptions },
+      stats: { started: Date.now(), checks: 0, changesDetected: 0, errors: 0, lastCheck: null, lastChange: null, averageResponseTime: 0 }
+    };
+
+    monitorConfig.timer = setInterval(
+      () => performMonitoringCheck(url, monitorConfig, deps),
+      monitoringOptions.interval
+    );
+
+    this.activeMonitors.set(url, monitorConfig);
+    this.monitorStats.set(url, monitorConfig.stats);
+
+    await performMonitoringCheck(url, monitorConfig, deps);
+
+    return {
+      success: true, operation: 'monitor', url,
+      monitoring: { enabled: true, interval: monitoringOptions.interval, notificationThreshold: monitoringOptions.notificationThreshold, startedAt: monitorConfig.stats.started },
+      timestamp: Date.now()
+    };
+  }
+
+  async getChangeHistory(params) {
+    const { url, queryOptions } = params;
+
+    const changeHistory = this.changeTracker.getChangeHistory(url, queryOptions.limit);
+    const snapshotHistory = await this.snapshotManager.getChangeHistory(url, queryOptions);
+    let combined = mergeHistoryData(changeHistory, snapshotHistory.history);
+
+    if (queryOptions.significanceFilter && queryOptions.significanceFilter !== 'all') {
+      combined = combined.filter(e => matchesSignificanceFilter(e, queryOptions.significanceFilter));
+    }
+
+    const start = queryOptions.offset || 0;
+    const end = start + (queryOptions.limit || 50);
+
+    return {
+      success: true, operation: 'get_history', url,
+      history: combined.slice(start, end),
+      pagination: { total: combined.length, limit: queryOptions.limit, offset: queryOptions.offset, hasMore: end < combined.length },
+      timespan: {
+        earliest: combined.length > 0 ? combined[combined.length - 1].timestamp : null,
+        latest: combined.length > 0 ? combined[0].timestamp : null,
+        totalEntries: combined.length
+      },
+      timestamp: Date.now()
+    };
+  }
+
+  async getStatistics(params) {
+    const { url } = params;
+    const monitoringStats = url ? this.monitorStats.get(url) : this._getAggregatedMonitoringStats();
+    let urlStats = null;
+    if (url) {
+      try {
+        const changeHistory = this.changeTracker.getChangeHistory(url, 100);
+        const snapshotHistory = await this.snapshotManager.querySnapshots({ url, limit: 100, includeContent: false });
+        urlStats = {
+          totalChanges: changeHistory.length,
+          totalSnapshots: snapshotHistory.snapshots.length,
+          lastChange: changeHistory.length > 0 ? changeHistory[0].timestamp : null,
+          averageChangeInterval: calculateAverageInterval(changeHistory),
+          significanceDistribution: calculateSignificanceDistribution(changeHistory),
+          isBeingMonitored: this.activeMonitors.has(url)
+        };
+      } catch (error) {
+        urlStats = { error: error.message };
+      }
+    }
+
+    return {
+      success: true, operation: 'get_stats', url: url || 'global',
+      stats: {
+        changeTracking: this.changeTracker.getStats(),
+        snapshotStorage: this.snapshotManager.getStats(),
+        monitoring: monitoringStats,
+        urlSpecific: urlStats,
+        system: { activeMonitors: this.activeMonitors.size, cacheEnabled: !!this.cache, cacheStats: this.cache ? this.cache.getStats() : null }
+      },
+      timestamp: Date.now()
+    };
+  }
+
+  async createScheduledMonitor(params) {
+    const { url, scheduledMonitorOptions, trackingOptions, notificationOptions } = params;
+    const schedule = scheduledMonitorOptions?.schedule || '0 */1 * * *';
+    const templateId = scheduledMonitorOptions?.templateId;
+    let monitorOptions = { ...trackingOptions };
+    if (templateId && this.changeTracker.monitoringTemplates.has(templateId)) {
+      monitorOptions = { ...this.changeTracker.monitoringTemplates.get(templateId).options, ...monitorOptions };
+    }
+    const result = await this.changeTracker.createScheduledMonitor(url, schedule, {
+      ...monitorOptions,
+      alertRules: { threshold: 'moderate', methods: ['webhook'], throttle: 600000, ...notificationOptions }
+    });
+    return { success: true, operation: 'create_scheduled_monitor', url, monitor: result, template: templateId ? this.changeTracker.monitoringTemplates.get(templateId)?.name : null, timestamp: Date.now() };
+  }
+
+  async stopScheduledMonitor(params) {
+    const { url } = params;
+    let stoppedMonitors = 0;
+    for (const [id, monitor] of this.changeTracker.scheduledMonitors.entries()) {
+      if (monitor.url === url) {
+        monitor.cronJob?.destroy();
+        monitor.status = 'stopped';
+        this.changeTracker.scheduledMonitors.delete(id);
+        stoppedMonitors++;
+      }
+    }
+    return { success: true, operation: 'stop_scheduled_monitor', url, stoppedMonitors, timestamp: Date.now() };
+  }
+
+  async getMonitoringDashboard(params) {
+    const { dashboardOptions } = params;
+    const dashboard = this.changeTracker.getMonitoringDashboard();
+    if (!dashboardOptions?.includeRecentAlerts) delete dashboard.recentAlerts;
+    if (!dashboardOptions?.includeTrends) delete dashboard.trends;
+    if (!dashboardOptions?.includeMonitorStatus) {
+      dashboard.monitors = dashboard.monitors.map(m => ({ id: m.id, url: m.url, status: m.status }));
+    }
+    return { success: true, operation: 'get_dashboard', dashboard, timestamp: Date.now() };
+  }
+
+  async exportHistoricalData(params) {
+    const { url, exportOptions } = params;
+    const exportData = await this.changeTracker.exportHistoricalData({ ...exportOptions, url });
+    return { success: true, operation: 'export_history', url: url || 'global', export: exportData, timestamp: Date.now() };
+  }
+
+  async createAlertRule(params) {
+    const { alertRuleOptions } = params;
+    const ruleId = alertRuleOptions?.ruleId || `custom_rule_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const rule = {
+      condition: this._parseCondition(alertRuleOptions?.condition || 'significance === "major"'),
+      actions: alertRuleOptions?.actions || ['webhook'],
+      throttle: alertRuleOptions?.throttle || 600000,
+      priority: alertRuleOptions?.priority || 'medium'
+    };
+    this.changeTracker.alertRules.set(ruleId, rule);
+    return { success: true, operation: 'create_alert_rule', ruleId, rule, timestamp: Date.now() };
+  }
+
+  async generateTrendReport(params) {
+    const report = await this.changeTracker.generateTrendAnalysisReport(params.url);
+    return { success: true, operation: 'generate_trend_report', report, timestamp: Date.now() };
+  }
+
+  async getMonitoringTemplates() {
+    const templates = {};
+    for (const [id, template] of this.changeTracker.monitoringTemplates.entries()) {
+      templates[id] = { name: template.name, frequency: template.frequency, options: template.options, alertRules: template.alertRules };
+    }
+    return { success: true, operation: 'get_monitoring_templates', templates, count: Object.keys(templates).length, timestamp: Date.now() };
+  }
+
+  // ── Public API ────────────────────────────────────────────────────────────────
+
+  stopMonitoring(url) {
+    if (!this.activeMonitors.has(url)) return false;
+    const monitorConfig = this.activeMonitors.get(url);
+    stopMonitor(url, monitorConfig, this);
+    this.activeMonitors.delete(url);
+    return true;
+  }
+
+  stopAllMonitoring() {
+    const urls = Array.from(this.activeMonitors.keys());
+    urls.forEach(url => this.stopMonitoring(url));
+    this.emit('allMonitoringStopped', { count: urls.length });
+    return urls.length;
+  }
+
+  getActiveMonitors() {
+    return Array.from(this.activeMonitors.keys()).map(url => ({
+      url,
+      config: this.activeMonitors.get(url).options,
+      stats: this.monitorStats.get(url)
+    }));
+  }
+
+  async shutdown() {
+    this.stopAllMonitoring();
+    await this.snapshotManager.shutdown();
+    await this.changeTracker.cleanup();
+    this.emit('shutdown');
+  }
+
+  // ── Private helpers ────────────────────────────────────────────────────────────
+
+  _getAggregatedMonitoringStats() {
+    const stats = { totalMonitors: this.activeMonitors.size, totalChecks: 0, totalChanges: 0, totalErrors: 0, averageResponseTime: 0, oldestMonitor: null, newestMonitor: null };
+    const all = Array.from(this.monitorStats.values());
+    if (all.length === 0) return stats;
+    stats.totalChecks = all.reduce((s, v) => s + v.checks, 0);
+    stats.totalChanges = all.reduce((s, v) => s + v.changesDetected, 0);
+    stats.totalErrors = all.reduce((s, v) => s + v.errors, 0);
+    stats.averageResponseTime = all.reduce((s, v) => s + v.averageResponseTime, 0) / all.length;
+    stats.oldestMonitor = Math.min(...all.map(v => v.started));
+    stats.newestMonitor = Math.max(...all.map(v => v.started));
+    return stats;
+  }
+
+  _parseCondition(conditionString) {
+    return (changeResult) => {
+      try {
+        if (conditionString.includes('significance')) {
+          const match = conditionString.match(/significance\s*===\s*["'](\w+)["']/);
+          if (match) return changeResult.significance === match[1];
+        }
+        return false;
+      } catch {
+        return false;
+      }
+    };
+  }
+}
+
+export default TrackChangesTool;
+
+// Singleton instance — kept for backward-compat with any code that imports it directly
+export const trackChangesTool = new TrackChangesTool();
+trackChangesTool.name = 'track_changes';
+trackChangesTool.validateParameters = (params) => TrackChangesSchema.parse(params);
+trackChangesTool.description = 'Track and analyze content changes with baseline capture, comparison, and monitoring capabilities';
+trackChangesTool.inputSchema = {
+  type: 'object',
+  properties: {
+    url: { type: 'string', description: 'URL to track for changes' },
+    operation: { type: 'string', description: 'Operation to perform: create_baseline, compare, monitor, get_history, get_stats' },
+    content: { type: 'string', description: 'Content to analyze or compare' }
+  },
+  required: ['url']
+};

package/src/tools/tracking/trackChanges/monitor.js

@@ -0,0 +1,93 @@
+/**
+ * TrackChanges — monitor module.
+ * Handles the polling monitor lifecycle: start, check, stop.
+ * Used by the TrackChangesTool class (index.js).
+ */
+
+import { fetchContent, meetsNotificationThreshold } from './differ.js';
+import { sendNotifications } from './notifier.js';
+
+/**
+ * Perform a single monitoring check for a URL.
+ * Mutates monitorConfig.stats in place.
+ *
+ * @param {string} url
+ * @param {Object} monitorConfig
+ * @param {Object} deps — { changeTracker, snapshotManager, emitter }
+ */
+export async function performMonitoringCheck(url, monitorConfig, { changeTracker, snapshotManager, emitter }) {
+  const startTime = Date.now();
+
+  try {
+    monitorConfig.stats.checks++;
+
+    const fetchResult = await fetchContent(url);
+
+    const comparisonResult = await changeTracker.compareWithBaseline(
+      url,
+      fetchResult.content,
+      monitorConfig.options.trackingOptions
+    );
+
+    const responseTime = Date.now() - startTime;
+    monitorConfig.stats.averageResponseTime =
+      (monitorConfig.stats.averageResponseTime * (monitorConfig.stats.checks - 1) + responseTime) /
+      monitorConfig.stats.checks;
+
+    monitorConfig.stats.lastCheck = Date.now();
+
+    if (comparisonResult.hasChanges) {
+      monitorConfig.stats.changesDetected++;
+      monitorConfig.stats.lastChange = Date.now();
+
+      if (meetsNotificationThreshold(
+        comparisonResult.significance,
+        monitorConfig.options.notificationThreshold
+      )) {
+        if (monitorConfig.options.storageOptions?.enableSnapshots) {
+          await snapshotManager.storeSnapshot(url, fetchResult.content, {
+            ...fetchResult.metadata,
+            changes: comparisonResult.summary,
+            significance: comparisonResult.significance,
+            monitoring: true
+          });
+        }
+
+        if (monitorConfig.options.notificationOptions) {
+          await sendNotifications(url, comparisonResult, monitorConfig.options.notificationOptions, emitter);
+        }
+      }
+    }
+
+    emitter?.emit('monitoringCheck', {
+      url,
+      hasChanges: comparisonResult.hasChanges,
+      significance: comparisonResult.significance,
+      responseTime,
+      timestamp: Date.now()
+    });
+  } catch (error) {
+    monitorConfig.stats.errors++;
+
+    emitter?.emit('monitoringError', { url, error: error.message, timestamp: Date.now() });
+
+    if (monitorConfig.stats.errors > monitorConfig.options.maxRetries) {
+      stopMonitor(url, monitorConfig, emitter);
+      emitter?.emit('monitoringDisabled', {
+        url,
+        reason: 'Too many errors',
+        totalErrors: monitorConfig.stats.errors
+      });
+    }
+  }
+}
+
+/**
+ * Stop a single active monitor (clears its interval).
+ */
+export function stopMonitor(url, monitorConfig, emitter) {
+  if (monitorConfig?.timer) {
+    clearInterval(monitorConfig.timer);
+  }
+  emitter?.emit('monitoringStopped', { url });
+}

package/src/tools/tracking/trackChanges/notifier.js

@@ -0,0 +1,105 @@
+/**
+ * TrackChanges — notifier module.
+ * Handles webhook, email and Slack change notifications.
+ * Used by monitor.js and the main TrackChangesTool class.
+ */
+
+/**
+ * Send all enabled notifications for a detected change.
+ * @param {string} url
+ * @param {Object} changeResult
+ * @param {Object} notificationOptions
+ * @param {EventEmitter} emitter — tool instance for event emission
+ */
+export async function sendNotifications(url, changeResult, notificationOptions, emitter) {
+  const notifications = [];
+
+  if (notificationOptions.webhook?.enabled) {
+    notifications.push(sendWebhookNotification(url, changeResult, notificationOptions.webhook, emitter));
+  }
+  if (notificationOptions.email?.enabled) {
+    notifications.push(sendEmailNotification(url, changeResult, notificationOptions.email, emitter));
+  }
+  if (notificationOptions.slack?.enabled) {
+    notifications.push(sendSlackNotification(url, changeResult, notificationOptions.slack, emitter));
+  }
+
+  await Promise.allSettled(notifications);
+}
+
+export async function sendWebhookNotification(url, changeResult, webhookConfig, emitter) {
+  try {
+    const payload = {
+      event: 'change_detected',
+      url,
+      timestamp: Date.now(),
+      significance: changeResult.significance,
+      changeType: changeResult.changeType,
+      summary: changeResult.summary,
+      details: webhookConfig.includeContent ? changeResult.details : undefined
+    };
+
+    const response = await fetch(webhookConfig.url, {
+      method: webhookConfig.method || 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'MCP-WebScraper-ChangeTracker/3.0',
+        ...webhookConfig.headers
+      },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+      throw new Error(`Webhook failed: ${response.status} ${response.statusText}`);
+    }
+
+    emitter?.emit('notificationSent', { type: 'webhook', url, success: true });
+  } catch (error) {
+    emitter?.emit('notificationError', { type: 'webhook', url, error: error.message });
+  }
+}
+
+export async function sendEmailNotification(url, changeResult, emailConfig, emitter) {
+  // Email integration placeholder — requires external service
+  emitter?.emit('notificationSent', {
+    type: 'email',
+    url,
+    success: true,
+    note: 'Email notifications require external service integration'
+  });
+}
+
+export async function sendSlackNotification(url, changeResult, slackConfig, emitter) {
+  try {
+    const colors = { none: '#36a64f', minor: '#ffeb3b', moderate: '#ff9800', major: '#f44336', critical: '#9c27b0' };
+    const payload = {
+      text: '🔄 Content Change Detected',
+      attachments: [{
+        color: colors[changeResult.significance] || '#36a64f',
+        fields: [
+          { title: 'URL', value: url, short: false },
+          { title: 'Significance', value: changeResult.significance.toUpperCase(), short: true },
+          { title: 'Change Type', value: changeResult.changeType.replace('_', ' '), short: true },
+          { title: 'Summary', value: changeResult.summary.changeDescription, short: false }
+        ],
+        timestamp: Math.floor(Date.now() / 1000)
+      }],
+      channel: slackConfig.channel,
+      username: slackConfig.username || 'Change Tracker'
+    };
+
+    const response = await fetch(slackConfig.webhookUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+      throw new Error(`Slack notification failed: ${response.status}`);
+    }
+
+    emitter?.emit('notificationSent', { type: 'slack', url, success: true });
+  } catch (error) {
+    emitter?.emit('notificationError', { type: 'slack', url, error: error.message });
+  }
+}