agent-relay 2.0.21 → 2.0.23

package/packages/dashboard/ui/lib/colors.ts

@@ -1,218 +0,0 @@
-/**
- * Hierarchical Color Coding System
- *
- * Inspired by AI Maestro's naming convention:
- * - Agent names use hyphens to denote hierarchy: project-category-agent
- * - Each top-level prefix gets a consistent color
- * - Colors are visually distinct and accessible
- */
-
-export interface ColorScheme {
-  primary: string;
-  light: string;
-  dark: string;
-  text: string;
-}
-
-// Predefined color schemes for common agent prefixes
-const PREFIX_COLORS: Record<string, ColorScheme> = {
-  backend: {
-    primary: '#1264a3',
-    light: '#e8f4fd',
-    dark: '#0d4f82',
-    text: '#ffffff',
-  },
-  frontend: {
-    primary: '#7c3aed',
-    light: '#f3e8ff',
-    dark: '#5b21b6',
-    text: '#ffffff',
-  },
-  infra: {
-    primary: '#ea580c',
-    light: '#fff7ed',
-    dark: '#c2410c',
-    text: '#ffffff',
-  },
-  lead: {
-    primary: '#2bac76',
-    light: '#ecfdf5',
-    dark: '#059669',
-    text: '#ffffff',
-  },
-  test: {
-    primary: '#0d9488',
-    light: '#f0fdfa',
-    dark: '#0f766e',
-    text: '#ffffff',
-  },
-  data: {
-    primary: '#dc2626',
-    light: '#fef2f2',
-    dark: '#b91c1c',
-    text: '#ffffff',
-  },
-  api: {
-    primary: '#2563eb',
-    light: '#eff6ff',
-    dark: '#1d4ed8',
-    text: '#ffffff',
-  },
-  worker: {
-    primary: '#9333ea',
-    light: '#faf5ff',
-    dark: '#7e22ce',
-    text: '#ffffff',
-  },
-  monitor: {
-    primary: '#0891b2',
-    light: '#ecfeff',
-    dark: '#0e7490',
-    text: '#ffffff',
-  },
-  security: {
-    primary: '#be123c',
-    light: '#fff1f2',
-    dark: '#9f1239',
-    text: '#ffffff',
-  },
-};
-
-// Fallback colors for unknown prefixes (generated from name hash)
-const FALLBACK_COLORS: ColorScheme[] = [
-  { primary: '#6366f1', light: '#eef2ff', dark: '#4f46e5', text: '#ffffff' },
-  { primary: '#ec4899', light: '#fdf2f8', dark: '#db2777', text: '#ffffff' },
-  { primary: '#14b8a6', light: '#f0fdfa', dark: '#0d9488', text: '#ffffff' },
-  { primary: '#f59e0b', light: '#fffbeb', dark: '#d97706', text: '#000000' },
-  { primary: '#8b5cf6', light: '#f5f3ff', dark: '#7c3aed', text: '#ffffff' },
-  { primary: '#06b6d4', light: '#ecfeff', dark: '#0891b2', text: '#ffffff' },
-  { primary: '#f43f5e', light: '#fff1f2', dark: '#e11d48', text: '#ffffff' },
-  { primary: '#84cc16', light: '#f7fee7', dark: '#65a30d', text: '#000000' },
-];
-
-// Status colors
-export const STATUS_COLORS = {
-  online: '#22c55e',      // Green
-  offline: '#6b7280',     // Gray
-  busy: '#eab308',        // Yellow
-  processing: '#6366f1',  // Indigo (thinking/processing)
-  error: '#ef4444',       // Red
-  attention: '#ef4444',   // Red (for badge)
-  stuck: '#f97316',       // Orange (received message but no response)
-} as const;
-
-export type AgentStatus = keyof typeof STATUS_COLORS;
-
-/**
- * Parse agent name into hierarchy levels
- * e.g., "backend-api-auth" => ["backend", "api", "auth"]
- */
-export function parseAgentHierarchy(name: string): string[] {
-  return name.toLowerCase().split('-').filter(Boolean);
-}
-
-/**
- * Get the top-level prefix from an agent name
- * e.g., "backend-api-auth" => "backend"
- */
-export function getAgentPrefix(name: string): string {
-  const parts = parseAgentHierarchy(name);
-  return parts[0] || name.toLowerCase();
-}
-
-/**
- * Generate a hash code from a string for consistent color assignment
- */
-function hashCode(str: string): number {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = ((hash << 5) - hash) + char;
-    hash = hash & hash; // Convert to 32bit integer
-  }
-  return Math.abs(hash);
-}
-
-/**
- * Get color scheme for an agent based on its name
- * Uses prefix matching first, falls back to hash-based color
- */
-export function getAgentColor(name: string): ColorScheme {
-  const prefix = getAgentPrefix(name);
-
-  // Check for predefined prefix color
-  if (prefix in PREFIX_COLORS) {
-    return PREFIX_COLORS[prefix];
-  }
-
-  // Fall back to hash-based color for consistency
-  const hash = hashCode(prefix);
-  return FALLBACK_COLORS[hash % FALLBACK_COLORS.length];
-}
-
-/**
- * Get CSS custom properties for an agent's color scheme
- * Useful for inline styles or CSS variables
- */
-export function getAgentColorVars(name: string): Record<string, string> {
-  const colors = getAgentColor(name);
-  return {
-    '--agent-primary': colors.primary,
-    '--agent-light': colors.light,
-    '--agent-dark': colors.dark,
-    '--agent-text': colors.text,
-  };
-}
-
-/**
- * Get initials from agent name (first 2 chars of first segment)
- */
-export function getAgentInitials(name: string): string {
-  const parts = parseAgentHierarchy(name);
-  if (parts.length === 0) return name.substring(0, 2).toUpperCase();
-
-  // Use first letter of first two segments, or first two letters of first segment
-  if (parts.length >= 2) {
-    return (parts[0][0] + parts[1][0]).toUpperCase();
-  }
-  return parts[0].substring(0, 2).toUpperCase();
-}
-
-/**
- * Group agents by their top-level prefix
- */
-export function groupAgentsByPrefix<T extends { name: string }>(
-  agents: T[]
-): Map<string, T[]> {
-  const groups = new Map<string, T[]>();
-
-  for (const agent of agents) {
-    const prefix = getAgentPrefix(agent.name);
-    const group = groups.get(prefix) || [];
-    group.push(agent);
-    groups.set(prefix, group);
-  }
-
-  return groups;
-}
-
-/**
- * Sort agents by hierarchy for display
- * Groups by prefix, then sorts alphabetically within groups
- */
-export function sortAgentsByHierarchy<T extends { name: string }>(
-  agents: T[]
-): T[] {
-  return [...agents].sort((a, b) => {
-    const prefixA = getAgentPrefix(a.name);
-    const prefixB = getAgentPrefix(b.name);
-
-    // Sort by prefix first
-    if (prefixA !== prefixB) {
-      return prefixA.localeCompare(prefixB);
-    }
-
-    // Then by full name
-    return a.name.localeCompare(b.name);
-  });
-}

