@usejarvis/brain 0.1.0

package/src/daemon/event-reactor.ts

@@ -0,0 +1,214 @@
+/**
+ * Event Reactor — Immediate Response Engine
+ *
+ * Handles critical/high priority events by sending them to the agent
+ * as synthetic messages with full tool access. Includes cooldown and
+ * deduplication to prevent reaction storms.
+ */
+
+import type { ClassifiedEvent } from './event-classifier.ts';
+import type { IAgentService } from './agent-service-interface.ts';
+
+export type ReactorConfig = {
+  /** Max reactions per event type within the cooldown window */
+  maxPerType: number;
+  /** Cooldown window per event type in ms (default: 60s) */
+  typeCooldownMs: number;
+  /** Global max reactions within the global window */
+  globalMax: number;
+  /** Global cooldown window in ms (default: 10 min) */
+  globalWindowMs: number;
+};
+
+const DEFAULT_CONFIG: ReactorConfig = {
+  maxPerType: 5,
+  typeCooldownMs: 10_000,
+  globalMax: 15,
+  globalWindowMs: 10 * 60_000,
+};
+
+type ReactionRecord = {
+  eventHash: string;
+  eventType: string;
+  timestamp: number;
+};
+
+export type ReactionCallback = (text: string, priority: 'urgent' | 'normal') => void;
+
+export class EventReactor {
+  private agentService: IAgentService | null = null;
+  private config: ReactorConfig;
+  private reactionLog: ReactionRecord[] = [];
+  private seenHashes = new Set<string>();
+  private onReaction: ReactionCallback | null = null;
+  private queue: ClassifiedEvent[] = [];
+  private processing = false;
+
+  constructor(config?: Partial<ReactorConfig>) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  /**
+   * Wire the reactor to the agent service (called during daemon startup).
+   */
+  setAgentService(agent: IAgentService): void {
+    this.agentService = agent;
+  }
+
+  /**
+   * Set callback for when a reaction is produced (e.g., broadcast via WebSocket).
+   */
+  setReactionCallback(cb: ReactionCallback): void {
+    this.onReaction = cb;
+  }
+
+  /**
+   * Attempt to react to a classified event.
+   * Returns true if reaction was triggered, false if throttled/deduped.
+   */
+  async react(classified: ClassifiedEvent): Promise<boolean> {
+    if (!this.agentService) {
+      console.warn('[EventReactor] No agent service configured, skipping reaction');
+      return false;
+    }
+
+    const hash = this.hashEvent(classified);
+
+    // Deduplication: don't react to the exact same event twice
+    if (this.seenHashes.has(hash)) {
+      return false;
+    }
+
+    // Cooldown: check per-type rate limit
+    if (!this.canReactForType(classified.event.type)) {
+      console.log(`[EventReactor] Cooldown active for type: ${classified.event.type}`);
+      return false;
+    }
+
+    // Cooldown: check global rate limit
+    if (!this.canReactGlobally()) {
+      console.log('[EventReactor] Global reaction limit reached');
+      return false;
+    }
+
+    // If already processing, queue for later
+    if (this.processing) {
+      console.log(`[EventReactor] Queuing event (${this.queue.length + 1} in queue): ${classified.reason}`);
+      this.queue.push(classified);
+      return true; // Will be processed later
+    }
+
+    await this.processEvent(classified, hash);
+    return true;
+  }
+
+  // --- Private helpers ---
+
+  private async processEvent(classified: ClassifiedEvent, hash: string): Promise<void> {
+    this.processing = true;
+
+    try {
+      const prompt = this.buildReactionPrompt(classified);
+      console.log(`[EventReactor] Reacting to ${classified.priority} event: ${classified.reason}`);
+
+      const response = await this.agentService!.handleMessage(prompt, 'system');
+
+      // Record the reaction
+      this.recordReaction(hash, classified.event.type);
+
+      // Broadcast via callback
+      const priority = classified.priority === 'critical' ? 'urgent' : 'normal';
+      if (this.onReaction && response) {
+        this.onReaction(response, priority);
+      }
+    } catch (err) {
+      console.error('[EventReactor] Reaction failed:', err);
+    } finally {
+      this.processing = false;
+
+      // Drain the queue
+      await this.processQueue();
+    }
+  }
+
+  private async processQueue(): Promise<void> {
+    while (this.queue.length > 0 && !this.processing) {
+      const next = this.queue.shift()!;
+      const hash = this.hashEvent(next);
+
+      // Re-check dedup and cooldowns before processing queued event
+      if (this.seenHashes.has(hash)) continue;
+      if (!this.canReactForType(next.event.type)) continue;
+      if (!this.canReactGlobally()) break;
+
+      await this.processEvent(next, hash);
+    }
+  }
+
+  private buildReactionPrompt(classified: ClassifiedEvent): string {
+    const { event, priority, reason } = classified;
+    const dataStr = JSON.stringify(event.data, null, 2);
+
+    return [
+      `[PROACTIVE — ${priority.toUpperCase()}]`,
+      '',
+      reason,
+      '',
+      `Event type: ${event.type}`,
+      `Event data: ${dataStr}`,
+      '',
+      'Take appropriate action. You have full access to your tools (browser, terminal, files).',
+      'If this requires user attention, explain clearly what happened and what you did or recommend.',
+      'If you can handle it autonomously, do so and report what you did.',
+    ].join('\n');
+  }
+
+  private hashEvent(classified: ClassifiedEvent): string {
+    // Simple hash: type + stringified data (first 500 chars to avoid huge hashes)
+    const key = `${classified.event.type}:${JSON.stringify(classified.event.data).slice(0, 500)}`;
+    let hash = 0;
+    for (let i = 0; i < key.length; i++) {
+      const char = key.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash |= 0; // Convert to 32-bit integer
+    }
+    return hash.toString(36);
+  }
+
+  private canReactForType(eventType: string): boolean {
+    const now = Date.now();
+    const cutoff = now - this.config.typeCooldownMs;
+
+    const recentForType = this.reactionLog.filter(
+      r => r.eventType === eventType && r.timestamp > cutoff
+    );
+
+    return recentForType.length < this.config.maxPerType;
+  }
+
+  private canReactGlobally(): boolean {
+    const now = Date.now();
+    const cutoff = now - this.config.globalWindowMs;
+
+    const recentGlobal = this.reactionLog.filter(r => r.timestamp > cutoff);
+
+    return recentGlobal.length < this.config.globalMax;
+  }
+
+  private recordReaction(hash: string, eventType: string): void {
+    const now = Date.now();
+
+    this.reactionLog.push({ eventHash: hash, eventType, timestamp: now });
+    this.seenHashes.add(hash);
+
+    // Prune old records (keep last hour)
+    const oneHourAgo = now - 60 * 60_000;
+    this.reactionLog = this.reactionLog.filter(r => r.timestamp > oneHourAgo);
+
+    // Prune seen hashes (keep max 1000)
+    if (this.seenHashes.size > 1000) {
+      const arr = Array.from(this.seenHashes);
+      this.seenHashes = new Set(arr.slice(arr.length - 500));
+    }
+  }
+}

