@weave_protocol/mund 0.1.0

package/src/notifications/slack.ts

@@ -0,0 +1,170 @@
+/**
+ * Mund - The Guardian Protocol
+ * Slack Notifier - Send alerts to Slack channels
+ */
+
+import type { INotifier, NotificationPayload, SlackConfig, Severity } from '../types.js';
+
+interface SlackMessage {
+  text: string;
+  attachments?: SlackAttachment[];
+  username?: string;
+  icon_emoji?: string;
+  channel?: string;
+}
+
+interface SlackAttachment {
+  color: string;
+  title: string;
+  text: string;
+  fields?: SlackField[];
+  footer?: string;
+  ts?: number;
+}
+
+interface SlackField {
+  title: string;
+  value: string;
+  short: boolean;
+}
+
+export class SlackNotifier implements INotifier {
+  name = 'SlackNotifier';
+  private config: SlackConfig;
+
+  constructor(config: SlackConfig) {
+    this.config = config;
+  }
+
+  async send(payload: NotificationPayload): Promise<boolean> {
+    const { event } = payload;
+
+    // Check minimum severity
+    if (this.config.min_severity && !this.meetsMinSeverity(event.severity, this.config.min_severity)) {
+      return true; // Successfully skipped
+    }
+
+    const message = this.formatMessage(payload);
+
+    try {
+      const response = await fetch(this.config.webhook_url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(message)
+      });
+
+      if (!response.ok) {
+        console.error(`Slack notification failed: ${response.status} ${response.statusText}`);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Failed to send Slack notification:', error);
+      return false;
+    }
+  }
+
+  private formatMessage(payload: NotificationPayload): SlackMessage {
+    const { event } = payload;
+    
+    const color = this.getSeverityColor(event.severity);
+    const emoji = this.getSeverityEmoji(event.severity);
+
+    const message: SlackMessage = {
+      text: `${emoji} *Mund Security Alert* - ${event.rule_name}`,
+      attachments: [
+        {
+          color,
+          title: `${event.severity.toUpperCase()}: ${event.rule_name}`,
+          text: `\`\`\`${event.content_snippet}\`\`\``,
+          fields: [
+            {
+              title: 'Type',
+              value: event.type,
+              short: true
+            },
+            {
+              title: 'Action',
+              value: event.action_taken,
+              short: true
+            },
+            {
+              title: 'Rule ID',
+              value: event.rule_id,
+              short: true
+            },
+            {
+              title: 'Event ID',
+              value: event.id,
+              short: true
+            }
+          ],
+          footer: 'Mund Guardian Protocol',
+          ts: Math.floor(event.timestamp.getTime() / 1000)
+        }
+      ]
+    };
+
+    // Add context fields if available
+    if (event.context.tool_name) {
+      message.attachments![0].fields!.push({
+        title: 'Tool',
+        value: event.context.tool_name,
+        short: true
+      });
+    }
+
+    if (event.context.agent_id) {
+      message.attachments![0].fields!.push({
+        title: 'Agent',
+        value: event.context.agent_id,
+        short: true
+      });
+    }
+
+    // Apply custom settings
+    if (this.config.username) {
+      message.username = this.config.username;
+    }
+    if (this.config.icon_emoji) {
+      message.icon_emoji = this.config.icon_emoji;
+    }
+    if (this.config.channel) {
+      message.channel = this.config.channel;
+    }
+
+    return message;
+  }
+
+  private getSeverityColor(severity: Severity): string {
+    const colors: Record<Severity, string> = {
+      critical: '#dc3545', // Red
+      high: '#fd7e14',     // Orange
+      medium: '#ffc107',   // Yellow
+      low: '#17a2b8',      // Cyan
+      info: '#6c757d'      // Gray
+    };
+    return colors[severity] || colors.info;
+  }
+
+  private getSeverityEmoji(severity: Severity): string {
+    const emojis: Record<Severity, string> = {
+      critical: '🚨',
+      high: '⚠️',
+      medium: '⚡',
+      low: 'ℹ️',
+      info: '📝'
+    };
+    return emojis[severity] || '📝';
+  }
+
+  private meetsMinSeverity(eventSeverity: Severity, minSeverity: Severity): boolean {
+    const order: Severity[] = ['critical', 'high', 'medium', 'low', 'info'];
+    const eventIndex = order.indexOf(eventSeverity);
+    const minIndex = order.indexOf(minSeverity);
+    return eventIndex <= minIndex;
+  }
+}
+
+export default SlackNotifier;

package/src/notifications/teams.ts

