@elevasis/ui 1.7.5 → 1.8.0

package/dist/{chunk-OK3XFSJJ.js → chunk-BWZMI4KP.js}

@@ -1,11 +1,20 @@
-import { getTimeRangeDates, observabilityKeys } from './chunk-6HZAMY6T.js';
+import { getTimeRangeDates, observabilityKeys } from './chunk-ARZM3OTI.js';
 import { useSupabase } from './chunk-JGJSZ3UE.js';
-import { useNotificationAdapter } from './chunk-TIRMFDM4.js';
+import { GRAPH_CONSTANTS } from './chunk-F6RBK7NJ.js';
+import { useNotificationAdapter } from './chunk-JRJW2H57.js';
+import { HTTP_HEADERS } from './chunk-JUPCUF77.js';
+import { STALE_TIME_MONITORING, REFETCH_INTERVAL_DASHBOARD, REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, STALE_TIME_DEFAULT, STALE_TIME_ADMIN } from './chunk-Z4TPHMRD.js';
 import { useStableAccessToken } from './chunk-FWZJH3TL.js';
-import { useElevasisServices } from './chunk-KA7LO7U5.js';
+import { useElevasisServices } from './chunk-GZVH423C.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { useAuthContext } from './chunk-7PLEQFHO.js';
 import { useQuery, useQueryClient, useMutation, useQueries } from '@tanstack/react-query';
 import { z } from 'zod';
-import { useCallback, useMemo, useState, useEffect, useId, useRef } from 'react';
+import { useCallback, useMemo, useState, useRef, useEffect, useId } from 'react';
+import { useNavigate, useSearch } from '@tanstack/react-router';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import dagre from '@dagrejs/dagre';
 
 function useCommandQueue({
   status,
@@ -202,7 +211,7 @@ function useExecutions(resourceId, resourceStatus, limit) {
     enabled: isReady && !!resourceId
   });
 }
-var REFETCH_INTERVAL_RUNNING = 2e3;
+var REFETCH_INTERVAL_RUNNING2 = 2e3;
 function useExecution(resourceId, executionId) {
   const { apiRequest, organizationId, isReady } = useElevasisServices();
   return useQuery({
@@ -211,7 +220,7 @@ function useExecution(resourceId, executionId) {
     enabled: isReady && !!resourceId && !!executionId,
     refetchInterval: (query) => {
       const data = query.state.data;
-      return data?.status === "running" ? REFETCH_INTERVAL_RUNNING : false;
+      return data?.status === "running" ? REFETCH_INTERVAL_RUNNING2 : false;
     }
   });
 }
@@ -323,7 +332,7 @@ var UuidSchema = z.string().uuid();
 var NonEmptyStringSchema = z.string().trim().min(1).max(1e3);
 var ResourceTypeSchema = z.enum(["agent", "workflow"]);
 var OriginResourceTypeSchema = z.enum(["agent", "workflow", "scheduler", "api"]);
-z.string().trim().toLowerCase().min(1, "Credential name required").max(100, "Credential name too long (max 100 chars)").regex(
+var CredentialNameSchema = z.string().trim().toLowerCase().min(1, "Credential name required").max(100, "Credential name too long (max 100 chars)").regex(
   /^[a-z0-9]+(-[a-z0-9]+)+$/,
   "Credential name must be lowercase letters, numbers, and hyphens in format: service-environment (e.g., gmail-prod, attio-dev)"
 );
@@ -946,6 +955,24 @@ function useBatchDelete(tableName, invalidateQueryKeys) {
     }
   });
 }
