karajan-code 1.59.0 → 2.0.0

package/src/proxy/progress-monitor.js

@@ -1,98 +0,0 @@
-/**
- * Progress monitor that bridges the response interceptor's events
- * to KJ's structured progress event system.
- *
- * Subscribes to interceptorEmitter events (tool_call, usage, message_complete)
- * and re-emits structured, timestamped progress events on the main emitter.
- *
- * @module proxy/progress-monitor
- */
-
-/**
- * Truncate a string to maxLen characters, appending "..." if truncated.
- * @param {string} str
- * @param {number} maxLen
- * @returns {string}
- */
-function truncate(str, maxLen) {
-  if (typeof str !== "string") return "";
-  if (str.length <= maxLen) return str;
-  return str.slice(0, maxLen) + "...";
-}
-
-/**
- * Create a progress monitor that subscribes to interceptor events
- * and re-emits structured progress events on the main emitter.
- *
- * @param {object} config
- * @param {import("node:events").EventEmitter} config.emitter - Main event emitter to emit structured events on
- * @param {import("node:events").EventEmitter} config.interceptorEmitter - Interceptor emitter to subscribe to
- * @param {string} config.stage - Pipeline stage name (e.g. "coder", "reviewer")
- * @param {string} config.provider - AI provider name (e.g. "anthropic", "openai")
- * @returns {{ getStats: () => object, stop: () => void }}
- */
-export function createProgressMonitor({
-  emitter,
-  interceptorEmitter,
-  stage,
-  provider,
-}) {
-  const stats = {
-    toolCalls: 0,
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-  };
-
-  function onToolCall({ name, id }) {
-    stats.toolCalls++;
-    const input = id ? truncate(String(id), 100) : "";
-    emitter.emit("progress", {
-      type: "proxy:tool_call",
-      stage,
-      provider,
-      tool: name,
-      input,
-      timestamp: Date.now(),
-    });
-  }
-
-  function onUsage({ input_tokens, output_tokens }) {
-    const inputTokens = input_tokens || 0;
-    const outputTokens = output_tokens || 0;
-    stats.totalInputTokens += inputTokens;
-    stats.totalOutputTokens += outputTokens;
-    emitter.emit("progress", {
-      type: "proxy:usage",
-      stage,
-      provider,
-      input_tokens: inputTokens,
-      output_tokens: outputTokens,
-      timestamp: Date.now(),
-    });
-  }
-
-  function onMessageComplete() {
-    emitter.emit("progress", {
-      type: "proxy:message_complete",
-      stage,
-      provider,
-      timestamp: Date.now(),
-    });
-  }
-
-  interceptorEmitter.on("tool_call", onToolCall);
-  interceptorEmitter.on("usage", onUsage);
-  interceptorEmitter.on("message_complete", onMessageComplete);
-
-  function getStats() {
-    return { ...stats };
-  }
-
-  function stop() {
-    interceptorEmitter.off("tool_call", onToolCall);
-    interceptorEmitter.off("usage", onUsage);
-    interceptorEmitter.off("message_complete", onMessageComplete);
-  }
-
-  return { getStats, stop };
-}

package/src/proxy/proxy-lifecycle.js

