agent-relay 2.0.21 → 2.0.23

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

@@ -1,328 +0,0 @@
-/**
- * useChannels Hook
- *
- * Manages channel-based messaging via the presence WebSocket.
- * - Join/leave channels
- * - Send/receive channel messages
- * - Send/receive direct messages
- * - Track joined channels
- */
-
-import { useState, useEffect, useCallback, useRef } from 'react';
-
-/** Channel message from server */
-export interface ChannelMessage {
-  id: string;
-  type: 'channel_message' | 'direct_message';
-  channel?: string;
-  from: string;
-  to?: string;
-  body: string;
-  thread?: string;
-  timestamp: string;
-}
-
-export interface UseChannelsOptions {
-  /** Current user info (if logged in) */
-  currentUser?: {
-    username: string;
-    avatarUrl?: string;
-  };
-  /** WebSocket URL (defaults to same as main WebSocket) */
-  wsUrl?: string;
-  /** Whether to auto-connect */
-  autoConnect?: boolean;
-  /** Callback when a message is received */
-  onMessage?: (message: ChannelMessage) => void;
-  /** Workspace ID for cloud channel message subscription */
-  workspaceId?: string;
-}
-
-export interface UseChannelsReturn {
-  /** List of channels user has joined */
-  channels: string[];
-  /** Join a channel */
-  joinChannel: (channel: string) => void;
-  /** Leave a channel */
-  leaveChannel: (channel: string) => void;
-  /** Send a message to a channel */
-  sendChannelMessage: (channel: string, body: string, thread?: string) => void;
-  /** Send a direct message */
-  sendDirectMessage: (to: string, body: string, thread?: string) => void;
-  /** Whether connected */
-  isConnected: boolean;
-  /** Recent messages (last 100) */
-  messages: ChannelMessage[];
-}
-
-/**
- * Get the presence WebSocket URL
- */
-function getPresenceUrl(): string {
-  const isDev = process.env.NODE_ENV === 'development';
-
-  if (typeof window === 'undefined') {
-    return 'ws://localhost:3889/ws/presence';
-  }
-
-  if (isDev && window.location.port === '3888') {
-    const host = window.location.hostname || 'localhost';
-    return `ws://${host}:3889/ws/presence`;
-  }
-
-  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-  return `${protocol}//${window.location.host}/ws/presence`;
-}
-
-const MAX_MESSAGES = 100;
-
-export function useChannels(options: UseChannelsOptions = {}): UseChannelsReturn {
-  const { currentUser, wsUrl, autoConnect = true, onMessage, workspaceId } = options;
-
-  const [channels, setChannels] = useState<string[]>([]);
-  const [messages, setMessages] = useState<ChannelMessage[]>([]);
-  const [isConnected, setIsConnected] = useState(false);
-
-  const wsRef = useRef<WebSocket | null>(null);
-  const reconnectTimeoutRef = useRef<NodeJS.Timeout | null>(null);
-  const isConnectingRef = useRef(false);
-  const currentUserRef = useRef(currentUser);
-  const onMessageRef = useRef(onMessage);
-  const workspaceIdRef = useRef(workspaceId);
-  currentUserRef.current = currentUser;
-  onMessageRef.current = onMessage;
-  workspaceIdRef.current = workspaceId;
-
-  const connect = useCallback(() => {
-    const user = currentUserRef.current;
-    if (!user) return;
-    if (wsRef.current?.readyState === WebSocket.OPEN) return;
-    if (isConnectingRef.current) return;
-
-    isConnectingRef.current = true;
-    const url = wsUrl || getPresenceUrl();
-
-    try {
-      const ws = new WebSocket(url);
-
-      ws.onopen = () => {
-        isConnectingRef.current = false;
-        setIsConnected(true);
-
-        const currentUserInfo = currentUserRef.current;
-        if (currentUserInfo) {
-          // Announce presence (this registers with UserBridge on server)
-          ws.send(JSON.stringify({
-            type: 'presence',
-            action: 'join',
-            user: {
-              username: currentUserInfo.username,
-              avatarUrl: currentUserInfo.avatarUrl,
-            },
-          }));
-
-          // Subscribe to channel messages for this workspace (cloud mode)
-          const wsId = workspaceIdRef.current;
-          if (wsId) {
-            ws.send(JSON.stringify({
-              type: 'subscribe_channels',
-              workspaceId: wsId,
-            }));
-          }
-        }
-      };
-
-      ws.onclose = () => {
-        isConnectingRef.current = false;
-        setIsConnected(false);
-        wsRef.current = null;
-
-        if (currentUserRef.current) {
-          reconnectTimeoutRef.current = setTimeout(() => {
-            connect();
-          }, 2000);
-        }
-      };
-
-      ws.onerror = (event) => {
-        console.error('[useChannels] Error:', event);
-      };
-
-      ws.onmessage = (event) => {
-        try {
-          const msg = JSON.parse(event.data);
-
-          switch (msg.type) {
-            case 'channel_joined':
-              if (msg.success) {
-                setChannels((prev) => {
-                  if (prev.includes(msg.channel)) return prev;
-                  return [...prev, msg.channel];
-                });
-              }
-              break;
-
-            case 'channel_left':
-              if (msg.success) {
-                setChannels((prev) => prev.filter((c) => c !== msg.channel));
-              }
-              break;
-
-            case 'channel_message': {
-              const channelMsg: ChannelMessage = {
-                id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
-                type: 'channel_message',
-                channel: msg.channel,
-                from: msg.from,
-                body: msg.body,
-                thread: msg.thread,
-                timestamp: msg.timestamp || new Date().toISOString(),
-              };
-              setMessages((prev) => {
-                const updated = [...prev, channelMsg];
-                return updated.slice(-MAX_MESSAGES);
-              });
-              onMessageRef.current?.(channelMsg);
-              break;
-            }
-
-            case 'direct_message': {
-              const dmMsg: ChannelMessage = {
-                id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
-                type: 'direct_message',
-                from: msg.from,
-                to: currentUserRef.current?.username,
-                body: msg.body,
-                thread: msg.thread,
-                timestamp: msg.timestamp || new Date().toISOString(),
-              };
-              setMessages((prev) => {
-                const updated = [...prev, dmMsg];
-                return updated.slice(-MAX_MESSAGES);
-              });
-              onMessageRef.current?.(dmMsg);
-              break;
-            }
-          }
-        } catch (e) {
-          console.error('[useChannels] Failed to parse message:', e);
-        }
-      };
-
-      wsRef.current = ws;
-    } catch (e) {
-      console.error('[useChannels] Failed to create WebSocket:', e);
-    }
-  }, [wsUrl]);
-
-  const disconnect = useCallback(() => {
-    if (reconnectTimeoutRef.current) {
-      clearTimeout(reconnectTimeoutRef.current);
-      reconnectTimeoutRef.current = null;
-    }
-
-    isConnectingRef.current = false;
-
-    if (wsRef.current) {
-      const ws = wsRef.current;
-      ws.onclose = null;
-      ws.onerror = null;
-
-      const user = currentUserRef.current;
-      if (ws.readyState === WebSocket.OPEN && user) {
-        ws.send(JSON.stringify({
-          type: 'presence',
-          action: 'leave',
-          username: user.username,
-        }));
-      }
-      ws.close();
-      wsRef.current = null;
-    }
-
-    setIsConnected(false);
-    setChannels([]);
-  }, []);
-
-  const joinChannel = useCallback((channel: string) => {
-    if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) return;
-
-    wsRef.current.send(JSON.stringify({
-      type: 'channel_join',
-      channel,
-    }));
-  }, []);
-
-  const leaveChannel = useCallback((channel: string) => {
-    if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) return;
-
-    wsRef.current.send(JSON.stringify({
-      type: 'channel_leave',
-      channel,
-    }));
-  }, []);
-
-  const sendChannelMessage = useCallback((channel: string, body: string, thread?: string) => {
-    if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) return;
-
-    wsRef.current.send(JSON.stringify({
-      type: 'channel_message',
-      channel,
-      body,
-      thread,
-    }));
-  }, []);
-
-  const sendDirectMessage = useCallback((to: string, body: string, thread?: string) => {
-    if (!wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) return;
-
-    wsRef.current.send(JSON.stringify({
-      type: 'direct_message',
-      to,
-      body,
-      thread,
-    }));
-  }, []);
-
-  // Connect when user is available
-  useEffect(() => {
-    if (!autoConnect || !currentUserRef.current) return;
-
-    if (wsRef.current && wsRef.current.readyState !== WebSocket.CLOSED) {
-      return;
-    }
-
-    connect();
-
-    return () => {
-      disconnect();
-    };
-  }, [autoConnect, currentUser?.username, workspaceId, connect, disconnect]);
-
-  // Send leave on page unload
-  useEffect(() => {
-    const handleUnload = () => {
-      const user = currentUserRef.current;
-      if (wsRef.current?.readyState === WebSocket.OPEN && user) {
-        wsRef.current.send(JSON.stringify({
-          type: 'presence',
-          action: 'leave',
-          username: user.username,
-        }));
-      }
-    };
-
-    window.addEventListener('beforeunload', handleUnload);
-    return () => window.removeEventListener('beforeunload', handleUnload);
-  }, []);
-
-  return {
-    channels,
-    joinChannel,
-    leaveChannel,
-    sendChannelMessage,
-    sendDirectMessage,
-    isConnected,
-    messages,
-  };
-}

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

