karajan-code 1.58.2 → 1.59.0

package/src/proxy/middleware/response-interceptor.js

@@ -0,0 +1,223 @@
+import { EventEmitter } from "node:events";
+
+/**
+ * Create a response interceptor middleware that extracts tool calls, usage data,
+ * and text content from AI provider responses without buffering.
+ *
+ * For SSE (text/event-stream) responses, it parses each "data: " line inline.
+ * For non-streaming JSON responses, it parses the completed body.
+ *
+ * Events emitted on the provided EventEmitter:
+ *   - tool_call        {name, id}
+ *   - tool_call_complete {id}
+ *   - text_delta       {text}
+ *   - usage            {input_tokens, output_tokens}
+ *   - message_complete {}
+ *
+ * @param {object} [config]
+ * @param {EventEmitter} [config.emitter] - EventEmitter to emit events on (created if not provided)
+ * @returns {{ middleware: (ctx: object, next: () => Promise<void>) => Promise<void>, emitter: EventEmitter }}
+ */
+export function createResponseInterceptor(config = {}) {
+  const emitter = config.emitter || new EventEmitter();
+
+  // Track accumulated tool input per tool id
+  const toolInputBuffers = new Map();
+
+  function handleSSELine(line) {
+    if (!line.startsWith("data: ")) return;
+    const payload = line.slice(6).trim();
+    if (payload === "[DONE]") return;
+
+    let event;
+    try {
+      event = JSON.parse(payload);
+    } catch {
+      return; // Malformed JSON, skip
+    }
+
+    processAnthropicEvent(event);
+  }
+
+  function processAnthropicEvent(event) {
+    const type = event.type;
+
+    if (type === "content_block_start") {
+      const block = event.content_block;
+      if (block && block.type === "tool_use") {
+        toolInputBuffers.set(block.id, "");
+        emitter.emit("tool_call", { name: block.name, id: block.id });
+      }
+    } else if (type === "content_block_delta") {
+      const delta = event.delta;
+      if (delta && delta.type === "input_json_delta") {
+        const id = findActiveToolId(event);
+        if (id && toolInputBuffers.has(id)) {
+          toolInputBuffers.set(id, toolInputBuffers.get(id) + (delta.partial_json || ""));
+        }
+      } else if (delta && delta.type === "text_delta") {
+        emitter.emit("text_delta", { text: delta.text || "" });
+      }
+    } else if (type === "content_block_stop") {
+      const id = findActiveToolId(event);
+      if (id && toolInputBuffers.has(id)) {
+        toolInputBuffers.delete(id);
+        emitter.emit("tool_call_complete", { id });
+      }
+    } else if (type === "message_delta") {
+      if (event.usage) {
+        emitter.emit("usage", {
+          input_tokens: event.usage.input_tokens,
+          output_tokens: event.usage.output_tokens,
+        });
+      }
+    } else if (type === "message_start") {
+      if (event.message && event.message.usage) {
+        emitter.emit("usage", {
+          input_tokens: event.message.usage.input_tokens,
+          output_tokens: event.message.usage.output_tokens,
+        });
+      }
+    } else if (type === "message_stop") {
+      emitter.emit("message_complete", {});
+    }
+  }
+
+  /**
+   * Resolve the tool ID from the event. Anthropic events use `index` to refer
+   * to the content block, but we track by id. For events with an index, we map
+   * it to the id stored at creation time. To keep things simple and avoid
+   * maintaining an index->id map, we accept an explicit `id` field if present
+   * or fall back to the first (and often only) active tool.
+   */
+  function findActiveToolId(event) {
+    if (event.id) return event.id;
+    // Fall back to the first active tool (works for single-tool scenarios)
+    const keys = [...toolInputBuffers.keys()];
+    return keys.length > 0 ? keys[keys.length - 1] : null;
+  }
+
+  /**
+   * Process a non-streaming JSON response body.
+   */
+  function processJsonBody(bodyStr) {
+    let body;
+    try {
+      body = JSON.parse(bodyStr);
+    } catch {
+      return;
+    }
+
+    // Extract tool_use blocks from content array
+    if (Array.isArray(body.content)) {
+      for (const block of body.content) {
+        if (block.type === "tool_use") {
+          emitter.emit("tool_call", { name: block.name, id: block.id });
+          emitter.emit("tool_call_complete", { id: block.id });
+        } else if (block.type === "text") {
+          emitter.emit("text_delta", { text: block.text || "" });
+        }
+      }
+    }
+
+    // Extract usage
+    if (body.usage) {
+      emitter.emit("usage", {
+        input_tokens: body.usage.input_tokens,
+        output_tokens: body.usage.output_tokens,
+      });
+    }
+
+    emitter.emit("message_complete", {});
+  }
+
+  /**
+   * Middleware function compatible with the proxy server's Koa-style middleware.
+   * Wraps ctx.res.write and ctx.res.end to tap into the response stream.
+   */
+  async function middleware(ctx, next) {
+    const origWrite = ctx.res.write.bind(ctx.res);
+    const origEnd = ctx.res.end.bind(ctx.res);
+    const origWriteHead = ctx.res.writeHead.bind(ctx.res);
+
+    let isSSE = false;
+    let isJSON = false;
+    let lineBuf = ""; // Buffer for partial SSE lines across chunks
+    const jsonChunks = []; // Accumulate non-streaming JSON body
+
+    function processSSEChunk(text) {
+      lineBuf += text;
+      const lines = lineBuf.split("\n");
+      // Keep the last element as it may be incomplete
+      lineBuf = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          handleSSELine(trimmed);
+        }
+      }
+    }
+
+    // Intercept writeHead to detect content-type
+    ctx.res.writeHead = function interceptWriteHead(statusCode, ...args) {
+      // headers can be in args[0] (object) or args[1] with reasonPhrase in args[0]
+      const headers = typeof args[0] === "object" ? args[0] : args[1];
+      const ct = findHeader(headers, "content-type") || "";
+      isSSE = ct.includes("text/event-stream");
+      isJSON = ct.includes("application/json");
+      return origWriteHead(statusCode, ...args);
+    };
+
+    // Intercept write to parse chunks inline
+    ctx.res.write = function interceptWrite(chunk, encoding, callback) {
+      if (isSSE) {
+        processSSEChunk(typeof chunk === "string" ? chunk : chunk.toString());
+      } else if (isJSON) {
+        jsonChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+      }
+      return origWrite(chunk, encoding, callback);
+    };
+
+    // Intercept end to handle final chunk and JSON body
+    ctx.res.end = function interceptEnd(chunk, encoding, callback) {
+      if (chunk) {
+        if (isSSE) {
+          processSSEChunk(typeof chunk === "string" ? chunk : chunk.toString());
+        } else if (isJSON) {
+          jsonChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
+        }
+      }
+      // Flush remaining SSE buffer
+      if (isSSE && lineBuf.trim()) {
+        handleSSELine(lineBuf.trim());
+        lineBuf = "";
+      }
+      // Process complete JSON body
+      if (isJSON && jsonChunks.length > 0) {
+        processJsonBody(jsonChunks.join(""));
+      }
+      return origEnd(chunk, encoding, callback);
+    };
+
+    await next();
+  }
+
+  function findHeader(headers, name) {
+    if (!headers) return undefined;
+    // Headers might be an object or an array of [key, value] pairs
+    if (Array.isArray(headers)) {
+      for (let i = 0; i < headers.length; i += 2) {
+        if (typeof headers[i] === "string" && headers[i].toLowerCase() === name) {
+          return headers[i + 1];
+        }
+      }
+      return undefined;
+    }
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === name) return headers[key];
+    }
+    return undefined;
+  }
+
+  return { middleware, emitter };
+}

package/src/proxy/progress-monitor.js

@@ -0,0 +1,98 @@
+/**
+ * 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

@@ -0,0 +1,198 @@
+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,
+    },
+  };
+}