@@ -1,198 +0,0 @@
-import net from "node:net";
-import http from "node:http";
-import { createProxyServer } from "./proxy-server.js";
-
-/** @type {import('./proxy-server.js').ProxyServer | null} */
-let proxyInstance = null;
-let proxyPort = 0;
-let orphanCheckInterval = null;
-
-const DEFAULT_TARGET_HOSTS = {
-  "api.anthropic.com": "anthropic",
-  "api.openai.com": "openai",
-  "generativelanguage.googleapis.com": "gemini",
-};
-
-/**
- * Find a free port on localhost by briefly binding a server to port 0.
- * @returns {Promise<number>}
- */
-async function findFreePort() {
-  return new Promise((resolve, reject) => {
-    const srv = net.createServer();
-    srv.on("error", reject);
-    srv.listen(0, "127.0.0.1", () => {
-      const { port } = srv.address();
-      srv.close(() => resolve(port));
-    });
-  });
-}
-
-/**
- * Wait until the proxy health endpoint responds with 200.
- * @param {number} port
- * @param {number} timeoutMs
- * @returns {Promise<void>}
- */
-function waitForHealth(port, timeoutMs = 5000) {
-  const deadline = Date.now() + timeoutMs;
-  return new Promise((resolve, reject) => {
-    function attempt() {
-      if (Date.now() > deadline) {
-        return reject(new Error("Proxy health check timed out"));
-      }
-      const req = http.get(`http://127.0.0.1:${port}/_kj/health`, (res) => {
-        if (res.statusCode === 200) {
-          // Consume response body to free socket
-          res.resume();
-          resolve();
-        } else {
-          res.resume();
-          setTimeout(attempt, 50);
-        }
-      });
-      req.on("error", () => setTimeout(attempt, 50));
-    }
-    attempt();
-  });
-}
-
-/**
- * Start orphan prevention: periodically check if the parent process is still alive.
- * If the parent exits, stop the proxy to avoid orphan servers.
- */
-function startOrphanPrevention() {
-  const parentPid = process.ppid;
-  orphanCheckInterval = setInterval(() => {
-    try {
-      // process.kill(pid, 0) throws if process doesn't exist
-      process.kill(parentPid, 0);
-    } catch {
-      // Parent is gone — self-terminate
-      stopProxy().catch(() => {});
-      clearInterval(orphanCheckInterval);
-      orphanCheckInterval = null;
-    }
-  }, 5000);
-
-  // Don't keep the event loop alive just for orphan checks
-  if (orphanCheckInterval.unref) {
-    orphanCheckInterval.unref();
-  }
-}
-
-/**
- * Start the proxy server in-process.
- *
- * @param {object} options
- * @param {object} [options.config] - Optional config overrides
- * @param {Record<string, string>} [options.config.targetHosts] - Host-to-provider map
- * @param {string} [options.sessionId] - Session identifier (for logging)
- * @returns {Promise<{port: number, baseUrls: {anthropic: string, openai: string, gemini: string}}>}
- */
-export async function startProxy({ config = {}, sessionId } = {}) {
-  if (proxyInstance) {
-    // Already running — return current info
-    return buildResult(proxyPort);
-  }
-
-  const port = await findFreePort();
-  const targetHosts = config.targetHosts || DEFAULT_TARGET_HOSTS;
-
-  proxyInstance = createProxyServer({ port, targetHosts });
-  await proxyInstance.listen();
-  proxyPort = proxyInstance.port;
-
-  await waitForHealth(proxyPort);
-  startOrphanPrevention();
-
-  return buildResult(proxyPort);
-}
-
-/**
- * Graceful shutdown with 5s timeout, then force cleanup.
- * @returns {Promise<void>}
- */
-export async function stopProxy() {
-  if (orphanCheckInterval) {
-    clearInterval(orphanCheckInterval);
-    orphanCheckInterval = null;
-  }
-
-  if (!proxyInstance) return;
-
-  const instance = proxyInstance;
-  proxyInstance = null;
-  proxyPort = 0;
-
-  // Race: graceful close vs 5s timeout
-  const graceful = instance.close();
-  const timeout = new Promise((resolve) => {
-    const timer = setTimeout(resolve, 5000);
-    if (timer.unref) timer.unref();
-  });
-
-  await Promise.race([graceful, timeout]);
-}
-
-/**
- * Returns env vars to inject into agent subprocesses so they route through the proxy.
- * @returns {Record<string, string> | null} env vars, or null if proxy is not running
- */
-export function getProxyEnv() {
-  if (!proxyInstance || !proxyPort) return null;
-
-  const base = `http://127.0.0.1:${proxyPort}`;
-  return {
-    ANTHROPIC_BASE_URL: base,
-    OPENAI_BASE_URL: base,
-    GEMINI_API_BASE: base,
-  };
-}
-
-/**
- * Return proxy stats if running, or null otherwise.
- * @returns {{ port: number, requests: number, bytes_in: number, bytes_out: number } | null}
- */
-export function getProxyStats() {
-  if (!proxyInstance || !proxyPort) return null;
-  return { port: proxyPort, ...proxyInstance.stats };
-}
-
-/**
- * Check if the proxy is running by hitting the health endpoint.
- * @returns {Promise<boolean>}
- */
-export async function isProxyRunning() {
-  if (!proxyInstance || !proxyPort) return false;
-
-  return new Promise((resolve) => {
-    const req = http.get(`http://127.0.0.1:${proxyPort}/_kj/health`, (res) => {
-      res.resume();
-      resolve(res.statusCode === 200);
-    });
-    req.on("error", () => resolve(false));
-    // Tight timeout — should be instant for localhost
-    req.setTimeout(2000, () => {
-      req.destroy();
-      resolve(false);
-    });
-  });
-}
-
-/**
- * Build the result object for startProxy.
- * @param {number} port
- * @returns {{port: number, baseUrls: {anthropic: string, openai: string, gemini: string}}}
- */
-function buildResult(port) {
-  const base = `http://127.0.0.1:${port}`;
-  return {
-    port,
-    baseUrls: {
-      anthropic: base,
-      openai: base,
-      gemini: base,
-    },
-  };
-}

