agent-relay 2.0.29 → 2.0.32

package/packages/api-types/src/schemas/fleet.ts

@@ -0,0 +1,83 @@
+/**
+ * Fleet Schemas
+ *
+ * Zod schemas for fleet/multi-server types used across the dashboard and API.
+ */
+
+import { z } from 'zod';
+import { AgentSchema } from './agent.js';
+
+/**
+ * Peer server status enum
+ */
+export const PeerServerStatusSchema = z.enum(['connected', 'disconnected', 'error']);
+export type PeerServerStatus = z.infer<typeof PeerServerStatusSchema>;
+
+/**
+ * Peer server schema - represents a connected server in the fleet
+ */
+export const PeerServerSchema = z.object({
+  id: z.string(),
+  url: z.string(),
+  name: z.string().optional(),
+  status: PeerServerStatusSchema,
+  agentCount: z.number(),
+  latency: z.number().optional(),
+});
+export type PeerServer = z.infer<typeof PeerServerSchema>;
+
+/**
+ * Fleet data schema - aggregate fleet information
+ */
+export const FleetDataSchema = z.object({
+  servers: z.array(PeerServerSchema),
+  agents: z.array(AgentSchema),
+  totalMessages: z.number(),
+});
+export type FleetData = z.infer<typeof FleetDataSchema>;
+
+/**
+ * Project schema - represents a project in the fleet
+ */
+export const ProjectSchema = z.object({
+  id: z.string(),
+  path: z.string(),
+  name: z.string().optional(),
+  agents: z.array(AgentSchema),
+  lead: z.object({
+    name: z.string(),
+    connected: z.boolean(),
+  }).optional(),
+});
+export type Project = z.infer<typeof ProjectSchema>;
+
+/**
+ * Fleet server schema (for /api/fleet/servers response)
+ */
+export const FleetServerSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  status: z.enum(['healthy', 'degraded', 'offline']),
+  agents: z.array(z.object({
+    name: z.string(),
+    status: z.string(),
+  })),
+  cpuUsage: z.number(),
+  memoryUsage: z.number(),
+  activeConnections: z.number(),
+  uptime: z.number(),
+  lastHeartbeat: z.string(),
+});
+export type FleetServer = z.infer<typeof FleetServerSchema>;
+
+/**
+ * Fleet stats schema (for /api/fleet/stats response)
+ */
+export const FleetStatsSchema = z.object({
+  totalAgents: z.number(),
+  onlineAgents: z.number(),
+  busyAgents: z.number(),
+  pendingDecisions: z.number(),
+  activeTasks: z.number(),
+});
+export type FleetStats = z.infer<typeof FleetStatsSchema>;

package/packages/api-types/src/schemas/history.test.ts

@@ -0,0 +1,242 @@
+/**
+ * History Schema Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  HistorySessionSchema,
+  HistoryMessageSchema,
+  ConversationSchema,
+  HistoryStatsSchema,
+  FileSearchResultSchema,
+  FileSearchResponseSchema,
+} from './history.js';
+
+describe('History Schemas', () => {
+  describe('HistorySessionSchema', () => {
+    it('should validate complete session', () => {
+      const session = {
+        id: 'session-001',
+        agentName: 'FullStack',
+        cli: 'claude',
+        startedAt: '2025-01-22T08:00:00Z',
+        endedAt: '2025-01-22T12:00:00Z',
+        duration: '4h 0m',
+        messageCount: 150,
+        summary: 'Implemented user authentication feature',
+        isActive: false,
+        closedBy: 'agent',
+      };
+      const result = HistorySessionSchema.parse(session);
+      expect(result.agentName).toBe('FullStack');
+      expect(result.closedBy).toBe('agent');
+      expect(result.messageCount).toBe(150);
+    });
+
+    it('should validate active session without endedAt', () => {
+      const session = {
+        id: 'session-002',
+        agentName: 'Worker',
+        startedAt: '2025-01-22T10:00:00Z',
+        duration: '1h 30m',
+        messageCount: 45,
+        isActive: true,
+      };
+      const result = HistorySessionSchema.parse(session);
+      expect(result.isActive).toBe(true);
+      expect(result.endedAt).toBeUndefined();
+      expect(result.closedBy).toBeUndefined();
+    });
+
+    it('should validate session closed by disconnect', () => {
+      const session = {
+        id: 'session-003',
+        agentName: 'Backend',
+        cli: 'codex',
+        startedAt: '2025-01-21T14:00:00Z',
+        endedAt: '2025-01-21T14:30:00Z',
+        duration: '30m',
+        messageCount: 20,
+        isActive: false,
+        closedBy: 'disconnect',
+      };
+      const result = HistorySessionSchema.parse(session);
+      expect(result.closedBy).toBe('disconnect');
+    });
+
+    it('should validate session closed by error', () => {
+      const session = {
+        id: 'session-004',
+        agentName: 'Frontend',
+        startedAt: '2025-01-21T10:00:00Z',
+        endedAt: '2025-01-21T10:05:00Z',
+        duration: '5m',
+        messageCount: 3,
+        isActive: false,
+        closedBy: 'error',
+      };
+      const result = HistorySessionSchema.parse(session);
+      expect(result.closedBy).toBe('error');
+    });
+  });
+
+  describe('HistoryMessageSchema', () => {
+    it('should validate complete message', () => {
+      const message = {
+        id: 'msg-001',
+        from: 'Lead',
+        to: 'FullStack',
+        content: 'Please implement the user authentication',
+        timestamp: '2025-01-22T08:30:00Z',
+        thread: 'auth-implementation',
+        isBroadcast: false,
+        isUrgent: true,
+        status: 'delivered',
+        data: { priority: 'high' },
+      };
+      const result = HistoryMessageSchema.parse(message);
+      expect(result.from).toBe('Lead');
+      expect(result.isUrgent).toBe(true);
+    });
+
+    it('should validate broadcast message', () => {
+      const message = {
+        id: 'msg-002',
+        from: 'Lead',
+        to: '*',
+        content: 'Team standup in 5 minutes',
+        timestamp: '2025-01-22T09:55:00Z',
+        isBroadcast: true,
+      };
+      const result = HistoryMessageSchema.parse(message);
+      expect(result.to).toBe('*');
+      expect(result.isBroadcast).toBe(true);
+    });
+
+    it('should validate minimal message', () => {
+      const message = {
+        id: 'msg-003',
+        from: 'Worker',
+        to: 'Lead',
+        content: 'Task completed',
+        timestamp: '2025-01-22T11:00:00Z',
+      };
+      const result = HistoryMessageSchema.parse(message);
+      expect(result.thread).toBeUndefined();
+      expect(result.isBroadcast).toBeUndefined();
+    });
+  });
+
+  describe('ConversationSchema', () => {
+    it('should validate conversation between two agents', () => {
+      const conversation = {
+        participants: ['Lead', 'FullStack'],
+        lastMessage: 'Thanks for the update!',
+        lastTimestamp: '2025-01-22T11:30:00Z',
+        messageCount: 25,
+      };
+      const result = ConversationSchema.parse(conversation);
+      expect(result.participants).toHaveLength(2);
+      expect(result.messageCount).toBe(25);
+    });
+
+    it('should validate group conversation', () => {
+      const conversation = {
+        participants: ['Lead', 'FullStack', 'Backend', 'Frontend'],
+        lastMessage: 'Let us sync tomorrow',
+        lastTimestamp: '2025-01-22T17:00:00Z',
+        messageCount: 150,
+      };
+      const result = ConversationSchema.parse(conversation);
+      expect(result.participants).toHaveLength(4);
+    });
+  });
+
+  describe('HistoryStatsSchema', () => {
+    it('should validate stats with numbers', () => {
+      const stats = {
+        messageCount: 1500,
+        sessionCount: 45,
+        activeSessions: 3,
+        uniqueAgents: 8,
+        oldestMessageDate: '2025-01-01T00:00:00Z',
+      };
+      const result = HistoryStatsSchema.parse(stats);
+      expect(result.messageCount).toBe(1500);
+      expect(result.uniqueAgents).toBe(8);
+    });
+
+    it('should validate stats with string values (from DB)', () => {
+      const stats = {
+        messageCount: '1500',
+        sessionCount: '45',
+        activeSessions: '3',
+        uniqueAgents: '8',
+        oldestMessageDate: '2025-01-01T00:00:00Z',
+      };
+      const result = HistoryStatsSchema.parse(stats);
+      expect(result.messageCount).toBe('1500');
+    });
+
+    it('should validate stats without oldest date', () => {
+      const stats = {
+        messageCount: 0,
+        sessionCount: 0,
+        activeSessions: 0,
+        uniqueAgents: 0,
+        oldestMessageDate: null,
+      };
+      const result = HistoryStatsSchema.parse(stats);
+      expect(result.oldestMessageDate).toBeNull();
+    });
+  });
+
+  describe('FileSearchResultSchema', () => {
+    it('should validate file result', () => {
+      const result = {
+        path: '/workspace/src/index.ts',
+        name: 'index.ts',
+        isDirectory: false,
+      };
+      const parsed = FileSearchResultSchema.parse(result);
+      expect(parsed.name).toBe('index.ts');
+      expect(parsed.isDirectory).toBe(false);
+    });
+
+    it('should validate directory result', () => {
+      const result = {
+        path: '/workspace/src',
+        name: 'src',
+        isDirectory: true,
+      };
+      const parsed = FileSearchResultSchema.parse(result);
+      expect(parsed.isDirectory).toBe(true);
+    });
+  });
+
+  describe('FileSearchResponseSchema', () => {
+    it('should validate search response with results', () => {
+      const response = {
+        files: [
+          { path: '/workspace/src/index.ts', name: 'index.ts', isDirectory: false },
+          { path: '/workspace/src/utils.ts', name: 'utils.ts', isDirectory: false },
+        ],
+        query: '*.ts',
+        searchRoot: '/workspace/src',
+      };
+      const result = FileSearchResponseSchema.parse(response);
+      expect(result.files).toHaveLength(2);
+      expect(result.query).toBe('*.ts');
+    });
+
+    it('should validate empty search response', () => {
+      const response = {
+        files: [],
+        query: '*.xyz',
+        searchRoot: '/workspace',
+      };
+      const result = FileSearchResponseSchema.parse(response);
+      expect(result.files).toHaveLength(0);
+    });
+  });
+});

package/packages/api-types/src/schemas/history.ts

@@ -0,0 +1,84 @@
+/**
+ * History Schemas
+ *
+ * Zod schemas for conversation history types used across the dashboard and API.
+ */
+
+import { z } from 'zod';
+
+/**
+ * History session schema
+ */
+export const HistorySessionSchema = z.object({
+  id: z.string(),
+  agentName: z.string(),
+  cli: z.string().optional(),
+  startedAt: z.string(),
+  endedAt: z.string().optional(),
+  duration: z.string(),
+  messageCount: z.number(),
+  summary: z.string().optional(),
+  isActive: z.boolean(),
+  closedBy: z.enum(['agent', 'disconnect', 'error']).optional(),
+});
+export type HistorySession = z.infer<typeof HistorySessionSchema>;
+
+/**
+ * History message schema
+ */
+export const HistoryMessageSchema = z.object({
+  id: z.string(),
+  from: z.string(),
+  to: z.string(),
+  content: z.string(),
+  timestamp: z.string(),
+  thread: z.string().optional(),
+  isBroadcast: z.boolean().optional(),
+  isUrgent: z.boolean().optional(),
+  status: z.string().optional(),
+  data: z.record(z.unknown()).optional(),
+});
+export type HistoryMessage = z.infer<typeof HistoryMessageSchema>;
+
+/**
+ * Conversation schema (unique agent pairs)
+ */
+export const ConversationSchema = z.object({
+  participants: z.array(z.string()),
+  lastMessage: z.string(),
+  lastTimestamp: z.string(),
+  messageCount: z.number(),
+});
+export type Conversation = z.infer<typeof ConversationSchema>;
+
+/**
+ * History stats schema
+ */
+export const HistoryStatsSchema = z.object({
+  messageCount: z.union([z.number(), z.string()]),
+  sessionCount: z.union([z.number(), z.string()]),
+  activeSessions: z.union([z.number(), z.string()]),
+  uniqueAgents: z.union([z.number(), z.string()]),
+  oldestMessageDate: z.string().nullable().optional(),
+});
+export type HistoryStats = z.infer<typeof HistoryStatsSchema>;
+
+/**
+ * File search result schema
+ */
+export const FileSearchResultSchema = z.object({
+  path: z.string(),
+  name: z.string(),
+  isDirectory: z.boolean(),
+});
+export type FileSearchResult = z.infer<typeof FileSearchResultSchema>;
+
+/**
+ * File search response schema
+ */
+export const FileSearchResponseSchema = z.object({
+  files: z.array(FileSearchResultSchema),
+  query: z.string(),
+  searchRoot: z.string(),
+});
+export type FileSearchResponse = z.infer<typeof FileSearchResponseSchema>;

package/packages/api-types/src/schemas/index.ts

@@ -0,0 +1,148 @@
+/**
+ * Schema Exports
+ *
+ * Re-exports all Zod schemas and their inferred types.
+ */
+
+// Agent schemas
+export {
+  AgentStatusSchema,
+  AgentProfileSchema,
+  AgentSchema,
+  AgentSummarySchema,
+  type AgentStatus,
+  type AgentProfile,
+  type Agent,
+  type AgentSummary,
+} from './agent.js';
+
+// Message schemas
+export {
+  MessageStatusSchema,
+  AttachmentSchema,
+  ThreadMetadataSchema,
+  MessageSchema,
+  ThreadSchema,
+  type MessageStatus,
+  type Attachment,
+  type ThreadMetadata,
+  type Message,
+  type Thread,
+} from './message.js';
+
+// Session schemas
+export {
+  SessionClosedBySchema,
+  SessionSchema,
+  type SessionClosedBy,
+  type Session,
+} from './session.js';
+
+// Fleet schemas
+export {
+  PeerServerStatusSchema,
+  PeerServerSchema,
+  FleetDataSchema,
+  ProjectSchema,
+  FleetServerSchema,
+  FleetStatsSchema,
+  type PeerServerStatus,
+  type PeerServer,
+  type FleetData,
+  type Project,
+  type FleetServer,
+  type FleetStats,
+} from './fleet.js';
+
+// Task schemas
+export {
+  TaskStatusSchema,
+  TaskPrioritySchema,
+  TaskTypeSchema,
+  TaskSchema,
+  TaskAssignmentStatusSchema,
+  TaskAssignmentPrioritySchema,
+  TaskAssignmentSchema,
+  type TaskStatus,
+  type TaskPriority,
+  type TaskType,
+  type Task,
+  type TaskAssignmentStatus,
+  type TaskAssignmentPriority,
+  type TaskAssignment,
+} from './task.js';
+
+// Decision schemas
+export {
+  DecisionUrgencySchema,
+  DecisionCategorySchema,
+  DecisionOptionSchema,
+  ApiDecisionSchema,
+  DecisionSchema,
+  PendingDecisionSchema,
+  TrajectoryDecisionTypeSchema,
+  TrajectoryDecisionOutcomeSchema,
+  TrajectoryDecisionSchema,
+  TrajectorySchema,
+  type DecisionUrgency,
+  type DecisionCategory,
+  type DecisionOption,
+  type ApiDecision,
+  type Decision,
+  type PendingDecision,
+  type TrajectoryDecisionType,
+  type TrajectoryDecisionOutcome,
+  type TrajectoryDecision,
+  type Trajectory,
+} from './decision.js';
+
+// API request/response schemas
+export {
+  ApiResponseSchema,
+  SimpleApiResponseSchema,
+  SendMessageRequestSchema,
+  SpeakOnTriggerSchema,
+  ShadowModeSchema,
+  SpawnAgentRequestSchema,
+  SpawnAgentResponseSchema,
+  CreateTaskRequestSchema,
+  CreateBeadRequestSchema,
+  SendRelayMessageRequestSchema,
+  ActivityEventTypeSchema,
+  ActorTypeSchema,
+  ActivityEventSchema,
+  WSMessageTypeSchema,
+  WSMessageSchema,
+  DashboardStateSchema,
+  type SimpleApiResponse,
+  type SendMessageRequest,
+  type SpeakOnTrigger,
+  type ShadowMode,
+  type SpawnAgentRequest,
+  type SpawnAgentResponse,
+  type CreateTaskRequest,
+  type CreateBeadRequest,
+  type SendRelayMessageRequest,
+  type ActivityEventType,
+  type ActorType,
+  type ActivityEvent,
+  type WSMessageType,
+  type WSMessage,
+  type DashboardState,
+} from './api.js';
+
+// History schemas
+export {
+  HistorySessionSchema,
+  HistoryMessageSchema,
+  ConversationSchema,
+  HistoryStatsSchema,
+  FileSearchResultSchema,
+  FileSearchResponseSchema,
+  type HistorySession,
+  type HistoryMessage,
+  type Conversation,
+  type HistoryStats,
+  type FileSearchResult,
+  type FileSearchResponse,
+} from './history.js';