agent-relay 2.0.21 → 2.0.23

package/packages/dashboard/ui/react-components/hooks/useChannelAdmin.ts

@@ -1,329 +0,0 @@
-/**
- * useChannelAdmin Hook
- *
- * Manages channel administration: settings, members, and permissions.
- * Used by ChannelAdminPanel for admin-only operations.
- */
-
-import { useState, useEffect, useCallback, useMemo } from 'react';
-import { api } from '../../lib/api';
-
-export interface ChannelMemberInfo {
-  id: string;
-  name: string;
-  displayName?: string;
-  avatarUrl?: string;
-  role: 'admin' | 'member';
-  joinedAt: string;
-  isAgent: boolean;
-}
-
-export interface ChannelSettings {
-  id: string;
-  name: string;
-  description?: string;
-  topic?: string;
-  isPrivate: boolean;
-  createdAt: string;
-  creatorId: string;
-  admins: string[];
-}
-
-export interface UseChannelAdminOptions {
-  /** Channel ID to manage */
-  channelId: string;
-  /** Current user ID for permission checks */
-  currentUserId?: string;
-  /** Page size for member pagination (default: 20) */
-  pageSize?: number;
-  /** Auto-fetch on mount (default: true) */
-  autoFetch?: boolean;
-}
-
-export interface UseChannelAdminReturn {
-  /** Channel settings */
-  settings: ChannelSettings | null;
-  /** List of members for current page */
-  members: ChannelMemberInfo[];
-  /** Loading states */
-  isLoadingSettings: boolean;
-  isLoadingMembers: boolean;
-  /** Error messages */
-  settingsError: string | null;
-  membersError: string | null;
-  /** Whether current user is admin */
-  isAdmin: boolean;
-  /** Member pagination */
-  memberPage: number;
-  memberTotalPages: number;
-  memberTotalCount: number;
-  goToMemberPage: (page: number) => void;
-  /** Member search */
-  memberSearchQuery: string;
-  setMemberSearchQuery: (query: string) => void;
-  /** Update channel settings */
-  updateSettings: (updates: Partial<Pick<ChannelSettings, 'description' | 'topic'>>) => Promise<void>;
-  /** Remove a member from channel */
-  removeMember: (memberId: string) => Promise<void>;
-  /** Assign an agent to the channel */
-  assignAgent: (agentName: string) => Promise<void>;
-  /** Promote/demote member to/from admin */
-  setMemberRole: (memberId: string, role: 'admin' | 'member') => Promise<void>;
-  /** Refresh data */
-  refreshSettings: () => void;
-  refreshMembers: () => void;
-}
-
-export function useChannelAdmin(
-  options: UseChannelAdminOptions
-): UseChannelAdminReturn {
-  const {
-    channelId,
-    currentUserId,
-    pageSize = 20,
-    autoFetch = true,
-  } = options;
-
-  // Settings state
-  const [settings, setSettings] = useState<ChannelSettings | null>(null);
-  const [isLoadingSettings, setIsLoadingSettings] = useState(false);
-  const [settingsError, setSettingsError] = useState<string | null>(null);
-
-  // Members state
-  const [members, setMembers] = useState<ChannelMemberInfo[]>([]);
-  const [isLoadingMembers, setIsLoadingMembers] = useState(false);
-  const [membersError, setMembersError] = useState<string | null>(null);
-  const [memberPage, setMemberPage] = useState(1);
-  const [memberTotalCount, setMemberTotalCount] = useState(0);
-  const [memberSearchQuery, setMemberSearchQuery] = useState('');
-
-  // Calculate admin status
-  const isAdmin = useMemo(() => {
-    if (!currentUserId || !settings) return false;
-    return settings.creatorId === currentUserId || settings.admins.includes(currentUserId);
-  }, [currentUserId, settings]);
-
-  // Calculate total pages
-  const memberTotalPages = useMemo(() => {
-    return Math.max(1, Math.ceil(memberTotalCount / pageSize));
-  }, [memberTotalCount, pageSize]);
-
-  // Fetch channel settings
-  const fetchSettings = useCallback(async () => {
-    setIsLoadingSettings(true);
-    setSettingsError(null);
-
-    try {
-      const result = await api.get<{
-        channel: ChannelSettings;
-        currentUserRole: 'admin' | 'member' | null;
-      }>(`/api/channels/${channelId}`);
-
-      if (result.channel) {
-        setSettings(result.channel);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to fetch channel settings';
-      setSettingsError(message);
-      console.error('[useChannelAdmin] Settings fetch error:', err);
-    } finally {
-      setIsLoadingSettings(false);
-    }
-  }, [channelId]);
-
-  // Fetch channel members
-  const fetchMembers = useCallback(async (page: number, search: string) => {
-    setIsLoadingMembers(true);
-    setMembersError(null);
-
-    try {
-      const params = new URLSearchParams({
-        page: page.toString(),
-        limit: pageSize.toString(),
-      });
-
-      if (search.trim()) {
-        params.set('search', search.trim());
-      }
-
-      const result = await api.get<{
-        members: ChannelMemberInfo[];
-        pagination: {
-          page: number;
-          limit: number;
-          total: number;
-          totalPages: number;
-        };
-      }>(`/api/channels/${channelId}/members?${params.toString()}`);
-
-      if (result.members) {
-        setMembers(result.members);
-        setMemberTotalCount(result.pagination?.total || result.members.length);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to fetch members';
-      setMembersError(message);
-      console.error('[useChannelAdmin] Members fetch error:', err);
-    } finally {
-      setIsLoadingMembers(false);
-    }
-  }, [channelId, pageSize]);
-
-  // Auto-fetch on mount or channelId change
-  useEffect(() => {
-    if (autoFetch && channelId) {
-      fetchSettings();
-      fetchMembers(1, '');
-    }
-  }, [autoFetch, channelId, fetchSettings, fetchMembers]);
-
-  // Fetch members when page or search changes
-  useEffect(() => {
-    if (autoFetch && channelId) {
-      fetchMembers(memberPage, memberSearchQuery);
-    }
-  }, [memberPage, memberSearchQuery, autoFetch, channelId, fetchMembers]);
-
-  // Reset to page 1 when search changes
-  useEffect(() => {
-    setMemberPage(1);
-  }, [memberSearchQuery]);
-
-  // Go to specific member page
-  const goToMemberPage = useCallback((page: number) => {
-    const validPage = Math.max(1, Math.min(page, memberTotalPages));
-    setMemberPage(validPage);
-  }, [memberTotalPages]);
-
-  // Update channel settings
-  const updateSettings = useCallback(async (updates: Partial<Pick<ChannelSettings, 'description' | 'topic'>>) => {
-    if (!isAdmin) {
-      throw new Error('Permission denied: Admin access required');
-    }
-
-    try {
-      await api.patch(`/api/channels/${channelId}`, updates);
-
-      // Optimistically update local state
-      setSettings((prev) => prev ? { ...prev, ...updates } : null);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to update settings';
-      setSettingsError(message);
-      throw err;
-    }
-  }, [channelId, isAdmin]);
-
-  // Remove a member
-  const removeMember = useCallback(async (memberId: string) => {
-    if (!isAdmin) {
-      throw new Error('Permission denied: Admin access required');
-    }
-
-    try {
-      await api.delete(`/api/channels/${channelId}/members/${memberId}`);
-
-      // Optimistically update local state
-      setMembers((prev) => prev.filter((m) => m.id !== memberId));
-      setMemberTotalCount((prev) => Math.max(0, prev - 1));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to remove member';
-      setMembersError(message);
-      throw err;
-    }
-  }, [channelId, isAdmin]);
-
-  // Assign an agent to the channel
-  const assignAgent = useCallback(async (agentName: string) => {
-    if (!isAdmin) {
-      throw new Error('Permission denied: Admin access required');
-    }
-
-    try {
-      const result = await api.post<{ member: ChannelMemberInfo }>(`/api/channels/${channelId}/agents`, {
-        agentName,
-      });
-
-      // Add to members list if returned
-      if (result.member) {
-        setMembers((prev) => [...prev, result.member]);
-        setMemberTotalCount((prev) => prev + 1);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to assign agent';
-      setMembersError(message);
-      throw err;
-    }
-  }, [channelId, isAdmin]);
-
-  // Set member role
-  const setMemberRole = useCallback(async (memberId: string, role: 'admin' | 'member') => {
-    if (!isAdmin) {
-      throw new Error('Permission denied: Admin access required');
-    }
-
-    try {
-      await api.patch(`/api/channels/${channelId}/members/${memberId}`, { role });
-
-      // Optimistically update local state
-      setMembers((prev) =>
-        prev.map((m) => m.id === memberId ? { ...m, role } : m)
-      );
-
-      // Update admins list in settings
-      if (role === 'admin') {
-        setSettings((prev) => {
-          if (!prev) return null;
-          const member = members.find((m) => m.id === memberId);
-          if (member && !prev.admins.includes(member.name)) {
-            return { ...prev, admins: [...prev.admins, member.name] };
-          }
-          return prev;
-        });
-      } else {
-        setSettings((prev) => {
-          if (!prev) return null;
-          const member = members.find((m) => m.id === memberId);
-          if (member) {
-            return { ...prev, admins: prev.admins.filter((a) => a !== member.name) };
-          }
-          return prev;
-        });
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to update member role';
-      setMembersError(message);
-      throw err;
-    }
-  }, [channelId, isAdmin, members]);
-
-  // Refresh functions
-  const refreshSettings = useCallback(() => {
-    fetchSettings();
-  }, [fetchSettings]);
-
-  const refreshMembers = useCallback(() => {
-    fetchMembers(memberPage, memberSearchQuery);
-  }, [fetchMembers, memberPage, memberSearchQuery]);
-
-  return {
-    settings,
-    members,
-    isLoadingSettings,
-    isLoadingMembers,
-    settingsError,
-    membersError,
-    isAdmin,
-    memberPage,
-    memberTotalPages,
-    memberTotalCount,
-    goToMemberPage,
-    memberSearchQuery,
-    setMemberSearchQuery,
-    updateSettings,
-    removeMember,
-    assignAgent,
-    setMemberRole,
-    refreshSettings,
-    refreshMembers,
-  };
-}

package/packages/dashboard/ui/react-components/hooks/useChannelBrowser.ts

@@ -1,239 +0,0 @@
-/**
- * useChannelBrowser Hook
- *
- * Manages browsing, searching, and joining channels.
- * Includes debounced search and pagination support.
- */
-
-import { useState, useEffect, useCallback, useMemo } from 'react';
-import { useDebounce } from './useDebounce';
-import { api } from '../../lib/api';
-
-export interface BrowseChannel {
-  id: string;
-  name: string;
-  description?: string;
-  memberCount: number;
-  isJoined: boolean;
-  isPrivate: boolean;
-  createdAt: string;
-}
-
-export interface UseChannelBrowserOptions {
-  /** Workspace ID (required for API calls) */
-  workspaceId: string;
-  /** Initial page size (default: 20) */
-  pageSize?: number;
-  /** Search debounce delay in ms (default: 300) */
-  debounceDelay?: number;
-  /** Auto-fetch on mount (default: true) */
-  autoFetch?: boolean;
-}
-
-export interface UseChannelBrowserReturn {
-  /** List of channels for current page */
-  channels: BrowseChannel[];
-  /** Loading state */
-  isLoading: boolean;
-  /** Error message if any */
-  error: string | null;
-  /** Current search query */
-  searchQuery: string;
-  /** Update search query */
-  setSearchQuery: (query: string) => void;
-  /** Current page (1-indexed) */
-  currentPage: number;
-  /** Total number of pages */
-  totalPages: number;
-  /** Total count of channels matching search */
-  totalCount: number;
-  /** Navigate to a specific page */
-  goToPage: (page: number) => void;
-  /** Join a channel */
-  joinChannel: (channelId: string) => Promise<void>;
-  /** Leave a channel */
-  leaveChannel: (channelId: string) => Promise<void>;
-  /** Refresh the channel list */
-  refresh: () => void;
-}
-
-export function useChannelBrowser(
-  options: UseChannelBrowserOptions
-): UseChannelBrowserReturn {
-  const {
-    workspaceId,
-    pageSize = 20,
-    debounceDelay = 300,
-    autoFetch = true,
-  } = options;
-
-  const [channels, setChannels] = useState<BrowseChannel[]>([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [searchQuery, setSearchQuery] = useState('');
-  const [currentPage, setCurrentPage] = useState(1);
-  const [totalCount, setTotalCount] = useState(0);
-
-  // Debounce search query
-  const debouncedSearchQuery = useDebounce(searchQuery, debounceDelay);
-
-  // Calculate total pages
-  const totalPages = useMemo(() => {
-    return Math.max(1, Math.ceil(totalCount / pageSize));
-  }, [totalCount, pageSize]);
-
-  // Fetch channels from API (workspace-scoped)
-  const fetchChannels = useCallback(async (page: number, search: string) => {
-    if (!workspaceId) {
-      setError('Workspace ID is required');
-      return;
-    }
-
-    setIsLoading(true);
-    setError(null);
-
-    try {
-      // Build query params
-      const params = new URLSearchParams({
-        page: page.toString(),
-        limit: pageSize.toString(),
-      });
-
-      if (search.trim()) {
-        params.set('search', search.trim());
-      }
-
-      // Use workspace-scoped endpoint
-      const result = await api.get<{
-        channels: Array<{
-          id: string;
-          name: string;
-          description?: string;
-          memberCount?: number;
-          isPrivate?: boolean;
-          createdAt: string;
-          // Backend may use different field names
-          isMember?: boolean;
-        }>;
-        archivedChannels?: unknown[];
-        pagination?: {
-          page: number;
-          limit: number;
-          total: number;
-          totalPages: number;
-        };
-      }>(`/api/workspaces/${workspaceId}/channels?${params.toString()}`);
-
-      if (result.channels) {
-        // Map backend response to BrowseChannel format
-        const mappedChannels: BrowseChannel[] = result.channels.map((ch) => ({
-          id: ch.id,
-          name: ch.name,
-          description: ch.description,
-          memberCount: ch.memberCount || 0,
-          isJoined: ch.isMember ?? false,
-          isPrivate: ch.isPrivate ?? false,
-          createdAt: ch.createdAt,
-        }));
-        setChannels(mappedChannels);
-        setTotalCount(result.pagination?.total || result.channels.length);
-      } else {
-        // API might return different structure - handle gracefully
-        setChannels([]);
-        setTotalCount(0);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to fetch channels';
-      setError(message);
-      console.error('[useChannelBrowser] Fetch error:', err);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [workspaceId, pageSize]);
-
-  // Fetch when search or page changes
-  useEffect(() => {
-    if (autoFetch) {
-      fetchChannels(currentPage, debouncedSearchQuery);
-    }
-  }, [currentPage, debouncedSearchQuery, autoFetch, fetchChannels]);
-
-  // Reset to page 1 when search changes
-  useEffect(() => {
-    setCurrentPage(1);
-  }, [debouncedSearchQuery]);
-
-  // Go to specific page
-  const goToPage = useCallback((page: number) => {
-    const validPage = Math.max(1, Math.min(page, totalPages));
-    setCurrentPage(validPage);
-  }, [totalPages]);
-
-  // Join a channel (workspace-scoped)
-  const joinChannel = useCallback(async (channelId: string) => {
-    if (!workspaceId) {
-      throw new Error('Workspace ID is required');
-    }
-
-    try {
-      await api.post(`/api/workspaces/${workspaceId}/channels/${encodeURIComponent(channelId)}/join`);
-
-      // Optimistically update local state
-      setChannels((prev) =>
-        prev.map((ch) =>
-          ch.id === channelId
-            ? { ...ch, isJoined: true, memberCount: ch.memberCount + 1 }
-            : ch
-        )
-      );
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to join channel';
-      setError(message);
-      throw err;
-    }
-  }, [workspaceId]);
-
-  // Leave a channel (workspace-scoped)
-  const leaveChannel = useCallback(async (channelId: string) => {
-    if (!workspaceId) {
-      throw new Error('Workspace ID is required');
-    }
-
-    try {
-      await api.post(`/api/workspaces/${workspaceId}/channels/${encodeURIComponent(channelId)}/leave`);
-
-      // Optimistically update local state
-      setChannels((prev) =>
-        prev.map((ch) =>
-          ch.id === channelId
-            ? { ...ch, isJoined: false, memberCount: Math.max(0, ch.memberCount - 1) }
-            : ch
-        )
-      );
-    } catch (err) {
-      const message = err instanceof Error ? err.message : 'Failed to leave channel';
-      setError(message);
-      throw err;
-    }
-  }, [workspaceId]);
-
-  // Refresh current view
-  const refresh = useCallback(() => {
-    fetchChannels(currentPage, debouncedSearchQuery);
-  }, [fetchChannels, currentPage, debouncedSearchQuery]);
-
-  return {
-    channels,
-    isLoading,
-    error,
-    searchQuery,
-    setSearchQuery,
-    currentPage,
-    totalPages,
-    totalCount,
-    goToPage,
-    joinChannel,
-    leaveChannel,
-    refresh,
-  };
-}

package/packages/dashboard/ui/react-components/hooks/useChannelCommands.ts

@@ -1,138 +0,0 @@
-/**
- * useChannelCommands Hook
- *
- * Provides channel-related commands for the CommandPalette.
- * Integrates /create-channel, /join-channel, /leave-channel, /channels commands.
- */
-
-import { useMemo, useCallback, createElement } from 'react';
-import type { Command } from '../CommandPalette';
-import { api } from '../../lib/api';
-
-export interface ChannelInfo {
-  id: string;
-  name: string;
-  memberCount?: number;
-}
-
-export interface UseChannelCommandsOptions {
-  /** List of channels user has joined */
-  joinedChannels: string[];
-  /** Callback when user wants to browse channels */
-  onBrowseChannels: () => void;
-  /** Callback when user wants to create a channel */
-  onCreateChannel: () => void;
-  /** Callback when a channel is joined */
-  onChannelJoined?: (channelName: string) => void;
-  /** Callback when a channel is left */
-  onChannelLeft?: (channelName: string) => void;
-}
-
-export interface UseChannelCommandsReturn {
-  /** Commands to add to CommandPalette */
-  commands: Command[];
-  /** Autocomplete suggestions for channel names */
-  getChannelSuggestions: (query: string) => Promise<ChannelInfo[]>;
-}
-
-export function useChannelCommands(
-  options: UseChannelCommandsOptions
-): UseChannelCommandsReturn {
-  const {
-    joinedChannels,
-    onBrowseChannels,
-    onCreateChannel,
-    onChannelJoined,
-    onChannelLeft,
-  } = options;
-
-  // Get channel suggestions for autocomplete
-  const getChannelSuggestions = useCallback(async (query: string): Promise<ChannelInfo[]> => {
-    try {
-      const params = new URLSearchParams({
-        search: query,
-        limit: '10',
-      });
-
-      const result = await api.get<{
-        channels: Array<{ id: string; name: string; memberCount: number }>;
-      }>(`/api/channels/browse?${params.toString()}`);
-
-      return result.channels || [];
-    } catch (err) {
-      console.error('[useChannelCommands] Failed to get suggestions:', err);
-      return [];
-    }
-  }, []);
-
-  // Join channel action (reserved for future use)
-  const _joinChannel = useCallback(async (channelName: string) => {
-    try {
-      // Normalize channel name
-      const normalized = channelName.startsWith('#') ? channelName.slice(1) : channelName;
-
-      await api.post(`/api/channels/${normalized}/join`);
-      onChannelJoined?.(`#${normalized}`);
-    } catch (err) {
-      console.error('[useChannelCommands] Failed to join channel:', err);
-    }
-  }, [onChannelJoined]);
-
-  // Leave channel action
-  const leaveChannel = useCallback(async (channelName: string) => {
-    try {
-      // Normalize channel name
-      const normalized = channelName.startsWith('#') ? channelName.slice(1) : channelName;
-
-      await api.post(`/api/channels/${normalized}/leave`);
-      onChannelLeft?.(`#${normalized}`);
-    } catch (err) {
-      console.error('[useChannelCommands] Failed to leave channel:', err);
-    }
-  }, [onChannelLeft]);
-
-  // Build commands
-  const commands = useMemo((): Command[] => {
-    const channelCommands: Command[] = [
-      {
-        id: 'browse-channels',
-        label: 'Browse Channels',
-        description: 'Discover and join public channels',
-        category: 'channels',
-        icon: createElement('span', { className: 'text-sm' }, '#'),
-        shortcut: '/channels',
-        action: onBrowseChannels,
-      },
-      {
-        id: 'create-channel',
-        label: 'Create Channel',
-        description: 'Start a new channel',
-        category: 'channels',
-        icon: createElement('span', { className: 'text-sm' }, '+'),
-        shortcut: '/create-channel',
-        action: onCreateChannel,
-      },
-    ];
-
-    // Add leave commands for joined channels
-    for (const channel of joinedChannels) {
-      const displayName = channel.startsWith('#') ? channel : `#${channel}`;
-      channelCommands.push({
-        id: `leave-${channel}`,
-        label: `Leave ${displayName}`,
-        description: 'Leave this channel',
-        category: 'channels',
-        icon: createElement('span', { className: 'text-sm' }, '⊗'),
-        action: () => leaveChannel(channel),
-      });
-    }
-
-    return channelCommands;
-  }, [joinedChannels, onBrowseChannels, onCreateChannel, leaveChannel]);
-
-  return {
-    commands,
-    getChannelSuggestions,
-  };
-}
-