cli4ai 1.2.0 → 1.2.1

package/src/server/service.ts

@@ -1,434 +0,0 @@
-/**
- * cli4ai Remote Service
- *
- * HTTP server that exposes cli4ai functionality for remote execution.
- * Run with `cli4ai serve` to start the service.
- */
-
-import { createServer, IncomingMessage, ServerResponse } from 'http';
-import { hostname } from 'os';
-import { log, output } from '../lib/cli.js';
-import { executeTool, ExecuteToolError, type ScopeLevel } from '../core/execute.js';
-import { findPackage, getGlobalPackages, getLocalPackages } from '../core/config.js';
-import { loadManifest } from '../core/manifest.js';
-import {
-  loadRoutineDefinition,
-  runRoutine,
-  type RoutineRunSummary
-} from '../core/routine-engine.js';
-import { resolveRoutine } from '../core/routines.js';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// TYPES
-// ═══════════════════════════════════════════════════════════════════════════
-
-export interface ServiceConfig {
-  /** Port to listen on (default: 4100) */
-  port: number;
-  /** Host to bind to (default: 0.0.0.0) */
-  host: string;
-  /** API key for authentication (optional but recommended) */
-  apiKey?: string;
-  /** Working directory for command execution */
-  cwd: string;
-  /** Allowed scope levels (defaults to ['read', 'write', 'full']) */
-  allowedScopes?: ScopeLevel[];
-}
-
-export interface RunToolRequest {
-  /** Package name */
-  package: string;
-  /** Command within the package */
-  command?: string;
-  /** Arguments to pass */
-  args?: string[];
-  /** Environment variables */
-  env?: Record<string, string>;
-  /** Standard input to pass to the tool */
-  stdin?: string;
-  /** Timeout in milliseconds */
-  timeout?: number;
-  /** Scope level for execution */
-  scope?: ScopeLevel;
-}
-
-export interface RunToolResponse {
-  success: boolean;
-  exitCode: number;
-  stdout?: string;
-  stderr?: string;
-  durationMs: number;
-  error?: {
-    code: string;
-    message: string;
-    details?: Record<string, unknown>;
-  };
-}
-
-export interface RunRoutineRequest {
-  /** Routine name */
-  routine: string;
-  /** Variables to pass to the routine */
-  vars?: Record<string, string>;
-}
-
-export interface ListPackagesResponse {
-  packages: Array<{
-    name: string;
-    version: string;
-    path: string;
-    source: 'local' | 'registry';
-  }>;
-}
-
-export interface PackageInfoResponse {
-  name: string;
-  version: string;
-  description?: string;
-  commands?: Record<string, { description: string }>;
-}
-
-export interface HealthResponse {
-  status: 'ok';
-  hostname: string;
-  version: string;
-  uptime: number;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// HELPERS
-// ═══════════════════════════════════════════════════════════════════════════
-
-function parseBody(req: IncomingMessage): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    req.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-    req.on('error', reject);
-    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-  });
-}
-
-function sendJson(res: ServerResponse, status: number, data: unknown): void {
-  const body = JSON.stringify(data);
-  res.writeHead(status, {
-    'Content-Type': 'application/json',
-    'Content-Length': Buffer.byteLength(body)
-  });
-  res.end(body);
-}
-
-function sendError(res: ServerResponse, status: number, code: string, message: string, details?: Record<string, unknown>): void {
-  sendJson(res, status, { error: { code, message, details } });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// REQUEST HANDLERS
-// ═══════════════════════════════════════════════════════════════════════════
-
-async function handleHealth(config: ServiceConfig, startTime: number): Promise<HealthResponse> {
-  return {
-    status: 'ok',
-    hostname: hostname(),
-    version: '1.0.0',
-    uptime: Math.floor((Date.now() - startTime) / 1000)
-  };
-}
-
-async function handleListPackages(config: ServiceConfig): Promise<ListPackagesResponse> {
-  const localPkgs = getLocalPackages(config.cwd);
-  const globalPkgs = getGlobalPackages();
-
-  const packages = [
-    ...localPkgs.map(p => ({ name: p.name, version: p.version, path: p.path, source: p.source })),
-    ...globalPkgs.map(p => ({ name: p.name, version: p.version, path: p.path, source: p.source }))
-  ];
-
-  // Deduplicate by name (local takes precedence)
-  const seen = new Set<string>();
-  const unique = packages.filter(p => {
-    if (seen.has(p.name)) return false;
-    seen.add(p.name);
-    return true;
-  });
-
-  return { packages: unique };
-}
-
-async function handlePackageInfo(config: ServiceConfig, packageName: string): Promise<PackageInfoResponse | null> {
-  const pkg = findPackage(packageName, config.cwd);
-  if (!pkg) return null;
-
-  const manifest = loadManifest(pkg.path);
-
-  const commands: Record<string, { description: string }> = {};
-  if (manifest.commands) {
-    for (const [name, cmd] of Object.entries(manifest.commands)) {
-      commands[name] = { description: cmd.description };
-    }
-  }
-
-  return {
-    name: manifest.name,
-    version: manifest.version,
-    description: manifest.description,
-    commands
-  };
-}
-
-async function handleRunTool(config: ServiceConfig, request: RunToolRequest): Promise<RunToolResponse> {
-  const startTime = Date.now();
-
-  // Validate scope
-  const scope = request.scope ?? 'full';
-  const allowedScopes = config.allowedScopes ?? ['read', 'write', 'full'];
-  if (!allowedScopes.includes(scope)) {
-    return {
-      success: false,
-      exitCode: 1,
-      durationMs: Date.now() - startTime,
-      error: {
-        code: 'FORBIDDEN',
-        message: `Scope "${scope}" is not allowed on this remote`,
-        details: { allowedScopes }
-      }
-    };
-  }
-
-  try {
-    const result = await executeTool({
-      packageName: request.package,
-      command: request.command,
-      args: request.args ?? [],
-      cwd: config.cwd,
-      env: request.env,
-      stdin: request.stdin,
-      capture: 'pipe',
-      timeoutMs: request.timeout,
-      scope,
-      teeStderr: false
-    });
-
-    return {
-      success: result.exitCode === 0,
-      exitCode: result.exitCode,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      durationMs: result.durationMs
-    };
-  } catch (err) {
-    const durationMs = Date.now() - startTime;
-
-    if (err instanceof ExecuteToolError) {
-      return {
-        success: false,
-        exitCode: 1,
-        durationMs,
-        error: {
-          code: err.code,
-          message: err.message,
-          details: err.details
-        }
-      };
-    }
-
-    return {
-      success: false,
-      exitCode: 1,
-      durationMs,
-      error: {
-        code: 'API_ERROR',
-        message: err instanceof Error ? err.message : String(err)
-      }
-    };
-  }
-}
-
-async function handleRunRoutine(config: ServiceConfig, request: RunRoutineRequest): Promise<RoutineRunSummary | null> {
-  const resolved = resolveRoutine(request.routine, config.cwd);
-  if (!resolved) return null;
-
-  const def = loadRoutineDefinition(resolved.path);
-  const result = await runRoutine(def, request.vars ?? {}, config.cwd);
-
-  return result;
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// MAIN SERVER
-// ═══════════════════════════════════════════════════════════════════════════
-
-export function createService(config: ServiceConfig): ReturnType<typeof createServer> {
-  const startTime = Date.now();
-
-  const server = createServer(async (req, res) => {
-    const method = req.method ?? 'GET';
-    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
-    const path = url.pathname;
-
-    // CORS headers for cross-origin requests
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key');
-
-    // Handle preflight
-    if (method === 'OPTIONS') {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-
-    // Authentication check
-    if (config.apiKey) {
-      const providedKey = req.headers['x-api-key'] ||
-                          req.headers['authorization']?.replace(/^Bearer\s+/i, '');
-
-      if (providedKey !== config.apiKey) {
-        sendError(res, 401, 'UNAUTHORIZED', 'Invalid or missing API key');
-        return;
-      }
-    }
-
-    try {
-      // Route: GET /health
-      if (method === 'GET' && path === '/health') {
-        const data = await handleHealth(config, startTime);
-        sendJson(res, 200, data);
-        return;
-      }
-
-      // Route: GET /packages
-      if (method === 'GET' && path === '/packages') {
-        const data = await handleListPackages(config);
-        sendJson(res, 200, data);
-        return;
-      }
-
-      // Route: GET /packages/:name
-      if (method === 'GET' && path.startsWith('/packages/')) {
-        const packageName = path.slice('/packages/'.length);
-        const data = await handlePackageInfo(config, packageName);
-        if (!data) {
-          sendError(res, 404, 'NOT_FOUND', `Package not found: ${packageName}`);
-          return;
-        }
-        sendJson(res, 200, data);
-        return;
-      }
-
-      // Route: POST /run
-      if (method === 'POST' && path === '/run') {
-        const body = await parseBody(req);
-        let request: RunToolRequest;
-
-        try {
-          request = JSON.parse(body);
-        } catch {
-          sendError(res, 400, 'PARSE_ERROR', 'Invalid JSON body');
-          return;
-        }
-
-        if (!request.package || typeof request.package !== 'string') {
-          sendError(res, 400, 'INVALID_INPUT', 'Missing required field: package');
-          return;
-        }
-
-        const data = await handleRunTool(config, request);
-        sendJson(res, data.success ? 200 : 500, data);
-        return;
-      }
-
-      // Route: POST /routines/:name/run
-      if (method === 'POST' && path.match(/^\/routines\/[^/]+\/run$/)) {
-        const routineName = path.split('/')[2];
-        const body = await parseBody(req);
-        let request: RunRoutineRequest;
-
-        try {
-          request = body ? JSON.parse(body) : {};
-          request.routine = routineName;
-        } catch {
-          sendError(res, 400, 'PARSE_ERROR', 'Invalid JSON body');
-          return;
-        }
-
-        const data = await handleRunRoutine(config, request);
-        if (!data) {
-          sendError(res, 404, 'NOT_FOUND', `Routine not found: ${routineName}`);
-          return;
-        }
-
-        sendJson(res, data.status === 'success' ? 200 : 500, data);
-        return;
-      }
-
-      // 404 for unknown routes
-      sendError(res, 404, 'NOT_FOUND', `Unknown route: ${method} ${path}`);
-    } catch (err) {
-      console.error('Request error:', err);
-      sendError(res, 500, 'API_ERROR', err instanceof Error ? err.message : String(err));
-    }
-  });
-
-  return server;
-}
-
-export interface StartServiceOptions {
-  port?: number;
-  host?: string;
-  apiKey?: string;
-  cwd?: string;
-  allowedScopes?: ScopeLevel[];
-}
-
-export async function startService(options: StartServiceOptions = {}): Promise<void> {
-  const config: ServiceConfig = {
-    port: options.port ?? 4100,
-    host: options.host ?? '0.0.0.0',
-    apiKey: options.apiKey,
-    cwd: options.cwd ?? process.cwd(),
-    allowedScopes: options.allowedScopes
-  };
-
-  const server = createService(config);
-
-  return new Promise((resolve, reject) => {
-    server.on('error', (err: NodeJS.ErrnoException) => {
-      if (err.code === 'EADDRINUSE') {
-        reject(new Error(`Port ${config.port} is already in use`));
-      } else {
-        reject(err);
-      }
-    });
-
-    server.listen(config.port, config.host, () => {
-      log(`cli4ai service running on http://${config.host}:${config.port}`);
-      log(`Hostname: ${hostname()}`);
-      log(`Working directory: ${config.cwd}`);
-      if (config.apiKey) {
-        log(`Authentication: API key required`);
-      } else {
-        log(`Authentication: None (not recommended for production)`);
-      }
-      log('');
-      log('Endpoints:');
-      log('  GET  /health              - Service health check');
-      log('  GET  /packages            - List available packages');
-      log('  GET  /packages/:name      - Get package info');
-      log('  POST /run                 - Execute a tool');
-      log('  POST /routines/:name/run  - Run a routine');
-      log('');
-      log('Press Ctrl+C to stop');
-    });
-
-    // Handle graceful shutdown
-    const shutdown = () => {
-      log('\nShutting down...');
-      server.close(() => {
-        resolve();
-      });
-    };
-
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-  });
-}