@elevasis/ui 1.0.0

package/dist/api/index.d.ts

@@ -0,0 +1,87 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * API module types
+ */
+interface ApiClientContextValue {
+    getAccessToken: () => Promise<string | undefined>;
+    organizationId: string | null;
+    isOrganizationReady: boolean;
+    onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
+}
+interface ApiErrorDetails {
+    method: string;
+    statusCode: number;
+    requestId?: string;
+}
+interface ApiClientProviderProps {
+    children: React.ReactNode;
+    getAccessToken: () => Promise<string | undefined>;
+    organizationId: string | null;
+    isOrganizationReady: boolean;
+    onError?: (endpoint: string, error: Error, details?: ApiErrorDetails) => void;
+}
+
+/**
+ * Hook to access the API client context
+ * Must be used within an ApiClientProvider
+ */
+declare function useApiClientContext(): ApiClientContextValue;
+/**
+ * Provider component that configures the API client context
+ *
+ * Configure this at your app root with auth and organization dependencies.
+ * All components using useApiClient will automatically get the configured values.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { getAccessToken } = useAuth()
+ *   const { currentWorkOSOrganizationId, currentMembership } = useOrganizations()
+ *
+ *   return (
+ *     <ApiClientProvider
+ *       getAccessToken={getAccessToken}
+ *       organizationId={currentWorkOSOrganizationId}
+ *       isOrganizationReady={!!currentMembership}
+ *       onError={(endpoint, error, details) => logError(endpoint, error, details)}
+ *     >
+ *       <YourApp />
+ *     </ApiClientProvider>
+ *   )
+ * }
+ * ```
+ */
+declare function ApiClientProvider({ children, getAccessToken, organizationId, isOrganizationReady, onError }: ApiClientProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Return type of useOrganizations hook (subset needed by useApiClient)
+ */
+interface UseOrganizationsReturn {
+    isInitializing: boolean;
+    isOrgRefreshing: boolean;
+}
+/**
+ * Factory function to create a useApiClient hook for your app.
+ *
+ * This pattern allows the shared package to provide the hook logic
+ * while each app provides its own useOrganizations hook and API URL.
+ *
+ * Usage in app:
+ * ```typescript
+ * import { createUseApiClient } from '@repo/ui/api'
+ * import { useOrganizations } from './organization/hooks/useOrganizations'
+ *
+ * const API_URL = import.meta.env.VITE_API_SERVER || 'http://localhost:5170'
+ * export const useApiClient = createUseApiClient(useOrganizations, API_URL)
+ * ```
+ */
+declare function createUseApiClient(useOrganizations: () => UseOrganizationsReturn, apiUrl: string): () => {
+    apiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    deferredApiRequest: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+    isOrganizationReady: boolean;
+    isInitializing: boolean;
+};
+
+export { ApiClientProvider, createUseApiClient, useApiClientContext };
+export type { ApiClientContextValue, ApiClientProviderProps, ApiErrorDetails };

package/dist/api/index.js

@@ -0,0 +1,3 @@
+import '../chunk-XCYKC6OZ.js';
+export { ApiClientProvider, createUseApiClient, useApiClientContext } from '../chunk-GDV44UWF.js';
+import '../chunk-7AI5ZYJ4.js';

package/dist/auth/context.d.ts

@@ -0,0 +1,19 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+interface AuthAdapter {
+    user: {
+        id: string;
+    } | null;
+    isLoading: boolean;
+    getAccessToken: () => Promise<string>;
+    organizationId?: string | null;
+}
+declare function useAuthContext(): AuthAdapter;
+declare function AuthProvider({ value, children }: {
+    value: AuthAdapter;
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<AuthAdapter | null>>;
+
+export { AuthProvider, useAuthContext };
+export type { AuthAdapter };

package/dist/auth/context.js

@@ -0,0 +1 @@
+export { AuthProvider, useAuthContext } from '../chunk-7PLEQFHO.js';

package/dist/auth/index.d.ts

@@ -0,0 +1,85 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+interface AuthAdapter {
+    user: {
+        id: string;
+    } | null;
+    isLoading: boolean;
+    getAccessToken: () => Promise<string>;
+    organizationId?: string | null;
+}
+declare function useAuthContext(): AuthAdapter;
+declare function AuthProvider({ value, children }: {
+    value: AuthAdapter;
+    children: ReactNode;
+}): react.FunctionComponentElement<react.ProviderProps<AuthAdapter | null>>;
+
+/**
+ * Bridge component that reads WorkOS AuthKit state and provides it
+ * via the generic AuthContext. Place inside AuthKitProvider.
+ *
+ * Narrows WorkOS User to { id: string } -- @repo/ui hooks only need the ID.
+ * Uses useMemo to stabilize the user object and prevent unnecessary
+ * useEffect re-runs in downstream hooks.
+ */
+declare function WorkOSAuthBridge({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Bridge component that reads OAuth state and provides it
+ * via the generic AuthContext. Place inside OAuthProvider.
+ *
+ * Mirrors WorkOSAuthBridge structure -- maps OAuthContextValue to AuthAdapter.
+ */
+declare function OAuthAuthBridge({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Returns a stable reference to getAccessToken that won't change between renders
+ *
+ * This prevents SSE connections from reconnecting unnecessarily when the
+ * WorkOS useAuth hook returns a new getAccessToken function reference
+ *
+ * @example
+ * ```tsx
+ * const getAccessToken = useStableAccessToken()
+ *
+ * useEffect(() => {
+ *   fetchEventSourceWithTokenRefresh({
+ *     getToken: getAccessToken,
+ *     // ...
+ *   })
+ * }, [getAccessToken]) // Won't re-run on every render
+ * ```
+ */
+declare function useStableAccessToken(): () => Promise<string>;
+
+/**
+ * Checks WorkOS session validity when window/tab regains focus
+ *
+ * When window or tab becomes visible after inactivity, validates session
+ * by attempting to get access token. If session expired (WorkOS inactivity
+ * timeout exceeded), signs out user and redirects to login.
+ *
+ * How it works:
+ * 1. Window/tab regains focus after inactivity
+ * 2. Cancel all pending queries to prevent 401 error cascade
+ * 3. Attempt to get access token from WorkOS
+ * 4. If successful: Resume queries with fresh token
+ * 5. If failed (session expired): Sign out and redirect to login
+ *
+ * @example
+ * // In __root.tsx
+ * export function RootLayoutComponent() {
+ *   useSessionCheck()
+ *   return <YourApp />
+ * }
+ */
+declare function useSessionCheck(): void;
+
+export { AuthProvider, OAuthAuthBridge, WorkOSAuthBridge, useAuthContext, useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken };
+export type { AuthAdapter };

package/dist/auth/index.js

@@ -0,0 +1,3 @@
+export { useSessionCheck as useRefocusSessionCheck, useSessionCheck, useStableAccessToken } from '../chunk-HBRMWW6V.js';
+export { OAuthAuthBridge, WorkOSAuthBridge } from '../chunk-OEYU5O27.js';
+export { AuthProvider, useAuthContext } from '../chunk-7PLEQFHO.js';

package/dist/chunk-3KMDHCAR.js

@@ -0,0 +1,52 @@
+import { Text, Box, Code, Title } from '@mantine/core';
+import Markdown from 'react-markdown';
+import { Prism } from 'react-syntax-highlighter';
+import { oneDark } from 'react-syntax-highlighter/dist/esm/styles/prism';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+// src/components/display/StyledMarkdown.tsx
+var customCodeTheme = Object.fromEntries(
+  Object.entries(oneDark).map(([key, value]) => [
+    key,
+    typeof value === "object" && value !== null ? { ...value, background: "none", backgroundColor: "none" } : value
+  ])
+);
+var defaultComponents = {
+  h1: ({ children }) => /* @__PURE__ */ jsx(Title, { order: 3, c: "var(--color-primary)", mb: "xs", mt: "md", children }),
+  h2: ({ children }) => /* @__PURE__ */ jsx(Title, { order: 4, c: "var(--color-primary)", mb: "xs", mt: "sm", children }),
+  ul: ({ children }) => /* @__PURE__ */ jsx("ul", { style: { margin: "0.5rem 0", paddingLeft: "1.5rem" }, children }),
+  ol: ({ children }) => /* @__PURE__ */ jsx("ol", { style: { margin: "0.5rem 0", paddingLeft: "1.5rem" }, children }),
+  li: ({ children }) => /* @__PURE__ */ jsx("li", { style: { marginBottom: "0.25rem", fontSize: "var(--mantine-font-size-sm)" }, children }),
+  code: ({ className, children, ...props }) => {
+    const match = /language-(\w+)/.exec(className || "");
+    const codeString = String(children).replace(/\n$/, "");
+    if (match) {
+      return /* @__PURE__ */ jsx(
+        Prism,
+        {
+          style: customCodeTheme,
+          language: match[1],
+          PreTag: "div",
+          customStyle: {
+            margin: "0.5rem 0",
+            borderRadius: "var(--mantine-radius-default)",
+            fontSize: "0.8rem"
+          },
+          children: codeString
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(Code, { ...props, children });
+  },
+  pre: ({ children }) => /* @__PURE__ */ jsx(Fragment, { children }),
+  blockquote: ({ children }) => /* @__PURE__ */ jsx(Box, { pl: "sm", my: "xs", style: { borderLeft: "2px solid var(--color-border)" }, children }),
+  p: ({ children }) => /* @__PURE__ */ jsx(Text, { size: "sm", m: 0, children }),
+  strong: ({ children }) => /* @__PURE__ */ jsx(Text, { component: "span", fw: 700, children }),
+  em: ({ children }) => /* @__PURE__ */ jsx(Text, { component: "span", fs: "italic", children })
+};
+function StyledMarkdown({ children, components, className, style }) {
+  const mergedComponents = components ? { ...defaultComponents, ...components } : defaultComponents;
+  return /* @__PURE__ */ jsx("div", { className, style, children: /* @__PURE__ */ jsx(Markdown, { components: mergedComponents, children }) });
+}
+
+export { StyledMarkdown };

package/dist/chunk-5UWFGBFM.js

@@ -0,0 +1,129 @@
+import { useElevasisServices } from './chunk-KA7LO7U5.js';
+import { useAuthContext } from './chunk-7PLEQFHO.js';
+import { useState, useEffect } from 'react';
+
+// src/profile/services/UserProfileService.ts
+var UserProfileService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * Sync WorkOS user data to Supabase users table
+   * This creates or updates the user profile with latest WorkOS data
+   */
+  async syncUserProfile() {
+    try {
+      const profile = await this.apiRequest("/users/me/sync", {
+        method: "POST"
+      });
+      return profile;
+    } catch (error) {
+      console.error("User profile sync error:", error);
+      return null;
+    }
+  }
+  /**
+   * Get user profile from API
+   * Server identifies user from JWT (no user ID needed)
+   */
+  async getUserProfile() {
+    try {
+      const profile = await this.apiRequest("/users/me");
+      return profile;
+    } catch (error) {
+      console.error("Get user profile error:", error);
+      return null;
+    }
+  }
+  /**
+   * Update last visited organization for the user
+   * @param organizationId - The Supabase organization ID
+   */
+  async updateLastVisitedOrg(organizationId) {
+    try {
+      await this.apiRequest("/users/me", {
+        method: "PATCH",
+        body: JSON.stringify({ lastVisitedOrg: organizationId })
+      });
+    } catch (error) {
+      console.error("Update last visited org error:", error);
+    }
+  }
+  /**
+   * Update user profile data
+   */
+  async updateUserProfile(updates) {
+    try {
+      const profile = await this.apiRequest("/users/me", {
+        method: "PATCH",
+        body: JSON.stringify(updates)
+      });
+      return profile;
+    } catch (error) {
+      console.error("Update user profile error:", error);
+      return null;
+    }
+  }
+};
+
+// src/profile/hooks/useUserProfile.ts
+var useUserProfile = (options) => {
+  const { user, isLoading: authLoading } = useAuthContext();
+  const { apiRequest } = useElevasisServices();
+  const [profile, setProfile] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const syncAndFetchProfile = async () => {
+    if (!user || authLoading) {
+      return;
+    }
+    try {
+      setLoading(true);
+      setError(null);
+      const profileService = new UserProfileService(apiRequest);
+      const syncedProfile = await profileService.syncUserProfile();
+      if (syncedProfile) {
+        setProfile(syncedProfile);
+      } else {
+        console.warn("Failed to sync user profile");
+      }
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      if (options?.onError) {
+        options.onError(
+          {
+            phase: "profile-sync",
+            userId: user?.id
+          },
+          error2
+        );
+      }
+      setError(error2);
+      console.error("User profile sync failed:", error2);
+    } finally {
+      setLoading(false);
+    }
+  };
+  useEffect(() => {
+    if (!authLoading) {
+      if (user) {
+        syncAndFetchProfile();
+      } else {
+        setProfile(null);
+        setLoading(false);
+        setError(null);
+      }
+    }
+  }, [user, authLoading]);
+  const refetch = async () => {
+    await syncAndFetchProfile();
+  };
+  return {
+    profile,
+    loading: loading || authLoading,
+    error,
+    refetch
+  };
+};
+
+export { UserProfileService, useUserProfile };

package/dist/chunk-6BJOYF6E.js

@@ -0,0 +1,8 @@
+// src/execution/utils/formatDuration.ts
+function formatDuration(ms) {
+  if (!ms) return "0ms";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+
+export { formatDuration };

package/dist/chunk-6M6OLGQY.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+
+// src/components/typeform/schemas.ts
+var answerValueSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("preset"), value: z.string() }),
+  z.object({ type: z.literal("custom"), value: z.string() })
+]);
+var multiAnswerValueSchema = z.array(answerValueSchema);
+function radioWithOtherSchema(presetValues) {
+  return z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("preset"),
+      value: z.enum(presetValues)
+    }),
+    z.object({
+      type: z.literal("custom"),
+      value: z.string().min(1, "Please specify a value")
+    })
+  ]);
+}
+function checkboxWithOtherSchema(presetValues) {
+  return z.array(
+    z.discriminatedUnion("type", [
+      z.object({
+        type: z.literal("preset"),
+        value: z.enum(presetValues)
+      }),
+      z.object({
+        type: z.literal("custom"),
+        value: z.string().min(1, "Please specify a value")
+      })
+    ])
+  );
+}
+
+export { answerValueSchema, checkboxWithOtherSchema, multiAnswerValueSchema, radioWithOtherSchema };

package/dist/chunk-7AI5ZYJ4.js

@@ -0,0 +1,202 @@
+import { notifications } from '@mantine/notifications';
+import { IconUser, IconExternalLink, IconPlug, IconBolt, IconGitBranch, IconBrain } from '@tabler/icons-react';
+
+// src/utils/notify.tsx
+
+// src/utils/error-utils.ts
+var APIClientError = class extends Error {
+  statusCode;
+  code;
+  requestId;
+  fields;
+  retryAfter;
+  constructor(message, code, statusCode, requestId, fields, retryAfter) {
+    super(message);
+    this.name = "APIClientError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.fields = fields;
+    this.retryAfter = retryAfter;
+  }
+};
+function isAPIClientError(error) {
+  return error instanceof APIClientError;
+}
+function getErrorInfo(error) {
+  if (isAPIClientError(error)) {
+    return {
+      message: error.message,
+      code: error.code,
+      requestId: error.requestId,
+      statusCode: error.statusCode,
+      fields: error.fields,
+      retryAfter: error.retryAfter
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message
+    };
+  }
+  return {
+    message: String(error)
+  };
+}
+function getErrorTitle(code) {
+  if (!code) return "Error";
+  switch (code) {
+    case "VALIDATION_ERROR":
+      return "Validation Error";
+    case "AUTHENTICATION_FAILED":
+      return "Authentication Required";
+    case "FORBIDDEN":
+      return "Access Denied";
+    case "NOT_FOUND":
+      return "Not Found";
+    case "CONFLICT":
+      return "Conflict";
+    case "RATE_LIMIT_EXCEEDED":
+      return "Rate Limit Exceeded";
+    case "INTERNAL_SERVER_ERROR":
+      return "Server Error";
+    case "SERVICE_UNAVAILABLE":
+      return "Service Temporarily Unavailable";
+    default:
+      return "Error";
+  }
+}
+function formatErrorMessage(message, requestId, fields, retryAfter) {
+  let formatted = message;
+  if (fields && Object.keys(fields).length > 0) {
+    const fieldErrors = [];
+    for (const [field, errors] of Object.entries(fields)) {
+      const fieldName = field === "root" || field === "_root" ? "Request" : field;
+      errors.forEach((error) => {
+        fieldErrors.push(`\u2022 ${fieldName}: ${error}`);
+      });
+    }
+    if (fieldErrors.length > 0) {
+      formatted = fieldErrors.join("\n");
+    }
+  }
+  if (retryAfter) {
+    formatted += `
+
+Please wait ${retryAfter} seconds before retrying.`;
+  }
+  if (requestId) {
+    formatted += `
+
+Request ID: ${requestId}`;
+  }
+  return formatted;
+}
+
+// src/utils/notify.tsx
+var showInfoNotification = (message) => {
+  notifications.show({
+    title: "Info",
+    message,
+    autoClose: 5e3,
+    color: "blue",
+    position: "top-right"
+  });
+};
+var showSuccessNotification = (message) => {
+  notifications.show({
+    title: "Action Successful",
+    message,
+    autoClose: 5e3,
+    color: "green",
+    position: "top-right"
+  });
+};
+var showErrorNotification = (error) => {
+  if (error instanceof Error) {
+    error = error.message;
+  }
+  notifications.show({
+    title: "Action Failed",
+    message: error,
+    autoClose: 5e3,
+    color: "red",
+    position: "top-right"
+  });
+};
+var showWarningNotification = (message) => {
+  notifications.show({
+    title: "Warning",
+    message,
+    autoClose: 5e3,
+    color: "orange",
+    position: "top-right"
+  });
+};
+var showApiErrorNotification = (error) => {
+  const { message, code, requestId, fields, retryAfter } = getErrorInfo(error);
+  notifications.show({
+    title: getErrorTitle(code),
+    message: formatErrorMessage(message, requestId, fields, retryAfter),
+    autoClose: retryAfter ? retryAfter * 1e3 : 5e3,
+    color: "red",
+    position: "top-right"
+  });
+};
+
+// src/utils/formatDate.ts
+var formatDate = (dateString) => {
+  const date = new Date(dateString);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+};
+
+// src/utils/validateEmail.ts
+var validateEmail = (email) => {
+  return /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)+$/.test(email);
+};
+
+// ../core/src/platform/registry/resource-metadata.ts
+var resourceTypeIconNames = {
+  agent: "IconBrain",
+  workflow: "IconGitBranch",
+  trigger: "IconBolt",
+  integration: "IconPlug",
+  external: "IconExternalLink",
+  human: "IconUser"
+};
+var resourceTypeColors = {
+  agent: "violet",
+  workflow: "blue",
+  trigger: "orange",
+  integration: "teal",
+  external: "gray",
+  human: "yellow"
+};
+function getResourceIconName(type) {
+  return resourceTypeIconNames[type];
+}
+function getResourceColor(type) {
+  return resourceTypeColors[type];
+}
+
+// src/utils/resource-icons.tsx
+var iconNameToComponent = {
+  IconBrain,
+  IconGitBranch,
+  IconBolt,
+  IconPlug,
+  IconExternalLink,
+  IconUser
+};
+function getResourceIcon(type) {
+  const iconName = getResourceIconName(type);
+  return iconNameToComponent[iconName];
+}
+
+export { APIClientError, formatDate, formatErrorMessage, getErrorInfo, getErrorTitle, getResourceColor, getResourceIcon, isAPIClientError, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, validateEmail };

package/dist/chunk-7PLEQFHO.js

@@ -0,0 +1,18 @@
+import { createContext, useContext, createElement } from 'react';
+
+// src/auth/context.ts
+var AuthContext = createContext(null);
+function useAuthContext() {
+  const ctx = useContext(AuthContext);
+  if (!ctx) {
+    throw new Error(
+      "useAuthContext must be used within an AuthProvider. Wrap your app with <ElevasisProvider> or a custom AuthProvider."
+    );
+  }
+  return ctx;
+}
+function AuthProvider({ value, children }) {
+  return createElement(AuthContext.Provider, { value }, children);
+}
+
+export { AuthProvider, useAuthContext };