@agent-relay/dashboard 2.0.82 → 2.0.84

package/src/components/hooks/useSession.ts

@@ -1,209 +0,0 @@
-/**
- * useSession Hook
- *
- * React hook for managing cloud session state.
- * Automatically detects session expiration and triggers re-login flow.
- */
-
-import { useState, useEffect, useCallback, useRef } from 'react';
-import {
-  cloudApi,
-  onSessionExpired,
-  getCsrfToken,
-  type CloudUser,
-  type SessionError,
-  type SessionStatus,
-} from '../../lib/cloudApi';
-
-export interface UseSessionOptions {
-  /** Check session on mount (default: true) */
-  checkOnMount?: boolean;
-  /** Interval to periodically check session in ms (default: 60000, set to 0 to disable) */
-  checkInterval?: number;
-  /** Callback when session expires */
-  onExpired?: (error: SessionError) => void;
-}
-
-export interface UseSessionReturn {
-  /** Current user data (null if not authenticated) */
-  user: CloudUser | null;
-  /** Whether the session check is in progress */
-  isLoading: boolean;
-  /** Whether user is authenticated */
-  isAuthenticated: boolean;
-  /** Whether session has expired (requires re-login) */
-  isExpired: boolean;
-  /** Session error if any */
-  error: SessionError | null;
-  /** CSRF token for API requests */
-  csrfToken: string | null;
-  /** Manually check session status */
-  checkSession: () => Promise<SessionStatus>;
-  /** Clear the expired state (e.g., after dismissing modal) */
-  clearExpired: () => void;
-  /** Redirect to login page */
-  redirectToLogin: () => void;
-  /** Logout the current user */
-  logout: () => Promise<void>;
-}
-
-const DEFAULT_OPTIONS: Required<UseSessionOptions> = {
-  checkOnMount: true,
-  checkInterval: 60000, // 1 minute
-  onExpired: () => {},
-};
-
-export function useSession(options: UseSessionOptions = {}): UseSessionReturn {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-
-  const [user, setUser] = useState<CloudUser | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [isExpired, setIsExpired] = useState(false);
-  const [error, setError] = useState<SessionError | null>(null);
-
-  const intervalRef = useRef<NodeJS.Timeout | null>(null);
-  const mountedRef = useRef(true);
-
-  // Check session status
-  const checkSession = useCallback(async (): Promise<SessionStatus> => {
-    try {
-      const status = await cloudApi.checkSession();
-
-      if (!mountedRef.current) return status;
-
-      if (!status.authenticated) {
-        setUser(null);
-        if (status.code) {
-          const sessionError: SessionError = {
-            error: 'Session expired',
-            code: status.code,
-            message: status.message || 'Your session has expired. Please log in again.',
-          };
-          setError(sessionError);
-          setIsExpired(true);
-          opts.onExpired(sessionError);
-        }
-      }
-
-      return status;
-    } catch (_e) {
-      return {
-        authenticated: false,
-        code: 'SESSION_ERROR',
-        message: 'Failed to check session',
-      };
-    }
-  }, [opts]);
-
-  // Fetch user data
-  const fetchUser = useCallback(async () => {
-    setIsLoading(true);
-    try {
-      const result = await cloudApi.getMe();
-
-      if (!mountedRef.current) return;
-
-      if (result.success) {
-        setUser(result.data);
-        setIsExpired(false);
-        setError(null);
-      } else if (result.sessionExpired) {
-        setUser(null);
-        setIsExpired(true);
-      } else {
-        setError({
-          error: result.error,
-          code: 'SESSION_ERROR',
-          message: result.error,
-        });
-      }
-    } finally {
-      if (mountedRef.current) {
-        setIsLoading(false);
-      }
-    }
-  }, []);
-
-  // Handle session expiration from any API call
-  useEffect(() => {
-    const unsubscribe = onSessionExpired((sessionError) => {
-      if (!mountedRef.current) return;
-
-      setUser(null);
-      setIsExpired(true);
-      setError(sessionError);
-      opts.onExpired(sessionError);
-    });
-
-    return unsubscribe;
-  }, [opts]);
-
-  // Check session on mount
-  useEffect(() => {
-    mountedRef.current = true;
-
-    if (opts.checkOnMount) {
-      fetchUser();
-    }
-
-    return () => {
-      mountedRef.current = false;
-    };
-  }, [opts.checkOnMount, fetchUser]);
-
-  // Periodic session check
-  useEffect(() => {
-    if (opts.checkInterval <= 0) return;
-
-    intervalRef.current = setInterval(() => {
-      // Only check if we think we're authenticated
-      if (user) {
-        checkSession();
-      }
-    }, opts.checkInterval);
-
-    return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-    };
-  }, [opts.checkInterval, user, checkSession]);
-
-  // Clear expired state
-  const clearExpired = useCallback(() => {
-    setIsExpired(false);
-    setError(null);
-  }, []);
-
-  // Redirect to login
-  const redirectToLogin = useCallback(() => {
-    // Preserve current path for redirect after login
-    const returnTo = encodeURIComponent(window.location.pathname + window.location.search);
-    window.location.href = `/login?returnTo=${returnTo}`;
-  }, []);
-
-  // Logout
-  const logout = useCallback(async () => {
-    await cloudApi.logout();
-    setUser(null);
-    setIsExpired(false);
-    setError(null);
-    window.location.href = '/login';
-  }, []);
-
-  return {
-    user,
-    isLoading,
-    isAuthenticated: user !== null,
-    isExpired,
-    error,
-    csrfToken: getCsrfToken(),
-    checkSession,
-    clearExpired,
-    redirectToLogin,
-    logout,
-  };
-}
-
-export type { SessionError, CloudUser };

