agent-relay 2.3.2 → 2.3.5

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

@@ -1,192 +0,0 @@
-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

@@ -1,98 +0,0 @@
-/**
- * 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

@@ -1,104 +0,0 @@
-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

@@ -1,40 +0,0 @@
-/**
- * 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

@@ -1,192 +0,0 @@
-/**
- * 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

@@ -1,78 +0,0 @@
-/**
- * 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>;