@@ -0,0 +1,200 @@
+/**
+ * Mund - The Guardian Protocol
+ * Teams Notifier - Send alerts to Microsoft Teams channels
+ */
+
+import type { INotifier, NotificationPayload, TeamsConfig, Severity } from '../types.js';
+
+interface TeamsAdaptiveCard {
+  type: string;
+  attachments: TeamsAttachment[];
+}
+
+interface TeamsAttachment {
+  contentType: string;
+  content: AdaptiveCardContent;
+}
+
+interface AdaptiveCardContent {
+  $schema: string;
+  type: string;
+  version: string;
+  body: AdaptiveCardElement[];
+  actions?: AdaptiveCardAction[];
+}
+
+interface AdaptiveCardElement {
+  type: string;
+  text?: string;
+  size?: string;
+  weight?: string;
+  color?: string;
+  wrap?: boolean;
+  spacing?: string;
+  items?: AdaptiveCardElement[];
+  columns?: AdaptiveCardColumn[];
+  facts?: AdaptiveCardFact[];
+}
+
+interface AdaptiveCardColumn {
+  type: string;
+  width: string;
+  items: AdaptiveCardElement[];
+}
+
+interface AdaptiveCardFact {
+  title: string;
+  value: string;
+}
+
+interface AdaptiveCardAction {
+  type: string;
+  title: string;
+  url?: string;
+}
+
+export class TeamsNotifier implements INotifier {
+  name = 'TeamsNotifier';
+  private config: TeamsConfig;
+
+  constructor(config: TeamsConfig) {
+    this.config = config;
+  }
+
+  async send(payload: NotificationPayload): Promise<boolean> {
+    const { event } = payload;
+
+    // Check minimum severity
+    if (this.config.min_severity && !this.meetsMinSeverity(event.severity, this.config.min_severity)) {
+      return true; // Successfully skipped
+    }
+
+    const card = this.formatAdaptiveCard(payload);
+
+    try {
+      const response = await fetch(this.config.webhook_url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(card)
+      });
+
+      if (!response.ok) {
+        console.error(`Teams notification failed: ${response.status} ${response.statusText}`);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Failed to send Teams notification:', error);
+      return false;
+    }
+  }
+
+  private formatAdaptiveCard(payload: NotificationPayload): TeamsAdaptiveCard {
+    const { event } = payload;
+    const color = this.getSeverityColor(event.severity);
+    const emoji = this.getSeverityEmoji(event.severity);
+
+    const facts: AdaptiveCardFact[] = [
+      { title: 'Severity', value: event.severity.toUpperCase() },
+      { title: 'Type', value: event.type },
+      { title: 'Action', value: event.action_taken },
+      { title: 'Rule ID', value: event.rule_id },
+      { title: 'Event ID', value: event.id },
+      { title: 'Time', value: event.timestamp.toISOString() }
+    ];
+
+    if (event.context.tool_name) {
+      facts.push({ title: 'Tool', value: event.context.tool_name });
+    }
+    if (event.context.agent_id) {
+      facts.push({ title: 'Agent', value: event.context.agent_id });
+    }
+
+    return {
+      type: 'message',
+      attachments: [
+        {
+          contentType: 'application/vnd.microsoft.card.adaptive',
+          content: {
+            $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+            type: 'AdaptiveCard',
+            version: '1.4',
+            body: [
+              {
+                type: 'Container',
+                items: [
+                  {
+                    type: 'TextBlock',
+                    text: `${emoji} Mund Security Alert`,
+                    size: 'Large',
+                    weight: 'Bolder',
+                    color: color
+                  },
+                  {
+                    type: 'TextBlock',
+                    text: event.rule_name,
+                    size: 'Medium',
+                    weight: 'Bolder',
+                    wrap: true
+                  }
+                ]
+              },
+              {
+                type: 'Container',
+                items: [
+                  {
+                    type: 'TextBlock',
+                    text: 'Detected Content:',
+                    weight: 'Bolder',
+                    spacing: 'Medium'
+                  },
+                  {
+                    type: 'TextBlock',
+                    text: `\`${event.content_snippet}\``,
+                    wrap: true
+                  }
+                ]
+              },
+              {
+                type: 'FactSet',
+                facts
+              }
+            ]
+          }
+        }
+      ]
+    };
+  }
+
+  private getSeverityColor(severity: Severity): 'attention' | 'warning' | 'good' | 'default' {
+    const colors: Record<Severity, 'attention' | 'warning' | 'good' | 'default'> = {
+      critical: 'attention',
+      high: 'attention',
+      medium: 'warning',
+      low: 'good',
+      info: 'default'
+    };
+    return colors[severity] || 'default';
+  }
+
+  private getSeverityEmoji(severity: Severity): string {
+    const emojis: Record<Severity, string> = {
+      critical: '🚨',
+      high: '⚠️',
+      medium: '⚡',
+      low: 'ℹ️',
+      info: '📝'
+    };
+    return emojis[severity] || '📝';
+  }
+
+  private meetsMinSeverity(eventSeverity: Severity, minSeverity: Severity): boolean {
+    const order: Severity[] = ['critical', 'high', 'medium', 'low', 'info'];
+    const eventIndex = order.indexOf(eventSeverity);
+    const minIndex = order.indexOf(minSeverity);
+    return eventIndex <= minIndex;
+  }
+}
+
+export default TeamsNotifier;