package/src/proxy/proxy-server.js

@@ -1,239 +0,0 @@
-import http from "node:http";
-import https from "node:https";
-import { isRequestTooLarge } from "./security.js";
-
-/**
- * Create a lightweight HTTP forward proxy with middleware pipeline.
- *
- * The proxy receives plain HTTP on localhost, detects the AI provider from the
- * Host header, runs the middleware chain, then forwards the request as HTTPS
- * (or HTTP for testing) to the real API endpoint.
- *
- * @param {object} options
- * @param {number} options.port - Port to listen on (0 = OS-assigned)
- * @param {Record<string, string>} options.targetHosts - Map host → provider name
- * @param {object} [options._testTarget] - Override target for testing (hostname, port, protocol)
- * @returns {ProxyServer}
- */
-export function createProxyServer({ port = 0, targetHosts = {}, _testTarget } = {}) {
-  const middlewares = [];
-  const startTime = Date.now();
-  const stats = { requests: 0, bytes_in: 0, bytes_out: 0 };
-  let activeConnections = 0;
-  let closing = false;
-  let closeResolve = null;
-
-  function detectProvider(host) {
-    // Strip port from host if present
-    const hostname = (host || "").split(":")[0];
-    return targetHosts[hostname] || "unknown";
-  }
-
-  /**
-   * Compose middlewares into a single function using Koa-style next() chaining.
-   */
-  function compose(mws, finalHandler) {
-    return function run(ctx) {
-      let index = -1;
-      function dispatch(i) {
-        if (i <= index) return Promise.reject(new Error("next() called multiple times"));
-        index = i;
-        const fn = i < mws.length ? mws[i] : finalHandler;
-        if (!fn) return Promise.resolve();
-        return Promise.resolve(fn(ctx, () => dispatch(i + 1)));
-      }
-      return dispatch(0);
-    };
-  }
-
-  /**
-   * Forward the request to the upstream target and stream the response back.
-   */
-  function forwardRequest(ctx) {
-    return new Promise((resolve, reject) => {
-      const { req, res } = ctx;
-      const host = (req.headers.host || "").split(":")[0];
-      const body = ctx.modifiedBody != null ? ctx.modifiedBody : ctx.body;
-
-      // Determine target
-      let targetHostname, targetPort, useHttps;
-      if (_testTarget) {
-        targetHostname = _testTarget.hostname;
-        targetPort = _testTarget.port;
-        useHttps = _testTarget.protocol === "https:";
-      } else {
-        targetHostname = host;
-        targetPort = 443;
-        useHttps = true;
-      }
-
-      const transport = useHttps ? https : http;
-
-      // Clone headers, remove hop-by-hop headers, update content-length
-      const headers = { ...req.headers };
-      delete headers["transfer-encoding"];
-      delete headers["connection"];
-      delete headers["proxy-connection"];
-      delete headers["keep-alive"];
-      if (body != null) {
-        headers["content-length"] = String(Buffer.byteLength(body));
-      }
-
-      const proxyReq = transport.request(
-        {
-          hostname: targetHostname,
-          port: targetPort,
-          path: req.url,
-          method: req.method,
-          headers,
-        },
-        (proxyRes) => {
-          // Track bytes out by instrumenting the response
-          proxyRes.on("data", (chunk) => {
-            stats.bytes_out += chunk.length;
-          });
-
-          // Stream the response back — write head then pipe
-          res.writeHead(proxyRes.statusCode, proxyRes.headers);
-          proxyRes.pipe(res);
-          proxyRes.on("end", resolve);
-          proxyRes.on("error", reject);
-        },
-      );
-
-      proxyReq.on("error", (err) => {
-        if (!res.headersSent) {
-          res.writeHead(502, { "content-type": "application/json" });
-          res.end(JSON.stringify({ error: "Bad Gateway", message: err.message }));
-        }
-        resolve(); // Don't reject — we handled the error via 502
-      });
-
-      if (body) {
-        proxyReq.write(body);
-      }
-      proxyReq.end();
-    });
-  }
-
-  function handleRequest(req, res) {
-    // Health check — bypass middleware and proxy
-    if (req.url === "/_kj/health") {
-      res.writeHead(200, { "content-type": "application/json" });
-      res.end(
-        JSON.stringify({
-          status: "ok",
-          uptime: Math.round((Date.now() - startTime) / 1000),
-          requests: stats.requests,
-        }),
-      );
-      return;
-    }
-
-    // Reject oversized requests early (50 MB default)
-    const MAX_BODY_BYTES = 50 * 1024 * 1024;
-    if (isRequestTooLarge(req.headers["content-length"], MAX_BODY_BYTES)) {
-      res.writeHead(413, { "content-type": "application/json" });
-      res.end(JSON.stringify({ error: "Payload Too Large", maxBytes: MAX_BODY_BYTES }));
-      return;
-    }
-
-    activeConnections++;
-    stats.requests++;
-
-    // Collect body — enforce streaming size limit even without Content-Length
-    let bodySize = 0;
-    const chunks = [];
-    req.on("data", (c) => {
-      bodySize += c.length;
-      if (bodySize > MAX_BODY_BYTES) {
-        res.writeHead(413, { "content-type": "application/json" });
-        res.end(JSON.stringify({ error: "Payload Too Large", maxBytes: MAX_BODY_BYTES }));
-        req.destroy();
-        return;
-      }
-      chunks.push(c);
-      stats.bytes_in += c.length;
-    });
-    req.on("end", () => {
-      const body = Buffer.concat(chunks).toString();
-      const provider = detectProvider(req.headers.host);
-
-      const ctx = {
-        req,
-        res,
-        body,
-        provider,
-        modifiedBody: null,
-      };
-
-      const chain = compose(middlewares, (c) => forwardRequest(c));
-      chain(ctx)
-        .catch((err) => {
-          if (!res.headersSent) {
-            res.writeHead(500, { "content-type": "application/json" });
-            res.end(JSON.stringify({ error: "Internal Server Error", message: err.message }));
-          }
-        })
-        .finally(() => {
-          activeConnections--;
-          if (closing && activeConnections === 0 && closeResolve) {
-            closeResolve();
-          }
-        });
-    });
-  }
-
-  const server = http.createServer(handleRequest);
-
-  const instance = {
-    get port() {
-      const addr = server.address();
-      return addr ? addr.port : port;
-    },
-
-    get stats() {
-      return { ...stats };
-    },
-
-    /**
-     * Register a middleware function.
-     * @param {(ctx: object, next: () => Promise<void>) => Promise<void>} fn
-     */
-    use(fn) {
-      middlewares.push(fn);
-      return instance;
-    },
-
-    /**
-     * Start listening on the configured port.
-     * @returns {Promise<void>}
-     */
-    listen() {
-      return new Promise((resolve, reject) => {
-        server.on("error", reject);
-        server.listen(port, "127.0.0.1", () => resolve());
-      });
-    },
-
-    /**
-     * Graceful shutdown — stop accepting new connections,
-     * drain active ones, then resolve.
-     * @returns {Promise<void>}
-     */
-    close() {
-      closing = true;
-      return new Promise((resolve) => {
-        server.close(() => {
-          if (activeConnections === 0) {
-            resolve();
-          } else {
-            closeResolve = resolve;
-          }
-        });
-      });
-    },
-  };
-
-  return instance;
-}

