@elevasis/ui 2.72.0 → 2.74.0

package/dist/chunk-FA7LMNQO.js

@@ -0,0 +1,439 @@
+import { createLiveTempMessageIdentity } from './chunk-QFGNRKIE.js';
+import { sessionsKeys } from './chunk-6JN2TLV2.js';
+import { SessionIdParamSchema, WebSocketSessionTurnSchema, ExecutionIdParamsSchema } from './chunk-2GIJBHZT.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { STALE_TIME_MONITORING, STALE_TIME_DEFAULT } from './chunk-R5UGIFYU.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 };

package/dist/chunk-FZSG6M6W.js

@@ -0,0 +1,45 @@
+import { dealKeys } from './chunk-6JN2TLV2.js';
+import { showApiErrorNotification } from './chunk-HYQOGRWG.js';
+import { APIClientError } from './chunk-R5UGIFYU.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+
+function useDealDetail(acqDealId) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["deal-detail", workOSOrganizationId, acqDealId],
+    queryFn: async () => {
+      if (!acqDealId) return null;
+      try {
+        return await apiRequest(`/deals/${acqDealId}`);
+      } catch (err) {
+        if (err instanceof APIClientError && err.statusCode === 404) return null;
+        throw err;
+      }
+    },
+    enabled: isReady && !!acqDealId
+  });
+}
+function useExecuteAction({ dealId }) {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ key, payload }) => {
+      await apiRequest(`/deals/${dealId}/actions/${encodeURIComponent(key)}`, {
+        method: "POST",
+        body: JSON.stringify({ payload })
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: dealKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: dealKeys.summaries() });
+      queryClient.invalidateQueries({ queryKey: ["deal-detail", workOSOrganizationId, dealId] });
+    },
+    onError: (error) => {
+      queryClient.invalidateQueries({ queryKey: dealKeys.all });
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+export { useDealDetail, useExecuteAction };

package/dist/chunk-GDOR57D7.js

@@ -0,0 +1,165 @@
+import { deriveActions } from './chunk-ZYNVCWDZ.js';
+import { acquisitionListKeys } from './chunk-6JN2TLV2.js';
+import { showApiErrorNotification, showSuccessNotification } from './chunk-HYQOGRWG.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+var leadGenArtifactKeys = {
+  all: ["lead-gen-artifacts"],
+  // ownerId is nullable/undefined here to match CreateArtifactRequest -- an
+  // 'organization'-owned artifact has no single owning entity row. See
+  // CreateArtifactRequestSchema (business/acquisition/api-schemas.ts).
+  list: (organizationId, ownerKind, ownerId) => [...leadGenArtifactKeys.all, organizationId, ownerKind, ownerId]
+};
+function useArtifacts({ ownerKind, ownerId }) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: leadGenArtifactKeys.list(workOSOrganizationId, ownerKind, ownerId),
+    queryFn: () => apiRequest(
+      `/acquisition/artifacts?ownerKind=${encodeURIComponent(ownerKind)}&ownerId=${encodeURIComponent(ownerId)}`
+    ),
+    enabled: isReady && !!ownerId
+  });
+}
+function useCreateArtifact() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body) => apiRequest("/acquisition/artifacts", {
+      method: "POST",
+      body: JSON.stringify(body)
+    }),
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: leadGenArtifactKeys.list(workOSOrganizationId, variables.ownerKind, variables.ownerId)
+      });
+      showSuccessNotification("Artifact created");
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+var leadGenListMemberKeys = {
+  all: ["lead-gen-list-members"],
+  list: (organizationId, listId) => [...leadGenListMemberKeys.all, organizationId, "list", listId],
+  detail: (organizationId, memberId) => [...leadGenListMemberKeys.all, organizationId, "detail", memberId]
+};
+function useListMembers({ listId }) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: leadGenListMemberKeys.list(workOSOrganizationId, listId),
+    queryFn: () => apiRequest(`/acquisition/lists/${listId}/members`),
+    enabled: isReady && !!listId
+  });
+}
+function useListMember(memberId) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: leadGenListMemberKeys.detail(workOSOrganizationId, memberId),
+    queryFn: () => apiRequest(`/acquisition/list-members/${memberId}`),
+    enabled: isReady && !!memberId
+  });
+}
+function useTransitionListMember() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input) => {
+      const { memberId, pipelineKey, stageKey, stateKey, reason, expectedUpdatedAt } = input;
+      await apiRequest(`/acquisition/list-members/${memberId}/transition`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          pipelineKey,
+          stageKey,
+          ...stateKey !== void 0 ? { stateKey } : {},
+          ...reason !== void 0 ? { reason } : {},
+          ...expectedUpdatedAt !== void 0 ? { expectedUpdatedAt } : {}
+        })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: leadGenListMemberKeys.detail(workOSOrganizationId, variables.memberId)
+      });
+      if (variables.listId) {
+        queryClient.invalidateQueries({ queryKey: leadGenListMemberKeys.list(workOSOrganizationId, variables.listId) });
+      }
+    },
+    onError: (error) => {
+      queryClient.invalidateQueries({ queryKey: leadGenListMemberKeys.all });
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useDeriveActions(item) {
+  return useMemo(() => {
+    if (!item) return [];
+    if (item.pipeline_key !== "lead-gen") {
+      return deriveActions(item);
+    }
+    return [];
+  }, [item]);
+}
+function useUpdateListStatus() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input) => {
+      await apiRequest(`/acquisition/lists/${input.listId}/status`, {
+        method: "PATCH",
+        body: JSON.stringify({ status: input.status })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.list(workOSOrganizationId) });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.detail(workOSOrganizationId, variables.listId) });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.telemetry(workOSOrganizationId) });
+    },
+    onError: (error) => {
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.all });
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+// src/hooks/lead-gen/useTransitionListCompany.ts
+var leadGenListCompanyKeys = {
+  all: ["lead-gen-list-companies"],
+  detail: (organizationId, listCompanyId) => [...leadGenListCompanyKeys.all, organizationId, "detail", listCompanyId]
+};
+function useTransitionListCompany() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input) => {
+      const { listCompanyId, pipelineKey, stageKey, stateKey, reason, expectedUpdatedAt } = input;
+      await apiRequest(`/acquisition/list-companies/${listCompanyId}/transition`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          pipelineKey,
+          stageKey,
+          ...stateKey !== void 0 ? { stateKey } : {},
+          ...reason !== void 0 ? { reason } : {},
+          ...expectedUpdatedAt !== void 0 ? { expectedUpdatedAt } : {}
+        })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: leadGenListCompanyKeys.detail(workOSOrganizationId, variables.listCompanyId)
+      });
+      if (variables.listId) {
+        queryClient.invalidateQueries({ queryKey: acquisitionListKeys.telemetry(workOSOrganizationId) });
+        queryClient.invalidateQueries({ queryKey: acquisitionListKeys.detail(workOSOrganizationId, variables.listId) });
+      }
+    },
+    onError: (error) => {
+      queryClient.invalidateQueries({ queryKey: leadGenListCompanyKeys.all });
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+export { leadGenArtifactKeys, leadGenListCompanyKeys, leadGenListMemberKeys, useArtifacts, useCreateArtifact, useDeriveActions, useListMember, useListMembers, useTransitionListCompany, useTransitionListMember, useUpdateListStatus };

package/dist/{chunk-RRS2QR3W.js → chunk-GO4XJ5D4.js}

@@ -1,4 +1,4 @@
-import { NavigationButton, useAppearance, useElevasisSystems } from './chunk-KIDZXZM5.js';
+import { NavigationButton, useAppearance, useElevasisSystems } from './chunk-6JN2TLV2.js';
 import { sidebarItemGap, sidebarSubLinkPaddingY, sidebarSubLinkPaddingX, sidebarSubLinkIndent, sidebarHoverDelay, sidebarTransitionDuration, sidebarCollapsedWidth, sidebarWidth, topbarHeight, sidebarToggleIconSize, sidebarSectionPadding, sidebarGroupChevronSize, sidebarIconInnerSize, SubshellNavItem } from './chunk-MISHPEJX.js';
 import { useRouterContext } from './chunk-Q7DJKLEN.js';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';