zevairouter 1.0.154 → 1.0.155

package/src/mitm/handlers/kiro.js

@@ -1,533 +0,0 @@
-const { err } = require("../logger");
-const { IS_DEV } = require("../config");
-const { fetchRouter, pipeTransformedEventStream } = require("./base");
-const fs = require("fs");
-const path = require("path");
-
-// Debug trace log — written to data/logs/mitm/kiro-debug.log (dev only)
-const DEBUG_LOG = path.join(__dirname, "../../../data/logs/mitm/kiro-debug.log");
-function dbg(msg) {
-  if (!IS_DEV) return;
-  try {
-    fs.appendFileSync(DEBUG_LOG, `${new Date().toISOString()} ${msg}\n`);
-  } catch {}
-}
-
-// ─── CRC32 (standard, polynomial 0xEDB88320 — same as AWS EventStream) ───────
-const CRC32_TABLE = (() => {
-  const t = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-    t[n] = c;
-  }
-  return t;
-})();
-
-function crc32(buf) {
-  let crc = 0xffffffff;
-  for (let i = 0; i < buf.length; i++) {
-    crc = (crc >>> 8) ^ CRC32_TABLE[(crc ^ buf[i]) & 0xff];
-  }
-  return (crc ^ 0xffffffff) >>> 0;
-}
-
-/**
- * Initialize state for the Kiro response translator
- */
-function initKiroState(modelId) {
-  return {
-    modelId: modelId || null,       // Model name from first chunk
-    toolCallInit: {},               // { [index]: { id, name } } — tracks seen tools
-    hasToolCalls: false,           // Whether this response uses tool calls
-    finishSent: false,             // Whether termination has been emitted
-    usage: null,                   // Accumulated usage from usage-only chunks
-    inThink: false,                // Whether inside a <thinking> block
-    thinkBuf: ""                   // Buffer for partial thinking content
-  };
-}
-
-/**
- * Extract thinking blocks from text content.
- * Handles both <thinking>...</thinking> and <think>...</think> tags,
- * including partial tags split across SSE chunks.
- */
-function extractThinking(text, state) {
-  if (!text) return { thinking: null, text: null };
-
-  let working = text;
-
-  // Prepend buffered partial thinking from previous chunk
-  if (state.inThink && state.thinkBuf) {
-    working = state.thinkBuf + working;
-    state.thinkBuf = "";
-    state.inThink = false;
-  }
-
-  // Match <thinking> or <think> opening tags
-  const startRe = /<thinking>|<think>/i;
-  const startMatch = working.match(startRe);
-
-  if (!startMatch) {
-    return { thinking: null, text: working };
-  }
-
-  const tag = startMatch[0].toLowerCase();
-  const closeTag = tag === "<think>" ? "</think>" : "</thinking>";
-  const startIdx = startMatch.index;
-  const endIdx = working.indexOf(closeTag, startIdx + tag.length);
-
-  if (endIdx === -1) {
-    // Opening tag without closing — buffer for next chunk
-    state.inThink = true;
-    state.thinkBuf = working.slice(startIdx);
-    const before = working.slice(0, startIdx).trim();
-    return { thinking: null, text: before || null };
-  }
-
-  // Complete block found
-  const thinking = working.slice(startIdx + tag.length, endIdx);
-  const before = working.slice(0, startIdx).trim();
-  const after = working.slice(endIdx + closeTag.length).trim();
-  const rest = [before, after].filter(Boolean).join("");
-
-  // Recursively process for more blocks
-  const recurse = rest
-    ? extractThinking(rest, { inThink: false, thinkBuf: "" })
-    : { thinking: null, text: null };
-
-  // Merge thinking from ALL blocks in this chunk — previously only the first block
-  // was returned and recurse.thinking was dropped, silently losing every <think>
-  // block after the first. Join with a blank line so no reasoning content is lost.
-  const allThinking = [thinking, recurse.thinking]
-    .filter((t) => t)
-    .join("\n\n") || null;
-
-  return {
-    thinking: allThinking,
-    text: recurse.text || null
-  };
-}
-
-// ─── AWS EventStream frame builder ────────────────────────────────────────────
-/**
- * Encode a single string header into the AWS EventStream binary format.
- * Header wire format: [nameLen 1B][name][type=7 1B][valueLen 2B][value]
- */
-function encodeHeader(name, value) {
-  const nameBuf = Buffer.from(name, "utf8");
-  const valueBuf = Buffer.from(value, "utf8");
-  const buf = Buffer.alloc(1 + nameBuf.length + 1 + 2 + valueBuf.length);
-  let o = 0;
-  buf[o++] = nameBuf.length;
-  nameBuf.copy(buf, o); o += nameBuf.length;
-  buf[o++] = 7; // string type
-  buf.writeUInt16BE(valueBuf.length, o); o += 2;
-  valueBuf.copy(buf, o);
-  return buf;
-}
-
-/**
- * Build a single AWS EventStream binary frame with all Smithy-required headers.
- *
- * Frame layout (big-endian):
- *   [totalLen 4B][headersLen 4B][preludeCRC 4B]
- *   [headers ...][payload JSON ...][messageCRC 4B]
- *
- * The SmithyMessageDecoderStream layer requires three system headers on every frame:
- *   :message-type  = "event"             (or "exception" / "error")
- *   :event-type    = e.g. "assistantResponseEvent"
- *   :content-type  = "application/json"
- */
-function buildEventStreamFrame(eventType, payload) {
-  const payloadBuf = Buffer.from(
-    typeof payload === "string" ? payload : JSON.stringify(payload),
-    "utf8"
-  );
-
-  // All three Smithy system headers are required
-  const headersBuf = Buffer.concat([
-    encodeHeader(":message-type", "event"),
-    encodeHeader(":event-type", eventType),
-    encodeHeader(":content-type", "application/json"),
-  ]);
-  const headersLen = headersBuf.length;
-
-  const totalLen = 4 + 4 + 4 + headersLen + payloadBuf.length + 4;
-  const frame = Buffer.alloc(totalLen);
-
-  frame.writeUInt32BE(totalLen, 0);
-  frame.writeUInt32BE(headersLen, 4);
-  frame.writeUInt32BE(crc32(frame.slice(0, 8)), 8); // prelude CRC
-  headersBuf.copy(frame, 12);
-  payloadBuf.copy(frame, 12 + headersLen);
-  frame.writeUInt32BE(crc32(frame.slice(0, totalLen - 4)), totalLen - 4); // message CRC
-
-  return frame;
-}
-
-// ─── CodeWhisperer → OpenAI conversion ───────────────────────────────────────
-
-/**
- * Safely stringify a tool-call input value.
- * OpenAI expects `function.arguments` to be a JSON string, never an object.
- * If zevairouter's Anthropic→OpenAI conversion passes the input as a pre-parsed object,
- * this prevents the "" + object → "[object Object]" corruption.
- */
-function safeArgsString(value) {
-  if (typeof value === "string") return value;
-  if (value == null) return "{}";
-  try { return JSON.stringify(value); } catch { return "{}"; }
-}
-
-/**
- * Convert a CodeWhisperer userInputMessage to one or more OpenAI messages.
- *
- * A user turn can contain:
- *   - plain text content  → { role:"user", content }
- *   - toolResults only    → one { role:"tool", tool_call_id, content } per result
- *   - both                → tool messages first, then the user text message
- */
-function convertUserInputMessage(uim) {
-  const out = [];
-  const toolResults = uim.userInputMessageContext?.toolResults || [];
-
-  // Emit one "tool" message per tool result (OpenAI multi-tool format)
-  for (const tr of toolResults) {
-    const text = (tr.content || []).map(c => c.text || "").join("\n");
-    out.push({
-      role: "tool",
-      tool_call_id: tr.toolUseId || "",
-      content: text,
-    });
-  }
-
-  // Emit user text only if it exists alongside OR when there are no tool results
-  const text = (uim.content || "").trim();
-  if (text || toolResults.length === 0) {
-    out.push({ role: "user", content: text });
-  }
-
-  return out;
-}
-
-/**
- * Convert a CodeWhisperer assistantResponseMessage to an OpenAI assistant message.
- *
- * The assistant turn can contain:
- *   - plain text content
- *   - toolUses (tool calls)  → tool_calls[] on the assistant message
- */
-function convertAssistantResponseMessage(arm) {
-  const toolUses = arm.toolUses || [];
-
-  if (toolUses.length > 0) {
-    return {
-      role: "assistant",
-      content: arm.content || null,
-      tool_calls: toolUses.map(tu => ({
-        id: tu.toolUseId || `call_${Date.now()}`,
-        type: "function",
-        function: {
-          name: tu.name || "",
-          arguments: safeArgsString(tu.input),
-        },
-      })),
-    };
-  }
-
-  return { role: "assistant", content: arm.content || "" };
-}
-
-/**
- * Convert AWS CodeWhisperer conversationState to an OpenAI messages array.
- *
- * Full multi-turn shape:
- *   history: [
- *     { userInputMessage: { content, userInputMessageContext?: { toolResults?, tools? } } },
- *     { assistantResponseMessage: { content, toolUses?: [...] } },
- *     ...
- *   ]
- *   currentMessage: { userInputMessage: { content, userInputMessageContext?: { toolResults? } } }
- */
-function codeWhispererToMessages(body) {
-  const cs = body.conversationState || {};
-  const history = cs.history || [];
-  const currentMsg = cs.currentMessage;
-  const messages = [];
-
-  for (const item of history) {
-    if (item.userInputMessage) {
-      messages.push(...convertUserInputMessage(item.userInputMessage));
-    } else if (item.assistantResponseMessage) {
-      messages.push(convertAssistantResponseMessage(item.assistantResponseMessage));
-    }
-  }
-
-  // Append the current (latest) turn
-  if (currentMsg?.userInputMessage) {
-    messages.push(...convertUserInputMessage(currentMsg.userInputMessage));
-  }
-
-  return messages;
-}
-
-/**
- * Extract tool definitions from a CodeWhisperer request and convert to OpenAI format.
- *
- * CodeWhisperer tools live in:
- *   conversationState.currentMessage.userInputMessage.userInputMessageContext.tools
- * OR (in multi-turn) the first history item's userInputMessageContext.tools
- *
- * CodeWhisperer tool shape:
- *   { toolSpecification: { name, description, inputSchema: { json: <schema> } } }
- *
- * OpenAI tool shape:
- *   { type: "function", function: { name, description, parameters: <schema> } }
- */
-function extractTools(body) {
-  const cs = body.conversationState || {};
-
-  // Tools are typically on the currentMessage; may also appear on the first history item
-  const fromCurrent = cs.currentMessage?.userInputMessage?.userInputMessageContext?.tools || [];
-  const fromHistory = cs.history?.find(h => h.userInputMessage?.userInputMessageContext?.tools)
-    ?.userInputMessage?.userInputMessageContext?.tools || [];
-  const cwTools = fromCurrent.length > 0 ? fromCurrent : fromHistory;
-
-  if (!cwTools.length) return [];
-
-  return cwTools.map(item => {
-    const spec = item.toolSpecification || item;
-    return {
-      type: "function",
-      function: {
-        name: spec.name || "",
-        description: spec.description || `Tool: ${spec.name || "unknown"}`,
-        parameters: spec.inputSchema?.json || { type: "object", properties: {}, required: [] },
-      },
-    };
-  });
-}
-
-// ─── OpenAI SSE → EventStream binary conversion ───────────────────────────────
-
-/**
- * Convert an OpenAI SSE chunk to AWS EventStream binary frame(s)
- * This replaces pipeOpenAIasEventStream and works with pipeTransformedEventStream
- *
- * @param {object|null} chunk - Parsed OpenAI chat.completion.chunk, or null for flush
- * @param {object} state - Mutable state object
- * @returns {Uint8Array|Uint8Array[]|null} Binary EventStream frame(s) or null to skip
- */
-function convertOpenAIToKiro(chunk, state) {
-  // Flush: ensure clean stream termination
-  if (!chunk) {
-    if (state.finishSent) return null;
-    // Flush any remaining buffered thinking
-    if (state.inThink && state.thinkBuf) {
-      state.inThink = false;
-      const thinking = state.thinkBuf;
-      state.thinkBuf = "";
-      return buildEventStreamFrame("reasoningContentEvent", {
-        content: thinking,
-        modelId: state.modelId || "kiro-unknown"
-      });
-    }
-    return buildEventStreamFrame("messageStopEvent", {});
-  }
-
-  const frames = [];
-  const choice = chunk.choices?.[0];
-  const delta = choice?.delta || {};
-
-  // Capture modelId from first chunk (real API includes it in every content frame)
-  if (!state.modelId && chunk.model) {
-    state.modelId = chunk.model;
-  }
-  const modelId = state.modelId || "unknown";
-
-  // Handle usage (may arrive standalone or with other chunks)
-  if (chunk.usage) {
-    state.usage = chunk.usage;
-  }
-
-  // Handle tool calls — stream incrementally, matching real API format
-  if (delta.tool_calls) {
-    state.hasToolCalls = true;
-    for (const tc of delta.tool_calls) {
-      const idx = tc.index ?? 0;
-
-      if (tc.id && tc.function?.name && !state.toolCallInit[idx]) {
-        // First appearance: emit frame with name + id, no input
-        state.toolCallInit[idx] = { id: tc.id, name: tc.function.name };
-        dbg(`toolUseEvent init: ${tc.function.name} (${tc.id})`);
-        frames.push(buildEventStreamFrame("toolUseEvent", {
-          name: tc.function.name,
-          toolUseId: tc.id
-        }));
-      }
-
-      // Emit incremental input fragment
-      if (tc.function?.arguments) {
-        const init = state.toolCallInit[idx];
-        dbg(`toolUseEvent fragment: ${tc.function.arguments.slice(0, 100)}`);
-        frames.push(buildEventStreamFrame("toolUseEvent", {
-          input: tc.function.arguments,
-          name: init?.name || tc.function?.name || "",
-          toolUseId: init?.id || tc.id || ""
-        }));
-      }
-    }
-  }
-
-  // Handle explicit reasoning_content (type-specific thinking channel)
-  if (delta.reasoning_content) {
-    frames.push(buildEventStreamFrame("reasoningContentEvent", {
-      content: delta.reasoning_content,
-      modelId
-    }));
-  }
-
-  // Handle text content — extract thinking blocks, emit rest as assistantResponseEvent
-  if (delta.content) {
-    const { thinking, text } = extractThinking(delta.content, state);
-
-    if (thinking) {
-      frames.push(buildEventStreamFrame("reasoningContentEvent", {
-        content: thinking,
-        modelId
-      }));
-    }
-
-    if (text) {
-      frames.push(buildEventStreamFrame("assistantResponseEvent", {
-        content: text,
-        modelId
-      }));
-    }
-  }
-
-  // Handle finish_reason
-  if (choice?.finish_reason) {
-    const finishFrames = emitFinish(state);
-    if (finishFrames) {
-      frames.push(...(Array.isArray(finishFrames) ? finishFrames : [finishFrames]));
-    }
-  }
-
-  if (frames.length === 0) return null;
-  return frames.length === 1 ? frames[0] : frames;
-}
-
-/**
- * Emit termination frames. For tool-call responses, emits stop:true per tool.
- * For text-only responses, emits messageStopEvent.
- */
-function emitFinish(state) {
-  const frames = [];
-
-  if (state.hasToolCalls) {
-    // Tool-call response: emit stop:true for each tool
-    for (const idx of Object.keys(state.toolCallInit).sort()) {
-      const tc = state.toolCallInit[idx];
-      frames.push(buildEventStreamFrame("toolUseEvent", {
-        name: tc.name,
-        stop: true,
-        toolUseId: tc.id
-      }));
-    }
-  } else {
-    // Text-only response: emit messageStopEvent
-    frames.push(buildEventStreamFrame("messageStopEvent", {}));
-  }
-  state.finishSent = true;
-
-  // Emit usage if available
-  if (state.usage) {
-    frames.push(buildEventStreamFrame("usageEvent", {
-      inputTokens: state.usage.prompt_tokens || 0,
-      outputTokens: state.usage.completion_tokens || 0
-    }));
-  }
-
-  state.toolCallInit = {};
-  return frames.length > 0 ? frames : null;
-}
-
-// ─── MITM intercept entry point ───────────────────────────────────────────────
-/**
- * Intercept Kiro IDE CodeWhisperer request and convert to EventStream response:
- *   1. Parse CodeWhisperer JSON body (reject binary EventStream formats)
- *   2. Convert CodeWhisperer format to OpenAI messages[] format
- *   3. Forward to zevairouter /v1/chat/completions (OpenAI SSE)
- *   4. Convert OpenAI SSE response → AWS EventStream binary frames
- *   5. Stream EventStream frames back to Kiro IDE
- * 
- * @param {http.IncomingMessage} req - HTTP request from Kiro IDE
- * @param {http.ServerResponse} res - HTTP response to Kiro IDE  
- * @param {Buffer} bodyBuffer - Request body buffer
- * @param {string} mappedModel - Model name after MITM alias mapping
- */
-async function intercept(req, res, bodyBuffer, mappedModel) {
-  try {
-    // Detect and handle binary data (e.g., continuation requests with EventStream frames)
-    if (isBinaryEventStream(bodyBuffer)) {
-      // Binary EventStream requests are typically continuation/streaming frames
-      // that don't contain model info - pass them through directly to avoid JSON.parse crash
-      throw new Error(`Binary EventStream format detected (${bodyBuffer.length}B) - request should use passthrough instead of intercept`);
-    }
-    
-    const body = JSON.parse(bodyBuffer.toString());
-
-    // 1 + 2: CodeWhisperer → OpenAI messages + tools
-    const messages = codeWhispererToMessages(body);
-    if (messages.length === 0) {
-      throw new Error("codeWhispererToMessages produced 0 messages — check request body");
-    }
-
-    const tools = extractTools(body);
-
-    const openaiBody = {
-      model: mappedModel,
-      messages,
-      stream: true,
-      // Forward tools so Claude uses structured tool_calls instead of XML text fallback
-      ...(tools.length > 0 && { tools, tool_choice: "auto" }),
-    };
-
-    // 3: Forward to zevairouter
-    const routerRes = await fetchRouter(openaiBody, "/v1/chat/completions", req.headers);
-
-    // 4 + 5: Re-encode response as AWS EventStream binary using standard pipeline
-    const state = initKiroState(mappedModel);
-
-    await pipeTransformedEventStream(routerRes, res, convertOpenAIToKiro, state);
-  } catch (error) {
-    err(`[Kiro MITM] Request processing failed: ${error.message}`);
-    if (!res.headersSent) {
-      res.writeHead(500, { "Content-Type": "application/json" });
-    }
-    res.end(JSON.stringify({ 
-      error: { 
-        message: error.message, 
-        type: "mitm_error",
-        handler: "kiro"
-      } 
-    }));
-  }
-}
-
-// Detect AWS EventStream binary format
-function isBinaryEventStream(buffer) {
-  if (!buffer || buffer.length < 12) return false;
-  // AWS EventStream signature: 
-  // - First 4 bytes: total frame length (big-endian)
-  // - Bytes 4-8: headers length (big-endian)
-  // - Typical frame length: 100-10000 bytes
-  const totalLen = buffer.readUInt32BE(0);
-  const headersLen = buffer.readUInt32BE(4);
-  // Sanity checks: frame length should be reasonable and headers should fit
-  return totalLen > 12 && totalLen < 1000000 && headersLen < totalLen - 12;
-}
-
-module.exports = { intercept };

