@agenticmail/enterprise 0.5.441 → 0.5.443

package/dist/chunk-FQWJMPKW.js

@@ -0,0 +1,305 @@
+import {
+  __esm
+} from "./chunk-KFQGP6VL.js";
+
+// src/engine/agent-status.ts
+function describeToolActivity(toolName) {
+  const MAP = {
+    gmail_search: "Searching Gmail",
+    gmail_read: "Reading email",
+    gmail_send: "Sending email",
+    gmail_reply: "Replying to email",
+    gmail_forward: "Forwarding email",
+    gmail_drafts: "Managing email drafts",
+    google_calendar_events: "Checking calendar",
+    google_calendar_list: "Listing calendars",
+    google_chat_send_message: "Sending chat message",
+    google_chat_list_messages: "Reading chat messages",
+    google_chat_list_spaces: "Browsing chat spaces",
+    meeting_join: "Joining a meeting",
+    meeting_speak: "Speaking in meeting",
+    meeting_prepare: "Preparing for meeting",
+    browser: "Browsing the web",
+    web_search: "Searching the web",
+    web_fetch: "Fetching a webpage",
+    memory: "Accessing memory",
+    memory_reflect: "Reflecting on learnings",
+    knowledge_base_search: "Searching knowledge base",
+    knowledge_hub_search: "Searching knowledge hub",
+    google_drive_search: "Searching Drive",
+    google_drive_get: "Reading a Drive file",
+    google_docs_create: "Creating a document",
+    google_sheets_read: "Reading a spreadsheet",
+    bash: "Running a command",
+    read: "Reading a file",
+    write: "Writing a file"
+  };
+  return MAP[toolName] || toolName.replace(/_/g, " ");
+}
+var AgentStatusTracker;
+var init_agent_status = __esm({
+  "src/engine/agent-status.ts"() {
+    AgentStatusTracker = class {
+      statuses = /* @__PURE__ */ new Map();
+      listeners = /* @__PURE__ */ new Set();
+      staleCheckTimer = null;
+      dbSyncTimer = null;
+      dirtyAgents = /* @__PURE__ */ new Set();
+      db = null;
+      // EngineDatabase reference for persisting state
+      /** How long without a heartbeat before agent is considered offline */
+      staleThresholdMs = 9e4;
+      // 90 seconds
+      constructor() {
+        this.staleCheckTimer = setInterval(() => this.checkStale(), 3e4);
+        if (this.staleCheckTimer.unref) this.staleCheckTimer.unref();
+        this.dbSyncTimer = setInterval(() => this.flushToDb(), 1e4);
+        if (this.dbSyncTimer.unref) this.dbSyncTimer.unref();
+      }
+      /** Set database reference for persisting status to managed_agents */
+      setDb(db) {
+        this.db = db;
+      }
+      // ─── Core State Updates ────────────────────────────────
+      /** Agent process sent a heartbeat (proves it's alive) */
+      heartbeat(agentId) {
+        const snap = this.getOrCreate(agentId);
+        snap.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+        if (snap.status === "offline" || snap.status === "error") {
+          snap.status = "idle";
+          snap.onlineSince = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        this.emit(agentId, snap);
+      }
+      /** Agent started working on something */
+      startActivity(agentId, activity) {
+        const snap = this.getOrCreate(agentId);
+        snap.status = "online";
+        snap.currentActivity = { ...activity, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        snap.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+        snap.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+        if (!snap.onlineSince) snap.onlineSince = (/* @__PURE__ */ new Date()).toISOString();
+        this.emit(agentId, snap);
+      }
+      /** Agent finished current activity */
+      endActivity(agentId) {
+        const snap = this.getOrCreate(agentId);
+        snap.currentActivity = null;
+        snap.status = snap.activeSessions > 0 ? "online" : "idle";
+        snap.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+        this.emit(agentId, snap);
+      }
+      /** Agent executing a tool */
+      toolStart(agentId, toolName, detail) {
+        const snap = this.getOrCreate(agentId);
+        snap.status = "online";
+        snap.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+        snap.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+        if (snap.currentActivity) {
+          snap.currentActivity.tool = toolName;
+          if (detail) snap.currentActivity.detail = detail;
+        } else {
+          snap.currentActivity = {
+            type: "tool_call",
+            detail: detail || toolName,
+            tool: toolName,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        this.emit(agentId, snap);
+      }
+      /** Tool execution finished */
+      toolEnd(agentId) {
+        const snap = this.getOrCreate(agentId);
+        if (snap.currentActivity?.tool) {
+          snap.currentActivity.tool = void 0;
+        }
+        this.emit(agentId, snap);
+      }
+      /** Session started */
+      sessionStart(agentId, sessionId, kind, detail) {
+        const snap = this.getOrCreate(agentId);
+        snap.activeSessions++;
+        snap.status = "online";
+        snap.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+        snap.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+        if (!snap.onlineSince) snap.onlineSince = (/* @__PURE__ */ new Date()).toISOString();
+        snap.currentActivity = {
+          type: kind || "task",
+          detail: detail || kind,
+          sessionId,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.emit(agentId, snap);
+      }
+      /** Session ended */
+      sessionEnd(agentId, _sessionId) {
+        const snap = this.getOrCreate(agentId);
+        snap.activeSessions = Math.max(0, snap.activeSessions - 1);
+        if (snap.activeSessions === 0) {
+          snap.currentActivity = null;
+          snap.status = "idle";
+        }
+        snap.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+        this.emit(agentId, snap);
+      }
+      /** Agent clocked in */
+      clockIn(agentId) {
+        const snap = this.getOrCreate(agentId);
+        snap.clockedIn = true;
+        snap.status = snap.activeSessions > 0 ? "online" : "idle";
+        snap.onlineSince = (/* @__PURE__ */ new Date()).toISOString();
+        this.emit(agentId, snap);
+      }
+      /** Agent clocked out */
+      clockOut(agentId) {
+        const snap = this.getOrCreate(agentId);
+        snap.clockedIn = false;
+        snap.status = "offline";
+        snap.currentActivity = null;
+        snap.onlineSince = null;
+        this.emit(agentId, snap);
+      }
+      /** Agent process crashed or went offline */
+      markOffline(agentId, reason) {
+        const snap = this.getOrCreate(agentId);
+        snap.status = reason ? "error" : "offline";
+        snap.currentActivity = null;
+        snap.activeSessions = 0;
+        snap.onlineSince = null;
+        this.emit(agentId, snap);
+      }
+      // ─── Queries ───────────────────────────────────────────
+      getStatus(agentId) {
+        const snap = this.getOrCreate(agentId);
+        if (snap.onlineSince) {
+          snap.uptimeMs = Date.now() - new Date(snap.onlineSince).getTime();
+        } else {
+          snap.uptimeMs = null;
+        }
+        return { ...snap };
+      }
+      getAllStatuses() {
+        return Array.from(this.statuses.values()).map((s) => ({
+          ...s,
+          uptimeMs: s.onlineSince ? Date.now() - new Date(s.onlineSince).getTime() : null
+        }));
+      }
+      // ─── Subscriptions (for SSE) ───────────────────────────
+      subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      }
+      // ─── Internals ─────────────────────────────────────────
+      getOrCreate(agentId) {
+        let snap = this.statuses.get(agentId);
+        if (!snap) {
+          snap = {
+            agentId,
+            status: "offline",
+            clockedIn: false,
+            currentActivity: null,
+            activeSessions: 0,
+            lastHeartbeat: null,
+            lastActivity: null,
+            uptimeMs: null,
+            onlineSince: null
+          };
+          this.statuses.set(agentId, snap);
+        }
+        return snap;
+      }
+      emit(agentId, snapshot) {
+        this.dirtyAgents.add(agentId);
+        for (const listener of this.listeners) {
+          try {
+            listener(agentId, snapshot);
+          } catch {
+          }
+        }
+      }
+      /** Map SSE status → DB state column value */
+      statusToDbState(status, activeSessions) {
+        switch (status) {
+          case "online":
+            return "running";
+          case "idle":
+            return activeSessions > 0 ? "running" : "ready";
+          case "error":
+            return "error";
+          case "offline":
+            return "stopped";
+          default:
+            return "unknown";
+        }
+      }
+      /** Flush dirty agent statuses to the database */
+      async flushToDb() {
+        if (!this.db || this.dirtyAgents.size === 0) return;
+        const batch = [...this.dirtyAgents];
+        this.dirtyAgents.clear();
+        for (const agentId of batch) {
+          const snap = this.statuses.get(agentId);
+          if (!snap) continue;
+          const dbState = this.statusToDbState(snap.status, snap.activeSessions);
+          try {
+            await this.db.run(
+              `UPDATE managed_agents SET state = $1, updated_at = $2 WHERE id = $3`,
+              [dbState, (/* @__PURE__ */ new Date()).toISOString(), agentId]
+            );
+          } catch {
+            try {
+              await this.db.run(
+                `UPDATE managed_agents SET state = ?, updated_at = ? WHERE id = ?`,
+                [dbState, (/* @__PURE__ */ new Date()).toISOString(), agentId]
+              );
+            } catch (e) {
+              console.warn(`[agent-status] DB sync failed for ${agentId}: ${e?.message}`);
+            }
+          }
+        }
+      }
+      checkStale() {
+        const now = Date.now();
+        for (const [agentId, snap] of this.statuses) {
+          if (snap.status === "offline" || snap.status === "error") continue;
+          if (snap.lastHeartbeat) {
+            const elapsed = now - new Date(snap.lastHeartbeat).getTime();
+            if (elapsed > this.staleThresholdMs) {
+              snap.status = "offline";
+              snap.currentActivity = null;
+              snap.activeSessions = 0;
+              snap.onlineSince = null;
+              this.emit(agentId, snap);
+            }
+          }
+        }
+      }
+      /** Accept a full status update from an external agent process */
+      externalUpdate(agentId, update) {
+        const snap = this.getOrCreate(agentId);
+        if (update.status != null) snap.status = update.status;
+        if (update.clockedIn != null) snap.clockedIn = update.clockedIn;
+        if (update.currentActivity !== void 0) snap.currentActivity = update.currentActivity;
+        if (update.activeSessions != null) snap.activeSessions = update.activeSessions;
+        snap.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+        if (snap.status !== "offline" && !snap.onlineSince) snap.onlineSince = (/* @__PURE__ */ new Date()).toISOString();
+        this.emit(agentId, snap);
+      }
+      destroy() {
+        if (this.staleCheckTimer) clearInterval(this.staleCheckTimer);
+        if (this.dbSyncTimer) clearInterval(this.dbSyncTimer);
+        this.flushToDb().catch(() => {
+        });
+        this.listeners.clear();
+        this.statuses.clear();
+      }
+    };
+  }
+});
+
+export {
+  AgentStatusTracker,
+  describeToolActivity,
+  init_agent_status
+};