package/src/notifications/webhook.ts

@@ -0,0 +1,80 @@
+/**
+ * Mund - The Guardian Protocol
+ * Webhook Notifier - Send alerts to generic webhooks
+ */
+
+import type { INotifier, NotificationPayload, WebhookConfig, Severity } from '../types.js';
+
+export class WebhookNotifier implements INotifier {
+  name = 'WebhookNotifier';
+  private config: WebhookConfig;
+
+  constructor(config: WebhookConfig) {
+    this.config = config;
+  }
+
+  async send(payload: NotificationPayload): Promise<boolean> {
+    const { event } = payload;
+
+    // Check minimum severity
+    if (this.config.min_severity && !this.meetsMinSeverity(event.severity, this.config.min_severity)) {
+      return true; // Successfully skipped
+    }
+
+    const webhookPayload = this.formatPayload(payload);
+
+    try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        ...this.config.headers
+      };
+
+      const response = await fetch(this.config.url, {
+        method: this.config.method,
+        headers,
+        body: JSON.stringify(webhookPayload)
+      });
+
+      if (!response.ok) {
+        console.error(`Webhook notification failed: ${response.status} ${response.statusText}`);
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Failed to send webhook notification:', error);
+      return false;
+    }
+  }
+
+  private formatPayload(payload: NotificationPayload): object {
+    const { event } = payload;
+
+    return {
+      source: 'mund',
+      version: '1.0',
+      event: {
+        id: event.id,
+        timestamp: event.timestamp.toISOString(),
+        rule_id: event.rule_id,
+        rule_name: event.rule_name,
+        severity: event.severity,
+        type: event.type,
+        action_taken: event.action_taken,
+        content_snippet: event.content_snippet,
+        content_hash: event.full_content_hash,
+        context: event.context,
+        acknowledged: event.acknowledged
+      }
+    };
+  }
+
+  private meetsMinSeverity(eventSeverity: Severity, minSeverity: Severity): boolean {
+    const order: Severity[] = ['critical', 'high', 'medium', 'low', 'info'];
+    const eventIndex = order.indexOf(eventSeverity);
+    const minIndex = order.indexOf(minSeverity);
+    return eventIndex <= minIndex;
+  }
+}
+
+export default WebhookNotifier;

package/src/storage/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Mund - The Guardian Protocol
+ * Storage Index - Exports storage implementations
+ */
+
+export { MemoryStorage } from './memory.js';
+
+import { MemoryStorage } from './memory.js';
+import type { IStorage, MundConfig } from '../types.js';
+
+/**
+ * Create storage instance based on configuration
+ */
+export function createStorage(config: MundConfig): IStorage {
+  switch (config.storage_type) {
+    case 'memory':
+      return new MemoryStorage();
+    case 'sqlite':
+      // SQLite implementation would go here
+      console.warn('SQLite storage not yet implemented, falling back to memory');
+      return new MemoryStorage();
+    case 'postgres':
+      // PostgreSQL implementation would go here
+      console.warn('PostgreSQL storage not yet implemented, falling back to memory');
+      return new MemoryStorage();
+    default:
+      return new MemoryStorage();
+  }
+}

package/src/storage/memory.ts

