cowork-os 0.3.21

package/src/electron/agents/HeartbeatService.ts

@@ -0,0 +1,469 @@
+import { EventEmitter } from 'events';
+import {
+  AgentRole,
+  HeartbeatResult,
+  HeartbeatEvent,
+  HeartbeatStatus,
+  HeartbeatConfig,
+  AgentMention,
+  Task,
+  Activity,
+} from '../../shared/types';
+import { AgentRoleRepository } from './AgentRoleRepository';
+import { MentionRepository } from './MentionRepository';
+import { ActivityRepository } from '../activity/ActivityRepository';
+import { WorkingStateRepository } from './WorkingStateRepository';
+
+/**
+ * Work items found during heartbeat check
+ */
+interface WorkItems {
+  pendingMentions: AgentMention[];
+  assignedTasks: Task[];
+  relevantActivities: Activity[];
+}
+
+/**
+ * Dependencies for HeartbeatService
+ */
+export interface HeartbeatServiceDeps {
+  agentRoleRepo: AgentRoleRepository;
+  mentionRepo: MentionRepository;
+  activityRepo: ActivityRepository;
+  workingStateRepo: WorkingStateRepository;
+  createTask: (workspaceId: string, prompt: string, title: string, agentRoleId?: string) => Promise<Task>;
+  getTasksForAgent: (agentRoleId: string, workspaceId?: string) => Task[];
+  getDefaultWorkspaceId: () => string | undefined;
+}
+
+/**
+ * HeartbeatService manages periodic agent wake-ups
+ *
+ * Each agent with heartbeat enabled wakes up at configured intervals
+ * to check for:
+ * - Pending @mentions directed at them
+ * - Tasks assigned to them
+ * - Relevant activity feed discussions
+ *
+ * If work is found, a task is created. Otherwise, HEARTBEAT_OK is logged.
+ */
+export class HeartbeatService extends EventEmitter {
+  private timers: Map<string, NodeJS.Timeout> = new Map();
+  private running: Map<string, boolean> = new Map();
+  private started = false;
+
+  constructor(private deps: HeartbeatServiceDeps) {
+    super();
+  }
+
+  /**
+   * Start the heartbeat service
+   * Schedules heartbeats for all enabled agents
+   */
+  async start(): Promise<void> {
+    if (this.started) {
+      return;
+    }
+
+    this.started = true;
+    const agents = this.deps.agentRoleRepo.findHeartbeatEnabled();
+
+    for (const agent of agents) {
+      this.scheduleHeartbeat(agent);
+    }
+
+    console.log(`[HeartbeatService] Started with ${agents.length} agents enabled`);
+  }
+
+  /**
+   * Stop the heartbeat service
+   * Clears all scheduled heartbeats
+   */
+  async stop(): Promise<void> {
+    this.started = false;
+
+    for (const [agentId, timer] of this.timers) {
+      clearTimeout(timer);
+    }
+
+    this.timers.clear();
+    this.running.clear();
+
+    console.log('[HeartbeatService] Stopped');
+  }
+
+  /**
+   * Manually trigger a heartbeat for a specific agent
+   */
+  async triggerHeartbeat(agentRoleId: string): Promise<HeartbeatResult> {
+    const agent = this.deps.agentRoleRepo.findById(agentRoleId);
+    if (!agent) {
+      return {
+        agentRoleId,
+        status: 'error',
+        pendingMentions: 0,
+        assignedTasks: 0,
+        relevantActivities: 0,
+        error: 'Agent role not found',
+      };
+    }
+
+    return this.executeHeartbeat(agent);
+  }
+
+  /**
+   * Update heartbeat configuration for an agent
+   */
+  updateAgentConfig(agentRoleId: string, config: HeartbeatConfig): void {
+    // Cancel existing timer
+    this.cancelHeartbeat(agentRoleId);
+
+    // Get updated agent
+    const agent = this.deps.agentRoleRepo.findById(agentRoleId);
+    if (!agent) {
+      return;
+    }
+
+    // Schedule new heartbeat if enabled
+    if (config.heartbeatEnabled && agent.heartbeatEnabled) {
+      this.scheduleHeartbeat(agent);
+    }
+  }
+
+  /**
+   * Cancel heartbeat for an agent
+   */
+  cancelHeartbeat(agentRoleId: string): void {
+    const timer = this.timers.get(agentRoleId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(agentRoleId);
+    }
+    this.running.delete(agentRoleId);
+  }
+
+  /**
+   * Get status of all heartbeat-enabled agents
+   */
+  getAllStatus(): Array<{
+    agentRoleId: string;
+    agentName: string;
+    heartbeatEnabled: boolean;
+    heartbeatStatus: HeartbeatStatus;
+    lastHeartbeatAt?: number;
+    nextHeartbeatAt?: number;
+  }> {
+    const agents = this.deps.agentRoleRepo.findAll(true);
+
+    return agents.map(agent => ({
+      agentRoleId: agent.id,
+      agentName: agent.displayName,
+      heartbeatEnabled: agent.heartbeatEnabled || false,
+      heartbeatStatus: agent.heartbeatStatus || 'idle',
+      lastHeartbeatAt: agent.lastHeartbeatAt,
+      nextHeartbeatAt: this.getNextHeartbeatTime(agent),
+    }));
+  }
+
+  /**
+   * Get status of a specific agent
+   */
+  getStatus(agentRoleId: string): {
+    heartbeatEnabled: boolean;
+    heartbeatStatus: HeartbeatStatus;
+    lastHeartbeatAt?: number;
+    nextHeartbeatAt?: number;
+    isRunning: boolean;
+  } | undefined {
+    const agent = this.deps.agentRoleRepo.findById(agentRoleId);
+    if (!agent) {
+      return undefined;
+    }
+
+    return {
+      heartbeatEnabled: agent.heartbeatEnabled || false,
+      heartbeatStatus: agent.heartbeatStatus || 'idle',
+      lastHeartbeatAt: agent.lastHeartbeatAt,
+      nextHeartbeatAt: this.getNextHeartbeatTime(agent),
+      isRunning: this.running.get(agentRoleId) || false,
+    };
+  }
+
+  /**
+   * Schedule a heartbeat for an agent
+   */
+  private scheduleHeartbeat(agent: AgentRole): void {
+    if (!this.started || !agent.heartbeatEnabled) {
+      return;
+    }
+
+    // Cancel any existing timer
+    const existingTimer = this.timers.get(agent.id);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+
+    // Calculate delay with stagger offset
+    const intervalMs = (agent.heartbeatIntervalMinutes || 15) * 60 * 1000;
+    const staggerMs = (agent.heartbeatStaggerOffset || 0) * 60 * 1000;
+
+    // Calculate time until next heartbeat
+    const now = Date.now();
+    const lastHeartbeat = agent.lastHeartbeatAt || 0;
+    const nextHeartbeat = lastHeartbeat + intervalMs + staggerMs;
+    const delayMs = Math.max(0, nextHeartbeat - now);
+
+    // Schedule the heartbeat
+    const timer = setTimeout(async () => {
+      const currentAgent = this.deps.agentRoleRepo.findById(agent.id);
+      if (currentAgent && currentAgent.heartbeatEnabled) {
+        await this.executeHeartbeat(currentAgent);
+        // Reschedule for next interval
+        this.scheduleHeartbeat(currentAgent);
+      }
+    }, delayMs);
+
+    this.timers.set(agent.id, timer);
+
+    console.log(
+      `[HeartbeatService] Scheduled ${agent.displayName} in ${Math.round(delayMs / 1000)}s`
+    );
+  }
+
+  /**
+   * Execute a heartbeat for an agent
+   */
+  private async executeHeartbeat(agent: AgentRole): Promise<HeartbeatResult> {
+    // Prevent concurrent execution
+    if (this.running.get(agent.id)) {
+      return {
+        agentRoleId: agent.id,
+        status: 'error',
+        pendingMentions: 0,
+        assignedTasks: 0,
+        relevantActivities: 0,
+        error: 'Heartbeat already running',
+      };
+    }
+
+    this.running.set(agent.id, true);
+    this.updateHeartbeatStatus(agent.id, 'running');
+
+    // Emit started event
+    this.emitHeartbeatEvent({
+      type: 'started',
+      agentRoleId: agent.id,
+      agentName: agent.displayName,
+      timestamp: Date.now(),
+    });
+
+    try {
+      // Check for pending work
+      const workItems = await this.checkForWork(agent);
+
+      const result: HeartbeatResult = {
+        agentRoleId: agent.id,
+        status: 'ok',
+        pendingMentions: workItems.pendingMentions.length,
+        assignedTasks: workItems.assignedTasks.length,
+        relevantActivities: workItems.relevantActivities.length,
+      };
+
+      // If work is found, create a task or process it
+      const hasWork =
+        workItems.pendingMentions.length > 0 ||
+        workItems.assignedTasks.length > 0;
+
+      if (hasWork) {
+        result.status = 'work_done';
+
+        // Build prompt for agent to handle the work
+        const prompt = this.buildHeartbeatPrompt(agent, workItems);
+        const workspaceId = this.deps.getDefaultWorkspaceId();
+
+        if (workspaceId) {
+          const task = await this.deps.createTask(
+            workspaceId,
+            prompt,
+            `Heartbeat: ${agent.displayName}`,
+            agent.id
+          );
+          result.taskCreated = task.id;
+        }
+
+        this.emitHeartbeatEvent({
+          type: 'work_found',
+          agentRoleId: agent.id,
+          agentName: agent.displayName,
+          timestamp: Date.now(),
+          result,
+        });
+      } else {
+        this.emitHeartbeatEvent({
+          type: 'no_work',
+          agentRoleId: agent.id,
+          agentName: agent.displayName,
+          timestamp: Date.now(),
+          result,
+        });
+      }
+
+      // Update status
+      this.updateHeartbeatStatus(agent.id, 'sleeping', Date.now());
+
+      // Emit completed event
+      this.emitHeartbeatEvent({
+        type: 'completed',
+        agentRoleId: agent.id,
+        agentName: agent.displayName,
+        timestamp: Date.now(),
+        result,
+      });
+
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+
+      this.updateHeartbeatStatus(agent.id, 'error');
+
+      const result: HeartbeatResult = {
+        agentRoleId: agent.id,
+        status: 'error',
+        pendingMentions: 0,
+        assignedTasks: 0,
+        relevantActivities: 0,
+        error: errorMessage,
+      };
+
+      this.emitHeartbeatEvent({
+        type: 'error',
+        agentRoleId: agent.id,
+        agentName: agent.displayName,
+        timestamp: Date.now(),
+        result,
+        error: errorMessage,
+      });
+
+      return result;
+    } finally {
+      this.running.set(agent.id, false);
+    }
+  }
+
+  /**
+   * Check for pending work for an agent
+   */
+  private async checkForWork(agent: AgentRole): Promise<WorkItems> {
+    // Get pending mentions
+    const pendingMentions = this.deps.mentionRepo.getPendingForAgent(agent.id);
+
+    // Get assigned tasks (in progress or pending)
+    const assignedTasks = this.deps.getTasksForAgent(agent.id);
+
+    // Get recent relevant activities (last hour)
+    // Could be enhanced to filter by agent capabilities
+    const relevantActivities: Activity[] = [];
+
+    return {
+      pendingMentions,
+      assignedTasks,
+      relevantActivities,
+    };
+  }
+
+  /**
+   * Build a prompt for the agent to handle pending work
+   */
+  private buildHeartbeatPrompt(agent: AgentRole, work: WorkItems): string {
+    const lines: string[] = [
+      `You are ${agent.displayName}, waking up for a scheduled heartbeat check.`,
+      '',
+    ];
+
+    // Add agent soul if available
+    if (agent.soul) {
+      try {
+        const soul = JSON.parse(agent.soul);
+        if (soul.communicationStyle) {
+          lines.push(`Communication style: ${soul.communicationStyle}`);
+        }
+        if (soul.focusAreas?.length) {
+          lines.push(`Focus areas: ${soul.focusAreas.join(', ')}`);
+        }
+        lines.push('');
+      } catch {
+        // Invalid JSON, skip
+      }
+    }
+
+    // Add pending mentions
+    if (work.pendingMentions.length > 0) {
+      lines.push('## Pending @Mentions');
+      for (const mention of work.pendingMentions) {
+        lines.push(`- Type: ${mention.mentionType}`);
+        if (mention.context) {
+          lines.push(`  Context: ${mention.context}`);
+        }
+      }
+      lines.push('');
+    }
+
+    // Add assigned tasks
+    if (work.assignedTasks.length > 0) {
+      lines.push('## Assigned Tasks');
+      for (const task of work.assignedTasks) {
+        lines.push(`- [${task.status}] ${task.title}`);
+      }
+      lines.push('');
+    }
+
+    // Add instructions
+    lines.push('## Instructions');
+    if (work.pendingMentions.length > 0 || work.assignedTasks.length > 0) {
+      lines.push('Please review the above items and take appropriate action.');
+      lines.push('For mentions, acknowledge them and respond as needed.');
+      lines.push('For assigned tasks, continue working on them or report any blockers.');
+    } else {
+      lines.push('No pending work found. HEARTBEAT_OK.');
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Update heartbeat status in the database
+   */
+  private updateHeartbeatStatus(
+    agentRoleId: string,
+    status: HeartbeatStatus,
+    lastHeartbeatAt?: number
+  ): void {
+    this.deps.agentRoleRepo.updateHeartbeatStatus(agentRoleId, status, lastHeartbeatAt);
+  }
+
+  /**
+   * Calculate next heartbeat time for an agent
+   */
+  private getNextHeartbeatTime(agent: AgentRole): number | undefined {
+    if (!agent.heartbeatEnabled) {
+      return undefined;
+    }
+
+    const intervalMs = (agent.heartbeatIntervalMinutes || 15) * 60 * 1000;
+    const staggerMs = (agent.heartbeatStaggerOffset || 0) * 60 * 1000;
+    const lastHeartbeat = agent.lastHeartbeatAt || Date.now();
+
+    return lastHeartbeat + intervalMs + staggerMs;
+  }
+
+  /**
+   * Emit a heartbeat event
+   */
+  private emitHeartbeatEvent(event: HeartbeatEvent): void {
+    this.emit('heartbeat', event);
+    console.log(
+      `[HeartbeatService] ${event.agentName}: ${event.type}`,
+      event.result ? `(mentions: ${event.result.pendingMentions}, tasks: ${event.result.assignedTasks})` : ''
+    );
+  }
+}

package/src/electron/agents/MentionRepository.ts

@@ -0,0 +1,242 @@
+import Database from 'better-sqlite3';
+import { v4 as uuidv4 } from 'uuid';
+import {
+  AgentMention,
+  CreateMentionRequest,
+  MentionListQuery,
+  MentionType,
+  MentionStatus,
+} from '../../shared/types';
+
+/**
+ * Repository for managing agent @mentions in the database
+ */
+export class MentionRepository {
+  constructor(private db: Database.Database) {}
+
+  /**
+   * Create a new mention
+   */
+  create(request: CreateMentionRequest): AgentMention {
+    const now = Date.now();
+    const mention: AgentMention = {
+      id: uuidv4(),
+      workspaceId: request.workspaceId,
+      taskId: request.taskId,
+      fromAgentRoleId: request.fromAgentRoleId,
+      toAgentRoleId: request.toAgentRoleId,
+      mentionType: request.mentionType,
+      context: request.context,
+      status: 'pending',
+      createdAt: now,
+    };
+
+    const stmt = this.db.prepare(`
+      INSERT INTO agent_mentions (
+        id, workspace_id, task_id, from_agent_role_id, to_agent_role_id,
+        mention_type, context, status, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(
+      mention.id,
+      mention.workspaceId,
+      mention.taskId,
+      mention.fromAgentRoleId || null,
+      mention.toAgentRoleId,
+      mention.mentionType,
+      mention.context || null,
+      mention.status,
+      mention.createdAt
+    );
+
+    return mention;
+  }
+
+  /**
+   * Find a mention by ID
+   */
+  findById(id: string): AgentMention | undefined {
+    const stmt = this.db.prepare('SELECT * FROM agent_mentions WHERE id = ?');
+    const row = stmt.get(id) as any;
+    return row ? this.mapRowToMention(row) : undefined;
+  }
+
+  /**
+   * List mentions with optional filtering
+   */
+  list(query: MentionListQuery): AgentMention[] {
+    const conditions: string[] = [];
+    const params: any[] = [];
+
+    if (query.workspaceId) {
+      conditions.push('workspace_id = ?');
+      params.push(query.workspaceId);
+    }
+
+    if (query.taskId) {
+      conditions.push('task_id = ?');
+      params.push(query.taskId);
+    }
+
+    if (query.toAgentRoleId) {
+      conditions.push('to_agent_role_id = ?');
+      params.push(query.toAgentRoleId);
+    }
+
+    if (query.fromAgentRoleId) {
+      conditions.push('from_agent_role_id = ?');
+      params.push(query.fromAgentRoleId);
+    }
+
+    if (query.status) {
+      if (Array.isArray(query.status)) {
+        conditions.push(`status IN (${query.status.map(() => '?').join(', ')})`);
+        params.push(...query.status);
+      } else {
+        conditions.push('status = ?');
+        params.push(query.status);
+      }
+    }
+
+    let sql = 'SELECT * FROM agent_mentions';
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(' AND ')}`;
+    }
+    sql += ' ORDER BY created_at DESC';
+
+    if (query.limit) {
+      sql += ` LIMIT ${query.limit}`;
+      if (query.offset) {
+        sql += ` OFFSET ${query.offset}`;
+      }
+    }
+
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params) as any[];
+    return rows.map((row) => this.mapRowToMention(row));
+  }
+
+  /**
+   * Get pending mentions for a specific agent role
+   */
+  getPendingForAgent(toAgentRoleId: string, workspaceId?: string): AgentMention[] {
+    const conditions = ['to_agent_role_id = ?', 'status = ?'];
+    const params: any[] = [toAgentRoleId, 'pending'];
+
+    if (workspaceId) {
+      conditions.push('workspace_id = ?');
+      params.push(workspaceId);
+    }
+
+    const sql = `SELECT * FROM agent_mentions WHERE ${conditions.join(' AND ')} ORDER BY created_at DESC`;
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all(...params) as any[];
+    return rows.map((row) => this.mapRowToMention(row));
+  }
+
+  /**
+   * Get pending mention count for an agent role
+   */
+  getPendingCount(toAgentRoleId: string, workspaceId?: string): number {
+    let sql = 'SELECT COUNT(*) as count FROM agent_mentions WHERE to_agent_role_id = ? AND status = ?';
+    const params: any[] = [toAgentRoleId, 'pending'];
+
+    if (workspaceId) {
+      sql += ' AND workspace_id = ?';
+      params.push(workspaceId);
+    }
+
+    const stmt = this.db.prepare(sql);
+    const result = stmt.get(...params) as { count: number };
+    return result.count;
+  }
+
+  /**
+   * Acknowledge a mention (mark as seen)
+   */
+  acknowledge(id: string): AgentMention | undefined {
+    const existing = this.findById(id);
+    if (!existing || existing.status !== 'pending') return existing;
+
+    const now = Date.now();
+    const stmt = this.db.prepare(
+      'UPDATE agent_mentions SET status = ?, acknowledged_at = ? WHERE id = ?'
+    );
+    stmt.run('acknowledged', now, id);
+
+    return { ...existing, status: 'acknowledged', acknowledgedAt: now };
+  }
+
+  /**
+   * Mark a mention as completed
+   */
+  complete(id: string): AgentMention | undefined {
+    const existing = this.findById(id);
+    if (!existing) return undefined;
+    if (existing.status === 'completed' || existing.status === 'dismissed') {
+      return existing;
+    }
+
+    const now = Date.now();
+    const stmt = this.db.prepare(
+      'UPDATE agent_mentions SET status = ?, completed_at = ? WHERE id = ?'
+    );
+    stmt.run('completed', now, id);
+
+    return { ...existing, status: 'completed', completedAt: now };
+  }
+
+  /**
+   * Dismiss a mention without completing it
+   */
+  dismiss(id: string): AgentMention | undefined {
+    const existing = this.findById(id);
+    if (!existing) return undefined;
+    if (existing.status === 'completed' || existing.status === 'dismissed') {
+      return existing;
+    }
+
+    const stmt = this.db.prepare('UPDATE agent_mentions SET status = ? WHERE id = ?');
+    stmt.run('dismissed', id);
+
+    return { ...existing, status: 'dismissed' };
+  }
+
+  /**
+   * Delete a mention
+   */
+  delete(id: string): boolean {
+    const stmt = this.db.prepare('DELETE FROM agent_mentions WHERE id = ?');
+    const result = stmt.run(id);
+    return result.changes > 0;
+  }
+
+  /**
+   * Delete all mentions for a task
+   */
+  deleteByTask(taskId: string): number {
+    const stmt = this.db.prepare('DELETE FROM agent_mentions WHERE task_id = ?');
+    const result = stmt.run(taskId);
+    return result.changes;
+  }
+
+  /**
+   * Map database row to AgentMention object
+   */
+  private mapRowToMention(row: any): AgentMention {
+    return {
+      id: row.id,
+      workspaceId: row.workspace_id,
+      taskId: row.task_id,
+      fromAgentRoleId: row.from_agent_role_id || undefined,
+      toAgentRoleId: row.to_agent_role_id,
+      mentionType: row.mention_type as MentionType,
+      context: row.context || undefined,
+      status: row.status as MentionStatus,
+      createdAt: row.created_at,
+      acknowledgedAt: row.acknowledged_at || undefined,
+      completedAt: row.completed_at || undefined,
+    };
+  }
+}