@openguardrails/gateway 1.0.0

package/src/config.ts

@@ -0,0 +1,122 @@
+/**
+ * Gateway configuration management
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { GatewayConfig } from "./types.js";
+
+const DEFAULT_CONFIG_PATH = join(homedir(), ".openguardrails", "gateway.json");
+
+/**
+ * Load gateway configuration from file or environment
+ */
+export function loadConfig(configPath?: string): GatewayConfig {
+  const path = configPath || DEFAULT_CONFIG_PATH;
+
+  // Default configuration
+  const defaultConfig: GatewayConfig = {
+    port: parseInt(process.env.GATEWAY_PORT || "8900", 10),
+    backends: {},
+  };
+
+  // Try to load from file
+  if (existsSync(path)) {
+    try {
+      const fileContent = readFileSync(path, "utf-8");
+      const fileConfig = JSON.parse(fileContent);
+      return mergeConfig(defaultConfig, fileConfig);
+    } catch (error) {
+      console.warn(
+        `[ai-security-gateway] Failed to load config from ${path}:`,
+        error,
+      );
+    }
+  }
+
+  // Load from environment variables
+  return loadFromEnv(defaultConfig);
+}
+
+/**
+ * Load backend configs from environment variables
+ */
+function loadFromEnv(config: GatewayConfig): GatewayConfig {
+  // Anthropic
+  if (process.env.ANTHROPIC_API_KEY) {
+    config.backends.anthropic = {
+      baseUrl: process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com",
+      apiKey: process.env.ANTHROPIC_API_KEY,
+    };
+  }
+
+  // OpenAI
+  if (process.env.OPENAI_API_KEY) {
+    config.backends.openai = {
+      baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com",
+      apiKey: process.env.OPENAI_API_KEY,
+    };
+  }
+
+  // Kimi (Moonshot)
+  if (process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY) {
+    config.backends.openai = {
+      baseUrl:
+        process.env.KIMI_BASE_URL || "https://api.moonshot.cn",
+      apiKey: process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY || "",
+    };
+  }
+
+  // Gemini
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+    config.backends.gemini = {
+      baseUrl:
+        process.env.GEMINI_BASE_URL ||
+        "https://generativelanguage.googleapis.com",
+      apiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || "",
+    };
+  }
+
+  return config;
+}
+
+/**
+ * Merge file config with default config
+ */
+function mergeConfig(
+  defaultConfig: GatewayConfig,
+  fileConfig: Partial<GatewayConfig>,
+): GatewayConfig {
+  return {
+    port: fileConfig.port ?? defaultConfig.port,
+    backends: {
+      ...defaultConfig.backends,
+      ...fileConfig.backends,
+    },
+    routing: fileConfig.routing,
+  };
+}
+
+/**
+ * Validate configuration
+ */
+export function validateConfig(config: GatewayConfig): void {
+  if (config.port < 1 || config.port > 65535) {
+    throw new Error(`Invalid port: ${config.port}`);
+  }
+
+  // Note: Backends are now optional. Gateway will act as transparent proxy.
+  // If no backends configured, gateway will forward requests based on routing rules
+  // or pass through to the original target.
+
+  // Validate each backend (if any)
+  for (const [name, backend] of Object.entries(config.backends)) {
+    if (!backend.baseUrl) {
+      throw new Error(`Backend ${name} missing baseUrl`);
+    }
+    if (!backend.apiKey) {
+      throw new Error(`Backend ${name} missing apiKey`);
+    }
+  }
+}

package/src/handlers/anthropic.ts

