voracode 0.0.1

package/src/models/router.ts

@@ -0,0 +1,426 @@
+/**
+ * VORACODE Model Router — Universal AI provider adapter
+ *
+ * Supports any AI provider through a unified interface.
+ *
+ * Provider protocols supported:
+ * - OpenAI-compatible (DeepSeek, Groq, Together, Ollama, OpenRouter, etc.)
+ * - Anthropic Messages API (Claude)
+ * - Google AI API (Gemini)
+ * - Custom (user-defined)
+ *
+ * BYOK ONLY — user must provide their own API key.
+ * VORACODE does not provide free managed models.
+ */
+
+export interface ChatMessage {
+  role: "user" | "assistant" | "system" | "tool";
+  content: string;
+  name?: string;
+  tool_calls?: Array<{
+    id: string;
+    type: "function";
+    function: { name: string; arguments: string };
+  }>;
+  tool_call_id?: string;
+}
+
+export interface ToolDefinition {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export interface ChatOptions {
+  model: string;
+  maxTokens?: number;
+  temperature?: number;
+  systemPrompt?: string;
+  stream?: boolean;
+  tools?: ToolDefinition[];
+  toolChoice?: "auto" | "required" | "none";
+}
+
+export interface ChatResponse {
+  content: string;
+  model: string;
+  provider: string;
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+  };
+  toolCalls?: Array<{
+    id: string;
+    type: "function";
+    function: { name: string; arguments: string };
+  }>;
+}
+
+interface ProviderConfig {
+  apiKey?: string;
+  baseUrl: string;
+}
+
+const PROVIDER_BASE_URLS: Record<string, string> = {
+  openai: "https://api.openai.com/v1",
+  deepseek: "https://api.deepseek.com/v1",
+  groq: "https://api.groq.com/openai/v1",
+  together: "https://api.together.xyz/v1",
+  openrouter: "https://openrouter.ai/api/v1",
+  ollama: "http://localhost:11434/v1",
+  huggingface: "https://router.huggingface.co/v1",
+  fireworks: "https://api.fireworks.ai/inference/v1",
+  cerebras: "https://api.cerebras.ai/v1",
+  anthropic: "https://api.anthropic.com/v1",
+  google: "https://generativelanguage.googleapis.com/v1beta",
+};
+
+const PROVIDER_KEY_PATTERNS: Record<string, RegExp> = {
+  openai: /^(sk-|sx-)/,
+  anthropic: /^sk-ant-/,
+  deepseek: /^sk-/,
+  groq: /^gsk_/,
+};
+
+// ── Rate Limiter ──
+
+class RateLimiter {
+  private calls: Map<string, number[]> = new Map();
+  private readonly windowMs = 60_000; // 1 minute
+  private readonly maxCalls = 10;     // 10 calls per minute
+
+  canCall(provider: string): boolean {
+    const now = Date.now();
+    const timestamps = this.calls.get(provider) || [];
+
+    // Remove entries older than the window
+    const recent = timestamps.filter((t) => now - t < this.windowMs);
+    this.calls.set(provider, recent);
+
+    if (recent.length >= this.maxCalls) {
+      return false; // Rate limited
+    }
+
+    recent.push(now);
+    this.calls.set(provider, recent);
+    return true;
+  }
+
+  retryAfter(provider: string): number {
+    const timestamps = this.calls.get(provider) || [];
+    if (timestamps.length === 0) return 0;
+    const oldest = timestamps[0];
+    return Math.max(0, Math.ceil((this.windowMs - (Date.now() - oldest)) / 1000));
+  }
+}
+
+export class ModelRouter {
+  private keychain: Map<string, string> = new Map();
+  private rateLimiter: RateLimiter = new RateLimiter();
+
+  constructor() {
+    // Keys will be loaded from OS Keychain in Phase 1.3
+    // For now, use environment variables
+    this.loadFromEnv();
+  }
+
+  private loadFromEnv(): void {
+    const envMap: Record<string, string | undefined> = {
+      openai: process.env.OPENAI_API_KEY || process.env.OPENAI_KEY,
+      anthropic: process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_KEY,
+      deepseek: process.env.DEEPSEEK_API_KEY || process.env.DEEPSEEK_KEY,
+      groq: process.env.GROQ_API_KEY || process.env.GROQ_KEY,
+      google: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY,
+      openrouter: process.env.OPENROUTER_API_KEY,
+      huggingface: process.env.HF_API_KEY || process.env.HUGGINGFACE_KEY,
+      together: process.env.TOGETHER_API_KEY,
+      ollama: "", // No key needed for local
+    };
+
+    for (const [provider, key] of Object.entries(envMap)) {
+      if (key) {
+        this.keychain.set(provider, key);
+      }
+    }
+  }
+
+  /**
+   * Get the active API key for a provider
+   */
+  getKey(provider: string): string | undefined {
+    return this.keychain.get(provider);
+  }
+
+  /**
+   * Set an API key for a provider
+   */
+  setKey(provider: string, key: string): void {
+    this.keychain.set(provider, key);
+  }
+
+  /**
+   * Check if a provider has a valid-looking API key configured
+   */
+  hasValidKey(provider: string): boolean {
+    const key = this.keychain.get(provider);
+    if (!key) return false;
+
+    const pattern = PROVIDER_KEY_PATTERNS[provider];
+    if (pattern) return pattern.test(key);
+    return key.length > 8;
+  }
+
+  /**
+   * Detect provider from model name
+   */
+  detectProvider(modelName: string): string {
+    const normalized = modelName.toLowerCase();
+
+    if (normalized.startsWith("gpt-") || normalized.startsWith("o3") || normalized.startsWith("o1")) return "openai";
+    if (normalized.startsWith("claude-") || normalized.startsWith("opus") || normalized.startsWith("sonnet") || normalized.startsWith("haiku")) return "anthropic";
+    if (normalized.startsWith("gemini-")) return "google";
+    if (normalized.startsWith("deepseek-")) return "deepseek";
+    if (normalized.startsWith("llama-") || normalized.startsWith("mixtral") || normalized.startsWith("qwen-")) return "groq";
+    if (normalized.startsWith("command-")) return "cohere";
+
+    return "openai"; // default fallback
+  }
+
+  /**
+   * Get available models for a provider
+   */
+  getModels(provider: string): string[] {
+    const modelMap: Record<string, string[]> = {
+      openai: ["gpt-4o", "gpt-4o-mini", "o3-mini", "o1"],
+      anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-haiku-4"],
+      deepseek: ["deepseek-chat", "deepseek-v4-flash", "deepseek-v4-pro"],
+      groq: ["llama-3.1-8b", "llama-3.1-70b", "qwen-32b", "mixtral-8x7b"],
+      google: ["gemini-2.5-pro", "gemini-2.5-flash"],
+      ollama: ["llama3.2", "mistral", "deepseek-coder-v2", "qwen2.5-coder"],
+      openrouter: ["openrouter/auto"],
+      huggingface: ["HuggingFaceH4/zephyr-7b-beta"],
+    };
+    return modelMap[provider] || [];
+  }
+
+  /**
+   * Get provider base URL
+   */
+  getBaseUrl(provider: string): string {
+    return PROVIDER_BASE_URLS[provider] || "";
+  }
+
+  /**
+   * Chat completion using OpenAI-compatible API
+   * Covers: DeepSeek, Groq, Together, Ollama, OpenRouter, HuggingFace
+   */
+  async chatOpenAI(provider: string, messages: ChatMessage[], options: ChatOptions): Promise<ChatResponse> {
+    const baseUrl = this.getBaseUrl(provider);
+    const apiKey = this.keychain.get(provider);
+
+    if (!apiKey && provider !== "ollama") {
+      throw new Error(`No API key configured for ${provider}. Run: voracode key set ${provider}`);
+    }
+
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: apiKey ? `Bearer ${apiKey}` : "",
+      },
+      body: JSON.stringify({
+        model: options.model,
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content,
+          ...(m.name ? { name: m.name } : {}),
+          ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+          ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}),
+        })),
+        max_tokens: options.maxTokens || 4096,
+        temperature: options.temperature ?? 0.7,
+        stream: false,
+        ...(options.tools && options.tools.length > 0 ? { tools: options.tools, tool_choice: options.toolChoice || "auto" } : {}),
+      }),
+      signal: AbortSignal.timeout(60_000), // 60s timeout
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(`${provider} API error (${response.status}): ${errorBody}`);
+    }
+
+    const data = await response.json() as {
+      choices: Array<{ message: { content: string; tool_calls?: Array<{ id: string; type: "function"; function: { name: string; arguments: string } }> } }>;
+      usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
+      model: string;
+    };
+
+    return {
+      content: data.choices[0]?.message?.content || "",
+      model: data.model,
+      provider,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens || 0,
+        outputTokens: data.usage?.completion_tokens || 0,
+        totalTokens: data.usage?.total_tokens || 0,
+      },
+      toolCalls: data.choices[0]?.message?.tool_calls,
+    };
+  }
+
+  /**
+   * Chat completion using Anthropic Messages API
+   */
+  async chatAnthropic(messages: ChatMessage[], options: ChatOptions): Promise<ChatResponse> {
+    const apiKey = this.keychain.get("anthropic");
+    if (!apiKey) throw new Error("No API key configured for Anthropic. Run: voracode key set anthropic");
+
+    // Convert messages to Anthropic format
+    const systemMsg = messages.find((m) => m.role === "system");
+    const nonSystem = messages.filter((m) => m.role !== "system");
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model: options.model,
+        messages: nonSystem.map((m) => ({
+          role: m.role === "assistant" ? "assistant" : "user",
+          content: m.content,
+        })),
+        system: systemMsg?.content,
+        max_tokens: options.maxTokens || 4096,
+        temperature: options.temperature ?? 0.7,
+      }),
+      signal: AbortSignal.timeout(60_000), // 60s timeout
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(`Anthropic API error (${response.status}): ${errorBody}`);
+    }
+
+    const data = await response.json() as {
+      content: Array<{ text: string }>;
+      model: string;
+      usage: { input_tokens: number; output_tokens: number };
+    };
+
+    return {
+      content: data.content?.[0]?.text || "",
+      model: data.model,
+      provider: "anthropic",
+      usage: {
+        inputTokens: data.usage?.input_tokens || 0,
+        outputTokens: data.usage?.output_tokens || 0,
+        totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+      },
+    };
+  }
+
+  /**
+   * Main chat method — auto-selects correct adapter based on model name
+   */
+  async chat(modelRef: string, messages: ChatMessage[], options: ChatOptions = {}): Promise<ChatResponse> {
+    const provider = modelRef.includes("/") ? modelRef.split("/")[0] : this.detectProvider(modelRef);
+    const modelName = modelRef.includes("/") ? modelRef.slice(modelRef.indexOf("/") + 1) : modelRef;
+
+    // Rate limit check
+    if (!this.rateLimiter.canCall(provider)) {
+      const retryAfter = this.rateLimiter.retryAfter(provider);
+      throw new Error(`Rate limited on ${provider}. Retry in ${retryAfter}s. Use voracode pro for higher limits.`);
+    }
+
+    const fullOptions = { ...options, model: modelName };
+
+    try {
+      switch (provider) {
+        case "anthropic":
+          return await this.chatAnthropic(messages, fullOptions);
+        case "google":
+          return await this.chatGoogle(messages, fullOptions);
+        default:
+          return await this.chatOpenAI(provider, messages, fullOptions);
+      }
+    } catch (error) {
+      // Auto-fallback: try next provider
+      const fallbacks = ["deepseek", "groq", "openrouter"];
+      for (const fb of fallbacks) {
+        if (fb === provider) continue;
+        const fbKey = this.keychain.get(fb);
+        if (fbKey) {
+          try {
+            return await this.chatOpenAI(fb, messages, { ...fullOptions, model: this.getModels(fb)[0] || fb });
+          } catch {
+            continue; // Try next fallback
+          }
+        }
+      }
+      throw error; // All fallbacks exhausted
+    }
+  }
+
+  /**
+   * Chat completion using Google AI API
+   */
+  async chatGoogle(messages: ChatMessage[], _options: ChatOptions): Promise<ChatResponse> {
+    const apiKey = this.keychain.get("google");
+    if (!apiKey) throw new Error("No API key configured for Google. Run: voracode key set google");
+
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${_options.model}:generateContent`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey,  // Use header instead of URL query param
+        },
+        body: JSON.stringify({
+          contents: messages
+            .filter((m) => m.role !== "system")
+            .map((m) => ({
+              role: m.role === "assistant" ? "model" : "user",
+              parts: [{ text: m.content }],
+            })),
+          systemInstruction: messages.find((m) => m.role === "system")?.content
+            ? { parts: [{ text: messages.find((m) => m.role === "system")!.content }] }
+            : undefined,
+          generationConfig: {
+            maxOutputTokens: _options.maxTokens || 4096,
+            temperature: _options.temperature ?? 0.7,
+          },
+        }),
+      },
+    );
+
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(`Google API error (${response.status}): ${errorBody}`);
+    }
+
+    const data = await response.json() as {
+      candidates: Array<{ content: { parts: Array<{ text: string }> } }>;
+      usageMetadata?: { promptTokenCount: number; candidatesTokenCount: number; totalTokenCount: number };
+    };
+
+    return {
+      content: data.candidates?.[0]?.content?.parts?.[0]?.text || "",
+      model: _options.model,
+      provider: "google",
+      usage: {
+        inputTokens: data.usageMetadata?.promptTokenCount || 0,
+        outputTokens: data.usageMetadata?.candidatesTokenCount || 0,
+        totalTokens: data.usageMetadata?.totalTokenCount || 0,
+      },
+    };
+  }
+}

package/src/security/owasp.ts

@@ -0,0 +1,254 @@
+/**
+ * VORACODE OWASP Security Layer
+ *
+ * Protects against OWASP Top 10 + 40 years of common vulnerabilities:
+ * - Prompt injection (new OWASP LLM Top 10)
+ * - Command injection
+ * - Path traversal
+ * - SSRF
+ * - SQL injection
+ * - XXE
+ * - Supply chain
+ * - Credential leakage
+ * - Data exfiltration
+ * - Rate limiting abuse
+ */
+
+export class OwaspShield {
+  private auditLog: string[] = [];
+
+  /**
+   * Scan user input for injection patterns
+   */
+  sanitizeInput(input: string): { clean: string; blocked: boolean; reason?: string } {
+    // Block control characters (except newlines and tabs)
+    const controlChars = input.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+    if (controlChars.length !== input.length) {
+      this.log("blocked", "Control characters in input");
+    }
+
+    // Detect prompt injection attempts
+    const injectionPatterns = [
+      /ignore\s+(all\s+)?(previous|above|below)\s+(instructions|commands)/i,
+      /forget\s+(all\s+)?(previous|above|below)\s+(instructions|commands)/i,
+      /you\s+(are\s+)?(now|will\s+now)\s+(act\s+as|become|be)/i,
+      /system\s+prompt/i,
+      /new\s+(instructions|commands|task)/i,
+      /disregard\s+(previous|above)/i,
+      /\[SYSTEM\]|\[INST\]|<\|im_start\|>|<\|\s*im_start\s*\|>/i,
+      /role\s*:\s*system/i,
+    ];
+
+    for (const pattern of injectionPatterns) {
+      if (pattern.test(input)) {
+        this.log("blocked", `Prompt injection detected: ${pattern.source}`);
+        return { clean: input, blocked: true, reason: "Potential prompt injection detected" };
+      }
+    }
+
+    return { clean: input, blocked: false };
+  }
+
+  /**
+   * Validate LLM output for dangerous content
+   */
+  validateOutput(output: string): { safe: boolean; sanitized: string; reason?: string } {
+    // Check for credential leakage
+    const credentialPatterns = [
+      /sk-[a-zA-Z0-9]{20,}/,           // OpenAI keys
+      /sk-ant-[a-zA-Z0-9]{20,}/,        // Anthropic keys
+      /gsk_[a-zA-Z0-9]{20,}/,           // Groq keys
+      /AIza[a-zA-Z0-9_-]{35}/,          // Google keys
+      /ghp_[a-zA-Z0-9]{36}/,            // GitHub tokens
+      /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----/i, // Private keys
+      /password\s*[:=]\s*\S+/i,         // Password leakage
+      /api[_-]?key\s*[:=]\s*\S+/i,      // API key leakage
+    ];
+
+    let sanitized = output;
+    for (const pattern of credentialPatterns) {
+      if (pattern.test(sanitized)) {
+        sanitized = sanitized.replace(pattern, "[REDACTED - CREDENTIAL]");
+        this.log("redacted", "Credential pattern detected in output");
+      }
+    }
+
+    // Check for dangerous code patterns in LLM output
+    const dangerousCode = [
+      /rm\s+-rf\s+\//g,
+      />\s*\/dev\/(sda|sdb|sdc)/g,
+      /:\(\s*\)\s*\{/g,
+      /eval\(\s*request/i,
+      /exec\(\s*request/i,
+      /system\(\s*request/i,
+    ];
+
+    for (const pattern of dangerousCode) {
+      if (pattern.test(sanitized)) {
+        this.log("warn", "Dangerous code pattern in output");
+      }
+    }
+
+    return { safe: true, sanitized };
+  }
+
+  /**
+   * Check SSRF protection — block private IPs, internal services
+   */
+  validateUrl(url: string): { safe: boolean; reason?: string } {
+    try {
+      const parsed = new URL(url);
+
+      // Block private/internal IP ranges
+      const blockedPatterns = [
+        /^localhost$/i,
+        /^127\.\d+\.\d+\.\d+$/,
+        /^10\.\d+\.\d+\.\d+$/,
+        /^172\.(1[6-9]|2\d|3[01])\.\d+\.\d+$/,
+        /^192\.168\.\d+\.\d+$/,
+        /^0\.0\.0\.0$/,
+        /^::1$/,
+        /^fc00:/i,
+        /^fe80:/i,
+        /^169\.254\.\d+\.\d+$/,
+      ];
+
+      const hostname = parsed.hostname;
+      for (const pattern of blockedPatterns) {
+        if (pattern.test(hostname)) {
+          this.log("blocked", `SSRF blocked: ${url}`);
+          return { safe: false, reason: "Internal/private address blocked (SSRF)" };
+        }
+      }
+
+      // Block known internal services
+      const internalServices = [
+        /metadata\.google\.internal/i,
+        /169\.254\.169\.254/,       // AWS/GCP/Azure metadata
+        /\.internal$/i,
+        /\.local$/i,
+      ];
+
+      for (const pattern of internalServices) {
+        if (pattern.test(hostname)) {
+          this.log("blocked", `Internal service blocked: ${url}`);
+          return { safe: false, reason: "Cloud metadata endpoint blocked" };
+        }
+      }
+
+      return { safe: true };
+    } catch {
+      return { safe: false, reason: "Invalid URL" };
+    }
+  }
+
+  /**
+   * Check for path traversal in file operations
+   */
+  validatePath(requestedPath: string, projectRoot: string): { safe: boolean; resolvedPath?: string; reason?: string } {
+    const path = require("path");
+    const resolved = path.resolve(projectRoot, requestedPath);
+
+    // Ensure resolved path starts with project root
+    if (!resolved.startsWith(projectRoot)) {
+      this.log("blocked", `Path traversal blocked: ${requestedPath}`);
+      return { safe: false, reason: "Path traversal detected" };
+    }
+
+    // Block sensitive files
+    const sensitiveFiles = [
+      /\.env$/,
+      /\.env\./,
+      /credentials\.json$/,
+      /config\.json$/i,
+      /\.ssh\//,
+      /id_rsa/,
+      /\.pem$/,
+      /\.key$/,
+      /\.cert$/,
+      /\/etc\//,
+      /\/proc\//,
+      /\/sys\//,
+      /\/dev\//,
+    ];
+
+    for (const pattern of sensitiveFiles) {
+      if (pattern.test(resolved)) {
+        this.log("blocked", `Sensitive file blocked: ${resolved}`);
+        return { safe: false, reason: "Access to sensitive files blocked" };
+      }
+    }
+
+    return { safe: true, resolvedPath: resolved };
+  }
+
+  /**
+   * Detect and block command injection in bash/shell commands
+   */
+  validateCommand(command: string): { safe: boolean; reason?: string } {
+    // Block dangerous commands
+    const blockedCommands = [
+      /^rm\s+-rf\s+\//m, /^sudo\s+/m, /^mkfs/m, /^dd\s+if=/m,
+      /^:\(\)/, /^chmod\s+777\s+\//m,
+      /^>\s*\/dev\//m, /bash\s+-c\s+/i, /sh\s+-c\s+/i,
+      /powershell\s+-c\s+/i, /cmd\.exe\s+\/c/i,
+      /`.*`/, /\$\(.*\)/, /\|.*(bash|sh|zsh|fish)/i,
+      /curl.*\|.*bash/i, /wget.*\|.*bash/i,
+      /nc\s+/, /ncat\s+/, /netcat\s+/,
+      /mkpasswd/, /openssl\s+(passwd|enc)/i,
+      /\/etc\/(passwd|shadow)/,
+    ];
+
+    for (const pattern of blockedCommands) {
+      if (pattern.test(command)) {
+        this.log("blocked", `Command injection blocked: ${command.slice(0, 50)}`);
+        return { safe: false, reason: "Command blocked for security" };
+      }
+    }
+
+    // Check for excessive command length (potential buffer overflow)
+    if (command.length > 10000) {
+      return { safe: false, reason: "Command too long (max 10000 chars)" };
+    }
+
+    return { safe: true };
+  }
+
+  /**
+   * Check rate limit
+   */
+  isRateLimited(provider: string, callCount: number, maxPerMinute = 10): boolean {
+    if (callCount > maxPerMinute) {
+      this.log("rate_limited", `${provider}: ${callCount} calls/min`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Validate API key format
+   */
+  validateApiKey(provider: string, key: string): boolean {
+    const patterns: Record<string, RegExp> = {
+      openai: /^(sk-|sx-)[a-zA-Z0-9]{20,}$/,
+      anthropic: /^sk-ant-[a-zA-Z0-9]{20,}$/,
+      deepseek: /^sk-[a-zA-Z0-9]{20,}$/,
+      groq: /^gsk_[a-zA-Z0-9]{20,}$/,
+      google: /^AIza[a-zA-Z0-9_-]{35,}$/,
+      openrouter: /^sk-or-v1-[a-zA-Z0-9]{20,}$/,
+    };
+
+    if (patterns[provider]) {
+      return patterns[provider].test(key);
+    }
+    return key.length > 8; // Basic length check for unknown providers
+  }
+
+  private log(type: string, detail: string): void {
+    this.auditLog.push(`[${new Date().toISOString()}] ${type}: ${detail}`);
+  }
+
+  getAuditLog(): string[] {
+    return this.auditLog;
+  }
+}