@fentz26/envcp 1.0.2 → 1.0.3

package/src/adapters/gemini.ts

@@ -1,228 +0,0 @@
-import { BaseAdapter } from './base.js';
-import { EnvCPConfig, GeminiFunctionDeclaration, GeminiFunctionCall, GeminiFunctionResponse } from '../types.js';
-import { setCorsHeaders, sendJson, parseBody, validateApiKey, RateLimiter, rateLimitMiddleware } from '../utils/http.js';
-import * as http from 'http';
-
-export class GeminiAdapter extends BaseAdapter {
-  private server: http.Server | null = null;
-  private rateLimiter = new RateLimiter(60, 60000);
-
-  constructor(config: EnvCPConfig, projectPath: string, password?: string) {
-    super(config, projectPath, password);
-  }
-
-  protected registerTools(): void {
-    this.registerDefaultTools();
-  }
-
-  // Convert tools to Gemini function declaration format
-  getGeminiFunctionDeclarations(): GeminiFunctionDeclaration[] {
-    return this.getToolDefinitions().map(tool => ({
-      name: tool.name,
-      description: tool.description,
-      parameters: {
-        type: 'object' as const,
-        properties: (tool.parameters as Record<string, unknown>).properties as Record<string, unknown> || {},
-        required: (tool.parameters as Record<string, unknown>).required as string[] | undefined,
-      },
-    }));
-  }
-
-  // Process Gemini function calls
-  async processFunctionCalls(calls: GeminiFunctionCall[]): Promise<GeminiFunctionResponse[]> {
-    const results: GeminiFunctionResponse[] = [];
-
-    for (const call of calls) {
-      try {
-        const result = await this.callTool(call.name, call.args);
-        results.push({
-          name: call.name,
-          response: { result },
-        });
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        results.push({
-          name: call.name,
-          response: { error: message },
-        });
-      }
-    }
-
-    return results;
-  }
-
-
-  async startServer(port: number, host: string, apiKey?: string): Promise<void> {
-    await this.init();
-
-    this.server = http.createServer(async (req, res) => {
-      setCorsHeaders(res, undefined, req.headers.origin);
-
-      if (req.method === 'OPTIONS') {
-        res.writeHead(204);
-        res.end();
-        return;
-      }
-
-      if (!rateLimitMiddleware(this.rateLimiter, req, res)) {
-        return;
-      }
-
-      // API key validation
-      if (apiKey) {
-        const providedKey = (req.headers['x-goog-api-key'] || req.headers['authorization']?.replace('Bearer ', '')) as string | undefined;
-        if (!validateApiKey(providedKey, apiKey)) {
-          sendJson(res, 401, { error: { code: 401, message: 'Invalid API key', status: 'UNAUTHENTICATED' } });
-          return;
-        }
-      }
-
-      const parsedUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-      const pathname = parsedUrl.pathname;
-
-      try {
-        // Gemini-compatible endpoints
-
-        // GET /v1/models - List models
-        if (pathname === '/v1/models' && req.method === 'GET') {
-          sendJson(res, 200, {
-            models: [{
-              name: 'models/envcp-1.0',
-              displayName: 'EnvCP Tool Server',
-              description: 'Environment variable management tools',
-              supportedGenerationMethods: ['generateContent'],
-            }],
-          });
-          return;
-        }
-
-        // GET /v1/tools - List available tools/functions
-        if (pathname === '/v1/tools' && req.method === 'GET') {
-          sendJson(res, 200, {
-            tools: [{
-              functionDeclarations: this.getGeminiFunctionDeclarations(),
-            }],
-          });
-          return;
-        }
-
-        // POST /v1/functions/call - Call a function directly
-        if (pathname === '/v1/functions/call' && req.method === 'POST') {
-          const body = await parseBody(req);
-          const { name, args } = body as { name: string; args: Record<string, unknown> };
-
-          if (!name) {
-            sendJson(res, 400, { error: { code: 400, message: 'Function name required', status: 'INVALID_ARGUMENT' } });
-            return;
-          }
-
-          const result = await this.callTool(name, args || {});
-          sendJson(res, 200, {
-            name,
-            response: { result },
-          });
-          return;
-        }
-
-        // POST /v1/function_calls - Process function calls (batch)
-        if (pathname === '/v1/function_calls' && req.method === 'POST') {
-          const body = await parseBody(req);
-          const { functionCalls } = body as { functionCalls: GeminiFunctionCall[] };
-
-          if (!functionCalls || !Array.isArray(functionCalls)) {
-            sendJson(res, 400, { error: { code: 400, message: 'functionCalls array required', status: 'INVALID_ARGUMENT' } });
-            return;
-          }
-
-          const results = await this.processFunctionCalls(functionCalls);
-          sendJson(res, 200, {
-            functionResponses: results,
-          });
-          return;
-        }
-
-        // POST /v1/models/envcp:generateContent - Gemini-style content generation
-        if ((pathname === '/v1/models/envcp:generateContent' || pathname === '/v1beta/models/envcp:generateContent') && req.method === 'POST') {
-          const body = await parseBody(req);
-          const contents = body.contents as Array<{ parts: Array<{ functionCall?: GeminiFunctionCall }> }> | undefined;
-
-          // Look for function calls in the content
-          const functionCalls: GeminiFunctionCall[] = [];
-          if (contents) {
-            for (const content of contents) {
-              for (const part of content.parts || []) {
-                if (part.functionCall) {
-                  functionCalls.push(part.functionCall);
-                }
-              }
-            }
-          }
-
-          if (functionCalls.length > 0) {
-            const results = await this.processFunctionCalls(functionCalls);
-            sendJson(res, 200, {
-              candidates: [{
-                content: {
-                  parts: results.map(r => ({
-                    functionResponse: r,
-                  })),
-                  role: 'model',
-                },
-                finishReason: 'STOP',
-              }],
-            });
-            return;
-          }
-
-          // Return available tools if no function calls
-          sendJson(res, 200, {
-            candidates: [{
-              content: {
-                parts: [{
-                  text: 'EnvCP tools available. Use function calling to interact with environment variables.',
-                }],
-                role: 'model',
-              },
-              finishReason: 'STOP',
-            }],
-            availableTools: [{
-              functionDeclarations: this.getGeminiFunctionDeclarations(),
-            }],
-          });
-          return;
-        }
-
-        // Health check
-        if (pathname === '/v1/health' || pathname === '/') {
-          sendJson(res, 200, {
-            status: 'ok',
-            version: '1.0.0',
-            mode: 'gemini',
-            endpoints: ['/v1/models', '/v1/tools', '/v1/functions/call', '/v1/function_calls', '/v1/models/envcp:generateContent'],
-          });
-          return;
-        }
-
-        // 404
-        sendJson(res, 404, { error: { code: 404, message: 'Not found', status: 'NOT_FOUND' } });
-
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        sendJson(res, 500, { error: { code: 500, message, status: 'INTERNAL' } });
-      }
-    });
-
-    return new Promise((resolve) => {
-      this.server!.listen(port, host, () => {
-        resolve();
-      });
-    });
-  }
-
-  stopServer(): void {
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-  }
-}

