@agenticmail/enterprise 0.5.200 → 0.5.201

package/src/engine/task-queue.ts

@@ -0,0 +1,369 @@
+/**
+ * Centralized Task Queue System
+ *
+ * Tracks all agent tasks with rich metadata — before spawn, during execution,
+ * and after completion. Provides SSE for real-time dashboard updates.
+ *
+ * Every task flows through: created → assigned → in_progress → completed|failed|cancelled
+ */
+
+import { randomUUID } from 'node:crypto';
+
+// ─── Types ────────────────────────────────────────────────
+
+export type TaskStatus = 'created' | 'assigned' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export type TaskPriority = 'low' | 'normal' | 'high' | 'urgent';
+
+export interface TaskRecord {
+  id: string;
+  orgId: string;
+
+  // Who
+  assignedTo: string;        // agent ID
+  assignedToName: string;    // agent display name
+  createdBy: string;         // 'system' | agent ID | user ID
+  createdByName: string;
+
+  // What
+  title: string;             // short summary
+  description: string;       // detailed task description
+  category: string;          // 'email' | 'research' | 'meeting' | 'workflow' | 'custom'
+  tags: string[];
+
+  // Status
+  status: TaskStatus;
+  priority: TaskPriority;
+  progress: number;          // 0-100
+
+  // Timing
+  createdAt: string;
+  assignedAt: string | null;
+  startedAt: string | null;
+  completedAt: string | null;
+  estimatedDurationMs: number | null;
+  actualDurationMs: number | null;
+
+  // Result
+  result: Record<string, unknown> | null;   // outcome metadata
+  error: string | null;
+
+  // Relationships
+  parentTaskId: string | null;   // for sub-tasks
+  relatedAgentIds: string[];     // other agents involved
+  sessionId: string | null;      // linked session if any
+
+  // Model info
+  model: string | null;
+  fallbackModel: string | null;
+  modelUsed: string | null;      // actual model that executed
+  tokensUsed: number;
+  costUsd: number;
+}
+
+type TaskListener = (event: TaskEvent) => void;
+
+export interface TaskEvent {
+  type: 'task_created' | 'task_updated' | 'task_completed' | 'task_failed' | 'task_cancelled' | 'task_progress';
+  task: TaskRecord;
+  timestamp: string;
+}
+
+// ─── Task Queue Manager ───────────────────────────────────
+
+export class TaskQueueManager {
+  private tasks = new Map<string, TaskRecord>();
+  private listeners = new Set<TaskListener>();
+  private db: any;
+  private initialized = false;
+
+  constructor(db?: any) {
+    this.db = db;
+  }
+
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    if (this.db) {
+      try {
+        await this.db.run(`CREATE TABLE IF NOT EXISTS task_queue (
+          id TEXT PRIMARY KEY,
+          org_id TEXT NOT NULL,
+          assigned_to TEXT NOT NULL,
+          assigned_to_name TEXT NOT NULL DEFAULT '',
+          created_by TEXT NOT NULL DEFAULT 'system',
+          created_by_name TEXT NOT NULL DEFAULT '',
+          title TEXT NOT NULL,
+          description TEXT NOT NULL DEFAULT '',
+          category TEXT NOT NULL DEFAULT 'custom',
+          tags TEXT NOT NULL DEFAULT '[]',
+          status TEXT NOT NULL DEFAULT 'created',
+          priority TEXT NOT NULL DEFAULT 'normal',
+          progress INTEGER NOT NULL DEFAULT 0,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          assigned_at TEXT,
+          started_at TEXT,
+          completed_at TEXT,
+          estimated_duration_ms INTEGER,
+          actual_duration_ms INTEGER,
+          result TEXT,
+          error TEXT,
+          parent_task_id TEXT,
+          related_agent_ids TEXT NOT NULL DEFAULT '[]',
+          session_id TEXT,
+          model TEXT,
+          fallback_model TEXT,
+          model_used TEXT,
+          tokens_used INTEGER NOT NULL DEFAULT 0,
+          cost_usd REAL NOT NULL DEFAULT 0
+        )`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_queue_org ON task_queue(org_id)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_queue_agent ON task_queue(assigned_to)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_queue_status ON task_queue(status)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_queue_created ON task_queue(created_at)`);
+
+        // Load recent tasks into memory
+        const rows = await this.db.all(`SELECT * FROM task_queue WHERE status IN ('created','assigned','in_progress') OR created_at > datetime('now', '-24 hours') ORDER BY created_at DESC LIMIT 500`);
+        for (const row of rows || []) {
+          this.tasks.set(row.id, this.rowToTask(row));
+        }
+      } catch (e: any) {
+        console.error('[TaskQueue] DB init error:', e.message);
+      }
+    }
+    this.initialized = true;
+  }
+
+  // ─── CRUD ─────────────────────────────────────────────
+
+  async createTask(opts: {
+    orgId: string;
+    assignedTo: string;
+    assignedToName: string;
+    createdBy?: string;
+    createdByName?: string;
+    title: string;
+    description?: string;
+    category?: string;
+    tags?: string[];
+    priority?: TaskPriority;
+    parentTaskId?: string;
+    relatedAgentIds?: string[];
+    sessionId?: string;
+    model?: string;
+    fallbackModel?: string;
+    estimatedDurationMs?: number;
+  }): Promise<TaskRecord> {
+    await this.init();
+    const now = new Date().toISOString();
+    const task: TaskRecord = {
+      id: randomUUID(),
+      orgId: opts.orgId,
+      assignedTo: opts.assignedTo,
+      assignedToName: opts.assignedToName,
+      createdBy: opts.createdBy || 'system',
+      createdByName: opts.createdByName || 'System',
+      title: opts.title,
+      description: opts.description || '',
+      category: opts.category || 'custom',
+      tags: opts.tags || [],
+      status: 'created',
+      priority: opts.priority || 'normal',
+      progress: 0,
+      createdAt: now,
+      assignedAt: null,
+      startedAt: null,
+      completedAt: null,
+      estimatedDurationMs: opts.estimatedDurationMs || null,
+      actualDurationMs: null,
+      result: null,
+      error: null,
+      parentTaskId: opts.parentTaskId || null,
+      relatedAgentIds: opts.relatedAgentIds || [],
+      sessionId: opts.sessionId || null,
+      model: opts.model || null,
+      fallbackModel: opts.fallbackModel || null,
+      modelUsed: null,
+      tokensUsed: 0,
+      costUsd: 0,
+    };
+    this.tasks.set(task.id, task);
+    await this.persist(task);
+    this.emit({ type: 'task_created', task, timestamp: now });
+    return task;
+  }
+
+  async updateTask(taskId: string, updates: Partial<Pick<TaskRecord, 'status' | 'progress' | 'result' | 'error' | 'modelUsed' | 'tokensUsed' | 'costUsd' | 'sessionId' | 'title' | 'description' | 'priority'>>): Promise<TaskRecord | null> {
+    await this.init();
+    const task = this.tasks.get(taskId);
+    if (!task) return null;
+
+    const now = new Date().toISOString();
+
+    if (updates.status === 'assigned' && !task.assignedAt) task.assignedAt = now;
+    if (updates.status === 'in_progress' && !task.startedAt) task.startedAt = now;
+    if (updates.status === 'completed' || updates.status === 'failed' || updates.status === 'cancelled') {
+      task.completedAt = now;
+      if (task.startedAt) task.actualDurationMs = new Date(now).getTime() - new Date(task.startedAt).getTime();
+      if (updates.status === 'completed') task.progress = 100;
+    }
+
+    Object.assign(task, updates);
+    await this.persist(task);
+
+    const eventType = updates.status === 'completed' ? 'task_completed'
+      : updates.status === 'failed' ? 'task_failed'
+      : updates.status === 'cancelled' ? 'task_cancelled'
+      : updates.progress !== undefined ? 'task_progress'
+      : 'task_updated';
+
+    this.emit({ type: eventType, task, timestamp: now });
+    return task;
+  }
+
+  getTask(taskId: string): TaskRecord | undefined {
+    return this.tasks.get(taskId);
+  }
+
+  // ─── Queries ──────────────────────────────────────────
+
+  getActiveTasks(orgId?: string): TaskRecord[] {
+    const active: TaskRecord[] = [];
+    for (const t of this.tasks.values()) {
+      if (t.status === 'created' || t.status === 'assigned' || t.status === 'in_progress') {
+        if (!orgId || t.orgId === orgId) active.push(t);
+      }
+    }
+    return active.sort((a, b) => {
+      const pri = { urgent: 0, high: 1, normal: 2, low: 3 };
+      return (pri[a.priority] - pri[b.priority]) || (new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    });
+  }
+
+  getAllTasks(orgId?: string, limit = 100): TaskRecord[] {
+    const all: TaskRecord[] = [];
+    for (const t of this.tasks.values()) {
+      if (!orgId || t.orgId === orgId) all.push(t);
+    }
+    return all.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
+  }
+
+  getAgentTasks(agentId: string, includeCompleted = false): TaskRecord[] {
+    const res: TaskRecord[] = [];
+    for (const t of this.tasks.values()) {
+      if (t.assignedTo === agentId) {
+        if (includeCompleted || t.status === 'created' || t.status === 'assigned' || t.status === 'in_progress') {
+          res.push(t);
+        }
+      }
+    }
+    return res.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+  }
+
+  async getTaskHistory(orgId: string, limit = 50, offset = 0): Promise<TaskRecord[]> {
+    if (this.db) {
+      try {
+        const rows = await this.db.all(
+          `SELECT * FROM task_queue WHERE org_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+          [orgId, limit, offset]
+        );
+        return (rows || []).map((r: any) => this.rowToTask(r));
+      } catch { /* fall through */ }
+    }
+    return this.getAllTasks(orgId, limit);
+  }
+
+  getPipelineStats(orgId?: string): { created: number; assigned: number; inProgress: number; completed: number; failed: number; cancelled: number; total: number } {
+    const stats = { created: 0, assigned: 0, inProgress: 0, completed: 0, failed: 0, cancelled: 0, total: 0 };
+    for (const t of this.tasks.values()) {
+      if (orgId && t.orgId !== orgId) continue;
+      stats.total++;
+      if (t.status === 'created') stats.created++;
+      else if (t.status === 'assigned') stats.assigned++;
+      else if (t.status === 'in_progress') stats.inProgress++;
+      else if (t.status === 'completed') stats.completed++;
+      else if (t.status === 'failed') stats.failed++;
+      else if (t.status === 'cancelled') stats.cancelled++;
+    }
+    return stats;
+  }
+
+  // ─── SSE Subscriptions ────────────────────────────────
+
+  subscribe(listener: TaskListener): () => void {
+    this.listeners.add(listener);
+    return () => { this.listeners.delete(listener); };
+  }
+
+  private emit(event: TaskEvent): void {
+    for (const l of this.listeners) {
+      try { l(event); } catch { /* ignore */ }
+    }
+  }
+
+  // ─── Persistence ──────────────────────────────────────
+
+  private async persist(task: TaskRecord): Promise<void> {
+    if (!this.db) return;
+    try {
+      await this.db.run(`INSERT OR REPLACE INTO task_queue (
+        id, org_id, assigned_to, assigned_to_name, created_by, created_by_name,
+        title, description, category, tags, status, priority, progress,
+        created_at, assigned_at, started_at, completed_at,
+        estimated_duration_ms, actual_duration_ms, result, error,
+        parent_task_id, related_agent_ids, session_id,
+        model, fallback_model, model_used, tokens_used, cost_usd
+      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, [
+        task.id, task.orgId, task.assignedTo, task.assignedToName,
+        task.createdBy, task.createdByName,
+        task.title, task.description, task.category, JSON.stringify(task.tags),
+        task.status, task.priority, task.progress,
+        task.createdAt, task.assignedAt, task.startedAt, task.completedAt,
+        task.estimatedDurationMs, task.actualDurationMs,
+        task.result ? JSON.stringify(task.result) : null,
+        task.error,
+        task.parentTaskId, JSON.stringify(task.relatedAgentIds), task.sessionId,
+        task.model, task.fallbackModel, task.modelUsed, task.tokensUsed, task.costUsd,
+      ]);
+    } catch (e: any) {
+      console.error('[TaskQueue] persist error:', e.message);
+    }
+  }
+
+  private rowToTask(row: any): TaskRecord {
+    return {
+      id: row.id,
+      orgId: row.org_id,
+      assignedTo: row.assigned_to,
+      assignedToName: row.assigned_to_name || '',
+      createdBy: row.created_by || 'system',
+      createdByName: row.created_by_name || '',
+      title: row.title,
+      description: row.description || '',
+      category: row.category || 'custom',
+      tags: safeJson(row.tags, []),
+      status: row.status as TaskStatus,
+      priority: (row.priority || 'normal') as TaskPriority,
+      progress: row.progress || 0,
+      createdAt: row.created_at,
+      assignedAt: row.assigned_at || null,
+      startedAt: row.started_at || null,
+      completedAt: row.completed_at || null,
+      estimatedDurationMs: row.estimated_duration_ms || null,
+      actualDurationMs: row.actual_duration_ms || null,
+      result: safeJson(row.result, null),
+      error: row.error || null,
+      parentTaskId: row.parent_task_id || null,
+      relatedAgentIds: safeJson(row.related_agent_ids, []),
+      sessionId: row.session_id || null,
+      model: row.model || null,
+      fallbackModel: row.fallback_model || null,
+      modelUsed: row.model_used || null,
+      tokensUsed: row.tokens_used || 0,
+      costUsd: row.cost_usd || 0,
+    };
+  }
+}
+
+function safeJson(v: any, fallback: any): any {
+  if (!v || typeof v !== 'string') return fallback;
+  try { return JSON.parse(v); } catch { return fallback; }
+}