package/packages/dashboard/ui/lib/hierarchy.ts

@@ -1,242 +0,0 @@
-/**
- * Agent Hierarchy Utilities
- *
- * Helpers for parsing, displaying, and organizing agents
- * based on their hierarchical naming convention.
- */
-
-import type { Agent } from '../types';
-import { getAgentPrefix, getAgentColor, type ColorScheme } from './colors';
-
-export interface HierarchyNode {
-  name: string;
-  level: number;
-  fullPath: string;
-  children: HierarchyNode[];
-  agent?: Agent;
-  color: ColorScheme;
-}
-
-export interface AgentGroup {
-  prefix: string;
-  displayName: string;
-  color: ColorScheme;
-  agents: Agent[];
-  isExpanded: boolean;
-}
-
-/**
- * Build a tree structure from a list of agents
- * e.g., ["backend-api", "backend-db", "frontend-ui"]
- * becomes a tree with "backend" and "frontend" as roots
- */
-export function buildAgentTree(agents: Agent[]): HierarchyNode[] {
-  const roots: Map<string, HierarchyNode> = new Map();
-
-  for (const agent of agents) {
-    const parts = agent.name.toLowerCase().split('-').filter(Boolean);
-    if (parts.length === 0) continue;
-
-    const prefix = parts[0];
-    const color = getAgentColor(agent.name);
-
-    // Get or create root node
-    let root = roots.get(prefix);
-    if (!root) {
-      root = {
-        name: prefix,
-        level: 0,
-        fullPath: prefix,
-        children: [],
-        color,
-      };
-      roots.set(prefix, root);
-    }
-
-    // For single-segment names, attach agent to root
-    if (parts.length === 1) {
-      root.agent = agent;
-      continue;
-    }
-
-    // Build path for multi-segment names
-    let current = root;
-    for (let i = 1; i < parts.length; i++) {
-      const part = parts[i];
-      const fullPath = parts.slice(0, i + 1).join('-');
-
-      let child = current.children.find((c) => c.name === part);
-      if (!child) {
-        child = {
-          name: part,
-          level: i,
-          fullPath,
-          children: [],
-          color,
-        };
-        current.children.push(child);
-      }
-
-      // Attach agent to leaf node
-      if (i === parts.length - 1) {
-        child.agent = agent;
-      }
-
-      current = child;
-    }
-  }
-
-  // Sort roots alphabetically
-  return Array.from(roots.values()).sort((a, b) =>
-    a.name.localeCompare(b.name)
-  );
-}
-
-/**
- * Flatten a hierarchy tree for list display
- * Returns nodes in depth-first order with indentation level
- */
-export function flattenTree(
-  nodes: HierarchyNode[],
-  depth = 0
-): Array<{ node: HierarchyNode; depth: number }> {
-  const result: Array<{ node: HierarchyNode; depth: number }> = [];
-
-  for (const node of nodes) {
-    result.push({ node, depth });
-
-    if (node.children.length > 0) {
-      result.push(...flattenTree(node.children, depth + 1));
-    }
-  }
-
-  return result;
-}
-
-/**
- * Group agents by their team (if set) or prefix for simpler grouped display.
- * User-defined teams take priority over auto-extracted prefixes.
- */
-export function groupAgents(agents: Agent[]): AgentGroup[] {
-  const groups: Map<string, AgentGroup> = new Map();
-
-  for (const agent of agents) {
-    // Use team if set, otherwise fall back to prefix from name
-    const groupKey = agent.team || getAgentPrefix(agent.name);
-    const color = getAgentColor(agent.name);
-
-    let group = groups.get(groupKey);
-    if (!group) {
-      group = {
-        prefix: groupKey,
-        displayName: capitalizeFirst(groupKey),
-        color,
-        agents: [],
-        isExpanded: true,
-      };
-      groups.set(groupKey, group);
-    }
-
-    group.agents.push(agent);
-  }
-
-  // Sort groups and agents within groups
-  const sortedGroups = Array.from(groups.values()).sort((a, b) =>
-    a.prefix.localeCompare(b.prefix)
-  );
-
-  for (const group of sortedGroups) {
-    group.agents.sort((a, b) => a.name.localeCompare(b.name));
-  }
-
-  return sortedGroups;
-}
-
-/**
- * Get display name for an agent (last segment, capitalized)
- * e.g., "backend-api-auth" => "Auth"
- */
-export function getAgentDisplayName(name: string): string {
-  const parts = name.split('-').filter(Boolean);
-  if (parts.length === 0) return name;
-
-  const lastPart = parts[parts.length - 1];
-  return capitalizeFirst(lastPart);
-}
-
-/**
- * Get full display path for an agent
- * e.g., "backend-api-auth" => "Backend > API > Auth"
- */
-export function getAgentBreadcrumb(name: string): string {
-  const parts = name.split('-').filter(Boolean);
-  return parts.map(capitalizeFirst).join(' > ');
-}
-
-/**
- * Check if an agent name matches a search query
- * Matches against all hierarchy segments
- */
-export function matchesSearch(agentName: string, query: string): boolean {
-  if (!query) return true;
-
-  const lowerQuery = query.toLowerCase();
-  const lowerName = agentName.toLowerCase();
-
-  // Direct match
-  if (lowerName.includes(lowerQuery)) return true;
-
-  // Match any segment
-  const parts = lowerName.split('-');
-  return parts.some((part) => part.includes(lowerQuery));
-}
-
-/**
- * Filter agents by search query
- */
-export function filterAgents(agents: Agent[], query: string): Agent[] {
-  if (!query) return agents;
-  return agents.filter((agent) => matchesSearch(agent.name, query));
-}
-
-/**
- * Sort agents by their hierarchical name for consistent display
- */
-export function sortAgentsByHierarchy(agents: Agent[]): Agent[] {
-  return [...agents].sort((a, b) => a.name.localeCompare(b.name));
-}
-
-/**
- * Capitalize first letter of a string
- */
-function capitalizeFirst(str: string): string {
-  if (!str) return str;
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-/**
- * Get statistics for a group of agents
- */
-export function getGroupStats(agents: Agent[]): {
-  total: number;
-  online: number;
-  offline: number;
-  needsAttention: number;
-} {
-  let online = 0;
-  let offline = 0;
-  let needsAttention = 0;
-
-  for (const agent of agents) {
-    if (agent.status === 'online') online++;
-    else if (agent.status === 'offline') offline++;
-    if (agent.needsAttention) needsAttention++;
-  }
-
-  return {
-    total: agents.length,
-    online,
-    offline,
-    needsAttention,
-  };
-}

package/packages/dashboard/ui/lib/stuckDetection.ts

@@ -1,142 +0,0 @@
-/**
- * Stuck Agent Detection
- *
- * Detects when an agent has received a message but hasn't responded
- * within a configurable threshold. This helps surface when agents
- * are blocked or crashed mid-response.
- */
-
-import type { Agent } from '../types';
-
-/** Default threshold in milliseconds (5 minutes) */
-export const DEFAULT_STUCK_THRESHOLD_MS = 5 * 60 * 1000;
-
-export interface StuckDetectionOptions {
-  /** Threshold in milliseconds before considering an agent stuck */
-  thresholdMs?: number;
-}
-
-/**
- * Check if an agent is stuck (received message but no output within threshold)
- *
- * An agent is considered stuck when:
- * 1. It has received a message (lastMessageReceivedAt is set)
- * 2. It hasn't produced output since receiving that message
- *    (lastOutputAt < lastMessageReceivedAt or lastOutputAt is not set)
- * 3. The time since receiving the message exceeds the threshold
- *
- * @param agent - The agent to check
- * @param options - Detection options
- * @returns true if the agent is stuck
- */
-export function isAgentStuck(
-  agent: Agent,
-  options: StuckDetectionOptions = {}
-): boolean {
-  const { thresholdMs = DEFAULT_STUCK_THRESHOLD_MS } = options;
-  const now = Date.now();
-
-  // No message received, can't be stuck waiting for response
-  if (!agent.lastMessageReceivedAt) {
-    return false;
-  }
-
-  // Agent has output after receiving the message - not stuck
-  if (agent.lastOutputAt && agent.lastOutputAt >= agent.lastMessageReceivedAt) {
-    return false;
-  }
-
-  // Check if threshold has been exceeded
-  const timeSinceMessage = now - agent.lastMessageReceivedAt;
-  return timeSinceMessage > thresholdMs;
-}
-
-/**
- * Calculate how long an agent has been stuck (in milliseconds)
- *
- * @param agent - The agent to check
- * @returns Time stuck in ms, or 0 if not stuck
- */
-export function getStuckDuration(agent: Agent): number {
-  if (!agent.lastMessageReceivedAt) {
-    return 0;
-  }
-
-  // Has output after message - not stuck
-  if (agent.lastOutputAt && agent.lastOutputAt >= agent.lastMessageReceivedAt) {
-    return 0;
-  }
-
-  return Date.now() - agent.lastMessageReceivedAt;
-}
-
-/**
- * Format stuck duration for display
- *
- * @param durationMs - Duration in milliseconds
- * @returns Human-readable string like "5m" or "1h 30m"
- */
-export function formatStuckDuration(durationMs: number): string {
-  if (durationMs < 60000) {
-    return '<1m';
-  }
-
-  const minutes = Math.floor(durationMs / 60000);
-  if (minutes < 60) {
-    return `${minutes}m`;
-  }
-
-  const hours = Math.floor(minutes / 60);
-  const remainingMinutes = minutes % 60;
-
-  if (remainingMinutes === 0) {
-    return `${hours}h`;
-  }
-
-  return `${hours}h ${remainingMinutes}m`;
-}
-
-/**
- * Enrich agents with stuck detection status
- *
- * @param agents - Array of agents to process
- * @param options - Detection options
- * @returns Agents with isStuck field computed
- */
-export function enrichAgentsWithStuckStatus(
-  agents: Agent[],
-  options: StuckDetectionOptions = {}
-): Agent[] {
-  return agents.map((agent) => ({
-    ...agent,
-    isStuck: isAgentStuck(agent, options),
-  }));
-}
-
-/**
- * Get agents that are currently stuck
- *
- * @param agents - Array of agents to filter
- * @param options - Detection options
- * @returns Only the stuck agents
- */
-export function getStuckAgents(
-  agents: Agent[],
-  options: StuckDetectionOptions = {}
-): Agent[] {
-  return agents.filter((agent) => isAgentStuck(agent, options));
-}
-
-/**
- * Get stuck agent count
- *
- * @param agents - Array of agents to check
- * @param options - Detection options
- * @returns Number of stuck agents
- */
-export function getStuckCount(
-  agents: Agent[],
-  options: StuckDetectionOptions = {}
-): number {
-  return agents.filter((agent) => isAgentStuck(agent, options)).length;
-}

package/packages/dashboard/ui/next-env.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="next" />
-/// <reference types="next/image-types/global" />
-
-// NOTE: This file should not be edited
-// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.

package/packages/dashboard/ui/next.config.js

@@ -1,41 +0,0 @@
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  // Static export - generates HTML/JS/CSS that can be served by any server
-  output: 'export',
-  // Export output goes to 'out/' by default with output: 'export'
-
-  // Disable strict mode for now during development
-  reactStrictMode: true,
-
-  // V2 is now the default dashboard at root path
-  // Legacy v1 dashboard is available at /v1
-
-  // Proxy API requests to the dashboard server (port 3889 in dev)
-  async rewrites() {
-    return [
-      {
-        source: '/api/:path*',
-        destination: 'http://localhost:3889/api/:path*',
-      },
-      {
-        source: '/ws',
-        destination: 'http://localhost:3889/ws',
-      },
-    ];
-  },
-
-  // Webpack configuration for WebSocket support
-  webpack: (config, { isServer }) => {
-    if (!isServer) {
-      config.resolve.fallback = {
-        ...config.resolve.fallback,
-        net: false,
-        tls: false,
-        fs: false,
-      };
-    }
-    return config;
-  },
-};
-
-module.exports = nextConfig;