@elevasis/ui 2.73.0 → 2.75.0

package/dist/chunk-NMHQAYZU.js

@@ -0,0 +1,439 @@
+import { createLiveTempMessageIdentity } from './chunk-QFGNRKIE.js';
+import { sessionsKeys } from './chunk-SB3IHM5Y.js';
+import { SessionIdParamSchema, WebSocketSessionTurnSchema, ExecutionIdParamsSchema } from './chunk-2GIJBHZT.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { STALE_TIME_MONITORING, STALE_TIME_DEFAULT } from './chunk-A2SB32YV.js';
+import { WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, REFETCH_INTERVAL_RUNNING } from './chunk-Y6I3IC45.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { useAuthContext } from './chunk-BRJ3QZ4E.js';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function useCommandViewStats(timeRange = "30d", options) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["command-view-stats", workOSOrganizationId, timeRange],
+    queryFn: async () => {
+      return apiRequest(`/command-view/stats?timeRange=${timeRange}`);
+    },
+    enabled: isReady && (options?.enabled ?? true),
+    staleTime: STALE_TIME_MONITORING
+  });
+}
+function useCheckpointTasks({ checkpointId, enabled = true }) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["checkpoint-tasks", workOSOrganizationId, checkpointId],
+    queryFn: async () => {
+      return apiRequest(
+        `/command-queue?humanCheckpoint=${checkpointId}&status=pending&limit=10`
+      );
+    },
+    // Only fetch when: org ready, checkpoint selected, and enabled
+    enabled: isReady && !!checkpointId && enabled,
+    staleTime: STALE_TIME_MONITORING
+  });
+}
+function useResourceExecutions({
+  resourceId,
+  timeRange,
+  page = 1,
+  limit = 10,
+  enabled = true
+}) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["resource-executions", workOSOrganizationId, resourceId, timeRange, page, limit],
+    queryFn: async () => {
+      return apiRequest(
+        `/command-view/resource-executions?resourceId=${resourceId}&timeRange=${timeRange}&page=${page}&limit=${limit}`
+      );
+    },
+    // Only fetch when: org ready, resource selected, and enabled
+    enabled: isReady && !!resourceId && enabled,
+    staleTime: STALE_TIME_MONITORING
+  });
+}
+var NEW_SESSION_VISUALIZATION_MODE = "explore";
+var LEGACY_VISUALIZATION_MODES = /* @__PURE__ */ new Set(["overview", "cluster", "swimlane", "focus", "network", "force"]);
+function normalizePersistedVisualizationMode(value) {
+  if (value === "explore") return "explore";
+  if (LEGACY_VISUALIZATION_MODES.has(String(value))) return NEW_SESSION_VISUALIZATION_MODE;
+  return NEW_SESSION_VISUALIZATION_MODE;
+}
+var DEFAULT_DIAGNOSTIC_CATEGORIES = ["diagnostic", "testing"];
+var useCommandViewStore = create()(
+  persist(
+    (set) => ({
+      statusFilter: "all",
+      setStatusFilter: (statusFilter) => set({ statusFilter }),
+      showIntegrations: true,
+      setShowIntegrations: (showIntegrations) => set({ showIntegrations }),
+      fitViewOnFilter: true,
+      setFitViewOnFilter: (fitViewOnFilter) => set({ fitViewOnFilter }),
+      // New sessions default to 'explore'; returning sessions get their stored mode via persist.
+      visualizationMode: NEW_SESSION_VISUALIZATION_MODE,
+      setVisualizationMode: (visualizationMode) => set({ visualizationMode, lastUsedVisualizationMode: visualizationMode }),
+      lastUsedVisualizationMode: null,
+      lastOpenBottomTab: null,
+      setLastOpenBottomTab: (lastOpenBottomTab) => set({ lastOpenBottomTab }),
+      selectedNodeId: null,
+      setSelectedNodeId: (selectedNodeId) => set({ selectedNodeId }),
+      resourcesHidden: true,
+      setResourcesHidden: (resourcesHidden) => set({ resourcesHidden, hasVisibilityInteraction: true }),
+      diagnosticsHidden: true,
+      setDiagnosticsHidden: (diagnosticsHidden) => set({ diagnosticsHidden, hasVisibilityInteraction: true }),
+      diagnosticCategories: DEFAULT_DIAGNOSTIC_CATEGORIES,
+      revealedIds: /* @__PURE__ */ new Set(),
+      setRevealedIds: (ids) => set({ revealedIds: new Set(ids) }),
+      clearRevealedIds: () => set({ revealedIds: /* @__PURE__ */ new Set() }),
+      hasVisibilityInteraction: false,
+      markVisibilityInteraction: () => set({ hasVisibilityInteraction: true }),
+      resetVisibilityInteraction: () => set({ hasVisibilityInteraction: false }),
+      expandedClusterDomains: [],
+      toggleClusterDomain: (domain) => set((s) => ({
+        expandedClusterDomains: s.expandedClusterDomains.includes(domain) ? s.expandedClusterDomains.filter((d) => d !== domain) : [...s.expandedClusterDomains, domain]
+      })),
+      setExpandedClusterDomains: (expandedClusterDomains) => set({ expandedClusterDomains }),
+      expandedNodeIdsArray: [],
+      expandedNodeIds: /* @__PURE__ */ new Set(),
+      toggleNodeExpansion: (nodeId) => set((s) => {
+        const currentSet = s.expandedNodeIds;
+        const isCurrentlyExpanded = currentSet.has(nodeId);
+        if (isCurrentlyExpanded) {
+          const next2 = new Set(currentSet);
+          next2.delete(nodeId);
+          const nextArray2 = [...next2];
+          return { expandedNodeIdsArray: nextArray2, expandedNodeIds: next2 };
+        }
+        const next = new Set(currentSet);
+        next.add(nodeId);
+        const nextArray = [...next];
+        return { expandedNodeIdsArray: nextArray, expandedNodeIds: next };
+      }),
+      clearExpandedNodes: () => set({ expandedNodeIdsArray: [], expandedNodeIds: /* @__PURE__ */ new Set() })
+    }),
+    {
+      name: "command-view-store",
+      partialize: (s) => ({
+        showIntegrations: s.showIntegrations,
+        fitViewOnFilter: s.fitViewOnFilter,
+        visualizationMode: s.visualizationMode,
+        lastUsedVisualizationMode: s.lastUsedVisualizationMode,
+        resourcesHidden: s.resourcesHidden,
+        diagnosticsHidden: s.diagnosticsHidden,
+        lastOpenBottomTab: s.lastOpenBottomTab,
+        expandedClusterDomains: s.expandedClusterDomains
+      }),
+      // Guard against stale localStorage with an invalid mode name (e.g. old 'overview' → 'explore' rename).
+      merge: (persisted, current) => {
+        const stored = persisted;
+        const storedMode = stored.visualizationMode;
+        const storedLastUsed = stored.lastUsedVisualizationMode;
+        const { expandedZonesArray: _dropped, ...restStored } = stored;
+        return {
+          ...current,
+          ...restStored,
+          visualizationMode: normalizePersistedVisualizationMode(storedMode),
+          lastUsedVisualizationMode: storedLastUsed === null || storedLastUsed === void 0 ? current.lastUsedVisualizationMode : normalizePersistedVisualizationMode(storedLastUsed)
+        };
+      }
+    }
+  )
+);
+function useSessionMessages(sessionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentSupabaseOrganizationId } = useOrganization();
+  return useQuery({
+    queryKey: sessionsKeys.messages(currentSupabaseOrganizationId, sessionId),
+    queryFn: async () => {
+      SessionIdParamSchema.parse({ sessionId });
+      const response = await apiRequest(`/sessions/${sessionId}/messages`, {
+        method: "GET"
+      });
+      const messages = response.messages.map((msg) => ({
+        ...msg,
+        createdAt: new Date(msg.createdAt)
+      }));
+      return messages;
+    },
+    enabled: isReady && !!sessionId,
+    staleTime: 0
+  });
+}
+function formatMessageEvent(event) {
+  switch (event.type) {
+    case "user_message":
+      return event.text;
+    case "assistant_message":
+      return event.text;
+    case "agent:started":
+      return "\u{1F916} Agent started reasoning";
+    case "agent:reasoning":
+      return `\u{1F4AD} Reasoning (Iteration ${event.iteration})`;
+    case "agent:tool_call":
+      return `\u{1F527} Tool: ${event.toolName}`;
+    case "agent:tool_result":
+      return event.success ? "\u2705 Tool Result" : "\u26A0\uFE0F Tool Result (Failed)";
+    case "agent:completed":
+      return "\u2705 Agent completed";
+    case "agent:error":
+      return `\u274C Agent error: ${event.error}`;
+  }
+}
+function getWsUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  const protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return `${protocol}//${url.host}`;
+}
+function useSessionWebSocket(sessionId, apiUrl) {
+  const [messages, setMessages] = useState([]);
+  const [state, setState] = useState({
+    isConnected: false,
+    isProcessing: false,
+    error: null
+  });
+  const [lastTokenUsage, setLastTokenUsage] = useState(null);
+  const wsRef = useRef(null);
+  const retryCountRef = useRef(0);
+  const reconnectTimeoutRef = useRef(null);
+  const connectionEpochRef = useRef(0);
+  const { getAccessToken } = useAuthContext();
+  const { currentWorkOSOrganizationId, currentSupabaseOrganizationId } = useOrganization();
+  const queryClient = useQueryClient();
+  const getAccessTokenRef = useRef(getAccessToken);
+  getAccessTokenRef.current = getAccessToken;
+  const currentWorkOSOrgIdRef = useRef(currentWorkOSOrganizationId);
+  currentWorkOSOrgIdRef.current = currentWorkOSOrganizationId;
+  const queryClientRef = useRef(queryClient);
+  queryClientRef.current = queryClient;
+  const currentSupabaseOrgIdRef = useRef(currentSupabaseOrganizationId);
+  currentSupabaseOrgIdRef.current = currentSupabaseOrganizationId;
+  const connect = useCallback(async () => {
+    if (!sessionId) {
+      return;
+    }
+    if (!currentWorkOSOrgIdRef.current) {
+      return;
+    }
+    if (wsRef.current?.readyState === WebSocket.OPEN || wsRef.current?.readyState === WebSocket.CONNECTING) {
+      return;
+    }
+    const epoch = connectionEpochRef.current;
+    const token = await getAccessTokenRef.current();
+    if (!token) {
+      return;
+    }
+    if (epoch !== connectionEpochRef.current) {
+      return;
+    }
+    const orgId = currentWorkOSOrgIdRef.current;
+    const wsUrl = `${getWsUrl(apiUrl)}/ws/sessions/${sessionId}?token=${token}&orgId=${orgId}`;
+    const ws = new WebSocket(wsUrl);
+    ws.onopen = () => {
+      setState((prev) => ({ ...prev, isConnected: true, error: null }));
+      retryCountRef.current = 0;
+      const supabaseOrgId = currentSupabaseOrgIdRef.current;
+      if (supabaseOrgId) {
+        queryClientRef.current.invalidateQueries({
+          queryKey: sessionsKeys.messages(supabaseOrgId, sessionId)
+        });
+      }
+    };
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type && data.type !== "turn:complete" && data.type !== "error") {
+          const liveIdentity = createLiveTempMessageIdentity();
+          const tempMessage = {
+            id: liveIdentity.id,
+            role: data.type === "user_message" ? "user" : "assistant",
+            messageType: data.type,
+            text: formatMessageEvent(data),
+            // Format based on type
+            metadata: data.type.startsWith("agent:") ? data : void 0,
+            turnNumber: 999999,
+            // High placeholder so temp messages sort to bottom
+            messageIndex: liveIdentity.messageIndex,
+            createdAt: liveIdentity.createdAt
+          };
+          setMessages((prev) => [...prev, tempMessage]);
+        } else if (data.type === "turn:complete") {
+          if (data.tokenUsage) {
+            setLastTokenUsage(data.tokenUsage);
+          }
+          setState((prev) => ({ ...prev, isProcessing: false }));
+          const supabaseOrgId = currentSupabaseOrgIdRef.current;
+          if (supabaseOrgId) {
+            queryClientRef.current.invalidateQueries({
+              queryKey: sessionsKeys.messages(supabaseOrgId, sessionId)
+            });
+            queryClientRef.current.invalidateQueries({
+              queryKey: sessionsKeys.executions(supabaseOrgId, sessionId)
+            });
+            queryClientRef.current.invalidateQueries({
+              queryKey: sessionsKeys.session(supabaseOrgId, sessionId)
+            });
+          }
+        } else if (data.type === "error") {
+          setState((prev) => ({
+            ...prev,
+            error: data.error,
+            isProcessing: false
+          }));
+        }
+      } catch (error) {
+        console.error("Failed to parse WebSocket message:", error);
+      }
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = (event) => {
+      setState((prev) => ({ ...prev, isConnected: false }));
+      if (!event.wasClean && retryCountRef.current >= WS_MAX_RETRIES_BEFORE_ERROR) {
+        setState((prev) => ({
+          ...prev,
+          error: "Unable to connect to session. Retrying..."
+        }));
+      }
+      const terminalCodes = [1003, 1008];
+      if (terminalCodes.includes(event.code) || event.code >= 4e3) {
+        setState((prev) => ({
+          ...prev,
+          error: `Connection rejected (code ${event.code})`
+        }));
+        return;
+      }
+      const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, retryCountRef.current), WS_RECONNECT_MAX_DELAY);
+      retryCountRef.current += 1;
+      reconnectTimeoutRef.current = setTimeout(() => {
+        connect();
+      }, delay);
+    };
+    wsRef.current = ws;
+  }, [sessionId, apiUrl]);
+  useEffect(() => {
+    retryCountRef.current = 0;
+    if (currentWorkOSOrgIdRef.current) {
+      connect();
+    }
+    return () => {
+      connectionEpochRef.current += 1;
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+        reconnectTimeoutRef.current = null;
+      }
+      const ws = wsRef.current;
+      if (ws) {
+        ws.onopen = null;
+        ws.onmessage = null;
+        ws.onerror = null;
+        ws.onclose = null;
+        ws.close();
+        wsRef.current = null;
+      }
+    };
+  }, [sessionId, currentWorkOSOrganizationId, connect]);
+  const sendMessage = useCallback(
+    (text, pageContext) => {
+      const trimmed = text.trim();
+      if (!trimmed) {
+        return;
+      }
+      if (!wsRef.current || state.isProcessing) {
+        return;
+      }
+      if (wsRef.current.readyState !== WebSocket.OPEN) {
+        setState((prev) => ({
+          ...prev,
+          error: "WebSocket not connected"
+        }));
+        return;
+      }
+      const liveIdentity = createLiveTempMessageIdentity();
+      const userMessage = {
+        id: liveIdentity.id,
+        role: "user",
+        messageType: "user_message",
+        text: trimmed,
+        turnNumber: 999999,
+        // High placeholder so temp messages sort to bottom
+        messageIndex: liveIdentity.messageIndex,
+        createdAt: liveIdentity.createdAt
+      };
+      setMessages((prev) => [...prev, userMessage]);
+      const input = { message: trimmed };
+      if (pageContext) {
+        input.pageContext = pageContext;
+      }
+      const message = WebSocketSessionTurnSchema.parse({
+        type: "session:turn",
+        input
+      });
+      wsRef.current.send(JSON.stringify(message));
+      setState((prev) => ({ ...prev, isProcessing: true, error: null }));
+    },
+    [state.isProcessing, sessionId]
+  );
+  const clearError = useCallback(() => {
+    setState((prev) => ({ ...prev, error: null }));
+  }, []);
+  return {
+    messages,
+    state,
+    sendMessage,
+    clearError,
+    lastTokenUsage
+  };
+}
+function useSessionExecutions(sessionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentSupabaseOrganizationId } = useOrganization();
+  return useQuery({
+    queryKey: sessionsKeys.executions(currentSupabaseOrganizationId, sessionId),
+    queryFn: async () => {
+      SessionIdParamSchema.parse({ sessionId });
+      return apiRequest(`/sessions/${sessionId}/executions`, {
+        method: "GET"
+      });
+    },
+    enabled: isReady && !!sessionId,
+    staleTime: 0
+  });
+}
+function useSessionExecution(sessionId, executionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentSupabaseOrganizationId } = useOrganization();
+  return useQuery({
+    queryKey: sessionsKeys.execution(currentSupabaseOrganizationId, sessionId, executionId),
+    queryFn: async () => {
+      ExecutionIdParamsSchema.parse({ sessionId, executionId });
+      return apiRequest(`/sessions/${sessionId}/executions/${executionId}`, {
+        method: "GET"
+      });
+    },
+    enabled: isReady && !!sessionId && !!executionId,
+    refetchInterval: (query) => {
+      const data = query.state.data;
+      const shouldRefetch = data?.status === "running";
+      return shouldRefetch ? REFETCH_INTERVAL_RUNNING : false;
+    }
+  });
+}
+
+// src/hooks/operations/command-view/useCommandViewData.ts
+function useCommandViewData() {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["command-view", workOSOrganizationId],
+    queryFn: async () => {
+      return apiRequest("/command-view");
+    },
+    enabled: isReady,
+    staleTime: STALE_TIME_DEFAULT
+  });
+}
+
+export { useCheckpointTasks, useCommandViewData, useCommandViewStats, useCommandViewStore, useResourceExecutions, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket };