agent-relay 2.0.29 → 2.0.32

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

@@ -0,0 +1,192 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import {
+  MessageStatusSchema,
+  AttachmentSchema,
+  MessageSchema,
+  ThreadSchema,
+  type Message,
+  type Attachment,
+  type Thread,
+} from './message.js';
+
+describe('MessageStatusSchema', () => {
+  it('accepts valid status values', () => {
+    expect(MessageStatusSchema.parse('unread')).toBe('unread');
+    expect(MessageStatusSchema.parse('read')).toBe('read');
+    expect(MessageStatusSchema.parse('acked')).toBe('acked');
+    expect(MessageStatusSchema.parse('sending')).toBe('sending');
+    expect(MessageStatusSchema.parse('failed')).toBe('failed');
+  });
+
+  it('rejects invalid status values', () => {
+    expect(() => MessageStatusSchema.parse('pending')).toThrow();
+    expect(() => MessageStatusSchema.parse('')).toThrow();
+  });
+});
+
+describe('AttachmentSchema', () => {
+  it('accepts valid attachment', () => {
+    const attachment: Attachment = {
+      id: 'att-123',
+      filename: 'screenshot.png',
+      mimeType: 'image/png',
+      size: 1024,
+      url: 'https://example.com/att-123',
+    };
+    const result = AttachmentSchema.parse(attachment);
+    expect(result).toEqual(attachment);
+  });
+
+  it('accepts attachment with all optional fields', () => {
+    const attachment: Attachment = {
+      id: 'att-123',
+      filename: 'image.jpg',
+      mimeType: 'image/jpeg',
+      size: 2048,
+      url: 'https://example.com/image.jpg',
+      filePath: '/tmp/uploads/image.jpg',
+      width: 800,
+      height: 600,
+      data: 'base64data...',
+    };
+    const result = AttachmentSchema.parse(attachment);
+    expect(result.filePath).toBe('/tmp/uploads/image.jpg');
+    expect(result.width).toBe(800);
+    expect(result.height).toBe(600);
+    expect(result.data).toBe('base64data...');
+  });
+
+  it('rejects attachment without required fields', () => {
+    expect(() =>
+      AttachmentSchema.parse({ id: 'att-123', filename: 'test.png' })
+    ).toThrow();
+  });
+});
+
+describe('MessageSchema', () => {
+  it('accepts minimal valid message', () => {
+    const message: Message = {
+      id: 'msg-123',
+      from: 'Agent1',
+      to: 'Agent2',
+      content: 'Hello!',
+      timestamp: '2024-01-01T00:00:00Z',
+    };
+    const result = MessageSchema.parse(message);
+    expect(result).toEqual(message);
+  });
+
+  it('accepts message with all optional fields', () => {
+    const message: Message = {
+      id: 'msg-123',
+      from: 'Agent1',
+      to: 'Agent2',
+      content: 'Hello with thread!',
+      timestamp: '2024-01-01T00:00:00Z',
+      thread: 'thread-456',
+      isBroadcast: false,
+      isRead: true,
+      replyCount: 5,
+      threadSummary: {
+        id: 'thread-456',
+        rootMessage: 'Original message',
+        participantCount: 3,
+        messageCount: 10,
+        lastActivityAt: '2024-01-02T00:00:00Z',
+      },
+      status: 'acked',
+      attachments: [
+        {
+          id: 'att-1',
+          filename: 'file.pdf',
+          mimeType: 'application/pdf',
+          size: 1024,
+          url: 'https://example.com/file.pdf',
+        },
+      ],
+      channel: 'general',
+    };
+    const result = MessageSchema.parse(message);
+    expect(result.thread).toBe('thread-456');
+    expect(result.status).toBe('acked');
+    expect(result.attachments).toHaveLength(1);
+  });
+
+  it('rejects message without required id', () => {
+    expect(() =>
+      MessageSchema.parse({
+        from: 'A',
+        to: 'B',
+        content: 'test',
+        timestamp: '2024-01-01',
+      })
+    ).toThrow();
+  });
+
+  it('rejects message without required from', () => {
+    expect(() =>
+      MessageSchema.parse({
+        id: '1',
+        to: 'B',
+        content: 'test',
+        timestamp: '2024-01-01',
+      })
+    ).toThrow();
+  });
+});
+
+describe('ThreadSchema', () => {
+  it('accepts valid thread', () => {
+    const thread: Thread = {
+      id: 'thread-123',
+      messages: [
+        {
+          id: 'msg-1',
+          from: 'A',
+          to: 'B',
+          content: 'First',
+          timestamp: '2024-01-01T00:00:00Z',
+        },
+        {
+          id: 'msg-2',
+          from: 'B',
+          to: 'A',
+          content: 'Reply',
+          timestamp: '2024-01-01T00:01:00Z',
+        },
+      ],
+      participants: ['A', 'B'],
+      lastActivity: '2024-01-01T00:01:00Z',
+    };
+    const result = ThreadSchema.parse(thread);
+    expect(result.messages).toHaveLength(2);
+    expect(result.participants).toContain('A');
+    expect(result.participants).toContain('B');
+  });
+
+  it('accepts thread with empty messages array', () => {
+    const thread: Thread = {
+      id: 'thread-123',
+      messages: [],
+      participants: ['A'],
+      lastActivity: '2024-01-01T00:00:00Z',
+    };
+    const result = ThreadSchema.parse(thread);
+    expect(result.messages).toHaveLength(0);
+  });
+});
+
+describe('Type inference', () => {
+  it('infers Message type correctly', () => {
+    const message: Message = {
+      id: '1',
+      from: 'A',
+      to: 'B',
+      content: 'Test',
+      timestamp: '2024-01-01',
+    };
+    const parsed: z.infer<typeof MessageSchema> = MessageSchema.parse(message);
+    expect(parsed.content).toBe('Test');
+  });
+});

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

@@ -0,0 +1,98 @@
+/**
+ * Message Schemas
+ *
+ * Zod schemas for message-related types used across the dashboard and API.
+ */
+
+import { z } from 'zod';
+
+/**
+ * Message status enum
+ */
+export const MessageStatusSchema = z.enum(['unread', 'read', 'acked', 'sending', 'failed']);
+export type MessageStatus = z.infer<typeof MessageStatusSchema>;
+
+/**
+ * Attachment schema - files/images attached to messages
+ */
+export const AttachmentSchema = z.object({
+  /** Unique identifier for the attachment */
+  id: z.string(),
+  /** Original filename */
+  filename: z.string(),
+  /** MIME type (e.g., 'image/png', 'image/jpeg') */
+  mimeType: z.string(),
+  /** Size in bytes */
+  size: z.number(),
+  /** URL to access the attachment */
+  url: z.string(),
+  /** Absolute file path for agents to read the file directly */
+  filePath: z.string().optional(),
+  /** Width for images */
+  width: z.number().optional(),
+  /** Height for images */
+  height: z.number().optional(),
+  /** Base64-encoded data (for inline display, optional) */
+  data: z.string().optional(),
+});
+export type Attachment = z.infer<typeof AttachmentSchema>;
+
+/**
+ * Thread metadata schema
+ */
+export const ThreadMetadataSchema = z.object({
+  id: z.string(),
+  rootMessage: z.string(),
+  participantCount: z.number(),
+  messageCount: z.number(),
+  lastActivityAt: z.string(),
+});
+export type ThreadMetadata = z.infer<typeof ThreadMetadataSchema>;
+
+/**
+ * Message schema
+ */
+export const MessageSchema = z.object({
+  /** Unique message ID */
+  id: z.string(),
+  /** Sender agent name */
+  from: z.string(),
+  /** Recipient agent name or '*' for broadcast */
+  to: z.string(),
+  /** Message content */
+  content: z.string(),
+  /** Timestamp (ISO string) */
+  timestamp: z.string(),
+  /** Optional thread ID for threading */
+  thread: z.string().optional(),
+  /** Whether this is a broadcast message */
+  isBroadcast: z.boolean().optional(),
+  /** Whether the message has been read */
+  isRead: z.boolean().optional(),
+  /** Number of replies in thread */
+  replyCount: z.number().optional(),
+  /** Thread summary metadata */
+  threadSummary: ThreadMetadataSchema.optional(),
+  /** Message delivery status */
+  status: MessageStatusSchema.optional(),
+  /** Attached files/images */
+  attachments: z.array(AttachmentSchema).optional(),
+  /** Channel context for routing */
+  channel: z.string().optional(),
+});
+export type Message = z.infer<typeof MessageSchema>;
+
+/**
+ * Thread schema - collection of messages
+ */
+export const ThreadSchema = z.object({
+  /** Thread ID */
+  id: z.string(),
+  /** Messages in the thread */
+  messages: z.array(MessageSchema),
+  /** Participant agent names */
+  participants: z.array(z.string()),
+  /** Last activity timestamp */
+  lastActivity: z.string(),
+});
+export type Thread = z.infer<typeof ThreadSchema>;

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

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import {
+  SessionSchema,
+  type Session,
+} from './session.js';
+
+describe('SessionSchema', () => {
+  it('accepts minimal valid session', () => {
+    const session: Session = {
+      id: 'session-123',
+      agentName: 'TestAgent',
+      startedAt: '2024-01-01T00:00:00Z',
+      messageCount: 0,
+      isActive: true,
+    };
+    const result = SessionSchema.parse(session);
+    expect(result.id).toBe('session-123');
+    expect(result.agentName).toBe('TestAgent');
+    expect(result.isActive).toBe(true);
+  });
+
+  it('accepts session with all optional fields', () => {
+    const session: Session = {
+      id: 'session-456',
+      agentName: 'FullAgent',
+      cli: 'claude',
+      startedAt: '2024-01-01T00:00:00Z',
+      endedAt: '2024-01-01T01:00:00Z',
+      duration: '1 hour',
+      messageCount: 42,
+      summary: 'Completed feature implementation',
+      isActive: false,
+      closedBy: 'agent',
+    };
+    const result = SessionSchema.parse(session);
+    expect(result.cli).toBe('claude');
+    expect(result.endedAt).toBe('2024-01-01T01:00:00Z');
+    expect(result.closedBy).toBe('agent');
+  });
+
+  it('accepts all closedBy values', () => {
+    const base = {
+      id: '1',
+      agentName: 'Test',
+      startedAt: '2024-01-01',
+      messageCount: 0,
+      isActive: false,
+    };
+
+    expect(SessionSchema.parse({ ...base, closedBy: 'agent' }).closedBy).toBe('agent');
+    expect(SessionSchema.parse({ ...base, closedBy: 'disconnect' }).closedBy).toBe('disconnect');
+    expect(SessionSchema.parse({ ...base, closedBy: 'error' }).closedBy).toBe('error');
+  });
+
+  it('rejects session without required id', () => {
+    expect(() =>
+      SessionSchema.parse({
+        agentName: 'Test',
+        startedAt: '2024-01-01',
+        messageCount: 0,
+        isActive: true,
+      })
+    ).toThrow();
+  });
+
+  it('rejects session without required agentName', () => {
+    expect(() =>
+      SessionSchema.parse({
+        id: '1',
+        startedAt: '2024-01-01',
+        messageCount: 0,
+        isActive: true,
+      })
+    ).toThrow();
+  });
+
+  it('rejects invalid closedBy value', () => {
+    expect(() =>
+      SessionSchema.parse({
+        id: '1',
+        agentName: 'Test',
+        startedAt: '2024-01-01',
+        messageCount: 0,
+        isActive: false,
+        closedBy: 'invalid',
+      })
+    ).toThrow();
+  });
+});
+
+describe('Type inference', () => {
+  it('infers Session type correctly', () => {
+    const session: Session = {
+      id: '1',
+      agentName: 'Test',
+      startedAt: '2024-01-01',
+      messageCount: 0,
+      isActive: true,
+    };
+    const parsed: z.infer<typeof SessionSchema> = SessionSchema.parse(session);
+    expect(parsed.agentName).toBe('Test');
+  });
+});

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

@@ -0,0 +1,40 @@
+/**
+ * Session Schemas
+ *
+ * Zod schemas for session-related types used across the dashboard and API.
+ */
+
+import { z } from 'zod';
+
+/**
+ * Session closed by enum
+ */
+export const SessionClosedBySchema = z.enum(['agent', 'disconnect', 'error']);
+export type SessionClosedBy = z.infer<typeof SessionClosedBySchema>;
+
+/**
+ * Session schema - represents an agent session
+ */
+export const SessionSchema = z.object({
+  /** Unique session ID */
+  id: z.string(),
+  /** Agent name for this session */
+  agentName: z.string(),
+  /** CLI type used (claude, codex, gemini, etc.) */
+  cli: z.string().optional(),
+  /** Session start timestamp (ISO string) */
+  startedAt: z.string(),
+  /** Session end timestamp (ISO string) */
+  endedAt: z.string().optional(),
+  /** Human-readable duration string */
+  duration: z.string().optional(),
+  /** Total messages in session */
+  messageCount: z.number(),
+  /** Session summary text */
+  summary: z.string().optional(),
+  /** Whether session is currently active */
+  isActive: z.boolean(),
+  /** How the session was closed */
+  closedBy: SessionClosedBySchema.optional(),
+});
+export type Session = z.infer<typeof SessionSchema>;

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

@@ -0,0 +1,192 @@
+/**
+ * Task Schema Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  TaskStatusSchema,
+  TaskPrioritySchema,
+  TaskTypeSchema,
+  TaskSchema,
+  TaskAssignmentStatusSchema,
+  TaskAssignmentPrioritySchema,
+  TaskAssignmentSchema,
+} from './task.js';
+
+describe('Task Schemas', () => {
+  describe('TaskStatusSchema', () => {
+    it('should validate valid statuses', () => {
+      expect(TaskStatusSchema.parse('open')).toBe('open');
+      expect(TaskStatusSchema.parse('in_progress')).toBe('in_progress');
+      expect(TaskStatusSchema.parse('completed')).toBe('completed');
+      expect(TaskStatusSchema.parse('blocked')).toBe('blocked');
+    });
+
+    it('should reject invalid status', () => {
+      expect(() => TaskStatusSchema.parse('done')).toThrow();
+      expect(() => TaskStatusSchema.parse('pending')).toThrow();
+    });
+  });
+
+  describe('TaskPrioritySchema', () => {
+    it('should validate P1-P4 priorities', () => {
+      expect(TaskPrioritySchema.parse('P1')).toBe('P1');
+      expect(TaskPrioritySchema.parse('P2')).toBe('P2');
+      expect(TaskPrioritySchema.parse('P3')).toBe('P3');
+      expect(TaskPrioritySchema.parse('P4')).toBe('P4');
+    });
+
+    it('should reject invalid priorities', () => {
+      expect(() => TaskPrioritySchema.parse('P0')).toThrow();
+      expect(() => TaskPrioritySchema.parse('P5')).toThrow();
+      expect(() => TaskPrioritySchema.parse('high')).toThrow();
+    });
+  });
+
+  describe('TaskTypeSchema', () => {
+    it('should validate task types', () => {
+      expect(TaskTypeSchema.parse('task')).toBe('task');
+      expect(TaskTypeSchema.parse('bug')).toBe('bug');
+      expect(TaskTypeSchema.parse('feature')).toBe('feature');
+      expect(TaskTypeSchema.parse('epic')).toBe('epic');
+    });
+
+    it('should reject invalid types', () => {
+      expect(() => TaskTypeSchema.parse('story')).toThrow();
+      expect(() => TaskTypeSchema.parse('issue')).toThrow();
+    });
+  });
+
+  describe('TaskSchema', () => {
+    it('should validate complete task', () => {
+      const task = {
+        id: 'beads-001',
+        title: 'Implement user authentication',
+        description: 'Add JWT-based authentication',
+        status: 'in_progress',
+        priority: 'P2',
+        type: 'feature',
+        assignee: 'FullStack',
+        blockedBy: ['beads-000'],
+        blocking: ['beads-002', 'beads-003'],
+        created: '2025-01-20T10:00:00Z',
+        updated: '2025-01-22T09:00:00Z',
+      };
+      const result = TaskSchema.parse(task);
+      expect(result.id).toBe('beads-001');
+      expect(result.status).toBe('in_progress');
+      expect(result.blockedBy).toHaveLength(1);
+      expect(result.blocking).toHaveLength(2);
+    });
+
+    it('should allow task without optional fields', () => {
+      const task = {
+        id: 'beads-002',
+        title: 'Fix login bug',
+        status: 'open',
+        priority: 'P1',
+        type: 'bug',
+        created: '2025-01-22T08:00:00Z',
+        updated: '2025-01-22T08:00:00Z',
+      };
+      const result = TaskSchema.parse(task);
+      expect(result.description).toBeUndefined();
+      expect(result.assignee).toBeUndefined();
+      expect(result.blockedBy).toBeUndefined();
+    });
+
+    it('should reject task with missing required fields', () => {
+      expect(() =>
+        TaskSchema.parse({
+          id: 'beads-003',
+          title: 'Incomplete task',
+        })
+      ).toThrow();
+    });
+  });
+
+  describe('TaskAssignmentStatusSchema', () => {
+    it('should validate all assignment statuses', () => {
+      expect(TaskAssignmentStatusSchema.parse('pending')).toBe('pending');
+      expect(TaskAssignmentStatusSchema.parse('assigned')).toBe('assigned');
+      expect(TaskAssignmentStatusSchema.parse('in_progress')).toBe('in_progress');
+      expect(TaskAssignmentStatusSchema.parse('completed')).toBe('completed');
+      expect(TaskAssignmentStatusSchema.parse('failed')).toBe('failed');
+    });
+  });
+
+  describe('TaskAssignmentPrioritySchema', () => {
+    it('should validate assignment priorities', () => {
+      expect(TaskAssignmentPrioritySchema.parse('low')).toBe('low');
+      expect(TaskAssignmentPrioritySchema.parse('medium')).toBe('medium');
+      expect(TaskAssignmentPrioritySchema.parse('high')).toBe('high');
+      expect(TaskAssignmentPrioritySchema.parse('critical')).toBe('critical');
+    });
+
+    it('should reject invalid priority', () => {
+      expect(() => TaskAssignmentPrioritySchema.parse('urgent')).toThrow();
+    });
+  });
+
+  describe('TaskAssignmentSchema', () => {
+    it('should validate complete assignment', () => {
+      const assignment = {
+        id: 'task-assign-001',
+        agentName: 'FullStack',
+        title: 'Build API endpoint',
+        description: 'Create REST endpoint for user data',
+        priority: 'high',
+        status: 'in_progress',
+        createdAt: '2025-01-22T08:00:00Z',
+        assignedAt: '2025-01-22T08:05:00Z',
+      };
+      const result = TaskAssignmentSchema.parse(assignment);
+      expect(result.agentName).toBe('FullStack');
+      expect(result.priority).toBe('high');
+      expect(result.status).toBe('in_progress');
+    });
+
+    it('should validate completed assignment', () => {
+      const assignment = {
+        id: 'task-assign-002',
+        agentName: 'Backend',
+        title: 'Database migration',
+        description: 'Run schema migrations',
+        priority: 'medium',
+        status: 'completed',
+        createdAt: '2025-01-21T10:00:00Z',
+        assignedAt: '2025-01-21T10:30:00Z',
+        completedAt: '2025-01-21T12:00:00Z',
+        result: 'Migration completed successfully. 3 tables updated.',
+      };
+      const result = TaskAssignmentSchema.parse(assignment);
+      expect(result.status).toBe('completed');
+      expect(result.completedAt).toBeDefined();
+      expect(result.result).toContain('Migration');
+    });
+
+    it('should allow pending assignment without dates', () => {
+      const assignment = {
+        id: 'task-assign-003',
+        agentName: 'Worker',
+        title: 'Pending task',
+        description: 'Waiting for assignment',
+        priority: 'low',
+        status: 'pending',
+        createdAt: '2025-01-22T09:00:00Z',
+      };
+      const result = TaskAssignmentSchema.parse(assignment);
+      expect(result.assignedAt).toBeUndefined();
+      expect(result.completedAt).toBeUndefined();
+    });
+
+    it('should reject assignment with missing required fields', () => {
+      expect(() =>
+        TaskAssignmentSchema.parse({
+          id: 'task-assign-004',
+          agentName: 'Worker',
+        })
+      ).toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,78 @@
+/**
+ * Task Schemas
+ *
+ * Zod schemas for task-related types used across the dashboard and API.
+ */
+
+import { z } from 'zod';
+
+/**
+ * Task status enum
+ */
+export const TaskStatusSchema = z.enum(['open', 'in_progress', 'completed', 'blocked']);
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+
+/**
+ * Task priority enum
+ */
+export const TaskPrioritySchema = z.enum(['P1', 'P2', 'P3', 'P4']);
+export type TaskPriority = z.infer<typeof TaskPrioritySchema>;
+
+/**
+ * Task type enum
+ */
+export const TaskTypeSchema = z.enum(['task', 'bug', 'feature', 'epic']);
+export type TaskType = z.infer<typeof TaskTypeSchema>;
+
+/**
+ * Task schema (Beads Integration)
+ */
+export const TaskSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  status: TaskStatusSchema,
+  priority: TaskPrioritySchema,
+  type: TaskTypeSchema,
+  assignee: z.string().optional(),
+  blockedBy: z.array(z.string()).optional(),
+  blocking: z.array(z.string()).optional(),
+  created: z.string(),
+  updated: z.string(),
+});
+export type Task = z.infer<typeof TaskSchema>;
+
+/**
+ * Task assignment status enum (for API)
+ */
+export const TaskAssignmentStatusSchema = z.enum([
+  'pending',
+  'assigned',
+  'in_progress',
+  'completed',
+  'failed',
+]);
+export type TaskAssignmentStatus = z.infer<typeof TaskAssignmentStatusSchema>;
+
+/**
+ * Task assignment priority enum (for API)
+ */
+export const TaskAssignmentPrioritySchema = z.enum(['low', 'medium', 'high', 'critical']);
+export type TaskAssignmentPriority = z.infer<typeof TaskAssignmentPrioritySchema>;
+
+/**
+ * Task assignment schema (for /api/tasks endpoints)
+ */
+export const TaskAssignmentSchema = z.object({
+  id: z.string(),
+  agentName: z.string(),
+  title: z.string(),
+  description: z.string(),
+  priority: TaskAssignmentPrioritySchema,
+  status: TaskAssignmentStatusSchema,
+  createdAt: z.string(),
+  assignedAt: z.string().optional(),
+  completedAt: z.string().optional(),
+  result: z.string().optional(),
+});
+export type TaskAssignment = z.infer<typeof TaskAssignmentSchema>;