@agenticmail/enterprise 0.5.319 → 0.5.320

package/dist/chunk-Z6K5FKAB.js

@@ -0,0 +1,548 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/engine/task-queue.ts
+import { randomUUID } from "crypto";
+function safeJson(v, fallback) {
+  if (!v || typeof v !== "string") return fallback;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return fallback;
+  }
+}
+var TaskQueueManager;
+var init_task_queue = __esm({
+  "src/engine/task-queue.ts"() {
+    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) {
+          if (!this.db.all && this.db.query) this.db.all = this.db.query.bind(this.db);
+          if (!this.db.get && this.db.query) this.db.get = async (sql, params) => {
+            const rows = await this.db.query(sql, params);
+            return rows?.[0] ?? null;
+          };
+          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,
+          chain_id TEXT,
+          chain_seq INTEGER NOT NULL DEFAULT 0,
+          delegated_from TEXT,
+          delegated_to TEXT,
+          delegation_type TEXT,
+          customer_context TEXT,
+          activity_log TEXT NOT NULL DEFAULT '[]',
+          source TEXT
+        )`);
+            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)`);
+            for (const col of [
+              ["chain_id", "TEXT"],
+              ["chain_seq", "INTEGER DEFAULT 0"],
+              ["delegated_from", "TEXT"],
+              ["delegated_to", "TEXT"],
+              ["delegation_type", "TEXT"],
+              ["customer_context", "TEXT"],
+              ["activity_log", "TEXT DEFAULT '[]'"],
+              ["source", "TEXT"],
+              ["delivery_context", "TEXT"]
+            ]) {
+              try {
+                await this.db.run(`ALTER TABLE task_pipeline ADD COLUMN ${col[0]} ${col[1]}`);
+              } catch {
+              }
+            }
+            try {
+              await this.db.run(`CREATE INDEX IF NOT EXISTS idx_task_pipeline_chain ON task_pipeline(chain_id)`);
+            } catch {
+            }
+            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;
+      }
+      /**
+       * Sync active tasks from database into memory.
+       * Called by the task poller before each cycle to catch externally-added or reset tasks.
+       */
+      async syncFromDb() {
+        if (!this.db) return;
+        try {
+          const rows = await this.db.all(
+            `SELECT * FROM task_pipeline WHERE status IN ('created','assigned','in_progress') ORDER BY created_at DESC LIMIT 200`
+          );
+          if (!rows) return;
+          let added = 0;
+          for (const row of rows) {
+            const existing = this.tasks.get(row.id);
+            const dbTask = this.rowToTask(row);
+            if (!existing) {
+              this.tasks.set(row.id, dbTask);
+              added++;
+            } else if (existing.status !== dbTask.status || existing.sessionId !== dbTask.sessionId) {
+              this.tasks.set(row.id, dbTask);
+            }
+          }
+          if (added > 0) console.log(`[TaskQueue] syncFromDb: added ${added} tasks from DB`);
+        } catch (e) {
+          console.error("[TaskQueue] syncFromDb error:", e.message);
+        }
+      }
+      // ─── 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,
+          chainId: opts.chainId || randomUUID(),
+          chainSeq: opts.chainSeq || 0,
+          delegatedFrom: opts.delegatedFrom || null,
+          delegatedTo: null,
+          delegationType: opts.delegationType || null,
+          customerContext: opts.customerContext || null,
+          source: opts.source || null,
+          deliveryContext: opts.deliveryContext || null,
+          activityLog: [{ ts: now, type: "created", agent: opts.createdBy || "system", detail: "Task created" }]
+        };
+        this.tasks.set(task.id, task);
+        await this.persist(task);
+        this.emit({ type: "task_created", task, timestamp: now });
+        return task;
+      }
+      /**
+       * Delegate a task from one agent to another, creating a new linked task in the chain.
+       */
+      async delegateTask(taskId, opts) {
+        const source = this.tasks.get(taskId);
+        if (!source) return null;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        source.activityLog.push({ ts: now, type: "delegated", agent: source.assignedTo, detail: `Delegated to ${opts.toAgentName} (${opts.delegationType || "delegation"})` });
+        const delegated = await this.createTask({
+          orgId: source.orgId,
+          assignedTo: opts.toAgent,
+          assignedToName: opts.toAgentName,
+          createdBy: source.assignedTo,
+          createdByName: source.assignedToName,
+          title: opts.title || source.title,
+          description: opts.description || source.description,
+          category: source.category,
+          tags: [...source.tags],
+          priority: opts.priority || source.priority,
+          parentTaskId: source.parentTaskId || void 0,
+          relatedAgentIds: [.../* @__PURE__ */ new Set([...source.relatedAgentIds, source.assignedTo])],
+          chainId: source.chainId || void 0,
+          chainSeq: (source.chainSeq || 0) + 1,
+          delegatedFrom: source.id,
+          delegationType: opts.delegationType || "delegation",
+          customerContext: source.customerContext,
+          deliveryContext: source.deliveryContext
+        });
+        source.delegatedTo = delegated.id;
+        await this.persist(source);
+        this.emit({ type: "task_updated", task: source, timestamp: now });
+        return delegated;
+      }
+      /**
+       * Get full task chain by chainId — all tasks in a delegation flow.
+       */
+      getTaskChain(chainId) {
+        const chain = [];
+        for (const t of this.tasks.values()) {
+          if (t.chainId === chainId) chain.push(t);
+        }
+        return chain.sort((a, b) => (a.chainSeq || 0) - (b.chainSeq || 0));
+      }
+      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;
+          task.activityLog.push({ ts: now, type: "assigned", agent: task.assignedTo, detail: "Task assigned" });
+        }
+        if (updates.status === "in_progress" && !task.startedAt) {
+          task.startedAt = now;
+          task.activityLog.push({ ts: now, type: "started", agent: task.assignedTo, detail: "Work started" });
+        }
+        if (updates.progress !== void 0 && updates.progress !== task.progress) {
+          task.activityLog.push({ ts: now, type: "progress", agent: task.assignedTo, detail: `Progress: ${updates.progress}%` });
+        }
+        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;
+            const dur = task.actualDurationMs ? ` in ${Math.round(task.actualDurationMs / 1e3)}s` : "";
+            const tokens = updates.tokensUsed ? ` (${updates.tokensUsed.toLocaleString()} tokens` + (updates.costUsd ? `, $${updates.costUsd.toFixed(4)}` : "") + ")" : "";
+            task.activityLog.push({ ts: now, type: "completed", agent: task.assignedTo, detail: `Task completed${dur}${tokens}` });
+          }
+          if (updates.status === "failed") {
+            task.activityLog.push({ ts: now, type: "failed", agent: task.assignedTo, detail: `Task failed: ${updates.error || "Unknown error"}` });
+          }
+          if (updates.status === "cancelled") {
+            task.activityLog.push({ ts: now, type: "cancelled", agent: task.assignedTo, detail: "Task cancelled" });
+          }
+        }
+        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 getTaskBySessionId(sessionId) {
+        if (this.db) {
+          try {
+            const row = await this.db.get(
+              `SELECT * FROM task_pipeline WHERE session_id = ? AND status = 'in_progress' ORDER BY created_at DESC LIMIT 1`,
+              [sessionId]
+            );
+            return row ? this.rowToTask(row) : null;
+          } catch {
+          }
+        }
+        for (const task of this.tasks.values()) {
+          if (task.sessionId === sessionId && task.status === "in_progress") return task;
+        }
+        return null;
+      }
+      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);
+      }
+      async getPipelineStats(orgId) {
+        const stats = {
+          created: 0,
+          assigned: 0,
+          inProgress: 0,
+          completed: 0,
+          failed: 0,
+          cancelled: 0,
+          total: 0,
+          todayCompleted: 0,
+          todayFailed: 0,
+          todayCreated: 0,
+          avgDurationMs: 0,
+          totalCost: 0,
+          totalTokens: 0,
+          topAgents: []
+        };
+        const todayStart = /* @__PURE__ */ new Date();
+        todayStart.setHours(0, 0, 0, 0);
+        const todayMs = todayStart.getTime();
+        let durationSum = 0;
+        let durationCount = 0;
+        const agentMap = /* @__PURE__ */ new Map();
+        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++;
+          const createdMs = new Date(t.createdAt).getTime();
+          if (createdMs >= todayMs) stats.todayCreated++;
+          if (t.completedAt && new Date(t.completedAt).getTime() >= todayMs) {
+            if (t.status === "completed") stats.todayCompleted++;
+            if (t.status === "failed") stats.todayFailed++;
+          }
+          if (t.actualDurationMs) {
+            durationSum += t.actualDurationMs;
+            durationCount++;
+          }
+          stats.totalCost += t.costUsd || 0;
+          stats.totalTokens += t.tokensUsed || 0;
+          if (t.assignedTo) {
+            if (!agentMap.has(t.assignedTo)) agentMap.set(t.assignedTo, { name: t.assignedToName || t.assignedTo, completed: 0, active: 0 });
+            const a = agentMap.get(t.assignedTo);
+            if (t.status === "completed") a.completed++;
+            if (t.status === "in_progress" || t.status === "assigned") a.active++;
+          }
+        }
+        stats.avgDurationMs = durationCount > 0 ? Math.round(durationSum / durationCount) : 0;
+        stats.topAgents = Array.from(agentMap.entries()).map(([agent, d]) => ({ agent, ...d })).sort((a, b) => b.completed + b.active - (a.completed + a.active)).slice(0, 5);
+        if (this.db) {
+          try {
+            const todayISO = todayStart.toISOString();
+            const dbToday = await this.db.get(
+              `SELECT COUNT(*) FILTER (WHERE status='completed' AND completed_at >= ?) as dc,
+                  COUNT(*) FILTER (WHERE status='failed' AND completed_at >= ?) as df,
+                  COUNT(*) FILTER (WHERE created_at >= ?) as dn
+           FROM task_pipeline` + (orgId ? ` WHERE org_id = ?` : ""),
+              orgId ? [todayISO, todayISO, todayISO, orgId] : [todayISO, todayISO, todayISO]
+            ).catch(() => null);
+            if (!dbToday || dbToday.dc === void 0) {
+              const r1 = await this.db.get(`SELECT COUNT(*) as c FROM task_pipeline WHERE status='completed' AND completed_at >= ?`, [todayISO]).catch(() => null);
+              const r2 = await this.db.get(`SELECT COUNT(*) as c FROM task_pipeline WHERE status='failed' AND completed_at >= ?`, [todayISO]).catch(() => null);
+              const r3 = await this.db.get(`SELECT COUNT(*) as c FROM task_pipeline WHERE created_at >= ?`, [todayISO]).catch(() => null);
+              if (r1?.c > stats.todayCompleted) stats.todayCompleted = r1.c;
+              if (r2?.c > stats.todayFailed) stats.todayFailed = r2.c;
+              if (r3?.c > stats.todayCreated) stats.todayCreated = r3.c;
+            } else {
+              if (dbToday.dc > stats.todayCompleted) stats.todayCompleted = dbToday.dc;
+              if (dbToday.df > stats.todayFailed) stats.todayFailed = dbToday.df;
+              if (dbToday.dn > stats.todayCreated) stats.todayCreated = dbToday.dn;
+            }
+          } catch {
+          }
+        }
+        return stats;
+      }
+      // ─── SSE Subscriptions ────────────────────────────────
+      subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+          this.listeners.delete(listener);
+        };
+      }
+      /** URL to notify when tasks change (for standalone agents → enterprise SSE relay) */
+      webhookUrl = null;
+      emit(event) {
+        for (const l of this.listeners) {
+          try {
+            l(event);
+          } catch {
+          }
+        }
+        if (this.webhookUrl) {
+          fetch(this.webhookUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(event),
+            signal: AbortSignal.timeout(3e3)
+          }).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,
+        chain_id, chain_seq, delegated_from, delegated_to, delegation_type,
+        customer_context, activity_log, source, delivery_context
+      ) 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,
+          delegated_to=EXCLUDED.delegated_to, activity_log=EXCLUDED.activity_log`, [
+            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,
+            task.chainId,
+            task.chainSeq,
+            task.delegatedFrom,
+            task.delegatedTo,
+            task.delegationType,
+            task.customerContext ? JSON.stringify(task.customerContext) : null,
+            JSON.stringify(task.activityLog || []),
+            task.source,
+            task.deliveryContext ? JSON.stringify(task.deliveryContext) : null
+          ]);
+        } 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,
+          chainId: row.chain_id || null,
+          chainSeq: row.chain_seq || 0,
+          delegatedFrom: row.delegated_from || null,
+          delegatedTo: row.delegated_to || null,
+          delegationType: row.delegation_type || null,
+          customerContext: safeJson(row.customer_context, null),
+          source: row.source || null,
+          deliveryContext: safeJson(row.delivery_context, null),
+          activityLog: safeJson(row.activity_log, [])
+        };
+      }
+    };
+  }
+});
+
+export {
+  TaskQueueManager,
+  init_task_queue
+};