+function useTestNotification() {
+  const queryClient = useQueryClient();
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  return useMutation({
+    mutationFn: async () => {
+      await apiRequest("/notifications/test", {
+        method: "POST"
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["notifications"] });
+    },
+    onError: (error) => {
+      adapter.apiError(error);
+    }
+  });
+}
 function useErrorAnalysis(timeRange) {
   const { apiRequest, isReady, organizationId } = useElevasisServices();
   return useQuery({
@@ -1206,6 +1233,62 @@ function useBatchedResourcesHealth(params) {
   }, [queryResults]);
   return { healthLookup };
 }
+function useUnresolvedErrors({ startDate, endDate }) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.unresolvedErrors(organizationId, startDate, endDate),
+    queryFn: async () => {
+      const params = new URLSearchParams({
+        resolved: "false",
+        limit: "5",
+        page: "1",
+        startDate,
+        endDate
+      });
+      return apiRequest(`/observability/error-details?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: REFETCH_INTERVAL_DASHBOARD,
+    staleTime: STALE_TIME_MONITORING
+  });
+}
+function useRecentExecutionsByResource({ timeRange, limit }) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.recentExecutionsByResource(organizationId, timeRange, limit),
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      const params = new URLSearchParams({
+        startDate,
+        endDate,
+        ...limit !== void 0 && { limit: String(limit) }
+      });
+      return apiRequest(
+        `/observability/recent-executions-by-resource?${params.toString()}`
+      );
+    },
+    enabled: isReady,
+    refetchInterval: REFETCH_INTERVAL_DASHBOARD
+  });
+}
+function useScheduledTasks(options = {}) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["schedules", "dashboard", organizationId, options.status, options.targetResourceType],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (options.status) params.append("status", options.status);
+      if (options.targetResourceType) params.append("targetResourceType", options.targetResourceType);
+      const queryString = params.toString();
+      const response = await apiRequest(
+        `/task-scheduler/schedules${queryString ? `?${queryString}` : ""}`
+      );
+      return response.schedules;
+    },
+    enabled: isReady,
+    refetchInterval: REFETCH_INTERVAL_DASHBOARD
+  });
+}
 
 // src/hooks/scheduling/queryKeys.ts
 var scheduleKeys = {
@@ -1384,6 +1467,358 @@ function useDeleteSchedule() {
     }
   });
 }
+
+// src/hooks/sessions/queryKeys.ts
+var sessionsKeys = {
+  all: ["sessions"],
+  sessions: (org, params) => [...sessionsKeys.all, "list", org, params],
+  session: (org, sessionId) => [...sessionsKeys.all, "detail", org, sessionId],
+  executions: (org, sessionId) => [...sessionsKeys.all, org, sessionId, "executions"],
+  execution: (org, sessionId, executionId) => [...sessionsKeys.all, org, sessionId, "executions", executionId],
+  messages: (org, sessionId) => [...sessionsKeys.all, org, sessionId, "messages"]
+};
+function useSessions(params, options) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  return useQuery({
+    queryKey: sessionsKeys.sessions(organizationName || "", params),
+    queryFn: async () => {
+      const service = new OperationsService(apiRequest);
+      return service.listSessions(params);
+    },
+    enabled: isReady && (options?.enabled ?? true)
+  });
+}
+function useSession(sessionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  return useQuery({
+    queryKey: sessionsKeys.session(organizationName || "", sessionId),
+    queryFn: () => {
+      const service = new OperationsService(apiRequest);
+      return service.getSession(sessionId);
+    },
+    enabled: isReady && !!sessionId
+  });
+}
+function useCreateSession() {
+  const { apiRequest } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (resourceId) => {
+      const service = new OperationsService(apiRequest);
+      return service.createSession(resourceId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sessionsKeys.sessions(organizationName || "") });
+    }
+  });
+}
+function useDeleteSession() {
+  const { apiRequest } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (sessionId) => {
+      SessionIdParamSchema.parse({ sessionId });
+      await apiRequest(`/sessions/${sessionId}`, {
+        method: "DELETE"
+      });
+    },
+    onSuccess: (_, sessionId) => {
+      queryClient.removeQueries({
+        queryKey: sessionsKeys.session(organizationName || "", sessionId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: sessionsKeys.sessions(organizationName || "")
+      });
+    }
+  });
+}
+function useArchiveSession() {
+  const { apiRequest } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (sessionId) => {
+      const service = new OperationsService(apiRequest);
+      return service.archiveSession(sessionId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sessionsKeys.sessions(organizationName || "") });
+    }
+  });
+}
+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;
+    }
+  });
+}
+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 { 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 (!currentWorkOSOrgIdRef.current) {
+      return;
+    }
+    if (wsRef.current?.readyState === WebSocket.OPEN || wsRef.current?.readyState === WebSocket.CONNECTING) {
+      return;
+    }
+    const token = await getAccessTokenRef.current();
+    if (!token) {
+      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 tempMessage = {
+            id: `temp-${Date.now()}`,
+            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: Date.now(),
+            // Use timestamp for unique ordering
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          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 () => {
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+      }
+      if (wsRef.current) {
+        wsRef.current.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 userMessage = {
+        id: `temp-${Date.now()}`,
+        role: "user",
+        messageType: "user_message",
+        text: trimmed,
+        turnNumber: 999999,
+        // High placeholder so temp messages sort to bottom
+        messageIndex: Date.now(),
+        // Use timestamp for unique ordering
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      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 usePaginationState(pageSize, resetDeps, total) {
   const [page, setPage] = useState(1);
   useEffect(() => {
@@ -1491,12 +1926,12 @@ function useSortedData(data, defaultColumn, accessors, defaultDirection = "desc"
 }
 function createUseFeatureAccess({
   useInitialization,
-  useOrganization,
+  useOrganization: useOrganization2,
   optInFeatures = []
 }) {
   return function useFeatureAccess() {
     const { profile, organizationReady } = useInitialization();
-    const { currentMembership } = useOrganization();
+    const { currentMembership } = useOrganization2();
     const { orgConfig, membershipConfig } = useMemo(() => {
       const organizationConfig = currentMembership?.organization?.config;
       const memberConfig = currentMembership?.config;
@@ -1593,4 +2028,522 @@ function useSSEConnection({
   return { connected, error };
 }
 
-export { ExecutionIdParamsSchema, OperationsService, SessionIdParamSchema, WebSocketSessionTurnSchema, createUseFeatureAccess, executionsKeys, scheduleKeys, sortData, useActivities, useActivityTrend, useBatchDelete, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCommandQueue, useCommandQueueTotals, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteTask, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useSortedData, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useWarningNotification };
+// src/hooks/operations/shared/queryKeys.ts
+var operationsKeys = {
+  all: ["operations"],
+  // Individual resource types (kept for CC-specific features)
+  workflows: (org) => [...operationsKeys.all, "workflows", org],
+  workflowDetails: (org) => [...operationsKeys.workflows(org), "details"],
+  workflow: (id, org) => [...operationsKeys.workflows(org), id],
+  agents: (org) => [...operationsKeys.all, "agents", org],
+  agentDetails: (org) => [...operationsKeys.agents(org), "details"],
+  agent: (id, org) => [...operationsKeys.agents(org), id],
+  sessions: (org, params) => [...operationsKeys.all, "sessions", org, params],
+  session: (org, sessionId) => [...operationsKeys.all, "session", org, sessionId]
+};
+function useExecutionLogSSE(resourceId, manager) {
+  const queryClient = useQueryClient();
+  const [liveExecutions, setLiveExecutions] = useState(/* @__PURE__ */ new Set());
+  const [streamingLogs, setStreamingLogs] = useState(/* @__PURE__ */ new Map());
+  const { isReady: isOrganizationReady, organizationId } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const currentWorkOSOrganizationId = currentMembership?.organization?.id;
+  const apiUrl = import.meta.env?.VITE_API_SERVER ?? "http://localhost:5170";
+  const sseUrl = `${apiUrl}/api/execution-engine/sse/${resourceId}`;
+  const headers = useMemo(() => {
+    const h = {};
+    if (currentWorkOSOrganizationId) h[HTTP_HEADERS.WORKOS_ORGANIZATION_ID] = currentWorkOSOrganizationId;
+    return h;
+  }, [currentWorkOSOrganizationId]);
+  const handleMessage = useCallback(
+    (data) => {
+      try {
+        const event = JSON.parse(data);
+        switch (event.type) {
+          case "connected":
+            break;
+          case "new-execution":
+            if (event.executionId) {
+              setLiveExecutions((prev) => {
+                const updated = new Set(prev);
+                updated.add(event.executionId);
+                return updated;
+              });
+              queryClient.invalidateQueries({
+                queryKey: executionsKeys.executions(organizationId, resourceId)
+              });
+            }
+            break;
+          case "execution-complete":
+            if (event.executionId) {
+              setLiveExecutions((prev) => {
+                const updated = new Set(prev);
+                updated.delete(event.executionId);
+                return updated;
+              });
+              setStreamingLogs((prev) => {
+                const updated = new Map(prev);
+                updated.delete(event.executionId);
+                return updated;
+              });
+              queryClient.invalidateQueries({
+                queryKey: executionsKeys.executions(organizationId, resourceId)
+              });
+              queryClient.invalidateQueries({
+                queryKey: executionsKeys.execution(organizationId, resourceId, event.executionId)
+              });
+            }
+            break;
+          case "log":
+            if (event.executionId) {
+              if (event.data?.log) {
+                setStreamingLogs((prev) => {
+                  const updated = new Map(prev);
+                  const existing = updated.get(event.executionId) || [];
+                  updated.set(event.executionId, [...existing, event.data.log]);
+                  return updated;
+                });
+              }
+              queryClient.invalidateQueries({
+                queryKey: executionsKeys.execution(organizationId, resourceId, event.executionId)
+              });
+            }
+            break;
+        }
+      } catch {
+      }
+    },
+    [organizationId, resourceId, queryClient]
+  );
+  const { connected, error } = useSSEConnection({
+    manager,
+    connectionKey: `resource-${resourceId}`,
+    url: sseUrl,
+    enabled: !!resourceId && !!organizationId && isOrganizationReady,
+    headers,
+    onmessage: handleMessage,
+    onopen: (response) => response.status === 403 ? "Organization access denied" : void 0
+  });
+  useEffect(() => {
+    return () => {
+      setLiveExecutions(/* @__PURE__ */ new Set());
+      setStreamingLogs(/* @__PURE__ */ new Map());
+    };
+  }, [resourceId, organizationId, isOrganizationReady]);
+  return {
+    liveExecutions,
+    connected,
+    error,
+    runningCount: liveExecutions.size,
+    isLive: (executionId) => liveExecutions.has(executionId),
+    streamingLogs
+  };
+}
+function useExecutionPanelState({
+  resourceId,
+  manager,
+  limit,
+  onConnectionStatus
+}) {
+  const queryClient = useQueryClient();
+  const navigate = useNavigate();
+  const { organizationId } = useElevasisServices();
+  const [resourceStatusFilter, setResourceStatusFilter] = useState("all");
+  const { data: executionsData, isLoading, isFetched } = useExecutions(resourceId, resourceStatusFilter, limit);
+  const { liveExecutions, connected, runningCount, streamingLogs } = useExecutionLogSSE(resourceId, manager);
+  const search = useSearch({ strict: false });
+  const selectedId = search.exec;
+  const setSelectedId = useCallback(
+    (id) => {
+      void navigate({
+        to: ".",
+        search: { exec: id },
+        replace: true
+      });
+    },
+    [navigate]
+  );
+  const executions = executionsData?.executions || [];
+  const prevExecutionCountRef = useRef(0);
+  const prevNewestIdRef = useRef(void 0);
+  const prevResourceIdRef = useRef(resourceId);
+  const hasInitializedRef = useRef(false);
+  useEffect(() => {
+    if (prevResourceIdRef.current !== resourceId) {
+      setSelectedId(void 0);
+      prevResourceIdRef.current = resourceId;
+      hasInitializedRef.current = false;
+    }
+  }, [resourceId, setSelectedId]);
+  useEffect(() => {
+    if (organizationId) {
+      queryClient.invalidateQueries({
+        queryKey: [...executionsKeys.all, "execution"]
+      });
+    }
+  }, [resourceId, queryClient, organizationId]);
+  useEffect(() => {
+    const sortedExecutions = [...executions].sort((a, b) => b.startTime - a.startTime);
+    const newestExecution = sortedExecutions[0];
+    if (!newestExecution) return;
+    if (!hasInitializedRef.current) {
+      hasInitializedRef.current = true;
+      prevExecutionCountRef.current = executions.length;
+      prevNewestIdRef.current = newestExecution.id;
+      return;
+    }
+    const executionCountIncreased = executions.length > prevExecutionCountRef.current;
+    const newestIdChanged = newestExecution.id !== prevNewestIdRef.current;
+    if (executionCountIncreased && newestIdChanged && newestExecution.id !== selectedId) {
+      setSelectedId(newestExecution.id);
+    }
+    prevExecutionCountRef.current = executions.length;
+    prevNewestIdRef.current = newestExecution.id;
+  }, [executions, selectedId, setSelectedId]);
+  useEffect(() => {
+    if (!isFetched) return;
+    if (executions.length === 0) {
+      setSelectedId(void 0);
+    } else if (!selectedId && executions.length > 0) {
+      const latest = [...executions].sort((a, b) => b.startTime - a.startTime)[0];
+      setSelectedId(latest.id);
+    }
+  }, [executions, selectedId, setSelectedId, isFetched]);
+  useEffect(() => {
+    if (onConnectionStatus) {
+      onConnectionStatus(connected, runningCount);
+    }
+  }, [connected, runningCount, onConnectionStatus]);
+  return {
+    executions,
+    isLoading,
+    isFetched,
+    selectedId,
+    setSelectedId,
+    resourceStatusFilter,
+    setResourceStatusFilter,
+    liveExecutions,
+    connected,
+    runningCount,
+    streamingLogs
+  };
+}
+
+// src/hooks/operations/shared/resourceDefinitionUtils.ts
+function isSessionCapable(type, resourceDefinition) {
+  if (type !== "agent" || !resourceDefinition) {
+    return false;
+  }
+  const config = resourceDefinition.config;
+  return config.sessionCapable === true;
+}
+function useDeploymentDocs(selectedDeploymentId) {
+  const { apiRequest, isReady: isOrganizationReady, organizationId } = useElevasisServices();
+  const deploymentsQuery = useQuery({
+    queryKey: ["deployments", organizationId],
+    queryFn: async () => {
+      const response = await apiRequest("/deployments");
+      return response.deployments;
+    },
+    enabled: isOrganizationReady,
+    staleTime: STALE_TIME_DEFAULT
+  });
+  const activeDeployments = useMemo(() => {
+    if (!deploymentsQuery.data) return [];
+    return deploymentsQuery.data.filter((d) => d.status === "active").sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+  }, [deploymentsQuery.data]);
+  const activeDeployment = useMemo(() => {
+    if (selectedDeploymentId) {
+      return activeDeployments.find((d) => d.id === selectedDeploymentId) ?? activeDeployments[0] ?? null;
+    }
+    return activeDeployments[0] ?? null;
+  }, [activeDeployments, selectedDeploymentId]);
+  const deploymentId = activeDeployment?.id;
+  const docsQuery = useQuery({
+    queryKey: ["deployment-docs", deploymentId],
+    queryFn: async () => {
+      const response = await apiRequest(`/deployments/${deploymentId}/docs`);
+      return response.files;
+    },
+    enabled: isOrganizationReady && !!deploymentId,
+    staleTime: STALE_TIME_DEFAULT
+  });
+  return {
+    files: docsQuery.data ?? [],
+    isLoading: deploymentsQuery.isLoading || !!deploymentId && docsQuery.isLoading,
+    error: deploymentsQuery.error || docsQuery.error,
+    activeDeployment,
+    activeDeployments
+  };
+}
+function useCommandViewData() {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["command-view", organizationId],
+    queryFn: async () => {
+      return apiRequest("/command-view");
+    },
+    enabled: isReady,
+    staleTime: STALE_TIME_DEFAULT
+  });
+}
+function useCommandViewStats(timeRange = "24h") {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["command-view-stats", organizationId, timeRange],
+    queryFn: async () => {
+      return apiRequest(`/command-view/stats?timeRange=${timeRange}`);
+    },
+    enabled: isReady,
+    staleTime: STALE_TIME_MONITORING
+  });
+}
+var useCommandViewStore = create()(
+  persist(
+    (set) => ({
+      statusFilter: "all",
+      setStatusFilter: (statusFilter) => set({ statusFilter }),
+      showIntegrations: true,
+      setShowIntegrations: (showIntegrations) => set({ showIntegrations }),
+      fitViewOnFilter: true,
+      setFitViewOnFilter: (fitViewOnFilter) => set({ fitViewOnFilter }),
+      selectedNodeId: null,
+      setSelectedNodeId: (selectedNodeId) => set({ selectedNodeId })
+    }),
+    {
+      name: "command-view-store",
+      partialize: (s) => ({
+        showIntegrations: s.showIntegrations,
+        fitViewOnFilter: s.fitViewOnFilter
+      })
+    }
+  )
+);
+function useCommandViewLayout(graph) {
+  return useMemo(() => {
+    const dagreGraph = new dagre.graphlib.Graph();
+    dagreGraph.setDefaultEdgeLabel(() => ({}));
+    dagreGraph.setGraph({
+      rankdir: "LR",
+      ranksep: GRAPH_CONSTANTS.RANK_SEP,
+      nodesep: GRAPH_CONSTANTS.NODE_SEP,
+      marginx: 50,
+      marginy: 50,
+      ranker: "longest-path"
+    });
+    graph.nodes.forEach((node) => {
+      dagreGraph.setNode(node.id, {
+        width: GRAPH_CONSTANTS.NODE_WIDTH,
+        height: GRAPH_CONSTANTS.NODE_HEIGHT
+      });
+    });
+    graph.edges.forEach((edge) => {
+      dagreGraph.setEdge(edge.source, edge.target);
+    });
+    dagre.layout(dagreGraph);
+    const nodePositions = /* @__PURE__ */ new Map();
+    const nodeNames = /* @__PURE__ */ new Map();
+    graph.nodes.forEach((node) => {
+      const dagreNode = dagreGraph.node(node.id);
+      nodePositions.set(node.id, { x: dagreNode.x, y: dagreNode.y });
+      nodeNames.set(node.id, node.name);
+    });
+    const parent = /* @__PURE__ */ new Map();
+    graph.nodes.forEach((node) => parent.set(node.id, node.id));
+    const find = (id) => {
+      if (parent.get(id) !== id) {
+        parent.set(id, find(parent.get(id)));
+      }
+      return parent.get(id);
+    };
+    const union = (a, b) => {
+      const rootA = find(a);
+      const rootB = find(b);
+      if (rootA !== rootB) {
+        parent.set(rootA, rootB);
+      }
+    };
+    graph.edges.forEach((edge) => {
+      if (edge.relationship === "triggers" || edge.relationship === "approval") {
+        union(edge.source, edge.target);
+      }
+    });
+    const components = /* @__PURE__ */ new Map();
+    graph.nodes.forEach((node) => {
+      const root = find(node.id);
+      const existing = components.get(root) || [];
+      existing.push(node.id);
+      components.set(root, existing);
+    });
+    const getMinPrefix = (nodeIds) => {
+      let minPrefix = "";
+      for (const id of nodeIds) {
+        const name = nodeNames.get(id) || "";
+        const prefix = name.match(/^([A-Z]+-\d+)/)?.[1];
+        if (prefix && (!minPrefix || prefix.localeCompare(minPrefix) < 0)) {
+          minPrefix = prefix;
+        }
+      }
+      return minPrefix || nodeNames.get(nodeIds[0]) || "";
+    };
+    const sortedComponents = Array.from(components.values()).sort((a, b) => {
+      return getMinPrefix(a).localeCompare(getMinPrefix(b));
+    });
+    const chains = sortedComponents.filter((c) => c.length > 1);
+    const orphans = sortedComponents.filter((c) => c.length === 1);
+    const componentYOffsets = /* @__PURE__ */ new Map();
+    let currentY = 0;
+    for (const nodeIds of chains) {
+      let minY = Infinity;
+      let maxY = -Infinity;
+      for (const id of nodeIds) {
+        const pos = nodePositions.get(id);
+        minY = Math.min(minY, pos.y);
+        maxY = Math.max(maxY, pos.y);
+      }
+      const offset = currentY - minY + 50;
+      for (const id of nodeIds) {
+        componentYOffsets.set(id, offset);
+      }
+      currentY = currentY + (maxY - minY) + GRAPH_CONSTANTS.NODE_HEIGHT + 80;
+    }
+    if (orphans.length > 0) {
+      const longestChainDepth = chains.length > 0 ? Math.max(
+        ...chains.map((chain) => {
+          const xValues = new Set(chain.map((id) => Math.round(nodePositions.get(id).x)));
+          return xValues.size;
+        })
+      ) : 0;
+      const ORPHAN_COLS = Math.max(5, longestChainDepth + Math.floor(longestChainDepth / 4));
+      const cellW = GRAPH_CONSTANTS.NODE_WIDTH + GRAPH_CONSTANTS.NODE_SEP;
+      const cellH = GRAPH_CONSTANTS.NODE_HEIGHT + GRAPH_CONSTANTS.NODE_SEP;
+      const gridStartY = currentY + 50;
+      orphans.forEach((nodeIds, i) => {
+        const id = nodeIds[0];
+        const col = i % ORPHAN_COLS;
+        const row = Math.floor(i / ORPHAN_COLS);
+        nodePositions.set(id, {
+          x: col * cellW + GRAPH_CONSTANTS.NODE_WIDTH / 2,
+          y: gridStartY + row * cellH + GRAPH_CONSTANTS.NODE_HEIGHT / 2
+        });
+        componentYOffsets.set(id, 0);
+      });
+    }
+    const nodes = graph.nodes.map((node) => {
+      const pos = nodePositions.get(node.id);
+      const yOffset = componentYOffsets.get(node.id) || 0;
+      return {
+        id: node.id,
+        type: "commandView",
+        position: {
+          x: pos.x - GRAPH_CONSTANTS.NODE_WIDTH / 2,
+          y: pos.y + yOffset - GRAPH_CONSTANTS.NODE_HEIGHT / 2
+        },
+        data: node
+      };
+    });
+    const edgesBySource = /* @__PURE__ */ new Map();
+    graph.edges.forEach((edge) => {
+      const existing = edgesBySource.get(edge.source) || [];
+      existing.push(edge);
+      edgesBySource.set(edge.source, existing);
+    });
+    const edges = graph.edges.map((edge) => {
+      const sourceEdges = edgesBySource.get(edge.source) || [];
+      const edgeIndex = sourceEdges.indexOf(edge);
+      const totalEdges = sourceEdges.length;
+      return {
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+        type: "commandView",
+        data: {
+          relationship: edge.relationship,
+          label: edge.label,
+          edgeIndex,
+          totalEdges
+        }
+      };
+    });
+    return { nodes, edges };
+  }, [graph]);
+}
+function useGraphStats(graph) {
+  return useMemo(() => {
+    const stats = {
+      agents: 0,
+      workflows: 0,
+      integrations: 0,
+      triggers: 0,
+      prodResources: 0,
+      devResources: 0,
+      connectedIntegrations: 0,
+      errorIntegrations: 0
+    };
+    for (const node of graph.nodes) {
+      switch (node.type) {
+        case "agent":
+          stats.agents++;
+          break;
+        case "workflow":
+          stats.workflows++;
+          break;
+        case "integration":
+          stats.integrations++;
+          if (node.connectionStatus === "connected") stats.connectedIntegrations++;
+          if (node.connectionStatus === "error") stats.errorIntegrations++;
+          break;
+        case "trigger":
+          stats.triggers++;
+          break;
+      }
+      if (node.status === "prod") stats.prodResources++;
+      if (node.status === "dev") stats.devResources++;
+    }
+    return stats;
+  }, [graph]);
+}
+function useCheckpointTasks({ checkpointId, enabled = true }) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["checkpoint-tasks", organizationId, 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 useResourceErrors({ resourceId, timeRange, hasFailures }) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["resource-errors", organizationId, resourceId, timeRange],
+    queryFn: async () => {
+      return apiRequest(
+        `/command-view/resource-errors?resourceId=${resourceId}&timeRange=${timeRange}`
+      );
+    },
+    // Only fetch when: org ready, resource selected, and resource has failures
+    enabled: isReady && !!resourceId && hasFailures,
+    staleTime: STALE_TIME_ADMIN
+  });
+}
+function useResourceExecutions({ resourceId, timeRange, enabled = true }) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["resource-executions", organizationId, resourceId, timeRange],
+    queryFn: async () => {
+      return apiRequest(
+        `/command-view/resource-executions?resourceId=${resourceId}&timeRange=${timeRange}`
+      );
+    },
+    // Only fetch when: org ready, resource selected, and enabled
+    enabled: isReady && !!resourceId && enabled,
+    staleTime: STALE_TIME_MONITORING
+  });
+}
+
+export { CredentialNameSchema, OperationsService, UuidSchema, createUseFeatureAccess, executionsKeys, isSessionCapable, operationsKeys, scheduleKeys, sessionsKeys, sortData, useActivities, useActivityTrend, useArchiveSession, useBatchDelete, useBatchedResourcesHealth, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCheckpointTasks, useCommandQueue, useCommandQueueTotals, useCommandViewData, useCommandViewLayout, useCommandViewStats, useCommandViewStore, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useCreateSession, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useDeleteSession, useDeleteTask, useDeploymentDocs, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogSSE, useExecutionLogs, useExecutionPanelState, useExecutions, useGetExecutionHistory, useGetSchedule, useGraphStats, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePatchTask, usePauseSchedule, useRecentExecutionsByResource, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResourceErrors, useResourceExecutions, useResources, useResourcesHealth, useResumeSchedule, useRetryExecution, useSSEConnection, useScheduledTasks, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions, useSortedData, useSubmitAction, useSuccessNotification, useTableSelection, useTableSort, useTestNotification, useTopFailingResources, useUnresolveError, useUnresolvedErrors, useUpdateAnchor, useUpdateSchedule, useWarningNotification };