@@ -0,0 +1,195 @@
+/**
+ * AI Security Gateway - Anthropic Messages API handler
+ *
+ * Handles POST /v1/messages requests in Anthropic's native format.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { GatewayConfig, MappingTable } from "../types.js";
+import { sanitize } from "../sanitizer.js";
+import { restore, restoreSSELine } from "../restorer.js";
+
+/**
+ * Handle Anthropic API request
+ */
+export async function handleAnthropicRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  config: GatewayConfig,
+): Promise<void> {
+  try {
+    // 1. Parse request body
+    const body = await readBody(req);
+    const requestData = JSON.parse(body);
+
+    const {
+      model,
+      messages,
+      system,
+      tools,
+      max_tokens,
+      temperature,
+      stream = false,
+      ...rest
+    } = requestData;
+
+    // 2. Sanitize messages
+    const { sanitized: sanitizedMessages, mappingTable } = sanitize(messages);
+
+    // 3. Sanitize system prompt if present
+    const sanitizedSystem = system
+      ? sanitize(system).sanitized
+      : system;
+
+    // Note: We reuse the same mapping table so placeholders are consistent
+
+    // 4. Build sanitized request
+    const sanitizedRequest = {
+      model,
+      messages: sanitizedMessages,
+      ...(system && { system: sanitizedSystem }),
+      ...(tools && { tools }),
+      max_tokens,
+      ...(temperature !== undefined && { temperature }),
+      stream,
+      ...rest,
+    };
+
+    // 5. Get backend config
+    const backend = config.backends.anthropic;
+    if (!backend) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Anthropic backend not configured" }));
+      return;
+    }
+
+    // 6. Forward to real Anthropic API
+    const apiUrl = `${backend.baseUrl}/v1/messages`;
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "anthropic-version": req.headers["anthropic-version"] as string || "2023-06-01",
+        "x-api-key": backend.apiKey,
+      },
+      body: JSON.stringify(sanitizedRequest),
+    });
+
+    if (!response.ok) {
+      // Forward error response
+      res.writeHead(response.status, { "Content-Type": "application/json" });
+      const errorBody = await response.text();
+      res.end(errorBody);
+      return;
+    }
+
+    // 7. Handle streaming response
+    if (stream) {
+      await handleAnthropicStream(response, res, mappingTable);
+    } else {
+      await handleAnthropicNonStream(response, res, mappingTable);
+    }
+  } catch (error) {
+    console.error("[ai-security-gateway] Anthropic handler error:", error);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Internal gateway error",
+        message: error instanceof Error ? error.message : String(error),
+      }),
+    );
+  }
+}
+
+/**
+ * Handle streaming response
+ */
+async function handleAnthropicStream(
+  response: Response,
+  res: ServerResponse,
+  mappingTable: MappingTable,
+): Promise<void> {
+  // Set SSE headers
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+  });
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    res.end();
+    return;
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      // Decode chunk
+      buffer += decoder.decode(value, { stream: true });
+
+      // Process complete lines
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        if (!line.trim()) {
+          res.write("\n");
+          continue;
+        }
+
+        // Restore placeholders in SSE line
+        const restoredLine = restoreSSELine(line, mappingTable);
+        res.write(restoredLine + "\n");
+      }
+    }
+
+    // Write any remaining buffer
+    if (buffer.trim()) {
+      const restoredLine = restoreSSELine(buffer, mappingTable);
+      res.write(restoredLine + "\n");
+    }
+
+    res.end();
+  } catch (error) {
+    console.error("[ai-security-gateway] Stream error:", error);
+    res.end();
+  }
+}
+
+/**
+ * Handle non-streaming response
+ */
+async function handleAnthropicNonStream(
+  response: Response,
+  res: ServerResponse,
+  mappingTable: MappingTable,
+): Promise<void> {
+  const responseBody = await response.text();
+  const responseData = JSON.parse(responseBody);
+
+  // Restore placeholders in response
+  const restoredData = restore(responseData, mappingTable);
+
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(restoredData));
+}
+
+/**
+ * Read request body as string
+ */
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}

package/src/handlers/gemini.ts

@@ -0,0 +1,99 @@
+/**
+ * AI Security Gateway - Google Gemini API handler
+ *
+ * Handles POST /v1/models/:model:generateContent requests in Gemini's format.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { GatewayConfig, MappingTable } from "../types.js";
+import { sanitize } from "../sanitizer.js";
+import { restore } from "../restorer.js";
+
+/**
+ * Handle Gemini API request
+ */
+export async function handleGeminiRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  config: GatewayConfig,
+  modelName: string,
+): Promise<void> {
+  try {
+    // 1. Parse request body
+    const body = await readBody(req);
+    const requestData = JSON.parse(body);
+
+    const { contents, tools, generationConfig, ...rest } = requestData;
+
+    // 2. Sanitize contents (Gemini uses "contents" instead of "messages")
+    const { sanitized: sanitizedContents, mappingTable } = sanitize(contents);
+
+    // 3. Build sanitized request
+    const sanitizedRequest = {
+      contents: sanitizedContents,
+      ...(tools && { tools }),
+      ...(generationConfig && { generationConfig }),
+      ...rest,
+    };
+
+    // 4. Get backend config
+    const backend = config.backends.gemini;
+    if (!backend) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Gemini backend not configured" }));
+      return;
+    }
+
+    // 5. Forward to Gemini API
+    const apiUrl = `${backend.baseUrl}/v1/models/${modelName}:generateContent`;
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-goog-api-key": backend.apiKey,
+      },
+      body: JSON.stringify(sanitizedRequest),
+    });
+
+    if (!response.ok) {
+      // Forward error response
+      res.writeHead(response.status, { "Content-Type": "application/json" });
+      const errorBody = await response.text();
+      res.end(errorBody);
+      return;
+    }
+
+    // 6. Handle response (Gemini typically doesn't stream in same way)
+    const responseBody = await response.text();
+    const responseData = JSON.parse(responseBody);
+
+    // Restore placeholders in response
+    const restoredData = restore(responseData, mappingTable);
+
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(restoredData));
+  } catch (error) {
+    console.error("[ai-security-gateway] Gemini handler error:", error);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Internal gateway error",
+        message: error instanceof Error ? error.message : String(error),
+      }),
+    );
+  }
+}
+
+/**
+ * Read request body as string
+ */
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}

