@fleettools/server 0.1.0 → 0.2.0

package/src/flightline/tech-orders.ts

@@ -1,85 +0,0 @@
-
-import path from 'path';
-import fs from 'fs';
-import crypto from 'crypto';
-
-const FLIGHTLINE_DIR = path.join(process.cwd(), '.flightline');
-const TECH_ORDERS_DIR = path.join(FLIGHTLINE_DIR, 'tech-orders');
-
-function ensureDirectory() {
-  if (!fs.existsSync(TECH_ORDERS_DIR)) {
-    fs.mkdirSync(TECH_ORDERS_DIR, { recursive: true });
-  }
-}
-
-export function registerTechOrdersRoutes(router: any, headers: Record<string, string>) {
-  ensureDirectory();
-
-  
-  router.get('/api/v1/tech-orders', async (req: Request) => {
-    try {
-      const files = fs.readdirSync(TECH_ORDERS_DIR);
-      const techOrders: any[] = [];
-
-      for (const file of files) {
-        if (file.endsWith('.json')) {
-          const content = fs.readFileSync(path.join(TECH_ORDERS_DIR, file), 'utf-8');
-          const techOrder = JSON.parse(content);
-          techOrders.push(techOrder);
-        }
-      }
-
-      return new Response(JSON.stringify({ tech_orders: techOrders }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error listing tech orders:', error);
-      return new Response(JSON.stringify({ error: 'Failed to list tech orders' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.post('/api/v1/tech-orders', async (req: Request) => {
-    try {
-      const body = await req.json() as { name?: string; pattern?: string; context?: any; usage_count?: number };
-      const { name, pattern, context, usage_count = 0 } = body;
-
-      if (!name || !pattern) {
-        return new Response(JSON.stringify({ error: 'name and pattern are required' }), {
-          status: 400,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const techOrder = {
-        id: 'to_' + crypto.randomUUID(),
-        name,
-        pattern,
-        context,
-        usage_count,
-        success_rate: 0,
-        anti_pattern: false,
-        created_at: new Date().toISOString(),
-        last_used: null,
-      };
-
-      const techOrderPath = path.join(TECH_ORDERS_DIR, `${techOrder.id}.json`);
-      fs.writeFileSync(techOrderPath, JSON.stringify(techOrder, null, 2));
-
-      console.log(`Created tech order: ${name}`);
-      return new Response(JSON.stringify({ tech_order: techOrder }), {
-        status: 201,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error creating tech order:', error);
-      return new Response(JSON.stringify({ error: 'Failed to create tech order' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-}

package/src/flightline/work-orders.ts

@@ -1,202 +0,0 @@
-
-import path from 'path';
-import fs from 'fs';
-import crypto from 'crypto';
-
-const FLIGHTLINE_DIR = path.join(process.cwd(), '.flightline');
-const WORK_ORDERS_DIR = path.join(FLIGHTLINE_DIR, 'work-orders');
-
-function ensureDirectories() {
-  if (!fs.existsSync(FLIGHTLINE_DIR)) {
-    fs.mkdirSync(FLIGHTLINE_DIR, { recursive: true });
-  }
-  if (!fs.existsSync(WORK_ORDERS_DIR)) {
-    fs.mkdirSync(WORK_ORDERS_DIR, { recursive: true });
-  }
-}
-
-function generateId() {
-  return 'wo_' + crypto.randomUUID();
-}
-
-function getWorkOrderPath(orderId: string) {
-  return path.join(WORK_ORDERS_DIR, orderId, 'manifest.json');
-}
-
-export function registerWorkOrdersRoutes(router: any, headers: Record<string, string>) {
-  ensureDirectories();
-
-  
-  router.get('/api/v1/work-orders', async (req: Request) => {
-    try {
-      if (!fs.existsSync(WORK_ORDERS_DIR)) {
-        return new Response(JSON.stringify({ work_orders: [] }), {
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const directories = fs.readdirSync(WORK_ORDERS_DIR);
-      const workOrders: any[] = [];
-
-      for (const dirName of directories) {
-        const manifestPath = path.join(WORK_ORDERS_DIR, dirName, 'manifest.json');
-        if (!fs.existsSync(manifestPath)) continue;
-
-        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-        workOrders.push(manifest);
-      }
-
-      return new Response(JSON.stringify({ work_orders: workOrders }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error listing work orders:', error);
-      return new Response(JSON.stringify({ error: 'Failed to list work orders' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.post('/api/v1/work-orders', async (req: Request) => {
-    try {
-      const body = await req.json() as { title?: string; description?: string; priority?: string; assigned_to?: string[] };
-      const { title, description, priority = 'medium', assigned_to = [] } = body;
-
-      if (!title) {
-        return new Response(JSON.stringify({ error: 'title is required' }), {
-          status: 400,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const orderId = generateId();
-      const now = new Date().toISOString();
-
-      const manifest = {
-        id: orderId,
-        title,
-        description: description || '',
-        status: 'pending',
-        priority,
-        created_at: now,
-        updated_at: now,
-        assigned_to: assigned_to,
-        cells: [],
-        tech_orders: [],
-      };
-
-      const orderDir = path.join(WORK_ORDERS_DIR, orderId);
-      const manifestPath = path.join(orderDir, 'manifest.json');
-
-      fs.mkdirSync(orderDir, { recursive: true });
-      fs.mkdirSync(path.join(orderDir, 'cells'), { recursive: true });
-      fs.mkdirSync(path.join(orderDir, 'events'), { recursive: true });
-      fs.mkdirSync(path.join(orderDir, 'artifacts'), { recursive: true });
-
-      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-
-      console.log(`Created work order: ${orderId} - ${title}`);
-
-      return new Response(JSON.stringify({ work_order: manifest }), {
-        status: 201,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error creating work order:', error);
-      return new Response(JSON.stringify({ error: 'Failed to create work order' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.get('/api/v1/work-orders/:id', async (req: Request, params: { id: string }) => {
-    try {
-      const manifestPath = getWorkOrderPath(params.id);
-      if (!fs.existsSync(manifestPath)) {
-        return new Response(JSON.stringify({ error: 'Work order not found' }), {
-          status: 404,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-      return new Response(JSON.stringify({ work_order: manifest }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error getting work order:', error);
-      return new Response(JSON.stringify({ error: 'Failed to get work order' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.patch('/api/v1/work-orders/:id', async (req: Request, params: { id: string }) => {
-    try {
-      const body = await req.json() as { title?: string; description?: string; status?: string; priority?: string; assigned_to?: string[] };
-      const manifestPath = getWorkOrderPath(params.id);
-      if (!fs.existsSync(manifestPath)) {
-        return new Response(JSON.stringify({ error: 'Work order not found' }), {
-          status: 404,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-
-      if (body.title) manifest.title = body.title;
-      if (body.description !== undefined) manifest.description = body.description;
-      if (body.status) manifest.status = body.status;
-      if (body.priority) manifest.priority = body.priority;
-      if (body.assigned_to) manifest.assigned_to = body.assigned_to;
-
-      manifest.updated_at = new Date().toISOString();
-
-      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-
-      console.log(`Updated work order: ${params.id}`);
-      return new Response(JSON.stringify({ work_order: manifest }), {
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    } catch (error) {
-      console.error('Error updating work order:', error);
-      return new Response(JSON.stringify({ error: 'Failed to update work order' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-
-  
-  router.delete('/api/v1/work-orders/:id', async (req: Request, params: { id: string }) => {
-    try {
-      const orderDir = path.join(WORK_ORDERS_DIR, params.id);
-      if (!fs.existsSync(orderDir)) {
-        return new Response(JSON.stringify({ error: 'Work order not found' }), {
-          status: 404,
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      fs.rmSync(orderDir, { recursive: true, force: true });
-
-      console.log(`Deleted work order: ${params.id}`);
-      return new Response(null, {
-        status: 204,
-        headers: { ...headers },
-      });
-    } catch (error) {
-      console.error('Error deleting work order:', error);
-      return new Response(JSON.stringify({ error: 'Failed to delete work order' }), {
-        status: 500,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    }
-  });
-}

package/src/index.ts

@@ -1,211 +0,0 @@
-
-
-import { closeDatabase, initializeDatabase } from '../../../squawk/src/db/index.js';
-import { registerWorkOrdersRoutes } from './flightline/work-orders.js';
-import { registerCtkRoutes } from './flightline/ctk.js';
-import { registerTechOrdersRoutes } from './flightline/tech-orders.js';
-import { registerMailboxRoutes } from './squawk/mailbox.js';
-import { registerCursorRoutes } from './squawk/cursor.js';
-import { registerLockRoutes } from './squawk/lock.js';
-import { registerCoordinatorRoutes } from './squawk/coordinator.js';
-
-const headers: Record<string, string> = {
-  'Access-Control-Allow-Origin': '*',
-  'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
-  'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-};
-
-const routes: Array<{
-  method: string;
-  pathPattern: string;
-  regex: RegExp;
-  paramNames: string[];
-  handler: (req: Request, params?: any) => Promise<Response>;
-}> = [];
-
-function parsePathPattern(pathPattern: string): { regex: RegExp; paramNames: string[] } {
-  const paramNames: string[] = [];
-  const regexPattern = pathPattern.replace(/:([^/]+)/g, (_, paramName) => {
-    paramNames.push(paramName);
-    return '([^/]+)';
-  });
-  return {
-    regex: new RegExp(`^${regexPattern}$`),
-    paramNames,
-  };
-}
-
-function createRouter() {
-  const addRoute = (method: string, path: string, handler: any, paramNames: string[], regex: RegExp) => {
-    routes.push({ method, pathPattern: path, regex, paramNames, handler });
-  };
-  
-  return {
-    get: (path: string, handler: any) => {
-      const { regex, paramNames } = parsePathPattern(path);
-      if (path.includes(':')) {
-        addRoute('GET', path, handler, paramNames, regex);
-      } else {
-        addRoute('GET', path, handler, [], regex);
-      }
-    },
-    post: (path: string, handler: any) => {
-      const { regex, paramNames } = parsePathPattern(path);
-      if (path.includes(':')) {
-        addRoute('POST', path, handler, paramNames, regex);
-      } else {
-        addRoute('POST', path, handler, [], regex);
-      }
-    },
-    patch: (path: string, handler: any) => {
-      const { regex, paramNames } = parsePathPattern(path);
-      if (path.includes(':')) {
-        addRoute('PATCH', path, handler, paramNames, regex);
-      } else {
-        addRoute('PATCH', path, handler, [], regex);
-      }
-    },
-    delete: (path: string, handler: any) => {
-      const { regex, paramNames } = parsePathPattern(path);
-      if (path.includes(':')) {
-        addRoute('DELETE', path, handler, paramNames, regex);
-      } else {
-        addRoute('DELETE', path, handler, [], regex);
-      }
-    },
-  };
-}
-
-function registerRoutes() {
-  registerWorkOrdersRoutes(createRouter(), headers);
-  registerCtkRoutes(createRouter(), headers);
-  registerTechOrdersRoutes(createRouter(), headers);
-  registerMailboxRoutes(createRouter(), headers);
-  registerCursorRoutes(createRouter(), headers);
-  registerLockRoutes(createRouter(), headers);
-  registerCoordinatorRoutes(createRouter(), headers);
-}
-
-async function startServer() {
-  try {
-    await initializeDatabase();
-    console.log('Squawk database initialized');
-  } catch (error) {
-    console.error('Failed to initialize database:', error);
-    process.exit(1);
-  }
-
-  registerRoutes();
-
-  const server = Bun.serve({
-    port: parseInt(process.env.PORT || '3001', 10),
-    async fetch(request) {
-      const url = new URL(request.url);
-      const path = url.pathname;
-      const method = request.method;
-
-      if (method === 'OPTIONS') {
-        return new Response(null, { headers });
-      }
-
-      if (path === '/health') {
-        return new Response(JSON.stringify({
-          status: 'healthy',
-          service: 'fleettools-consolidated',
-          timestamp: new Date().toISOString(),
-          version: '1.0.0',
-        }), {
-          headers: { ...headers, 'Content-Type': 'application/json' },
-        });
-      }
-
-      for (const route of routes) {
-        if (route.method !== method) continue;
-        const match = path.match(route.regex);
-        if (match) {
-          try {
-            const params: any = {};
-            route.paramNames.forEach((name, i) => {
-              params[name] = match[i + 1];
-            });
-            return await route.handler(request, params);
-          } catch (error) {
-            console.error('Route handler error:', error);
-            return new Response(JSON.stringify({
-              error: 'Internal server error',
-              message: error instanceof Error ? error.message : 'Unknown error',
-            }), {
-              status: 500,
-              headers: { ...headers, 'Content-Type': 'application/json' },
-            });
-          }
-        }
-      }
-
-      // 404
-      return new Response(JSON.stringify({
-        error: 'Not found',
-        path,
-        method,
-      }), {
-        status: 404,
-        headers: { ...headers, 'Content-Type': 'application/json' },
-      });
-    },
-  });
-
-  setInterval(async () => {
-    try {
-      const { lockOps } = await import('../../../squawk/src/db/index.js');
-      const released = await lockOps.releaseExpired();
-      if (released > 0) {
-        console.log(`Released ${released} expired locks`);
-      }
-    } catch (error) {
-      console.error('Error releasing expired locks:', error);
-    }
-  }, 30000); // Check every 30 seconds
-
-  console.log(`FleetTools Consolidated API server listening on port ${server.port}`);
-  console.log(`Health check: http://localhost:${server.port}/health`);
-  console.log('\nFlightline Endpoints:');
-  console.log('  GET    /api/v1/work-orders         - List work orders');
-  console.log('  POST   /api/v1/work-orders         - Create work order');
-  console.log('  GET    /api/v1/work-orders/:id     - Get work order');
-  console.log('  PATCH  /api/v1/work-orders/:id     - Update work order');
-  console.log('  DELETE /api/v1/work-orders/:id     - Delete work order');
-  console.log('  GET    /api/v1/ctk/reservations    - List CTK reservations');
-  console.log('  POST   /api/v1/ctk/reserve         - Reserve file');
-  console.log('  POST   /api/v1/ctk/release         - Release reservation');
-  console.log('  GET    /api/v1/tech-orders         - List tech orders');
-  console.log('  POST   /api/v1/tech-orders         - Create tech order');
-  console.log('\nSquawk Endpoints:');
-  console.log('  POST   /api/v1/mailbox/append      - Append events to mailbox');
-  console.log('  GET    /api/v1/mailbox/:streamId   - Get mailbox contents');
-  console.log('  POST   /api/v1/cursor/advance      - Advance cursor position');
-  console.log('  GET    /api/v1/cursor/:cursorId    - Get cursor position');
-  console.log('  POST   /api/v1/lock/acquire        - Acquire file lock');
-  console.log('  POST   /api/v1/lock/release        - Release file lock');
-  console.log('  GET    /api/v1/locks               - List all active locks');
-  console.log('  GET    /api/v1/coordinator/status  - Get coordinator status');
-
-  process.on('SIGINT', () => {
-    console.log('\nShutting down...');
-    closeDatabase();
-    server.stop();
-    process.exit(0);
-  });
-
-  process.on('SIGTERM', () => {
-    console.log('\nShutting down...');
-    closeDatabase();
-    server.stop();
-    process.exit(0);
-  });
-
-  return server;
-}
-
-const server = await startServer();
-
-export { server };

package/src/middleware/agent-validation.ts

@@ -1,130 +0,0 @@
-/**
- * Agent Validation Schemas
- *
- * Zod validation schemas for agent coordination
- */
-
-import { z } from 'zod';
-
-// Agent Type Schema
-export const AgentTypeSchema = z.enum([
-  'frontend',
-  'backend', 
-  'testing',
-  'documentation',
-  'security',
-  '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(),
-});
-
-// Validation functions
-export class AgentValidator {
-  /**
-   * Validate agent spawn request
-   */
-  static validateSpawnRequest(data: unknown) {
-    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) {
-    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) {
-    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);
-  }
-
-  /**
-   * Check if agent type is suitable for task type
-   */
-  static isAgentSuitableForTask(agentType: string, taskType: string): boolean {
-    const suitabilityMap: Record<string, string[]> = {
-      'frontend': ['ui', 'frontend', 'component', 'interface'],
-      'backend': ['api', 'backend', 'server', 'database'],
-      'testing': ['test', 'testing', 'qa', 'validation'],
-      'documentation': ['docs', 'documentation', 'readme', 'guide'],
-      'security': ['security', 'audit', 'vulnerability', 'scan'],
-      'performance': ['performance', 'optimization', 'benchmark', 'metrics']
-    };
-
-    const agentCapabilities = suitabilityMap[agentType] || [];
-    return agentCapabilities.includes(taskType.toLowerCase());
-  }
-
-  /**
-   * Get recommended agents for task type
-   */
-  static getRecommendedAgents(taskType: string): string[] {
-    const taskToAgents: Record<string, string[]> = {
-      'ui': ['frontend'],
-      'frontend': ['frontend'],
-      'api': ['backend'],
-      'backend': ['backend'],
-      'test': ['testing'],
-      'security': ['security'],
-      'docs': ['documentation'],
-      'performance': ['performance'],
-      'general': ['backend', 'frontend'] // General tasks can go to multiple types
-    };
-
-    return taskToAgents[taskType.toLowerCase()] || ['backend']; // Default to backend
-  }
-}

package/src/middleware/error-handler.ts

@@ -1,59 +0,0 @@
-
-
-export class HttpError extends Error {
-  constructor(
-    public status: number,
-    message: string,
-    public details?: any
-  ) {
-    super(message);
-    this.name = 'HttpError';
-  }
-}
-
-export function errorHandler(error: unknown): Response {
-  const timestamp = new Date().toISOString();
-  
-  if (error instanceof HttpError) {
-    console.error(`[${timestamp}] HTTP ${error.status}: ${error.message}`, error.details);
-    return new Response(JSON.stringify({
-      error: error.message,
-      details: error.details,
-      timestamp,
-    }), {
-      status: error.status,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-  
-  if (error instanceof SyntaxError && 'status' in error) {
-    console.error(`[${timestamp}] JSON Parse Error:`, error.message);
-    return new Response(JSON.stringify({
-      error: 'Invalid JSON in request body',
-      timestamp,
-    }), {
-      status: 400,
-      headers: { 'Content-Type': 'application/json' },
-    });
-  }
-  
-  console.error(`[${timestamp}] Internal Server Error:`, error);
-  return new Response(JSON.stringify({
-    error: 'Internal server error',
-    message: error instanceof Error ? error.message : 'Unknown error',
-    timestamp,
-  }), {
-    status: 500,
-    headers: { 'Content-Type': 'application/json' },
-  });
-}
-
-export function withErrorHandler(handler: (request: Request) => Promise<Response>): (request: Request) => Promise<Response> {
-  return async (request: Request) => {
-    try {
-      return await handler(request);
-    } catch (error) {
-      return errorHandler(error);
-    }
-  };
-}