@yina-npm/openrouterx 0.4.56 → 0.4.71

package/app/src/mitm/handlers/base.js

@@ -1,39 +1,28 @@
 const { log, err } = require("../logger");
 
-const DEFAULT_LOCAL_ROUTER = "http://localhost:20502";
+const DEFAULT_LOCAL_ROUTER = "http://localhost:20128";
 const ROUTER_BASE = String(process.env.MITM_ROUTER_BASE || DEFAULT_LOCAL_ROUTER)
   .trim()
-  .replace(/^(['"])(.*)\1$/, "$2")
   .replace(/\/+$/, "") || DEFAULT_LOCAL_ROUTER;
-const API_KEY = String(process.env.ROUTER_API_KEY || "")
-  .trim()
-  .replace(/^(['"])(.*)\1$/, "$2");
+const API_KEY = process.env.ROUTER_API_KEY;
 
-// Headers that must not be forwarded to OpenrouterX
+// Headers that must not be forwarded to 9Router
 const STRIP_HEADERS = new Set([
   "host", "content-length", "connection", "transfer-encoding",
   "content-type", "authorization"
 ]);
 
-function normalizeRouterPath(path) {
-  const rawPath = String(path || "").trim() || "/v1/chat/completions";
-  if (rawPath === "/v1") return "/api/v1";
-  if (rawPath.startsWith("/v1/")) return `/api${rawPath}`;
-  return rawPath;
-}
-
 /**
- * Send body to OpenrouterX at the given path and return the fetch Response object.
+ * Send body to 9Router at the given path and return the fetch Response object.
  * Optionally forwards client headers (stripped of hop-by-hop / overridden keys).
  */
 async function fetchRouter(openaiBody, path = "/v1/chat/completions", clientHeaders = {}) {
-  const routerPath = normalizeRouterPath(path);
   const forwarded = {};
   for (const [k, v] of Object.entries(clientHeaders)) {
     if (!STRIP_HEADERS.has(k.toLowerCase())) forwarded[k] = v;
   }
 
-  const response = await fetch(`${ROUTER_BASE}${routerPath}`, {
+  const response = await fetch(`${ROUTER_BASE}${path}`, {
     method: "POST",
     headers: {
       ...forwarded,
@@ -76,4 +65,162 @@ async function pipeSSE(routerRes, res, dumper) {
   }
 }
 
-module.exports = { fetchRouter, normalizeRouterPath, pipeSSE };
+/**
+ * Pipe SSE stream from router, transforming each chunk through a user function.
+ * Reads SSE data: lines, parses JSON, calls transformFn(parsed, state),
+ * and writes returned SSE strings to the client response.
+ *
+ * @param {Response} routerRes - Fetch Response from 9Router
+ * @param {http.ServerResponse} res - Client response
+ * @param {Function} transformFn - (parsedChunk, state) => string|string[]|null
+ * @param {object} state - Mutable state object shared across chunks and flush
+ */
+async function pipeTransformedSSE(routerRes, res, transformFn, state) {
+  const ct = routerRes.headers.get("content-type") || "application/json";
+  const resHeaders = { "Content-Type": ct, "Cache-Control": "no-cache", "Connection": "keep-alive" };
+  if (ct.includes("text/event-stream")) resHeaders["X-Accel-Buffering"] = "no";
+  res.writeHead(200, resHeaders);
+
+  if (!routerRes.body) {
+    res.end(await routerRes.text().catch(() => ""));
+    return;
+  }
+
+  const reader = routerRes.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith("data:")) continue;
+
+      const data = trimmed.slice(5).trim();
+      if (data === "[DONE]") continue;
+
+      if (process.env.DEBUG_MITM) {
+        log(`[SSE in] ${data.slice(0, 200)}`);
+      }
+
+      try {
+        const parsed = JSON.parse(data);
+        const result = transformFn(parsed, state);
+        if (result != null) {
+          const outputs = Array.isArray(result) ? result : [result];
+          for (const output of outputs) {
+            if (process.env.DEBUG_MITM) {
+              const len = output.length || output.byteLength || 0;
+              log(`[write binary frame] (${len}B) first 20B: ${Array.from(output.slice(0, 20)).join(',')}`);
+            }
+            res.write(Buffer.from(output));
+          }
+        }
+      } catch {
+        // Skip unparseable lines
+      }
+    }
+  }
+
+  // Flush: pass null to signal stream end
+  try {
+    const flushed = transformFn(null, state);
+    if (flushed != null) {
+      const outputs = Array.isArray(flushed) ? flushed : [flushed];
+      for (const output of outputs) {
+        res.write(output);
+      }
+    }
+  } catch { /* ignore flush errors */ }
+
+  res.end();
+}
+
+/**
+ * Pipe SSE stream from router, transforming each chunk through a user function,
+ * and writing binary EventStream frames to the client.
+ *
+ * Reads SSE data: lines, parses JSON, calls transformFn(parsed, state),
+ * and writes returned Uint8Array frames to the client response.
+ *
+ * @param {Response} routerRes - Fetch Response from 9Router
+ * @param {http.ServerResponse} res - Client response
+ * @param {Function} transformFn - (parsedChunk, state) => Uint8Array|Uint8Array[]|null
+ * @param {object} state - Mutable state object shared across chunks and flush
+ */
+async function pipeTransformedEventStream(routerRes, res, transformFn, state) {
+  const resHeaders = {
+    "Content-Type": "application/vnd.amazon.eventstream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive"
+  };
+  res.writeHead(200, resHeaders);
+
+  if (!routerRes.body) {
+    res.end(await routerRes.text().catch(() => ""));
+    return;
+  }
+
+  const reader = routerRes.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || !trimmed.startsWith("data:")) continue;
+
+      const data = trimmed.slice(5).trim();
+      if (data === "[DONE]") continue;
+
+      if (process.env.DEBUG_MITM) {
+        log(`[SSE in] ${data.slice(0, 200)}`);
+      }
+
+      try {
+        const parsed = JSON.parse(data);
+        const result = transformFn(parsed, state);
+        if (result != null) {
+          const outputs = Array.isArray(result) ? result : [result];
+          for (const output of outputs) {
+            if (process.env.DEBUG_MITM) {
+              const len = output.length || output.byteLength || 0;
+              log(`[write binary frame] (${len}B) first 20B: ${Array.from(output.slice(0, 20)).join(',')}`);
+            }
+            res.write(Buffer.from(output));
+          }
+        }
+      } catch {
+        // Skip unparseable lines
+      }
+    }
+  }
+
+  // Flush: pass null to signal stream end
+  try {
+    const flushed = transformFn(null, state);
+    if (flushed != null) {
+      const outputs = Array.isArray(flushed) ? flushed : [flushed];
+      for (const output of outputs) {
+        res.write(output);
+      }
+    }
+  } catch { /* ignore flush errors */ }
+
+  res.end();
+}
+
+module.exports = { fetchRouter, pipeSSE, pipeTransformedSSE, pipeTransformedEventStream };

package/app/src/mitm/handlers/copilot.js

@@ -1,7 +1,7 @@
 const { err } = require("../logger");
 const { fetchRouter, pipeSSE } = require("./base");
 
-// Map Copilot endpoint -> OpenrouterX path
+// Map Copilot endpoint → 9Router path
 const URL_MAP = {
   "/chat/completions": "/v1/chat/completions",
   "/v1/messages":      "/v1/messages",
@@ -16,7 +16,7 @@ function resolveRouterPath(reqUrl) {
 }
 
 /**
- * Intercept Copilot request — replace model and forward to matching OpenrouterX endpoint
+ * Intercept Copilot request — replace model and forward to matching 9Router endpoint
  */
 async function intercept(req, res, bodyBuffer, mappedModel) {
   try {

package/app/src/mitm/handlers/kiro.js

@@ -1,6 +1,6 @@
 const { err } = require("../logger");
 const { IS_DEV } = require("../config");
-const { fetchRouter } = require("./base");
+const { fetchRouter, pipeTransformedEventStream } = require("./base");
 const fs = require("fs");
 const path = require("path");
 
@@ -32,6 +32,76 @@ function crc32(buf) {
   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 };
+
+  return {
+    thinking: thinking || null,
+    text: recurse.text || null
+  };
+}
+
 // ─── AWS EventStream frame builder ────────────────────────────────────────────
 /**
  * Encode a single string header into the AWS EventStream binary format.
@@ -233,132 +303,173 @@ function extractTools(body) {
 }
 
 // ─── OpenAI SSE → EventStream binary conversion ───────────────────────────────
+
 /**
- * Read 9router's OpenAI SSE response and re-encode it as AWS EventStream binary
- * frames that Kiro's Smithy SDK expects.
+ * Convert an OpenAI SSE chunk to AWS EventStream binary frame(s)
+ * This replaces pipeOpenAIasEventStream and works with pipeTransformedEventStream
  *
- * OpenAI SSE format:  data: { choices:[{ delta:{ content:"..." } }] }\n\n
- * EventStream events emitted:
- *   assistantResponseEvent  { content: "..." }   — one per SSE chunk with text
- *   toolUseEvent            { toolUseId, name, input }   — for tool calls
- *   messageStopEvent        {}                   — on finish
+ * @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
  */
-async function pipeOpenAIasEventStream(routerRes, res) {
-  if (!routerRes.body) {
-    res.end(buildEventStreamFrame("messageStopEvent", {}));
-    return;
+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 reader = routerRes.body.getReader();
-  const decoder = new TextDecoder();
-  let sseBuffer = "";
-  let stopSent = false;
+  const frames = [];
+  const choice = chunk.choices?.[0];
+  const delta = choice?.delta || {};
 
-  // Accumulated tool-call state keyed by index
-  const toolCallAccum = {};
+  // 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";
 
-  const sendStop = () => {
-    if (!stopSent) {
-      stopSent = true;
-      res.write(buildEventStreamFrame("messageStopEvent", {}));
-    }
-  };
+  // Handle usage (may arrive standalone or with other chunks)
+  if (chunk.usage) {
+    state.usage = chunk.usage;
+  }
 
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      sseBuffer += decoder.decode(value, { stream: true });
-
-      // Split on newlines; keep the last (possibly incomplete) line in the buffer
-      const lines = sseBuffer.split("\n");
-      sseBuffer = lines.pop() ?? "";
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data:")) continue;
-
-        const raw = trimmed.slice(5).trim();
-        if (raw === "[DONE]") {
-          sendStop();
-          continue;
-        }
-
-        let chunk;
-        try { chunk = JSON.parse(raw); } catch { continue; }
-
-        const delta = chunk?.choices?.[0]?.delta;
-        if (!delta) continue;
-
-        // ── Text content ───────────────────────────────────────────────────────
-        if (delta.content) {
-          res.write(buildEventStreamFrame("assistantResponseEvent", { content: delta.content }));
-        }
-
-        // ── Tool calls (streamed in pieces by OpenAI SSE) ──────────────────────
-        if (delta.tool_calls) {
-          dbg(`TOOL_CALLS delta: ${JSON.stringify(delta.tool_calls).slice(0, 300)}`);
-          for (const tc of delta.tool_calls) {
-            const idx = tc.index ?? 0;
-            if (!toolCallAccum[idx]) {
-              toolCallAccum[idx] = { id: tc.id ?? "", name: "", args: "" };
-            }
-            const acc = toolCallAccum[idx];
-            if (tc.id) acc.id = tc.id;
-            if (tc.function?.name) acc.name += tc.function.name;
-            // safeArgsString prevents `"" + object` → "[object Object]" corruption
-            // when 9router's Anthropic→OpenAI conversion passes a pre-parsed object
-            const argType = typeof tc.function?.arguments;
-            if (tc.function?.arguments != null) {
-              acc.args += safeArgsString(tc.function.arguments);
-            }
-            dbg(`  tc[${idx}] argType=${argType} id=${acc.id} name=${acc.name} args_so_far=${acc.args.slice(0, 100)}`);
-          }
-        }
-
-        // ── Finish ─────────────────────────────────────────────────────────────
-        const finish = chunk?.choices?.[0]?.finish_reason;
-        if (finish) {
-          dbg(`FINISH finish_reason=${finish} toolCallKeys=${JSON.stringify(Object.keys(toolCallAccum))}`);
-          // Flush accumulated tool calls before stop
-          if (finish === "tool_calls") {
-            for (const acc of Object.values(toolCallAccum)) {
-              // IMPORTANT: Kiro's internal tool dispatcher expects `input` to be a JSON string
-              // (not a parsed object). The real CodeWhisperer server sends:
-              //   { toolUseId, name, input: "{\"key\":\"value\"}" }  ← input is a string
-              // Kiro then JSON.parses that string to get the tool arguments.
-              // If we send input as a parsed object, Kiro does String(obj) → "[object Object]".
-              const inputStr = acc.args || "{}";
-              dbg(`  toolUseEvent: id=${acc.id} name=${acc.name} inputStr=${inputStr.slice(0, 200)}`);
-              res.write(buildEventStreamFrame("toolUseEvent", {
-                toolUseId: acc.id,
-                name: acc.name,
-                input: inputStr,  // Must be a JSON STRING, not a parsed object
-              }));
-            }
-          }
-          sendStop();
-        }
+  // 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 || ""
+        }));
       }
     }
-  } finally {
-    sendStop();
-    res.end();
   }
+
+  // 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:
- *   1. Parse CodeWhisperer binary/JSON body
- *   2. Convert to OpenAI messages[] format
+ * 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 9router /v1/chat/completions (OpenAI SSE)
  *   4. Convert OpenAI SSE response → AWS EventStream binary frames
- *   5. Stream binary frames back to Kiro
+ *   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
@@ -380,22 +491,36 @@ async function intercept(req, res, bodyBuffer, mappedModel) {
     // 3: Forward to 9router
     const routerRes = await fetchRouter(openaiBody, "/v1/chat/completions", req.headers);
 
-    // 4 + 5: Re-encode response as AWS EventStream binary
-    res.writeHead(routerRes.status, {
-      "Content-Type": "application/vnd.amazon.eventstream",
-      "x-amzn-requestid": `mitm-${Date.now()}`,
-      "x-amz-id-2": "mitm",
-      "Transfer-Encoding": "chunked",
-    });
+    // 4 + 5: Re-encode response as AWS EventStream binary using standard pipeline
+    const state = initKiroState(mappedModel);
 
-    await pipeOpenAIasEventStream(routerRes, res);
+    await pipeTransformedEventStream(routerRes, res, convertOpenAIToKiro, state);
   } catch (error) {
-    err(`[Kiro] ${error.message}`);
+    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" } }));
+    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/app/src/mitm/logger.js

@@ -11,21 +11,8 @@ function time() {
 const log = (msg) => console.log(`[${time()}] [MITM] ${msg}`);
 const err = (msg) => console.error(`[${time()}] ❌ [MITM] ${msg}`);
 
-function ensureDumpDir() {
-  const candidates = [
-    path.join(DATA_DIR, "logs", "mitm"),
-    path.join(require("os").tmpdir(), "openrouterx", "logs", "mitm"),
-  ];
-  for (const dir of candidates) {
-    try {
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      return dir;
-    } catch { /* try next writable location */ }
-  }
-  return candidates[1];
-}
-
-const DUMP_DIR = ensureDumpDir();
+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() {