package/src/handlers/openai.ts

@@ -0,0 +1,188 @@
+/**
+ * AI Security Gateway - OpenAI Chat Completions API handler
+ *
+ * Handles POST /v1/chat/completions requests in OpenAI's format.
+ * Also compatible with OpenAI-compatible APIs (Kimi, DeepSeek, etc.)
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { GatewayConfig, MappingTable } from "../types.js";
+import { sanitize } from "../sanitizer.js";
+import { restore, restoreSSELine } from "../restorer.js";
+
+/**
+ * Handle OpenAI API request
+ */
+export async function handleOpenAIRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  config: GatewayConfig,
+): Promise<void> {
+  try {
+    // 1. Parse request body
+    const body = await readBody(req);
+    const requestData = JSON.parse(body);
+
+    const {
+      model,
+      messages,
+      tools,
+      tool_choice,
+      temperature,
+      max_tokens,
+      stream = false,
+      ...rest
+    } = requestData;
+
+    // 2. Sanitize messages
+    const { sanitized: sanitizedMessages, mappingTable } = sanitize(messages);
+
+    // 3. Build sanitized request
+    const sanitizedRequest = {
+      model,
+      messages: sanitizedMessages,
+      ...(tools && { tools }),
+      ...(tool_choice && { tool_choice }),
+      ...(temperature !== undefined && { temperature }),
+      ...(max_tokens && { max_tokens }),
+      stream,
+      ...rest,
+    };
+
+    // 4. Get backend config
+    const backend = config.backends.openai;
+    if (!backend) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "OpenAI backend not configured" }));
+      return;
+    }
+
+    // 5. Forward to OpenAI (or compatible) API
+    const apiUrl = `${backend.baseUrl}/v1/chat/completions`;
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${backend.apiKey}`,
+      },
+      body: JSON.stringify(sanitizedRequest),
+    });
+
+    if (!response.ok) {
+      // Forward error response
+      res.writeHead(response.status, { "Content-Type": "application/json" });
+      const errorBody = await response.text();
+      res.end(errorBody);
+      return;
+    }
+
+    // 6. Handle streaming or non-streaming response
+    if (stream) {
+      await handleOpenAIStream(response, res, mappingTable);
+    } else {
+      await handleOpenAINonStream(response, res, mappingTable);
+    }
+  } catch (error) {
+    console.error("[ai-security-gateway] OpenAI handler error:", error);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Internal gateway error",
+        message: error instanceof Error ? error.message : String(error),
+      }),
+    );
+  }
+}
+
+/**
+ * Handle streaming response (SSE)
+ */
+async function handleOpenAIStream(
+  response: Response,
+  res: ServerResponse,
+  mappingTable: MappingTable,
+): Promise<void> {
+  // Set SSE headers
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+  });
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    res.end();
+    return;
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      // Decode chunk
+      buffer += decoder.decode(value, { stream: true });
+
+      // Process complete lines
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        if (!line.trim()) {
+          res.write("\n");
+          continue;
+        }
+
+        // Restore placeholders in SSE line
+        const restoredLine = restoreSSELine(line, mappingTable);
+        res.write(restoredLine + "\n");
+      }
+    }
+
+    // Write any remaining buffer
+    if (buffer.trim()) {
+      const restoredLine = restoreSSELine(buffer, mappingTable);
+      res.write(restoredLine + "\n");
+    }
+
+    res.end();
+  } catch (error) {
+    console.error("[ai-security-gateway] Stream error:", error);
+    res.end();
+  }
+}
+
+/**
+ * Handle non-streaming response
+ */
+async function handleOpenAINonStream(
+  response: Response,
+  res: ServerResponse,
+  mappingTable: MappingTable,
+): Promise<void> {
+  const responseBody = await response.text();
+  const responseData = JSON.parse(responseBody);
+
+  // Restore placeholders in response
+  const restoredData = restore(responseData, mappingTable);
+
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(restoredData));
+}
+
+/**
+ * Read request body as string
+ */
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}