@fleettools/server 0.1.0 → 0.1.1

package/src/middleware/logger.ts

@@ -1,37 +0,0 @@
-
-
-export function requestLogger() {
-  return async (request: Request, next: (request: Request) => Promise<Response>): Promise<Response> => {
-    const start = Date.now();
-    const url = new URL(request.url);
-    const method = request.method;
-    
-    console.log(`[${new Date().toISOString()}] ${method} ${url.pathname}`);
-    
-    try {
-      const response = await next(request);
-      const duration = Date.now() - start;
-      const status = response.status;
-      
-      console.log(`[${new Date().toISOString()}] ${method} ${url.pathname} ${status} ${duration}ms`);
-      
-      return response;
-    } catch (error) {
-      const duration = Date.now() - start;
-      console.error(`[${new Date().toISOString()}] ${method} ${url.pathname} ERROR ${duration}ms:`, error);
-      throw error;
-    }
-  };
-}
-
-export function logRequest(req: Request) {
-  const timestamp = new Date().toISOString();
-  const method = req.method;
-  const url = new URL(req.url);
-  console.log(`[${timestamp}] ${method} ${url.pathname}`);
-  return { timestamp, method, path: url.pathname };
-}
-
-export function logResponse(timestamp: string, method: string, path: string, status: number, duration: number) {
-  console.log(`[${new Date().toISOString()}] ${method} ${path} ${status} ${duration}ms`);
-}

package/src/middleware/validation.ts