package/src/proxy/security.js

@@ -1,45 +0,0 @@
-/**
- * Security utilities for the proxy layer.
- *
- * - sanitizeHeaders: strips sensitive values before logging
- * - isRequestTooLarge: checks Content-Length against a limit
- *
- * @module proxy/security
- */
-
-/** Headers whose values must never appear in logs. */
-const SENSITIVE_HEADERS = new Set([
-  "authorization",
-  "x-api-key",
-  "x-goog-api-key",
-]);
-
-/**
- * Return a shallow copy of `headers` with sensitive values replaced by "[REDACTED]".
- *
- * @param {Record<string, string>} headers
- * @returns {Record<string, string>}
- */
-export function sanitizeHeaders(headers) {
-  if (!headers || typeof headers !== "object") return {};
-
-  const result = {};
-  for (const [key, value] of Object.entries(headers)) {
-    result[key] = SENSITIVE_HEADERS.has(key.toLowerCase()) ? "[REDACTED]" : value;
-  }
-  return result;
-}
-
-/**
- * Check whether the declared Content-Length exceeds the allowed maximum.
- *
- * @param {number|string|undefined} contentLength - Value of the content-length header
- * @param {number} maxBytes - Maximum allowed body size in bytes (default 50 MB)
- * @returns {boolean} true if the request is too large
- */
-export function isRequestTooLarge(contentLength, maxBytes = 50 * 1024 * 1024) {
-  if (contentLength == null) return false;
-  const len = Number(contentLength);
-  if (Number.isNaN(len)) return false;
-  return len > maxBytes;
-}