@@ -0,0 +1,181 @@
+/**
+ * Mund - The Guardian Protocol
+ * Memory Storage - In-memory storage for development and testing
+ */
+
+import type { 
+  IStorage, 
+  SecurityEvent, 
+  DetectionRule, 
+  GetEventsInput,
+  DetectorType
+} from '../types.js';
+
+export class MemoryStorage implements IStorage {
+  private events: Map<string, SecurityEvent> = new Map();
+  private rules: Map<string, DetectionRule> = new Map();
+  private allowlist: Map<string, { pattern: string; type: DetectorType }> = new Map();
+  private blocklist: Map<string, { pattern: string; type: DetectorType }> = new Map();
+
+  // ============================================================================
+  // Events
+  // ============================================================================
+
+  async saveEvent(event: SecurityEvent): Promise<void> {
+    this.events.set(event.id, event);
+    
+    // Keep only last 10000 events in memory
+    if (this.events.size > 10000) {
+      const oldestKey = this.events.keys().next().value;
+      if (oldestKey) {
+        this.events.delete(oldestKey);
+      }
+    }
+  }
+
+  async getEvent(id: string): Promise<SecurityEvent | null> {
+    return this.events.get(id) || null;
+  }
+
+  async getEvents(query: GetEventsInput): Promise<SecurityEvent[]> {
+    let events = Array.from(this.events.values());
+
+    // Apply filters
+    if (query.severity) {
+      events = events.filter(e => e.severity === query.severity);
+    }
+    if (query.type) {
+      events = events.filter(e => e.type === query.type);
+    }
+    if (query.acknowledged !== undefined) {
+      events = events.filter(e => e.acknowledged === query.acknowledged);
+    }
+    if (query.start_time) {
+      events = events.filter(e => e.timestamp >= query.start_time!);
+    }
+    if (query.end_time) {
+      events = events.filter(e => e.timestamp <= query.end_time!);
+    }
+
+    // Sort by timestamp descending (newest first)
+    events.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+
+    // Apply pagination
+    const offset = query.offset || 0;
+    const limit = query.limit || 50;
+    return events.slice(offset, offset + limit);
+  }
+
+  async countEvents(query: GetEventsInput): Promise<number> {
+    let events = Array.from(this.events.values());
+
+    if (query.severity) {
+      events = events.filter(e => e.severity === query.severity);
+    }
+    if (query.type) {
+      events = events.filter(e => e.type === query.type);
+    }
+    if (query.acknowledged !== undefined) {
+      events = events.filter(e => e.acknowledged === query.acknowledged);
+    }
+    if (query.start_time) {
+      events = events.filter(e => e.timestamp >= query.start_time!);
+    }
+    if (query.end_time) {
+      events = events.filter(e => e.timestamp <= query.end_time!);
+    }
+
+    return events.length;
+  }
+
+  async acknowledgeEvent(id: string, by?: string): Promise<void> {
+    const event = this.events.get(id);
+    if (event) {
+      event.acknowledged = true;
+      event.acknowledged_by = by;
+      event.acknowledged_at = new Date();
+    }
+  }
+
+  // ============================================================================
+  // Rules
+  // ============================================================================
+
+  async saveRule(rule: DetectionRule): Promise<void> {
+    this.rules.set(rule.id, rule);
+  }
+
+  async getRule(id: string): Promise<DetectionRule | null> {
+    return this.rules.get(id) || null;
+  }
+
+  async getRules(): Promise<DetectionRule[]> {
+    return Array.from(this.rules.values());
+  }
+
+  async deleteRule(id: string): Promise<void> {
+    this.rules.delete(id);
+  }
+
+  // ============================================================================
+  // Allowlist/Blocklist
+  // ============================================================================
+
+  async addToAllowlist(pattern: string, type: DetectorType): Promise<void> {
+    this.allowlist.set(pattern, { pattern, type });
+  }
+
+  async addToBlocklist(pattern: string, type: DetectorType): Promise<void> {
+    this.blocklist.set(pattern, { pattern, type });
+  }
+
+  async getAllowlist(type?: DetectorType): Promise<string[]> {
+    const entries = Array.from(this.allowlist.values());
+    if (type) {
+      return entries.filter(e => e.type === type).map(e => e.pattern);
+    }
+    return entries.map(e => e.pattern);
+  }
+
+  async getBlocklist(type?: DetectorType): Promise<string[]> {
+    const entries = Array.from(this.blocklist.values());
+    if (type) {
+      return entries.filter(e => e.type === type).map(e => e.pattern);
+    }
+    return entries.map(e => e.pattern);
+  }
+
+  async removeFromAllowlist(pattern: string): Promise<void> {
+    this.allowlist.delete(pattern);
+  }
+
+  async removeFromBlocklist(pattern: string): Promise<void> {
+    this.blocklist.delete(pattern);
+  }
+
+  // ============================================================================
+  // Cleanup
+  // ============================================================================
+
+  async close(): Promise<void> {
+    this.events.clear();
+    this.rules.clear();
+    this.allowlist.clear();
+    this.blocklist.clear();
+  }
+
+  // ============================================================================
+  // Utility Methods
+  // ============================================================================
+
+  getStats(): { events: number; rules: number; allowlist: number; blocklist: number } {
+    return {
+      events: this.events.size,
+      rules: this.rules.size,
+      allowlist: this.allowlist.size,
+      blocklist: this.blocklist.size
+    };
+  }
+}
+
+export default MemoryStorage;