@@ -1,235 +0,0 @@
-/**
- * Agent Types and Validation Schemas
- *
- * Zod validation schemas for agent coordination
- */
-
-import { z } from 'zod';
-
-// Define AgentType locally to avoid import conflicts
-export enum AgentType {
-  FRONTEND = 'frontend',
-  BACKEND = 'backend',
-  TESTING = 'testing',
-  DOCUMENTATION = 'documentation',
-  SECURITY = 'security',
-  PERFORMANCE = 'performance'
-}
-
-export interface AgentConfig {
-  timeout?: number;
-  retries?: number;
-  resources?: {
-    memory?: string;
-    cpu?: string;
-  };
-  environment?: Record<string, string>;
-}
-
-export interface AgentSpawnRequest {
-  type: AgentType;
-  task?: string;
-  metadata?: Record<string, any>;
-  config?: AgentConfig;
-}
-
-// Enhanced AgentType with validation
-export const AgentTypeSchema = z.enum([
-  AgentType.FRONTEND,
-  AgentType.BACKEND,
-  AgentType.TESTING,
-  AgentType.DOCUMENTATION,
-  AgentType.SECURITY,
-  AgentType.PERFORMANCE
-]);
-
-// Agent Configuration Schema
-export const AgentConfigSchema = z.object({
-  timeout: z.number().int().positive().optional(),
-  retries: z.number().int().min(0).max(10).optional(),
-  resources: z.object({
-    memory: z.string().optional(),
-    cpu: z.string().optional(),
-  }).optional(),
-  environment: z.record(z.string()).optional(),
-});
-
-// Agent Spawn Request Schema
-export const AgentSpawnRequestSchema = z.object({
-  type: AgentTypeSchema,
-  task: z.string().optional(),
-  metadata: z.record(z.unknown()).optional(),
-  config: AgentConfigSchema.optional(),
-});
-
-// Agent Update Request Schema
-export const AgentUpdateRequestSchema = z.object({
-  status: z.enum(['idle', 'busy', 'error']).optional(),
-  metadata: z.record(z.unknown()).optional(),
-  heartbeat: z.boolean().optional(),
-});
-
-// Agent Capability Schema
-export const AgentCapabilitySchema = z.object({
-  id: z.string().uuid(),
-  agentId: z.string(),
-  capability: z.string(),
-  version: z.string(),
-  enabled: z.boolean(),
-  config: z.record(z.unknown()).optional(),
-});
-
-// Agent Specialization Schema
-export const AgentSpecializationSchema = z.object({
-  id: z.string().uuid(),
-  agentId: z.string(),
-  specialization: z.string(),
-  proficiency: z.number().min(0).max(1), // 0-1 scale
-  experience: z.number().int().min(0), // years
-  certifications: z.array(z.string()).optional(),
-});
-
-// Task Assignment Schema
-export const TaskAssignmentSchema = z.object({
-  taskId: z.string(),
-  agentId: z.string(),
-  assignedAt: z.string().datetime(),
-  deadline: z.string().datetime().optional(),
-  priority: z.enum(['low', 'medium', 'high', 'critical']),
-  requirements: z.object({
-    skills: z.array(z.string()).optional(),
-    tools: z.array(z.string()).optional(),
-    resources: z.record(z.string()).optional(),
-  }).optional(),
-});
-
-// Agent Performance Schema
-export const AgentPerformanceSchema = z.object({
-  agentId: z.string(),
-  taskId: z.string().optional(),
-  metrics: z.object({
-    executionTime: z.number().min(0),
-    accuracy: z.number().min(0).max(1),
-    efficiency: z.number().min(0).max(1),
-    resourceUsage: z.object({
-      memory: z.number().min(0),
-      cpu: z.number().min(0),
-      disk: z.number().min(0).optional(),
-    }),
-  }),
-  timestamp: z.string().datetime(),
-});
-
-// Validation functions
-export class AgentValidator {
-  /**
-   * Validate agent spawn request
-   */
-  static validateSpawnRequest(data: unknown): AgentSpawnRequest {
-    const result = AgentSpawnRequestSchema.safeParse(data);
-    
-    if (!result.success) {
-      throw new Error(`Invalid spawn request: ${result.error.message}`);
-    }
-    
-    return result.data;
-  }
-
-  /**
-   * Validate agent configuration
-   */
-  static validateConfig(data: unknown): AgentConfig {
-    const result = AgentConfigSchema.safeParse(data);
-    
-    if (!result.success) {
-      throw new Error(`Invalid agent config: ${result.error.message}`);
-    }
-    
-    return result.data;
-  }
-
-  /**
-   * Validate agent type
-   */
-  static validateAgentType(type: string): AgentType {
-    const result = AgentTypeSchema.safeParse(type);
-    
-    if (!result.success) {
-      throw new Error(`Invalid agent type: ${result.error.message}`);
-    }
-    
-    return result.data;
-  }
-
-  /**
-   * Validate agent ID format
-   */
-  static validateAgentId(id: string): boolean {
-    // Agent IDs should follow pattern: agt_<uuid>
-    const agentIdPattern = /^agt_[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
-    return agentIdPattern.test(id);
-  }
-
-  /**
-   * Validate task assignment
-   */
-  static validateTaskAssignment(data: unknown): z.infer<typeof TaskAssignmentSchema> {
-    const result = TaskAssignmentSchema.safeParse(data);
-    
-    if (!result.success) {
-      throw new Error(`Invalid task assignment: ${result.error.message}`);
-    }
-    
-    return result.data;
-  }
-
-  /**
-   * Check if agent type is suitable for task type
-   */
-  static isAgentSuitableForTask(agentType: AgentType, taskType: string): boolean {
-    const suitabilityMap: Record<AgentType, string[]> = {
-      [AgentType.FRONTEND]: ['ui', 'frontend', 'component', 'interface'],
-      [AgentType.BACKEND]: ['api', 'backend', 'server', 'database'],
-      [AgentType.TESTING]: ['test', 'testing', 'qa', 'validation'],
-      [AgentType.DOCUMENTATION]: ['docs', 'documentation', 'readme', 'guide'],
-      [AgentType.SECURITY]: ['security', 'audit', 'vulnerability', 'scan'],
-      [AgentType.PERFORMANCE]: ['performance', 'optimization', 'benchmark', 'metrics']
-    };
-
-    const agentCapabilities = suitabilityMap[agentType] || [];
-    return agentCapabilities.some(capability => 
-      taskType.toLowerCase().includes(capability)
-    );
-  }
-
-  /**
-   * Get recommended agents for task type
-   */
-  static getRecommendedAgents(taskType: string): AgentType[] {
-    const taskToAgents: Record<string, AgentType[]> = {
-      'ui': [AgentType.FRONTEND],
-      'frontend': [AgentType.FRONTEND],
-      'api': [AgentType.BACKEND],
-      'backend': [AgentType.BACKEND],
-      'test': [AgentType.TESTING],
-      'security': [AgentType.SECURITY],
-      'docs': [AgentType.DOCUMENTATION],
-      'performance': [AgentType.PERFORMANCE],
-      'general': [AgentType.BACKEND, AgentType.FRONTEND] // General tasks can go to multiple types
-    };
-
-    return taskToAgents[taskType.toLowerCase()] || [AgentType.BACKEND]; // Default to backend
-  }
-}
-
-// Common task categories for validation
-const AgentCapabilities = [
-  'ui', 'frontend', 'component', 'interface',
-  'api', 'backend', 'server', 'database',
-  'test', 'testing', 'qa', 'validation',
-  'docs', 'documentation', 'readme', 'guide',
-  'security', 'audit', 'vulnerability', 'scan',
-  'performance', 'optimization', 'benchmark', 'metrics',
-  'general', 'utility', 'helper', 'tool'
-];
-

package/src/squawk/coordinator.ts

@@ -1,26 +0,0 @@
-
-import { mailboxOps, lockOps } from '../../../../squawk/src/db/index.js';
-
-export function registerCoordinatorRoutes(router: any, headers: Record<string, string>) {
-  
-  router.get('/api/v1/coordinator/status', async (req: Request) => {
-    try {
-      const mailboxes = await mailboxOps.getAll();
-      const locks = await lockOps.getAll();
-
-      return new Response(JSON.stringify({
-        active_mailboxes: mailboxes.length,
-        active_locks: locks.length,
-        timestamp: new Date().toISOString(),
-      }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error getting coordinator status:', error);
-      return new Response(JSON.stringify({ error: 'Failed to get status' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-}

package/src/squawk/cursor.ts

@@ -1,62 +0,0 @@
-
-import { cursorOps, mailboxOps } from '../../../../squawk/src/db/index.js';
-
-export function registerCursorRoutes(router: any, headers: Record<string, string>) {
-  
-  router.post('/api/v1/cursor/advance', async (req: Request) => {
-    try {
-      const body = await req.json() as { stream_id?: string; position?: number };
-      const { stream_id, position } = body;
-
-      if (!stream_id || typeof position !== 'number') {
-        return new Response(JSON.stringify({ error: 'stream_id and position are required' }), {
-          status: 400,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      if (!(await mailboxOps.exists(stream_id))) {
-        return new Response(JSON.stringify({ error: 'Mailbox not found' }), {
-          status: 404,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const cursor = await cursorOps.upsert({ stream_id, position, updated_at: new Date().toISOString() });
-      return new Response(JSON.stringify({ cursor }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error advancing cursor:', error);
-      return new Response(JSON.stringify({ error: 'Failed to advance cursor' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.get('/api/v1/cursor/:cursorId', async (req: Request, params: { cursorId: string }) => {
-    try {
-      const cursorId = params.cursorId;
-      const cursor = cursorOps.getById(cursorId);
-
-      if (!cursor) {
-        return new Response(JSON.stringify({ error: 'Cursor not found' }), {
-          status: 404,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      return new Response(JSON.stringify({ cursor }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error getting cursor:', error);
-      return new Response(JSON.stringify({ error: 'Failed to get cursor' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-}

package/src/squawk/lock.ts

@@ -1,98 +0,0 @@
-
-import { lockOps } from '../../../../squawk/src/db/index.js';
-
-export function registerLockRoutes(router: any, headers: Record<string, string>) {
-  
-  router.post('/api/v1/lock/acquire', async (req: Request) => {
-    try {
-      const body = await req.json() as { file?: string; specialist_id?: string; timeout_ms?: number };
-      const { file, specialist_id, timeout_ms = 30000 } = body;
-
-      if (!file || !specialist_id) {
-        return new Response(JSON.stringify({ error: 'file and specialist_id are required' }), {
-          status: 400,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const lock = await lockOps.acquire({
-        file,
-        reserved_by: specialist_id,
-        reserved_at: new Date().toISOString(),
-        released_at: null,
-        purpose: 'edit',
-        checksum: null,
-        timeout_ms,
-        metadata: null,
-      });
-
-      return new Response(JSON.stringify({ lock }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error acquiring lock:', error);
-      return new Response(JSON.stringify({ error: 'Failed to acquire lock' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.post('/api/v1/lock/release', async (req: Request) => {
-    try {
-      const body = await req.json() as { lock_id?: string; specialist_id?: string };
-      const { lock_id, specialist_id } = body;
-
-      if (!lock_id) {
-        return new Response(JSON.stringify({ error: 'lock_id is required' }), {
-          status: 400,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const lock = await lockOps.getById(lock_id);
-
-      if (!lock) {
-        return new Response(JSON.stringify({ error: 'Lock not found' }), {
-          status: 404,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      if (lock.reserved_by !== specialist_id) {
-        return new Response(JSON.stringify({ error: 'Cannot release lock: wrong specialist' }), {
-          status: 403,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const updatedLock = await lockOps.release(lock_id);
-      return new Response(JSON.stringify({ lock: updatedLock }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error releasing lock:', error);
-      return new Response(JSON.stringify({ error: 'Failed to release lock' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.get('/api/v1/locks', async (req: Request) => {
-    try {
-      const locks = lockOps.getAll();
-      return new Response(JSON.stringify({ locks }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error listing locks:', error);
-      return new Response(JSON.stringify({ error: 'Failed to list locks' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-}

package/src/squawk/mailbox.ts

@@ -1,75 +0,0 @@
-
-import { mailboxOps, eventOps } from '../../../../squawk/src/db/index.js';
-
-export function registerMailboxRoutes(router: any, headers: Record<string, string>) {
-  
-  router.post('/api/v1/mailbox/append', async (req: Request) => {
-    try {
-      const body = await req.json() as { stream_id?: string; events?: any[] };
-      const { stream_id, events } = body;
-
-      if (!stream_id || !Array.isArray(events)) {
-        return new Response(JSON.stringify({ error: 'stream_id and events array are required' }), {
-          status: 400,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      if (!(await mailboxOps.exists(stream_id))) {
-        await mailboxOps.create(stream_id);
-      }
-
-      const formattedEvents = events.map((e: any) => ({
-        type: e.type,
-        stream_id,
-        data: JSON.stringify(e.data),
-        occurred_at: new Date().toISOString(),
-        causation_id: e.causation_id || null,
-        metadata: e.metadata ? JSON.stringify(e.metadata) : null,
-      }));
-
-      const inserted = await eventOps.append(stream_id, formattedEvents);
-      const mailbox = await mailboxOps.getById(stream_id);
-      const mailboxEvents = await eventOps.getByMailbox(stream_id);
-
-      return new Response(JSON.stringify({
-        mailbox: { ...mailbox, events: mailboxEvents },
-        inserted: inserted.length
-      }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error appending to mailbox:', error);
-      return new Response(JSON.stringify({ error: 'Failed to append to mailbox' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.get('/api/v1/mailbox/:streamId', async (req: Request, params: { streamId: string }) => {
-    try {
-      const streamId = params.streamId;
-      const mailbox = await mailboxOps.getById(streamId);
-      
-      if (!mailbox) {
-        return new Response(JSON.stringify({ error: 'Mailbox not found' }), {
-          status: 404,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const events = await eventOps.getByMailbox(streamId);
-      return new Response(JSON.stringify({ mailbox: { ...mailbox, events } }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error getting mailbox:', error);
-      return new Response(JSON.stringify({ error: 'Failed to get mailbox' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-}

package/src/types/api.ts

@@ -1,71 +0,0 @@
-/**
- * Type definitions for API requests
- */
-
-export interface SpawnAgentRequest {
-  type: string;
-  task?: string;
-  metadata?: Record<string, any>;
-  config?: {
-    timeout?: number;
-    retries?: number;
-    resources?: {
-      memory?: string;
-      cpu?: string;
-    };
-    environment?: Record<string, string>;
-  };
-}
-
-export interface CreateTaskRequest {
-  type: string;
-  title: string;
-  description: string;
-  priority?: 'low' | 'medium' | 'high' | 'critical';
-  missionId?: string;
-  dependencies?: string[];
-  metadata?: Record<string, any>;
-}
-
-export interface UpdateTaskRequest {
-  status: string;
-  result?: any;
-  error?: string;
-}
-
-export interface WorkOrderRequest {
-  title: string;
-  description: string;
-  priority?: 'low' | 'medium' | 'high' | 'critical';
-  assigned_to?: string;
-  metadata?: Record<string, any>;
-}
-
-export interface TechOrderRequest {
-  name: string;
-  pattern: string;
-  context: string;
-  usage_count?: number;
-}
-
-export interface CtkReservationRequest {
-  file: string;
-  specialist_id: string;
-  purpose: string;
-}
-
-export interface LockRequest {
-  file: string;
-  specialist_id: string;
-  timeout_ms?: number;
-}
-
-export interface CursorRequest {
-  stream_id: string;
-  position: number;
-}
-
-export interface MailboxRequest {
-  stream_id: string;
-  events: any[];
-}