package/src/adapters/index.ts

@@ -1,4 +0,0 @@
-export { BaseAdapter } from './base.js';
-export { RESTAdapter } from './rest.js';
-export { OpenAIAdapter } from './openai.js';
-export { GeminiAdapter } from './gemini.js';

package/src/adapters/openai.ts

@@ -1,238 +0,0 @@
-import { BaseAdapter } from './base.js';
-import { EnvCPConfig, OpenAIFunction, OpenAIToolCall, OpenAIMessage } from '../types.js';
-import { setCorsHeaders, sendJson, parseBody, validateApiKey, RateLimiter, rateLimitMiddleware } from '../utils/http.js';
-import * as http from 'http';
-
-export class OpenAIAdapter extends BaseAdapter {
-  private server: http.Server | null = null;
-  private rateLimiter = new RateLimiter(60, 60000);
-
-  constructor(config: EnvCPConfig, projectPath: string, password?: string) {
-    super(config, projectPath, password);
-  }
-
-  protected registerTools(): void {
-    this.registerDefaultTools();
-  }
-
-  // Convert tools to OpenAI function format
-  getOpenAIFunctions(): OpenAIFunction[] {
-    return this.getToolDefinitions().map(tool => ({
-      name: tool.name,
-      description: tool.description,
-      parameters: {
-        type: 'object' as const,
-        properties: (tool.parameters as Record<string, unknown>).properties as Record<string, unknown> || {},
-        required: (tool.parameters as Record<string, unknown>).required as string[] | undefined,
-      },
-    }));
-  }
-
-  // Process OpenAI tool calls
-  async processToolCalls(toolCalls: OpenAIToolCall[]): Promise<OpenAIMessage[]> {
-    const results: OpenAIMessage[] = [];
-
-    for (const call of toolCalls) {
-      try {
-        const args = JSON.parse(call.function.arguments);
-        const result = await this.callTool(call.function.name, args);
-        results.push({
-          role: 'tool',
-          tool_call_id: call.id,
-          content: JSON.stringify(result),
-        });
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        results.push({
-          role: 'tool',
-          tool_call_id: call.id,
-          content: JSON.stringify({ error: message }),
-        });
-      }
-    }
-
-    return results;
-  }
-
-
-  async startServer(port: number, host: string, apiKey?: string): Promise<void> {
-    await this.init();
-
-    this.server = http.createServer(async (req, res) => {
-      setCorsHeaders(res, undefined, req.headers.origin);
-
-      if (req.method === 'OPTIONS') {
-        res.writeHead(204);
-        res.end();
-        return;
-      }
-
-      if (!rateLimitMiddleware(this.rateLimiter, req, res)) {
-        return;
-      }
-
-      // API key validation
-      if (apiKey) {
-        const providedKey = req.headers['authorization']?.replace('Bearer ', '');
-        if (!validateApiKey(providedKey, apiKey)) {
-          sendJson(res, 401, { error: { message: 'Invalid API key', type: 'invalid_api_key' } });
-          return;
-        }
-      }
-
-      const parsedUrl = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-      const pathname = parsedUrl.pathname;
-
-      try {
-        // OpenAI-compatible endpoints
-
-        // GET /v1/models - List models (for compatibility)
-        if (pathname === '/v1/models' && req.method === 'GET') {
-          sendJson(res, 200, {
-            object: 'list',
-            data: [{
-              id: 'envcp-1.0',
-              object: 'model',
-              created: Date.now(),
-              owned_by: 'envcp',
-            }],
-          });
-          return;
-        }
-
-        // GET /v1/functions - List available functions
-        if (pathname === '/v1/functions' && req.method === 'GET') {
-          sendJson(res, 200, {
-            object: 'list',
-            data: this.getOpenAIFunctions(),
-          });
-          return;
-        }
-
-        // POST /v1/functions/call - Call a function directly
-        if (pathname === '/v1/functions/call' && req.method === 'POST') {
-          const body = await parseBody(req);
-          const { name, arguments: args } = body as { name: string; arguments: Record<string, unknown> };
-          
-          if (!name) {
-            sendJson(res, 400, { error: { message: 'Function name required', type: 'invalid_request_error' } });
-            return;
-          }
-
-          const result = await this.callTool(name, args || {});
-          sendJson(res, 200, {
-            object: 'function_result',
-            name,
-            result,
-          });
-          return;
-        }
-
-        // POST /v1/tool_calls - Process tool calls (batch)
-        if (pathname === '/v1/tool_calls' && req.method === 'POST') {
-          const body = await parseBody(req);
-          const { tool_calls } = body as { tool_calls: OpenAIToolCall[] };
-
-          if (!tool_calls || !Array.isArray(tool_calls)) {
-            sendJson(res, 400, { error: { message: 'tool_calls array required', type: 'invalid_request_error' } });
-            return;
-          }
-
-          const results = await this.processToolCalls(tool_calls);
-          sendJson(res, 200, {
-            object: 'list',
-            data: results,
-          });
-          return;
-        }
-
-        // POST /v1/chat/completions - For integration with proxies
-        // This allows tools to be called through a chat completion-like interface
-        if (pathname === '/v1/chat/completions' && req.method === 'POST') {
-          const body = await parseBody(req);
-          const messages = body.messages as OpenAIMessage[] | undefined;
-
-          if (!messages || !Array.isArray(messages)) {
-            sendJson(res, 400, { error: { message: 'messages array required', type: 'invalid_request_error' } });
-            return;
-          }
-
-          // Check if last message has tool_calls to process
-          const lastMessage = messages[messages.length - 1];
-          if (lastMessage?.tool_calls) {
-            const results = await this.processToolCalls(lastMessage.tool_calls);
-            sendJson(res, 200, {
-              id: `chatcmpl-${Date.now()}`,
-              object: 'chat.completion',
-              created: Math.floor(Date.now() / 1000),
-              model: 'envcp-1.0',
-              choices: [{
-                index: 0,
-                message: {
-                  role: 'assistant',
-                  content: null,
-                  tool_calls: null,
-                },
-                finish_reason: 'tool_calls',
-              }],
-              tool_results: results,
-            });
-            return;
-          }
-
-          // Return available tools if no tool_calls
-          sendJson(res, 200, {
-            id: `chatcmpl-${Date.now()}`,
-            object: 'chat.completion',
-            created: Math.floor(Date.now() / 1000),
-            model: 'envcp-1.0',
-            choices: [{
-              index: 0,
-              message: {
-                role: 'assistant',
-                content: 'EnvCP tools available. Use function calling to interact with environment variables.',
-              },
-              finish_reason: 'stop',
-            }],
-            available_tools: this.getOpenAIFunctions().map(f => ({
-              type: 'function',
-              function: f,
-            })),
-          });
-          return;
-        }
-
-        // Health check
-        if (pathname === '/v1/health' || pathname === '/') {
-          sendJson(res, 200, {
-            status: 'ok',
-            version: '1.0.0',
-            mode: 'openai',
-            endpoints: ['/v1/models', '/v1/functions', '/v1/functions/call', '/v1/tool_calls', '/v1/chat/completions'],
-          });
-          return;
-        }
-
-        // 404
-        sendJson(res, 404, { error: { message: 'Not found', type: 'not_found' } });
-
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error);
-        sendJson(res, 500, { error: { message, type: 'internal_error' } });
-      }
-    });
-
-    return new Promise((resolve) => {
-      this.server!.listen(port, host, () => {
-        resolve();
-      });
-    });
-  }
-
-  stopServer(): void {
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-  }
-}