cli4ai 1.0.4 → 1.1.1

package/src/server/service.ts

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