@@ -1,29 +0,0 @@
-/**
- * useDebounce Hook
- *
- * Returns a debounced value that only updates after a delay.
- * Useful for search inputs and other rapid-change scenarios.
- */
-
-import { useState, useEffect } from 'react';
-
-/**
- * Debounce a value by a specified delay.
- * @param value - The value to debounce
- * @param delay - Delay in milliseconds (default: 300ms)
- */
-export function useDebounce<T>(value: T, delay: number = 300): T {
-  const [debouncedValue, setDebouncedValue] = useState(value);
-
-  useEffect(() => {
-    const handler = setTimeout(() => {
-      setDebouncedValue(value);
-    }, delay);
-
-    return () => {
-      clearTimeout(handler);
-    };
-  }, [value, delay]);
-
-  return debouncedValue;
-}

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

@@ -1,141 +0,0 @@
-/**
- * useDirectMessage Hook
- *
- * Handles DM conversation logic including agent participation,
- * message filtering, and deduplication.
- */
-
-import { useMemo } from 'react';
-import type { Agent, Message } from '../../types';
-
-export interface UseDirectMessageOptions {
-  currentHuman: Agent | null;
-  currentUserName: string | null;
-  messages: Message[];
-  agents: Agent[];
-  selectedDmAgents: string[];
-  removedDmAgents: string[];
-}
-
-export interface UseDirectMessageResult {
-  visibleMessages: Message[];
-  participantAgents: string[];
-}
-
-export function useDirectMessage({
-  currentHuman,
-  currentUserName,
-  messages,
-  agents,
-  selectedDmAgents,
-  removedDmAgents,
-}: UseDirectMessageOptions): UseDirectMessageResult {
-  const agentNameSet = useMemo(() => new Set(agents.map((a) => a.name)), [agents]);
-
-  // Derive agents participating in this conversation from message history
-  const dmParticipantAgents = useMemo(() => {
-    if (!currentHuman) return [];
-    const humanName = currentHuman.name;
-    const derived = new Set<string>();
-
-    for (const msg of messages) {
-      const { from, to } = msg;
-      if (!from || !to) continue;
-      if (from === humanName && agentNameSet.has(to)) derived.add(to);
-      if (to === humanName && agentNameSet.has(from)) derived.add(from);
-      if (selectedDmAgents.includes(from) && agentNameSet.has(to)) derived.add(to);
-      if (selectedDmAgents.includes(to) && agentNameSet.has(from)) derived.add(from);
-    }
-
-    const participants = new Set<string>([...selectedDmAgents, ...derived]);
-    removedDmAgents.forEach((a) => participants.delete(a));
-    return Array.from(participants);
-  }, [agentNameSet, currentHuman, messages, removedDmAgents, selectedDmAgents]);
-
-  // Filter messages for this DM conversation
-  const visibleMessages = useMemo(() => {
-    if (!currentHuman) return messages;
-    // Include current user, the other human, and all participant agents
-    const participants = new Set<string>([currentHuman.name, ...dmParticipantAgents]);
-    // Add current user to participants - use "Dashboard" as fallback for local mode
-    const effectiveUserName = currentUserName || 'Dashboard';
-    participants.add(effectiveUserName);
-
-    console.log('[DM Filter] currentHuman:', currentHuman.name, 'currentUser:', currentUserName, 'agents:', dmParticipantAgents, 'participants:', Array.from(participants));
-
-    const filtered = messages.filter((msg) => {
-      if (!msg.from || !msg.to) return false;
-      const hasFrom = participants.has(msg.from);
-      const hasTo = participants.has(msg.to);
-      const passes = hasFrom && hasTo;
-
-      if (msg.from?.includes('Agent') || msg.to?.includes('Agent')) {
-        console.log('[DM Filter] msg:', msg.from, '->', msg.to, 'hasFrom:', hasFrom, 'hasTo:', hasTo, 'passes:', passes);
-      }
-
-      return passes;
-    });
-
-    console.log('[DM Filter] filtered count:', filtered.length);
-    return filtered;
-  }, [currentHuman, currentUserName, dmParticipantAgents, messages]);
-
-  // Deduplicate DM messages (merge duplicates sent to multiple participants)
-  const dedupedVisibleMessages = useMemo(() => {
-    if (!currentHuman) return visibleMessages;
-
-    const normalizeBody = (content?: string) => (content ?? '').trim().replace(/\s+/g, ' ');
-    const rank = (msg: Message) => (msg.status === 'sending' ? 1 : 0);
-    const choose = (current: Message, incoming: Message) => {
-      const currentRank = rank(current);
-      const incomingRank = rank(incoming);
-      const currentTs = new Date(current.timestamp).getTime();
-      const incomingTs = new Date(incoming.timestamp).getTime();
-      if (incomingRank < currentRank) return incoming;
-      if (incomingRank > currentRank) return current;
-      return incomingTs >= currentTs ? incoming : current;
-    };
-
-    const sorted = [...visibleMessages].sort(
-      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-    );
-
-    const byId = new Map<string, Message>();
-    const byFuzzy = new Map<string, Message>();
-
-    for (const msg of sorted) {
-      if (msg.id) {
-        const existing = byId.get(msg.id);
-        byId.set(msg.id, existing ? choose(existing, msg) : msg);
-        continue;
-      }
-
-      const sender = msg.from?.toLowerCase() ?? '';
-      const bucket = Math.floor(new Date(msg.timestamp).getTime() / 5000);
-      const key = `${sender}|${bucket}|${normalizeBody(msg.content)}`;
-      const existing = byFuzzy.get(key);
-      byFuzzy.set(key, existing ? choose(existing, msg) : msg);
-    }
-
-    const merged = [...byId.values(), ...byFuzzy.values()];
-
-    // Final pass: deduplicate by sender + recipient + content (no time bucket)
-    const finalDedup = new Map<string, Message>();
-    for (const msg of merged) {
-      const sender = msg.from?.toLowerCase() ?? '';
-      const recipient = msg.to?.toLowerCase() ?? '';
-      const key = `${sender}|${recipient}|${normalizeBody(msg.content)}`;
-      const existing = finalDedup.get(key);
-      finalDedup.set(key, existing ? choose(existing, msg) : msg);
-    }
-
-    return Array.from(finalDedup.values()).sort(
-      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
-    );
-  }, [currentHuman, visibleMessages]);
-
-  return {
-    visibleMessages: dedupedVisibleMessages,
-    participantAgents: dmParticipantAgents,
-  };
-}