prepia 1.0.0

package/src/client/connector.mjs

@@ -0,0 +1,391 @@
+/**
+ * Prepia Universal Connector
+ * Auto-detects and connects any AI agent to Prepia
+ * Supports: HTTP REST, WebSocket, CLI, Webhook, stdio
+ */
+
+import { EventEmitter } from 'events';
+import http from 'http';
+import { PrepiClient, prepiConnect } from './index.mjs';
+import { WebSocketServer } from './websocket.mjs';
+import { createAdapter, listAdapters } from './adapters.mjs';
+
+/**
+ * @typedef {Object} ConnectorConfig
+ * @property {number} [port=4710] - Server port
+ * @property {string} [host='0.0.0.0'] - Bind host
+ * @property {string} [apiKey] - Required API key (null = no auth)
+ * @property {boolean} [cors=true] - Enable CORS
+ * @property {number} [maxConnections=100] - Max concurrent WebSocket connections
+ * @property {boolean} [websocket=true] - Enable WebSocket support
+ * @property {Object} [rateLimit] - Per-client rate limiting
+ * @property {number} [rateLimit.windowMs=60000] - Rate limit window
+ * @property {number} [rateLimit.maxRequests=100] - Max requests per window
+ */
+
+/**
+ * Prepia Universal Connector Server
+ * Accepts connections from ANY AI agent via REST, WebSocket, or CLI
+ */
+export class PrepiaConnector extends EventEmitter {
+  /**
+   * @param {ConnectorConfig} config
+   * @param {import('../core/engine.mjs').PrepiaEngine} engine - Prepia engine instance
+   */
+  constructor(config = {}, engine = null) {
+    super();
+    this.config = {
+      port: config.port != null ? config.port : 4710,
+      host: config.host || '0.0.0.0',
+      apiKey: config.apiKey || null,
+      cors: config.cors !== false,
+      maxConnections: config.maxConnections || 100,
+      websocket: config.websocket !== false,
+      rateLimit: config.rateLimit || { windowMs: 60000, maxRequests: 100 },
+    };
+    this.engine = engine;
+    this.server = null;
+    this.wsServer = null;
+    /** @type {Map<string, { count: number, resetAt: number }>} */
+    this.rateLimits = new Map();
+    this.running = false;
+  }
+
+  /**
+   * Start the connector server
+   * @returns {Promise<void>}
+   */
+  async start() {
+    if (this.running) return;
+
+    this.server = http.createServer((req, res) => this._handleRequest(req, res));
+
+    if (this.config.websocket) {
+      this.wsServer = new WebSocketServer();
+      this.server.on('upgrade', (req, socket, head) => {
+        if (this.wsServer.clients.size >= this.config.maxConnections) {
+          socket.destroy();
+          return;
+        }
+        if (!this._authenticate(req)) {
+          socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+          socket.destroy();
+          return;
+        }
+        this.wsServer.handleUpgrade(req, socket, head);
+      });
+
+      this.wsServer.on('task:submit', async (conn, data, msg) => {
+        try {
+          conn.send({ event: 'task:started', taskId: msg.taskId, timestamp: Date.now() });
+          const result = await this._executeTask(data, (phase) => {
+            conn.send({ event: 'task:progress', taskId: msg.taskId, data: phase });
+          });
+          conn.send({ event: 'task:complete', taskId: msg.taskId, data: result });
+        } catch (err) {
+          conn.send({ event: 'task:error', taskId: msg.taskId, data: { error: err.message } });
+        }
+      });
+    }
+
+    return new Promise((resolve) => {
+      this.server.listen(this.config.port, this.config.host, () => {
+        this.running = true;
+        this.emit('started', { host: this.config.host, port: this.config.port });
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Stop the connector server
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    if (!this.running) return;
+    if (this.wsServer) this.wsServer.closeAll();
+    return new Promise((resolve) => {
+      this.server.close(() => {
+        this.running = false;
+        this.emit('stopped');
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Handle incoming HTTP request
+   * @param {http.IncomingMessage} req
+   * @param {http.ServerResponse} res
+   */
+  async _handleRequest(req, res) {
+    // CORS
+    if (this.config.cors) {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Prepia-Agent-Id, X-Prepia-Agent-Type');
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+    }
+
+    // Auth
+    if (!this._authenticate(req)) {
+      this._json(res, 401, { error: 'Unauthorized', message: 'Invalid or missing API key' });
+      return;
+    }
+
+    // Rate limit
+    const clientId = this._getClientId(req);
+    if (!this._checkRateLimit(clientId)) {
+      this._json(res, 429, { error: 'Rate limited', message: 'Too many requests', retryAfter: this.config.rateLimit.windowMs / 1000 });
+      return;
+    }
+
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const path = url.pathname;
+    const method = req.method;
+
+    try {
+      // Parse body for POST/PUT
+      let body = null;
+      if (method === 'POST' || method === 'PUT') {
+        body = await this._parseBody(req);
+      }
+
+      // Route request
+      const result = await this._route(method, path, body, req, url.searchParams);
+      this._json(res, result.status || 200, result.data || result);
+    } catch (err) {
+      const status = err.status || 500;
+      this._json(res, status, { error: err.message, code: err.code });
+    }
+  }
+
+  /**
+   * Route request to appropriate handler
+   */
+  async _route(method, path, body, req, params) {
+    // Health
+    if (path === '/api/health' && method === 'GET') {
+      return {
+        data: {
+          status: 'ok',
+          version: '1.0.0',
+          uptime: process.uptime(),
+          connections: this.wsServer?.clientCount || 0,
+          adapters: listAdapters(),
+          features: {
+            websocket: this.config.websocket,
+            caching: true,
+            analytics: true,
+            plugins: true,
+          },
+        },
+      };
+    }
+
+    // Task submission
+    if (path === '/api/task' && method === 'POST') {
+      if (!body?.description) {
+        throw Object.assign(new Error('Missing required field: description'), { status: 400 });
+      }
+      const onProgress = (phase) => this.emit('task:progress', phase);
+      const result = await this._executeTask(body, onProgress);
+      return { data: result };
+    }
+
+    // Analytics
+    if (path === '/api/analytics' && method === 'GET') {
+      if (this.engine?.analytics) {
+        return { data: this.engine.analytics.getReport() };
+      }
+      return { data: { message: 'Analytics not available' } };
+    }
+
+    // Cache
+    if (path === '/api/cache' && method === 'DELETE') {
+      if (this.engine?.cache) {
+        this.engine.cache.clear();
+        return { data: { message: 'Cache cleared' } };
+      }
+      return { data: { message: 'Cache not available' } };
+    }
+
+    if (path.startsWith('/api/cache/') && method === 'DELETE') {
+      const key = decodeURIComponent(path.slice('/api/cache/'.length));
+      if (this.engine?.cache) {
+        this.engine.cache.delete(key);
+        return { data: { message: `Cache key '${key}' deleted` } };
+      }
+      return { data: { message: 'Cache not available' } };
+    }
+
+    // Plugins
+    if (path === '/api/plugins' && method === 'GET') {
+      if (this.engine?.plugins) {
+        return { data: this.engine.plugins.list() };
+      }
+      return { data: [] };
+    }
+
+    // Config
+    if (path === '/api/config' && method === 'GET') {
+      return { data: this.engine?.getConfig?.() || {} };
+    }
+    if (path === '/api/config' && method === 'POST') {
+      if (this.engine?.updateConfig) {
+        this.engine.updateConfig(body);
+        return { data: { message: 'Config updated' } };
+      }
+      return { data: { message: 'Config update not available' } };
+    }
+
+    // Script execution
+    if (path === '/api/script' && method === 'POST') {
+      if (!body?.script) {
+        throw Object.assign(new Error('Missing required field: script'), { status: 400 });
+      }
+      if (this.engine?.script) {
+        const result = await this.engine.script.execute(body.script);
+        return { data: result };
+      }
+      return { data: { message: 'Script engine not available' } };
+    }
+
+    // Knowledge base
+    if (path === '/api/knowledge' && method === 'GET') {
+      const query = params.get('q');
+      if (this.engine?.vault) {
+        const results = this.engine.vault.search(query || '');
+        return { data: results };
+      }
+      return { data: [] };
+    }
+    if (path === '/api/knowledge' && method === 'POST') {
+      if (this.engine?.vault && body?.key) {
+        this.engine.vault.store(body.key, body.value, body);
+        return { data: { message: 'Stored' } };
+      }
+      throw Object.assign(new Error('Missing key'), { status: 400 });
+    }
+
+    // Adapters info
+    if (path === '/api/adapters' && method === 'GET') {
+      return { data: { adapters: listAdapters() } };
+    }
+
+    // Python client generation
+    if (path === '/api/client/python' && method === 'GET') {
+      const { PythonBridgeAdapter } = await import('./adapters.mjs');
+      const adapter = new PythonBridgeAdapter({ host: this.config.host, port: this.config.port });
+      return { data: { code: adapter.generatePythonClient() } };
+    }
+
+    // OpenAPI spec
+    if (path === '/api/spec' && method === 'GET') {
+      const { RestAdapter } = await import('./adapters.mjs');
+      const adapter = new RestAdapter({ host: this.config.host, port: this.config.port });
+      return { data: adapter.getOpenAPISpec() };
+    }
+
+    throw Object.assign(new Error(`Not found: ${method} ${path}`), { status: 404 });
+  }
+
+  /**
+   * Execute a task through the engine
+   */
+  async _executeTask(taskData, onProgress) {
+    if (this.engine) {
+      return this.engine.process(taskData, onProgress);
+    }
+    // Fallback if no engine attached
+    return {
+      status: 'no_engine',
+      message: 'Prepia engine not attached. Connect an engine to process tasks.',
+      input: taskData,
+    };
+  }
+
+  /**
+   * Authenticate request
+   */
+  _authenticate(req) {
+    if (!this.config.apiKey) return true;
+    const auth = req.headers.authorization;
+    if (!auth) return false;
+    const token = auth.replace(/^Bearer\s+/i, '');
+    return token === this.config.apiKey;
+  }
+
+  /**
+   * Get client identifier for rate limiting
+   */
+  _getClientId(req) {
+    return req.headers['x-prepia-agent-id'] || req.socket.remoteAddress || 'unknown';
+  }
+
+  /**
+   * Check rate limit for a client
+   */
+  _checkRateLimit(clientId) {
+    const now = Date.now();
+    const limit = this.rateLimits.get(clientId);
+
+    if (!limit || now > limit.resetAt) {
+      this.rateLimits.set(clientId, { count: 1, resetAt: now + this.config.rateLimit.windowMs });
+      return true;
+    }
+
+    if (limit.count >= this.config.rateLimit.maxRequests) {
+      return false;
+    }
+
+    limit.count++;
+    return true;
+  }
+
+  /**
+   * Parse JSON request body
+   */
+  _parseBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on('data', (chunk) => chunks.push(chunk));
+      req.on('end', () => {
+        const raw = Buffer.concat(chunks).toString();
+        if (!raw) return resolve(null);
+        try {
+          resolve(JSON.parse(raw));
+        } catch {
+          reject(Object.assign(new Error('Invalid JSON body'), { status: 400 }));
+        }
+      });
+      req.on('error', reject);
+    });
+  }
+
+  /**
+   * Send JSON response
+   */
+  _json(res, status, data) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+  }
+}
+
+/**
+ * Create and start a Prepia connector
+ * @param {ConnectorConfig} config
+ * @param {import('../core/engine.mjs').PrepiaEngine} engine
+ * @returns {Promise<PrepiaConnector>}
+ */
+export async function startConnector(config = {}, engine = null) {
+  const connector = new PrepiaConnector(config, engine);
+  await connector.start();
+  return connector;
+}
+
+export default PrepiaConnector;