@agenticmail/enterprise 0.5.207 → 0.5.208

package/dist/chunk-WZ4F4SYK.js

@@ -0,0 +1,292 @@
+// src/engine/task-queue.ts
+import { randomUUID } from "crypto";
+var TaskQueueManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  db;
+  initialized = false;
+  constructor(db) {
+    this.db = db;
+  }
+  async init() {
+    if (this.initialized) return;
+    if (this.db) {
+      try {
+        await this.db.run(`CREATE TABLE IF NOT EXISTS task_pipeline (
+          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 CURRENT_TIMESTAMP,
+          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_pipeline_org ON task_pipeline(org_id)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_agent ON task_pipeline(assigned_to)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_status ON task_pipeline(status)`);
+        await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_created ON task_pipeline(created_at)`);
+        const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+        const rows = await this.db.all(`SELECT * FROM task_pipeline WHERE status IN ('created','assigned','in_progress') OR created_at > ? ORDER BY created_at DESC LIMIT 500`, [cutoff]);
+        for (const row of rows || []) {
+          this.tasks.set(row.id, this.rowToTask(row));
+        }
+      } catch (e) {
+        console.error("[TaskQueue] DB init error:", e.message);
+      }
+    }
+    this.initialized = true;
+  }
+  // ─── CRUD ─────────────────────────────────────────────
+  async createTask(opts) {
+    await this.init();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      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, updates) {
+    await this.init();
+    const task = this.tasks.get(taskId);
+    if (!task) return null;
+    const now = (/* @__PURE__ */ 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 !== void 0 ? "task_progress" : "task_updated";
+    this.emit({ type: eventType, task, timestamp: now });
+    return task;
+  }
+  getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  // ─── Queries ──────────────────────────────────────────
+  getActiveTasks(orgId) {
+    const active = [];
+    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, limit = 100) {
+    const all = [];
+    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, includeCompleted = false) {
+    const res = [];
+    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, limit = 50, offset = 0) {
+    if (this.db) {
+      try {
+        const rows = await this.db.all(
+          `SELECT * FROM task_pipeline WHERE org_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+          [orgId, limit, offset]
+        );
+        return (rows || []).map((r) => this.rowToTask(r));
+      } catch {
+      }
+    }
+    return this.getAllTasks(orgId, limit);
+  }
+  getPipelineStats(orgId) {
+    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) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  emit(event) {
+    for (const l of this.listeners) {
+      try {
+        l(event);
+      } catch {
+      }
+    }
+  }
+  // ─── Persistence ──────────────────────────────────────
+  async persist(task) {
+    if (!this.db) return;
+    try {
+      await this.db.run(`INSERT INTO task_pipeline (
+        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 (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+        ON CONFLICT (id) DO UPDATE SET
+          status=EXCLUDED.status, priority=EXCLUDED.priority, progress=EXCLUDED.progress,
+          assigned_at=EXCLUDED.assigned_at, started_at=EXCLUDED.started_at, completed_at=EXCLUDED.completed_at,
+          actual_duration_ms=EXCLUDED.actual_duration_ms, result=EXCLUDED.result, error=EXCLUDED.error,
+          model_used=EXCLUDED.model_used, tokens_used=EXCLUDED.tokens_used, cost_usd=EXCLUDED.cost_usd,
+          session_id=EXCLUDED.session_id, title=EXCLUDED.title, description=EXCLUDED.description`, [
+        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) {
+      console.error("[TaskQueue] persist error:", e.message);
+    }
+  }
+  rowToTask(row) {
+    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,
+      priority: row.priority || "normal",
+      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, fallback) {
+  if (!v || typeof v !== "string") return fallback;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return fallback;
+  }
+}
+
+export {
+  TaskQueueManager
+};