package/src/mitm/logger.js

@@ -1,106 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const zlib = require("zlib");
-const { DATA_DIR } = require("./paths");
-const { LOG_BLACKLIST_URL_PARTS } = require("./config");
-
-function time() {
-  return new Date().toLocaleTimeString("en-US", { hour12: false });
-}
-
-const log = (msg) => console.log(`[${time()}] [MITM] ${msg}`);
-const err = (msg) => console.error(`[${time()}] ❌ [MITM] ${msg}`);
-
-const DUMP_DIR = path.join(DATA_DIR, "logs", "mitm");
-if (!fs.existsSync(DUMP_DIR)) fs.mkdirSync(DUMP_DIR, { recursive: true });
-
-// Clear all files inside DUMP_DIR (called on MITM server start to avoid unbounded growth)
-function clearDumpDir() {
-  try {
-    if (!fs.existsSync(DUMP_DIR)) return;
-    for (const f of fs.readdirSync(DUMP_DIR)) {
-      try { fs.rmSync(path.join(DUMP_DIR, f), { recursive: true, force: true }); } catch { /* ignore */ }
-    }
-  } catch { /* ignore */ }
-}
-
-const EMPTY_BODY_RE = /^\s*(\{\s*\}|\[\s*\]|null)?\s*$/;
-
-function slugify(s, max = 80) {
-  return String(s).replace(/[^a-zA-Z0-9]/g, "_").substring(0, max);
-}
-
-function isBlacklisted(url) {
-  if (!url) return false;
-  return LOG_BLACKLIST_URL_PARTS.some(part => url.includes(part));
-}
-
-// Decode body buffer based on content-encoding header
-function decodeBody(buf, encoding) {
-  if (!buf || buf.length === 0) return buf;
-  try {
-    const enc = (encoding || "").toLowerCase();
-    if (enc.includes("gzip")) return zlib.gunzipSync(buf);
-    if (enc.includes("br")) return zlib.brotliDecompressSync(buf);
-    if (enc.includes("deflate")) return zlib.inflateSync(buf);
-  } catch { /* return raw on failure */ }
-  return buf;
-}
-
-// Save raw request: method + url + headers + body
-function dumpRequest(req, bodyBuffer, tag = "raw") {
-  if (isBlacklisted(req.url)) return null;
-  try {
-    const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const slug = slugify((req.headers.host || "") + req.url);
-    const file = path.join(DUMP_DIR, `${ts}_${tag}_${slug}.req.json`);
-    let parsed = null;
-    try { parsed = JSON.parse(bodyBuffer.toString()); } catch { /* not JSON */ }
-    fs.writeFileSync(file, JSON.stringify({
-      method: req.method,
-      url: req.url,
-      host: req.headers.host,
-      headers: req.headers,
-      body: parsed ?? bodyBuffer.toString("utf8")
-    }, null, 2));
-    return file;
-  } catch { return null; }
-}
-
-// Buffer-based response dumper — collects chunks then decodes + writes once on end()
-// Trade-off: holds response in RAM, but enables gzip/br decoding for readable output.
-function createResponseDumper(req, tag = "raw") {
-  if (isBlacklisted(req.url)) return null;
-  const ts = new Date().toISOString().replace(/[:.]/g, "-");
-  const slug = slugify((req.headers.host || "") + req.url);
-  const file = path.join(DUMP_DIR, `${ts}_${tag}_${slug}.res.txt`);
-  let status = 0;
-  let headers = {};
-  const chunks = [];
-  return {
-    writeHeader: (s, h) => { status = s; headers = h || {}; },
-    writeChunk: (chunk) => {
-      if (chunk == null) return;
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    },
-    end: () => {
-      try {
-        const raw = Buffer.concat(chunks);
-        const enc = headers["content-encoding"] || headers["Content-Encoding"];
-        const decoded = decodeBody(raw, enc);
-        const text = decoded.toString("utf8");
-        // Skip empty / trivially-empty bodies
-        if (EMPTY_BODY_RE.test(text)) return;
-        // Strip content-encoding since body is now decoded
-        const cleanHeaders = { ...headers };
-        delete cleanHeaders["content-encoding"];
-        delete cleanHeaders["Content-Encoding"];
-        const out = `STATUS: ${status}\nHEADERS: ${JSON.stringify(cleanHeaders, null, 2)}\n---BODY---\n${text}`;
-        fs.writeFileSync(file, out);
-      } catch { /* ignore */ }
-    },
-    file
-  };
-}
-
-module.exports = { log, err, dumpRequest, createResponseDumper, clearDumpDir };