package/src/components/hooks/useWorkspaceMembers.ts

@@ -1,132 +0,0 @@
-/**
- * useWorkspaceMembers Hook
- *
- * Fetches and caches workspace members for filtering online users.
- * Returns the set of usernames that have access to the workspace.
- */
-
-import { useState, useEffect, useCallback, useMemo } from 'react';
-import { cloudApi } from '../../lib/cloudApi';
-import type { UserPresence } from './usePresence';
-
-interface WorkspaceMember {
-  id: string;
-  userId: string;
-  role: string;
-  isPending: boolean;
-  user?: {
-    githubUsername?: string;
-    displayName?: string;
-    email?: string;
-    avatarUrl?: string;
-  };
-}
-
-export interface UseWorkspaceMembersOptions {
-  /** The workspace ID to fetch members for */
-  workspaceId?: string;
-  /** Whether to enable fetching (e.g., only in cloud mode) */
-  enabled?: boolean;
-}
-
-export interface UseWorkspaceMembersReturn {
-  /** Set of usernames with workspace access (lowercase for comparison) */
-  memberUsernames: Set<string>;
-  /** Whether members are currently loading */
-  isLoading: boolean;
-  /** Error message if fetch failed */
-  error: string | null;
-  /** Refetch workspace members */
-  refetch: () => Promise<void>;
-}
-
-/**
- * Hook to fetch workspace members and provide a set of usernames with access.
- * Used to filter online users to show only those with workspace access.
- */
-export function useWorkspaceMembers(
-  options: UseWorkspaceMembersOptions = {}
-): UseWorkspaceMembersReturn {
-  const { workspaceId, enabled = true } = options;
-
-  const [members, setMembers] = useState<WorkspaceMember[]>([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const fetchMembers = useCallback(async () => {
-    if (!workspaceId || !enabled) {
-      setMembers([]);
-      return;
-    }
-
-    setIsLoading(true);
-    setError(null);
-
-    try {
-      const result = await cloudApi.getWorkspaceMembers(workspaceId);
-      if (result.success) {
-        setMembers(result.data.members as WorkspaceMember[]);
-      } else {
-        setError(result.error);
-        setMembers([]);
-      }
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to fetch members');
-      setMembers([]);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [workspaceId, enabled]);
-
-  // Fetch members when workspace changes
-  useEffect(() => {
-    fetchMembers();
-  }, [fetchMembers]);
-
-  // Build set of member usernames (lowercase for case-insensitive comparison)
-  // Include githubUsername, displayName, and email prefix to match all possible presence usernames
-  // (The auth API uses: displayName || githubUsername || email.split('@')[0])
-  const memberUsernames = useMemo(() => {
-    const usernames = new Set<string>();
-    for (const member of members) {
-      // Add GitHub username if available
-      if (member.user?.githubUsername) {
-        usernames.add(member.user.githubUsername.toLowerCase());
-      }
-      // Also add displayName for email-only users who don't have a GitHub username
-      if (member.user?.displayName) {
-        usernames.add(member.user.displayName.toLowerCase());
-      }
-      // Also add email prefix for email-only users without displayName
-      if (member.user?.email) {
-        usernames.add(member.user.email.split('@')[0].toLowerCase());
-      }
-    }
-    return usernames;
-  }, [members]);
-
-  return {
-    memberUsernames,
-    isLoading,
-    error,
-    refetch: fetchMembers,
-  };
-}
-
-/**
- * Filter online users to only include those with workspace access.
- * If no members are loaded (non-cloud mode or error), returns all users.
- */
-export function filterOnlineUsersByWorkspace(
-  onlineUsers: UserPresence[],
-  memberUsernames: Set<string>
-): UserPresence[] {
-  // If no members loaded, show all users (non-cloud mode fallback)
-  if (memberUsernames.size === 0) {
-    return onlineUsers;
-  }
-
-  return onlineUsers.filter((user) =>
-    memberUsernames.has(user.username.toLowerCase())
-  );
-}

package/src/components/hooks/useWorkspaceStatus.ts

@@ -1,237 +0,0 @@
-/**
- * useWorkspaceStatus Hook
- *
- * React hook for monitoring workspace status with auto-wakeup capability.
- * Polls for status updates and can automatically restart stopped workspaces.
- */
-
-import { useState, useEffect, useCallback, useRef } from 'react';
-import { cloudApi } from '../../lib/cloudApi';
-
-export interface WorkspaceStatus {
-  id: string;
-  name: string;
-  status: string;
-  publicUrl?: string;
-  isStopped: boolean;
-  isRunning: boolean;
-  isProvisioning: boolean;
-  hasError: boolean;
-  config: {
-    providers: string[];
-    repositories: string[];
-  };
-}
-
-export interface UseWorkspaceStatusOptions {
-  /** Poll for status updates (default: true) */
-  autoRefresh?: boolean;
-  /** Interval to poll for status in ms (default: 30000) */
-  refreshInterval?: number;
-  /** Auto-wakeup when workspace is stopped (default: false) */
-  autoWakeup?: boolean;
-  /** Callback when workspace status changes */
-  onStatusChange?: (status: string, wasRestarted: boolean) => void;
-}
-
-export interface UseWorkspaceStatusReturn {
-  /** Current workspace data (null if no workspace) */
-  workspace: WorkspaceStatus | null;
-  /** Whether workspace exists */
-  exists: boolean;
-  /** Whether the status check is in progress */
-  isLoading: boolean;
-  /** Whether a wakeup is in progress */
-  isWakingUp: boolean;
-  /** Status message for display */
-  statusMessage: string;
-  /** Action needed (wakeup, check_error, etc) */
-  actionNeeded: 'wakeup' | 'check_error' | null;
-  /** Error if any */
-  error: string | null;
-  /** Manually refresh status */
-  refresh: () => Promise<void>;
-  /** Manually wake up workspace */
-  wakeup: () => Promise<{ success: boolean; message: string }>;
-}
-
-const DEFAULT_OPTIONS: Required<UseWorkspaceStatusOptions> = {
-  autoRefresh: true,
-  refreshInterval: 30000, // 30 seconds
-  autoWakeup: false,
-  onStatusChange: () => {},
-};
-
-export function useWorkspaceStatus(
-  options: UseWorkspaceStatusOptions = {}
-): UseWorkspaceStatusReturn {
-  // Stabilize options to prevent infinite re-renders
-  // Use refs for callbacks and useMemo for primitive values
-  const autoRefresh = options.autoRefresh ?? DEFAULT_OPTIONS.autoRefresh;
-  const refreshInterval = options.refreshInterval ?? DEFAULT_OPTIONS.refreshInterval;
-  const autoWakeup = options.autoWakeup ?? DEFAULT_OPTIONS.autoWakeup;
-
-  // Store callback in ref to avoid recreating refresh on every render
-  const onStatusChangeRef = useRef(options.onStatusChange ?? DEFAULT_OPTIONS.onStatusChange);
-  onStatusChangeRef.current = options.onStatusChange ?? DEFAULT_OPTIONS.onStatusChange;
-
-  const [workspace, setWorkspace] = useState<WorkspaceStatus | null>(null);
-  const [exists, setExists] = useState(false);
-  const [isLoading, setIsLoading] = useState(true);
-  const [isWakingUp, setIsWakingUp] = useState(false);
-  const [statusMessage, setStatusMessage] = useState('');
-  const [actionNeeded, setActionNeeded] = useState<'wakeup' | 'check_error' | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  const intervalRef = useRef<NodeJS.Timeout | null>(null);
-  const mountedRef = useRef(true);
-  const previousStatusRef = useRef<string | null>(null);
-
-  // Fetch workspace status
-  const refresh = useCallback(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-
-      const result = await cloudApi.getPrimaryWorkspace();
-
-      if (!mountedRef.current) return;
-
-      if (result.success) {
-        setExists(result.data.exists);
-        setStatusMessage(result.data.statusMessage);
-        setActionNeeded(result.data.actionNeeded || null);
-
-        if (result.data.workspace) {
-          const ws = result.data.workspace;
-          setWorkspace(ws);
-
-          // Check for status change
-          if (previousStatusRef.current && previousStatusRef.current !== ws.status) {
-            onStatusChangeRef.current(ws.status, false);
-          }
-          previousStatusRef.current = ws.status;
-        } else {
-          setWorkspace(null);
-        }
-      } else {
-        setError(result.error);
-      }
-    } catch (_e) {
-      if (mountedRef.current) {
-        setError('Failed to fetch workspace status');
-      }
-    } finally {
-      if (mountedRef.current) {
-        setIsLoading(false);
-      }
-    }
-  }, []); // No dependencies - uses refs for callbacks
-
-  // Store refresh interval in ref for wakeup callback
-  const refreshIntervalRef = useRef(refreshInterval);
-  refreshIntervalRef.current = refreshInterval;
-  const autoRefreshRef = useRef(autoRefresh);
-  autoRefreshRef.current = autoRefresh;
-
-  // Wake up workspace
-  const wakeup = useCallback(async (): Promise<{ success: boolean; message: string }> => {
-    if (!workspace?.id) {
-      return { success: false, message: 'No workspace to wake up' };
-    }
-
-    try {
-      setIsWakingUp(true);
-      setError(null);
-
-      const result = await cloudApi.wakeupWorkspace(workspace.id);
-
-      if (!mountedRef.current) {
-        return { success: false, message: 'Component unmounted' };
-      }
-
-      if (result.success) {
-        // Update local state
-        if (result.data.wasRestarted) {
-          setStatusMessage(result.data.message);
-          setActionNeeded(null);
-          onStatusChangeRef.current('starting', true);
-
-          // Start more frequent polling to catch when workspace is ready
-          if (intervalRef.current) {
-            clearInterval(intervalRef.current);
-          }
-          intervalRef.current = setInterval(refresh, 5000); // Poll every 5s during startup
-
-          // Reset to normal interval after 2 minutes
-          setTimeout(() => {
-            if (mountedRef.current && intervalRef.current) {
-              clearInterval(intervalRef.current);
-              if (autoRefreshRef.current) {
-                intervalRef.current = setInterval(refresh, refreshIntervalRef.current);
-              }
-            }
-          }, 120000);
-        }
-
-        return { success: true, message: result.data.message };
-      } else {
-        setError(result.error);
-        return { success: false, message: result.error };
-      }
-    } catch (e) {
-      const message = e instanceof Error ? e.message : 'Failed to wake up workspace';
-      if (mountedRef.current) {
-        setError(message);
-      }
-      return { success: false, message };
-    } finally {
-      if (mountedRef.current) {
-        setIsWakingUp(false);
-      }
-    }
-  }, [workspace?.id, refresh]);
-
-  // Initial fetch
-  useEffect(() => {
-    mountedRef.current = true;
-    refresh();
-
-    return () => {
-      mountedRef.current = false;
-    };
-  }, [refresh]);
-
-  // Auto-refresh polling
-  useEffect(() => {
-    if (!autoRefresh) return;
-
-    intervalRef.current = setInterval(refresh, refreshInterval);
-
-    return () => {
-      if (intervalRef.current) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-    };
-  }, [autoRefresh, refreshInterval, refresh]);
-
-  // Auto-wakeup when workspace is stopped
-  useEffect(() => {
-    if (autoWakeup && workspace?.isStopped && !isWakingUp) {
-      wakeup();
-    }
-  }, [autoWakeup, workspace?.isStopped, isWakingUp, wakeup]);
-
-  return {
-    workspace,
-    exists,
-    isLoading,
-    isWakingUp,
-    statusMessage,
-    actionNeeded,
-    error,
-    refresh,
-    wakeup,
-  };
-}