package/src/daemon/health.ts

@@ -0,0 +1,220 @@
+/**
+ * Health Monitor
+ *
+ * Monitors daemon health, service status, memory usage, and database connectivity.
+ * Runs periodic health checks and logs warnings when issues are detected.
+ */
+
+import { existsSync, statSync } from "node:fs";
+import { ServiceRegistry, type ServiceStatus } from "./services.ts";
+import { getDb } from "../vault/schema.ts";
+
+export type HealthStatus = {
+  uptime: number;           // seconds
+  services: Record<string, ServiceStatus>;
+  memory: { heapUsed: number; heapTotal: number; rss: number };
+  database: { connected: boolean; size: number };  // DB file size in bytes
+  startedAt: number;        // epoch ms
+};
+
+export class HealthMonitor {
+  private startTime: number;
+  private registry: ServiceRegistry;
+  private checkInterval: Timer | null = null;
+  private dbPath: string;
+
+  constructor(registry: ServiceRegistry, dbPath: string) {
+    this.startTime = Date.now();
+    this.registry = registry;
+    this.dbPath = dbPath;
+  }
+
+  /**
+   * Start periodic health checks
+   * @param intervalMs - Check interval in milliseconds (default: 30 seconds)
+   */
+  start(intervalMs: number = 30000): void {
+    if (this.checkInterval) {
+      console.log('[HealthMonitor] Already running');
+      return;
+    }
+
+    console.log(`[HealthMonitor] Starting health checks (every ${intervalMs}ms)`);
+    this.checkInterval = setInterval(() => {
+      this.check();
+    }, intervalMs);
+
+    // Run initial check
+    this.check();
+  }
+
+  /**
+   * Stop periodic health checks
+   */
+  stop(): void {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+      console.log('[HealthMonitor] Stopped');
+    }
+  }
+
+  /**
+   * Get current health status
+   */
+  getHealth(): HealthStatus {
+    const now = Date.now();
+    const uptime = Math.floor((now - this.startTime) / 1000);
+    const services = this.registry.getStatus();
+    const memory = this.getMemoryStats();
+    const database = this.getDatabaseStats();
+
+    return {
+      uptime,
+      services,
+      memory,
+      database,
+      startedAt: this.startTime,
+    };
+  }
+
+  /**
+   * Perform health check and log warnings
+   */
+  private check(): void {
+    const health = this.getHealth();
+
+    // Check service health
+    const unhealthyServices = Object.entries(health.services)
+      .filter(([_, status]) => status === 'error' || status === 'stopping');
+
+    if (unhealthyServices.length > 0) {
+      console.warn('[HealthMonitor] ⚠ Unhealthy services detected:');
+      for (const [name, status] of unhealthyServices) {
+        const info = this.registry.getServiceInfo(name);
+        const error = info?.error ? ` - ${info.error}` : '';
+        console.warn(`  - ${name}: ${status}${error}`);
+      }
+    }
+
+    // Check database connectivity
+    if (!health.database.connected) {
+      console.warn('[HealthMonitor] ⚠ Database not connected');
+    }
+
+    // Check memory usage (warn if > 500MB)
+    const memoryMB = health.memory.rss / (1024 * 1024);
+    if (memoryMB > 500) {
+      console.warn(
+        `[HealthMonitor] ⚠ High memory usage: ${memoryMB.toFixed(2)}MB RSS`
+      );
+    }
+
+    // Log uptime milestone (every hour)
+    if (health.uptime > 0 && health.uptime % 3600 === 0) {
+      const hours = health.uptime / 3600;
+      console.log(`[HealthMonitor] Uptime: ${hours} hour${hours > 1 ? 's' : ''}`);
+    }
+  }
+
+  /**
+   * Get memory statistics
+   */
+  private getMemoryStats(): { heapUsed: number; heapTotal: number; rss: number } {
+    const usage = process.memoryUsage();
+    return {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      rss: usage.rss,
+    };
+  }
+
+  /**
+   * Get database statistics
+   */
+  private getDatabaseStats(): { connected: boolean; size: number } {
+    let connected = false;
+    let size = 0;
+
+    try {
+      const db = getDb();
+      // Simple query to check if DB is responsive
+      db.query("SELECT 1").get();
+      connected = true;
+
+      // Get DB file size if it's not in-memory
+      if (this.dbPath !== ':memory:' && existsSync(this.dbPath)) {
+        const stats = statSync(this.dbPath);
+        size = stats.size;
+      }
+    } catch (error) {
+      // DB not connected or not initialized
+      connected = false;
+    }
+
+    return { connected, size };
+  }
+
+  /**
+   * Format health status as human-readable string
+   */
+  formatHealth(): string {
+    const health = this.getHealth();
+    const lines: string[] = [];
+
+    lines.push('=== JARVIS Health Status ===');
+    lines.push(`Uptime: ${this.formatUptime(health.uptime)}`);
+    lines.push(`Started: ${new Date(health.startedAt).toISOString()}`);
+    lines.push('');
+
+    lines.push('Services:');
+    for (const [name, status] of Object.entries(health.services)) {
+      const icon = status === 'running' ? '✓' : status === 'error' ? '✗' : '○';
+      lines.push(`  ${icon} ${name}: ${status}`);
+    }
+    lines.push('');
+
+    lines.push('Memory:');
+    lines.push(`  Heap: ${this.formatBytes(health.memory.heapUsed)} / ${this.formatBytes(health.memory.heapTotal)}`);
+    lines.push(`  RSS: ${this.formatBytes(health.memory.rss)}`);
+    lines.push('');
+
+    lines.push('Database:');
+    lines.push(`  Connected: ${health.database.connected ? 'Yes' : 'No'}`);
+    lines.push(`  Size: ${this.formatBytes(health.database.size)}`);
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Format uptime in human-readable format
+   */
+  private formatUptime(seconds: number): string {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+
+    const parts: string[] = [];
+    if (days > 0) parts.push(`${days}d`);
+    if (hours > 0) parts.push(`${hours}h`);
+    if (minutes > 0) parts.push(`${minutes}m`);
+    if (secs > 0 || parts.length === 0) parts.push(`${secs}s`);
+
+    return parts.join(' ');
+  }
+
+  /**
+   * Format bytes in human-readable format
+   */
+  private formatBytes(bytes: number): string {
+    if (bytes === 0) return '0 B';
+
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    const size = bytes / Math.pow(k, i);
+
+    return `${size.toFixed(2)} ${sizes[i]}`;
+  }
+}